rwsdk 1.2.8 → 1.2.10

package/dist/runtime/client/navigation.js

@@ -1,4 +1,5 @@
 import { onNavigationCommit, preloadFromLinkTags, } from "./navigationCache.js";
+import { createScrollRestoration, } from "./scrollRestoration.js";
 export function validateClickEvent(event, target) {
     // should this only work for left click?
     if (event.button !== 0) {
@@ -32,47 +33,37 @@ export function validateClickEvent(event, target) {
     return true;
 }
 let IS_CLIENT_NAVIGATION = false;
-// Scroll intent recorded at navigation time and applied post-commit in
-// onHydrated, so the new scroll position aligns with the new DOM rather
-// than flashing on top of the old one.
-let pendingScroll = null;
+let scrollRestoration = null;
 export async function navigate(href, options = { history: "push" }) {
     if (!IS_CLIENT_NAVIGATION) {
         window.location.href = href;
         return;
     }
-    saveScrollPosition(window.scrollX, window.scrollY);
     const url = new URL(href, window.location.href);
+    const scrollToTop = options.info?.scrollToTop ?? true;
+    const scrollBehavior = (options.info?.scrollBehavior ??
+        "instant");
+    const nextScrollPosition = scrollToTop
+        ? { x: 0, y: 0 }
+        : { x: window.scrollX, y: window.scrollY };
     if (options.history === "push") {
-        window.history.pushState({ path: href }, "", url);
+        scrollRestoration?.pushEntry(href, url, nextScrollPosition);
     }
     else {
-        window.history.replaceState({ path: href }, "", url);
+        scrollRestoration?.replaceEntry(href, url, nextScrollPosition);
     }
-    const scrollToTop = options.info?.scrollToTop ?? true;
-    const scrollBehavior = (options.info?.scrollBehavior ??
-        "instant");
     if (scrollToTop) {
-        pendingScroll = { x: 0, y: 0, behavior: scrollBehavior };
+        scrollRestoration?.setPendingScroll({
+            ...nextScrollPosition,
+            behavior: scrollBehavior,
+        });
+    }
+    else {
+        scrollRestoration?.recordCurrentPosition(window.scrollX, window.scrollY);
     }
     await options.onNavigate?.();
     await globalThis.__rsc_callServer(null, null, "navigation");
 }
-function saveScrollPosition(x, y) {
-    window.history.replaceState({
-        ...window.history.state,
-        scrollX: x,
-        scrollY: y,
-    }, "", window.location.href);
-}
-function applyPendingScroll() {
-    if (!pendingScroll)
-        return;
-    const { x, y, behavior } = pendingScroll;
-    pendingScroll = null;
-    window.scrollTo({ top: y, left: x, behavior });
-    saveScrollPosition(x, y);
-}
 /**
  * Initializes client-side navigation for Single Page App (SPA) behavior.
  *
@@ -116,23 +107,8 @@ function applyPendingScroll() {
  */
 export function initClientNavigation(opts = {}) {
     IS_CLIENT_NAVIGATION = true;
-    // Take manual control of scroll restoration. With "auto", the browser
-    // restores scroll immediately on popstate — before the RSC payload has
-    // committed — which causes the old DOM to flash at the new scroll offset.
-    history.scrollRestoration = "manual";
-    // If we're booting onto an entry that already has a saved scroll (e.g.
-    // a reload after scrolling, or a back-forward cache restore), queue that
-    // position so the first commit lands us where the user left off.
-    const bootState = window.history.state;
-    if (bootState &&
-        (typeof bootState.scrollX === "number" ||
-            typeof bootState.scrollY === "number")) {
-        pendingScroll = {
-            x: bootState.scrollX ?? 0,
-            y: bootState.scrollY ?? 0,
-            behavior: "instant",
-        };
-    }
+    scrollRestoration = createScrollRestoration();
+    scrollRestoration.initialize();
     document.addEventListener("click", async function handleClickEvent(event) {
         if (!validateClickEvent(event, event.target)) {
             return;
@@ -144,28 +120,33 @@ export function initClientNavigation(opts = {}) {
         await navigate(href, { history: "push", onNavigate: opts.onNavigate });
     }, true);
     window.addEventListener("popstate", async function handlePopState() {
-        const state = window.history.state ?? {};
-        pendingScroll = {
-            x: typeof state.scrollX === "number" ? state.scrollX : 0,
-            y: typeof state.scrollY === "number" ? state.scrollY : 0,
-            behavior: "instant",
-        };
+        scrollRestoration?.restorePopStateScroll();
         await opts.onNavigate?.();
         await globalThis.__rsc_callServer(null, null, "navigation");
     });
-    // Persist the user's scroll position on the current history entry so
-    // that back/forward navigation can restore it accurately once the new
-    // RSC payload commits. Coalesced via rAF to avoid thrashing replaceState.
-    let scrollSaveScheduled = false;
+    // Track the user's scroll position in memory so back/forward navigation can
+    // restore it after the RSC payload commits. Avoid writing on every scroll via
+    // history.replaceState because browsers throttle frequent history updates.
     window.addEventListener("scroll", () => {
-        if (scrollSaveScheduled)
-            return;
-        scrollSaveScheduled = true;
-        requestAnimationFrame(() => {
-            scrollSaveScheduled = false;
-            saveScrollPosition(window.scrollX, window.scrollY);
-        });
+        scrollRestoration?.recordCurrentPosition(window.scrollX, window.scrollY);
     }, { passive: true });
+    let didFlushForHiddenPage = false;
+    function flushForPageLifecycle() {
+        if (didFlushForHiddenPage) {
+            return;
+        }
+        didFlushForHiddenPage = true;
+        scrollRestoration?.flushCurrentPositionToHistoryState();
+    }
+    window.addEventListener("pagehide", flushForPageLifecycle);
+    document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "hidden") {
+            flushForPageLifecycle();
+        }
+        else {
+            didFlushForHiddenPage = false;
+        }
+    });
     function handleResponse(response) {
         if (response.status >= 300 && response.status < 400) {
             const location = response.headers.get("Location");
@@ -190,7 +171,7 @@ export function initClientNavigation(opts = {}) {
         // Apply any pending scroll intent now that React has committed the new
         // DOM — this is what prevents the scroll flash on both link-click and
         // popstate navigations.
-        applyPendingScroll();
+        scrollRestoration?.applyPendingScroll();
         // After each RSC hydration/update, increment generation and evict old caches,
         // then warm the navigation cache based on any <link rel="x-prefetch"> tags
         // rendered for the current location.

package/dist/runtime/client/navigation.test.js

@@ -1,10 +1,18 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { validateClickEvent, initClientNavigation } from "./navigation";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { initClientNavigation, validateClickEvent } from "./navigation";
+import { HISTORY_STATE_SCROLL_KEY } from "./scrollRestoration";
 // Mocking browser globals
 vi.stubGlobal("window", {
     location: { href: "http://localhost/" },
     addEventListener: vi.fn(),
-    history: { scrollRestoration: "auto" },
+    history: {
+        scrollRestoration: "auto",
+        pushState: vi.fn(),
+        replaceState: vi.fn(),
+        state: {},
+    },
+    scrollX: 0,
+    scrollY: 0,
 });
 vi.stubGlobal("document", {
     addEventListener: vi.fn(),
@@ -84,8 +92,11 @@ describe("onNavigate callback (issue #1123 regression)", () => {
         capturedClickHandler = null;
         capturedPopstateHandler = null;
         vi.clearAllMocks();
+        let historyState = {};
         // Capture registered event listeners so we can invoke them manually
         vi.stubGlobal("document", {
+            visibilityState: "visible",
+            querySelectorAll: vi.fn().mockReturnValue([]),
             addEventListener: vi.fn((event, handler) => {
                 if (event === "click")
                     capturedClickHandler = handler;
@@ -99,10 +110,18 @@ describe("onNavigate callback (issue #1123 regression)", () => {
             }),
             history: {
                 scrollRestoration: "auto",
-                pushState: vi.fn(),
-                replaceState: vi.fn(),
-                state: {},
+                get state() {
+                    return historyState;
+                },
+                pushState: vi.fn((state) => {
+                    historyState = state;
+                }),
+                replaceState: vi.fn((state) => {
+                    historyState = state;
+                }),
             },
+            scrollX: 0,
+            scrollY: 0,
             scrollTo: vi.fn(),
         });
         vi.stubGlobal("history", {
@@ -153,7 +172,9 @@ describe("onNavigate callback (issue #1123 regression)", () => {
     });
     it("onNavigate fires after pushState but before RSC fetch", async () => {
         const callOrder = [];
-        const onNavigate = vi.fn(() => { callOrder.push("onNavigate"); });
+        const onNavigate = vi.fn(() => {
+            callOrder.push("onNavigate");
+        });
         globalThis.__rsc_callServer = vi.fn(() => {
             callOrder.push("rscCallServer");
             return Promise.resolve();
@@ -183,9 +204,54 @@ describe("onNavigate callback (issue #1123 regression)", () => {
     });
 });
 describe("initClientNavigation", () => {
+    let historyState;
+    let capturedScrollHandler = null;
+    let capturedPagehideHandler = null;
+    let capturedVisibilityChangeHandler = null;
     beforeEach(() => {
-        window.location.href = "http://localhost/";
+        historyState = {};
+        capturedScrollHandler = null;
+        capturedPagehideHandler = null;
+        capturedVisibilityChangeHandler = null;
         vi.clearAllMocks();
+        const mockHistory = {
+            scrollRestoration: "auto",
+            get state() {
+                return historyState;
+            },
+            pushState: vi.fn((state) => {
+                historyState = state;
+            }),
+            replaceState: vi.fn((state) => {
+                historyState = state;
+            }),
+        };
+        vi.stubGlobal("document", {
+            visibilityState: "visible",
+            querySelectorAll: vi.fn().mockReturnValue([]),
+            addEventListener: vi.fn((event, handler) => {
+                if (event === "visibilitychange") {
+                    capturedVisibilityChangeHandler = handler;
+                }
+            }),
+        });
+        vi.stubGlobal("window", {
+            location: { href: "http://localhost/" },
+            addEventListener: vi.fn((event, handler) => {
+                if (event === "scroll") {
+                    capturedScrollHandler = handler;
+                }
+                if (event === "pagehide") {
+                    capturedPagehideHandler = handler;
+                }
+            }),
+            history: mockHistory,
+            fetch: vi.fn(),
+            scrollX: 0,
+            scrollY: 0,
+            scrollTo: vi.fn(),
+        });
+        vi.stubGlobal("history", mockHistory);
     });
     it("handleResponse should follow redirects", () => {
         const { handleResponse } = initClientNavigation();
@@ -213,4 +279,75 @@ describe("initClientNavigation", () => {
         initClientNavigation();
         expect(history.scrollRestoration).toBe("manual");
     });
+    it("does not write to history state on scroll", () => {
+        initClientNavigation();
+        expect(capturedScrollHandler).not.toBeNull();
+        vi.mocked(window.history.replaceState).mockClear();
+        window.scrollY = 100;
+        capturedScrollHandler();
+        window.scrollY = 200;
+        capturedScrollHandler();
+        expect(window.history.replaceState).not.toHaveBeenCalled();
+    });
+    it("restores scroll from persisted history state after reload", () => {
+        historyState = {
+            [HISTORY_STATE_SCROLL_KEY]: "entry:1",
+            scrollX: 9,
+            scrollY: 321,
+        };
+        const { onHydrated } = initClientNavigation();
+        onHydrated();
+        expect(window.scrollTo).toHaveBeenCalledWith({
+            left: 9,
+            top: 321,
+            behavior: "instant",
+        });
+    });
+    it("migrates legacy scrollX/scrollY state on boot", () => {
+        historyState = { scrollX: 11, scrollY: 432 };
+        const { onHydrated } = initClientNavigation();
+        onHydrated();
+        expect(window.history.replaceState).toHaveBeenCalledWith(expect.objectContaining({
+            [HISTORY_STATE_SCROLL_KEY]: expect.any(String),
+            scrollX: 11,
+            scrollY: 432,
+        }), "", "http://localhost/");
+        expect(window.scrollTo).toHaveBeenCalledWith({
+            left: 11,
+            top: 432,
+            behavior: "instant",
+        });
+    });
+    it("flushes the latest scroll position on pagehide for reload restoration", () => {
+        initClientNavigation();
+        expect(capturedScrollHandler).not.toBeNull();
+        expect(capturedPagehideHandler).not.toBeNull();
+        vi.mocked(window.history.replaceState).mockClear();
+        window.scrollX = 3;
+        window.scrollY = 250;
+        capturedScrollHandler();
+        capturedPagehideHandler();
+        expect(window.history.replaceState).toHaveBeenCalledWith(expect.objectContaining({
+            [HISTORY_STATE_SCROLL_KEY]: expect.any(String),
+            scrollX: 3,
+            scrollY: 250,
+        }), "", "http://localhost/");
+    });
+    it("flushes the latest scroll position when the page is hidden", () => {
+        initClientNavigation();
+        expect(capturedVisibilityChangeHandler).not.toBeNull();
+        vi.mocked(window.history.replaceState).mockClear();
+        window.scrollX = 5;
+        window.scrollY = 275;
+        Object.defineProperty(document, "visibilityState", {
+            value: "hidden",
+            configurable: true,
+        });
+        capturedVisibilityChangeHandler();
+        expect(window.history.replaceState).toHaveBeenCalledWith(expect.objectContaining({
+            [HISTORY_STATE_SCROLL_KEY]: expect.any(String),
+            scrollX: 5,
+            scrollY: 275,
+        }), "", "http://localhost/");
+    });
 });

package/dist/runtime/client/scrollRestoration.d.ts

@@ -0,0 +1,25 @@
+export declare const HISTORY_STATE_SCROLL_KEY = "__rwsdk_scroll_key";
+export type ScrollPosition = {
+    x: number;
+    y: number;
+};
+export type PendingScroll = ScrollPosition & {
+    behavior: ScrollBehavior;
+};
+export interface NavigationHistoryState extends Record<string, unknown> {
+    path?: string;
+    scrollX?: number;
+    scrollY?: number;
+    [HISTORY_STATE_SCROLL_KEY]?: string;
+}
+export interface ScrollRestorationController {
+    initialize(): void;
+    recordCurrentPosition(x: number, y: number): void;
+    flushCurrentPositionToHistoryState(x?: number, y?: number): void;
+    pushEntry(href: string, url: URL, initialPosition: ScrollPosition): void;
+    replaceEntry(href: string, url: URL, initialPosition: ScrollPosition): void;
+    restorePopStateScroll(): void;
+    setPendingScroll(pendingScroll: PendingScroll): void;
+    applyPendingScroll(): void;
+}
+export declare function createScrollRestoration(): ScrollRestorationController;

package/dist/runtime/client/scrollRestoration.js

@@ -0,0 +1,157 @@
+export const HISTORY_STATE_SCROLL_KEY = "__rwsdk_scroll_key";
+export function createScrollRestoration() {
+    const historyEntryKeyPrefix = Math.random().toString(36).slice(2);
+    const scrollPositions = new Map();
+    let currentHistoryEntryKey = null;
+    let nextHistoryEntryKey = 0;
+    let pendingScroll = null;
+    function createHistoryEntryKey() {
+        nextHistoryEntryKey += 1;
+        return `${historyEntryKeyPrefix}:${nextHistoryEntryKey}`;
+    }
+    function readHistoryState() {
+        const state = window.history.state;
+        return state && typeof state === "object"
+            ? { ...state }
+            : {};
+    }
+    function getHistoryEntryKey(state) {
+        const key = state[HISTORY_STATE_SCROLL_KEY];
+        return typeof key === "string" ? key : null;
+    }
+    function getScrollPositionFromState(state) {
+        if (typeof state.scrollX === "number" ||
+            typeof state.scrollY === "number") {
+            return {
+                x: typeof state.scrollX === "number" ? state.scrollX : 0,
+                y: typeof state.scrollY === "number" ? state.scrollY : 0,
+            };
+        }
+        return null;
+    }
+    function ensureCurrentHistoryEntryKey(state = readHistoryState()) {
+        const existingKey = getHistoryEntryKey(state);
+        if (existingKey) {
+            currentHistoryEntryKey = existingKey;
+            return existingKey;
+        }
+        const historyEntryKey = createHistoryEntryKey();
+        currentHistoryEntryKey = historyEntryKey;
+        window.history.replaceState({ ...state, [HISTORY_STATE_SCROLL_KEY]: historyEntryKey }, "", window.location.href);
+        return historyEntryKey;
+    }
+    function getCurrentHistoryEntryKeyForReplace(state) {
+        const existingKey = getHistoryEntryKey(state) ?? currentHistoryEntryKey;
+        if (existingKey) {
+            currentHistoryEntryKey = existingKey;
+            return existingKey;
+        }
+        const historyEntryKey = createHistoryEntryKey();
+        currentHistoryEntryKey = historyEntryKey;
+        return historyEntryKey;
+    }
+    function getSavedScrollPosition(state) {
+        const historyEntryKey = getHistoryEntryKey(state) ?? currentHistoryEntryKey;
+        const savedPosition = historyEntryKey
+            ? scrollPositions.get(historyEntryKey)
+            : undefined;
+        return savedPosition ?? getScrollPositionFromState(state);
+    }
+    function writeHistoryState(state, historyEntryKey, position) {
+        window.history.replaceState({
+            ...state,
+            [HISTORY_STATE_SCROLL_KEY]: historyEntryKey,
+            scrollX: position.x,
+            scrollY: position.y,
+        }, "", window.location.href);
+    }
+    return {
+        initialize() {
+            // Take manual control of scroll restoration. With "auto", the browser
+            // restores scroll immediately on popstate — before the RSC payload has
+            // committed — which causes the old DOM to flash at the new scroll offset.
+            if ("scrollRestoration" in window.history) {
+                window.history.scrollRestoration = "manual";
+            }
+            // Boot can happen after a reload, or after an older runtime wrote only
+            // scrollX/scrollY. Seed the in-memory store from history.state so the
+            // first commit can restore the saved position without per-scroll writes.
+            const bootState = readHistoryState();
+            const bootHistoryEntryKey = ensureCurrentHistoryEntryKey(bootState);
+            const bootScrollPosition = getSavedScrollPosition(bootState);
+            if (bootScrollPosition) {
+                scrollPositions.set(bootHistoryEntryKey, bootScrollPosition);
+                pendingScroll = {
+                    x: bootScrollPosition.x,
+                    y: bootScrollPosition.y,
+                    behavior: "instant",
+                };
+            }
+        },
+        recordCurrentPosition(x, y) {
+            if (!currentHistoryEntryKey) {
+                return;
+            }
+            scrollPositions.set(currentHistoryEntryKey, { x, y });
+        },
+        flushCurrentPositionToHistoryState(x = window.scrollX, y = window.scrollY) {
+            const state = readHistoryState();
+            const historyEntryKey = ensureCurrentHistoryEntryKey(state);
+            const position = { x, y };
+            scrollPositions.set(historyEntryKey, position);
+            writeHistoryState(state, historyEntryKey, position);
+        },
+        pushEntry(href, url, initialPosition) {
+            this.flushCurrentPositionToHistoryState();
+            const historyEntryKey = createHistoryEntryKey();
+            currentHistoryEntryKey = historyEntryKey;
+            scrollPositions.set(historyEntryKey, initialPosition);
+            window.history.pushState({
+                path: href,
+                [HISTORY_STATE_SCROLL_KEY]: historyEntryKey,
+                scrollX: initialPosition.x,
+                scrollY: initialPosition.y,
+            }, "", url);
+        },
+        replaceEntry(href, url, initialPosition) {
+            const state = readHistoryState();
+            const historyEntryKey = getCurrentHistoryEntryKeyForReplace(state);
+            scrollPositions.set(historyEntryKey, initialPosition);
+            window.history.replaceState({
+                ...state,
+                path: href,
+                [HISTORY_STATE_SCROLL_KEY]: historyEntryKey,
+                scrollX: initialPosition.x,
+                scrollY: initialPosition.y,
+            }, "", url);
+        },
+        restorePopStateScroll() {
+            const state = readHistoryState();
+            const historyEntryKey = ensureCurrentHistoryEntryKey(state);
+            const savedScrollPosition = getSavedScrollPosition(state) ?? {
+                x: 0,
+                y: 0,
+            };
+            if (!scrollPositions.has(historyEntryKey)) {
+                scrollPositions.set(historyEntryKey, savedScrollPosition);
+            }
+            pendingScroll = {
+                x: savedScrollPosition.x,
+                y: savedScrollPosition.y,
+                behavior: "instant",
+            };
+        },
+        setPendingScroll(nextPendingScroll) {
+            pendingScroll = nextPendingScroll;
+            this.recordCurrentPosition(nextPendingScroll.x, nextPendingScroll.y);
+        },
+        applyPendingScroll() {
+            if (!pendingScroll)
+                return;
+            const { x, y, behavior } = pendingScroll;
+            pendingScroll = null;
+            window.scrollTo({ top: y, left: x, behavior });
+            this.recordCurrentPosition(x, y);
+        },
+    };
+}

package/dist/runtime/client/scrollRestoration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/scrollRestoration.test.js

@@ -0,0 +1,93 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createScrollRestoration, HISTORY_STATE_SCROLL_KEY, } from "./scrollRestoration";
+describe("scrollRestoration", () => {
+    let historyState;
+    beforeEach(() => {
+        historyState = {};
+        vi.stubGlobal("window", {
+            location: { href: "http://localhost/" },
+            scrollX: 0,
+            scrollY: 0,
+            scrollTo: vi.fn(),
+            history: {
+                scrollRestoration: "auto",
+                get state() {
+                    return historyState;
+                },
+                pushState: vi.fn((state) => {
+                    historyState = state;
+                }),
+                replaceState: vi.fn((state) => {
+                    historyState = state;
+                }),
+            },
+        });
+    });
+    it("restores scroll from history state after a reload", () => {
+        historyState = {
+            [HISTORY_STATE_SCROLL_KEY]: "entry:1",
+            scrollX: 12,
+            scrollY: 345,
+        };
+        const scrollRestoration = createScrollRestoration();
+        scrollRestoration.initialize();
+        scrollRestoration.applyPendingScroll();
+        expect(window.scrollTo).toHaveBeenCalledWith({
+            left: 12,
+            top: 345,
+            behavior: "instant",
+        });
+    });
+    it("migrates legacy scrollX/scrollY history state on boot", () => {
+        historyState = { scrollX: 7, scrollY: 222 };
+        const scrollRestoration = createScrollRestoration();
+        scrollRestoration.initialize();
+        scrollRestoration.applyPendingScroll();
+        expect(window.history.replaceState).toHaveBeenCalledWith(expect.objectContaining({
+            [HISTORY_STATE_SCROLL_KEY]: expect.any(String),
+            scrollX: 7,
+            scrollY: 222,
+        }), "", "http://localhost/");
+        expect(window.scrollTo).toHaveBeenCalledWith({
+            left: 7,
+            top: 222,
+            behavior: "instant",
+        });
+    });
+    it("restores back/forward positions from the in-memory key map", () => {
+        const scrollRestoration = createScrollRestoration();
+        scrollRestoration.initialize();
+        const firstEntryState = historyState;
+        window.scrollY = 500;
+        scrollRestoration.recordCurrentPosition(0, 500);
+        scrollRestoration.pushEntry("/next", new URL("/next", "http://localhost/"), { x: 0, y: 0 });
+        historyState = firstEntryState;
+        scrollRestoration.restorePopStateScroll();
+        scrollRestoration.applyPendingScroll();
+        expect(window.scrollTo).toHaveBeenCalledWith({
+            left: 0,
+            top: 500,
+            behavior: "instant",
+        });
+    });
+    it("does not write to history state while recording scroll", () => {
+        const scrollRestoration = createScrollRestoration();
+        scrollRestoration.initialize();
+        vi.mocked(window.history.replaceState).mockClear();
+        scrollRestoration.recordCurrentPosition(0, 100);
+        scrollRestoration.recordCurrentPosition(0, 200);
+        expect(window.history.replaceState).not.toHaveBeenCalled();
+    });
+    it("flushes the latest scroll position to history state on lifecycle boundaries", () => {
+        const scrollRestoration = createScrollRestoration();
+        scrollRestoration.initialize();
+        vi.mocked(window.history.replaceState).mockClear();
+        scrollRestoration.recordCurrentPosition(4, 400);
+        scrollRestoration.flushCurrentPositionToHistoryState(4, 400);
+        expect(window.history.replaceState).toHaveBeenCalledWith(expect.objectContaining({
+            [HISTORY_STATE_SCROLL_KEY]: expect.any(String),
+            scrollX: 4,
+            scrollY: 400,
+        }), "", "http://localhost/");
+    });
+});

package/dist/runtime/lib/router.d.ts

@@ -9,6 +9,7 @@ export type RouteMiddleware<T extends RequestInfo = RequestInfo> = BivariantRout
 export type ExceptHandler<T extends RequestInfo = RequestInfo> = {
     __rwExcept: true;
     handler: (error: unknown, requestInfo: T) => MaybePromise<React.JSX.Element | Response | void>;
+    pathPattern?: string;
 };
 type RouteFunction<T extends RequestInfo = RequestInfo> = BivariantRouteHandler<T, MaybePromise<Response>>;
 type RouteComponent<T extends RequestInfo = RequestInfo> = BivariantRouteHandler<T, MaybePromise<React.JSX.Element | Response | void>>;