diff --git a/packages/vinext/src/shims/router.ts b/packages/vinext/src/shims/router.ts
index f3bb4ea6..0df3bd1d 100644
--- a/packages/vinext/src/shims/router.ts
+++ b/packages/vinext/src/shims/router.ts
@@ -340,11 +340,59 @@ function getPathnameAndQuery(): {
   return { pathname, query, asPath };
 }
 
+/**
+ * Error thrown when a navigation is superseded by a newer one.
+ * Matches Next.js's convention of an Error with `.cancelled = true`.
+ */
+class NavigationCancelledError extends Error {
+  cancelled = true;
+  constructor(route: string) {
+    super(`Abort fetching component for route: "${route}"`);
+    this.name = "NavigationCancelledError";
+  }
+}
+
+/**
+ * Error thrown after queueing a hard navigation fallback for a known failure
+ * mode. Callers can use this to avoid scheduling the same hard navigation twice.
+ */
+class HardNavigationScheduledError extends Error {
+  hardNavigationScheduled = true;
+  constructor(message: string) {
+    super(message);
+    this.name = "HardNavigationScheduledError";
+  }
+}
+
+/**
+ * Monotonically increasing ID for tracking the current navigation.
+ * Each call to navigateClient() increments this and captures the value.
+ * After each async boundary, the navigation checks whether it is still
+ * the active one. If a newer navigation has started, the stale one
+ * throws NavigationCancelledError so the caller can emit routeChangeError
+ * and skip routeChangeComplete.
+ *
+ * Replaces the old boolean `_navInProgress` guard which silently dropped
+ * the second navigation, causing URL/content mismatch.
+ */
+let _navigationId = 0;
+
+/** AbortController for the in-flight fetch, so superseded navigations abort network I/O. */
+let _activeAbortController: AbortController | null = null;
+
+function scheduleHardNavigationAndThrow(url: string, message: string): never {
+  window.location.href = url;
+  throw new HardNavigationScheduledError(message);
+}
+
 /**
  * Perform client-side navigation: fetch the target page's HTML,
  * extract __NEXT_DATA__, and re-render the React root.
+ *
+ * Throws NavigationCancelledError if a newer navigation supersedes this one.
+ * Throws on hard-navigation failures (non-OK response, missing data) so the
+ * caller can distinguish success from failure for event emission.
  */
