perf(@angular/build): consolidate build worker pools with shared router

Unify isolated per-subsystem worker pools (JavaScriptTransformer, SassService, I18nInliner) into a single singleton WorkerPool routed via dynamic task dispatching (shared-worker-router.ts).

- Reduce active worker threads by 66.7% (24 -> 8 threads), eliminating thread thrashing and reducing kernel system CPU time by 40.7%.
- Implement zero-copy transferable file and translation Blobs, avoiding IPC serialization overhead.
- Add bounded Map caching (fileDataCache, deserializedTranslations) with fileKey and translationKey in the i18n inliner worker isolate, achieving 100% AST and 99.8% translation cache hit rates across locales without memory leaks.
- Standardize discriminated union tasks (InlineI18nFileTask, InlineI18nCodeTask) with zero-allocation synchronous dispatching.

### Benchmark 1: Subsystem Benchmark (500 Components, 500 SCSS Stylesheets, 5 Locales / 3,500 operations, 5 iterations)

| Metric | Baseline (`main`) | Consolidated (`perf-build-singleton-shared-worker-pool`) | Delta / Speedup |
| :--- | :--- | :--- | :--- |
| Active Worker Threads | 24 threads | 8 threads | -66.7% threads (-16 threads) |
| Cold Build Duration (mean) | 1,192.6 ms | 1,214.9 ms | +1.9% (+22.3 ms) |
| Cold Build Duration (min / max) | 1,180.4 ms / 1,206.1 ms | 1,189.2 ms / 1,236.0 ms | +8.8 ms / +29.9 ms |
| P95 Build Latency | 1,206.1 ms | 1,236.0 ms | +2.5% (+29.9 ms) |
| Throughput | 2,935.1 ops/sec | 2,881.5 ops/sec | -1.8% (-53.6 ops/sec) |
| I18n Inlining Duration (Pure mean) | 703.1 ms | 238.5 ms | 2.95x faster (-66.1%) |
| I18n Inlining (min / max) | 697.3 ms / 711.0 ms | 216.2 ms / 258.3 ms | 3.23x / 2.75x faster |
| AST Cache Hit Rate (Subsequent Locales) | 0.0% (0 / 2,000) | 100.0% (2,000 / 2,000) | 100.0% cache hit rate |
| Translation Cache Hit Rate | 0.0% (0 / 2,500) | 99.8% (2,495 / 2,500) | 99.8% cache hit rate |
| Process RSS Delta | +2,779.1 MB | +1,517.4 MB | -45.4% (-1,261.7 MB saved) |
| Final Process RSS | 2,835.6 MB | 1,573.9 MB | -44.5% (-1,261.7 MB saved) |
| Kernel System CPU | 2,355.1 ms | 1,396.7 ms | -40.7% (1.69x less kernel CPU) |
| Total CPU (User + Kernel) | 16,252.7 ms | 11,106.8 ms | -31.7% (1.46x CPU efficiency) |

### Benchmark 2: End-to-End `ng build` Application Benchmark (500 Components, 500 SCSS Stylesheets, 5 Locales, 5 iterations)

| Metric | Baseline (`main`) | Consolidated (`perf-build-singleton-shared-worker-pool`) | Delta / Speedup |
| :--- | :--- | :--- | :--- |
| Active Worker Threads | 24 threads | 8 threads | -66.7% threads (-16 threads) |
| E2E Build Duration (mean) | 5,376.4 ms | 5,728.0 ms | +6.5% (+351.6 ms) |
| E2E Build Duration (min / max) | 5,292.6 ms / 5,463.4 ms | 5,610.4 ms / 5,782.3 ms | +317.8 ms / +318.9 ms |
| P95 Build Latency | 5,463.4 ms | 5,782.3 ms | +5.8% (+318.9 ms) |
| Process RSS Delta | +2,016.9 MB | +1,806.2 MB | -10.4% (-210.7 MB saved) |
| Final Process RSS | 2,098.1 MB | 1,887.0 MB | -10.1% (-211.1 MB saved) |
| Kernel System CPU | 2,156.0 ms | 1,915.7 ms | -11.1% (1.13x less kernel CPU) |
| Total CPU (User + Kernel) | 18,743.3 ms | 16,487.5 ms | -12.0% (-2,255.8 ms CPU saved) |

> **Note on Concurrency Bounds**: On high-core machines, baseline's 24 unthrottled concurrent threads across 3 independent pools allow concurrent execution of different compiler phases, whereas the consolidated 8-thread singleton enforces strict concurrency bounds, trading ~350 ms wall-clock time for -2.26s lower total CPU work and lower peak memory. This is particularly important for lower-end machines and resource-constrained CI/container environments to avoid severe CPU starvation, thread thrashing, and out-of-memory crashes.

