@mui/internal-bundle-size-checker 1.0.9-canary.8 → 1.0.9-canary.80

package/README.md

@@ -19,9 +19,12 @@ bundle-size-checker [options]
 
 Options:
 
-- `--analyze`: Creates a webpack-bundle-analyzer report for each bundle
-- `--accurateBundles`: Displays used bundles accurately at the cost of more CPU cycles
+- `--analyze`: Creates a report for each bundle (using rollup-plugin-visualizer)
+- `--debug`: Build with readable output (no name mangling or whitespace collapse, but still tree-shake)
+- `--verbose`: Show more detailed information during compilation
 - `--output`, `-o`: Path to output the size snapshot JSON file
+- `--filter`, `-F`: Filter entry points by glob pattern(s) applied to their IDs
+- `--concurrency`, `-c`: Number of workers to use for parallel processing
 
 ### Configuration
 
@@ -63,6 +66,13 @@ export default defineConfig(async () => {
         importedNames: ['Button'],
         // When externals is not specified, peer dependencies will be automatically excluded
       },
+      // Expand a package into one entry per export from its package.json
+      { id: '@mui/material', expand: true },
+      // Expand with glob exclusions (matched against the export subpath, e.g. `styles/colors`)
+      {
+        id: '@mui/material',
+        expand: { exclude: ['styles/**', 'internal/*'] },
+      },
       // ...
     ],
     // Optional upload configuration

package/build/builder.d.ts

@@ -0,0 +1,25 @@
+export type ObjectEntry = import('./types.js').ObjectEntry;
+export type CommandLineArgs = import('./types.js').CommandLineArgs;
+export type SizeSnapshotEntry = import('./types.js').SizeSnapshotEntry;
+export type ManifestChunk = {
+    file: string;
+    name?: string;
+    src?: string;
+    css?: string[];
+    isEntry?: boolean;
+    isDynamicEntry?: boolean;
+    imports?: string[];
+    dynamicImports?: string[];
+};
+export type Manifest = Record<string, ManifestChunk>;
+/**
+ * Get sizes for a vite bundle
+ * @param {ObjectEntry} entry - The entry configuration
+ * @param {CommandLineArgs} args - Command line arguments
+ * @param {Record<string, string>} [replacements] - String replacements to apply
+ * @returns {Promise<{ sizes: Map<string, SizeSnapshotEntry>, treemapPath: string }>}
+ */
+export declare function getBundleSizes(entry: ObjectEntry, args: CommandLineArgs, replacements?: Record<string, string>): Promise<{
+    sizes: Map<string, SizeSnapshotEntry>;
+    treemapPath: string;
+}>;

package/build/ciReport.d.ts

@@ -0,0 +1,32 @@
+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.
+ * @param {string} type - The report type literal (e.g. 'size-snapshot')
+ * @param {number} version - The schema version number
+ * @param {z.ZodType} reportSchema - Zod schema for the report payload
+ */
+export declare function ciReportUploadSchema(type: string, version: number, reportSchema: z.ZodType): 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: z.ZodType<any, any, z.core.$ZodTypeInternals<any, any>>;
+}, z.core.$strip>;
+export declare const sizeSnapshotUploadSchema: 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: z.ZodType<any, any, z.core.$ZodTypeInternals<any, any>>;
+}, z.core.$strip>;
+export type SizeSnapshotUpload = z.infer<typeof sizeSnapshotUploadSchema>;
+/**
+ * @typedef {z.infer<typeof sizeSnapshotUploadSchema>} SizeSnapshotUpload
+ */

package/build/cli.d.ts

@@ -0,0 +1,3 @@
+export type CommandLineArgs = import('./types.js').CommandLineArgs;
+export type NormalizedBundleSizeCheckerConfig = import('./types.js').NormalizedBundleSizeCheckerConfig;
+export type SizeSnapshotEntry = import('./types.js').SizeSnapshotEntry;