-let _navInProgress = false;
 async function navigateClient(url: string): Promise<void> {
   if (typeof window === "undefined") return;
 
@@ -355,30 +403,62 @@ async function navigateClient(url: string): Promise<void> {
     return;
   }
 
-  // Prevent re-entrant navigation (e.g., double popstate events)
-  if (_navInProgress) return;
-  _navInProgress = true;
+  // Cancel any in-flight navigation (abort its fetch, mark it stale)
+  _activeAbortController?.abort();
+  const controller = new AbortController();
+  _activeAbortController = controller;
+
+  const navId = ++_navigationId;
+
+  /** Check if this navigation is still the active one. If not, throw. */
+  function assertStillCurrent(): void {
+    if (navId !== _navigationId) {
+      throw new NavigationCancelledError(url);
+    }
+  }
 
   try {
     // Fetch the target page's SSR HTML
-    const res = await fetch(url, { headers: { Accept: "text/html" } });
+    let res: Response;
+    try {
+      res = await fetch(url, {
+        headers: { Accept: "text/html" },
+        signal: controller.signal,
+      });
+    } catch (err: unknown) {
+      // AbortError means a newer navigation cancelled this fetch
+      if (err instanceof DOMException && err.name === "AbortError") {
+        throw new NavigationCancelledError(url);
+      }
+      throw err;
+    }
+    assertStillCurrent();
+
     if (!res.ok) {
-      window.location.href = url;
-      return;
+      // Set window.location.href first so the browser navigates to the correct
+      // page even if the caller suppresses the error.  The assignment schedules
+      // the navigation asynchronously (as a task), so synchronous routeChangeError
+      // listeners still run — and observe the error — before the page unloads.
+      // Contract: routeChangeError listeners MUST be synchronous; async listeners
+      // will not fire before the navigation completes.  Callers (runNavigateClient)
+      // must NOT schedule a second hard navigation — this assignment already queues one.
+      scheduleHardNavigationAndThrow(url, `Navigation failed: ${res.status} ${res.statusText}`);
     }
 
     const html = await res.text();
+    assertStillCurrent();
 
     // Extract __NEXT_DATA__ from the HTML
     const match = html.match(/<script>window\.__NEXT_DATA__\s*=\s*(.*?)<\/script>/);
     if (!match) {
-      window.location.href = url;
-      return;
+      scheduleHardNavigationAndThrow(url, "Navigation failed: missing __NEXT_DATA__ in response");
     }
 
     const nextData = JSON.parse(match[1]);
     const { pageProps } = nextData.props;
-    window.__NEXT_DATA__ = nextData;
+    // Defer writing window.__NEXT_DATA__ until just before root.render() —
+    // writing it here would let a stale navigation briefly pollute the global
+    // between this assertStillCurrent() and the next one after await import().
 
     // Get the page module URL from __NEXT_DATA__.__vinext (preferred),
     // or fall back to parsing the hydration script
@@ -392,29 +472,29 @@ async function navigateClient(url: string): Promise<void> {
     }
 
     if (!pageModuleUrl) {
-      window.location.href = url;
-      return;
+      scheduleHardNavigationAndThrow(url, "Navigation failed: no page module URL found");
     }
 
     // Validate the module URL before importing — defense-in-depth against
     // unexpected __NEXT_DATA__ or malformed HTML responses
     if (!isValidModulePath(pageModuleUrl)) {
       console.error("[vinext] Blocked import of invalid page module path:", pageModuleUrl);
-      window.location.href = url;
-      return;
+      scheduleHardNavigationAndThrow(url, "Navigation failed: invalid page module path");
     }
 
     // Dynamically import the new page module
     const pageModule = await import(/* @vite-ignore */ pageModuleUrl);
+    assertStillCurrent();
+
     const PageComponent = pageModule.default;
 
     if (!PageComponent) {
-      window.location.href = url;
-      return;
+      scheduleHardNavigationAndThrow(url, "Navigation failed: page module has no default export");
     }
 
     // Import React for createElement
     const React = (await import("react")).default;
+    assertStillCurrent();
 
     // Re-render with the new page, loading _app if needed
     let AppComponent = window.__VINEXT_APP__;
@@ -433,6 +513,7 @@ async function navigateClient(url: string): Promise<void> {
         }
       }
     }
+    assertStillCurrent();
 
     let element;
     if (AppComponent) {
@@ -447,13 +528,50 @@ async function navigateClient(url: string): Promise<void> {
     // Wrap with RouterContext.Provider so next/compat/router works
     element = wrapWithRouterContext(element);
 
+    // Commit __NEXT_DATA__ only after all assertStillCurrent() checks have passed,
+    // so a stale navigation can never pollute the global.
+    window.__NEXT_DATA__ = nextData;
     root.render(element);
-  } catch (err) {
-    console.error("[vinext] Client navigation failed:", err);
-    routerEvents.emit("routeChangeError", err, url, { shallow: false });
-    window.location.href = url;
   } finally {
-    _navInProgress = false;
+    // Clean up the abort controller if this navigation is still the active one
+    if (navId === _navigationId) {
+      _activeAbortController = null;
+    }
+  }
+}
+
+/**
+ * Run navigateClient and handle errors: emit routeChangeError on failure,
+ * and fall back to a hard navigation for non-cancel errors so the browser
+ * recovers to a consistent state.
+ *
+ * Returns:
+ * - "completed" — navigation finished, caller should emit routeChangeComplete
+ * - "cancelled" — superseded by a newer navigation, caller should return true
+ *   without emitting routeChangeComplete (matches Next.js behaviour)
+ * - "failed" — genuine error, caller should return false (hard nav is already
+ *   scheduled as recovery)
+ */
+async function runNavigateClient(
+  fullUrl: string,
+  resolvedUrl: string,
+): Promise<"completed" | "cancelled" | "failed"> {
+  try {
+    await navigateClient(fullUrl);
+    return "completed";
+  } catch (err: unknown) {
+    routerEvents.emit("routeChangeError", err, resolvedUrl, { shallow: false });
+    if (err instanceof NavigationCancelledError) {
+      return "cancelled";
+    }
+    // Genuine error (network, parse, import failure): fall back to a hard
+    // navigation so the browser lands on the correct page. Known failure modes
+    // already scheduled that fallback inside navigateClient(); only unexpected
+    // failures (parse, import, render) need recovery here.
+    if (typeof window !== "undefined" && !(err instanceof HardNavigationScheduledError)) {
+      window.location.href = fullUrl;
+    }
+    return "failed";
   }
 }
 
