perf(@angular/build): implement sliding-window batching and worker translation eviction

In enterprise Angular applications with a high number of locales (e.g. 20–50+), deserializing translation dictionaries into native JavaScript objects across all worker threads simultaneously can lead to multi-gigabyte resident memory footprints in V8 worker heaps.

This change introduces sliding-window locale batching and lock-free translation eviction:
- `I18nInliner.inlineAll` processes locales in sliding windows of up to 8 locales each (`DEFAULT_LOCALE_WINDOW_SIZE`), capping peak memory while retaining maximum multi-locale batching throughput.
- Worker tasks receive an `activeLocales` array on each batch request. Workers automatically purge any cached translation dictionaries in `deserializedTranslations` that are not part of the active window when transitioning across window boundaries.

Author: clydin

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

@@ -84,6 +84,12 @@ interface InlineFileBatchRequest {
    * Typically true when all remaining locales for the file are processed in a single batch.
    */
   ephemeral?: boolean;
+
+  /**
+   * The list of active locales in the current inlining window. Any cached translation dictionaries
+   * not present in this list will be evicted from the Worker's memory cache.
+   */
+  activeLocales?: string[];
 }
 
 /**
@@ -237,6 +243,15 @@ export default async function inlineFile(request: InlineFileRequest) {
 export async function inlineFileBatch(
   request: InlineFileBatchRequest,
 ): Promise<InlineFileBatchResult> {
+  if (request.activeLocales) {
+    const activeSet = new Set(request.activeLocales);
+    for (const locale of deserializedTranslations.keys()) {
+      if (!activeSet.has(locale)) {
+        deserializedTranslations.delete(locale);
+      }
+    }
+  }
+
   const { code, metadata } = await loadFileData(request.filename, !request.ephemeral);
 
   // Parse the sourcemap once for the entire batch.

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

@@ -20,6 +20,12 @@ import { type PersistentCacheStore, createPersistentCacheStore } from './cache';
  */
 const LOCALIZE_KEYWORD = '$localize';
 
