@angular/ssr 19.2.0-next.0 → 19.2.0-next.2

package/fesm2022/ssr.mjs

@@ -1,7 +1,7 @@
 import { APP_BASE_HREF, PlatformLocation } from '@angular/common';
 import { ɵConsole as _Console, InjectionToken, makeEnvironmentProviders, runInInjectionContext, ɵENABLE_ROOT_COMPONENT_BOOTSTRAP as _ENABLE_ROOT_COMPONENT_BOOTSTRAP, ApplicationRef, Compiler, REQUEST, REQUEST_CONTEXT, RESPONSE_INIT, LOCALE_ID, ɵresetCompiledComponents as _resetCompiledComponents } from '@angular/core';
 import { ɵSERVER_CONTEXT as _SERVER_CONTEXT, renderModule, renderApplication, platformServer, INITIAL_CONFIG } from '@angular/platform-server';
-import { ɵloadChildren as _loadChildren, Router } from '@angular/router';
+import { ROUTES, ɵloadChildren as _loadChildren, Router } from '@angular/router';
 import Beasties from '../third_party/beasties/index.js';
 
 /**
@@ -399,9 +399,23 @@ function promiseWithAbort(promise, signal, errorMessagePrefix) {
     });
 }
 
+/**
+ * The internal path used for the app shell route.
+ * @internal
+ */
+const APP_SHELL_ROUTE = 'ng-app-shell';
+/**
+ * Identifies a particular kind of `ServerRoutesFeatureKind`.
+ * @see {@link ServerRoutesFeature}
+ * @developerPreview
+ */
+var ServerRoutesFeatureKind;
+(function (ServerRoutesFeatureKind) {
+    ServerRoutesFeatureKind[ServerRoutesFeatureKind["AppShell"] = 0] = "AppShell";
+})(ServerRoutesFeatureKind || (ServerRoutesFeatureKind = {}));
 /**
  * Different rendering modes for server routes.
- * @see {@link provideServerRoutesConfig}
+ * @see {@link provideServerRouting}
  * @see {@link ServerRoute}
  * @developerPreview
  */
@@ -455,6 +469,8 @@ const SERVER_ROUTES_CONFIG = new InjectionToken('SERVER_ROUTES_CONFIG');
  *
  * @see {@link ServerRoute}
  * @see {@link ServerRoutesConfigOptions}
+ * @see {@link provideServerRouting}
+ * @deprecated use `provideServerRouting`. This will be removed in version 20.
  * @developerPreview
  */
 function provideServerRoutesConfig(routes, options) {
@@ -468,6 +484,75 @@ function provideServerRoutesConfig(routes, options) {
         },
     ]);
 }
+/**
+ * Sets up the necessary providers for configuring server routes.
+ * This function accepts an array of server routes and optional configuration
+ * options, returning an `EnvironmentProviders` object that encapsulates
+ * the server routes and configuration settings.
+ *
+ * @param routes - An array of server routes to be provided.
+ * @param features - (Optional) server routes features.
+ * @returns An `EnvironmentProviders` instance with the server routes configuration.
+ *
+ * @see {@link ServerRoute}
+ * @see {@link withAppShell}
+ * @developerPreview
+ */
+function provideServerRouting(routes, ...features) {
+    const config = { routes };
+    const hasAppShell = features.some((f) => f.ɵkind === ServerRoutesFeatureKind.AppShell);
+    if (hasAppShell) {
+        config.appShellRoute = APP_SHELL_ROUTE;
+    }
+    const providers = [
+        {
+            provide: SERVER_ROUTES_CONFIG,
+            useValue: config,
+        },
+    ];
+    for (const feature of features) {
+        providers.push(...feature.ɵproviders);
+    }
+    return makeEnvironmentProviders(providers);
+}
+/**
+ * Configures the app shell route with the provided component.
+ *
+ * The app shell serves as the main entry point for the application and is commonly used
+ * to enable server-side rendering (SSR) of the application shell. It handles requests
+ * that do not match any specific server route, providing a fallback mechanism and improving
+ * perceived performance during navigation.
+ *
+ * This configuration is particularly useful in applications leveraging Progressive Web App (PWA)
+ * patterns, such as service workers, to deliver a seamless user experience.
+ *
+ * @param component The Angular component to render for the app shell route.
+ * @returns A server routes feature configuration for the app shell.
+ *
+ * @see {@link provideServerRouting}
+ * @see {@link https://angular.dev/ecosystem/service-workers/app-shell | App shell pattern on Angular.dev}
+ */
+function withAppShell(component) {
+    const routeConfig = {
+        path: APP_SHELL_ROUTE,
+    };
+    if ('ɵcmp' in component) {
+        routeConfig.component = component;
+    }
+    else {
+        routeConfig.loadComponent = component;
+    }
+    return {
+        ɵkind: ServerRoutesFeatureKind.AppShell,
+        ɵproviders: [
+            {
+                provide: ROUTES,
+                useValue: routeConfig,
+                multi: true,
+            },
+        ],
+    };
+}
 
 /**
  * A route tree implementation that supports efficient route matching, including support for wildcard routes.
@@ -482,12 +567,6 @@ class RouteTree {
      * All routes are stored and accessed relative to this root node.
      */
     root = this.createEmptyRouteTreeNode();
