@@ -31,7 +31,7 @@ import { AngularAppManifest, getAngularAppManifest } from '../manifest';
 import { AngularBootstrap, isNgModule } from '../utils/ng';
 import { promiseWithAbort } from '../utils/promise';
 import { VALID_REDIRECT_RESPONSE_CODES, isValidRedirectResponseCode } from '../utils/redirect';
-import { joinUrlParts, stripLeadingSlash } from '../utils/url';
+import { addLeadingSlash, joinUrlParts, stripLeadingSlash } from '../utils/url';
 import {
   PrerenderFallback,
   RenderMode,
@@ -202,7 +202,7 @@ async function* handleRoute(options: {
       } else if (typeof redirectTo === 'string') {
         parentRoutes.set(metadata.route, {
           ...metadata,
-          redirectTo: resolveRedirectTo(parentRoute, redirectTo),
+          redirectTo: resolveRedirectTo(parentRoute, redirectTo, currentRoutePath),
           relativeRedirect: redirectTo[0] !== '/' ? true : undefined,
         });
       } else {
@@ -452,7 +452,7 @@ async function* handleSSGRoute(
   }
 
   if (redirectTo !== undefined) {
-    meta.redirectTo = resolveRedirectTo(parentRoute, redirectTo);
+    meta.redirectTo = resolveRedirectTo(parentRoute, redirectTo, currentRoutePath);
     meta.relativeRedirect = redirectTo[0] !== '/' ? true : undefined;
   }
 
@@ -513,7 +513,10 @@ async function* handleSSGRoute(
               ? undefined
               : resolveRedirectTo(
                   parentRoute.replace(URL_PARAMETER_GLOBAL_REGEXP, replacer),
-                  redirectTo,
+                  redirectTo.replace(URL_PARAMETER_GLOBAL_REGEXP, (match) =>
+                    Object.hasOwn(params, match.slice(1)) ? replacer(match) : match,
+                  ),
+                  currentRoutePath,
                 ),
         };
       }
@@ -570,23 +573,53 @@ function handlePrerenderParamsReplacement(
  *
  * This function processes the `redirectTo` property to ensure that it correctly
  * resolves relative to the parent route path. If `redirectTo` is an absolute path,
- * it is returned as is. If it is a relative path, it is resolved based on the parent route path,
+ * it is used 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.
  *
+ * Like in the Angular router, route parameters (e.g. `:id`) used in `redirectTo` take the value
+ * they have in the matched URL. They are emitted as `*` placeholders, or `*<n>` when the value
+ * comes from a different segment position than the one it is used in.
+ *
  * @param parentRoute - The path of the parent route.
  * @param redirectTo - The target path for redirection.
+ * @param currentRoutePath - The full path of the route that redirects, including its parent route.
  * @returns The resolved redirect path as a string.
  */
-function resolveRedirectTo(parentRoute: string, redirectTo: string): string {
+function resolveRedirectTo(
+  parentRoute: string,
+  redirectTo: string,
+  currentRoutePath: string,
+): string {
+  let target: string;
   if (redirectTo[0] === '/') {
-    // If the redirectTo path is absolute, return it as is.
-    return redirectTo;
+    target = redirectTo;
+  } else {
+    // Match Angular router behavior: replace all segments matched by the route.
+    const [path] = redirectTo.split(/[?#]/, 1);
+    target = joinUrlParts(parentRoute.replace(URL_PARAMETER_GLOBAL_REGEXP, '*'), path);
+  }
+
+  if (!URL_PARAMETER_REGEXP.test(target)) {
+    return target;
   }
 
-  // Match Angular router behavior: replace all segments matched by the route.
-  const [path] = redirectTo.split(/[?#]/, 1);
+  const sourceSegments = addLeadingSlash(currentRoutePath).split('/');
+
+  return target
+    .split('/')
+    .map((segment, index) => {
+      if (segment[0] !== ':') {
+        return segment;
+      }
+
+      const sourceIndex = sourceSegments.indexOf(segment);
+      if (sourceIndex === -1) {
+        return segment;
+      }
 
-  return joinUrlParts(parentRoute.replace(URL_PARAMETER_GLOBAL_REGEXP, '*'), path);
+      return sourceIndex === index ? '*' : `*${sourceIndex}`;
+    })
+    .join('/');
 }
 
 /**
 
@@ -157,7 +157,8 @@ export function stripIndexHtmlFromURL(url: URL): URL {
  * from a base path. This is useful for constructing paths dynamically based on a given base path.
  *
  * The function processes the `toPath` string, replacing each `*` placeholder with
- * the corresponding segment from the `fromPath`. If the `toPath` contains no placeholders,
+ * the corresponding segment from the `fromPath`. A `*<n>` placeholder (e.g. `*3`) takes the
+ * segment at position `n` of the `fromPath` instead of the one at its own position. If the `toPath` contains no placeholders,
  * it is returned as-is. Invalid `toPath` formats (not starting with `/`) will throw an error.
  *
  * @param toPath - A path template string that may contain `*` placeholders. Each `*` is replaced
@@ -196,9 +197,15 @@ export function buildPathWithParams(toPath: string, fromPath: string): string {
 
   const fromPathParts = fromPath.split('/');
   const toPathParts = toPath.split('/');
-  const resolvedParts = toPathParts.map((part, index) =>
-    toPathParts[index] === '*' ? fromPathParts[index] : part,
-  );
+  const resolvedParts = toPathParts.map((part, index) => {
+    // `*` takes the segment at the same position, `*<n>` the segment at position `n`.
+    const match = /^\*(\d*)$/.exec(part);
+    if (!match) {
+      return part;
+    }
+
+    return fromPathParts[match[1] ? Number(match[1]) : index];
+  });
 
   return joinUrlParts(...resolvedParts);
 }
 
@@ -90,6 +90,12 @@ describe('AngularServerApp', () => {
         { path: 'redirect/absolute', redirectTo: '/home' },
         { path: 'redirect-with-query', redirectTo: 'home?param=value' },
         { path: 'redirect-nested/:param', children: [{ path: 'old', redirectTo: 'new' }] },
+        { path: 'redirect-param/:id', redirectTo: 'redirect-target/:id' },
+        { path: 'redirect-param-deep/:id', redirectTo: 'redirect-target/deep/:id' },
+        {
+          path: 'redirect-nested-param/:parent',
+          children: [{ path: 'old/:id', redirectTo: 'new/:id/:parent' }],
+        },
         {
           path: 'redirect-to-function',
           redirectTo: () => 'home',
@@ -446,6 +452,24 @@ describe('AngularServerApp', () => {
     });
 
     describe('SSR pages', () => {
+      it('substitutes route parameters used in `redirectTo`', async () => {
+        const response = await app.handle(new Request('http://localhost/redirect-param/5'));
+        expect(response?.headers.get('location')).toBe('/redirect-target/5');
+        expect(response?.status).toBe(302);
+      });
+
+      it('substitutes route parameters used at a different position in `redirectTo`', async () => {
+        const response = await app.handle(new Request('http://localhost/redirect-param-deep/5'));
+        expect(response?.headers.get('location')).toBe('/redirect-target/deep/5');
+      });
+
+      it('substitutes parameters of parent routes used in `redirectTo`', async () => {
+        const response = await app.handle(
+          new Request('http://localhost/redirect-nested-param/a/old/b'),
+        );
+        expect(response?.headers.get('location')).toBe('/redirect-nested-param/a/new/b/a');
+      });
+
       it('returns a 302 status and redirects to the correct location when `redirectTo` is a function', async () => {
         const response = await app.handle(new Request('http://localhost/redirect-to-function'));
         expect(response?.headers.get('location')).toBe('/home');
 
@@ -448,6 +448,48 @@ describe('extractRoutesAndCreateRouteTree', () => {
       ]);
     });
 
+    it('should substitute route parameters used in the `redirectTo` of prerendered routes', async () => {
+      setAngularAppTestingManifest(
+        [
+          { path: 'old/:id', redirectTo: 'new/:id' },
+          { path: 'new/:id', component: DummyComponent },
+        ],
+        [
+          {
+            path: 'old/:id',
+            renderMode: RenderMode.Prerender,
+            async getPrerenderParams() {
+              return [{ id: '5' }];
+            },
+          },
+          { path: '**', renderMode: RenderMode.Server },
+        ],
+      );
+
+      const { routeTree, errors } = await extractRoutesAndCreateRouteTree({
+        url,
+        invokeGetPrerenderParams: true,
+        includePrerenderFallbackRoutes: true,
+      });
+
+      expect(errors).toHaveSize(0);
+      expect(routeTree.toObject()).toEqual([
+        {
+          route: '/old/5',
+          renderMode: RenderMode.Prerender,
+          redirectTo: '/new/5',
+          relativeRedirect: true,
+        },
+        {
+          route: '/old/*',
+          renderMode: RenderMode.Server,
+          redirectTo: '/new/*',
+          relativeRedirect: true,
+        },
+        { route: '/new/*', renderMode: RenderMode.Server },
+      ]);
+    });
+
     it('should resolve relative redirects of prerendered catch-all routes', async () => {
       setAngularAppTestingManifest(
         [
 
@@ -184,6 +184,15 @@ describe('URL Utils', () => {
       expect(result.toString()).toBe('/base/path/details');
     });
 
+    it('should take the segment at position `n` for `*<n>` placeholders', () => {
+      const fromPath = '/old/5';
+      const toPath = '/new/deep/*2';
+
+      const result = buildPathWithParams(toPath, fromPath);
+
+      expect(result.toString()).toBe('/new/deep/5');
+    });
+
     it('should throw an error if the toPath does not start with "/"', () => {
       const fromPath = '/base/path';
       const toPath = 'details';