package/build/configLoader.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Utility to load the bundle-size-checker configuration
+ */
+export type BundleSizeCheckerConfigObject = import('./types.js').BundleSizeCheckerConfigObject;
+export type UploadConfig = import('./types.js').UploadConfig;
+export type NormalizedUploadConfig = import('./types.js').NormalizedUploadConfig;
+export type EntryPoint = import('./types.js').EntryPoint;
+export type ObjectEntry = import('./types.js').ObjectEntry;
+export type NormalizedBundleSizeCheckerConfig = import('./types.js').NormalizedBundleSizeCheckerConfig;
+/**
+ * Validates and normalizes an upload configuration object
+ * @param {UploadConfig} uploadConfig - The upload configuration to normalize
+ * @param {Object} ciInfo - CI environment information
+ * @param {string} [ciInfo.branch] - Branch name from CI environment
+ * @param {boolean} [ciInfo.isPr] - Whether this is a pull request from CI environment
+ * @param {string} [ciInfo.prBranch] - PR branch name from CI environment
+ * @param {string} [ciInfo.slug] - Repository slug from CI environment
+ * @param {string} [ciInfo.pr] - Pull request number from CI environment
+ * @returns {NormalizedUploadConfig} - Normalized upload config
+ * @throws {Error} If required fields are missing
+ */
+export declare function applyUploadConfigDefaults(uploadConfig: UploadConfig, ciInfo: {
+    branch?: string;
+    isPr?: boolean;
+    prBranch?: string;
+    slug?: string;
+    pr?: string;
+}): NormalizedUploadConfig;
+/**
+ * Attempts to load the config file from the given directory
+ * @param {string} rootDir - The directory to search for the config file
+ * @returns {Promise<NormalizedBundleSizeCheckerConfig>} A promise that resolves to the normalized config object
+ */
+export declare function loadConfig(rootDir: string): Promise<NormalizedBundleSizeCheckerConfig>;

package/build/defineConfig.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @typedef {import('./types.js').BundleSizeCheckerConfig} BundleSizeCheckerConfig
+ */
+export type BundleSizeCheckerConfig = import('./types.js').BundleSizeCheckerConfig;
+/**
+ * Define a configuration for the bundle size checker.
+ * This is just a pass-through function for better TypeScript typing.
+ *
+ * @param {BundleSizeCheckerConfig} config - Configuration object
+ * @returns {BundleSizeCheckerConfig} The configuration object
+ */
+export default function defineConfig(config: BundleSizeCheckerConfig): BundleSizeCheckerConfig;

package/build/formatUtils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Format utilities for consistent display of sizes and percentages
+ */
+export declare const byteSizeFormatter: Intl.NumberFormat;
+export declare const byteSizeChangeFormatter: Intl.NumberFormat;
+export declare const displayPercentFormatter: Intl.NumberFormat;

package/build/git.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Gets parent commits for a given commit SHA using git CLI
+ * @param {string} repo - Repository name (e.g., 'mui/material-ui') - ignored for git CLI
+ * @param {string} commit - The commit SHA to start from
+ * @param {number} depth - How many commits to retrieve (including the starting commit)
+ * @returns {Promise<string[]>} Array of commit SHAs in chronological order (excluding the starting commit)
+ */
+export declare function getParentCommits(repo: string, commit: string, depth?: number): Promise<string[]>;
+/**
+ * Compares two commits and returns merge base information using git CLI
+ * @param {string} base - Base commit SHA
+ * @param {string} head - Head commit SHA
+ * @returns {Promise<string>} Object with merge base commit info
+ */
+export declare function getMergeBase(base: string, head: string): Promise<string>;
+/**
+ * Gets the current repository owner and name from git remote
+ * @returns {Promise<{owner: string | null, name: string | null}>}
+ */
+export declare function getCurrentRepoInfo(): Promise<{
+    owner: string | null;
+    name: string | null;
+}>;