-    /**
-     * A counter that tracks the order of route insertion.
-     * This ensures that routes are matched in the order they were defined,
-     * with earlier routes taking precedence.
-     */
-    insertionIndexCounter = 0;
     /**
      * Inserts a new route into the route tree.
      * The route is broken down into segments, and each segment is added to the tree.
@@ -516,7 +595,6 @@ class RouteTree {
             ...metadata,
             route: addLeadingSlash(normalizedSegments.join('/')),
         };
-        node.insertionIndex = this.insertionIndexCounter++;
     }
     /**
      * Matches a given route against the route tree and returns the best matching route's metadata.
@@ -579,7 +657,7 @@ class RouteTree {
      * @returns An array of path segments.
      */
     getPathSegments(route) {
-        return stripTrailingSlash(route).split('/');
+        return route.split('/').filter(Boolean);
     }
     /**
      * Recursively traverses the route tree from a given node, attempting to match the remaining route segments.
@@ -588,52 +666,39 @@ class RouteTree {
      * This function prioritizes exact segment matches first, followed by wildcard matches (`*`),
      * and finally deep wildcard matches (`**`) that consume all segments.
      *
-     * @param remainingSegments - The remaining segments of the route path to match.
-     * @param node - The current node in the route tree to start traversal from.
+     * @param segments - The array of route path segments to match against the route tree.
+     * @param node - The current node in the route tree to start traversal from. Defaults to the root node.
+     * @param currentIndex - The index of the segment in `remainingSegments` currently being matched.
+     * Defaults to `0` (the first segment).
      *
      * @returns The node that best matches the remaining segments or `undefined` if no match is found.
      */
