@@ -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,45 @@ Options:
     return 1;
   }
 
+  const rawSaveBaseline = options.saveBaseline ?? options['save-baseline'];
+  const rawCompareBaseline = options.compareBaseline ?? options['compare-baseline'];
+
+  const iterations = options.iterations !== undefined ? Number(options.iterations) : undefined;
+  const warmup = options.warmup !== undefined ? Number(options.warmup) : undefined;
+  const concurrency = options.concurrency !== undefined ? Number(options.concurrency) : undefined;
+
+  if (iterations !== undefined && (!Number.isInteger(iterations) || iterations < 1)) {
+    // eslint-disable-next-line no-console
+    console.error('Error: --iterations must be a positive integer.');
+
+    return 1;
+  }
+
+  if (warmup !== undefined && (!Number.isInteger(warmup) || warmup < 0)) {
+    // eslint-disable-next-line no-console
+    console.error('Error: --warmup must be a non-negative integer.');
+
+    return 1;
+  }
+
+  if (concurrency !== undefined && (!Number.isInteger(concurrency) || concurrency < 1)) {
+    // eslint-disable-next-line no-console
+    console.error('Error: --concurrency must be a positive integer.');
+
+    return 1;
+  }
+
   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,
+    iterations,
+    warmup,
+    concurrency,
     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);
 
@@ -13,8 +13,8 @@ import { createRequire } from 'node:module';
 
 import path from 'node:path';
 
-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';
+import type { BuildOutputFile } from '../../../packages/angular/build/src/tools/esbuild/bundler-files.js';
+import type { LocaleInlineOptions } from '../../../packages/angular/build/src/tools/esbuild/i18n-inliner.js';
 
 // Setup module paths to resolve dependencies from packages/angular/build
 const requireFromBuild = createRequire(
 
@@ -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
 
@@ -82,9 +82,12 @@ export async function runI18nBenchmarks(
       }
 
       const proc = spawnSync(process.execPath, args, { encoding: 'utf-8' });
-      if (proc.status !== 0) {
+      if (proc.status !== 0 || proc.error) {
         // eslint-disable-next-line no-console
-        console.error(`Error running scenario ${scenario.name}:\n${proc.stderr || proc.stdout}`);
+        console.error(
+          `Error running scenario ${scenario.name}:\n` +
+            (proc.error?.message ?? (proc.stderr || proc.stdout)),
+        );
 
         return { results, exitCode: 1 };
       }
 
@@ -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?.();
 
@@ -13,9 +13,10 @@ 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';
+import type { BuildOutputFile } from '../../../packages/angular/build/src/tools/esbuild/bundler-files.js';
+import type { LocaleInlineOptions } from '../../../packages/angular/build/src/tools/esbuild/i18n-inliner.js';
 import { generateSyntheticBundle, generateTranslations, initializeFixtures } from './fixtures.mts';
 import type { BenchmarkScenario } from './harness.mts';
 
@@ -25,7 +26,7 @@ const requireFromBuild = createRequire(
 
 const { I18nInliner } = requireFromBuild(
   '../../../dist/@angular/build/src/tools/esbuild/i18n-inliner.js',
-) as typeof import('../../../dist/@angular/build/src/tools/esbuild/i18n-inliner.d.ts');
+) as typeof import('../../../packages/angular/build/src/tools/esbuild/i18n-inliner.js');
 
 export interface ScenarioFactoryOptions {
   concurrency?: number;
@@ -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,28 @@ 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],
+        [
+          '--no-warnings=ExperimentalWarning',
+          '--experimental-transform-types',
+          '--input-type=module',
+          '-e',
+          primerCode,
+        ],
         { stdio: 'inherit' },
       );
+
+      if (primerProc.status !== 0 || primerProc.error) {
+        throw new Error(
+          `Failed to prime cache for persistent-cache-warm scenario: ${primerProc.error?.message ?? primerProc.status}`,
+        );
+      }
     },
 
     async run() {
@@ -384,11 +407,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),
   ];
Original file line number	Diff line number	Diff line change
@@ -82,9 +82,12 @@ export async function runI18nBenchmarks(
82	82	}
83	83
84	84	const proc = spawnSync(process.execPath, args, { encoding: 'utf-8' });
85		- if (proc.status !== 0) {
	85	+ if (proc.status !== 0 \|\| proc.error) {
86	86	// eslint-disable-next-line no-console
87		- console.error(`Error running scenario ${scenario.name}:\n${proc.stderr \|\| proc.stdout}`);
	87	+ console.error(
	88	+ `Error running scenario ${scenario.name}:\n` +
	89	+ (proc.error?.message ?? (proc.stderr \|\| proc.stdout)),
	90	+ );
88	91
89	92	return { results, exitCode: 1 };
90	93	}