test(@angular/build): add large-enterprise-10k benchmark scenario

Adds a large-scale stress test scenario to the i18n inliner benchmark suite with 10,000 translation messages across 32 locales. The scenario generates a 3 MB main bundle and 100 route chunks with source maps, evaluating binary translation catalog encoding, small file batching, and memory scaling under maximum enterprise workloads.

Author: clydin

scripts/benchmark.mts

@@ -7,6 +7,7 @@
  */
 
 import fs from 'node:fs';
+import path from 'node:path';
 import { type BenchmarkCliOptions, runI18nBenchmarks } from './benchmarks/i18n/index.mts';
 
 function checkBuildStatus(logger: Console): boolean {
@@ -44,6 +45,8 @@ export default async function (
     concurrency?: string | number;
     build?: boolean;
     json?: boolean;
+    inProcess?: boolean;
+    'in-process'?: boolean;
     saveBaseline?: string;
     'save-baseline'?: string;
     compareBaseline?: string;
@@ -72,6 +75,7 @@ Options:
   --iterations=<n>           Number of measured iterations (default: 5)
   --warmup=<n>               Number of warmup iterations (default: 2)
   --concurrency=<n>          Override worker thread pool concurrency
+  --in-process               Run all scenarios in a single process (useful for debugging)
   --build                    Automatically build packages before benchmarking
   --json                     Output results in machine-readable JSON
   --save-baseline=<file>     Save run results to a baseline JSON file
@@ -99,14 +103,20 @@ Options:
     return 1;
   }
 
+  const rawSaveBaseline = options.saveBaseline ?? options['save-baseline'];
+  const rawCompareBaseline = options.compareBaseline ?? options['compare-baseline'];
+
   const cliOptions: BenchmarkCliOptions = {
     scenario: options.scenario,
     iterations: options.iterations !== undefined ? Number(options.iterations) : undefined,
     warmup: options.warmup !== undefined ? Number(options.warmup) : undefined,
     concurrency: options.concurrency !== undefined ? Number(options.concurrency) : undefined,
     json: Boolean(options.json),
-    saveBaseline: options.saveBaseline ?? options['save-baseline'],
-    compareBaseline: options.compareBaseline ?? options['compare-baseline'],
+    inProcess: Boolean(options.inProcess ?? options['in-process']),
+    saveBaseline: rawSaveBaseline ? path.resolve(_cwd, String(rawSaveBaseline)) : undefined,
+    compareBaseline: rawCompareBaseline
+      ? path.resolve(_cwd, String(rawCompareBaseline))
+      : undefined,
   };
 
   const { exitCode } = await runI18nBenchmarks(cliOptions);

scripts/benchmarks/i18n/harness.mts

@@ -63,9 +63,9 @@ export async function runScenario(
   const warmup = options.warmup ?? 2;
   const iterations = options.iterations ?? 5;
 
-  await scenario.setup?.();
-
   try {
+    await scenario.setup?.();
+
     // Warmup phase
     for (let w = 0; w < warmup; w++) {
       // Force GC if available between warmups
@@ -106,10 +106,10 @@ export async function runScenario(
       if (rssDelta > maxRssDeltaBytes) {
         maxRssDeltaBytes = rssDelta;
       }
-      finalHeap = memAfter.heapUsed;
 
       // Force GC immediately after iteration to clean main thread isolate
       global.gc?.();
+      finalHeap = process.memoryUsage().heapUsed;
     }
 
     // Sort ascending for percentile computation

scripts/benchmarks/i18n/init-env.mts

@@ -17,7 +17,9 @@ const buildNodeModules = path.resolve(
 
 const currentPath = process.env.NODE_PATH ?? '';
 if (!currentPath.includes(buildNodeModules)) {
-  process.env.NODE_PATH = currentPath ? `${buildNodeModules}:${currentPath}` : buildNodeModules;
+  process.env.NODE_PATH = currentPath
+    ? `${buildNodeModules}${path.delimiter}${currentPath}`
+    : buildNodeModules;
   // Initialize internal search paths for Node CommonJS loader
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   (Module as any)._initPaths?.();

scripts/benchmarks/i18n/scenarios.mts

@@ -13,6 +13,7 @@ import fs from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import os from 'node:os';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 
 import type { BuildOutputFile } from '../../../dist/@angular/build/src/tools/esbuild/bundler-files.d.ts';
 import type { LocaleInlineOptions } from '../../../dist/@angular/build/src/tools/esbuild/i18n-inliner.d.ts';
@@ -124,6 +125,15 @@ function calculateInputSizeBytes(files: BuildOutputFile[]): number {
   }, 0);
 }
 
+/**
+ * Note on Worker Pool Lifecycle:
+ * Each scenario's run() method instantiates and closes an I18nInliner per iteration.
+ * This is designed as a macro benchmark to reflect the cold-start behavior of single-shot
+ * CLI build invocations (including worker thread pool initialization, task dispatch,
+ * inlining transformations, and thread pool shutdown). Warmup iterations warm up the
+ * main-thread V8 isolate and runtime paths, while worker threads are initialized per iteration.
+ */
+
 /**
  * 1. Standard App Scenario:
  * 1 main bundle (1 MB) + 20 route chunks (50 KB) = ~2 MB input JS, 8 locales, maps enabled.
@@ -350,15 +360,22 @@ export function createPersistentCacheWarmScenario(
 
       // Prime the persistent cache out-of-process so cold worker thread allocations
       // do not inflate this process's RSS metrics.
+      const scenariosUrl = pathToFileURL(path.resolve(import.meta.dirname, './scenarios.mts')).href;
       const primerCode =
-        `import { primeCache } from ${JSON.stringify(path.resolve(import.meta.dirname, './scenarios.mts'))};\n` +
+        `import { primeCache } from ${JSON.stringify(scenariosUrl)};\n` +
         `await primeCache(${JSON.stringify(cacheDir)}, ${options.concurrency ?? 'undefined'});\n`;
 
-      spawnSync(
+      const primerProc = spawnSync(
         process.execPath,
         ['--no-warnings=ExperimentalWarning', '--experimental-transform-types', '-e', primerCode],
         { stdio: 'inherit' },
       );
+
+      if (primerProc.status !== 0) {
+        throw new Error(
+          `Failed to prime cache for persistent-cache-warm scenario: ${primerProc.error?.message ?? primerProc.status}`,
+        );
+      }
     },
 
     async run() {
@@ -384,11 +401,60 @@ export function createPersistentCacheWarmScenario(
   };
 }
 
+/**
+ * 6. Large Enterprise (10k translations) Scenario:
+ * 1 main bundle (3 MB) + 100 chunks (50 KB), 32 locales, 10,000 translations, sourcemaps ON.
+ * Maximum scale stress test for binary translation tables, memory retention, and multi-locale windows.
+ */
+export function createLargeEnterpriseScenario(
+  options: ScenarioFactoryOptions = {},
+): BenchmarkScenario {
+  let workload: GeneratedWorkload | undefined;
+
+  return {
+    name: 'large-enterprise-10k',
+    description:
+      'Large Enterprise (10k msgs): 1 main (3 MB) + 100 chunks (50 KB), 32 locales, 10,000 translations',
+    get inputSizeBytes() {
+      return workload?.totalInputSizeBytes ?? 0;
+    },
+    get localeCount() {
+      return DEFAULT_LOCALES_32.length;
+    },
+    async setup() {
+      await initializeFixtures();
+      const files = createBundleSet(3 * 1024 * 1024, 100, 50 * 1024, 10000, true);
+      const locales = generateTranslations(DEFAULT_LOCALES_32, 10000);
+
+      workload = {
+        files,
+        locales,
+        totalInputSizeBytes: calculateInputSizeBytes(files),
+      };
+    },
+    async run() {
+      if (!workload) {
+        return;
+      }
+      const inliner = new I18nInliner({
+        missingTranslation: 'warning',
+        maxConcurrency: options.concurrency,
+      });
+      try {
+        await inliner.inlineAll(workload.files, workload.locales);
+      } finally {
+        await inliner.close();
+      }
+    },
+  };
+}
+
 export function getAllScenarios(options: ScenarioFactoryOptions = {}): BenchmarkScenario[] {
   return [
     createStandardAppScenario(options),
     createStandardAppNoMapsScenario(options),
     createEnterpriseScenario(options),
+    createLargeEnterpriseScenario(options),
     createMonolithicScenario(options),
     createPersistentCacheWarmScenario(options),
   ];