@mui/internal-benchmark 0.0.3-canary.9 → 0.1.1-canary.1

package/ElementTiming.d.mts

@@ -1,5 +1,6 @@
+import * as React from 'react';
 export declare function ElementTiming({
   name
 }: {
   name: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;

package/Metric.mjs

@@ -33,6 +33,8 @@ function flush(test, accumulator) {
  * tests and loop iterations, inside or outside React.
  */
 export class Metric {
+  name;
+  config;
   constructor(config) {
     this.config = typeof config === 'string' ? {
       name: config

package/ciApi.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Posts `body` to the dashboard, authenticated as this CI job, and returns the response text. `what`
+ * names the request in the errors it raises.
+ */
+export declare function postToDashboard(pathname: string, body: unknown, what: string): Promise<string>;

package/ciApi.mjs

@@ -0,0 +1,34 @@
+/* eslint-disable no-console -- progress belongs in the CI log. */
+
+// The dashboard's CI-report API: a bearer-token POST of one JSON body, with the OIDC token
+// CircleCI mints for the job.
+
+const DEFAULT_API_URL = 'https://frontend-public.mui.com';
+
+/**
+ * Posts `body` to the dashboard, authenticated as this CI job, and returns the response text. `what`
+ * names the request in the errors it raises.
+ */
+export async function postToDashboard(pathname, body, what) {
+  const oidcToken = process.env.CIRCLE_OIDC_TOKEN_V2;
+  if (!oidcToken) {
+    throw new Error(`CIRCLE_OIDC_TOKEN_V2 environment variable is required for ${what}`);
+  }
+
+  // The override exists so a pull request can point at its own dashboard preview deployment.
+  const url = new URL(pathname, process.env.CI_REPORT_API_URL || DEFAULT_API_URL);
+  console.log(`${what} → ${url.href}`);
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${oidcToken}`
+    },
+    body: JSON.stringify(body)
+  });
+  const responseText = await response.text();
+  if (!response.ok) {
+    throw new Error(`${what} failed (${response.status}): ${responseText}`);
+  }
+  return responseText;
+}

package/ciReport.d.mts

@@ -1,4 +1,18 @@
 import { z } from 'zod/v4';
+/**
+ * Creates a CI report upload schema for a specific report type.
+ * Common fields (commitSha, repo, branch, prNumber) are shared across all report types.
+ */
+export declare function ciReportUploadSchema<ReportSchema extends z.ZodType>(type: string, version: number, reportSchema: ReportSchema): z.ZodObject<{
+  version: z.ZodLiteral<number>;
+  timestamp: z.ZodNumber;
+  commitSha: z.ZodString;
+  repo: z.ZodString;
+  reportType: z.ZodLiteral<string>;
+  prNumber: z.ZodOptional<z.ZodNumber>;
+  branch: z.ZodString;
+  report: ReportSchema;
+}, z.core.$strip>;
 declare const renderStatsSchema: z.ZodObject<{
   id: z.ZodString;
   phase: z.ZodEnum<{
@@ -81,7 +95,27 @@ declare const benchmarkBaseUploadSchema: z.ZodObject<{
   reportType: z.ZodLiteral<string>;
   prNumber: z.ZodOptional<z.ZodNumber>;
   branch: z.ZodString;
-  report: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+  report: z.ZodRecord<z.ZodString, z.ZodObject<{
+    iterations: z.ZodNumber;
+    totalDuration: z.ZodNumber;
+    renders: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      phase: z.ZodEnum<{
+        mount: "mount";
+        "nested-update": "nested-update";
+        update: "update";
+      }>;
+      startTime: z.ZodNumber;
+      actualDuration: z.ZodNumber;
+      stdDev: z.ZodNumber;
+      outliers: z.ZodNumber;
+    }, z.core.$strip>>;
+    metrics: z.ZodRecord<z.ZodString, z.ZodObject<{
+      mean: z.ZodNumber;
+      stdDev: z.ZodNumber;
+      outliers: z.ZodNumber;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
   metricDefinitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
     kind: z.ZodEnum<{
       discrete: "discrete";
@@ -106,7 +140,27 @@ export declare const benchmarkUploadSchema: z.ZodObject<{
   reportType: z.ZodLiteral<string>;
   prNumber: z.ZodOptional<z.ZodNumber>;
   branch: z.ZodString;
-  report: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+  report: z.ZodRecord<z.ZodString, z.ZodObject<{
+    iterations: z.ZodNumber;
+    totalDuration: z.ZodNumber;
+    renders: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      phase: z.ZodEnum<{
+        mount: "mount";
+        "nested-update": "nested-update";
+        update: "update";
+      }>;
+      startTime: z.ZodNumber;
+      actualDuration: z.ZodNumber;
+      stdDev: z.ZodNumber;
+      outliers: z.ZodNumber;
+    }, z.core.$strip>>;
+    metrics: z.ZodRecord<z.ZodString, z.ZodObject<{
+      mean: z.ZodNumber;
+      stdDev: z.ZodNumber;
+      outliers: z.ZodNumber;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
   metricDefinitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
     kind: z.ZodEnum<{
       discrete: "discrete";
@@ -130,7 +184,27 @@ export declare const benchmarkUploadSchema: z.ZodObject<{
     reportType: z.ZodLiteral<string>;
     prNumber: z.ZodOptional<z.ZodNumber>;
     branch: z.ZodString;
-    report: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    report: z.ZodRecord<z.ZodString, z.ZodObject<{
+      iterations: z.ZodNumber;
+      totalDuration: z.ZodNumber;
+      renders: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        phase: z.ZodEnum<{
+          mount: "mount";
+          "nested-update": "nested-update";
+          update: "update";
+        }>;
+        startTime: z.ZodNumber;
+        actualDuration: z.ZodNumber;
+        stdDev: z.ZodNumber;
+        outliers: z.ZodNumber;
+      }, z.core.$strip>>;
+      metrics: z.ZodRecord<z.ZodString, z.ZodObject<{
+        mean: z.ZodNumber;
+        stdDev: z.ZodNumber;
+        outliers: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
     metricDefinitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
       kind: z.ZodEnum<{
         discrete: "discrete";

package/ciReport.mjs

@@ -13,7 +13,7 @@ async function getGitInfo() {
  * Creates a CI report upload schema for a specific report type.
  * Common fields (commitSha, repo, branch, prNumber) are shared across all report types.
  */
-function ciReportUploadSchema(type, version, reportSchema) {
+export function ciReportUploadSchema(type, version, reportSchema) {
   return z.object({
     version: z.literal(version),
     timestamp: z.number(),

package/index.mjs

@@ -1,5 +1,5 @@
 /**
- * @mui/internal-benchmark v0.0.2
+ * @mui/internal-benchmark v0.1.0
  *
  * @license undefined
  * This source code is licensed under the undefined license found in the
@@ -206,17 +206,15 @@ export function benchmark(name, renderFn, interactionOrOptions, maybeOptions) {
 
     // Paint timings are recorded as one harness-owned `bench:paint` metric: the default sentinel
     // is the base series (`bench:paint`) and named `elementtiming` markers are sub-series
-    // (`bench:paint#grid-header`, …), all sharing a single definition. A default alarm keeps a
-    // >20% paint regression flagged, matching the previous behavior.
+    // (`bench:paint#grid-header`, …), all sharing a single definition. Paint is informational (no
+    // alarm): it dominates each test's total duration, so a per-test paint alarm just duplicates the
+    // Duration regression signal and floods the report on any broadly-regressed run.
     const paint = new ScalarMetric({
       name: 'bench:paint',
       format: {
         style: 'unit',
         unit: 'millisecond',
         maximumFractionDigits: 2
-      },
-      alarm: {
-        error: 0.2
       }
     });
     if (typeof window.gc !== 'function') {
@@ -286,13 +284,13 @@ export function benchmark(name, renderFn, interactionOrOptions, maybeOptions) {
       if (!isWarmup) {
         for (const entry of timing.elementEntries) {
           // Skip paints that happened while recording was paused. Attribute by the paint's
-          // `renderTime`, not by when the observer callback fired (which can lag the paint).
-          if (!recording.activeAt(entry.renderTime)) {
+          // `paintTime`, not by when the observer callback fired (which can lag the paint).
+          if (!recording.activeAt(entry.paintTime)) {
             continue;
           }
           // The default sentinel is the base series; named markers become sub-series.
           const id = entry.identifier === 'default' ? undefined : entry.identifier;
-          paint.record(entry.renderTime - iterationStart, id !== undefined ? {
+          paint.record(entry.paintTime - iterationStart, id !== undefined ? {
             id
           } : undefined);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-benchmark",
-  "version": "0.0.3-canary.9",
+  "version": "0.1.1-canary.1",
   "author": "MUI Team",
   "description": "Benchmark utilities for MUI projects. Internal package.",
   "repository": {
@@ -9,11 +9,13 @@
     "directory": "packages/benchmark"
   },
   "dependencies": {
-    "@babel/runtime": "^7.29.2",
-    "@vitejs/plugin-react": "^6.0.2",
+    "@babel/runtime": "^8.0.5",
+    "@vitejs/plugin-react": "^6.1.1",
+    "chalk": "^5.6.2",
     "env-ci": "^11.2.0",
-    "execa": "^9.6.1",
-    "zod": "^4.4.3"
+    "es-toolkit": "^1.52.0",
+    "execa": "^10.0.1",
+    "zod": "^4.6.5"
   },
   "peerDependencies": {
     "@vitest/browser-playwright": ">=4.1",
@@ -68,5 +70,5 @@
       }
     }
   },
-  "gitSha": "cb672accc6b61d455e18ce874f99ea841831a734"
+  "gitSha": "c2a0ca83b8dd00ae2fa2b5714dbc6684d50926d9"
 }

package/reactRecording.d.mts

@@ -5,7 +5,7 @@ export interface ReactRecordingControls {
   readonly hadEmptyActiveWindow: boolean;
   /**
    * Whether recording was active at `time` (a `performance.now()` timestamp). Paint entries are
-   * observed asynchronously, so they are attributed by their `renderTime` rather than by the
+   * observed asynchronously, so they are attributed by their `paintTime` rather than by the
    * recording state at the moment the observer callback happens to fire.
    */
   activeAt(time: number): boolean;

package/reporter.mjs

@@ -240,6 +240,9 @@ async function loadBaselineReport(baselinePath) {
 class BenchmarkReporter {
   benchmarks = {};
   metricDefinitions = {};
+  outputPath;
+  upload;
+  baselinePath;
   hasFailures = false;
   constructor(options) {
     this.outputPath = options?.outputPath ?? process.env.BENCHMARK_OUTPUT_PATH ?? path.resolve(process.cwd(), 'benchmarks', 'results.json');

package/syncPrComment.d.mts

@@ -2,8 +2,6 @@ interface SyncPrCommentResult {
   success: boolean;
   skipped?: boolean;
 }
-/**
- * Syncs a PR comment via the dashboard API.
- */
+/** Asks the dashboard to regenerate the pull request comment for `repo`. */
 export declare function syncPrComment(repo: string): Promise<SyncPrCommentResult>;
 export {};

package/syncPrComment.mjs

@@ -1,27 +1,8 @@
-const DEFAULT_API_URL = 'https://frontend-public.mui.com';
-/**
- * Syncs a PR comment via the dashboard API.
- */
+import { postToDashboard } from "./ciApi.mjs";
+/** Asks the dashboard to regenerate the pull request comment for `repo`. */
 export async function syncPrComment(repo) {
-  const oidcToken = process.env.CIRCLE_OIDC_TOKEN_V2;
-  if (!oidcToken) {
-    throw new Error('CIRCLE_OIDC_TOKEN_V2 environment variable is required for PR comment sync');
-  }
-  const apiUrl = process.env.CI_REPORT_API_URL || DEFAULT_API_URL;
-  const url = new URL('/api/ci-reports/sync-pr-comment', apiUrl);
-  const response = await fetch(url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${oidcToken}`
-    },
-    body: JSON.stringify({
-      repo
-    })
-  });
-  if (!response.ok) {
-    const responseText = await response.text();
-    throw new Error(`Sync PR comment API returned ${response.status} ${response.statusText}: ${responseText}`);
-  }
-  return response.json();
+  const responseText = await postToDashboard('/api/ci-reports/sync-pr-comment', {
+    repo
+  }, 'The pull request comment sync');
+  return JSON.parse(responseText);
 }

package/upload.d.mts

@@ -1,5 +1,9 @@
 import type { BenchmarkUpload } from "./ciReport.mjs";
-declare function uploadCiReport(report: BenchmarkUpload, options?: {
-  apiUrl?: string;
-}): Promise<void>;
+/**
+ * Uploads a benchmark report to the CI report store.
+ *
+ * Validated before sending: the server stores `report` without inspecting it, so a malformed one
+ * would be accepted here and only fail later, when the dashboard tried to render it.
+ */
+declare function uploadCiReport(report: BenchmarkUpload): Promise<void>;
 export { uploadCiReport };

package/upload.mjs

@@ -1,34 +1,17 @@
+/* eslint-disable no-console -- progress belongs in the CI log. */
+
+import { postToDashboard } from "./ciApi.mjs";
 import { benchmarkUploadSchema } from "./ciReport.mjs";
-async function uploadCiReport(report, options) {
+/**
+ * Uploads a benchmark report to the CI report store.
+ *
+ * Validated before sending: the server stores `report` without inspecting it, so a malformed one
+ * would be accepted here and only fail later, when the dashboard tried to render it.
+ */
+async function uploadCiReport(report) {
   benchmarkUploadSchema.parse(report);
-  const apiUrl = options?.apiUrl ?? process.env.CI_REPORT_API_URL ?? 'https://frontend-public.mui.com';
-  const url = new URL('/api/ci-reports/upload', apiUrl);
-  const oidcToken = process.env.CIRCLE_OIDC_TOKEN_V2;
-  if (!oidcToken) {
-    throw new Error('CIRCLE_OIDC_TOKEN_V2 environment variable is required for uploads');
-  }
-
-  // eslint-disable-next-line no-console
-  console.log('Upload request body:', JSON.stringify({
-    ...report,
-    report: '...'
-  }, null, 2));
-  // eslint-disable-next-line no-console
-  console.log(`Uploading benchmark to ${url.href}`);
-  const response = await fetch(url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${oidcToken}`
-    },
-    body: JSON.stringify(report)
-  });
-  const responseText = await response.text();
-  if (!response.ok) {
-    throw new Error(`Upload failed (${response.status}): ${responseText}`);
-  }
+  const responseText = await postToDashboard('/api/ci-reports/upload', report, 'The benchmark upload');
   const result = JSON.parse(responseText);
-  // eslint-disable-next-line no-console
   console.log(`Benchmark results uploaded successfully. S3 key: ${result.key}`);
 }
 export { uploadCiReport };

package/utils/git.d.mts

@@ -0,0 +1,2 @@
+/** Resolves a committish to the commit it names, peeling an annotated tag to its commit. */
+export declare function resolveCommit(repoRoot: string, ref: string): Promise<string>;

package/utils/git.mjs

@@ -0,0 +1,13 @@
+import { execa } from 'execa';
+
+/** Resolves a committish to the commit it names, peeling an annotated tag to its commit. */
+export async function resolveCommit(repoRoot, ref) {
+  const result = await execa('git', ['rev-parse', '--verify', `${ref}^{commit}`], {
+    cwd: repoRoot,
+    reject: false
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`Could not resolve git ref "${ref}": ${String(result.stderr).trim()}`);
+  }
+  return result.stdout.trim();
+}

package/utils/packWorkspace.d.mts

@@ -0,0 +1,46 @@
+export interface PackedPackage {
+  /** Package name from its package.json. */
+  name: string;
+  version: string;
+  /** Absolute path to the packed `.tgz`. */
+  tarball: string;
+}
+export interface PackRefOptions {
+  /** The repository the ref lives in; also where the worktree is added from. */
+  repoRoot: string;
+  /** A git ref (SHA, branch, or tag) to pack. */
+  ref: string;
+  /** Cache root. The packed folder lands at `<outRoot>/<sha>` and is reused on the next call. */
+  outRoot: string;
+  /**
+   * Command run in the checkout to install before building. Defaults to a frozen-lockfile
+   * `pnpm install`; pass `''` to skip installing.
+   */
+  installCmd?: string;
+  /**
+   * Command run in the checkout to build before packing. Defaults to `pnpm release:build`. Part of
+   * the cache key.
+   */
+  buildCmd?: string;
+}
+/**
+ * Packs every public workspace package at `ref` into `<outRoot>/<sha>`, returning the packed
+ * tarballs.
+ *
+ * The folder is cached by SHA: a later call for the same commit, built with the same `buildCmd`,
+ * reuses it and skips the checkout, install and build. It is assembled in a staging folder and
+ * renamed into place, so an interrupted run never leaves something that looks like a cache.
+ */
+export declare function packRef(options: PackRefOptions): Promise<PackedPackage[]>;
+/**
+ * Builds and packs the working tree into `outRoot`, naming each tarball by a hash of its bytes: an
+ * unchanged build keeps its path, so an install that depends on it has nothing to redo.
+ */
+export declare function packWorkingTree(options: {
+  /** The workspace to build and pack. */
+  repoRoot: string;
+  /** Directory to hold the hashed tarballs. Replaced on each call. */
+  outRoot: string;
+  /** Command that builds the publishable packages. Defaults to `pnpm release:build`. */
+  buildCmd?: string;
+}): Promise<PackedPackage[]>;

package/utils/packWorkspace.mjs

@@ -0,0 +1,217 @@
+/* eslint-disable no-console */
+
+// Packs a workspace's public packages with `pnpm pack`, so each tarball is exactly what
+// `pnpm publish` would upload — for installing a build the way a consumer installs a release.
+
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { access, mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { pipeline } from 'node:stream/promises';
+import chalk from 'chalk';
+import { mapAsync } from 'es-toolkit/array';
+import { execa, parseCommandString } from 'execa';
+import { resolveCommit } from "./git.mjs";
+import { listPublishablePackages } from "./pnpm.mjs";
+const MANIFEST = 'manifest.json';
+
+/** `@scope/pkg` → `scope+pkg.tgz`; `+` cannot appear in a package name, so no two collide. */
+function tarballName(pkgName) {
+  return `${pkgName.replace(/^@/, '').replace('/', '+')}.tgz`;
+}
+
+/** Removes a temporary checkout, and git's record of it. */
+async function removeCheckout(repoRoot, checkout) {
+  await rm(checkout, {
+    recursive: true,
+    force: true,
+    maxRetries: 5,
+    retryDelay: 200
+  });
+  await execa('git', ['worktree', 'prune'], {
+    cwd: repoRoot
+  });
+}
+
+/** Runs `buildCmd` in `cwd`, with the nx daemon off so nothing keeps writing after it returns. */
+async function build(cwd, buildCmd) {
+  const [file, ...args] = parseCommandString(buildCmd);
+  await execa(file, args, {
+    cwd,
+    env: {
+      NX_DAEMON: 'false'
+    },
+    stdio: 'inherit',
+    verbose: 'short'
+  });
+}
+
+/** Content hash of a file, short enough to live in a filename. */
+async function hashFile(file) {
+  const hash = createHash('sha256');
+  await pipeline(createReadStream(file), hash);
+  return hash.digest('hex').slice(0, 12);
+}
+
+/**
+ * `dir`'s packages if it holds a cache of the requested build — built with the same `buildCmd`,
+ * every tarball still present — or `null` otherwise.
+ */
+async function readFreshCache(dir, buildCmd) {
+  let manifest;
+  try {
+    manifest = JSON.parse(await readFile(path.join(dir, MANIFEST), 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return null;
+    }
+    throw error;
+  }
+  if (manifest.buildCmd !== buildCmd) {
+    return null;
+  }
+  const packages = manifest.packages.map(pkg => ({
+    ...pkg,
+    tarball: path.join(dir, pkg.tarball)
+  }));
+  const present = await Promise.allSettled(packages.map(pkg => access(pkg.tarball)));
+  return present.every(result => result.status === 'fulfilled') ? packages : null;
+}
+
+/**
+ * Packs the already-built public workspace packages of `workspaceDir` into `outDir`.
+ *
+ * A public package that depends on a private workspace package cannot be installed from these —
+ * the private one is never packed — which is a packaging bug in the ref, not something to hide here.
+ */
+async function packBuiltPackages(workspaceDir, outDir) {
+  await mkdir(outDir, {
+    recursive: true
+  });
+  const packages = await listPublishablePackages(workspaceDir);
+  if (packages.length === 0) {
+    throw new Error(`No public workspace packages found in ${workspaceDir}.`);
+  }
+  // Each `pnpm pack` is a node process of its own.
+  return mapAsync(packages, async ({
+    path: pkgDir,
+    name,
+    version
+  }) => {
+    const tarball = path.join(outDir, tarballName(name));
+    await execa('pnpm', ['pack', '--out', tarball], {
+      cwd: pkgDir,
+      verbose: 'short'
+    });
+    return {
+      name,
+      version,
+      tarball
+    };
+  }, {
+    concurrency: os.availableParallelism()
+  });
+}
+
+/**
+ * Packs every public workspace package at `ref` into `<outRoot>/<sha>`, returning the packed
+ * tarballs.
+ *
+ * The folder is cached by SHA: a later call for the same commit, built with the same `buildCmd`,
+ * reuses it and skips the checkout, install and build. It is assembled in a staging folder and
+ * renamed into place, so an interrupted run never leaves something that looks like a cache.
+ */
+export async function packRef(options) {
+  const {
+    repoRoot,
+    ref,
+    outRoot,
+    installCmd = 'pnpm install --frozen-lockfile --prefer-offline --config.engine-strict=false',
+    buildCmd = 'pnpm release:build'
+  } = options;
+  const sha = await resolveCommit(repoRoot, ref);
+  const dir = path.join(outRoot, sha);
+  const cached = await readFreshCache(dir, buildCmd);
+  if (cached) {
+    console.log(chalk.green(`\nReusing packed workspace for "${ref}" (${sha.slice(0, 9)}).`));
+    return cached;
+  }
+  await mkdir(outRoot, {
+    recursive: true
+  });
+  const staging = await mkdtemp(path.join(outRoot, '.staging-'));
+  const checkout = await mkdtemp(path.join(os.tmpdir(), 'pack-workspace-'));
+  try {
+    console.log(chalk.cyan(`\nChecking out "${ref}" (${sha.slice(0, 9)}) at ${checkout}`));
+    await execa('git', ['worktree', 'add', '--detach', checkout, sha], {
+      cwd: repoRoot,
+      verbose: 'short'
+    });
+    if (installCmd) {
+      console.log(chalk.cyan(`\nInstalling dependencies for ${sha.slice(0, 9)}…`));
+      const [installFile, ...installArgs] = parseCommandString(installCmd);
+      await execa(installFile, installArgs, {
+        cwd: checkout,
+        stdio: 'inherit',
+        verbose: 'short'
+      });
+    }
+    console.log(chalk.cyan(`\nBuilding packages for ${sha.slice(0, 9)}…`));
+    await build(checkout, buildCmd);
+    const packages = await packBuiltPackages(checkout, staging);
+    const manifest = {
+      buildCmd,
+      packages: packages.map(pkg => ({
+        ...pkg,
+        tarball: path.basename(pkg.tarball)
+      }))
+    };
+    // Written last: it is what marks the folder complete.
+    await writeFile(path.join(staging, MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`);
+    await rm(dir, {
+      recursive: true,
+      force: true
+    });
+    await rename(staging, dir);
+    return packages.map(pkg => ({
+      ...pkg,
+      tarball: path.join(dir, path.basename(pkg.tarball))
+    }));
+  } finally {
+    // On success the staging folder has already become `dir`.
+    await Promise.all([rm(staging, {
+      recursive: true,
+      force: true
+    }), removeCheckout(repoRoot, checkout)]);
+  }
+}
+
+/**
+ * Builds and packs the working tree into `outRoot`, naming each tarball by a hash of its bytes: an
+ * unchanged build keeps its path, so an install that depends on it has nothing to redo.
+ */
+export async function packWorkingTree(options) {
+  const {
+    repoRoot,
+    outRoot,
+    buildCmd = 'pnpm release:build'
+  } = options;
+  console.log(chalk.cyan(`\nBuilding workspace packages for "working tree" (${buildCmd})…`));
+  await build(repoRoot, buildCmd);
+  console.log(chalk.cyan('\nPacking the working tree…'));
+  await rm(outRoot, {
+    recursive: true,
+    force: true
+  });
+  const packed = await packBuiltPackages(repoRoot, outRoot);
+  return Promise.all(packed.map(async pkg => {
+    const hash = await hashFile(pkg.tarball);
+    const tarball = path.join(outRoot, `${path.basename(pkg.tarball, '.tgz')}-${hash}.tgz`);
+    await rename(pkg.tarball, tarball);
+    return {
+      ...pkg,
+      tarball
+    };
+  }));
+}

package/utils/pnpm.d.mts

@@ -0,0 +1,12 @@
+/** A publishable workspace package, as `pnpm ls` reports it. */
+export interface PublishablePackage {
+  name: string;
+  version: string;
+  /** Absolute path to the package directory. */
+  path: string;
+}
+/**
+ * The publishable workspace packages of `cwd`: those pnpm lists that are not private and have the
+ * name and version publishing requires.
+ */
+export declare function listPublishablePackages(cwd: string): Promise<PublishablePackage[]>;

package/utils/pnpm.mjs

@@ -0,0 +1,19 @@
+import { $ } from 'execa';
+
+/** A publishable workspace package, as `pnpm ls` reports it. */
+
+/**
+ * The publishable workspace packages of `cwd`: those pnpm lists that are not private and have the
+ * name and version publishing requires.
+ */
+export async function listPublishablePackages(cwd) {
+  const result = await $({
+    cwd
+  })`pnpm ls -r --json --depth -1`;
+  const listed = JSON.parse(result.stdout);
+  return listed.flatMap(pkg => pkg.private || !pkg.name || !pkg.version ? [] : [{
+    name: pkg.name,
+    version: pkg.version,
+    path: pkg.path
+  }]);
+}

package/utils/testUtils.d.mts

@@ -0,0 +1,2 @@
+/** Creates a temporary directory and removes it when the current test ends, even if it throws. */
+export declare function makeTempDir(): Promise<string>;

package/utils/testUtils.mjs

@@ -0,0 +1,16 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { onTestFinished } from 'vitest';
+
+/** Creates a temporary directory and removes it when the current test ends, even if it throws. */
+export async function makeTempDir() {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'benchmark-test-'));
+  onTestFinished(async () => {
+    await fs.rm(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+  return tmpDir;
+}

package/vitest.mjs

@@ -34,6 +34,18 @@ function resolveViewport(option) {
 // workload needs them.
 const LAUNCH_ARGS = ['--js-flags=--expose-gc', '--disable-background-timer-throttling', '--disable-backgrounding-occluded-windows', '--disable-renderer-backgrounding'];
 export function createBenchmarkVitestConfig(options) {
+  // Benchmarks have to measure production React, which is why the config below sets NODE_ENV to
+  // "production" for the code running in the browser. That alone isn't enough: Vite picks which
+  // JSX runtime to compile against by reading NODE_ENV from the Node process, where Vitest has set
+  // it to "test". Benchmarks then get development JSX calling into a production React build, which
+  // has no `jsxDEV` function, and every benchmark crashes on its first render with
+  // "_jsxDEV is not a function".
+  //
+  // Setting NODE_ENV here, while this config file is still being evaluated, means Vite reads
+  // "production" as well and the two agree. Vitest considers this the intended way to run tests
+  // against production React: https://github.com/vitest-dev/vitest/issues/11265
+  // eslint-disable-next-line mui/consistent-production-guard -- an assignment, not a guard
+  process.env.NODE_ENV = 'production';
   const {
     outputPath,
     baselinePath,