-    traverseBySegments(remainingSegments, node = this.root) {
-        const { metadata, children } = node;
-        // If there are no remaining segments and the node has metadata, return this node
-        if (!remainingSegments.length) {
-            return metadata ? node : node.children.get('**');
-        }
-        // If the node has no children, end the traversal
-        if (!children.size) {
-            return;
+    traverseBySegments(segments, node = this.root, currentIndex = 0) {
+        if (currentIndex >= segments.length) {
+            return node.metadata ? node : node.children.get('**');
         }
-        const [segment, ...restSegments] = remainingSegments;
-        let currentBestMatchNode;
-        // 1. Exact segment match
-        const exactMatchNode = node.children.get(segment);
-        currentBestMatchNode = this.getHigherPriorityNode(currentBestMatchNode, this.traverseBySegments(restSegments, exactMatchNode));
-        // 2. Wildcard segment match (`*`)
-        const wildcardNode = node.children.get('*');
-        currentBestMatchNode = this.getHigherPriorityNode(currentBestMatchNode, this.traverseBySegments(restSegments, wildcardNode));
-        // 3. Deep wildcard segment match (`**`)
-        const deepWildcardNode = node.children.get('**');
-        currentBestMatchNode = this.getHigherPriorityNode(currentBestMatchNode, deepWildcardNode);
-        return currentBestMatchNode;
-    }
-    /**
-     * Compares two nodes and returns the node with higher priority based on insertion index.
-     * A node with a lower insertion index is prioritized as it was defined earlier.
-     *
-     * @param currentBestMatchNode - The current best match node.
-     * @param candidateNode - The node being evaluated for higher priority based on insertion index.
-     * @returns The node with higher priority (i.e., lower insertion index). If one of the nodes is `undefined`, the other node is returned.
-     */
-    getHigherPriorityNode(currentBestMatchNode, candidateNode) {
-        if (!candidateNode) {
-            return currentBestMatchNode;
+        if (!node.children.size) {
+            return undefined;
         }
-        if (!currentBestMatchNode) {
-            return candidateNode;
+        const segment = segments[currentIndex];
+        // 1. Attempt exact match with the current segment.
+        const exactMatch = node.children.get(segment);
+        if (exactMatch) {
+            const match = this.traverseBySegments(segments, exactMatch, currentIndex + 1);
+            if (match) {
+                return match;
+            }
         }
-        return candidateNode.insertionIndex < currentBestMatchNode.insertionIndex
-            ? candidateNode
-            : currentBestMatchNode;
+        // 2. Attempt wildcard match ('*').
+        const wildcardMatch = node.children.get('*');
+        if (wildcardMatch) {
+            const match = this.traverseBySegments(segments, wildcardMatch, currentIndex + 1);
+            if (match) {
+                return match;
+            }
+        }
+        // 3. Attempt double wildcard match ('**').
+        return node.children.get('**');
     }
     /**
      * Creates an empty route tree node.
@@ -643,7 +708,6 @@ class RouteTree {
      */
     createEmptyRouteTreeNode() {
         return {
-            insertionIndex: -1,
             children: new Map(),
         };
     }
@@ -662,6 +726,73 @@ const URL_PARAMETER_REGEXP = /(?<!\\):([^/]+)/g;
  * An set of HTTP status codes that are considered valid for redirect responses.
  */
 const VALID_REDIRECT_RESPONSE_CODES = new Set([301, 302, 303, 307, 308]);
+/**
+ * Handles a single route within the route tree and yields metadata or errors.
+ *
+ * @param options - Configuration options for handling the route.
+ * @returns An async iterable iterator yielding `RouteTreeNodeMetadata` or an error object.
+ */
+async function* handleRoute(options) {
+    try {
+        const { metadata, currentRoutePath, route, compiler, parentInjector, serverConfigRouteTree, entryPointToBrowserMapping, invokeGetPrerenderParams, includePrerenderFallbackRoutes, } = options;
+        const { redirectTo, loadChildren, loadComponent, children, ɵentryName } = route;
+        if (ɵentryName && loadComponent) {
+            appendPreloadToMetadata(ɵentryName, entryPointToBrowserMapping, metadata, true);
+        }
+        if (metadata.renderMode === RenderMode.Prerender) {
+            yield* handleSSGRoute(serverConfigRouteTree, typeof redirectTo === 'string' ? redirectTo : undefined, metadata, parentInjector, invokeGetPrerenderParams, includePrerenderFallbackRoutes);
+        }
+        else if (typeof redirectTo === 'string') {
+            if (metadata.status && !VALID_REDIRECT_RESPONSE_CODES.has(metadata.status)) {
+                yield {
+                    error: `The '${metadata.status}' status code is not a valid redirect response code. ` +
+                        `Please use one of the following redirect response codes: ${[...VALID_REDIRECT_RESPONSE_CODES.values()].join(', ')}.`,
+                };
+            }
+            else {
+                yield { ...metadata, redirectTo: resolveRedirectTo(metadata.route, redirectTo) };
+            }
+        }
+        else {
+            yield metadata;
+        }
+        // Recursively process child routes
+        if (children?.length) {
+            yield* traverseRoutesConfig({
+                ...options,
+                routes: children,
+                parentRoute: currentRoutePath,
+                parentPreloads: metadata.preload,
+            });
+        }
+        // Load and process lazy-loaded child routes
+        if (loadChildren) {
+            if (ɵentryName) {
+                // When using `loadChildren`, the entire feature area (including multiple routes) is loaded.
+                // As a result, we do not want all dynamic-import dependencies to be preload, because it involves multiple dependencies
+                // across different child routes. In contrast, `loadComponent` only loads a single component, which allows
+                // for precise control over preloading, ensuring that the files preloaded are exactly those required for that specific route.
+                appendPreloadToMetadata(ɵentryName, entryPointToBrowserMapping, metadata, false);
+            }
+            const loadedChildRoutes = await _loadChildren(route, compiler, parentInjector).toPromise();
+            if (loadedChildRoutes) {
+                const { routes: childRoutes, injector = parentInjector } = loadedChildRoutes;
+                yield* traverseRoutesConfig({
+                    ...options,
+                    routes: childRoutes,
+                    parentInjector: injector,
+                    parentRoute: currentRoutePath,
+                    parentPreloads: metadata.preload,
+                });
+            }
+        }
+    }
+    catch (error) {
+        yield {
+            error: `Error in handleRoute for '${options.currentRoutePath}': ${error.message}`,
+        };
+    }
+}
 /**
  * Traverses an array of route configurations to generate route tree node metadata.
  *
@@ -672,32 +803,60 @@ const VALID_REDIRECT_RESPONSE_CODES = new Set([301, 302, 303, 307, 308]);
  * @returns An async iterable iterator yielding either route tree node metadata or an error object with an error message.
  */
 async function* traverseRoutesConfig(options) {
-    const { routes, compiler, parentInjector, parentRoute, serverConfigRouteTree, entryPointToBrowserMapping, parentPreloads, invokeGetPrerenderParams, includePrerenderFallbackRoutes, } = options;
-    for (const route of routes) {
-        try {
-            const { path = '', matcher, redirectTo, loadChildren, loadComponent, children, ɵentryName, } = route;
-            const currentRoutePath = joinUrlParts(parentRoute, path);
-            // Get route metadata from the server config route tree, if available
-            let matchedMetaData;
-            if (serverConfigRouteTree) {
-                if (matcher) {
-                    // Only issue this error when SSR routing is used.
-                    yield {
-                        error: `The route '${stripLeadingSlash(currentRoutePath)}' uses a route matcher that is not supported.`,
-                    };
+    const { routes: routeConfigs, parentPreloads, parentRoute, serverConfigRouteTree } = options;
+    for (const route of routeConfigs) {
+        const { matcher, path = matcher ? '**' : '' } = route;
+        const currentRoutePath = joinUrlParts(parentRoute, path);
+        if (matcher && serverConfigRouteTree) {
+            let foundMatch = false;
+            for (const matchedMetaData of serverConfigRouteTree.traverse()) {
+                if (!matchedMetaData.route.startsWith(currentRoutePath)) {
                     continue;
                 }
-                matchedMetaData = serverConfigRouteTree.match(currentRoutePath);
-                if (!matchedMetaData) {
+                foundMatch = true;
+                matchedMetaData.presentInClientRouter = true;
+                if (matchedMetaData.renderMode === RenderMode.Prerender) {
                     yield {
-                        error: `The '${stripLeadingSlash(currentRoutePath)}' route does not match any route defined in the server routing configuration. ` +
-                            'Please ensure this route is added to the server routing configuration.',
+                        error: `The route '${stripLeadingSlash(currentRoutePath)}' is set for prerendering but has a defined matcher. ` +
+                            `Routes with matchers cannot use prerendering. Please specify a different 'renderMode'.`,
                     };
                     continue;
                 }
-                matchedMetaData.presentInClientRouter = true;
+                yield* handleRoute({
+                    ...options,
+                    currentRoutePath,
+                    route,
+                    metadata: {
+                        ...matchedMetaData,
+                        preload: parentPreloads,
+                        route: matchedMetaData.route,
+                        presentInClientRouter: undefined,
+                    },
+                });
+            }
+            if (!foundMatch) {
+                yield {
+                    error: `The route '${stripLeadingSlash(currentRoutePath)}' has a defined matcher but does not ` +
+                        'match any route in the server routing configuration. Please ensure this route is added to the server routing configuration.',
+                };
             }
-            const metadata = {
+            continue;
+        }
+        let matchedMetaData;
+        if (serverConfigRouteTree) {
+            matchedMetaData = serverConfigRouteTree.match(currentRoutePath);
+            if (!matchedMetaData) {
+                yield {
+                    error: `The '${stripLeadingSlash(currentRoutePath)}' route does not match any route defined in the server routing configuration. ` +
+                        'Please ensure this route is added to the server routing configuration.',
+                };
+                continue;
+            }
+            matchedMetaData.presentInClientRouter = true;
+        }
+        yield* handleRoute({
+            ...options,
+            metadata: {
                 renderMode: RenderMode.Prerender,
                 ...matchedMetaData,
                 preload: parentPreloads,
@@ -706,64 +865,10 @@ async function* traverseRoutesConfig(options) {
                 // ['one', 'two', 'three'] -> 'one/two/three'
                 route: path === '' ? addTrailingSlash(currentRoutePath) : currentRoutePath,
                 presentInClientRouter: undefined,
-            };
-            if (ɵentryName && loadComponent) {
-                appendPreloadToMetadata(ɵentryName, entryPointToBrowserMapping, metadata, true);
-            }
-            if (metadata.renderMode === RenderMode.Prerender) {
-                // Handle SSG routes
-                yield* handleSSGRoute(typeof redirectTo === 'string' ? redirectTo : undefined, metadata, parentInjector, invokeGetPrerenderParams, includePrerenderFallbackRoutes);
-            }
-            else if (typeof redirectTo === 'string') {
-                // Handle redirects
-                if (metadata.status && !VALID_REDIRECT_RESPONSE_CODES.has(metadata.status)) {
-                    yield {
-                        error: `The '${metadata.status}' status code is not a valid redirect response code. ` +
-                            `Please use one of the following redirect response codes: ${[...VALID_REDIRECT_RESPONSE_CODES.values()].join(', ')}.`,
-                    };
-                    continue;
-                }
-                yield { ...metadata, redirectTo: resolveRedirectTo(metadata.route, redirectTo) };
-            }
-            else {
-                yield metadata;
-            }
-            // Recursively process child routes
-            if (children?.length) {
-                yield* traverseRoutesConfig({
-                    ...options,
-                    routes: children,
-                    parentRoute: currentRoutePath,
-                    parentPreloads: metadata.preload,
-                });
-            }
-            // Load and process lazy-loaded child routes
-            if (loadChildren) {
-                if (ɵentryName) {
-                    // When using `loadChildren`, the entire feature area (including multiple routes) is loaded.
-                    // As a result, we do not want all dynamic-import dependencies to be preload, because it involves multiple dependencies
-                    // across different child routes. In contrast, `loadComponent` only loads a single component, which allows
-                    // for precise control over preloading, ensuring that the files preloaded are exactly those required for that specific route.
-                    appendPreloadToMetadata(ɵentryName, entryPointToBrowserMapping, metadata, false);
-                }
-                const loadedChildRoutes = await _loadChildren(route, compiler, parentInjector).toPromise();
-                if (loadedChildRoutes) {
-                    const { routes: childRoutes, injector = parentInjector } = loadedChildRoutes;
-                    yield* traverseRoutesConfig({
-                        ...options,
-                        routes: childRoutes,
-                        parentInjector: injector,
-                        parentRoute: currentRoutePath,
-                        parentPreloads: metadata.preload,
-                    });
-                }
-            }
-        }
-        catch (error) {
-            yield {
-                error: `Error processing route '${stripLeadingSlash(route.path ?? '')}': ${error.message}`,
-            };
-        }
+            },
+            currentRoutePath,
+            route,
+        });
     }
 }
 /**
@@ -774,23 +879,32 @@ async function* traverseRoutesConfig(options) {
  * preloads to a predefined maximum.
  */
 function appendPreloadToMetadata(entryName, entryPointToBrowserMapping, metadata, includeDynamicImports) {
-    if (!entryPointToBrowserMapping) {
+    const existingPreloads = metadata.preload ?? [];
+    if (!entryPointToBrowserMapping || existingPreloads.length >= MODULE_PRELOAD_MAX) {
         return;
     }
     const preload = entryPointToBrowserMapping[entryName];
-    if (preload?.length) {
-        // Merge existing preloads with new ones, ensuring uniqueness and limiting the total to the maximum allowed.
-        const preloadPaths = preload
-            .filter(({ dynamicImport }) => includeDynamicImports || !dynamicImport)
-            .map(({ path }) => path) ?? [];
-        const combinedPreloads = [...(metadata.preload ?? []), ...preloadPaths];
-        metadata.preload = Array.from(new Set(combinedPreloads)).slice(0, MODULE_PRELOAD_MAX);
+    if (!preload?.length) {
+        return;
+    }
+    // Merge existing preloads with new ones, ensuring uniqueness and limiting the total to the maximum allowed.
+    const combinedPreloads = new Set(existingPreloads);
+    for (const { dynamicImport, path } of preload) {
+        if (dynamicImport && !includeDynamicImports) {
+            continue;
+        }
+        combinedPreloads.add(path);
+        if (combinedPreloads.size === MODULE_PRELOAD_MAX) {
+            break;
+        }
     }
+    metadata.preload = Array.from(combinedPreloads);
 }
 /**
  * Handles SSG (Static Site Generation) routes by invoking `getPrerenderParams` and yielding
  * all parameterized paths, returning any errors encountered.
  *
+ * @param serverConfigRouteTree - The tree representing the server's routing setup.
  * @param redirectTo - Optional path to redirect to, if specified.
  * @param metadata - The metadata associated with the route tree node.
  * @param parentInjector - The dependency injection container for the parent route.
@@ -798,7 +912,7 @@ function appendPreloadToMetadata(entryName, entryPointToBrowserMapping, metadata
  * @param includePrerenderFallbackRoutes - A flag indicating whether to include fallback routes in the result.
  * @returns An async iterable iterator that yields route tree node metadata for each SSG path or errors.
  */
-async function* handleSSGRoute(redirectTo, metadata, parentInjector, invokeGetPrerenderParams, includePrerenderFallbackRoutes) {
+async function* handleSSGRoute(serverConfigRouteTree, redirectTo, metadata, parentInjector, invokeGetPrerenderParams, includePrerenderFallbackRoutes) {
     if (metadata.renderMode !== RenderMode.Prerender) {
         throw new Error(`'handleSSGRoute' was called for a route which rendering mode is not prerender.`);
     }
@@ -827,6 +941,18 @@ async function* handleSSGRoute(redirectTo, metadata, parentInjector, invokeGetPr
             };
             return;
         }
+        if (serverConfigRouteTree) {
+            // Automatically resolve dynamic parameters for nested routes.
+            const catchAllRoutePath = joinUrlParts(currentRoutePath, '**');
+            const match = serverConfigRouteTree.match(catchAllRoutePath);
+            if (match && match.renderMode === RenderMode.Prerender && !('getPrerenderParams' in match)) {
+                serverConfigRouteTree.insert(catchAllRoutePath, {
+                    ...match,
+                    presentInClientRouter: true,
+                    getPrerenderParams,
+                });
+            }
+        }
         const parameters = await runInInjectionContext(parentInjector, () => getPrerenderParams());
         try {
             for (const params of parameters) {
@@ -912,6 +1038,10 @@ function buildServerConfigRouteTree({ routes, appShellRoute }) {
             errors.push(`Invalid '${path}' route configuration: the path cannot start with a slash.`);
             continue;
         }
+        if (path.includes('*') && 'getPrerenderParams' in metadata) {
+            errors.push(`Invalid '${path}' route configuration: 'getPrerenderParams' cannot be used with a '*' or '**' route.`);
+            continue;
+        }
         serverConfigRouteTree.insert(path, metadata);
     }
     return { serverConfigRouteTree, errors };
@@ -973,13 +1103,10 @@ async function getRoutesFromAngularRouterConfig(bootstrap, document, url, invoke
         router.navigationTransitions.afterPreactivation()?.next?.();
         // Wait until the application is stable.
         await applicationRef.whenStable();
-        const routesResults = [];
         const errors = [];
-        let baseHref = injector.get(APP_BASE_HREF, null, { optional: true }) ??
+        const rawBaseHref = injector.get(APP_BASE_HREF, null, { optional: true }) ??
             injector.get(PlatformLocation).getBaseHrefFromDOM();
-        if (baseHref.startsWith('./')) {
-            baseHref = baseHref.slice(2);
-        }
+        const { pathname: baseHref } = new URL(rawBaseHref, 'http://localhost');
         const compiler = injector.get(Compiler);
         const serverRoutesConfig = injector.get(SERVER_ROUTES_CONFIG, null, { optional: true });
         let serverConfigRouteTree;
@@ -991,10 +1118,11 @@ async function getRoutesFromAngularRouterConfig(bootstrap, document, url, invoke
         if (errors.length) {
             return {
                 baseHref,
-                routes: routesResults,
+                routes: [],
                 errors,
             };
         }
+        const routesResults = [];
         if (router.config.length) {
             // Retrieve all routes from the Angular router configuration.
             const traverseRoutes = traverseRoutesConfig({
@@ -1007,12 +1135,18 @@ async function getRoutesFromAngularRouterConfig(bootstrap, document, url, invoke
                 includePrerenderFallbackRoutes,
                 entryPointToBrowserMapping,
             });
-            for await (const result of traverseRoutes) {
-                if ('error' in result) {
-                    errors.push(result.error);
+            const seenRoutes = new Set();
+            for await (const routeMetadata of traverseRoutes) {
+                if ('error' in routeMetadata) {
+                    errors.push(routeMetadata.error);
+                    continue;
                 }
-                else {
-                    routesResults.push(result);
+                // If a result already exists for the exact same route, subsequent matches should be ignored.
+                // This aligns with Angular's app router behavior, which prioritizes the first route.
+                const routePath = routeMetadata.route;
+                if (!seenRoutes.has(routePath)) {
+                    routesResults.push(routeMetadata);
+                    seenRoutes.add(routePath);
                 }
             }
             // This timeout is necessary to prevent 'adev' from hanging in production builds.
@@ -2154,8 +2288,8 @@ class AngularAppEngine {
     redirectBasedOnAcceptLanguage(request) {
         const { basePath, supportedLocales } = this.manifest;
         // If the request is not for the base path, it's not our responsibility to handle it.
-        const url = new URL(request.url);
-        if (url.pathname !== basePath) {
+        const { pathname } = new URL(request.url);
+        if (pathname !== basePath) {
             return null;
         }
         // For requests to the base path (typically '/'), attempt to extract the preferred locale
@@ -2164,11 +2298,10 @@ class AngularAppEngine {
         if (preferredLocale) {
             const subPath = supportedLocales[preferredLocale];
             if (subPath !== undefined) {
-                url.pathname = joinUrlParts(url.pathname, subPath);
                 return new Response(null, {
                     status: 302, // Use a 302 redirect as language preference may change.
                     headers: {
-                        'Location': url.toString(),
+                        'Location': joinUrlParts(pathname, subPath),
                         'Vary': 'Accept-Language',
                     },
                 });
@@ -2272,5 +2405,5 @@ function createRequestHandler(handler) {
     return handler;
 }
 
-export { AngularAppEngine, PrerenderFallback, RenderMode, createRequestHandler, provideServerRoutesConfig, InlineCriticalCssProcessor as ɵInlineCriticalCssProcessor, destroyAngularServerApp as ɵdestroyAngularServerApp, extractRoutesAndCreateRouteTree as ɵextractRoutesAndCreateRouteTree, getOrCreateAngularServerApp as ɵgetOrCreateAngularServerApp, getRoutesFromAngularRouterConfig as ɵgetRoutesFromAngularRouterConfig, setAngularAppEngineManifest as ɵsetAngularAppEngineManifest, setAngularAppManifest as ɵsetAngularAppManifest };
+export { AngularAppEngine, PrerenderFallback, RenderMode, createRequestHandler, provideServerRoutesConfig, provideServerRouting, withAppShell, InlineCriticalCssProcessor as ɵInlineCriticalCssProcessor, destroyAngularServerApp as ɵdestroyAngularServerApp, extractRoutesAndCreateRouteTree as ɵextractRoutesAndCreateRouteTree, getOrCreateAngularServerApp as ɵgetOrCreateAngularServerApp, getRoutesFromAngularRouterConfig as ɵgetRoutesFromAngularRouterConfig, setAngularAppEngineManifest as ɵsetAngularAppEngineManifest, setAngularAppManifest as ɵsetAngularAppManifest };
 //# sourceMappingURL=ssr.mjs.map