From 3f8aa9d8c7dc7eff06516c04ba08764bb044cb6b Mon Sep 17 00:00:00 2001
From: Alan Agius <alanagius@google.com>
Date: Fri, 8 Sep 2023 09:34:22 +0000
Subject: [PATCH] feat(@schematics/angular): update` ng new` to use the esbuild
 application builder based builder

This commit updates the `ng generate application` to use the esbuild `application` builder. This also updates the schematics to support both `browser` and `application` builders.

BREAKING CHANGE: `rootModuleClassName`, `rootModuleFileName` and `main` options have been removed from the public `pwa` and `app-shell` schematics.
---
 packages/angular/pwa/pwa/index.ts             |   5 +-
 packages/angular/pwa/pwa/index_spec.ts        | 183 ++++++-------
 packages/angular/ssr/package.json             |   3 +
 .../application-builder/server.ts.template    |  53 ++++
 .../{ => server-builder}/server.ts.template   |   4 +-
 .../angular/ssr/schematics/ng-add/index.ts    | 155 +++++++----
 .../ssr/schematics/ng-add/index_spec.ts       | 100 +++++--
 .../angular/ssr/schematics/ng-add/schema.json |  17 --
 .../src/builders/app-shell/render-worker.ts   |   8 +-
 .../src/builders/prerender/render-worker.ts   |  28 +-
 .../schematics/angular/app-shell/index.ts     | 101 +++----
 .../angular/app-shell/index_spec.ts           |  88 +++---
 .../schematics/angular/app-shell/schema.json  |  21 --
 .../schematics/angular/application/index.ts   |   7 +-
 .../angular/application/index_spec.ts         |   4 +-
 packages/schematics/angular/collection.json   |   8 +-
 .../schematics/angular/environments/index.ts  |   8 +-
 .../angular/environments/index_spec.ts        |  28 +-
 .../files/root/tsconfig.server.json.template  |   2 +-
 .../src/app/app.module.server.ts.template}    |   2 +-
 .../server/files/src/main.server.ts.template  |   1 +
 .../app/app.config.server.ts.template         |   0
 .../standalone-src/main.server.ts.template    |   0
 .../angular/{universal => server}/index.ts    | 109 ++++++--
 .../schematics/angular/server/index_spec.ts   | 254 ++++++++++++++++++
 .../schematics/angular/server/schema.json     |  23 ++
 .../angular/service-worker/index.ts           |  62 ++---
 .../angular/service-worker/index_spec.ts      |  79 ++++--
 .../src/__main@stripTsExtension__.ts.template |   2 -
 .../angular/universal/index_spec.ts           | 242 -----------------
 .../schematics/angular/universal/schema.json  |  40 ---
 .../angular/utility/standalone/util.ts        |   6 +-
 .../angular/utility/workspace-models.ts       |   3 +-
 .../workspace/files/tsconfig.json.template    |   1 +
 .../server/platform-server-build-optimizer.ts |   2 +-
 .../server/platform-server-standalone.ts      |   2 +-
 .../e2e/tests/build/server/platform-server.ts |   2 +-
 37 files changed, 953 insertions(+), 700 deletions(-)
 create mode 100644 packages/angular/ssr/schematics/ng-add/files/application-builder/server.ts.template
 rename packages/angular/ssr/schematics/ng-add/files/{ => server-builder}/server.ts.template (92%)
 rename packages/schematics/angular/{universal => server}/files/root/tsconfig.server.json.template (88%)
 rename packages/schematics/angular/{universal/files/src/app/__rootModuleFileName__.template => server/files/src/app/app.module.server.ts.template} (86%)
 create mode 100644 packages/schematics/angular/server/files/src/main.server.ts.template
 rename packages/schematics/angular/{universal => server}/files/standalone-src/app/app.config.server.ts.template (100%)
 rename packages/schematics/angular/{universal => server}/files/standalone-src/main.server.ts.template (100%)
 rename packages/schematics/angular/{universal => server}/index.ts (60%)
 create mode 100644 packages/schematics/angular/server/index_spec.ts
 create mode 100644 packages/schematics/angular/server/schema.json
 delete mode 100644 packages/schematics/angular/universal/files/src/__main@stripTsExtension__.ts.template
 delete mode 100644 packages/schematics/angular/universal/index_spec.ts
 delete mode 100644 packages/schematics/angular/universal/schema.json

