perf(@angular/build): release build resources early in non-watch mode (#33715)

Disposes the Angular compilation and bundler contexts within the build execution
for non-watch builds once bundling has completed. This terminates the TypeScript
compilation worker and JavaScript transformation workers before the post-bundle
steps (chunk optimization, i18n inlining, index generation) execute instead of
after all results have been emitted. Repeat compilation disposal calls now return
the in progress disposal to ensure all callers can await completion of the
underlying compiler shutdown. The result disposal also releases the incremental
build caches which can retain the emitted contents of every TypeScript file
within the program. This reduces the peak memory usage of the build for both
the non-watch early disposal and watch mode teardown.

Closes #33368

PR Close #33715

Author: alan-agius4

packages/angular/build/src/builders/application/execute-build.ts

@@ -156,6 +156,17 @@ export async function executeBuild(
     executionResult.extraWatchFiles.push(...componentStyleBundler.collectReferencedFiles());
   }
 
+  // In non-watch mode, the bundler rebuild contexts and Angular compilation
+  // are no longer needed once bundling completes. Dispose them early to free
+  // worker processes, TypeScript ASTs, and caches before post-bundling steps
+  // execute or before returning bundling errors.
+  if (!options.watch) {
+    // This is fire-and-forget so worker teardown runs concurrently in the background
+    // without blocking the critical path of post-bundle optimization steps.
+    // Any in-flight disposal is awaited in the builder action's finally block.
+    void Promise.allSettled([angularCompilationContext?.dispose(), executionResult.dispose()]);
+  }
+
   // Return if the bundling has errors
   if (bundlingResult.errors) {
     executionResult.addErrors(bundlingResult.errors);

packages/angular/build/src/tools/esbuild/angular/compilation-state.ts

@@ -46,13 +46,14 @@ export class AngularCompilationContext {
     this.#pendingCompilation = true;
   }
 
-  #disposed = false;
+  #disposal: Promise<void> | undefined;
 
-  async dispose(): Promise<void> {
-    if (this.#disposed) {
-      return;
-    }
-    this.#disposed = true;
+  dispose(): Promise<void> {
+    // Reuse any in progress disposal to ensure all callers can await completion
+    return (this.#disposal ??= this.#close());
+  }
+
+  async #close(): Promise<void> {
     this.markAsReady(true);
     try {
       await this.#compilation.close?.();

packages/angular/build/src/tools/esbuild/angular/source-file-cache.ts

@@ -25,6 +25,19 @@ export class SourceFileCache extends Map<string, ts.SourceFile> {
     super();
   }
 
+  /**
+   * Releases all cached content. The cached data is only needed for incremental
+   * rebuilds and can include the emitted contents of every TypeScript file in the
+   * program. The cache is repopulated if a build is performed after this is called.
+   */
+  dispose(): void {
+    this.clear();
+    this.modifiedFiles.clear();
+    this.typeScriptFileCache.clear();
+    this.loadResultCache.clear();
+    this.referencedFiles = undefined;
+  }
+
   invalidate(files: Iterable<string>): boolean {
     if (files !== this.modifiedFiles) {
       this.modifiedFiles.clear();

packages/angular/build/src/tools/esbuild/bundler-execution-result.ts

@@ -194,11 +194,21 @@ export class ExecutionResult {
     return changed;
   }
 
-  async dispose(): Promise<void> {
-    await Promise.allSettled([
-      ...this.rebuildContexts.typescriptContexts.map((context) => context.dispose()),
-      ...this.rebuildContexts.otherContexts.map((context) => context.dispose()),
-      this.componentStyleBundler.dispose(),
-    ]);
+  #disposal?: Promise<void>;
+
+  dispose(): Promise<void> {
+    return (this.#disposal ??= this.#dispose());
+  }
+
+  async #dispose(): Promise<void> {
+    try {
+      await Promise.allSettled([
+        ...this.rebuildContexts.typescriptContexts.map((context) => context.dispose()),
+        ...this.rebuildContexts.otherContexts.map((context) => context.dispose()),
+        this.componentStyleBundler.dispose(),
+      ]);
+    } finally {
+      this.codeBundleCache?.dispose();
+    }
   }
 }

packages/angular/build/src/tools/esbuild/load-result-cache.ts

@@ -90,4 +90,9 @@ export class MemoryLoadResultCache implements LoadResultCache {
     // are namespaced request paths and not disk-based file paths.
     return [...this.#fileDependencies.keys()];
   }
+
+  clear(): void {
+    this.#loadResults.clear();
+    this.#fileDependencies.clear();
+  }
 }