@@ -564,7 +682,9 @@ export function useRouter(): NextRouter {
       window.history.pushState({}, "", full);
       _lastPathnameAndSearch = window.location.pathname + window.location.search;
       if (!options?.shallow) {
-        await navigateClient(full);
+        const result = await runNavigateClient(full, resolved);
+        if (result === "cancelled") return true;
+        if (result === "failed") return false;
       }
       setState(getPathnameAndQuery());
       routerEvents.emit("routeChangeComplete", resolved, { shallow: options?.shallow ?? false });
@@ -621,7 +741,9 @@ export function useRouter(): NextRouter {
       window.history.replaceState({}, "", full);
       _lastPathnameAndSearch = window.location.pathname + window.location.search;
       if (!options?.shallow) {
-        await navigateClient(full);
+        const result = await runNavigateClient(full, resolved);
+        if (result === "cancelled") return true;
+        if (result === "failed") return false;
       }
       setState(getPathnameAndQuery());
       routerEvents.emit("routeChangeComplete", resolved, { shallow: options?.shallow ?? false });
@@ -730,11 +852,21 @@ if (typeof window !== "undefined") {
     // precedes that call, not the URL change itself. We emit it here for API
     // compatibility.
     routerEvents.emit("beforeHistoryChange", fullAppUrl, { shallow: false });
-    void navigateClient(browserUrl).then(() => {
-      routerEvents.emit("routeChangeComplete", fullAppUrl, { shallow: false });
-      restoreScrollPosition(e.state);
-      window.dispatchEvent(new CustomEvent("vinext:navigate"));
-    });
+    void navigateClient(browserUrl).then(
+      () => {
+        routerEvents.emit("routeChangeComplete", fullAppUrl, { shallow: false });
+        restoreScrollPosition(e.state);
+        window.dispatchEvent(new CustomEvent("vinext:navigate"));
+      },
+      (err: unknown) => {
+        routerEvents.emit("routeChangeError", err, fullAppUrl, { shallow: false });
+        // For genuine errors (not cancellations), fall back to a hard navigation
+        // so the browser recovers to a consistent URL/content state.
+        if (!(err instanceof NavigationCancelledError)) {
+          window.location.href = browserUrl;
+        }
+      },
+    );
   });
 }
 
@@ -802,7 +934,9 @@ const Router = {
     window.history.pushState({}, "", full);
     _lastPathnameAndSearch = window.location.pathname + window.location.search;
     if (!options?.shallow) {
-      await navigateClient(full);
+      const result = await runNavigateClient(full, resolved);
+      if (result === "cancelled") return true;
+      if (result === "failed") return false;
     }
     routerEvents.emit("routeChangeComplete", resolved, { shallow: options?.shallow ?? false });
 
@@ -852,7 +986,9 @@ const Router = {
     window.history.replaceState({}, "", full);
     _lastPathnameAndSearch = window.location.pathname + window.location.search;
     if (!options?.shallow) {
-      await navigateClient(full);
+      const result = await runNavigateClient(full, resolved);
+      if (result === "cancelled") return true;
+      if (result === "failed") return false;
     }
     routerEvents.emit("routeChangeComplete", resolved, { shallow: options?.shallow ?? false });
 
diff --git a/tests/shims.test.ts b/tests/shims.test.ts
index 9b86462d..fd37f7ea 100644
--- a/tests/shims.test.ts
+++ b/tests/shims.test.ts
@@ -8401,6 +8401,617 @@ describe("Pages Router router helpers", () => {
   });
 });
 
