refactor(@angular/build): cap default i18n inlining concurrency to 8

Translation inlining and sourcemap remapping are CPU- and memory-intensive operations. When Piscina is initialized without explicit maxThreads, it defaults to floor(cpus * 1.5), spawning 18 to 48 worker threads on high-core machines. This excessive concurrency causes severe thread oversubscription, memory allocator lock contention, and high-core performance degradation under Promise.all barriers.

This change introduces maxInlinerWorkers in environment options defaulting to min(8, availableParallelism()) while preserving explicit overrides via NG_BUILD_MAX_WORKERS. Concurrency passed to I18nInliner in the application builder is bounded to maxInlinerWorkers, capping standalone workers and shared worker pools while honoring shared pool thread limits when lower.

(cherry picked from commit 93c118e)

Author: clydin

packages/angular/build/src/builders/application/i18n.ts

@@ -17,7 +17,7 @@ import {
 } from '../../tools/esbuild/bundler-execution-result';
 import { BuildOutputFileType, InitialFileRecord } from '../../tools/esbuild/bundler-files';
 import { I18nInliner } from '../../tools/esbuild/i18n-inliner';
-import { maxWorkers } from '../../utils/environment-options';
+import { maxInlinerWorkers } from '../../utils/environment-options';
 import { loadTranslations } from '../../utils/i18n-options';
 import { createTranslationLoader } from '../../utils/load-translations';
 import { createProjectResolver } from '../../utils/resolve-project';
@@ -51,7 +51,9 @@ export async function inlineI18n(
   const inliner = new I18nInliner(
     {
       missingTranslation: i18nOptions.missingTranslationBehavior ?? 'warning',
-      maxConcurrency: workerPool ? undefined : maxWorkers,
+      maxConcurrency: workerPool
+        ? Math.min(workerPool.maxThreads, maxInlinerWorkers)
+        : maxInlinerWorkers,
       persistentCachePath: cacheOptions.enabled ? cacheOptions.path : undefined,
       localizeVersion: i18nOptions.localizeVersion,
     },

packages/angular/build/src/utils/environment-options.ts

@@ -141,6 +141,15 @@ export const maxWorkers = customMaxWorkers ?? Math.max(availableParallelism() -
 export const maxTransformWorkers =
   customMaxWorkers ?? Math.max(1, Math.min(6, Math.floor(availableParallelism() / 4)));
 
+/**
+ * The maximum number of workers to use for i18n translation inlining.
+ * Translation inlining and sourcemap remapping are CPU- and memory-intensive operations.
+ * To prevent thread oversubscription, memory allocator lock contention, and high-core
+ * performance degradation, concurrency is capped at 8 unless overridden by
+ * `NG_BUILD_MAX_WORKERS`.
+ */
+export const maxInlinerWorkers = customMaxWorkers ?? Math.min(8, availableParallelism());
+
 /**
  * When `NG_BUILD_PARALLEL_TS` is set to `0` or `false`, parallel TypeScript compilation is disabled.
  */

packages/angular/build/src/utils/environment-options_spec.ts

@@ -181,3 +181,67 @@ describe('environment options - maxTransformWorkers', () => {
     expect(maxTransformWorkers).toBe(expected);
   });
 });
+
+describe('environment options - maxInlinerWorkers', () => {
+  const originalEnvValue = process.env['NG_BUILD_MAX_WORKERS'];
+
+  function loadEnvironmentOptions(): typeof import('./environment-options') {
+    delete require.cache[require.resolve('./environment-options')];
+
+    return require('./environment-options');
+  }
+
+  afterEach(() => {
+    if (originalEnvValue !== undefined) {
+      process.env['NG_BUILD_MAX_WORKERS'] = originalEnvValue;
+    } else {
+      delete process.env['NG_BUILD_MAX_WORKERS'];
+    }
+    delete require.cache[require.resolve('./environment-options')];
+  });
+
+  it('defaults maxInlinerWorkers to min(8, availableParallelism()) when NG_BUILD_MAX_WORKERS is unset', () => {
+    delete process.env['NG_BUILD_MAX_WORKERS'];
+    const { maxInlinerWorkers } = loadEnvironmentOptions();
+
+    expect(maxInlinerWorkers).toBe(Math.min(8, availableParallelism()));
+  });
+
+  it('uses configured positive integer when NG_BUILD_MAX_WORKERS is set', () => {
+    process.env['NG_BUILD_MAX_WORKERS'] = '4';
+    const { maxInlinerWorkers } = loadEnvironmentOptions();
+
+    expect(maxInlinerWorkers).toBe(4);
+  });
+
+  it('allows maxInlinerWorkers greater than 8 when explicitly configured', () => {
+    process.env['NG_BUILD_MAX_WORKERS'] = '16';
+    const { maxInlinerWorkers } = loadEnvironmentOptions();
+
+    expect(maxInlinerWorkers).toBe(16);
+  });
+
+  it('supports maxInlinerWorkers set to 1', () => {
+    process.env['NG_BUILD_MAX_WORKERS'] = '1';
+    const { maxInlinerWorkers } = loadEnvironmentOptions();
+
+    expect(maxInlinerWorkers).toBe(1);
+  });
+
+  it('falls back to min(8, availableParallelism()) when NG_BUILD_MAX_WORKERS is 0 or negative', () => {
+    process.env['NG_BUILD_MAX_WORKERS'] = '0';
+    const { maxInlinerWorkers: zeroWorkers } = loadEnvironmentOptions();
+    expect(zeroWorkers).toBe(Math.min(8, availableParallelism()));
+
+    process.env['NG_BUILD_MAX_WORKERS'] = '-4';
+    const { maxInlinerWorkers: negativeWorkers } = loadEnvironmentOptions();
+    expect(negativeWorkers).toBe(Math.min(8, availableParallelism()));
+  });
+
+  it('falls back to min(8, availableParallelism()) when NG_BUILD_MAX_WORKERS is invalid', () => {
+    process.env['NG_BUILD_MAX_WORKERS'] = 'invalid';
+    const { maxInlinerWorkers } = loadEnvironmentOptions();
+
+    expect(maxInlinerWorkers).toBe(Math.min(8, availableParallelism()));
+  });
+});