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

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()));
+  });
+});