package/build/github.d.ts

@@ -0,0 +1,2 @@
+/** @type {import('@octokit/rest').Octokit} */
+export declare const octokit: import('@octokit/rest').Octokit;

package/build/index.d.ts

@@ -0,0 +1,3 @@
+import defineConfig from './defineConfig.js';
+import { loadConfig } from './configLoader.js';
+export { defineConfig, loadConfig };

package/build/notifyPr.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates or updates a comment on a pull request with the specified content.
+ * Uses an HTML comment marker to identify and update existing comments.
+ * Searches page-by-page (newest first) and stops early when comment is found.
+ *
+ * @param {string} repo - The repository in format "owner/repo"
+ * @param {number} prNumber - The pull request number
+ * @param {string} id - Unique identifier to mark the comment for future updates
+ * @param {string} content - The content to post or update in the comment
+ * @returns {Promise<void>}
+ */
+export declare function notifyPr(repo: string, prNumber: number, id: string, content: string): Promise<void>;

package/build/strings.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Inspired by https://github.com/parshap/node-sanitize-filename
+ *
+ * Replaces characters in strings that are illegal/unsafe for filenames.
+ * Unsafe characters are either removed or replaced by a substitute set
+ * in the optional `options` object.
+ *
+ * Illegal Characters on Various Operating Systems
+ * / ? < > \ : * | "
+ * https://kb.acronis.com/content/39790
+ *
+ * Unicode Control codes
+ * C0 0x00-0x1f & C1 (0x80-0x9f)
+ * http://en.wikipedia.org/wiki/C0_and_C1_control_codes
+ *
+ * Reserved filenames on Unix-based systems (".", "..")
+ * Reserved filenames in Windows ("CON", "PRN", "AUX", "NUL", "COM1",
+ * "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
+ * "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", and
+ * "LPT9") case-insesitively and with or without filename extensions.
+ * @param {string} input
+ */
+export declare function escapeFilename(input: string, replacement?: string): string;

package/build/syncPrComment.d.ts

@@ -0,0 +1,13 @@
+export type SyncPrCommentResult = {
+    success: boolean;
+    skipped?: boolean;
+};
+/**
+ * @typedef {{ success: boolean, skipped?: boolean }} SyncPrCommentResult
+ */
+/**
+ * Syncs a PR comment via the dashboard API.
+ * @param {string} repo - Repository in owner/repo format
+ * @returns {Promise<SyncPrCommentResult>}
+ */
+export declare function syncPrComment(repo: string): Promise<SyncPrCommentResult>;

package/build/uploadSnapshot.d.ts

@@ -0,0 +1,11 @@
+export type NormalizedUploadConfig = import('./types.js').NormalizedUploadConfig;
+/**
+ * Uploads the size snapshot to S3
+ * @param {string} snapshotPath - The path to the size snapshot JSON file
+ * @param {NormalizedUploadConfig} uploadConfig - The normalized upload configuration
+ * @param {string} [commitSha] - Optional commit SHA (defaults to current Git HEAD)
+ * @returns {Promise<{key:string}>}
+ */
+export declare function uploadSnapshot(snapshotPath: string, uploadConfig: NormalizedUploadConfig, commitSha?: string): Promise<{
+    key: string;
+}>;

package/build/worker.d.ts

@@ -0,0 +1,15 @@
+export type ObjectEntry = import('./types.js').ObjectEntry;
+export type CommandLineArgs = import('./types.js').CommandLineArgs;
+export type SizeSnapshotEntry = import('./types.js').SizeSnapshotEntry;
+/**
+ * Get sizes for a bundle
+ * @param {{ entry: ObjectEntry, args: CommandLineArgs, index: number, total: number, replace?: Record<string, string> }} options
+ * @returns {Promise<Array<[string, SizeSnapshotEntry]>>}
+ */
+export default function getSizes({ entry, args, index, total, replace }: {
+    entry: ObjectEntry;
+    args: CommandLineArgs;
+    index: number;
+    total: number;
+    replace?: Record<string, string>;
+}): Promise<Array<[string, SizeSnapshotEntry]>>;

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@mui/internal-bundle-size-checker",
-  "version": "1.0.9-canary.8",
+  "version": "1.0.9-canary.80",
+  "author": "MUI Team",
   "description": "Bundle size checker for MUI packages.",