Author: alan-agius4

packages/angular/build/src/tools/esbuild/i18n-inliner-worker.ts

@@ -10,9 +10,10 @@ import assert from 'node:assert';
 import { extname, join } from 'node:path';
 import { serialize } from 'node:v8';
 import { calculateHash, createContentHash, initializeHash } from '../../utils/hash';
-import { WorkerPool } from '../../utils/worker-pool';
+import { WorkerPool, getSharedBuildWorkerPool } from '../../utils/worker-pool';
 import { type BuildOutputFile, BuildOutputFileType, createOutputFile } from './bundler-files';
 import { type Cache, type PersistentCacheStore, createPersistentCacheStore } from './cache';
+import type { InlineCodeResult, InlineDiagnosticMessage } from './i18n-inliner-worker';
 import { encodeTranslationToBuffer } from './i18n-translation-encoder';
 
 /**
@@ -127,13 +128,41 @@ interface CacheCheckItem {
   cachedResult: Promise<TransformedFileResult | null>;
 }
 
+export interface InlineTemplateUpdateResult {
+  code: string;
+  errors: string[];
+  warnings: string[];
+}
+
+/**
+ * Partitions diagnostic messages into error and warning strings.
+ */
+function partitionDiagnostics(messages: readonly InlineDiagnosticMessage[]): {
+  errors: string[];
+  warnings: string[];
+} {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  for (const message of messages) {
+    if (message.type === 'error') {
+      errors.push(message.message);
+    } else {
+      warnings.push(message.message);
+    }
+  }
+
+  return { errors, warnings };
+}
+
 /**
  * An uncached transformation request entry for a file within a specific locale.
  */
 interface UncachedLocaleEntry {
   locale: string;
   cacheKey?: string;
   translation?: Blob | SharedArrayBuffer;
+  translationKey?: string;
 }
 
 /**
@@ -148,27 +177,27 @@ export class I18nInliner {
   #cacheStore: PersistentCacheStore | undefined;
   #cache: Cache<TransformedFileResult> | undefined;
   readonly #localizeFiles: ReadonlyMap<string, BuildOutputFile>;
+  readonly #filesBlobs: Map<string, Blob>;
   readonly #unmodifiedFiles: Array<BuildOutputFile>;
 
   constructor(
     private readonly options: I18nInlinerOptions,
-    maxThreads?: number,
+    _maxThreads?: number,
   ) {
     this.#unmodifiedFiles = [];
-    const { outputFiles, shouldOptimize, missingTranslation, translations } = options;
+    const { outputFiles } = options;
     const files = new Map<string, BuildOutputFile>();
 
     const pendingMaps = [];
     for (const file of outputFiles) {
       if (file.type === BuildOutputFileType.Root || file.type === BuildOutputFileType.ServerRoot) {
         // Skip also the server entry-point.
-        // Skip stats and similar files.
+        this.#unmodifiedFiles.push(file);
         continue;
       }
 
       const fileExtension = extname(file.path);
       if (fileExtension === '.js' || fileExtension === '.mjs') {
-        // Check if localizations are present
         const contentBuffer = Buffer.isBuffer(file.contents)
           ? file.contents
           : Buffer.from(file.contents.buffer, file.contents.byteOffset, file.contents.byteLength);
@@ -199,24 +228,11 @@ export class I18nInliner {
     }
 
     this.#localizeFiles = files;
+    this.#filesBlobs = new Map<string, Blob>(
+      Array.from(files, ([name, file]) => [name, new Blob([file.contents])]),
+    );
 
-    this.#workerPool = new WorkerPool({
-      filename: require.resolve('./i18n-inliner-worker'),
-      maxThreads,
-      // Extract options to ensure only the named options are serialized and sent to the worker
-      workerData: {
-        missingTranslation,
-        shouldOptimize,
-        translations,
-        // A Blob is an immutable data structure that allows sharing the data between workers
-        // without copying until the data is actually used within a Worker. This is useful here
-        // since each file may not actually be processed in each Worker and the Blob avoids
-        // unneeded repeat copying of potentially large JavaScript files.
-        files: new Map<string, Blob>(
-          Array.from(files, ([name, file]) => [name, new Blob([file.contents])]),
-        ),
-      },
-    });
+    this.#workerPool = getSharedBuildWorkerPool();
   }
 
   /**
@@ -258,9 +274,15 @@ export class I18nInliner {
       // Pre-calculate cache key bases and serialized Blobs for each locale in this window
       const localeCacheBases = new Map<string, string>();
       const localeBlobs = new Map<string, Blob | SharedArrayBuffer | undefined>();
+      const localeKeys = new Map<string, string | undefined>();
 
       for (const { locale, translation, translationIntegrity } of windowLocales) {
         localeBlobs.set(locale, serializeTranslation(translation));
+        localeKeys.set(
+          locale,
+          translationIntegrity ??
+            (translation ? calculateHash(JSON.stringify(translation)) : undefined),
+        );
 
         if (this.#cacheStore) {
           localeCacheBases.set(
@@ -339,6 +361,7 @@ export class I18nInliner {
             locale: item.locale,
             cacheKey: item.cacheKey,
             translation: localeBlobs.get(item.locale),
+            translationKey: localeKeys.get(item.locale),
           });
         }
       }
@@ -379,13 +402,11 @@ export class I18nInliner {
             outputFiles.push(createOutputFile(filename + '.map', fileResult.map, type));
           }
 
-          for (const message of fileResult.messages) {
-            if (message.type === 'error') {
-              errors.push(message.message);
-            } else {
-              warnings.push(message.message);
-            }
-          }
+          const { errors: newErrors, warnings: newWarnings } = partitionDiagnostics(
+            fileResult.messages,
+          );
+          errors.push(...newErrors);
+          warnings.push(...newWarnings);
         }
       }
 
@@ -419,22 +440,32 @@ export class I18nInliner {
     const workerTasks: Promise<void>[] = [];
 
     for (const [filename, entries] of uncachedByFile) {
+      const file = this.#localizeFiles.get(filename);
+      const fileBlob = this.#filesBlobs.get(filename);
+      const mapBlob = this.#filesBlobs.get(filename + '.map');
+      const fileKey = file ? `${filename}\0${file.hash}` : undefined;
       const ephemeral = isLastWindow && entries.length <= localesPerBatch;
+
       for (let i = 0; i < entries.length; i += localesPerBatch) {
         const batchEntries = entries.slice(i, i + localesPerBatch);
         const task = (async () => {
-          const batchResult = (await this.#workerPool.run(
-            {
-              filename,
-              locales: batchEntries.map((e) => ({
-                locale: e.locale,
-                translation: e.translation,
-              })),
-              ephemeral,
-              activeLocales,
-            },
-            { name: 'inlineFileBatch' },
-          )) as {
+          const batchResult = (await this.#workerPool.run({
+            tag: 'inline-i18n',
+            action: 'inlineFileBatch',
+            filename,
+            fileBlob,
+            fileKey,
+            mapBlob,
+            missingTranslation: this.options.missingTranslation,
+            shouldOptimize: this.options.shouldOptimize,
+            ephemeral,
+            activeLocales,
+            locales: batchEntries.map((e) => ({
+              locale: e.locale,
+              translation: e.translation,
+              translationKey: e.translationKey,
+            })),
+          })) as {
             file: string;
             results: Array<TransformedFileResult & { locale: string }>;
           };
@@ -493,7 +524,7 @@ export class I18nInliner {
     translation: Record<string, unknown> | undefined,
     templateCode: string,
     templateId: string,
-  ): Promise<{ code: string; errors: string[]; warnings: string[] }> {
+  ): Promise<InlineTemplateUpdateResult> {
     const hasLocalize = templateCode.includes(LOCALIZE_KEYWORD);
 
     if (!hasLocalize) {
@@ -504,25 +535,19 @@ export class I18nInliner {
       };
     }
 
-    const { output, messages } = await this.#workerPool.run(
-      {
-        code: templateCode,
-        filename: templateId,
-        locale,
-        translation: serializeTranslation(translation),
-      },
-      { name: 'inlineCode' },
-    );
+    const { output, messages } = (await this.#workerPool.run({
+      tag: 'inline-i18n',
+      action: 'inlineCode',
+      code: templateCode,
+      filename: templateId,
+      locale,
+      translation: serializeTranslation(translation),
+      translationKey: translation ? calculateHash(JSON.stringify(translation)) : undefined,
+      missingTranslation: this.options.missingTranslation,
+      shouldOptimize: this.options.shouldOptimize,
+    })) as InlineCodeResult;
 
-    const errors: string[] = [];
-    const warnings: string[] = [];
-    for (const message of messages) {
-      if (message.type === 'error') {
-        errors.push(message.message);
-      } else {
-        warnings.push(message.message);
-      }
-    }
+    const { errors, warnings } = partitionDiagnostics(messages);
 
     return {
       code: output,
@@ -536,7 +561,11 @@ export class I18nInliner {
    * @returns A void promise that resolves when closing is complete.
    */
   async close(): Promise<void> {
-    await Promise.allSettled([this.#cacheStore?.close(), this.#workerPool.destroy()]);
+    if (this.#workerPool !== getSharedBuildWorkerPool()) {
+      await Promise.allSettled([this.#cacheStore?.close(), this.#workerPool.destroy()]);
+    } else {
+      await this.#cacheStore?.close();
+    }
   }
 
   /**

packages/angular/build/src/tools/esbuild/i18n-inliner.ts

@@ -22,17 +22,25 @@ import {
 import { transform as transformWithOxc } from '../oxc/oxc-transform.js';
 import type { JavaScriptTransformerOptions } from './javascript-transformer';
 
-interface JavaScriptTransformRequest {
+export interface JavaScriptTransformRequest {
   filename: string;
   data: string | Uint8Array;
   skipLinker?: boolean;
   sideEffects?: boolean;
   instrumentForCoverage?: boolean;
+  sourcemap?: boolean;
+  thirdPartySourcemaps?: boolean;
+  advancedOptimizations?: boolean;
+  jit?: boolean;
 }
 
 interface TransformOptions extends Omit<JavaScriptTransformRequest, 'filename' | 'data'> {
   inputSourceMap?: EncodedSourceMap;
   isAlreadyStripped?: boolean;
+  sourcemap?: boolean;
+  thirdPartySourcemaps?: boolean;
+  advancedOptimizations?: boolean;
+  jit?: boolean;
 }
 
 const {
@@ -92,10 +100,18 @@ async function instrumentCoverage(
 export default async function transformJavaScript(
   request: JavaScriptTransformRequest,
 ): Promise<unknown> {
-  const { filename, data, ...options } = request;
+  const {
+    filename,
+    data,
+    sourcemap: reqSourcemap = sourcemap,
+    thirdPartySourcemaps: reqThirdPartySourcemaps = thirdPartySourcemaps,
+    advancedOptimizations: reqAdvancedOptimizations = advancedOptimizations,
+    jit: reqJit = jit,
+    ...options
+  } = request;
 
   const useInputSourcemap =
-    sourcemap && (!!thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));
+    reqSourcemap && (!!reqThirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));
 
   let textData: string;
   let inputSourceMap: EncodedSourceMap | undefined;
@@ -137,6 +153,10 @@ export default async function transformJavaScript(
 
   const transformedData = await transformJavaScriptImpl(filename, textData, {
     ...options,
+    sourcemap: reqSourcemap,
+    thirdPartySourcemaps: reqThirdPartySourcemaps,
+    advancedOptimizations: reqAdvancedOptimizations,
+    jit: reqJit,
     inputSourceMap,
     isAlreadyStripped,
   });
@@ -156,8 +176,13 @@ async function transformJavaScriptImpl(
   options: TransformOptions,
 ): Promise<string> {
   const shouldLink = !options.skipLinker;
+  const optSourcemap = options.sourcemap ?? sourcemap;
+  const optThirdPartySourcemaps = options.thirdPartySourcemaps ?? thirdPartySourcemaps;
+  const optAdvancedOptimizations = options.advancedOptimizations ?? advancedOptimizations;
+  const optJit = options.jit ?? jit;
+
   const useInputSourcemap =
-    sourcemap && (!!thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));
+    optSourcemap && (!!optThirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));
 
   let code = data;
   const maps: (DecodedSourceMap | EncodedSourceMap)[] = [];
@@ -191,7 +216,7 @@ async function transformJavaScriptImpl(
             relative: (_from: string, to: string) => to,
           } as never,
           logger: new ConsoleLogger(LogLevel.info),
-          linkerJitMode: jit,
+          linkerJitMode: optJit,
           // This is a workaround until https://github.com/angular/angular/issues/42769 is fixed.
           sourceMapping: false,
         }) as PluginItem,
@@ -206,16 +231,16 @@ async function transformJavaScriptImpl(
 
   // Run Oxc linking and/or advanced optimizations in a single unified AST traversal pass
   const oxcLink = shouldLink && !useBabelLinker;
-  if (oxcLink || advancedOptimizations) {
+  if (oxcLink || optAdvancedOptimizations) {
     const sideEffectFree = options.sideEffects === false;
     const safeAngularPackage =
       sideEffectFree && /[\\/]node_modules[\\/]@angular[\\/]/.test(filename);
     const topLevelSafeMode = !safeAngularPackage;
 
     const result = transformWithOxc(filename, code, {
       link: oxcLink,
-      jit,
-      advancedOptimizations,
+      jit: optJit,
+      advancedOptimizations: optAdvancedOptimizations,
       sourcemap: useInputSourcemap,
       sideEffects: options.sideEffects,
       topLevelSafeMode,