@@ -30,14 +30,8 @@ import { Console } from '../console';
 import { AngularAppManifest, getAngularAppManifest } from '../manifest';
 import { AngularBootstrap, isNgModule } from '../utils/ng';
 import { promiseWithAbort } from '../utils/promise';
-import {
-  NormalizedUrl,
-  VALID_REDIRECT_RESPONSE_CODES,
-  isValidRedirectResponseCode,
-  normalizeAndValidateRedirect,
-  normalizeAndValidateRoutePath,
-} from '../utils/redirect';
-import { addLeadingSlash, joinUrlParts, stripLeadingSlash } from '../utils/url';
+import { VALID_REDIRECT_RESPONSE_CODES, isValidRedirectResponseCode } from '../utils/redirect';
+import { joinUrlParts, stripLeadingSlash } from '../utils/url';
 import {
   PrerenderFallback,
   RenderMode,
@@ -211,23 +205,18 @@ async function* handleRoute(options: {
       } else if (typeof redirectTo === 'string') {
         // Reference the route parameters by their position in the URL (see `buildPathWithParams`).
         const routeSegments = joinUrlParts(baseHref, currentRoutePath).split('/');
-        const { url, error } = resolveRedirectTo(
-          parentRoute,
-          replaceRedirectParams(
-            route,
-            redirectTo,
-            (parameter) => `*${routeSegments.lastIndexOf(parameter)}`,
+        parentRoutes.set(metadata.route, {
+          ...metadata,
+          redirectTo: resolveRedirectTo(
+            parentRoute,
+            replaceRedirectParams(
+              route,
+              redirectTo,
+              (parameter) => `*${routeSegments.lastIndexOf(parameter)}`,
+            ),
           ),
-        );
-        if (error !== undefined) {
-          yield { error: invalidRedirectError(metadata.route, error) };
-        } else {
-          parentRoutes.set(metadata.route, {
-            ...metadata,
-            redirectTo: url,
-            relativeRedirect: redirectTo[0] !== '/' ? true : undefined,
-          });
-        }
+          relativeRedirect: redirectTo[0] !== '/' ? true : undefined,
+        });
       } else {
         parentRoutes.set(metadata.route, metadata);
       }
@@ -481,21 +470,14 @@ async function* handleSSGRoute(
   if (redirectTo !== undefined) {
     // Reference the route parameters by their position in the URL (see `buildPathWithParams`).
     const routeSegments = joinUrlParts(baseHref, currentRoutePath).split('/');
-    const { url, error } = resolveRedirectTo(
+    meta.redirectTo = resolveRedirectTo(
       parentRoute,
       replaceRedirectParams(
         route,
         redirectTo,
         (parameter) => `*${routeSegments.lastIndexOf(parameter)}`,
       ),
     );
-    if (error !== undefined) {
-      yield { error: invalidRedirectError(currentRoutePath, error) };
-
-      return;
-    }
-
-    meta.redirectTo = url;
     meta.relativeRedirect = redirectTo[0] !== '/' ? true : undefined;
   }
 
@@ -548,41 +530,20 @@ async function* handleSSGRoute(
           .replace(URL_PARAMETER_GLOBAL_REGEXP, replacer)
           .replace(CATCH_ALL_REGEXP, replacer);
 
-        // A parameter value is only meaningful in the context of the route it is substituted into,
-        // so the composed path is what gets normalized and validated. This also catches values that
-        // only become unsafe once combined with the route, such as a protocol-relative `//`.
-        const { url: normalizedRoute, error: routeError } = normalizeAndValidateRoutePath(
-          addLeadingSlash(routeWithResolvedParams),
-        );
-        if (routeError !== undefined) {
-          yield {
-            error:
-              `The '${stripLeadingSlash(currentRoutePath)}' route produced an invalid ` +
-              `prerender path: ${routeError}`,
-          };
-
-          continue;
-        }
-
-        let resolvedRedirectTo: string | undefined;
-        if (redirectTo !== undefined) {
-          const { url, error } = resolveRedirectTo(
-            parentRoute.replace(URL_PARAMETER_GLOBAL_REGEXP, replacer),
-            replaceRedirectParams(route, redirectTo, (parameter) => params[parameter.slice(1)]),
-          );
-          if (error !== undefined) {
-            yield { error: invalidRedirectError(routeWithResolvedParams, error) };
-
-            continue;
-          }
-
-          resolvedRedirectTo = url;
-        }
-
         yield {
           ...meta,
-          route: normalizedRoute,
-          redirectTo: resolvedRedirectTo,
+          route: routeWithResolvedParams,
+          redirectTo:
+            redirectTo === undefined
+              ? undefined
+              : resolveRedirectTo(
+                  parentRoute.replace(URL_PARAMETER_GLOBAL_REGEXP, replacer),
+                  replaceRedirectParams(
+                    route,
+                    redirectTo,
+                    (parameter) => params[parameter.slice(1)],
+                  ),
+                ),
         };
       }
     } catch (error) {
@@ -629,10 +590,7 @@ function handlePrerenderParamsReplacement(
       );
     }
 
-    // The matched placeholder includes the separator, so it has to be re-added. The documented
-    // value of a `**` parameter is a path, which may already carry it: re-adding it unconditionally
-    // would compose a root catch-all into a protocol-relative `//foo/bar`.
-    return parameterName === '**' ? addLeadingSlash(value) : value;
+    return parameterName === '**' ? `/${value}` : value;
   };
 }
 
@@ -644,36 +602,20 @@ function handlePrerenderParamsReplacement(
  * it is returned as is. If it is a relative path, it is resolved based on the parent route path,
  * and, like in the Angular router, its query and fragment are ignored.
  *
- * The resolved target is then normalized and validated, so that every `redirectTo` reaching the
- * route tree is a safe HTTP(S) URL or same-origin path.
- *
  * @param parentRoute - The path of the parent route.
  * @param redirectTo - The target path for redirection.
- * @returns The normalized redirect target, or the reason it was rejected.
+ * @returns The resolved redirect path as a string.
  */
-function resolveRedirectTo(parentRoute: string, redirectTo: string): NormalizedUrl {
+function resolveRedirectTo(parentRoute: string, redirectTo: string): string {
   if (redirectTo[0] === '/') {
-    // If the redirectTo path is absolute, use it as is.
-    return normalizeAndValidateRedirect(redirectTo);
+    // If the redirectTo path is absolute, return it as is.
+    return redirectTo;
   }
 
   // Match Angular router behavior: replace all segments matched by the route.
   const [path] = redirectTo.split(/[?#]/, 1);
 
-  return normalizeAndValidateRedirect(
-    joinUrlParts(parentRoute.replace(URL_PARAMETER_GLOBAL_REGEXP, '*'), path),
-  );
-}
-
-/**
- * Builds the diagnostic emitted when a route's `redirectTo` cannot be normalized.
- *
- * @param routePath - The route the `redirectTo` is defined on.
- * @param reason - The reason reported by the redirect normalization.
- * @returns The error message to report.
- */
-function invalidRedirectError(routePath: string, reason: string): string {
-  return `The 'redirectTo' value for the '${stripLeadingSlash(routePath)}' route is invalid: ${reason}`;
+  return joinUrlParts(parentRoute.replace(URL_PARAMETER_GLOBAL_REGEXP, '*'), path);
 }
 
 /**
@@ -764,27 +706,6 @@ function buildServerConfigRouteTree({ routes, appShellRoute }: ServerRoutesConfi
   return { serverConfigRouteTree, errors };
 }
 
-/**
- * Builds the key used to de-duplicate an extracted route.
- *
- * `RouteTree` percent-decodes every segment when a route is inserted, so two route paths which
- * differ only in their encoding land on the same node, where the later one overwrites the earlier.
- * De-duplication therefore runs on the decoded path rather than on the path as it was written:
- * a prerendered path is normalized by the URL parser while the path of every other render mode is
- * not, so the same route can be reached in both an encoded and an unencoded form.
- *
- * @param route - The route path to build a key for.
- * @returns The decoded route path.
- */
-function routeDeduplicationKey(route: string): string {
-  try {
-    return route.split('/').map(decodeURIComponent).join('/');
-  } catch {
-    // A malformed percent escape is reported when the route is inserted into the route tree.
-    return route;
-  }
-}
-
 /**
  * Retrieves routes from the given Angular application.
  *
@@ -908,7 +829,7 @@ export async function getRoutesFromAngularRouterConfig(
 
         // 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 = routeDeduplicationKey(routeMetadata.route);
+        const routePath = routeMetadata.route;
         if (!seenRoutes.has(routePath)) {
           routesResults.push(routeMetadata);
           seenRoutes.add(routePath);