+  "license": "MIT",
   "type": "module",
   "main": "./src/index.js",
+  "types": "./build/index.d.ts",
   "bin": {
     "bundle-size-checker": "./bin/bundle-size-checker.js"
   },
@@ -14,45 +17,38 @@
   },
   "sideEffects": false,
   "exports": {
-    ".": "./src/index.js",
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./src/index.js"
+    },
     "./package.json": "./package.json",
-    "./browser": "./src/browser.js"
+    "./ciReport": {
+      "types": "./build/ciReport.d.ts",
+      "default": "./src/ciReport.js"
+    }
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.515.0",
-    "@aws-sdk/credential-providers": "^3.787.0",
-    "@babel/core": "^7.27.4",
-    "@octokit/rest": "^22.0.0",
-    "@babel/preset-react": "^7.18.6",
-    "@babel/preset-typescript": "^7.27.1",
-    "babel-loader": "^10.0.0",
-    "chalk": "^5.4.1",
-    "compression-webpack-plugin": "^10.0.0",
-    "css-loader": "^7.1.2",
-    "env-ci": "^11.1.0",
-    "execa": "^7.2.0",
-    "fast-glob": "^3.3.2",
-    "file-loader": "^6.2.0",
+    "@octokit/rest": "^22.0.1",
+    "chalk": "^5.6.2",
+    "env-ci": "^11.2.0",
+    "execa": "^9.6.1",
     "git-url-parse": "^16.1.0",
     "micromatch": "^4.0.8",
-    "piscina": "^4.2.1",
-    "rollup-plugin-visualizer": "^6.0.1",
-    "terser-webpack-plugin": "^5.3.10",
-    "vite": "^6.3.5",
-    "webpack": "^5.90.3",
-    "webpack-bundle-analyzer": "^4.10.1",
-    "yargs": "^17.7.2"
+    "piscina": "^5.1.4",
+    "rollup-plugin-visualizer": "^7.0.1",
+    "vite": "^8.0.11",
+    "yargs": "^18.0.0",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/env-ci": "^3.1.4",
-    "@types/micromatch": "^4.0.9",
-    "@types/webpack": "^5.28.5",
-    "@types/webpack-bundle-analyzer": "^4.7.0",
-    "@types/yargs": "^17.0.33"
+    "@types/env-ci": "3.1.4",
+    "@types/micromatch": "4.0.10",
+    "@types/yargs": "17.0.35"
   },
-  "gitSha": "0812f9aed28e33d8d0713ddfb3131825b2321867",
+  "gitSha": "8b0badde3f4948db33af81129bf69b51a619aa3a",
   "scripts": {
-    "typescript": "tsc -p tsconfig.json",
-    "test": "pnpm -w test --project @mui/internal-bundle-size-checker"
+    "build": "tsgo -p tsconfig.build.json",
+    "test": "pnpm -w test --project @mui/internal-bundle-size-checker",
+    "typescript": "tsgo -noEmit"
   }
 }

package/src/{viteBuilder.js → builder.js}

@@ -1,9 +1,16 @@
-import path from 'path';
-import fs from 'fs/promises';
-import * as zlib from 'zlib';
-import { promisify } from 'util';
-import { build, transformWithEsbuild } from 'vite';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import * as zlib from 'node:zlib';
+import { promisify } from 'node:util';
+import { build, transformWithOxc } from 'vite';
 import { visualizer } from 'rollup-plugin-visualizer';
