rwsdk 1.0.0-beta.5 → 1.0.0-beta.51

package/dist/runtime/lib/router.test.js

@@ -1,6 +1,6 @@
 import React from "react";
 import { describe, expect, it } from "vitest";
-import { defineRoutes, layout, matchPath, prefix, render, route, } from "./router";
+import { defineRoutes, except, layout, matchPath, prefix, render, route, } from "./router";
 describe("matchPath", () => {
     // Test case 1: Static paths
     it("should match static paths", () => {
@@ -34,6 +34,11 @@ describe("matchPath", () => {
     it("should match empty wildcard", () => {
         expect(matchPath("/files/*/", "/files//")).toEqual({ $0: "" });
     });
+    it("should match wildcard route against root path", () => {
+        // Wildcard route should match the root path "/"
+        // This tests the regression where route("*") stopped matching "/"
+        expect(matchPath("/*", "/")).toEqual({ $0: "" });
+    });
     // Test case 4: Paths with both parameters and wildcards
     it("should match paths with both parameters and wildcards", () => {
         expect(matchPath("/products/:productId/*/", "/products/abc/details/more/")).toEqual({ productId: "abc", $0: "details/more" });
@@ -62,6 +67,7 @@ describe("defineRoutes - Request Handling Behavior", () => {
     const createMockDependencies = () => {
         const mockRequestInfo = {
             request: new Request("http://localhost:3000/"),
+            path: "/",
             params: {},
             ctx: {},
             rw: {
@@ -71,6 +77,8 @@ describe("defineRoutes - Request Handling Behavior", () => {
                 ssr: true,
                 databases: new Map(),
                 scriptsToBeLoaded: new Set(),
+                entryScripts: new Set(),
+                inlineScripts: new Set(),
                 pageRouteResolved: undefined,
             },
             cf: {},
@@ -291,6 +299,109 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(executionOrder).toEqual(["prefixedMiddleware"]);
             expect(await response.text()).toBe("From prefixed middleware");
         });
+        it("should pass prefix parameters to route handlers", async () => {
+            let capturedParams = null;
+            const TaskDetailPage = (requestInfo) => {
+                capturedParams = requestInfo.params;
+                return React.createElement("div", {}, "Task Detail");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId", [route("/", TaskDetailPage)]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(capturedParams).toEqual({ containerId: "123" });
+        });
+        it("should pass prefix parameters to middlewares within a parameterized prefix", async () => {
+            const executionOrder = [];
+            let capturedParams = null;
+            const prefixedMiddleware = (requestInfo) => {
+                executionOrder.push("prefixedMiddleware");
+                capturedParams = requestInfo.params;
+            };
+            const PageComponent = () => {
+                executionOrder.push("PageComponent");
+                return React.createElement("div", {}, "Page");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId", [
+                    prefixedMiddleware,
+                    route("/", PageComponent),
+                ]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["prefixedMiddleware", "PageComponent"]);
+            // The wildcard captures the trailing slash as an empty string
+            expect(capturedParams).toEqual({ containerId: "123", $0: "" });
+        });
+        it("should pass prefix parameters to route handlers (array)", async () => {
+            let capturedParamsInMiddleware = null;
+            let capturedParamsInComponent = null;
+            const middleware = (requestInfo) => {
+                capturedParamsInMiddleware = requestInfo.params;
+            };
+            const Component = (requestInfo) => {
+                capturedParamsInComponent = requestInfo.params;
+                return React.createElement("div", {}, "Component");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId", [route("/", [middleware, Component])]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(capturedParamsInMiddleware).toEqual({ containerId: "123" });
+            expect(capturedParamsInComponent).toEqual({ containerId: "123" });
+        });
+        it("should match even if prefix has a trailing slash", async () => {
+            let capturedParams = null;
+            const TaskDetailPage = (requestInfo) => {
+                capturedParams = requestInfo.params;
+                return React.createElement("div", {}, "Task Detail");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId/", [route("/", TaskDetailPage)]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(capturedParams).toEqual({ containerId: "123" });
+        });
     });
     describe("RSC Action Handling", () => {
         it("should handle RSC actions before the first route definition", async () => {
@@ -435,6 +546,28 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(response.status).toBe(404);
             expect(await response.text()).toBe("Not Found");
         });
+        it("should match wildcard route against root path", async () => {
+            // Regression test: wildcard route should match the root path "/"
+            const executionOrder = [];
+            const WildcardPage = () => {
+                executionOrder.push("WildcardPage");
+                return React.createElement("div", {}, "Wildcard Page");
+            };
+            const router = defineRoutes([route("*", WildcardPage)]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/");
+            deps.mockRequestInfo.path = "/";
+            const request = new Request("http://localhost:3000/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["WildcardPage"]);
+        });
     });
     describe("Multiple Render Blocks with SSR Configuration", () => {
         it("should short-circuit on first matching render block and not apply later configurations", async () => {
@@ -593,6 +726,245 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(extractedParams).toEqual({ id: "123" });
         });
     });
+    describe("HTTP Method Routing", () => {
+        it("should route GET request to get handler", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("GET Response");
+        });
+        it("should route POST request to post handler", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("POST Response");
+        });
+        it("should return 405 for unsupported method with Allow header", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "DELETE",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "DELETE",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(405);
+            expect(await response.text()).toBe("Method Not Allowed");
+            expect(response.headers.get("Allow")).toBe("GET, OPTIONS, POST");
+        });
+        it("should handle OPTIONS request with Allow header", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(204);
+            expect(response.headers.get("Allow")).toBe("GET, OPTIONS, POST");
+        });
+        it("should support custom methods (case-insensitive)", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    custom: {
+                        report: () => new Response("REPORT Response"),
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "REPORT",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "REPORT",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("REPORT Response");
+        });
+        it("should normalize custom method keys to lowercase", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    custom: {
+                        REPORT: () => new Response("REPORT Response"),
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "report",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "report",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("REPORT Response");
+        });
+        it("should disable 405 when config.disable405 is true", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    config: {
+                        disable405: true,
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(404);
+            expect(await response.text()).toBe("Not Found");
+        });
+        it("should disable OPTIONS when config.disableOptions is true", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                    config: {
+                        disableOptions: true,
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(405);
+            expect(await response.text()).toBe("Method Not Allowed");
+            expect(response.headers.get("Allow")).toBe("GET, POST");
+        });
+        it("should support middleware arrays in method handlers", async () => {
+            const executionOrder = [];
+            const authMiddleware = () => {
+                executionOrder.push("authMiddleware");
+            };
+            const getHandler = () => {
+                executionOrder.push("getHandler");
+                return new Response("GET Response");
+            };
+            const router = defineRoutes([
+                route("/test/", {
+                    get: [authMiddleware, getHandler],
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["authMiddleware", "getHandler"]);
+            expect(await response.text()).toBe("GET Response");
+        });
+    });
     describe("Edge Cases", () => {
         it("should handle middleware-only apps with RSC actions", async () => {
             const executionOrder = [];
@@ -643,4 +1015,242 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(await response.text()).toBe("Rendered: Element");
         });
     });
+    describe("except - Error Handling", () => {
+        it("should catch errors from global middleware", async () => {
+            const errorMessage = "Middleware error";
+            const middleware = () => {
+                throw new Error(errorMessage);
+            };
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                middleware,
+                errorHandler,
+                route("/test/", () => React.createElement("div")),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should catch errors from route handlers (components)", async () => {
+            const errorMessage = "Component error";
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should catch errors from route handlers (functions)", async () => {
+            const errorMessage = "Handler error";
+            const routeHandler = () => {
+                throw new Error(errorMessage);
+            };
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", routeHandler),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should catch errors from RSC actions", async () => {
+            const errorMessage = "RSC action error";
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", () => React.createElement("div")),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/?__rsc_action_id=test");
+            deps.mockRscActionHandler = async () => {
+                throw new Error(errorMessage);
+            };
+            const request = new Request("http://localhost:3000/test/?__rsc_action_id=test");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should use the most recent except handler before the error", async () => {
+            const errorMessage = "Route error";
+            const firstHandler = except((error) => {
+                return new Response("First handler", { status: 500 });
+            });
+            const secondHandler = except((error) => {
+                return new Response("Second handler", { status: 500 });
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const router = defineRoutes([
+                firstHandler,
+                secondHandler,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            // Should use the second handler (most recent before the route)
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe("Second handler");
+        });
+        it("should try next except handler if current one throws", async () => {
+            const errorMessage = "Route error";
+            const firstHandler = except(() => {
+                throw new Error("First handler error");
+            });
+            const secondHandler = except((error) => {
+                return new Response(`Caught by second: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const router = defineRoutes([
+                secondHandler, // Outer handler
+                firstHandler, // Inner handler (closer to route)
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            // Should catch the error from the first handler with the second handler
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe("Caught by second: First handler error");
+        });
+        it("should return JSX element from except handler", async () => {
+            const errorMessage = "Route error";
+            function ErrorComponent() {
+                return React.createElement("div", {}, "Error Page");
+            }
+            const errorHandler = except(() => {
+                return React.createElement(ErrorComponent);
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("Rendered: ErrorComponent");
+        });
+        it("should work with prefix and layout", async () => {
+            const errorMessage = "Route error";
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const Layout = ({ children }) => {
+                return React.createElement("div", {}, children);
+            };
+            const router = defineRoutes([
+                errorHandler,
+                layout(Layout, [prefix("/api", [route("/test/", PageComponent)])]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/api/test/");
+            const request = new Request("http://localhost:3000/api/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+    });
 });