diff --git a/packages/angular/pwa/pwa/index.ts b/packages/angular/pwa/pwa/index.ts
index 2b4996f0f324..0389e686a40e 100644
--- a/packages/angular/pwa/pwa/index.ts
+++ b/packages/angular/pwa/pwa/index.ts
@@ -114,7 +114,10 @@ export default function (options: PwaOptions): Rule {
     const buildTargets = [];
     const testTargets = [];
     for (const target of project.targets.values()) {
-      if (target.builder === '@angular-devkit/build-angular:browser') {
+      if (
+        target.builder === '@angular-devkit/build-angular:browser' ||
+        target.builder === '@angular-devkit/build-angular:application'
+      ) {
         buildTargets.push(target);
       } else if (target.builder === '@angular-devkit/build-angular:karma') {
         testTargets.push(target);
diff --git a/packages/angular/pwa/pwa/index_spec.ts b/packages/angular/pwa/pwa/index_spec.ts
index 9657b0493b31..e6b0d4e576bb 100644
--- a/packages/angular/pwa/pwa/index_spec.ts
+++ b/packages/angular/pwa/pwa/index_spec.ts
@@ -52,122 +52,123 @@ describe('PWA Schematic', () => {
     );
   });
 
-  it('should run the service worker schematic', (done) => {
-    schematicRunner
-      .runSchematic('ng-add', defaultOptions, appTree)
-
-      .then((tree) => {
-        const configText = tree.readContent('/angular.json');
-        const config = JSON.parse(configText);
-        const swFlag = config.projects.bar.architect.build.options.serviceWorker;
-        expect(swFlag).toEqual(true);
-        done();
-      }, done.fail);
-  });
-
-  it('should create icon files', (done) => {
+  it('should create icon files', async () => {
     const dimensions = [72, 96, 128, 144, 152, 192, 384, 512];
     const iconPath = '/projects/bar/src/assets/icons/icon-';
-    schematicRunner
-      .runSchematic('ng-add', defaultOptions, appTree)
-
-      .then((tree) => {
-        dimensions.forEach((d) => {
-          const path = `${iconPath}${d}x${d}.png`;
-          expect(tree.exists(path)).toEqual(true);
-        });
-        done();
-      }, done.fail);
+    const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
+
+    dimensions.forEach((d) => {
+      const path = `${iconPath}${d}x${d}.png`;
+      expect(tree.exists(path)).toBeTrue();
+    });
   });
 
-  it('should create a manifest file', (done) => {
-    schematicRunner
-      .runSchematic('ng-add', defaultOptions, appTree)
+  it('should run the service worker schematic', async () => {
+    const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
+    const configText = tree.readContent('/angular.json');
+    const config = JSON.parse(configText);
+    const swFlag = config.projects.bar.architect.build.configurations.production.serviceWorker;
 
-      .then((tree) => {
-        expect(tree.exists('/projects/bar/src/manifest.webmanifest')).toEqual(true);
-        done();
-      }, done.fail);
+    expect(swFlag).toBe('projects/bar/ngsw-config.json');
   });
 
-  it('should set the name & short_name in the manifest file', (done) => {
-    schematicRunner
-      .runSchematic('ng-add', defaultOptions, appTree)
+  it('should create a manifest file', async () => {
+    const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
+    expect(tree.exists('/projects/bar/src/manifest.webmanifest')).toBeTrue();
+  });
+
+  it('should set the name & short_name in the manifest file', async () => {
+    const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
 
-      .then((tree) => {
-        const manifestText = tree.readContent('/projects/bar/src/manifest.webmanifest');
-        const manifest = JSON.parse(manifestText);
+    const manifestText = tree.readContent('/projects/bar/src/manifest.webmanifest');
+    const manifest = JSON.parse(manifestText);
 
-        expect(manifest.name).toEqual(defaultOptions.title);
-        expect(manifest.short_name).toEqual(defaultOptions.title);
-        done();
-      }, done.fail);
+    expect(manifest.name).toEqual(defaultOptions.title);
+    expect(manifest.short_name).toEqual(defaultOptions.title);
   });
 
-  it('should set the name & short_name in the manifest file when no title provided', (done) => {
+  it('should set the name & short_name in the manifest file when no title provided', async () => {
     const options = { ...defaultOptions, title: undefined };
-    schematicRunner
-      .runSchematic('ng-add', options, appTree)
+    const tree = await schematicRunner.runSchematic('ng-add', options, appTree);
 
-      .then((tree) => {
-        const manifestText = tree.readContent('/projects/bar/src/manifest.webmanifest');
-        const manifest = JSON.parse(manifestText);
+    const manifestText = tree.readContent('/projects/bar/src/manifest.webmanifest');
+    const manifest = JSON.parse(manifestText);
 
-        expect(manifest.name).toEqual(defaultOptions.project);
-        expect(manifest.short_name).toEqual(defaultOptions.project);
-        done();
-      }, done.fail);
+    expect(manifest.name).toEqual(defaultOptions.project);
+    expect(manifest.short_name).toEqual(defaultOptions.project);
   });
 
-  it('should update the index file', (done) => {
-    schematicRunner
-      .runSchematic('ng-add', defaultOptions, appTree)
-
-      .then((tree) => {
-        const content = tree.readContent('projects/bar/src/index.html');
+  it('should update the index file', async () => {
+    const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
+    const content = tree.readContent('projects/bar/src/index.html');
 
-        expect(content).toMatch(/<link rel="manifest" href="manifest.webmanifest">/);
-        expect(content).toMatch(/<meta name="theme-color" content="#1976d2">/);
-        expect(content).toMatch(
-          /<noscript>Please enable JavaScript to continue using this application.<\/noscript>/,
-        );
-        done();
-      }, done.fail);
+    expect(content).toMatch(/<link rel="manifest" href="manifest.webmanifest">/);
+    expect(content).toMatch(/<meta name="theme-color" content="#1976d2">/);
+    expect(content).toMatch(
+      /<noscript>Please enable JavaScript to continue using this application.<\/noscript>/,
+    );
   });
 
-  it('should not add noscript element to the index file if already present', (done) => {
+  it('should not add noscript element to the index file if already present', async () => {
     let index = appTree.readContent('projects/bar/src/index.html');
     index = index.replace('</body>', '<noscript>NO JAVASCRIPT</noscript></body>');
     appTree.overwrite('projects/bar/src/index.html', index);
-    schematicRunner
-      .runSchematic('ng-add', defaultOptions, appTree)
-
-      .then((tree) => {
-        const content = tree.readContent('projects/bar/src/index.html');
-
-        expect(content).toMatch(/<link rel="manifest" href="manifest.webmanifest">/);
-        expect(content).toMatch(/<meta name="theme-color" content="#1976d2">/);
-        expect(content).not.toMatch(
-          /<noscript>Please enable JavaScript to continue using this application.<\/noscript>/,
-        );
-        expect(content).toMatch(/<noscript>NO JAVASCRIPT<\/noscript>/);
-        done();
-      }, done.fail);
+
+    const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
+    const content = tree.readContent('projects/bar/src/index.html');
+
+    expect(content).toMatch(/<link rel="manifest" href="manifest.webmanifest">/);
+    expect(content).toMatch(/<meta name="theme-color" content="#1976d2">/);
+    expect(content).not.toMatch(
+      /<noscript>Please enable JavaScript to continue using this application.<\/noscript>/,
+    );
+    expect(content).toMatch(/<noscript>NO JAVASCRIPT<\/noscript>/);
   });
 
-  it('should update the build and test assets configuration', (done) => {
-    schematicRunner
-      .runSchematic('ng-add', defaultOptions, appTree)
+  it('should update the build and test assets configuration', async () => {
+    const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
+    const configText = tree.readContent('/angular.json');
+    const config = JSON.parse(configText);
+    const targets = config.projects.bar.architect;
 
-      .then((tree) => {
-        const configText = tree.readContent('/angular.json');
-        const config = JSON.parse(configText);
-        const targets = config.projects.bar.architect;
+    ['build', 'test'].forEach((target) => {
+      expect(targets[target].options.assets).toContain('projects/bar/src/manifest.webmanifest');
+    });
+  });
 
-        ['build', 'test'].forEach((target) => {
-          expect(targets[target].options.assets).toContain('projects/bar/src/manifest.webmanifest');
-        });
-        done();
-      }, done.fail);
+  describe('Legacy browser builder', () => {
+    function convertBuilderToLegacyBrowser(): void {
+      const config = JSON.parse(appTree.readContent('/angular.json'));
+      const build = config.projects.bar.architect.build;
+
+      build.builder = '@angular-devkit/build-angular:browser';
+      build.options = {
+        ...build.options,
+        main: build.options.browser,
+        browser: undefined,
+      };
+
+      build.configurations.development = {
+        ...build.configurations.development,
+        vendorChunk: true,
+        namedChunks: true,
+        buildOptimizer: false,
+      };
+
+      appTree.overwrite('/angular.json', JSON.stringify(config, undefined, 2));
+    }
+
+    beforeEach(() => {
+      convertBuilderToLegacyBrowser();
+    });
+
+    it('should run the service worker schematic', async () => {
+      const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
+      const configText = tree.readContent('/angular.json');
+      const config = JSON.parse(configText);
+      const swFlag = config.projects.bar.architect.build.options.serviceWorker;
+
+      expect(swFlag).toBeTrue();
+    });
   });
 });
diff --git a/packages/angular/ssr/package.json b/packages/angular/ssr/package.json
index fbfc95470704..fc4962fe9a87 100644
--- a/packages/angular/ssr/package.json
+++ b/packages/angular/ssr/package.json
@@ -9,6 +9,9 @@
     "ssr",
     "universal"
   ],
+  "ng-add": {
+    "save": "dependencies"
+  },
   "dependencies": {
     "critters": "0.0.20",
     "tslib": "^2.3.0"
diff --git a/packages/angular/ssr/schematics/ng-add/files/application-builder/server.ts.template b/packages/angular/ssr/schematics/ng-add/files/application-builder/server.ts.template
new file mode 100644
index 000000000000..79d3b09f00d0
--- /dev/null
+++ b/packages/angular/ssr/schematics/ng-add/files/application-builder/server.ts.template
@@ -0,0 +1,53 @@
+import { APP_BASE_HREF } from '@angular/common';
+import { CommonEngine } from '@angular/ssr';
+import express from 'express';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import <% if (isStandalone) { %>bootstrap<% } else { %>AppServerModule<% } %> from './src/main.server';
+
+// The Express app is exported so that it can be used by serverless Functions.
+export function app(): express.Express {
+  const server = express();
+  const browserDistFolder = dirname(fileURLToPath(import.meta.url));
+  const indexHtml = join(browserDistFolder, 'index.server.html');
+
+  const commonEngine = new CommonEngine();
+
+  server.set('view engine', 'html');
+  server.set('views', browserDistFolder);
+
+  // Example Express Rest API endpoints
+  // server.get('/api/**', (req, res) => { });
+  // Serve static files from /browser
+  server.get('*.*', express.static(browserDistFolder, {
+    maxAge: '1y'
+  }));
+
+  // All regular routes use the Angular engine
+  server.get('*', (req, res, next) => {
+    commonEngine
+      .render({
+        <% if (isStandalone) { %>bootstrap<% } else { %>bootstrap: AppServerModule<% } %>,
+        documentFilePath: indexHtml,
+        url: req.originalUrl,
+        publicPath: browserDistFolder,
+        providers: [{ provide: APP_BASE_HREF, useValue: req.baseUrl }],
+      })
+      .then((html) => res.send(html))
+      .catch((err) => next(err));
+  });
+
+  return server;
+}
+
+function run(): void {
+  const port = process.env['PORT'] || 4000;
+
+  // Start up the Node server
+  const server = app();
+  server.listen(port, () => {
+    console.log(`Node Express server listening on http://localhost:${port}`);
+  });
+}
+
+run();
diff --git a/packages/angular/ssr/schematics/ng-add/files/server.ts.template b/packages/angular/ssr/schematics/ng-add/files/server-builder/server.ts.template
similarity index 92%
rename from packages/angular/ssr/schematics/ng-add/files/server.ts.template
rename to packages/angular/ssr/schematics/ng-add/files/server-builder/server.ts.template
index b414f4fabe18..d028b46fd8bc 100644
--- a/packages/angular/ssr/schematics/ng-add/files/server.ts.template
+++ b/packages/angular/ssr/schematics/ng-add/files/server-builder/server.ts.template
@@ -5,7 +5,7 @@ import { CommonEngine } from '@angular/ssr';
 import * as express from 'express';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import <% if (isStandalone) { %>bootstrap<% } else { %>{ AppServerModule }<% } %> from './src/<%= stripTsExtension(main) %>';
+import <% if (isStandalone) { %>bootstrap<% } else { %>AppServerModule<% } %> from './src/main.server';
 
 // The Express app is exported so that it can be used by serverless Functions.
 export function app(): express.Express {
@@ -64,4 +64,4 @@ if (moduleFilename === __filename || moduleFilename.includes('iisnode')) {
   run();
 }
 
-<% if (isStandalone) { %>export default bootstrap;<% } else { %>export * from './src/<%= stripTsExtension(main) %>';<% } %>
+<% if (isStandalone) { %>export default bootstrap;<% } else { %>export * from './src/main.server';<% } %>
diff --git a/packages/angular/ssr/schematics/ng-add/index.ts b/packages/angular/ssr/schematics/ng-add/index.ts
index 7134483cf72b..f6bdd5d06f27 100644
--- a/packages/angular/ssr/schematics/ng-add/index.ts
+++ b/packages/angular/ssr/schematics/ng-add/index.ts
@@ -20,12 +20,14 @@ import {
   noop,
   url,
 } from '@angular-devkit/schematics';
-import { Schema as UniversalOptions } from '@schematics/angular/universal/schema';
+import { Schema as ServerOptions } from '@schematics/angular/server/schema';
 import { DependencyType, addDependency, updateWorkspace } from '@schematics/angular/utility';
 import { JSONFile } from '@schematics/angular/utility/json-file';
 import { isStandaloneApp } from '@schematics/angular/utility/ng-ast-utils';
 import { targetBuildNotFoundError } from '@schematics/angular/utility/project-targets';
-import { BrowserBuilderOptions } from '@schematics/angular/utility/workspace-models';
+import { getMainFilePath } from '@schematics/angular/utility/standalone/util';
+import { getWorkspace } from '@schematics/angular/utility/workspace';
+import { Builders } from '@schematics/angular/utility/workspace-models';
 import * as ts from 'typescript';
 
 import { latestVersions } from '../utility/latest-versions';
@@ -35,15 +37,14 @@ import {
   getImportOfIdentifier,
   getOutputPath,
   getProject,
-  stripTsExtension,
 } from '../utility/utils';
 
-import { Schema as AddUniversalOptions } from './schema';
+import { Schema as AddServerOptions } from './schema';
 
 const SERVE_SSR_TARGET_NAME = 'serve-ssr';
 const PRERENDER_TARGET_NAME = 'prerender';
 
-function addScriptsRule(options: AddUniversalOptions): Rule {
+function addScriptsRule(options: AddServerOptions): Rule {
   return async (host) => {
     const pkgPath = '/package.json';
     const buffer = host.read(pkgPath);
@@ -65,7 +66,55 @@ function addScriptsRule(options: AddUniversalOptions): Rule {
   };
 }
 
-function updateWorkspaceConfigRule(options: AddUniversalOptions): Rule {
+function updateApplicationBuilderTsConfigRule(options: AddServerOptions): Rule {
+  return async (host) => {
+    const project = await getProject(host, options.project);
+    const buildTarget = project.targets.get('build');
+    if (!buildTarget || !buildTarget.options) {
+      return;
+    }
+
+    const tsConfigPath = buildTarget.options.tsConfig;
+    if (!tsConfigPath || typeof tsConfigPath !== 'string') {
+      // No tsconfig path
+      return;
+    }
+
+    const tsConfig = new JSONFile(host, tsConfigPath);
+    const filesAstNode = tsConfig.get(['files']);
+    const serverFilePath = 'server.ts';
+    if (Array.isArray(filesAstNode) && !filesAstNode.some(({ text }) => text === serverFilePath)) {
+      tsConfig.modify(['files'], [...filesAstNode, serverFilePath]);
+    }
+  };
+}
+
+function updateApplicationBuilderWorkspaceConfigRule(
+  projectRoot: string,
+  options: AddServerOptions,
+): Rule {
+  return () => {
+    return updateWorkspace((workspace) => {
+      const buildTarget = workspace.projects.get(options.project)?.targets.get('build');
+      if (!buildTarget) {
+        return;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const prodConfig = buildTarget.configurations?.production as Record<string, any>;
+      if (!prodConfig) {
+        throw new SchematicsException(
+          `A "production" configuration is not defined for the "build" builder.`,
+        );
+      }
+
+      prodConfig.prerender = true;
+      (prodConfig.ssr ??= {}).entry = join(normalize(projectRoot), 'server.ts');
+    });
+  };
+}
+
+function updateWebpackBuilderWorkspaceConfigRule(options: AddServerOptions): Rule {
   return () => {
     return updateWorkspace((workspace) => {
       const projectName = options.project;
@@ -127,7 +176,7 @@ function updateWorkspaceConfigRule(options: AddUniversalOptions): Rule {
   };
 }
 
-function updateServerTsConfigRule(options: AddUniversalOptions): Rule {
+function updateWebpackBuilderServerTsConfigRule(options: AddServerOptions): Rule {
   return async (host) => {
     const project = await getProject(host, options.project);
     const serverTarget = project.targets.get('server');
@@ -150,7 +199,7 @@ function updateServerTsConfigRule(options: AddUniversalOptions): Rule {
   };
 }
 
-function routingInitialNavigationRule(options: UniversalOptions): Rule {
+function routingInitialNavigationRule(options: ServerOptions): Rule {
   return async (host) => {
     const project = await getProject(host, options.project);
     const serverTarget = project.targets.get('server');
@@ -254,62 +303,72 @@ function routingInitialNavigationRule(options: UniversalOptions): Rule {
 }
 
 function addDependencies(): Rule {
-  return (_host: Tree) => {
-    return chain([
-      addDependency('express', latestVersions['express'], {
-        type: DependencyType.Default,
-      }),
-      addDependency('@types/express', latestVersions['@types/express'], {
-        type: DependencyType.Dev,
-      }),
-    ]);
-  };
+  return chain([
+    addDependency('express', latestVersions['express'], {
+      type: DependencyType.Default,
+    }),
+    addDependency('@types/express', latestVersions['@types/express'], {
+      type: DependencyType.Dev,
+    }),
+  ]);
 }
 
-function addServerFile(options: UniversalOptions, isStandalone: boolean): Rule {
+function addServerFile(options: ServerOptions, isStandalone: boolean): Rule {
   return async (host) => {
     const project = await getProject(host, options.project);
     const browserDistDirectory = await getOutputPath(host, options.project, 'build');
 
     return mergeWith(
-      apply(url('./files'), [
-        applyTemplates({
-          ...strings,
-          ...options,
-          stripTsExtension,
-          browserDistDirectory,
-          isStandalone,
-        }),
-        move(project.root),
-      ]),
+      apply(
+        url(
+          `./files/${
+            project?.targets?.get('build')?.builder === Builders.Application
+              ? 'application-builder'
+              : 'server-builder'
+          }`,
+        ),
+        [
+          applyTemplates({
+            ...strings,
+            ...options,
+            browserDistDirectory,
+            isStandalone,
+          }),
+          move(project.root),
+        ],
+      ),
     );
   };
 }
 
-export default function (options: AddUniversalOptions): Rule {
+export default function (options: AddServerOptions): Rule {
   return async (host) => {
-    const project = await getProject(host, options.project);
-    const universalOptions = {
-      ...options,
-      skipInstall: true,
-    };
-    const clientBuildTarget = project.targets.get('build');
-    if (!clientBuildTarget) {
+    const browserEntryPoint = await getMainFilePath(host, options.project);
+    const isStandalone = isStandaloneApp(host, browserEntryPoint);
+
+    const workspace = await getWorkspace(host);
+    const clientProject = workspace.projects.get(options.project);
+    if (!clientProject) {
       throw targetBuildNotFoundError();
     }
-
-    const clientBuildOptions = (clientBuildTarget.options ||
-      {}) as unknown as BrowserBuilderOptions;
-
-    const isStandalone = isStandaloneApp(host, clientBuildOptions.main);
+    const isUsingApplicationBuilder =
+      clientProject.targets.get('build')?.builder === Builders.Application;
 
     return chain([
-      project.targets.has('server')
-        ? noop()
-        : externalSchematic('@schematics/angular', 'universal', universalOptions),
-      addScriptsRule(options),
-      updateServerTsConfigRule(options),
-      updateWorkspaceConfigRule(options),
+      externalSchematic('@schematics/angular', 'server', {
+        ...options,
+        skipInstall: true,
+      }),
+      ...(isUsingApplicationBuilder
+        ? [
+            updateApplicationBuilderWorkspaceConfigRule(clientProject.root, options),
+            updateApplicationBuilderTsConfigRule(options),
+          ]
+        : [
+            addScriptsRule(options),
+            updateWebpackBuilderServerTsConfigRule(options),
+            updateWebpackBuilderWorkspaceConfigRule(options),
+          ]),
       isStandalone ? noop() : routingInitialNavigationRule(options),
       addServerFile(options, isStandalone),
       addDependencies(),
diff --git a/packages/angular/ssr/schematics/ng-add/index_spec.ts b/packages/angular/ssr/schematics/ng-add/index_spec.ts
index 9085edd01fff..865e3df4faaf 100644
--- a/packages/angular/ssr/schematics/ng-add/index_spec.ts
+++ b/packages/angular/ssr/schematics/ng-add/index_spec.ts
@@ -7,15 +7,14 @@
  */
 
 import { tags } from '@angular-devkit/core';
-import { Tree } from '@angular-devkit/schematics';
 // eslint-disable-next-line import/no-extraneous-dependencies
-import { SchematicTestRunner } from '@angular-devkit/schematics/testing';
+import { SchematicTestRunner, UnitTestTree } from '@angular-devkit/schematics/testing';
 
 import { join } from 'node:path';
-import { Schema as UniversalOptions } from './schema';
+import { Schema as ServerOptions } from './schema';
 
-describe('Universal Schematic', () => {
-  const defaultOptions: UniversalOptions = {
+describe('SSR Schematic', () => {
+  const defaultOptions: ServerOptions = {
     project: 'test-app',
   };
 
@@ -24,7 +23,7 @@ describe('Universal Schematic', () => {
     require.resolve(join(__dirname, '../collection.json')),
   );
 
-  let appTree: Tree;
+  let appTree: UnitTestTree;
 
   const workspaceOptions = {
     name: 'workspace',
@@ -73,28 +72,13 @@ describe('Universal Schematic', () => {
       expect((schematicRunner.tasks[0].options as { command: string }).command).toBe('install');
     });
 
-    it(`should update 'tsconfig.server.json' files with Express main file`, async () => {
+    it(`should update 'tsconfig.app.json' files with Express main file`, async () => {
       const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
-
-      const { files } = tree.readJson('/projects/test-app/tsconfig.server.json') as {
+      const { files } = tree.readJson('/projects/test-app/tsconfig.app.json') as {
         files: string[];
       };
 
-      expect(files).toEqual(['src/main.server.ts', 'server.ts']);
-    });
-
-    it(`should add export to main file in 'server.ts'`, async () => {
-      const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
-
-      const content = tree.readContent('/projects/test-app/server.ts');
-      expect(content).toContain(`export * from './src/main.server'`);
-    });
-
-    it(`should add correct value to 'distFolder'`, async () => {
-      const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
-
-      const content = tree.readContent('/projects/test-app/server.ts');
-      expect(content).toContain(`const distFolder = join(process.cwd(), 'dist/test-app/browser');`);
+      expect(files).toEqual(['src/main.ts', 'src/main.server.ts', 'server.ts']);
     });
 
     it(`should import 'AppServerModule' from 'main.server.ts'`, async () => {
@@ -102,7 +86,7 @@ describe('Universal Schematic', () => {
 
       const filePath = '/projects/test-app/server.ts';
       const content = tree.readContent(filePath);
-      expect(content).toContain(`import { AppServerModule } from './src/main.server';`);
+      expect(content).toContain(`import AppServerModule from './src/main.server';`);
     });
 
     it(`should pass 'AppServerModule' in the bootstrap parameter.`, async () => {
@@ -154,4 +138,70 @@ describe('Universal Schematic', () => {
       `);
     });
   });
+
+  describe('Legacy browser builder', () => {
+    function convertBuilderToLegacyBrowser(): void {
+      const config = JSON.parse(appTree.readContent('/angular.json'));
+      const build = config.projects['test-app'].architect.build;
+
+      build.builder = '@angular-devkit/build-angular:browser';
+      build.options = {
+        ...build.options,
+        main: build.options.browser,
+        browser: undefined,
+      };
+
+      build.configurations.development = {
+        ...build.configurations.development,
+        vendorChunk: true,
+        namedChunks: true,
+        buildOptimizer: false,
+      };
+
+      appTree.overwrite('/angular.json', JSON.stringify(config, undefined, 2));
+    }
+
+    beforeEach(async () => {
+      appTree = await schematicRunner.runExternalSchematic(
+        '@schematics/angular',
+        'application',
+        {
+          name: 'test-app',
+          inlineStyle: false,
+          inlineTemplate: false,
+          routing: false,
+          style: 'css',
+          skipTests: false,
+          standalone: false,
+        },
+        appTree,
+      );
+
+      convertBuilderToLegacyBrowser();
+    });
+
+    it(`should update 'tsconfig.server.json' files with Express main file`, async () => {
+      const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
+
+      const { files } = tree.readJson('/projects/test-app/tsconfig.server.json') as {
+        files: string[];
+      };
+
+      expect(files).toEqual(['src/main.server.ts', 'server.ts']);
+    });
+
+    it(`should add export to main file in 'server.ts'`, async () => {
+      const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
+
+      const content = tree.readContent('/projects/test-app/server.ts');
+      expect(content).toContain(`export * from './src/main.server'`);
+    });
+
+    it(`should add correct value to 'distFolder'`, async () => {
+      const tree = await schematicRunner.runSchematic('ng-add', defaultOptions, appTree);
+
+      const content = tree.readContent('/projects/test-app/server.ts');
+      expect(content).toContain(`const distFolder = join(process.cwd(), 'dist/test-app/browser');`);
+    });
+  });
 });
diff --git a/packages/angular/ssr/schematics/ng-add/schema.json b/packages/angular/ssr/schematics/ng-add/schema.json
index b43f616c3e70..b239a9e92168 100644
--- a/packages/angular/ssr/schematics/ng-add/schema.json
+++ b/packages/angular/ssr/schematics/ng-add/schema.json
@@ -11,23 +11,6 @@
         "$source": "projectName"
       }
     },
-    "main": {
-      "type": "string",
-      "format": "path",
-      "description": "The name of the main entry-point file.",
-      "default": "main.server.ts"
-    },
-    "rootModuleFileName": {
-      "type": "string",
-      "format": "path",
-      "description": "The name of the root module file",
-      "default": "app.server.module.ts"
-    },
-    "rootModuleClassName": {
-      "type": "string",
-      "description": "The name of the root module class.",
-      "default": "AppServerModule"
-    },
     "skipInstall": {
       "description": "Skip installing dependency packages.",
       "type": "boolean",
diff --git a/packages/angular_devkit/build_angular/src/builders/app-shell/render-worker.ts b/packages/angular_devkit/build_angular/src/builders/app-shell/render-worker.ts
index 1b1cf3277401..3f8e59a17cb6 100644
--- a/packages/angular_devkit/build_angular/src/builders/app-shell/render-worker.ts
+++ b/packages/angular_devkit/build_angular/src/builders/app-shell/render-worker.ts
@@ -87,14 +87,14 @@ async function render({ serverBundlePath, document, url }: RenderRequest): Promi
       platformProviders,
     });
   }
-
+  assert(renderModule, `renderModule was not exported from: ${serverBundlePath}.`);
+  const moduleClass = bootstrapAppFn || AppServerModule;
   assert(
-    AppServerModule,
+    moduleClass,
     `Neither an AppServerModule nor a bootstrapping function was exported from: ${serverBundlePath}.`,
   );
-  assert(renderModule, `renderModule was not exported from: ${serverBundlePath}.`);
 
-  return renderModule(AppServerModule, {
+  return renderModule(moduleClass, {
     document,
     url,
     extraProviders: platformProviders,
diff --git a/packages/angular_devkit/build_angular/src/builders/prerender/render-worker.ts b/packages/angular_devkit/build_angular/src/builders/prerender/render-worker.ts
index ab60a75cb659..f26cc8fef3c8 100644
--- a/packages/angular_devkit/build_angular/src/builders/prerender/render-worker.ts
+++ b/packages/angular_devkit/build_angular/src/builders/prerender/render-worker.ts
@@ -43,7 +43,7 @@ interface ServerBundleExports {
   renderApplication?: typeof renderApplication;
 
   /** Standalone application bootstrapping function. */
-  default?: () => Promise<ApplicationRef>;
+  default?: (() => Promise<ApplicationRef>) | Type<unknown>;
 }
 
 /**
@@ -105,19 +105,21 @@ async function render({
       url: route,
       platformProviders,
     });
-  }
+  } else {
+    assert(renderModule, `renderModule was not exported from: ${serverBundlePath}.`);
 
-  assert(
-    AppServerModule,
-    `Neither an AppServerModule nor a bootstrapping function was exported from: ${serverBundlePath}.`,
-  );
-  assert(renderModule, `renderModule was not exported from: ${serverBundlePath}.`);
-
-  html = await renderModule(AppServerModule, {
-    document,
-    url: route,
-    extraProviders: platformProviders,
-  });
+    const moduleClass = bootstrapAppFn || AppServerModule;
+    assert(
+      moduleClass,
+      `Neither an AppServerModule nor a bootstrapping function was exported from: ${serverBundlePath}.`,
+    );
+
+    html = await renderModule(moduleClass, {
+      document,
+      url: route,
+      extraProviders: platformProviders,
+    });
+  }
 
   if (inlineCriticalCss) {
     const inlineCriticalCssProcessor = new InlineCriticalCssProcessor({
diff --git a/packages/schematics/angular/app-shell/index.ts b/packages/schematics/angular/app-shell/index.ts
index 0a0b54919416..dd6033e94a7e 100644
--- a/packages/schematics/angular/app-shell/index.ts
+++ b/packages/schematics/angular/app-shell/index.ts
@@ -9,7 +9,6 @@
 import { dirname, join, normalize } from '@angular-devkit/core';
 import {
   Rule,
-  SchematicContext,
   SchematicsException,
   Tree,
   chain,
@@ -30,11 +29,13 @@ import {
 } from '../utility/ast-utils';
 import { applyToUpdateRecorder } from '../utility/change';
 import { getAppModulePath, isStandaloneApp } from '../utility/ng-ast-utils';
-import { targetBuildNotFoundError } from '../utility/project-targets';
+import { getMainFilePath } from '../utility/standalone/util';
 import { getWorkspace, updateWorkspace } from '../utility/workspace';
-import { BrowserBuilderOptions, Builders, ServerBuilderOptions } from '../utility/workspace-models';
+import { Builders, ServerBuilderOptions } from '../utility/workspace-models';
 import { Schema as AppShellOptions } from './schema';
 
+const APP_SHELL_ROUTE = 'shell';
+
 function getSourceFile(host: Tree, path: string): ts.SourceFile {
   const content = host.readText(path);
   const source = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true);
@@ -128,46 +129,44 @@ function getBootstrapComponentPath(host: Tree, mainPath: string): string {
 // end helper functions.
 
 function validateProject(mainPath: string): Rule {
-  return (host: Tree, context: SchematicContext) => {
+  return (host: Tree) => {
     const routerOutletCheckRegex = /<router-outlet.*?>([\s\S]*?)<\/router-outlet>/;
 
     const componentPath = getBootstrapComponentPath(host, mainPath);
     const tmpl = getComponentTemplateInfo(host, componentPath);
     const template = getComponentTemplate(host, componentPath, tmpl);
     if (!routerOutletCheckRegex.test(template)) {
-      const errorMsg = `Prerequisite for application shell is to define a router-outlet in your root component.`;
-      context.logger.error(errorMsg);
-      throw new SchematicsException(errorMsg);
+      throw new SchematicsException(
+        `Prerequisite for application shell is to define a router-outlet in your root component.`,
+      );
     }
   };
 }
 
-function addUniversalTarget(options: AppShellOptions): Rule {
-  return () => {
-    // Copy options.
-    const universalOptions = {
-      ...options,
-    };
-
-    // Delete non-universal options.
-    delete universalOptions.route;
-
-    return schematic('universal', universalOptions);
-  };
-}
-
 function addAppShellConfigToWorkspace(options: AppShellOptions): Rule {
   return (host, context) => {
-    if (!options.route) {
-      throw new SchematicsException(`Route is not defined`);
-    }
-
     return updateWorkspace((workspace) => {
       const project = workspace.projects.get(options.project);
       if (!project) {
         return;
       }
 
+      const buildTarget = project.targets.get('build');
+      if (buildTarget?.builder === Builders.Application) {
+        // Application builder configuration.
+        const prodConfig = buildTarget.configurations?.production;
+        if (!prodConfig) {
+          throw new SchematicsException(
+            `A "production" configuration is not defined for the "build" builder.`,
+          );
+        }
+
+        prodConfig.appShell = true;
+
+        return;
+      }
+
+      // Webpack based builders configuration.
       // Validation of targets is handled already in the main function.
       // Duplicate keys means that we have configurations in both server and build builders.
       const serverConfigKeys = project.targets.get('server')?.configurations ?? {};
@@ -207,7 +206,7 @@ function addAppShellConfigToWorkspace(options: AppShellOptions): Rule {
         builder: Builders.AppShell,
         defaultConfiguration: configurations['production'] ? 'production' : undefined,
         options: {
-          route: options.route,
+          route: APP_SHELL_ROUTE,
         },
         configurations,
       });
@@ -249,25 +248,14 @@ function addServerRoutes(options: AppShellOptions): Rule {
   return async (host: Tree) => {
     // The workspace gets updated so this needs to be reloaded
     const workspace = await getWorkspace(host);
-    const clientProject = workspace.projects.get(options.project);
-    if (!clientProject) {
-      throw new Error('Universal schematic removed client project.');
-    }
-    const clientServerTarget = clientProject.targets.get('server');
-    if (!clientServerTarget) {
-      throw new Error('Universal schematic did not add server target to client project.');
-    }
-    const clientServerOptions = clientServerTarget.options as unknown as ServerBuilderOptions;
-    if (!clientServerOptions) {
-      throw new SchematicsException('Server target does not contain options.');
+    const project = workspace.projects.get(options.project);
+    if (!project) {
+      throw new SchematicsException(`Invalid project name (${options.project})`);
     }
-    const modulePath = getServerModulePath(
-      host,
-      clientProject.sourceRoot || 'src',
-      options.main as string,
-    );
+
+    const modulePath = getServerModulePath(host, project.sourceRoot || 'src', 'main.server.ts');
     if (modulePath === null) {
-      throw new SchematicsException('Universal/server module not found.');
+      throw new SchematicsException('Server module not found.');
     }
 
     let moduleSource = getSourceFile(host, modulePath);
@@ -282,7 +270,7 @@ function addServerRoutes(options: AppShellOptions): Rule {
         .filter((node) => node.kind === ts.SyntaxKind.ImportDeclaration)
         .sort((a, b) => a.getStart() - b.getStart());
       const insertPosition = imports[imports.length - 1].getEnd();
-      const routeText = `\n\nconst routes: Routes = [ { path: '${options.route}', component: AppShellComponent }];`;
+      const routeText = `\n\nconst routes: Routes = [ { path: '${APP_SHELL_ROUTE}', component: AppShellComponent }];`;
       recorder.insertRight(insertPosition, routeText);
       host.commitUpdate(recorder);
     }
@@ -369,7 +357,7 @@ function addStandaloneServerRoute(options: AppShellOptions): Rule {
                   [
                     ts.factory.createPropertyAssignment(
                       'path',
-                      ts.factory.createIdentifier(`'${options.route}'`),
+                      ts.factory.createIdentifier(`'${APP_SHELL_ROUTE}'`),
                     ),
                     ts.factory.createPropertyAssignment(
                       'component',
@@ -410,29 +398,18 @@ function addStandaloneServerRoute(options: AppShellOptions): Rule {
 
 export default function (options: AppShellOptions): Rule {
   return async (tree) => {
-    const workspace = await getWorkspace(tree);
-    const clientProject = workspace.projects.get(options.project);
-    if (!clientProject || clientProject.extensions.projectType !== 'application') {
-      throw new SchematicsException(`A client project type of "application" is required.`);
-    }
-    const clientBuildTarget = clientProject.targets.get('build');
-    if (!clientBuildTarget) {
-      throw targetBuildNotFoundError();
-    }
-    const clientBuildOptions = (clientBuildTarget.options ||
-      {}) as unknown as BrowserBuilderOptions;
-
-    const isStandalone = isStandaloneApp(tree, clientBuildOptions.main);
+    const browserEntryPoint = await getMainFilePath(tree, options.project);
+    const isStandalone = isStandaloneApp(tree, browserEntryPoint);
 
     return chain([
-      validateProject(clientBuildOptions.main),
-      clientProject.targets.has('server') ? noop() : addUniversalTarget(options),
+      validateProject(browserEntryPoint),
+      schematic('server', options),
       addAppShellConfigToWorkspace(options),
-      isStandalone ? noop() : addRouterModule(clientBuildOptions.main),
+      isStandalone ? noop() : addRouterModule(browserEntryPoint),
       isStandalone ? addStandaloneServerRoute(options) : addServerRoutes(options),
       schematic('component', {
         name: 'app-shell',
-        module: options.rootModuleFileName,
+        module: 'app.module.server.ts',
         project: options.project,
         standalone: isStandalone,
       }),
diff --git a/packages/schematics/angular/app-shell/index_spec.ts b/packages/schematics/angular/app-shell/index_spec.ts
index a0db5b305466..46c6bd1caad6 100644
--- a/packages/schematics/angular/app-shell/index_spec.ts
+++ b/packages/schematics/angular/app-shell/index_spec.ts
@@ -9,6 +9,7 @@
 import { tags } from '@angular-devkit/core';
 import { SchematicTestRunner, UnitTestTree } from '@angular-devkit/schematics/testing';
 import { Schema as ApplicationOptions } from '../application/schema';
+import { Builders } from '../utility/workspace-models';
 import { Schema as WorkspaceOptions } from '../workspace/schema';
 import { Schema as AppShellOptions } from './schema';
 
@@ -42,6 +43,15 @@ describe('App Shell Schematic', () => {
     appTree = await schematicRunner.runSchematic('application', appOptions, appTree);
   });
 
+  it('should add app shell configuration', async () => {
+    const tree = await schematicRunner.runSchematic('app-shell', defaultOptions, appTree);
+    const filePath = '/angular.json';
+    const content = tree.readContent(filePath);
+    const workspace = JSON.parse(content);
+    const target = workspace.projects.bar.architect['build'];
+    expect(target.configurations.production.appShell).toBeTrue();
+  });
+
   it('should ensure the client app has a router-outlet', async () => {
     appTree = await schematicRunner.runSchematic('workspace', workspaceOptions);
     appTree = await schematicRunner.runSchematic(
@@ -54,25 +64,12 @@ describe('App Shell Schematic', () => {
     ).toBeRejected();
   });
 
-  it('should add a universal app', async () => {
+  it('should add a server app', async () => {
     const tree = await schematicRunner.runSchematic('app-shell', defaultOptions, appTree);
     const filePath = '/projects/bar/src/app/app.module.server.ts';
     expect(tree.exists(filePath)).toEqual(true);
   });
 
-  it('should add app shell configuration', async () => {
-    const tree = await schematicRunner.runSchematic('app-shell', defaultOptions, appTree);
-    const filePath = '/angular.json';
-    const content = tree.readContent(filePath);
-    const workspace = JSON.parse(content);
-    const target = workspace.projects.bar.architect['app-shell'];
-    expect(target.options.route).toEqual('shell');
-    expect(target.configurations.development.browserTarget).toEqual('bar:build:development');
-    expect(target.configurations.development.serverTarget).toEqual('bar:server:development');
-    expect(target.configurations.production.browserTarget).toEqual('bar:build:production');
-    expect(target.configurations.production.serverTarget).toEqual('bar:server:production');
-  });
-
   it('should add router module to client app module', async () => {
     const tree = await schematicRunner.runSchematic('app-shell', defaultOptions, appTree);
     const filePath = '/projects/bar/src/app/app.module.ts';
@@ -100,7 +97,7 @@ describe('App Shell Schematic', () => {
         App works!
       </p>`;
       const newText = `
-        import { Component, OnInit } from '@angular/core';
+        import { Component } from '@angular/core';
 
         @Component({
           selector: ''
@@ -109,14 +106,7 @@ describe('App Shell Schematic', () => {
           \`,
           styleUrls: ['./app.component.css']
         })
-        export class AppComponent implements OnInit {
-
-          constructor() { }
-
-          ngOnInit() {
-          }
-
-        }
+        export class AppComponent { }
 
       `;
       tree.overwrite('/projects/bar/src/app/app.component.ts', newText);
@@ -150,17 +140,10 @@ describe('App Shell Schematic', () => {
     expect(content).toMatch(/import { Routes, RouterModule } from '@angular\/router';/);
   });
 
-  it('should work after adding nguniversal', async () => {
-    let tree = await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    // change main tsconfig to mimic ng add for nguniveral
-    const workspace = JSON.parse(appTree.readContent('/angular.json'));
-    workspace.projects.bar.architect.server.options.main = 'server.ts';
-    appTree.overwrite('angular.json', JSON.stringify(workspace, undefined, 2));
-
+  it('should work if server config was added prior to running the app-shell schematic', async () => {
+    let tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
     tree = await schematicRunner.runSchematic('app-shell', defaultOptions, tree);
-    const filePath = '/projects/bar/src/app/app.module.server.ts';
-    const content = tree.readContent(filePath);
-    expect(content).toMatch(/import { Routes, RouterModule } from '@angular\/router';/);
+    expect(tree.exists('/projects/bar/src/app/app-shell/app-shell.component.ts')).toBe(true);
   });
 
   it('should define a server route', async () => {
@@ -269,4 +252,43 @@ describe('App Shell Schematic', () => {
       );
     });
   });
+
+  describe('Legacy browser builder', () => {
+    function convertBuilderToLegacyBrowser(): void {
+      const config = JSON.parse(appTree.readContent('/angular.json'));
+      const build = config.projects.bar.architect.build;
+
+      build.builder = Builders.Browser;
+      build.options = {
+        ...build.options,
+        main: build.options.browser,
+        browser: undefined,
+      };
+
+      build.configurations.development = {
+        ...build.configurations.development,
+        vendorChunk: true,
+        namedChunks: true,
+        buildOptimizer: false,
+      };
+
+      appTree.overwrite('/angular.json', JSON.stringify(config, undefined, 2));
+    }
+
+    beforeEach(() => {
+      convertBuilderToLegacyBrowser();
+    });
+
+    it('should add app shell configuration', async () => {
+      const tree = await schematicRunner.runSchematic('app-shell', defaultOptions, appTree);
+      const filePath = '/angular.json';
+      const content = tree.readContent(filePath);
+      const workspace = JSON.parse(content);
+      const target = workspace.projects.bar.architect['app-shell'];
+      expect(target.configurations.development.browserTarget).toEqual('bar:build:development');
+      expect(target.configurations.development.serverTarget).toEqual('bar:server:development');
+      expect(target.configurations.production.browserTarget).toEqual('bar:build:production');
+      expect(target.configurations.production.serverTarget).toEqual('bar:server:production');
+    });
+  });
 });
diff --git a/packages/schematics/angular/app-shell/schema.json b/packages/schematics/angular/app-shell/schema.json
index aada27d60881..df82f16f3b7d 100644
--- a/packages/schematics/angular/app-shell/schema.json
+++ b/packages/schematics/angular/app-shell/schema.json
@@ -12,27 +12,6 @@
       "$default": {
         "$source": "projectName"
       }
-    },
-    "route": {
-      "type": "string",
-      "description": "Route path used to produce the application shell.",
-      "default": "shell"
-    },
-    "main": {
-      "type": "string",
-      "description": "The name of the main entry-point file.",
-      "default": "main.server.ts"
-    },
-    "rootModuleFileName": {
-      "type": "string",
-      "description": "The name of the root module file",
-      "default": "app.module.server.ts"
-    },
-    "rootModuleClassName": {
-      "type": "string",
-      "format": "html-selector",
-      "description": "The name of the root module class.",
-      "default": "AppServerModule"
     }
   },
   "required": ["project"]
diff --git a/packages/schematics/angular/application/index.ts b/packages/schematics/angular/application/index.ts
index ed03e3b110b9..83e906143a19 100644
--- a/packages/schematics/angular/application/index.ts
+++ b/packages/schematics/angular/application/index.ts
@@ -240,12 +240,12 @@ function addAppToWorkspaceFile(
     schematics,
     targets: {
       build: {
-        builder: Builders.Browser,
+        builder: Builders.Application,
         defaultConfiguration: 'production',
         options: {
           outputPath: `dist/${folderName}`,
           index: `${sourceRoot}/index.html`,
-          main: `${sourceRoot}/main.ts`,
+          browser: `${sourceRoot}/main.ts`,
           polyfills: ['zone.js'],
           tsConfig: `${projectRoot}tsconfig.app.json`,
           inlineStyleLanguage,
@@ -259,12 +259,9 @@ function addAppToWorkspaceFile(
             outputHashing: 'all',
           },
           development: {
-            buildOptimizer: false,
             optimization: false,
-            vendorChunk: true,
             extractLicenses: false,
             sourceMap: true,
-            namedChunks: true,
           },
         },
       },
diff --git a/packages/schematics/angular/application/index_spec.ts b/packages/schematics/angular/application/index_spec.ts
index 857eb8122696..d6d97b964089 100644
--- a/packages/schematics/angular/application/index_spec.ts
+++ b/packages/schematics/angular/application/index_spec.ts
@@ -376,7 +376,7 @@ describe('Application Schematic', () => {
       expect(prj.root).toEqual('');
       const buildOpt = prj.architect.build.options;
       expect(buildOpt.index).toEqual('src/index.html');
-      expect(buildOpt.main).toEqual('src/main.ts');
+      expect(buildOpt.browser).toEqual('src/main.ts');
       expect(buildOpt.polyfills).toEqual(['zone.js']);
       expect(buildOpt.tsConfig).toEqual('tsconfig.app.json');
 
@@ -465,7 +465,7 @@ describe('Application Schematic', () => {
       expect(project.root).toEqual('foo');
       const buildOpt = project.architect.build.options;
       expect(buildOpt.index).toEqual('foo/src/index.html');
-      expect(buildOpt.main).toEqual('foo/src/main.ts');
+      expect(buildOpt.browser).toEqual('foo/src/main.ts');
       expect(buildOpt.polyfills).toEqual(['zone.js']);
       expect(buildOpt.tsConfig).toEqual('foo/tsconfig.app.json');
 
diff --git a/packages/schematics/angular/collection.json b/packages/schematics/angular/collection.json
index 65a57023b64f..118a89623bf9 100755
--- a/packages/schematics/angular/collection.json
+++ b/packages/schematics/angular/collection.json
@@ -94,10 +94,10 @@
       "description": "Create an Angular service.",
       "schema": "./service/schema.json"
     },
-    "universal": {
-      "factory": "./universal",
-      "description": "Create an Angular universal app.",
-      "schema": "./universal/schema.json",
+    "server": {
+      "factory": "./server",
+      "description": "Create an Angular server app.",
+      "schema": "./server/schema.json",
       "hidden": true
     },
     "app-shell": {
diff --git a/packages/schematics/angular/environments/index.ts b/packages/schematics/angular/environments/index.ts
index 1ce9aa4287a9..975af7117561 100644
--- a/packages/schematics/angular/environments/index.ts
+++ b/packages/schematics/angular/environments/index.ts
@@ -72,7 +72,11 @@ function* generateConfigurationEnvironments(
   sourceRoot: string,
   projectName: string,
 ): Iterable<Rule> {
-  if (!buildTarget.builder.startsWith(AngularBuilder.Browser)) {
+  if (
+    buildTarget.builder !== AngularBuilder.Browser &&
+    buildTarget.builder !== AngularBuilder.BrowserEsbuild &&
+    buildTarget.builder !== AngularBuilder.Application
+  ) {
     yield log(
       'warn',
       `"build" target found for project "${projectName}" has a third-party builder "${buildTarget.builder}".` +
@@ -80,7 +84,7 @@ function* generateConfigurationEnvironments(
     );
   }
 
-  if (serverTarget && !serverTarget.builder.startsWith(AngularBuilder.Server)) {
+  if (serverTarget && serverTarget.builder !== AngularBuilder.Server) {
     yield log(
       'warn',
       `"server" target found for project "${projectName}" has a third-party builder "${buildTarget.builder}".` +
diff --git a/packages/schematics/angular/environments/index_spec.ts b/packages/schematics/angular/environments/index_spec.ts
index e97a0e9f50fd..ff797a17f952 100644
--- a/packages/schematics/angular/environments/index_spec.ts
+++ b/packages/schematics/angular/environments/index_spec.ts
@@ -8,10 +8,11 @@
 
 import { SchematicTestRunner, UnitTestTree } from '@angular-devkit/schematics/testing';
 import { Schema as ApplicationOptions } from '../application/schema';
+import { Builders } from '../utility/workspace-models';
 import { Schema as WorkspaceOptions } from '../workspace/schema';
 import { Schema as EnvironmentOptions } from './schema';
 
-describe('Application Schematic', () => {
+describe('Environments Schematic', () => {
   const schematicRunner = new SchematicTestRunner(
     '@schematics/angular',
     require.resolve('../collection.json'),
@@ -42,6 +43,27 @@ describe('Application Schematic', () => {
     return schematicRunner.runSchematic('environments', defaultOptions, applicationTree);
   }
 
+  function convertBuilderToLegacyBrowser(): void {
+    const config = JSON.parse(applicationTree.readContent('/angular.json'));
+    const build = config.projects.foo.architect.build;
+
+    build.builder = Builders.Browser;
+    build.options = {
+      ...build.options,
+      main: build.options.browser,
+      browser: undefined,
+    };
+
+    build.configurations.development = {
+      ...build.configurations.development,
+      vendorChunk: true,
+      namedChunks: true,
+      buildOptimizer: false,
+    };
+
+    applicationTree.overwrite('/angular.json', JSON.stringify(config, undefined, 2));
+  }
+
   beforeEach(async () => {
     const workspaceTree = await schematicRunner.runSchematic('workspace', workspaceOptions);
     applicationTree = await schematicRunner.runSchematic(
@@ -133,8 +155,10 @@ describe('Application Schematic', () => {
   });
 
   it('should update the angular.json file replacements option for server configurations', async () => {
+    convertBuilderToLegacyBrowser();
+
     await schematicRunner.runSchematic(
-      'universal',
+      'server',
       { project: 'foo', skipInstall: true },
       applicationTree,
     );
diff --git a/packages/schematics/angular/universal/files/root/tsconfig.server.json.template b/packages/schematics/angular/server/files/root/tsconfig.server.json.template
similarity index 88%
rename from packages/schematics/angular/universal/files/root/tsconfig.server.json.template
rename to packages/schematics/angular/server/files/root/tsconfig.server.json.template
index 3bbf001a5b1c..931da00dc8ff 100644
--- a/packages/schematics/angular/universal/files/root/tsconfig.server.json.template
+++ b/packages/schematics/angular/server/files/root/tsconfig.server.json.template
@@ -9,6 +9,6 @@
     ]
   },
   "files": [
-    "src/<%= stripTsExtension(main) %>.ts"
+    "src/main.server.ts"
   ]
 }
diff --git a/packages/schematics/angular/universal/files/src/app/__rootModuleFileName__.template b/packages/schematics/angular/server/files/src/app/app.module.server.ts.template
similarity index 86%
rename from packages/schematics/angular/universal/files/src/app/__rootModuleFileName__.template
rename to packages/schematics/angular/server/files/src/app/app.module.server.ts.template
index af9a56e17c92..795380cd2294 100644
--- a/packages/schematics/angular/universal/files/src/app/__rootModuleFileName__.template
+++ b/packages/schematics/angular/server/files/src/app/app.module.server.ts.template
@@ -11,4 +11,4 @@ import { AppComponent } from './app.component';
   ],
   bootstrap: [AppComponent],
 })
-export class <%= rootModuleClassName %> {}
+export class AppServerModule {}
diff --git a/packages/schematics/angular/server/files/src/main.server.ts.template b/packages/schematics/angular/server/files/src/main.server.ts.template
new file mode 100644
index 000000000000..dfb6fdb3f1f0
--- /dev/null
+++ b/packages/schematics/angular/server/files/src/main.server.ts.template
@@ -0,0 +1 @@
+export { AppServerModule as default } from './app/app.module.server';
diff --git a/packages/schematics/angular/universal/files/standalone-src/app/app.config.server.ts.template b/packages/schematics/angular/server/files/standalone-src/app/app.config.server.ts.template
similarity index 100%
rename from packages/schematics/angular/universal/files/standalone-src/app/app.config.server.ts.template
rename to packages/schematics/angular/server/files/standalone-src/app/app.config.server.ts.template
diff --git a/packages/schematics/angular/universal/files/standalone-src/main.server.ts.template b/packages/schematics/angular/server/files/standalone-src/main.server.ts.template
similarity index 100%
rename from packages/schematics/angular/universal/files/standalone-src/main.server.ts.template
rename to packages/schematics/angular/server/files/standalone-src/main.server.ts.template
diff --git a/packages/schematics/angular/universal/index.ts b/packages/schematics/angular/server/index.ts
similarity index 60%
rename from packages/schematics/angular/universal/index.ts
rename to packages/schematics/angular/server/index.ts
index 6d144db5bfbd..4a4452376827 100644
--- a/packages/schematics/angular/universal/index.ts
+++ b/packages/schematics/angular/server/index.ts
@@ -21,20 +21,25 @@ import {
   url,
 } from '@angular-devkit/schematics';
 import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
+import { posix } from 'node:path';
 import {
   NodeDependencyType,
   addPackageJsonDependency,
   getPackageJsonDependency,
 } from '../utility/dependencies';
+import { JSONFile } from '../utility/json-file';
 import { latestVersions } from '../utility/latest-versions';
 import { isStandaloneApp } from '../utility/ng-ast-utils';
 import { relativePathToWorkspaceRoot } from '../utility/paths';
 import { targetBuildNotFoundError } from '../utility/project-targets';
+import { getMainFilePath } from '../utility/standalone/util';
 import { getWorkspace, updateWorkspace } from '../utility/workspace';
-import { BrowserBuilderOptions, Builders } from '../utility/workspace-models';
-import { Schema as UniversalOptions } from './schema';
+import { Builders } from '../utility/workspace-models';
+import { Schema as ServerOptions } from './schema';
 
-function updateConfigFile(options: UniversalOptions, tsConfigDirectory: Path): Rule {
+const serverMainEntryName = 'main.server.ts';
+
+function updateConfigFileBrowserBuilder(options: ServerOptions, tsConfigDirectory: Path): Rule {
   return updateWorkspace((workspace) => {
     const clientProject = workspace.projects.get(options.project);
 
@@ -75,7 +80,6 @@ function updateConfigFile(options: UniversalOptions, tsConfigDirectory: Path): R
         }
       }
 
-      const mainPath = options.main as string;
       const sourceRoot = clientProject.sourceRoot ?? join(normalize(clientProject.root), 'src');
       const serverTsConfig = join(tsConfigDirectory, 'tsconfig.server.json');
       clientProject.targets.add({
@@ -84,7 +88,7 @@ function updateConfigFile(options: UniversalOptions, tsConfigDirectory: Path): R
         defaultConfiguration: 'production',
         options: {
           outputPath: `dist/${options.project}/server`,
-          main: join(normalize(sourceRoot), mainPath.endsWith('.ts') ? mainPath : mainPath + '.ts'),
+          main: join(normalize(sourceRoot), serverMainEntryName),
           tsConfig: serverTsConfig,
           ...(buildTarget?.options ? getServerOptions(buildTarget?.options) : {}),
         },
@@ -94,6 +98,43 @@ function updateConfigFile(options: UniversalOptions, tsConfigDirectory: Path): R
   });
 }
 
+function updateConfigFileApplicationBuilder(options: ServerOptions): Rule {
+  return updateWorkspace((workspace) => {
+    const project = workspace.projects.get(options.project);
+    if (!project) {
+      return;
+    }
+
+    const buildTarget = project.targets.get('build');
+    if (buildTarget?.builder !== Builders.Application) {
+      throw new SchematicsException(
+        `This schematic requires "${Builders.Application}" to be used as a build builder.`,
+      );
+    }
+
+    buildTarget.options ??= {};
+    buildTarget.options['server'] = posix.join(
+      project.sourceRoot ?? posix.join(project.root, 'src'),
+      serverMainEntryName,
+    );
+  });
+}
+
+function updateTsConfigFile(tsConfigPath: string): Rule {
+  return (host: Tree) => {
+    const json = new JSONFile(host, tsConfigPath);
+    const filesPath = ['files'];
+    const files = new Set((json.get(filesPath) as string[] | undefined) ?? []);
+    files.add('src/' + serverMainEntryName);
+    json.modify(filesPath, [...files]);
+
+    const typePath = ['compilerOptions', 'types'];
+    const types = new Set((json.get(typePath) as string[] | undefined) ?? []);
+    types.add('node');
+    json.modify(typePath, [...types]);
+  };
+}
+
 function addDependencies(): Rule {
   return (host: Tree) => {
     const coreDep = getPackageJsonDependency(host, '@angular/core');
@@ -114,13 +155,12 @@ function addDependencies(): Rule {
   };
 }
 
-export default function (options: UniversalOptions): Rule {
+export default function (options: ServerOptions): Rule {
   return async (host: Tree, context: SchematicContext) => {
     const workspace = await getWorkspace(host);
-
     const clientProject = workspace.projects.get(options.project);
-    if (!clientProject || clientProject.extensions.projectType !== 'application') {
-      throw new SchematicsException(`Universal requires a project type of "application".`);
+    if (clientProject?.extensions.projectType !== 'application') {
+      throw new SchematicsException(`Server schematic requires a project type of "application".`);
     }
 
     const clientBuildTarget = clientProject.targets.get('build');
@@ -128,20 +168,26 @@ export default function (options: UniversalOptions): Rule {
       throw targetBuildNotFoundError();
     }
 
-    const clientBuildOptions = (clientBuildTarget.options ||
-      {}) as unknown as BrowserBuilderOptions;
+    const isUsingApplicationBuilder = clientBuildTarget.builder === Builders.Application;
+    if (
+      clientProject.targets.has('server') ||
+      (isUsingApplicationBuilder && clientBuildTarget.options?.server !== undefined)
+    ) {
+      // Server has already been added.
+      return;
+    }
 
     if (!options.skipInstall) {
       context.addTask(new NodePackageInstallTask());
     }
-
-    const isStandalone = isStandaloneApp(host, clientBuildOptions.main);
+    const clientBuildOptions = clientBuildTarget.options as Record<string, string>;
+    const browserEntryPoint = await getMainFilePath(host, options.project);
+    const isStandalone = isStandaloneApp(host, browserEntryPoint);
 
     const templateSource = apply(url(isStandalone ? './files/standalone-src' : './files/src'), [
       applyTemplates({
         ...strings,
         ...options,
-        stripTsExtension: (s: string) => s.replace(/\.ts$/, ''),
       }),
       move(join(normalize(clientProject.root), 'src')),
     ]);
@@ -150,23 +196,30 @@ export default function (options: UniversalOptions): Rule {
     const tsConfigExtends = basename(clientTsConfig);
     const tsConfigDirectory = dirname(clientTsConfig);
 
-    const rootSource = apply(url('./files/root'), [
-      applyTemplates({
-        ...strings,
-        ...options,
-        stripTsExtension: (s: string) => s.replace(/\.ts$/, ''),
-        tsConfigExtends,
-        hasLocalizePackage: !!getPackageJsonDependency(host, '@angular/localize'),
-        relativePathToWorkspaceRoot: relativePathToWorkspaceRoot(tsConfigDirectory),
-      }),
-      move(tsConfigDirectory),
-    ]);
-
     return chain([
       mergeWith(templateSource),
-      mergeWith(rootSource),
+      ...(isUsingApplicationBuilder
+        ? [
+            updateConfigFileApplicationBuilder(options),
+            updateTsConfigFile(clientBuildOptions.tsConfig),
+          ]
+        : [
+            mergeWith(
+              apply(url('./files/root'), [
+                applyTemplates({
+                  ...strings,
+                  ...options,
+                  stripTsExtension: (s: string) => s.replace(/\.ts$/, ''),
+                  tsConfigExtends,
+                  hasLocalizePackage: !!getPackageJsonDependency(host, '@angular/localize'),
+                  relativePathToWorkspaceRoot: relativePathToWorkspaceRoot(tsConfigDirectory),
+                }),
+                move(tsConfigDirectory),
+              ]),
+            ),
+            updateConfigFileBrowserBuilder(options, tsConfigDirectory),
+          ]),
       addDependencies(),
-      updateConfigFile(options, tsConfigDirectory),
     ]);
   };
 }
diff --git a/packages/schematics/angular/server/index_spec.ts b/packages/schematics/angular/server/index_spec.ts
new file mode 100644
index 000000000000..a296e1562427
--- /dev/null
+++ b/packages/schematics/angular/server/index_spec.ts
@@ -0,0 +1,254 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import { SchematicTestRunner, UnitTestTree } from '@angular-devkit/schematics/testing';
+import { parse as parseJson } from 'jsonc-parser';
+import { Schema as ApplicationOptions, Style } from '../application/schema';
+import { CompilerOptions } from '../third_party/github.com/Microsoft/TypeScript/lib/typescript';
+import { NodeDependencyType, addPackageJsonDependency } from '../utility/dependencies';
+import { Builders } from '../utility/workspace-models';
+import { Schema as WorkspaceOptions } from '../workspace/schema';
+import { Schema as ServerOptions } from './schema';
+
+describe('Server Schematic', () => {
+  const schematicRunner = new SchematicTestRunner(
+    '@schematics/angular',
+    require.resolve('../collection.json'),
+  );
+  const defaultOptions: ServerOptions = {
+    project: 'bar',
+  };
+  const workspaceUniversalOptions: ServerOptions = {
+    project: 'workspace',
+  };
+
+  const workspaceOptions: WorkspaceOptions = {
+    name: 'workspace',
+    newProjectRoot: 'projects',
+    version: '6.0.0',
+  };
+
+  const appOptions: ApplicationOptions = {
+    name: 'bar',
+    inlineStyle: false,
+    inlineTemplate: false,
+    routing: false,
+    style: Style.Css,
+    skipTests: false,
+    skipPackageJson: false,
+  };
+
+  const initialWorkspaceAppOptions: ApplicationOptions = {
+    name: 'workspace',
+    projectRoot: '',
+    inlineStyle: false,
+    inlineTemplate: false,
+    routing: false,
+    style: Style.Css,
+    skipTests: false,
+    skipPackageJson: false,
+  };
+
+  let appTree: UnitTestTree;
+
+  beforeEach(async () => {
+    appTree = await schematicRunner.runSchematic('workspace', workspaceOptions);
+    appTree = await schematicRunner.runSchematic(
+      'application',
+      initialWorkspaceAppOptions,
+      appTree,
+    );
+    appTree = await schematicRunner.runSchematic('application', appOptions, appTree);
+  });
+
+  it('should create a root module file', async () => {
+    const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+    const filePath = '/projects/bar/src/app/app.module.server.ts';
+    expect(tree.exists(filePath)).toBeTrue();
+  });
+
+  it('should create a main file', async () => {
+    const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+    const filePath = '/projects/bar/src/main.server.ts';
+    expect(tree.exists(filePath)).toBeTrue();
+    const contents = tree.readContent(filePath);
+    expect(contents).toContain(
+      `export { AppServerModule as default } from './app/app.module.server';`,
+    );
+  });
+
+  it('should add dependency: @angular/platform-server', async () => {
+    const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+    const filePath = '/package.json';
+    const contents = tree.readContent(filePath);
+    expect(contents).toMatch(/"@angular\/platform-server": "/);
+  });
+
+  it('should install npm dependencies', async () => {
+    await schematicRunner.runSchematic('server', defaultOptions, appTree);
+    expect(schematicRunner.tasks.length).toBe(1);
+    expect(schematicRunner.tasks[0].name).toBe('node-package');
+    expect((schematicRunner.tasks[0].options as { command: string }).command).toBe('install');
+  });
+
+  it('should update tsconfig.app.json', async () => {
+    const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+    const filePath = '/projects/bar/tsconfig.app.json';
+    const contents = parseJson(tree.readContent(filePath).toString());
+    expect(contents.compilerOptions.types).toEqual(['node']);
+    expect(contents.files).toEqual(['src/main.ts', 'src/main.server.ts']);
+  });
+
+  describe('standalone application', () => {
+    let standaloneAppOptions;
+    let defaultStandaloneOptions: ServerOptions;
+    beforeEach(async () => {
+      const standaloneAppName = 'baz';
+      standaloneAppOptions = {
+        ...appOptions,
+        name: standaloneAppName,
+        standalone: true,
+      };
+      defaultStandaloneOptions = {
+        project: standaloneAppName,
+      };
+      appTree = await schematicRunner.runSchematic('application', standaloneAppOptions, appTree);
+    });
+
+    it('should create not root module file', async () => {
+      const tree = await schematicRunner.runSchematic('server', defaultStandaloneOptions, appTree);
+      const filePath = '/projects/baz/src/app/app.module.server.ts';
+      expect(tree.exists(filePath)).toEqual(false);
+    });
+
+    it('should update workspace and add the server option', async () => {
+      const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+      const filePath = '/angular.json';
+      const contents = tree.readContent(filePath);
+      const config = JSON.parse(contents.toString());
+      const targets = config.projects.bar.architect;
+      expect(targets.build.options.server).toEqual('projects/bar/src/main.server.ts');
+    });
+
+    it('should create a main file', async () => {
+      const tree = await schematicRunner.runSchematic('server', defaultStandaloneOptions, appTree);
+      const filePath = '/projects/baz/src/main.server.ts';
+      expect(tree.exists(filePath)).toBeTrue();
+      const contents = tree.readContent(filePath);
+      expect(contents).toContain(`bootstrapApplication(AppComponent, config)`);
+    });
+
+    it('should create server app config file', async () => {
+      const tree = await schematicRunner.runSchematic('server', defaultStandaloneOptions, appTree);
+      const filePath = '/projects/baz/src/app/app.config.server.ts';
+      expect(tree.exists(filePath)).toBeTrue();
+      const contents = tree.readContent(filePath);
+      expect(contents).toContain(`const serverConfig: ApplicationConfig = {`);
+    });
+  });
+
+  describe('Legacy browser builder', () => {
+    function convertBuilderToLegacyBrowser(): void {
+      const config = JSON.parse(appTree.readContent('/angular.json'));
+      const build = config.projects.bar.architect.build;
+
+      build.builder = Builders.Browser;
+      build.options = {
+        ...build.options,
+        main: build.options.browser,
+        browser: undefined,
+      };
+
+      build.configurations.development = {
+        ...build.configurations.development,
+        vendorChunk: true,
+        namedChunks: true,
+        buildOptimizer: false,
+      };
+
+      appTree.overwrite('/angular.json', JSON.stringify(config, undefined, 2));
+    }
+
+    beforeEach(() => {
+      convertBuilderToLegacyBrowser();
+    });
+
+    it(`should not add import to '@angular/localize' as type in 'tsconfig.server.json' when it's not a dependency`, async () => {
+      const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+      const { compilerOptions } = tree.readJson('/projects/bar/tsconfig.server.json') as {
+        compilerOptions: CompilerOptions;
+      };
+      expect(compilerOptions.types).not.toContain('@angular/localize');
+    });
+
+    it(`should add import to '@angular/localize' as type in 'tsconfig.server.json' when it's a dependency`, async () => {
+      addPackageJsonDependency(appTree, {
+        name: '@angular/localize',
+        type: NodeDependencyType.Default,
+        version: 'latest',
+      });
+      const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+      const { compilerOptions } = tree.readJson('/projects/bar/tsconfig.server.json') as {
+        compilerOptions: CompilerOptions;
+      };
+      expect(compilerOptions.types).toContain('@angular/localize');
+    });
+
+    it('should update workspace with a server target', async () => {
+      const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+      const filePath = '/angular.json';
+      const contents = tree.readContent(filePath);
+      const config = JSON.parse(contents.toString());
+      const targets = config.projects.bar.architect;
+      expect(targets.server).toBeDefined();
+      expect(targets.server.builder).toBeDefined();
+      const opts = targets.server.options;
+      expect(opts.outputPath).toEqual('dist/bar/server');
+      expect(opts.main).toEqual('projects/bar/src/main.server.ts');
+      expect(opts.tsConfig).toEqual('projects/bar/tsconfig.server.json');
+    });
+
+    it('should update workspace with a build target outputPath', async () => {
+      const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+      const filePath = '/angular.json';
+      const contents = tree.readContent(filePath);
+      const config = JSON.parse(contents.toString());
+      const targets = config.projects.bar.architect;
+      expect(targets.build.options.outputPath).toEqual('dist/bar/browser');
+    });
+
+    it(`should work when 'tsconfig.app.json' has comments`, async () => {
+      const appTsConfigPath = '/projects/bar/tsconfig.app.json';
+      const appTsConfigContent = appTree.readContent(appTsConfigPath);
+      appTree.overwrite(appTsConfigPath, '// comment in json file\n' + appTsConfigContent);
+
+      const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+      const filePath = '/projects/bar/tsconfig.server.json';
+      expect(tree.exists(filePath)).toBeTrue();
+    });
+
+    it('should create a tsconfig file for a generated application', async () => {
+      const tree = await schematicRunner.runSchematic('server', defaultOptions, appTree);
+      const filePath = '/projects/bar/tsconfig.server.json';
+      expect(tree.exists(filePath)).toBeTrue();
+      const contents = parseJson(tree.readContent(filePath).toString());
+      expect(contents).toEqual({
+        extends: './tsconfig.app.json',
+        compilerOptions: {
+          outDir: '../../out-tsc/server',
+          types: ['node'],
+        },
+        files: ['src/main.server.ts'],
+      });
+      const angularConfig = JSON.parse(tree.readContent('angular.json'));
+      expect(angularConfig.projects.bar.architect.server.options.tsConfig).toEqual(
+        'projects/bar/tsconfig.server.json',
+      );
+    });
+  });
+});
diff --git a/packages/schematics/angular/server/schema.json b/packages/schematics/angular/server/schema.json
new file mode 100644
index 000000000000..0704b4cd62e1
--- /dev/null
+++ b/packages/schematics/angular/server/schema.json
@@ -0,0 +1,23 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "SchematicsAngularServerApp",
+  "title": "Angular Server App Options Schema",
+  "type": "object",
+  "additionalProperties": false,
+  "description": "Pass this schematic to the \"run\" command to set up server-side rendering for an app.",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project.",
+      "$default": {
+        "$source": "projectName"
+      }
+    },
+    "skipInstall": {
+      "description": "Do not install packages for dependencies.",
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "required": ["project"]
+}
diff --git a/packages/schematics/angular/service-worker/index.ts b/packages/schematics/angular/service-worker/index.ts
index 9af5768f1b81..bb7d9f48d32f 100644
--- a/packages/schematics/angular/service-worker/index.ts
+++ b/packages/schematics/angular/service-worker/index.ts
@@ -19,34 +19,26 @@ import {
   move,
   url,
 } from '@angular-devkit/schematics';
-import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
 import { addFunctionalProvidersToStandaloneBootstrap } from '../private/standalone';
 import * as ts from '../third_party/github.com/Microsoft/TypeScript/lib/typescript';
-import { readWorkspace, writeWorkspace } from '../utility';
+import { addDependency, readWorkspace, writeWorkspace } from '../utility';
 import { addSymbolToNgModuleMetadata, insertImport } from '../utility/ast-utils';
 import { applyToUpdateRecorder } from '../utility/change';
-import { addPackageJsonDependency, getPackageJsonDependency } from '../utility/dependencies';
+import { getPackageJsonDependency } from '../utility/dependencies';
 import { getAppModulePath, isStandaloneApp } from '../utility/ng-ast-utils';
 import { relativePathToWorkspaceRoot } from '../utility/paths';
 import { targetBuildNotFoundError } from '../utility/project-targets';
-import { BrowserBuilderOptions } from '../utility/workspace-models';
+import { Builders } from '../utility/workspace-models';
 import { Schema as ServiceWorkerOptions } from './schema';
 
 function addDependencies(): Rule {
-  return (host: Tree, context: SchematicContext) => {
-    const packageName = '@angular/service-worker';
-    context.logger.debug(`adding dependency (${packageName})`);
+  return (host: Tree) => {
     const coreDep = getPackageJsonDependency(host, '@angular/core');
-    if (coreDep === null) {
-      throw new SchematicsException('Could not find version.');
+    if (!coreDep) {
+      throw new SchematicsException('Could not find "@angular/core" version.');
     }
-    const serviceWorkerDep = {
-      ...coreDep,
-      name: packageName,
-    };
-    addPackageJsonDependency(host, serviceWorkerDep);
 
-    return host;
+    return addDependency('@angular/service-worker', coreDep.version);
   };
 }
 
@@ -132,7 +124,7 @@ function getTsSourceFile(host: Tree, path: string): ts.SourceFile {
 }
 
 export default function (options: ServiceWorkerOptions): Rule {
-  return async (host: Tree, context: SchematicContext) => {
+  return async (host: Tree) => {
     const workspace = await readWorkspace(host);
     const project = workspace.projects.get(options.project);
     if (!project) {
@@ -145,23 +137,32 @@ export default function (options: ServiceWorkerOptions): Rule {
     if (!buildTarget) {
       throw targetBuildNotFoundError();
     }
-    const buildOptions = (buildTarget.options || {}) as unknown as BrowserBuilderOptions;
-    const root = project.root;
-    buildOptions.serviceWorker = true;
-    buildOptions.ngswConfigPath = join(normalize(root), 'ngsw-config.json');
-
-    let { resourcesOutputPath = '' } = buildOptions;
-    if (resourcesOutputPath) {
-      resourcesOutputPath = normalize(`/${resourcesOutputPath}`);
-    }
 
-    context.addTask(new NodePackageInstallTask());
+    const buildOptions = buildTarget.options as Record<string, string | boolean>;
+    let browserEntryPoint: string | undefined;
+    let resourcesOutputPath = '';
+    const ngswConfigPath = join(normalize(project.root), 'ngsw-config.json');
+
+    if (buildTarget.builder === Builders.Application) {
+      browserEntryPoint = buildOptions.browser as string;
+      resourcesOutputPath = '/media';
+      const productionConf = buildTarget.configurations?.production;
+      if (productionConf) {
+        productionConf.serviceWorker = ngswConfigPath;
+      }
+    } else {
+      browserEntryPoint = buildOptions.main as string;
+      buildOptions.serviceWorker = true;
+      buildOptions.ngswConfigPath = ngswConfigPath;
+      if (buildOptions.resourcesOutputPath) {
+        resourcesOutputPath = normalize(`/${buildOptions.resourcesOutputPath}`);
+      }
+    }
 
     await writeWorkspace(host, workspace);
 
-    const { main } = buildOptions;
-
     return chain([
+      addDependencies(),
       mergeWith(
         apply(url('./files'), [
           applyTemplates({
@@ -172,8 +173,9 @@ export default function (options: ServiceWorkerOptions): Rule {
           move(project.root),
         ]),
       ),
-      addDependencies(),
-      isStandaloneApp(host, main) ? addProvideServiceWorker(main) : updateAppModule(main),
+      isStandaloneApp(host, browserEntryPoint)
+        ? addProvideServiceWorker(browserEntryPoint)
+        : updateAppModule(browserEntryPoint),
     ]);
   };
 }
diff --git a/packages/schematics/angular/service-worker/index_spec.ts b/packages/schematics/angular/service-worker/index_spec.ts
index 63f962a4179f..644e98ac00bb 100644
--- a/packages/schematics/angular/service-worker/index_spec.ts
+++ b/packages/schematics/angular/service-worker/index_spec.ts
@@ -9,6 +9,7 @@
 import { tags } from '@angular-devkit/core';
 import { SchematicTestRunner, UnitTestTree } from '@angular-devkit/schematics/testing';
 import { Schema as ApplicationOptions } from '../application/schema';
+import { Builders } from '../utility/workspace-models';
 import { Schema as WorkspaceOptions } from '../workspace/schema';
 import { Schema as ServiceWorkerOptions } from './schema';
 
@@ -49,7 +50,9 @@ describe('Service Worker Schematic', () => {
     const configText = tree.readContent('/angular.json');
     const buildConfig = JSON.parse(configText).projects.bar.architect.build;
 
-    expect(buildConfig.options.serviceWorker).toBeTrue();
+    expect(buildConfig.configurations.production.serviceWorker).toBe(
+      'projects/bar/ngsw-config.json',
+    );
   });
 
   it('should add the necessary dependency', async () => {
@@ -87,7 +90,7 @@ describe('Service Worker Schematic', () => {
     expect(tree.exists(path)).toEqual(true);
 
     const { projects } = JSON.parse(tree.readContent('/angular.json'));
-    expect(projects.bar.architect.build.options.ngswConfigPath).toBe(
+    expect(projects.bar.architect.build.configurations.production.serviceWorker).toBe(
       'projects/bar/ngsw-config.json',
     );
   });
@@ -130,19 +133,7 @@ describe('Service Worker Schematic', () => {
     const pkgText = tree.readContent('/projects/bar/ngsw-config.json');
     const config = JSON.parse(pkgText);
     expect(config.assetGroups[1].resources.files).toContain(
-      '/*.(svg|cur|jpg|jpeg|png|apng|webp|avif|gif|otf|ttf|woff|woff2)',
-    );
-  });
-
-  it('should add resourcesOutputPath to root assets when specified', async () => {
-    const config = JSON.parse(appTree.readContent('/angular.json'));
-    config.projects.bar.architect.build.options.resourcesOutputPath = 'outDir';
-    appTree.overwrite('/angular.json', JSON.stringify(config));
-    const tree = await schematicRunner.runSchematic('service-worker', defaultOptions, appTree);
-    const pkgText = tree.readContent('/projects/bar/ngsw-config.json');
-    const ngswConfig = JSON.parse(pkgText);
-    expect(ngswConfig.assetGroups[1].resources.files).toContain(
-      '/outDir/*.(svg|cur|jpg|jpeg|png|apng|webp|avif|gif|otf|ttf|woff|woff2)',
+      '/media/*.(svg|cur|jpg|jpeg|png|apng|webp|avif|gif|otf|ttf|woff|woff2)',
     );
   });
 
@@ -161,9 +152,6 @@ describe('Service Worker Schematic', () => {
     let tree = await schematicRunner.runSchematic('application', rootAppOptions, appTree);
     tree = await schematicRunner.runSchematic('service-worker', rootSWOptions, tree);
     expect(tree.exists('/ngsw-config.json')).toBe(true);
-
-    const { projects } = JSON.parse(tree.readContent('/angular.json'));
-    expect(projects.foo.architect.build.options.ngswConfigPath).toBe('ngsw-config.json');
   });
 
   describe('standalone', () => {
@@ -217,4 +205,59 @@ describe('Service Worker Schematic', () => {
       expect(content).toContain(`import { provideServiceWorker } from '@angular/service-worker';`);
     });
   });
+
+  describe('Legacy browser builder', () => {
+    function convertBuilderToLegacyBrowser(): void {
+      const config = JSON.parse(appTree.readContent('/angular.json'));
+      const build = config.projects.bar.architect.build;
+
+      build.builder = Builders.Browser;
+      build.options = {
+        ...build.options,
+        main: build.options.browser,
+        browser: undefined,
+      };
+
+      build.configurations.development = {
+        ...build.configurations.development,
+        vendorChunk: true,
+        namedChunks: true,
+        buildOptimizer: false,
+      };
+
+      appTree.overwrite('/angular.json', JSON.stringify(config, undefined, 2));
+    }
+
+    beforeEach(() => {
+      convertBuilderToLegacyBrowser();
+    });
+
+    it('should add resourcesOutputPath to root assets when specified', async () => {
+      const config = JSON.parse(appTree.readContent('/angular.json'));
+      config.projects.bar.architect.build.options.resourcesOutputPath = 'outDir';
+      appTree.overwrite('/angular.json', JSON.stringify(config));
+      const tree = await schematicRunner.runSchematic('service-worker', defaultOptions, appTree);
+      const pkgText = tree.readContent('/projects/bar/ngsw-config.json');
+      const ngswConfig = JSON.parse(pkgText);
+      expect(ngswConfig.assetGroups[1].resources.files).toContain(
+        '/outDir/*.(svg|cur|jpg|jpeg|png|apng|webp|avif|gif|otf|ttf|woff|woff2)',
+      );
+    });
+
+    it('should add `serviceWorker` option to build target', async () => {
+      const tree = await schematicRunner.runSchematic('service-worker', defaultOptions, appTree);
+      const configText = tree.readContent('/angular.json');
+      const buildConfig = JSON.parse(configText).projects.bar.architect.build;
+
+      expect(buildConfig.options.serviceWorker).toBeTrue();
+    });
+
+    it('should add `ngswConfigPath` option to build target', async () => {
+      const tree = await schematicRunner.runSchematic('service-worker', defaultOptions, appTree);
+      const configText = tree.readContent('/angular.json');
+      const buildConfig = JSON.parse(configText).projects.bar.architect.build;
+
+      expect(buildConfig.options.ngswConfigPath).toBe('projects/bar/ngsw-config.json');
+    });
+  });
 });
diff --git a/packages/schematics/angular/universal/files/src/__main@stripTsExtension__.ts.template b/packages/schematics/angular/universal/files/src/__main@stripTsExtension__.ts.template
deleted file mode 100644
index 5ccc29c792b0..000000000000
--- a/packages/schematics/angular/universal/files/src/__main@stripTsExtension__.ts.template
+++ /dev/null
@@ -1,2 +0,0 @@
-
-export { <%= rootModuleClassName %> } from './app/<%= stripTsExtension(rootModuleFileName) %>';
diff --git a/packages/schematics/angular/universal/index_spec.ts b/packages/schematics/angular/universal/index_spec.ts
deleted file mode 100644
index c2dbf575fc56..000000000000
--- a/packages/schematics/angular/universal/index_spec.ts
+++ /dev/null
@@ -1,242 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import { SchematicTestRunner, UnitTestTree } from '@angular-devkit/schematics/testing';
-import { parse as parseJson } from 'jsonc-parser';
-import { Schema as ApplicationOptions, Style } from '../application/schema';
-import { CompilerOptions } from '../third_party/github.com/Microsoft/TypeScript/lib/typescript';
-import { NodeDependencyType, addPackageJsonDependency } from '../utility/dependencies';
-import { Schema as WorkspaceOptions } from '../workspace/schema';
-import { Schema as UniversalOptions } from './schema';
-
-describe('Universal Schematic', () => {
-  const schematicRunner = new SchematicTestRunner(
-    '@schematics/angular',
-    require.resolve('../collection.json'),
-  );
-  const defaultOptions: UniversalOptions = {
-    project: 'bar',
-  };
-  const workspaceUniversalOptions: UniversalOptions = {
-    project: 'workspace',
-  };
-
-  const workspaceOptions: WorkspaceOptions = {
-    name: 'workspace',
-    newProjectRoot: 'projects',
-    version: '6.0.0',
-  };
-
-  const appOptions: ApplicationOptions = {
-    name: 'bar',
-    inlineStyle: false,
-    inlineTemplate: false,
-    routing: false,
-    style: Style.Css,
-    skipTests: false,
-    skipPackageJson: false,
-  };
-
-  const initialWorkspaceAppOptions: ApplicationOptions = {
-    name: 'workspace',
-    projectRoot: '',
-    inlineStyle: false,
-    inlineTemplate: false,
-    routing: false,
-    style: Style.Css,
-    skipTests: false,
-    skipPackageJson: false,
-  };
-
-  let appTree: UnitTestTree;
-
-  beforeEach(async () => {
-    appTree = await schematicRunner.runSchematic('workspace', workspaceOptions);
-    appTree = await schematicRunner.runSchematic(
-      'application',
-      initialWorkspaceAppOptions,
-      appTree,
-    );
-    appTree = await schematicRunner.runSchematic('application', appOptions, appTree);
-  });
-
-  it('should create a root module file', async () => {
-    const tree = await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    const filePath = '/projects/bar/src/app/app.module.server.ts';
-    expect(tree.exists(filePath)).toEqual(true);
-  });
-
-  it('should create a main file', async () => {
-    const tree = await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    const filePath = '/projects/bar/src/main.server.ts';
-    expect(tree.exists(filePath)).toEqual(true);
-    const contents = tree.readContent(filePath);
-    expect(contents).toMatch(/export { AppServerModule } from '\.\/app\/app\.module\.server'/);
-  });
-
-  it('should create a tsconfig file for the workspace project', async () => {
-    const tree = await schematicRunner.runSchematic(
-      'universal',
-      workspaceUniversalOptions,
-      appTree,
-    );
-    const filePath = '/tsconfig.server.json';
-    expect(tree.exists(filePath)).toEqual(true);
-    const contents = parseJson(tree.readContent(filePath).toString());
-    expect(contents).toEqual({
-      extends: './tsconfig.app.json',
-      compilerOptions: {
-        outDir: './out-tsc/server',
-        types: ['node'],
-      },
-      files: ['src/main.server.ts'],
-    });
-    const angularConfig = JSON.parse(tree.readContent('angular.json'));
-    expect(angularConfig.projects.workspace.architect.server.options.tsConfig).toEqual(
-      'tsconfig.server.json',
-    );
-  });
-
-  it('should create a tsconfig file for a generated application', async () => {
-    const tree = await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    const filePath = '/projects/bar/tsconfig.server.json';
-    expect(tree.exists(filePath)).toEqual(true);
-    const contents = parseJson(tree.readContent(filePath).toString());
-    expect(contents).toEqual({
-      extends: './tsconfig.app.json',
-      compilerOptions: {
-        outDir: '../../out-tsc/server',
-        types: ['node'],
-      },
-      files: ['src/main.server.ts'],
-    });
-    const angularConfig = JSON.parse(tree.readContent('angular.json'));
-    expect(angularConfig.projects.bar.architect.server.options.tsConfig).toEqual(
-      'projects/bar/tsconfig.server.json',
-    );
-  });
-
-  it('should add dependency: @angular/platform-server', async () => {
-    const tree = await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    const filePath = '/package.json';
-    const contents = tree.readContent(filePath);
-    expect(contents).toMatch(/"@angular\/platform-server": "/);
-  });
-
-  it('should update workspace with a server target', async () => {
-    const tree = await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    const filePath = '/angular.json';
-    const contents = tree.readContent(filePath);
-    const config = JSON.parse(contents.toString());
-    const targets = config.projects.bar.architect;
-    expect(targets.server).toBeDefined();
-    expect(targets.server.builder).toBeDefined();
-    const opts = targets.server.options;
-    expect(opts.outputPath).toEqual('dist/bar/server');
-    expect(opts.main).toEqual('projects/bar/src/main.server.ts');
-    expect(opts.tsConfig).toEqual('projects/bar/tsconfig.server.json');
-  });
-
-  it('should update workspace with a build target outputPath', async () => {
-    const tree = await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    const filePath = '/angular.json';
-    const contents = tree.readContent(filePath);
-    const config = JSON.parse(contents.toString());
-    const targets = config.projects.bar.architect;
-    expect(targets.build.options.outputPath).toEqual('dist/bar/browser');
-  });
-
-  it('should install npm dependencies', async () => {
-    await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    expect(schematicRunner.tasks.length).toBe(1);
-    expect(schematicRunner.tasks[0].name).toBe('node-package');
-    expect((schematicRunner.tasks[0].options as { command: string }).command).toBe('install');
-  });
-
-  it(`should work when 'tsconfig.app.json' has comments`, async () => {
-    const appTsConfigPath = '/projects/bar/tsconfig.app.json';
-    const appTsConfigContent = appTree.readContent(appTsConfigPath);
-    appTree.overwrite(appTsConfigPath, '// comment in json file\n' + appTsConfigContent);
-
-    const tree = await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    const filePath = '/projects/bar/tsconfig.server.json';
-    expect(tree.exists(filePath)).toEqual(true);
-  });
-
-  it(`should not add import to '@angular/localize' as type in 'tsconfig.server.json' when it's not a dependency`, async () => {
-    const tree = await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    const { compilerOptions } = tree.readJson('/projects/bar/tsconfig.server.json') as {
-      compilerOptions: CompilerOptions;
-    };
-    expect(compilerOptions.types).not.toContain('@angular/localize');
-  });
-
-  it(`should add import to '@angular/localize' as type in 'tsconfig.server.json' when it's a dependency`, async () => {
-    addPackageJsonDependency(appTree, {
-      name: '@angular/localize',
-      type: NodeDependencyType.Default,
-      version: 'latest',
-    });
-    const tree = await schematicRunner.runSchematic('universal', defaultOptions, appTree);
-    const { compilerOptions } = tree.readJson('/projects/bar/tsconfig.server.json') as {
-      compilerOptions: CompilerOptions;
-    };
-    expect(compilerOptions.types).toContain('@angular/localize');
-  });
-
-  describe('standalone application', () => {
-    let standaloneAppOptions;
-    let defaultStandaloneOptions: UniversalOptions;
-    beforeEach(async () => {
-      const standaloneAppName = 'baz';
-      standaloneAppOptions = {
-        ...appOptions,
-        name: standaloneAppName,
-        standalone: true,
-      };
-      defaultStandaloneOptions = {
-        project: standaloneAppName,
-      };
-      appTree = await schematicRunner.runSchematic('application', standaloneAppOptions, appTree);
-    });
-
-    it('should create not root module file', async () => {
-      const tree = await schematicRunner.runSchematic(
-        'universal',
-        defaultStandaloneOptions,
-        appTree,
-      );
-      const filePath = '/projects/baz/src/app/app.module.server.ts';
-      expect(tree.exists(filePath)).toEqual(false);
-    });
-
-    it('should create a main file', async () => {
-      const tree = await schematicRunner.runSchematic(
-        'universal',
-        defaultStandaloneOptions,
-        appTree,
-      );
-      const filePath = '/projects/baz/src/main.server.ts';
-      expect(tree.exists(filePath)).toEqual(true);
-      const contents = tree.readContent(filePath);
-      expect(contents).toContain(`bootstrapApplication(AppComponent, config)`);
-    });
-
-    it('should create server app config file', async () => {
-      const tree = await schematicRunner.runSchematic(
-        'universal',
-        defaultStandaloneOptions,
-        appTree,
-      );
-      const filePath = '/projects/baz/src/app/app.config.server.ts';
-      expect(tree.exists(filePath)).toEqual(true);
-      const contents = tree.readContent(filePath);
-      expect(contents).toContain(`const serverConfig: ApplicationConfig = {`);
-    });
-  });
-});
diff --git a/packages/schematics/angular/universal/schema.json b/packages/schematics/angular/universal/schema.json
deleted file mode 100644
index 1ad12fbfbf27..000000000000
--- a/packages/schematics/angular/universal/schema.json
+++ /dev/null
@@ -1,40 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema",
-  "$id": "SchematicsAngularUniversalApp",
-  "title": "Angular Universal App Options Schema",
-  "type": "object",
-  "additionalProperties": false,
-  "description": "Pass this schematic to the \"run\" command to set up server-side rendering for an app.",
-  "properties": {
-    "project": {
-      "type": "string",
-      "description": "The name of the project.",
-      "$default": {
-        "$source": "projectName"
-      }
-    },
-    "main": {
-      "type": "string",
-      "format": "path",
-      "description": "The name of the main entry-point file.",
-      "default": "main.server.ts"
-    },
-    "rootModuleFileName": {
-      "type": "string",
-      "format": "path",
-      "description": "The name of the root NgModule file.",
-      "default": "app.module.server.ts"
-    },
-    "rootModuleClassName": {
-      "type": "string",
-      "description": "The name of the root NgModule class.",
-      "default": "AppServerModule"
-    },
-    "skipInstall": {
-      "description": "Do not install packages for dependencies.",
-      "type": "boolean",
-      "default": false
-    }
-  },
-  "required": ["project"]
-}
diff --git a/packages/schematics/angular/utility/standalone/util.ts b/packages/schematics/angular/utility/standalone/util.ts
index 8195acd69725..29214f3bd1fa 100644
--- a/packages/schematics/angular/utility/standalone/util.ts
+++ b/packages/schematics/angular/utility/standalone/util.ts
@@ -11,7 +11,7 @@ import ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript
 import { Change, applyToUpdateRecorder } from '../change';
 import { targetBuildNotFoundError } from '../project-targets';
 import { getWorkspace } from '../workspace';
-import { BrowserBuilderOptions } from '../workspace-models';
+import { Builders } from '../workspace-models';
 
 /**
  * Finds the main file of a project.
@@ -27,7 +27,9 @@ export async function getMainFilePath(tree: Tree, projectName: string): Promise<
     throw targetBuildNotFoundError();
   }
 
-  return ((buildTarget.options || {}) as unknown as BrowserBuilderOptions).main;
+  const options = buildTarget.options as Record<string, string>;
+
+  return buildTarget.builder === Builders.Application ? options.browser : options.main;
 }
 
 /**
diff --git a/packages/schematics/angular/utility/workspace-models.ts b/packages/schematics/angular/utility/workspace-models.ts
index f64e0de4f922..52a2148b80aa 100644
--- a/packages/schematics/angular/utility/workspace-models.ts
+++ b/packages/schematics/angular/utility/workspace-models.ts
@@ -18,12 +18,13 @@ export enum ProjectType {
  * `angular.json` workspace file.
  */
 export enum Builders {
+  Application = '@angular-devkit/build-angular:application',
   AppShell = '@angular-devkit/build-angular:app-shell',
   Server = '@angular-devkit/build-angular:server',
   Browser = '@angular-devkit/build-angular:browser',
+  BrowserEsbuild = '@angular-devkit/build-angular:browser-esbuild',
   Karma = '@angular-devkit/build-angular:karma',
   TsLint = '@angular-devkit/build-angular:tslint',
-  DeprecatedNgPackagr = '@angular-devkit/build-ng-packagr:build',
   NgPackagr = '@angular-devkit/build-angular:ng-packagr',
   DevServer = '@angular-devkit/build-angular:dev-server',
   ExtractI18n = '@angular-devkit/build-angular:extract-i18n',
diff --git a/packages/schematics/angular/workspace/files/tsconfig.json.template b/packages/schematics/angular/workspace/files/tsconfig.json.template
index cac9dd40cf28..cb51da79c7ee 100644
--- a/packages/schematics/angular/workspace/files/tsconfig.json.template
+++ b/packages/schematics/angular/workspace/files/tsconfig.json.template
@@ -10,6 +10,7 @@
     "noPropertyAccessFromIndexSignature": true,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,<% } %>
+    "allowSyntheticDefaultImports": true,
     "sourceMap": true,
     "declaration": false,
     "downlevelIteration": true,
diff --git a/tests/legacy-cli/e2e/tests/build/server/platform-server-build-optimizer.ts b/tests/legacy-cli/e2e/tests/build/server/platform-server-build-optimizer.ts
index 8a15c9279e1a..dfece1b506bd 100644
--- a/tests/legacy-cli/e2e/tests/build/server/platform-server-build-optimizer.ts
+++ b/tests/legacy-cli/e2e/tests/build/server/platform-server-build-optimizer.ts
@@ -9,7 +9,7 @@ const snapshots = require('../../../ng-snapshot/package.json');
 
 export default async function () {
   await ng('generate', 'application', 'test-project-two', '--standalone', '--skip-install');
-  await ng('generate', 'universal', '--project', 'test-project-two');
+  await ng('generate', 'server', '--project', 'test-project-two');
 
   const isSnapshotBuild = getGlobalVariable('argv')['ng-snapshots'];
   if (isSnapshotBuild) {
diff --git a/tests/legacy-cli/e2e/tests/build/server/platform-server-standalone.ts b/tests/legacy-cli/e2e/tests/build/server/platform-server-standalone.ts
index 3291afbd8e08..6d422f39e35f 100644
--- a/tests/legacy-cli/e2e/tests/build/server/platform-server-standalone.ts
+++ b/tests/legacy-cli/e2e/tests/build/server/platform-server-standalone.ts
@@ -9,7 +9,7 @@ const snapshots = require('../../../ng-snapshot/package.json');
 
 export default async function () {
   await ng('generate', 'application', 'test-project-two', '--standalone', '--skip-install');
-  await ng('generate', 'universal', '--project', 'test-project-two');
+  await ng('generate', 'server', '--project', 'test-project-two');
 
   const isSnapshotBuild = getGlobalVariable('argv')['ng-snapshots'];
   if (isSnapshotBuild) {
diff --git a/tests/legacy-cli/e2e/tests/build/server/platform-server.ts b/tests/legacy-cli/e2e/tests/build/server/platform-server.ts
index 8154e2aee283..a58278fb241a 100644
--- a/tests/legacy-cli/e2e/tests/build/server/platform-server.ts
+++ b/tests/legacy-cli/e2e/tests/build/server/platform-server.ts
@@ -8,7 +8,7 @@ import { updateJsonFile } from '../../../utils/project';
 const snapshots = require('../../../ng-snapshot/package.json');
 
 export default async function () {
-  await ng('generate', 'universal', '--project', 'test-project');
+  await ng('generate', 'server', '--project', 'test-project');
 
   const isSnapshotBuild = getGlobalVariable('argv')['ng-snapshots'];
   if (isSnapshotBuild) {