fix(rsc): normalize double slashes in manifest URLs

Fixes #14583 by using joinPaths utility to normalize double slashes
in getManifestUrl function, preventing ERR_NAME_NOT_RESOLVED errors

Author: swarnim02

integration/rsc-double-slashes-test.ts

@@ -0,0 +1,105 @@
+import {
+  test,
+  expect,
+} from "@playwright/test";
+import getPort from "get-port";
+
+import { implementations, js, setupRscTest, validateRSCHtml } from "./rsc/utils";
+
+implementations.forEach((implementation) => {
+  test.describe(`RSC Double Slashes Fix (${implementation.name})`, () => {
+    test.describe("Production", () => {
+      let port: number;
+      let stopAfterAll: () => void;
+
+      test.afterAll(() => {
+        stopAfterAll?.();
+      });
+
+      test.beforeAll(async () => {
+        port = await getPort();
+        stopAfterAll = await setupRscTest({
+          implementation,
+          port,
+          files: {
+            "src/routes.ts": js`
+              import type { unstable_RSCRouteConfig as RSCRouteConfig } from "react-router";
+
+              export const routes = [
+                {
+                  id: "root",
+                  path: "",
+                  lazy: () => import("./routes/root"),
+                  children: [
+                    {
+                      id: "double-slash-test",
+                      path: "en/test2/test",
+                      lazy: () => import("./routes/double-slash-test/home"),
+                    },
+                  ],
+                },
+              ] satisfies RSCRouteConfig;
+            `,
+
+            "src/routes/double-slash-test/home.tsx": js`
+              export function loader() {
+                return { message: "Double slash test successful" };
+              }
+
+              export default function HomeRoute({ loaderData }) {
+                return (
+                  <div>
+                    <h2 data-test-result>Double Slash Test</h2>
+                    <p data-test-message>{loaderData.message}</p>
+                  </div>
+                );
+              }
+            `,
+          },
+        });
+      });
+
+      test("should handle URLs with double slashes correctly", async ({ page }) => {
+        // Test the problematic URL pattern from the issue
+        await page.goto(`http://localhost:${port}//en//test2/test`);
+
+        // Should successfully load the page despite double slashes
+        await page.waitForSelector("[data-test-result]");
+        expect(await page.locator("[data-test-result]").textContent()).toBe(
+          "Double Slash Test",
+        );
+        expect(await page.locator("[data-test-message]").textContent()).toBe(
+          "Double slash test successful",
+        );
+
+        // Ensure this is using RSC
+        validateRSCHtml(await page.content());
+      });
+
+      test("should normalize URLs and not cause manifest loading errors", async ({ page }) => {
+        // Monitor network requests to ensure no ERR_NAME_NOT_RESOLVED errors
+        const failedRequests: string[] = [];
+        
+        page.on('requestfailed', (request) => {
+          failedRequests.push(request.url());
+        });
+
+        // Navigate to a URL with double slashes
+        await page.goto(`http://localhost:${port}//en//test2/test`);
+        
+        // Wait for the page to load
+        await page.waitForSelector("[data-test-result]");
+        
+        // Check that no manifest requests failed with name resolution errors
+        const manifestFailures = failedRequests.filter(url => 
+          url.includes('.manifest') && url.includes('//')
+        );
+        
+        expect(manifestFailures).toHaveLength(0);
+        
+        // Ensure this is using RSC
+        validateRSCHtml(await page.content());
+      });
+    });
+  });
+});

packages/react-router/__tests__/rsc-double-slashes-test.ts

@@ -0,0 +1,28 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { joinPaths } from "../lib/router/utils";
+
+describe("RSC Double Slashes Issue - URL Normalization", () => {
+  test("joinPaths should normalize double slashes", () => {
+    expect(joinPaths(["//en//test2/test"])).toBe("/en/test2/test");
+    expect(joinPaths(["//en//test1", "//fr//test2"])).toBe("/en/test1/fr/test2");
+    expect(joinPaths(["/app//base/"])).toBe("/app/base");
+    expect(joinPaths(["/normal/path"])).toBe("/normal/path");
+    expect(joinPaths([""])).toBe("/");
+  });
+
+  test("should handle various double slash scenarios", () => {
+    // Test cases that would cause the original issue
+    expect(joinPaths(["//en//test2/test"])).toBe("/en/test2/test");
+    expect(joinPaths(["///multiple///slashes"])).toBe("/multiple/slashes");
+    expect(joinPaths(["path//with//double//slashes"])).toBe("path/with/double/slashes");
+    expect(joinPaths(["//"])).toBe("/");
+  });
+
+  test("should preserve single slashes", () => {
+    expect(joinPaths(["/normal/path"])).toBe("/normal/path");
+    expect(joinPaths(["path/without/leading/slash"])).toBe("path/without/leading/slash");
+  });
+});

packages/react-router/lib/rsc/browser.tsx

@@ -22,7 +22,7 @@ import type {
   DataStrategyFunctionArgs,
   RouterContextProvider,
 } from "../router/utils";
-import { ErrorResponseImpl, createContext } from "../router/utils";
+import { ErrorResponseImpl, createContext, joinPaths } from "../router/utils";
 import type {
   DecodedSingleFetchResults,
   FetchAndDecodeFunction,
@@ -972,16 +972,22 @@ function getManifestUrl(paths: string[]): URL | null {
   }
 
   if (paths.length === 1) {
-    return new URL(`${paths[0]}.manifest`, window.location.origin);
+    // Normalize double slashes in the single path
+    const normalizedPath = joinPaths([paths[0]]);
+    return new URL(`${normalizedPath}.manifest`, window.location.origin);
   }
 
   const globalVar = window as WindowWithRouterGlobals;
   let basename = (globalVar.__reactRouterDataRouter.basename ?? "").replace(
     /^\/|\/$/g,
     "",
   );
+  // Normalize double slashes in basename
+  basename = joinPaths([basename]);
   let url = new URL(`${basename}/.manifest`, window.location.origin);
-  url.searchParams.set("paths", paths.sort().join(","));
+  // Normalize double slashes in all paths before joining
+  const normalizedPaths = paths.map(path => joinPaths([path]));
+  url.searchParams.set("paths", normalizedPaths.sort().join(","));
 
   return url;
 }