+describe("Pages Router concurrent navigation", () => {
+  /**
+   * Helper: create a mock window suitable for non-shallow Router.push().
+   * Returns an object with the window mock plus helpers for controlling
+   * the fetch responses (deferred promises).
+   */
+  function createNavWindow() {
+    const pushState = vi.fn();
+    const replaceState = vi.fn();
+    const render = vi.fn();
+
+    const win = {
+      location: {
+        pathname: "/",
+        search: "",
+        hash: "",
+        href: "http://localhost/",
+        hostname: "localhost",
+        assign: vi.fn(),
+        replace: vi.fn(),
+        reload: vi.fn(),
+      },
+      history: {
+        state: null,
+        pushState: pushState as any,
+        replaceState: replaceState as any,
+        back: vi.fn(),
+      },
+      dispatchEvent: vi.fn(),
+      scrollTo: vi.fn(),
+      scrollX: 0,
+      scrollY: 0,
+      addEventListener: vi.fn(),
+      __NEXT_DATA__: {
+        page: "/",
+        query: {},
+        isFallback: false,
+        props: { pageProps: {} },
+        __vinext: { pageModuleUrl: "/@fs/pages/index.js" },
+      },
+      __VINEXT_ROOT__: { render },
+      __VINEXT_APP__: undefined,
+      __VINEXT_LOCALE__: undefined,
+      __VINEXT_LOCALES__: undefined,
+      __VINEXT_DEFAULT_LOCALE__: undefined,
+    };
+
+    // Make pushState update location to simulate real browser behavior
+    pushState.mockImplementation((_state: unknown, _title: string, url: string) => {
+      try {
+        const parsed = new URL(url, "http://localhost");
+        win.location.pathname = parsed.pathname;
+        win.location.search = parsed.search;
+        win.location.hash = parsed.hash;
+        win.location.href = parsed.href;
+      } catch {
+        // Relative URL — just set pathname
+        win.location.pathname = url;
+        win.location.href = "http://localhost" + url;
+      }
+    });
+
+    replaceState.mockImplementation((_state: unknown, _title: string, url?: string) => {
+      if (!url) return;
+      try {
+        const parsed = new URL(url, "http://localhost");
+        win.location.pathname = parsed.pathname;
+        win.location.search = parsed.search;
+        win.location.hash = parsed.hash;
+        win.location.href = parsed.href;
+      } catch {
+        win.location.pathname = url;
+        win.location.href = "http://localhost" + url;
+      }
+    });
+
+    return { win, pushState, replaceState, render };
+  }
+
+  /**
+   * Build a minimal HTML response that navigateClient can parse.
+   * Includes __NEXT_DATA__ with a pageModuleUrl pointing to the given path.
+   */
+  function buildNavHtml(page: string, pageModuleUrl: string): string {
+    const nextData = JSON.stringify({
+      page,
+      query: {},
+      isFallback: false,
+      props: { pageProps: { page } },
+      __vinext: { pageModuleUrl },
+    });
+    return `<html><head></head><body><script>window.__NEXT_DATA__ = ${nextData}</script></body></html>`;
+  }
+
+  /**
+   * Create a deferred promise for controlling fetch timing.
+   */
+  function createDeferred<T>() {
+    let resolve!: (value: T) => void;
+    let reject!: (reason: unknown) => void;
+    const promise = new Promise<T>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  }
+
+  function trackHrefAssignments(win: {
+    location: {
+      href: string;
+    };
+  }): string[] {
+    let currentHref = win.location.href;
+    const assignments: string[] = [];
+
+    Object.defineProperty(win.location, "href", {
+      configurable: true,
+      enumerable: true,
+      get: () => currentHref,
+      set: (value: string) => {
+        currentHref = value;
+        assignments.push(value);
+      },
+    });
+
+    return assignments;
+  }
+
+  it("last push() wins when two overlap — superseded navigation does not render", async () => {
+    const previousWindow = (globalThis as any).window;
+    const originalFetch = globalThis.fetch;
+    const { win } = createNavWindow();
+    (globalThis as any).window = win;
+
+    // Two deferred fetches so we control resolution order
+    const fetchA = createDeferred<Response>();
+    const fetchB = createDeferred<Response>();
+    let fetchCount = 0;
+
+    globalThis.fetch = async (_url: any, _init: any) => {
+      fetchCount++;
+      if (fetchCount === 1) return fetchA.promise;
+      return fetchB.promise;
+    };
+
+    try {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+
+      // Start two navigations — don't await yet
+      const navA = Router.push("/page-a");
+      // Let microtask queue process so navA's fetch has been called
+      await Promise.resolve();
+      const navB = Router.push("/page-b");
+
+      // Resolve B first (the winning navigation)
+      fetchB.resolve(new Response(buildNavHtml("/page-b", "/@fs/pages/page-b.js")));
+
+      // Resolve A after B (stale — should be ignored)
+      fetchA.resolve(new Response(buildNavHtml("/page-a", "/@fs/pages/page-a.js")));
+
+      await Promise.allSettled([navA, navB]);
+
+      // The superseded navigation (page-a) must NOT have committed its data.
+      // In a real browser page-b would render; in the test env B's dynamic import
+      // may fail, so we verify the important invariant: A never writes.
+      expect(win.__NEXT_DATA__.page).not.toBe("/page-a");
+    } finally {
+      if (previousWindow === undefined) {
+        delete (globalThis as any).window;
+      } else {
+        (globalThis as any).window = previousWindow;
+      }
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it("routeChangeComplete does not fire for the superseded navigation", async () => {
+    const previousWindow = (globalThis as any).window;
+    const originalFetch = globalThis.fetch;
+    const { win } = createNavWindow();
+    (globalThis as any).window = win;
+
+    const fetchA = createDeferred<Response>();
+    const fetchB = createDeferred<Response>();
+    let fetchCount = 0;
+
+    globalThis.fetch = async (_url: any, _init: any) => {
+      fetchCount++;
+      if (fetchCount === 1) return fetchA.promise;
+      return fetchB.promise;
+    };
+
+    const completedUrls: string[] = [];
+    const onRouteChangeComplete = (...args: unknown[]) => {
+      completedUrls.push(String(args[0]));
+    };
+
+    try {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+
+      Router.events.on("routeChangeComplete", onRouteChangeComplete);
+
+      // Start two overlapping navigations
+      const navA = Router.push("/page-a");
+      await Promise.resolve();
+      const navB = Router.push("/page-b");
+
+      // Resolve B first, then A
+      fetchB.resolve(new Response(buildNavHtml("/page-b", "/@fs/pages/page-b.js")));
+      fetchA.resolve(new Response(buildNavHtml("/page-a", "/@fs/pages/page-a.js")));
+
+      await Promise.allSettled([navA, navB]);
+
+      // The superseded navigation (page-a) must NOT fire routeChangeComplete.
+      // page-b may or may not complete fully (dynamic import may fail in test
+      // env), but that's a separate concern. The critical fix is that the
+      // cancelled navigation never fires routeChangeComplete.
+      expect(completedUrls).not.toContain("/page-a");
+    } finally {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+      Router.events.off("routeChangeComplete", onRouteChangeComplete);
+      if (previousWindow === undefined) {
+        delete (globalThis as any).window;
+      } else {
+        (globalThis as any).window = previousWindow;
+      }
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it("routeChangeError fires for superseded navigation with cancelled error", async () => {
+    const previousWindow = (globalThis as any).window;
+    const originalFetch = globalThis.fetch;
+    const { win } = createNavWindow();
+    (globalThis as any).window = win;
+
+    const fetchA = createDeferred<Response>();
+    const fetchB = createDeferred<Response>();
+    let fetchCount = 0;
+
+    globalThis.fetch = async (_url: any, _init: any) => {
+      fetchCount++;
+      if (fetchCount === 1) return fetchA.promise;
+      return fetchB.promise;
+    };
+
+    const errors: Array<{ err: unknown; url: string }> = [];
+    const onRouteChangeError = (...args: unknown[]) => {
+      errors.push({ err: args[0], url: String(args[1]) });
+    };
+
+    try {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+
+      Router.events.on("routeChangeError", onRouteChangeError);
+
+      // Start two overlapping navigations
+      const navA = Router.push("/page-a");
+      await Promise.resolve();
+      const navB = Router.push("/page-b");
+
+      // Resolve both
+      fetchB.resolve(new Response(buildNavHtml("/page-b", "/@fs/pages/page-b.js")));
+      fetchA.resolve(new Response(buildNavHtml("/page-a", "/@fs/pages/page-a.js")));
+
+      await Promise.allSettled([navA, navB]);
+
+      // The superseded navigation (page-a) should emit routeChangeError
+      // with a cancelled error, matching Next.js behavior
+      const cancelledError = errors.find((e) => e.url === "/page-a");
+      expect(cancelledError).toBeDefined();
+      const errObj = cancelledError?.err;
+      expect(errObj).toHaveProperty("cancelled", true);
+    } finally {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+      Router.events.off("routeChangeError", onRouteChangeError);
+      if (previousWindow === undefined) {
+        delete (globalThis as any).window;
+      } else {
+        (globalThis as any).window = previousWindow;
+      }
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it("failed navigation (non-OK response) does not emit routeChangeComplete", async () => {
+    const previousWindow = (globalThis as any).window;
+    const originalFetch = globalThis.fetch;
+    const { win } = createNavWindow();
+    (globalThis as any).window = win;
+
+    globalThis.fetch = async (_url: any, _init: any) =>
+      new Response("Internal Server Error", { status: 500 });
+
+    const completedUrls: string[] = [];
+    const errorUrls: string[] = [];
+    const onRouteChangeComplete = (...args: unknown[]) => {
+      completedUrls.push(String(args[0]));
+    };
+    const onRouteChangeError = (...args: unknown[]) => {
+      errorUrls.push(String(args[1]));
+    };
+
+    try {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+
+      Router.events.on("routeChangeComplete", onRouteChangeComplete);
+      Router.events.on("routeChangeError", onRouteChangeError);
+
+      await Router.push("/failing-page");
+
+      // Should NOT have fired routeChangeComplete for a failed navigation
+      expect(completedUrls).not.toContain("/failing-page");
+      // Should have fired routeChangeError
+      expect(errorUrls).toContain("/failing-page");
+    } finally {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+      Router.events.off("routeChangeComplete", onRouteChangeComplete);
+      Router.events.off("routeChangeError", onRouteChangeError);
+      if (previousWindow === undefined) {
+        delete (globalThis as any).window;
+      } else {
+        (globalThis as any).window = previousWindow;
+      }
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it("known navigation failures schedule a single hard navigation", async () => {
+    const previousWindow = (globalThis as any).window;
+    const originalFetch = globalThis.fetch;
+    const { win } = createNavWindow();
+    const hrefAssignments = trackHrefAssignments(win);
+    (globalThis as any).window = win;
+
+    globalThis.fetch = async (_url: any, _init: any) =>
+      new Response("Internal Server Error", { status: 500 });
+
+    try {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+
+      const result = await Router.push("/failing-page");
+
+      expect(result).toBe(false);
+      expect(hrefAssignments.filter((value) => value.endsWith("/failing-page"))).toHaveLength(2);
+    } finally {
+      if (previousWindow === undefined) {
+        delete (globalThis as any).window;
+      } else {
+        (globalThis as any).window = previousWindow;
+      }
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it("replace() also cancels superseded navigation", async () => {
+    const previousWindow = (globalThis as any).window;
+    const originalFetch = globalThis.fetch;
+    const { win } = createNavWindow();
+    (globalThis as any).window = win;
+
+    const fetchA = createDeferred<Response>();
+    const fetchB = createDeferred<Response>();
+    let fetchCount = 0;
+
+    globalThis.fetch = async (_url: any, _init: any) => {
+      fetchCount++;
+      if (fetchCount === 1) return fetchA.promise;
+      return fetchB.promise;
+    };
+
+    const completedUrls: string[] = [];
+    const errors: Array<{ err: unknown; url: string }> = [];
+    const onRouteChangeComplete = (...args: unknown[]) => {
+      completedUrls.push(String(args[0]));
+    };
+    const onRouteChangeError = (...args: unknown[]) => {
+      errors.push({ err: args[0], url: String(args[1]) });
+    };
+
+    try {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+
+      Router.events.on("routeChangeComplete", onRouteChangeComplete);
+      Router.events.on("routeChangeError", onRouteChangeError);
+
+      // First push, then replace overlapping
+      const navA = Router.push("/page-a");
+      await Promise.resolve();
+      const navB = Router.replace("/page-b");
+
+      fetchB.resolve(new Response(buildNavHtml("/page-b", "/@fs/pages/page-b.js")));
+      fetchA.resolve(new Response(buildNavHtml("/page-a", "/@fs/pages/page-a.js")));
+
+      await Promise.allSettled([navA, navB]);
+
+      // The superseded push (page-a) should be cancelled, not completed
+      expect(completedUrls).not.toContain("/page-a");
+      // page-a should have a cancelled error
+      const cancelledA = errors.find((e) => e.url === "/page-a");
+      expect(cancelledA).toBeDefined();
+      expect(cancelledA?.err).toHaveProperty("cancelled", true);
+    } finally {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+      Router.events.off("routeChangeComplete", onRouteChangeComplete);
+      Router.events.off("routeChangeError", onRouteChangeError);
+      if (previousWindow === undefined) {
+        delete (globalThis as any).window;
+      } else {
+        (globalThis as any).window = previousWindow;
+      }
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it("abort signal fires when navigation is superseded — AbortError becomes NavigationCancelledError", async () => {
+    // Verify that the AbortController signal passed to fetch actually fires when a
+    // newer navigation starts, and that the resulting AbortError is converted into
+    // a NavigationCancelledError (the routeChangeError path, not a plain rejection).
+    const previousWindow = (globalThis as any).window;
+    const originalFetch = globalThis.fetch;
+    const { win } = createNavWindow();
+    (globalThis as any).window = win;
+
+    const fetchA = createDeferred<Response>();
+    const fetchB = createDeferred<Response>();
+    let fetchCount = 0;
+
+    // Signal-aware mock: the first fetch rejects with AbortError when its signal fires.
+    globalThis.fetch = async (_url: any, _init: any) => {
+      fetchCount++;
+      if (fetchCount === 1) {
+        return new Promise<Response>((resolve, reject) => {
+          fetchA.promise.then(resolve, reject);
+          _init?.signal?.addEventListener("abort", () => {
+            reject(new DOMException("The operation was aborted.", "AbortError"));
+          });
+        });
+      }
+      return fetchB.promise;
+    };
+
+    const errors: Array<{ err: unknown; url: string }> = [];
+    const onRouteChangeError = (...args: unknown[]) => {
+      errors.push({ err: args[0], url: String(args[1]) });
+    };
+
+    try {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+
+      Router.events.on("routeChangeError", onRouteChangeError);
+
+      // Start navigation A then immediately supersede it with B
+      const navA = Router.push("/page-a");
+      await Promise.resolve();
+      const navB = Router.push("/page-b");
+
+      // Resolve B; A is aborted via its signal — no manual resolution needed
+      fetchB.resolve(new Response(buildNavHtml("/page-b", "/@fs/pages/page-b.js")));
+
+      await Promise.allSettled([navA, navB]);
+
+      // navA's fetch was aborted via signal → AbortError → NavigationCancelledError
+      const cancelledError = errors.find((e) => e.url === "/page-a");
+      expect(cancelledError).toBeDefined();
+      expect(cancelledError?.err).toHaveProperty("cancelled", true);
+    } finally {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+      Router.events.off("routeChangeError", onRouteChangeError);
+      if (previousWindow === undefined) {
+        delete (globalThis as any).window;
+      } else {
+        (globalThis as any).window = previousWindow;
+      }
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it("stale response arriving first does not render before the winning navigation", async () => {
+    // fetchA (stale, page-a) resolves before fetchB (winning, page-b).
+    // assertStillCurrent() in navigateClient must catch the stale navigation
+    // after it processes the response, so page-a's data never reaches the DOM.
+    const previousWindow = (globalThis as any).window;
+    const originalFetch = globalThis.fetch;
+    const { win } = createNavWindow();
+    (globalThis as any).window = win;
+
+    const fetchA = createDeferred<Response>();
+    const fetchB = createDeferred<Response>();
+    let fetchCount = 0;
+
+    globalThis.fetch = async (_url: any, _init: any) => {
+      fetchCount++;
+      if (fetchCount === 1) return fetchA.promise;
+      return fetchB.promise;
+    };
+
+    const completedUrls: string[] = [];
+    const onRouteChangeComplete = (...args: unknown[]) => {
+      completedUrls.push(String(args[0]));
+    };
+
+    try {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+
+      Router.events.on("routeChangeComplete", onRouteChangeComplete);
+
+      // Start two navigations
+      const navA = Router.push("/page-a");
+      await Promise.resolve();
+      const navB = Router.push("/page-b");
+
+      // Stale fetch (A) resolves first this time
+      fetchA.resolve(new Response(buildNavHtml("/page-a", "/@fs/pages/page-a.js")));
+      // Winning fetch (B) resolves after
+      fetchB.resolve(new Response(buildNavHtml("/page-b", "/@fs/pages/page-b.js")));
+
+      await Promise.allSettled([navA, navB]);
+
+      // Stale navigation must not have committed its data to the DOM.
+      // B may also fail at dynamic import in test env, so we only verify A never wrote.
+      expect(win.__NEXT_DATA__.page).not.toBe("/page-a");
+      // Stale navigation must not fire routeChangeComplete
+      expect(completedUrls).not.toContain("/page-a");
+    } finally {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+      Router.events.off("routeChangeComplete", onRouteChangeComplete);
+      if (previousWindow === undefined) {
+        delete (globalThis as any).window;
+      } else {
+        (globalThis as any).window = previousWindow;
+      }
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it("__NEXT_DATA__ is not stale when routeChangeError fires for a cancelled navigation", async () => {
+    // Regression test: __NEXT_DATA__ must not reflect the cancelled route's data
+    // at the moment routeChangeError fires.  The fix defers the global write until
+    // just before root.render(), after all assertStillCurrent() checks pass.
+    const previousWindow = (globalThis as any).window;
+    const originalFetch = globalThis.fetch;
+    const { win } = createNavWindow();
+    (globalThis as any).window = win;
+
+    const fetchA = createDeferred<Response>();
+    const fetchB = createDeferred<Response>();
+    let fetchCount = 0;
+
+    globalThis.fetch = async (_url: any, _init: any) => {
+      fetchCount++;
+      if (fetchCount === 1) return fetchA.promise;
+      return fetchB.promise;
+    };
+
+    // Track __NEXT_DATA__.page at the moment of each routeChangeError
+    const nextDataPageAtError: string[] = [];
+    const onRouteChangeError = () => {
+      nextDataPageAtError.push(win.__NEXT_DATA__.page);
+    };
+
+    try {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+
+      Router.events.on("routeChangeError", onRouteChangeError);
+
+      // Start two navigations — A will be superseded by B
+      const navA = Router.push("/page-a");
+      await Promise.resolve();
+      const navB = Router.push("/page-b");
+
+      // Resolve stale (A) first, then winning (B)
+      fetchA.resolve(new Response(buildNavHtml("/page-a", "/@fs/pages/page-a.js")));
+      fetchB.resolve(new Response(buildNavHtml("/page-b", "/@fs/pages/page-b.js")));
+
+      await Promise.allSettled([navA, navB]);
+
+      // At the moment routeChangeError fired for nav A, __NEXT_DATA__ must NOT
+      // have been overwritten with page-a's data
+      for (const page of nextDataPageAtError) {
+        expect(page).not.toBe("/page-a");
+      }
+    } finally {
+      const routerModule = await import("../packages/vinext/src/shims/router.js");
+      const Router = routerModule.default;
+      Router.events.off("routeChangeError", onRouteChangeError);
+      if (previousWindow === undefined) {
+        delete (globalThis as any).window;
+      } else {
+        (globalThis as any).window = previousWindow;
+      }
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
 describe("next/server enhancements", () => {
   it("NextRequest.ip extracts from x-forwarded-for header", async () => {
     const { NextRequest } = await import("../packages/vinext/src/shims/server.js");