+/**
+ * The maximum number of locales to process concurrently in a single sliding window.
+ * This caps peak worker memory while maintaining multi-locale batching throughput.
+ */
+const DEFAULT_LOCALE_WINDOW_SIZE = 8;
+
 /**
  * Serializes the translation messages for a locale for transfer to an inliner Worker.
  *
@@ -218,101 +224,114 @@ export class I18nInliner {
       fileResultsByLocale.set(locale, new Map());
     }
 
-    // Pre-calculate cache key bases and serialized Blobs for each requested locale
-    const localeCacheBases = new Map<string, string>();
-    const localeBlobs = new Map<string, Blob | undefined>();
-
-    for (const { locale, translation, translationIntegrity } of localeList) {
-      localeBlobs.set(locale, serializeTranslation(translation));
-
-      if (this.#cache) {
-        localeCacheBases.set(
-          locale,
-          calculateHash(
-            JSON.stringify({
-              locale,
-              translation: translationIntegrity || translation,
-              missingTranslation,
-              shouldOptimize,
-              localizeVersion,
-            }),
-          ),
-        );
-      }
-    }
-
     const filenames = Array.from(this.#localizeFiles.keys()).filter(
       (name) => !name.endsWith('.map'),
     );
 
-    const cacheChecks: CacheCheckItem[] = [];
+    // Process locales in sliding windows to cap peak worker memory
+    for (let i = 0; i < localeList.length; i += DEFAULT_LOCALE_WINDOW_SIZE) {
+      const windowLocales = localeList.slice(i, i + DEFAULT_LOCALE_WINDOW_SIZE);
+      const activeLocales = windowLocales.map((item) => item.locale);
+      const isLastWindow = i + DEFAULT_LOCALE_WINDOW_SIZE >= localeList.length;
 
-    for (const filename of filenames) {
-      const file = this.#localizeFiles.get(filename);
-      assert(file !== undefined, 'Localize file must exist: ' + filename);
+      // 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 | undefined>();
 
-      for (const { locale } of localeList) {
-        let cacheKey: string | undefined;
-        let cachedResultPromise: Promise<TransformedFileResult | null> = Promise.resolve(null);
+      for (const { locale, translation, translationIntegrity } of windowLocales) {
+        localeBlobs.set(locale, serializeTranslation(translation));
 
         if (this.#cache) {
-          const fileCacheKeyBase = localeCacheBases.get(locale);
-          assert(fileCacheKeyBase !== undefined, 'Cache base must exist for locale: ' + locale);
+          localeCacheBases.set(
+            locale,
+            calculateHash(
+              JSON.stringify({
+                locale,
+                translation: translationIntegrity || translation,
+                missingTranslation,
+                shouldOptimize,
+                localizeVersion,
+              }),
+            ),
+          );
+        }
+      }
 
-          const hasher = createContentHash();
-          hasher.update(file.hash);
-          hasher.update(filename);
-          hasher.update(fileCacheKeyBase);
-          cacheKey = hasher.digest();
+      const cacheChecks: CacheCheckItem[] = [];
 
-          cachedResultPromise = this.#cache.get(cacheKey).catch(() => null);
-        }
+      for (const filename of filenames) {
+        const file = this.#localizeFiles.get(filename);
+        assert(file !== undefined, 'Localize file must exist: ' + filename);
 
-        cacheChecks.push({
-          filename,
-          locale,
-          cacheKey,
-          cachedResult: cachedResultPromise,
-        });
-      }
-    }
+        for (const { locale } of windowLocales) {
+          let cacheKey: string | undefined;
+          let cachedResultPromise: Promise<TransformedFileResult | null> = Promise.resolve(null);
 
-    // Await all cache checks
-    const resolvedChecks = await Promise.all(
-      cacheChecks.map(async (item) => ({
-        ...item,
-        result: await item.cachedResult,
-      })),
-    );
+          if (this.#cache) {
+            const fileCacheKeyBase = localeCacheBases.get(locale);
+            assert(fileCacheKeyBase !== undefined, 'Cache base must exist for locale: ' + locale);
 
-    // Group uncached items by filename
-    const uncachedByFile = new Map<
-      string,
-      Array<{ locale: string; cacheKey?: string; translation?: Blob }>
-    >();
+            const hasher = createContentHash();
+            hasher.update(file.hash);
+            hasher.update(filename);
+            hasher.update(fileCacheKeyBase);
+            cacheKey = hasher.digest();
 
-    for (const item of resolvedChecks) {
-      if (item.result) {
-        // Cache hit: store directly in locale file results
-        fileResultsByLocale.get(item.locale)?.set(item.filename, item.result);
-      } else {
-        // Cache miss: needs worker processing
-        let fileEntries = uncachedByFile.get(item.filename);
-        if (!fileEntries) {
-          fileEntries = [];
-          uncachedByFile.set(item.filename, fileEntries);
+            cachedResultPromise = this.#cache.get(cacheKey).catch(() => null);
+          }
+
+          cacheChecks.push({
+            filename,
+            locale,
+            cacheKey,
+            cachedResult: cachedResultPromise,
+          });
         }
-        fileEntries.push({
-          locale: item.locale,
-          cacheKey: item.cacheKey,
-          translation: localeBlobs.get(item.locale),
-        });
       }
-    }
 
-    // Adaptive 2D Sharding for uncached tasks
-    if (uncachedByFile.size > 0) {
-      await this.#processUncachedBatches(uncachedByFile, localeList.length, fileResultsByLocale);
+      // Await all cache checks for this window
+      const resolvedChecks = await Promise.all(
+        cacheChecks.map(async (item) => ({
+          ...item,
+          result: await item.cachedResult,
+        })),
+      );
+
+      // Group uncached items by filename for this window
+      const uncachedByFile = new Map<
+        string,
+        Array<{ locale: string; cacheKey?: string; translation?: Blob }>
+      >();
+
+      for (const item of resolvedChecks) {
+        if (item.result) {
+          // Cache hit: store directly in locale file results
+          fileResultsByLocale.get(item.locale)?.set(item.filename, item.result);
+        } else {
+          // Cache miss: needs worker processing
+          let fileEntries = uncachedByFile.get(item.filename);
+          if (!fileEntries) {
+            fileEntries = [];
+            uncachedByFile.set(item.filename, fileEntries);
+          }
+          fileEntries.push({
+            locale: item.locale,
+            cacheKey: item.cacheKey,
+            translation: localeBlobs.get(item.locale),
+          });
+        }
+      }
+
+      // Adaptive 2D Sharding for uncached tasks in this window
+      if (uncachedByFile.size > 0) {
+        await this.#processUncachedBatches(
+          uncachedByFile,
+          windowLocales.length,
+          fileResultsByLocale,
+          activeLocales,
+          isLastWindow,
+        );
+      }
     }
 
     // Assemble final results in deterministic order per locale
@@ -366,6 +385,8 @@ export class I18nInliner {
     uncachedByFile: Map<string, Array<{ locale: string; cacheKey?: string; translation?: Blob }>>,
     localeCount: number,
     fileResultsByLocale: Map<string, Map<string, TransformedFileResult>>,
+    activeLocales?: string[],
+    isLastWindow = true,
   ): Promise<void> {
     const workerCount = this.#workerPool.maxThreads || 1;
     const targetTaskCount = Math.max(uncachedByFile.size, workerCount * 2);
@@ -377,7 +398,7 @@ export class I18nInliner {
     const workerTasks: Promise<void>[] = [];
 
     for (const [filename, entries] of uncachedByFile) {
-      const ephemeral = entries.length <= localesPerBatch;
+      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 () => {
@@ -389,6 +410,7 @@ export class I18nInliner {
                 translation: e.translation,
               })),
               ephemeral,
+              activeLocales,
             },
             { name: 'inlineFileBatch' },
           )) as {

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

@@ -516,4 +516,28 @@ describe('I18nInliner', () => {
       await fs.rm(cacheDir, { recursive: true, force: true });
     }
   });
+
+  it('inlines across sliding windows when locale count exceeds window size', async () => {
+    const locales = Array.from({ length: 20 }, (_, i) => ({
+      locale: `locale-${i}`,
+      translation: { greeting: translationFor(`Hello ${i}`) },
+    }));
+
+    const inliner = new I18nInliner(
+      {
+        missingTranslation: 'warning',
+        outputFiles: [browserFile('main.js', GREETING_SOURCE)],
+      },
+      2,
+    );
+
+    const results = await inliner.inlineAll(locales);
+
+    expect(results.size).toBe(20);
+    for (let i = 0; i < 20; i++) {
+      const localeResult = results.get(`locale-${i}`);
+      expect(localeResult?.errors).toEqual([]);
+      expect(findFile(localeResult?.outputFiles ?? [], 'main.js').text).toContain(`"Hello ${i}"`);
+    }
+  });
 });