+import { escapeFilename } from './strings.js';
+
+/**
+ * @typedef {import('./types.js').ObjectEntry} ObjectEntry
+ * @typedef {import('./types.js').CommandLineArgs} CommandLineArgs
+ * @typedef {import('./types.js').SizeSnapshotEntry} SizeSnapshotEntry
+ */
 
 const gzipAsync = promisify(zlib.gzip);
 
@@ -25,13 +32,32 @@ const rootDir = process.cwd();
  * @typedef {Record<string, ManifestChunk>} Manifest
  */
 
+/**
+ * Creates a simple string replacement plugin
+ * @param {Record<string, string>} replacements - Object with string replacements
+ * @returns {import('vite').Plugin}
+ */
+function createReplacePlugin(replacements) {
+  return {
+    name: 'string-replace',
+    transform(code) {
+      let transformedCode = code;
+      for (const [search, replace] of Object.entries(replacements)) {
+        transformedCode = transformedCode.replaceAll(search, replace);
+      }
+      return transformedCode !== code ? transformedCode : null;
+    },
+  };
+}
+
 /**
  * Creates vite configuration for bundle size checking
  * @param {ObjectEntry} entry - Entry point (string or object)
  * @param {CommandLineArgs} args
- * @returns {Promise<{configuration: import('vite').InlineConfig, externalsArray: string[]}>}
+ * @param {Record<string, string>} [replacements] - String replacements to apply
+ * @returns {Promise<{ config:import('vite').InlineConfig, treemapPath: string }>}
  */
