@@ -18,7 +18,6 @@ import {
   BuildOutputFileType,
   createOutputFile,
 } from '../../tools/esbuild/bundler-files';
-import { calculateHash } from '../hash';
 import { findNonce } from '../index-file/nonce';
 import { joinUrlParts } from '../url';
 
@@ -61,37 +60,6 @@ function escapeUnsafeChars(str: string): string {
   return str.replace(/[$`\\]/g, (c) => UNSAFE_CHAR_MAP[c]);
 }
 
-/**
- * Matches every character which is not safe in the name of a generated server asset chunk.
- */
-const UNSAFE_CHUNK_NAME_CHARACTER_REGEXP = /[^a-zA-Z0-9_-]/g;
-
-/**
- * The maximum number of characters of an asset path kept in the name of its generated chunk.
- * The appended digest is what makes the name unique, so the readable part can be truncated to
- * stay well within the file name length limits of all supported platforms.
- */
-const MAX_CHUNK_NAME_LENGTH = 128;
-
-/**
- * Builds the path of the generated chunk which holds the content of a server asset.
- *
- * Asset paths are derived from route paths and can therefore contain characters which are unusable
- * in a file name (`?`, `:` and `*` are invalid on Windows) or which change how the generated
- * dynamic import is resolved (`?`, `#` and `%` are URL syntax). Those characters are replaced, and
- * a digest of the asset path is appended so that two asset paths never share a chunk.
- *
- * @param assetPath - The path of the asset, for example `store/summer sale/index.html`.
- * @returns The path of the chunk to generate for the asset.
- */
-function generateServerAssetChunkPath(assetPath: string): string {
-  const name = assetPath
-    .replace(UNSAFE_CHUNK_NAME_CHARACTER_REGEXP, '_')
-    .slice(0, MAX_CHUNK_NAME_LENGTH);
-
-  return `assets-chunks/${name}-${calculateHash(assetPath)}.mjs`;
-}
-
 /**
  * Generates the server manifest for the App Engine environment.
  *
@@ -202,7 +170,7 @@ export async function generateAngularServerAppManifest(
   for (const file of [...additionalHtmlOutputFiles.values(), ...outputFiles]) {
     const extension = extname(file.path);
     if (extension === '.html') {
-      const jsChunkFilePath = generateServerAssetChunkPath(file.path);
+      const jsChunkFilePath = `assets-chunks/${file.path.replace(/[./]/g, '_')}.mjs`;
       const escapedContent = escapeUnsafeChars(file.text);
 
       serverAssetsChunks.push(
 
@@ -11,48 +11,45 @@ import { BuildOutputFileType, createOutputFile } from '../../tools/esbuild/bundl
 import { initializeHash } from '../hash';
 import { generateAngularServerAppManifest } from './manifest';
 
-/**
- * Evaluates a generated manifest, which both asserts that it is syntactically valid JavaScript and
- * gives access to the values it declares. The dynamic imports it contains are never invoked.
- */
-function evaluateManifest(manifestContent: string): Record<string, unknown> {
-  return new Function(manifestContent.replace('export default', 'return'))() as Record<
-    string,
-    unknown
-  >;
-}
-
-const dummyMetafile = { inputs: {}, outputs: {} } as unknown as Metafile;
-
-function generateManifest(
-  htmlOutputFiles: Record<string, string>,
-  baseHref = '/',
-): ReturnType<typeof generateAngularServerAppManifest> {
-  const additionalHtmlOutputFiles = new Map(
-    Object.entries(htmlOutputFiles).map(([path, content]) => [
-      path,
-      createOutputFile(path, content, BuildOutputFileType.Browser),
-    ]),
-  );
-
-  return generateAngularServerAppManifest(
-    additionalHtmlOutputFiles,
-    [],
-    false,
-    undefined,
-    undefined,
-    baseHref,
-    new Set(),
-    dummyMetafile,
-    undefined,
-  );
-}
-
 describe('generateAngularServerAppManifest', () => {
   beforeAll(async () => {
     await initializeHash();
   });
 
+  const dummyMetafile = { inputs: {}, outputs: {} } as unknown as Metafile;
+
+  /**
+   * Evaluates a generated manifest, which both asserts that it is syntactically valid JavaScript and
+   * gives access to the values it declares. The dynamic imports it contains are never invoked.
+   */
+  function evaluateManifest(manifestContent: string): unknown {
+    return new Function(manifestContent.replace('export default', 'return'))();
+  }
+
+  function generateManifest(
+    htmlOutputFiles: Record<string, string>,
+    baseHref = '/',
+  ): ReturnType<typeof generateAngularServerAppManifest> {
+    const additionalHtmlOutputFiles = new Map(
+      Object.entries(htmlOutputFiles).map(([path, content]) => [
+        path,
+        createOutputFile(path, content, BuildOutputFileType.Browser),
+      ]),
+    );
+
+    return generateAngularServerAppManifest(
+      additionalHtmlOutputFiles,
+      [],
+      false,
+      undefined,
+      undefined,
+      baseHref,
+      new Set(),
+      dummyMetafile,
+      undefined,
+    );
+  }
+
   it('should include criticalCssPlans when inlineCriticalCss is true', async () => {
     const additionalHtml = new Map([
       [
@@ -176,63 +173,35 @@ describe('generateAngularServerAppManifest', () => {
     expect(manifestContent).not.toContain('"styles.css":');
   });
 
-  it('serializes asset paths which contain JavaScript string delimiters', async () => {
+  it('should serialize asset paths which contain JavaScript string delimiters', async () => {
     const assetPath = "catalog/customer's-choice/index.html";
     const { manifestContent } = await generateManifest({
       [assetPath]: '<main>Featured</main>',
     });
 
-    const assets = evaluateManifest(manifestContent)['assets'] as Record<string, unknown>;
-    expect(Object.keys(assets)).toEqual([assetPath]);
+    expect(evaluateManifest(manifestContent)).toEqual(
+      jasmine.objectContaining({
+        assets: {
+          [assetPath]: jasmine.objectContaining({
+            size: 21,
+            hash: jasmine.any(String),
+            text: jasmine.any(Function),
+          }),
+        },
+      }),
+    );
   });
 
-  it('serializes a base href which contains JavaScript string delimiters', async () => {
+  it('should serialize a base href which contains JavaScript string delimiters', async () => {
     const { manifestContent } = await generateManifest(
       { 'index.html': '<main></main>' },
       "/o'brien/",
     );
 
-    expect(evaluateManifest(manifestContent)['baseHref']).toBe("/o'brien/");
-  });
-
-  it('generates chunk names which are usable as a file name and as a module specifier', async () => {
-    const assetPath = "catalog/customer's#featured?ratio=50%/index.html";
-    const { serverAssetsChunks } = await generateManifest({
-      [assetPath]: '<main>Featured</main>',
-    });
-
-    expect(serverAssetsChunks).toHaveSize(1);
-    expect(serverAssetsChunks[0].path).toMatch(/^assets-chunks\/[a-zA-Z0-9_-]+\.mjs$/);
-  });
-
-  it('generates a dynamic import which resolves back to the emitted chunk', async () => {
-    // The in-memory ESM loader used while prerendering resolves the specifier as a URL and looks the
-    // result up by output file path, so the two have to match exactly.
-    const assetPath = "catalog/customer's#featured?ratio=50%/index.html";
-    const { manifestContent, serverAssetsChunks } = await generateManifest({
-      [assetPath]: '<main>Featured</main>',
-    });
-
-    const assets = evaluateManifest(manifestContent)['assets'] as Record<
-      string,
-      { text: () => Promise<string> }
-    >;
-    const specifier = /import\("(.+?)"\)/.exec(assets[assetPath].text.toString())?.[1];
-
-    const root = 'file:///virtual/root/';
-    expect(specifier).toBeDefined();
-    expect(new URL(specifier as string, root).href.slice(root.length)).toBe(
-      serverAssetsChunks[0].path,
+    expect(evaluateManifest(manifestContent)).toEqual(
+      jasmine.objectContaining({
+        baseHref: "/o'brien/",
+      }),
     );
   });
-
-  it('generates a distinct chunk for asset paths which map to the same name', async () => {
-    const { serverAssetsChunks } = await generateManifest({
-      'foo/bar/index.html': '<main>nested</main>',
-      'foo_bar/index.html': '<main>flat</main>',
-    });
-
-    expect(serverAssetsChunks).toHaveSize(2);
-    expect(serverAssetsChunks[0].path).not.toBe(serverAssetsChunks[1].path);
-  });
 });