-async function createViteConfig(entry, args) {
+async function createViteConfig(entry, args, replacements = {}) {
   const entryName = entry.id;
   let entryContent;
 
@@ -59,29 +85,43 @@ async function createViteConfig(entry, args) {
   const externalsArray = entry.externals || ['react', 'react-dom'];
 
   // Ensure build directory exists
-  const outDir = path.join(rootDir, 'build', entryName);
+  const outDir = path.join(rootDir, 'build', escapeFilename(entryName));
   await fs.mkdir(outDir, { recursive: true });
+
+  const treemapPath = path.join(outDir, 'treemap.html');
+
   /**
    * @type {import('vite').InlineConfig}
    */
-  const configuration = {
+  const config = {
     configFile: false,
     root: rootDir,
 
     build: {
       write: true,
-      minify: true,
+      minify: args.debug ? 'esbuild' : true,
       outDir,
       emptyOutDir: true,
+      modulePreload: false,
       rollupOptions: {
-        input: '/index.tsx',
-        external: externalsArray,
+        input: {
+          ignore: '/ignore.ts',
+          bundle: '/entry.tsx',
+        },
+        output: {
+          // The output is for debugging purposes only. Remove all hashes to make it easier to compare two folders
+          // of build output.
+          entryFileNames: `assets/[name].js`,
+          chunkFileNames: `assets/[name].js`,
+          assetFileNames: `assets/[name].[ext]`,
+        },
+        external: (id) => externalsArray.some((ext) => id === ext || id.startsWith(`${ext}/`)),
         plugins: [
           ...(args.analyze
             ? [
                 // File sizes are not accurate, use it only for relative comparison
                 visualizer({
-                  filename: `${outDir}.html`,
+                  filename: treemapPath,
                   title: `Bundle Size Analysis: ${entryName}`,
                   projectRoot: rootDir,
                   open: false,
@@ -100,19 +140,25 @@ async function createViteConfig(entry, args) {
 
     esbuild: {
       legalComments: 'none',
+      ...(args.debug && {
+        minifyIdentifiers: false,
+        minifyWhitespace: false,
+        minifySyntax: true, // This enables tree-shaking and other safe optimizations
+      }),
     },
 
     define: {
-      'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'production'),
+      'process.env.NODE_ENV': JSON.stringify('production'),
     },
     logLevel: args.verbose ? 'info' : 'silent',
     // Add plugins to handle virtual entry points
     plugins: [
+      createReplacePlugin(replacements),
       {
         name: 'virtual-entry',
         resolveId(id) {
-          if (id === '/index.tsx') {
-            return `\0virtual:index.tsx`;
+          if (id === '/ignore.ts') {
+            return `\0virtual:ignore.ts`;
           }
           if (id === '/entry.tsx') {
             return `\0virtual:entry.tsx`;
@@ -120,11 +166,13 @@ async function createViteConfig(entry, args) {
           return null;
         },
         load(id) {
-          if (id === `\0virtual:index.tsx`) {
-            return transformWithEsbuild(`import('/entry.tsx').then(console.log)`, id);
+          if (id === `\0virtual:ignore.ts`) {
+            // ignore chunk will contain the vite preload code, we can ignore this chunk in the output
+            // See https://github.com/vitejs/vite/issues/18551
+            return transformWithOxc(`import('/entry.tsx').then(console.log)`, id);
           }
           if (id === `\0virtual:entry.tsx`) {
-            return transformWithEsbuild(entryContent, id);
+            return transformWithOxc(entryContent, id);
           }
           return null;
         },
@@ -132,7 +180,7 @@ async function createViteConfig(entry, args) {
     ],
   };
 
-  return { configuration, externalsArray };
+  return { config, treemapPath };
 }
 
 /**
@@ -173,32 +221,49 @@ function walkDependencyTree(chunkKey, manifest, visited = new Set()) {
 
 /**
  * Process vite output to extract bundle sizes
- * @param {string} outDir - The output directory
+ * @param {import('vite').Rollup.RollupOutput['output']} output - The Vite output
  * @param {string} entryName - The entry name
- * @returns {Promise<Map<string, { parsed: number, gzip: number }>>} - Map of bundle names to size information
+ * @returns {Promise<Map<string, SizeSnapshotEntry>>} - Map of bundle names to size information
  */
-async function processBundleSizes(outDir, entryName) {
+async function processBundleSizes(output, entryName) {
+  const chunksByFileName = new Map(output.map((chunk) => [chunk.fileName, chunk]));
+
   // Read the manifest file to find the generated chunks
-  const manifestPath = path.join(outDir, '.vite/manifest.json');
-  const manifestContent = await fs.readFile(manifestPath, 'utf8');
+  const manifestChunk = chunksByFileName.get('.vite/manifest.json');
+  if (manifestChunk?.type !== 'asset') {
+    throw new Error(`Manifest file not found in output for entry: ${entryName}`);
+  }
+
+  const manifestContent =
+    typeof manifestChunk.source === 'string'
+      ? manifestChunk.source
+      : new TextDecoder().decode(manifestChunk.source);
+
   /** @type {Manifest} */
   const manifest = JSON.parse(manifestContent);
 
   // Find the main entry point JS file in the manifest
-  const mainEntry = manifest['virtual:entry.tsx'];
+  const mainEntry = Object.entries(manifest).find(([_, entry]) => entry.name === 'bundle');
 
   if (!mainEntry) {
     throw new Error(`No main entry found in manifest for ${entryName}`);
   }
 
   // Walk the dependency tree to get all chunks that are part of this entry
-  const allChunks = walkDependencyTree('virtual:entry.tsx', manifest);
+  const allChunks = walkDependencyTree(mainEntry[0], manifest);
 
   // Process each chunk in the dependency tree in parallel
   const chunkPromises = Array.from(allChunks, async (chunkKey) => {
     const chunk = manifest[chunkKey];
-    const filePath = path.join(outDir, chunk.file);
-    const fileContent = await fs.readFile(filePath, 'utf8');
+    const outputChunk = chunksByFileName.get(chunk.file);
+    if (outputChunk?.type !== 'chunk') {
+      throw new Error(`Output chunk not found for ${chunk.file}`);
+    }
+    const fileContent = outputChunk.code;
+    if (chunk.name === 'preload-helper') {
+      // Skip the preload-helper chunk as it is not relevant for bundle size
+      return null;
+    }
 
     // Calculate sizes
     const parsed = Buffer.byteLength(fileContent);
@@ -206,28 +271,34 @@ async function processBundleSizes(outDir, entryName) {
     const gzipSize = Buffer.byteLength(gzipBuffer);
 
     // Use chunk key as the name, or fallback to entry name for main chunk
-    const chunkName = chunkKey === 'virtual:entry.tsx' ? entryName : chunkKey;
+    const chunkName = chunk.name === 'bundle' ? entryName : chunk.name || chunkKey;
     return /** @type {const} */ ([chunkName, { parsed, gzip: gzipSize }]);
   });
 
   const chunkEntries = await Promise.all(chunkPromises);
-  return new Map(chunkEntries);
+  return new Map(/** @type {[string, SizeSnapshotEntry][]} */ (chunkEntries.filter(Boolean)));
 }
 
 /**
  * Get sizes for a vite bundle
  * @param {ObjectEntry} entry - The entry configuration
  * @param {CommandLineArgs} args - Command line arguments
- * @returns {Promise<Map<string, { parsed: number, gzip: number }>>}
+ * @param {Record<string, string>} [replacements] - String replacements to apply
+ * @returns {Promise<{ sizes: Map<string, SizeSnapshotEntry>, treemapPath: string }>}
  */
-export async function getViteSizes(entry, args) {
+export async function getBundleSizes(entry, args, replacements) {
   // Create vite configuration
-  const { configuration } = await createViteConfig(entry, args);
-  const outDir = path.join(rootDir, 'build', entry.id);
+  const { config, treemapPath } = await createViteConfig(entry, args, replacements);
 
   // Run vite build
-  await build(configuration);
+  const { output } = /** @type {import('vite').Rollup.RollupOutput} */ (await build(config));
+  const manifestChunk = output.find((chunk) => chunk.fileName === '.vite/manifest.json');
+  if (!manifestChunk) {
+    throw new Error(`Manifest file not found in output for entry: ${entry.id}`);
+  }
 
   // Process the output to get bundle sizes
-  return processBundleSizes(outDir, entry.id);
+  const sizes = await processBundleSizes(output, entry.id);
+
+  return { sizes, treemapPath };
 }

package/src/ciReport.js

@@ -0,0 +1,44 @@
+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.
+ * @param {string} type - The report type literal (e.g. 'size-snapshot')
+ * @param {number} version - The schema version number
+ * @param {z.ZodType} reportSchema - Zod schema for the report payload
+ */
+export function ciReportUploadSchema(type, version, reportSchema) {
+  return z.object({
+    version: z.literal(version),
+    timestamp: z.number(),
+    commitSha: z.string().regex(/^[0-9a-f]{40}$/, 'Must be a 40-character hex string'),
+    repo: z.string().includes('/', 'Must be in owner/repo format'),
+    reportType: z.literal(type),
+    prNumber: z.number().int().positive().optional(),
+    branch: z.string(),
+    report: reportSchema,
+  });
+}
+
+const sizeSnapshotEntrySchema = z.object({
+  parsed: z.number(),
+  gzip: z.number(),
+});
+
+const snapshotMetadataSchema = z.object({
+  trackedBundles: z.array(z.string()).optional(),
+});
+
+const sizeSnapshotSchema = z
+  .record(z.string(), sizeSnapshotEntrySchema)
+  .and(z.object({ _metadata: snapshotMetadataSchema }).partial());
+
+export const sizeSnapshotUploadSchema = ciReportUploadSchema(
+  'size-snapshot',
+  1,
+  sizeSnapshotSchema,
+);
+
+/**
+ * @typedef {z.infer<typeof sizeSnapshotUploadSchema>} SizeSnapshotUpload
+ */