@pyreon/router 0.12.14 → 0.13.0

package/lib/types/index.d.ts

@@ -449,20 +449,6 @@ declare function onBeforeRouteLeave(guard: NavigationGuard): () => void;
  * })
  */
 declare function onBeforeRouteUpdate(guard: NavigationGuard): () => void;
-/**
- * Register a navigation blocker. The `fn` callback is called before each
- * navigation — return `true` (or resolve to `true`) to block it.
- *
- * Automatically removed on component unmount if called during component setup.
- * Also installs a `beforeunload` handler so the browser shows a confirmation
- * dialog when the user tries to close the tab while a blocker is active.
- *
- * @example
- * const blocker = useBlocker((to, from) => {
- *   return hasUnsavedChanges() && !confirm("Discard changes?")
- * })
- * // later: blocker.remove()
- */
 declare function useBlocker(fn: BlockerFn): Blocker;
 /**
  * Reactive read/write access to the current route's query parameters.

package/lib/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index2.d.ts","names":[],"sources":["../../../src/types.ts","../../../src/components.tsx","../../../src/loader.ts","../../../src/match.ts","../../../src/router.ts"],"mappings":"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"}
+{"version":3,"file":"index2.d.ts","names":[],"sources":["../../../src/types.ts","../../../src/components.tsx","../../../src/loader.ts","../../../src/match.ts","../../../src/router.ts"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/router",
-  "version": "0.12.14",
+  "version": "0.13.0",
   "description": "Official router for Pyreon",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/router#readme",
   "bugs": {
@@ -43,13 +43,14 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@pyreon/core": "^0.12.14",
-    "@pyreon/reactivity": "^0.12.14",
-    "@pyreon/runtime-dom": "^0.12.14"
+    "@pyreon/core": "^0.13.0",
+    "@pyreon/reactivity": "^0.13.0",
+    "@pyreon/runtime-dom": "^0.13.0"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.8.9",
-    "@pyreon/test-utils": "^0.12.10",
+    "@pyreon/manifest": "0.13.0",
+    "@pyreon/test-utils": "^0.13.0",
     "@vitest/browser-playwright": "^4.1.4",
     "happy-dom": "^20.8.3"
   }

package/src/components.tsx

@@ -151,6 +151,7 @@ export const RouterLink: ComponentFn<RouterLinkProps> = (props) => {
     if (!router) return ''
     const current = router.currentRoute().path
     const target = props.to
+    if (typeof target !== 'string') return ''
     const isExact = current === target
     const isActive = isExact || (!props.exact && isSegmentPrefix(current, target))
 

package/src/loader.ts

@@ -35,8 +35,11 @@ export function useLoaderData<T = unknown>(): T {
  */
 export async function prefetchLoaderData(router: RouterInstance, path: string): Promise<void> {
   const route = router._resolve(path)
+  // Use a local AbortController — prefetch is best-effort and must NOT
+  // clobber `router._abortController`, which belongs to the active
+  // navigation. Previously, hovering a link during a navigation replaced
+  // the nav's controller, destroying its abort capability.
   const ac = new AbortController()
-  router._abortController = ac
   await Promise.all(
     route.matched
       .filter((r) => r.loader)

package/src/manifest.ts

@@ -0,0 +1,336 @@
+import { defineManifest } from '@pyreon/manifest'
+
+export default defineManifest({
+  name: '@pyreon/router',
+  title: 'Router',
+  tagline:
+    'hash+history+SSR, context-based, prefetching, guards, loaders, useIsActive, View Transitions, middleware, typed search params',
+  description:
+    'Type-safe client-side router for Pyreon with nested routes, per-route and global navigation guards, data loaders, middleware chain, View Transitions API integration, and typed search params. Context-based (`RouterContext`) with hash and history mode support. Route params are inferred from path strings (`"/user/:id"` yields `{ id: string }`). Named routes enable typed programmatic navigation. SSR-compatible with server-side route resolution. Hash mode uses `history.pushState` (not `window.location.hash`) to avoid double-update. `await router.push()` resolves after the View Transition `updateCallbackDone` (DOM commit), not after animation completion.',
+  category: 'browser',
+  longExample: `import { createRouter, RouterProvider, RouterView, RouterLink, useRouter, useRoute, useIsActive, useTypedSearchParams, useTransition, useLoaderData, useMiddlewareData } from "@pyreon/router"
+import { mount } from "@pyreon/runtime-dom"
+
+// Define routes with typed params, guards, loaders, and middleware
+const router = createRouter({
+  routes: [
+    { path: "/", component: Home, name: "home" },
+    { path: "/user/:id", component: User, name: "user",
+      loader: ({ params }) => fetchUser(params.id),
+      meta: { title: "User Profile" } },
+    { path: "/admin", component: AdminLayout,
+      beforeEnter: (to, from) => isAdmin() || "/login",
+      children: [
+        { path: "users", component: AdminUsers },
+        { path: "settings", component: AdminSettings },
+      ] },
+    { path: "/settings", redirect: "/admin/settings" },
+    { path: "(.*)", component: NotFound },
+  ],
+  middleware: [authMiddleware, loggerMiddleware],
+})
+
+// Mount with RouterProvider
+mount(
+  <RouterProvider router={router}>
+    <nav>
+      <RouterLink to="/" activeClass="nav-active">Home</RouterLink>
+      <RouterLink to={{ name: "user", params: { id: "42" } }}>Profile</RouterLink>
+    </nav>
+    <RouterView />
+  </RouterProvider>,
+  document.getElementById("app")!
+)
+
+// Inside a component — hooks
+const User = () => {
+  const route = useRoute<"/user/:id">()
+  const data = useLoaderData<UserData>()
+  const router = useRouter()
+  const isAdmin = useIsActive("/admin")
+  const { isTransitioning } = useTransition()
+  const params = useTypedSearchParams({ tab: "string", page: "number" })
+
+  return (
+    <div>
+      <h1>{data.name} (ID: {route().params.id})</h1>
+      <Show when={isTransitioning()}>
+        <ProgressBar />
+      </Show>
+      <button onClick={() => router.push("/")}>Go Home</button>
+    </div>
+  )
+}`,
+  features: [
+    'createRouter() — factory with routes, guards, middleware, loaders, hash/history mode',
+    'RouterProvider / RouterView / RouterLink — context-based rendering components',
+    'useRouter / useRoute — programmatic navigation and typed route access',
+    'useIsActive — reactive boolean for path matching (segment-aware prefix)',
+    'useTypedSearchParams — typed search params with auto-coercion',
+    'useTransition — reactive signal for route transition state',
+    'useMiddlewareData — read data set by route middleware chain',
+    'useLoaderData — access route loader results',
+    'View Transitions API — auto-enabled, awaits updateCallbackDone',
+    'Named routes — typed navigation via { name, params }',
+    'Nested routes — recursive matching with child RouterView',
+    'Navigation guards — per-route and global beforeEnter/afterEach hooks',
+  ],
+  api: [
+    {
+      name: 'createRouter',
+      kind: 'function',
+      signature: 'createRouter(options: RouterOptions | RouteRecord[]): Router',
+      summary:
+        'Create a router instance with route records, guards, middleware, and mode configuration. Accepts either an array of route records (shorthand) or a full `RouterOptions` object with `routes`, `mode` (`"history"` | `"hash"`), `scrollBehavior`, `beforeEach`, `afterEach`, and `middleware`. The returned `Router` is generic over route names for typed programmatic navigation.',
+      example: `const router = createRouter([
+  { path: "/", component: Home },
+  { path: "/user/:id", component: User, loader: ({ params }) => fetchUser(params.id) },
+  { path: "/admin", component: Admin, beforeEnter: requireAuth, children: [
+    { path: "settings", component: Settings },
+  ]},
+])`,
+      mistakes: [
+        '`createRouter({ routes: [...], mode: "hash" })` and using `window.location.hash` elsewhere — hash mode uses `history.pushState`, not `location.hash`. Reading `location.hash` directly will not reflect router state',
+        'Defining route paths without leading `/` in root routes — all root-level paths must start with `/`',
+        'Using `redirect: "/target"` with a guard on the same route — redirects bypass guards. Use `beforeEnter` to conditionally redirect instead',
+        'Forgetting the catch-all route — `{ path: "(.*)", component: NotFound }` should be the last route to handle 404s',
+      ],
+      seeAlso: ['RouterProvider', 'useRouter', 'useRoute'],
+    },
+    {
+      name: 'RouterProvider',
+      kind: 'component',
+      signature: '<RouterProvider router={router}>{children}</RouterProvider>',
+      summary:
+        'Provide the router instance to the component tree via `RouterContext`. Must wrap the entire app (or the routed section). Sets up the context stack so `useRouter()`, `useRoute()`, and other hooks can access the router.',
+      example: `const App = () => (
+  <RouterProvider router={router}>
+    <nav><RouterLink to="/">Home</RouterLink></nav>
+    <RouterView />
+  </RouterProvider>
+)`,
+      seeAlso: ['createRouter', 'RouterView', 'RouterLink'],
+    },
+    {
+      name: 'RouterView',
+      kind: 'component',
+      signature: '<RouterView />',
+      summary:
+        'Render the matched route\'s component. For nested routes, the parent route component includes a `<RouterView />` that renders the matched child. Each `<RouterView>` renders one level of the route tree.',
+      example: `// Renders the matched route's component
+<RouterView />
+
+// Nested routes: parent component includes <RouterView /> for children
+const Admin = () => (
+  <div>
+    <h1>Admin</h1>
+    <RouterView />  {/* renders Settings, Users, etc. */}
+  </div>
+)`,
+      seeAlso: ['RouterProvider', 'createRouter'],
+    },
+    {
+      name: 'RouterLink',
+      kind: 'component',
+      signature: '<RouterLink to={path} activeClass={cls} exactActiveClass={cls}>{children}</RouterLink>',
+      summary:
+        'Declarative navigation link that renders an `<a>` element. Supports string paths or named route objects (`{ name, params }`). Applies `activeClass` when the current route matches the link path (prefix), and `exactActiveClass` for exact matches. Click handler calls `router.push()` and prevents default.',
+      example: `<RouterLink to="/" activeClass="nav-active">Home</RouterLink>
+<RouterLink to={{ name: "user", params: { id: "42" } }}>Profile</RouterLink>`,
+      mistakes: [
+        '`<a href="/about" onClick={() => router.push("/about")}>` — use `<RouterLink to="/about">` instead; it handles the anchor element, active class, and click interception',
+        '`<RouterLink to="/about" target="_blank">` — external navigation bypasses the router; use a plain `<a>` for external links',
+        '`<RouterLink to={dynamicPath}>` without calling the signal — must call: `<RouterLink to={dynamicPath()}>` (or let the compiler handle it via `_rp()`)',
+      ],
+      seeAlso: ['useRouter', 'useIsActive'],
+    },
+    {
+      name: 'useRouter',
+      kind: 'hook',
+      signature: 'useRouter(): Router',
+      summary:
+        'Access the router instance for programmatic navigation. Returns the `Router` object with `push()`, `replace()`, `back()`, `forward()`, `go()`. `await router.push()` resolves after the View Transition `updateCallbackDone` (DOM commit is complete, new route state is live), NOT after the animation finishes.',
+      example: `const router = useRouter()
+
+router.push("/settings")
+router.push({ name: "user", params: { id: "42" } })
+router.replace("/login")
+router.back()
+router.forward()
+router.go(-2)`,
+      mistakes: [
+        '`router.push("/path")` at the top level of a component body — this is synchronous imperative navigation during render, causing an infinite loop. Wrap in `onMount`, event handler, or `effect`',
+        '`await router.push("/path")` expecting animation completion — `push` resolves after DOM commit (`updateCallbackDone`), not after View Transition animation finishes. Use the returned transition object\'s `.finished` if you need to wait for animation',
+        'Calling `useRouter()` outside a `<RouterProvider>` — throws because no router context exists',
+      ],
+      seeAlso: ['useRoute', 'RouterLink', 'createRouter'],
+    },
+    {
+      name: 'useRoute',
+      kind: 'hook',
+      signature: 'useRoute<TPath extends string>(): () => ResolvedRoute<ExtractParams<TPath>>',
+      summary:
+        'Access the current resolved route as a reactive accessor. Generic over the path string for typed params — `useRoute<"/user/:id">()` yields `route().params.id: string`. Returns a function (accessor) that must be called to read the current route — reads inside reactive scopes track route changes.',
+      example: `// Type-safe params:
+const route = useRoute<"/user/:id">()
+const userId = route().params.id  // string
+
+// Access query, meta, etc:
+route().query
+route().meta`,
+      seeAlso: ['useRouter', 'useSearchParams', 'useLoaderData'],
+    },
+    {
+      name: 'useIsActive',
+      kind: 'hook',
+      signature: 'useIsActive(path: string, exact?: boolean): () => boolean',
+      summary:
+        'Returns a reactive boolean for whether a path matches the current route. Segment-aware prefix matching: `/admin` matches `/admin/users` but NOT `/admin-panel`. Pass `exact=true` for exact-only matching. Updates reactively when the route changes.',
+      example: `const isHome = useIsActive("/")
+const isAdmin = useIsActive("/admin")          // prefix match
+const isExactAdmin = useIsActive("/admin", true)  // exact only
+
+// Reactive — updates when route changes:
+<a class={{ active: isAdmin() }} href="/admin">Admin</a>`,
+      mistakes: [
+        '`useIsActive("/admin")` matching `/admin-panel` — this does NOT happen. Matching is segment-aware: `/admin` only matches paths starting with `/admin/` or exactly `/admin`',
+        '`if (useIsActive("/settings")())` at component top level — the outer call returns an accessor; make sure to read it inside a reactive scope for updates',
+        'Using `useIsActive` for complex route matching — it only does path prefix/exact matching. For query-param-aware or meta-aware checks, use `useRoute()` directly',
+      ],
+      seeAlso: ['useRoute', 'RouterLink'],
+    },
+    {
+      name: 'useTypedSearchParams',
+      kind: 'hook',
+      signature: 'useTypedSearchParams<T>(schema: T): TypedSearchParams<T>',
+      summary:
+        'Type-safe search params with auto-coercion from URL strings. Schema keys define parameter names, values define types (`"string"`, `"number"`, `"boolean"`). Returns an object where each key is a reactive accessor and `.set()` updates the URL.',
+      example: `const params = useTypedSearchParams({ page: "number", q: "string", active: "boolean" })
+params.page()    // number (auto-coerced)
+params.q()       // string
+params.set({ page: 2 })  // updates URL`,
+      seeAlso: ['useSearchParams', 'useRoute'],
+    },
+    {
+      name: 'useTransition',
+      kind: 'hook',
+      signature: 'useTransition(): { isTransitioning: () => boolean }',
+      summary:
+        'Reactive signal for route transition state. `isTransitioning()` is true during navigation (while guards run + loaders resolve), false when the new route is mounted. Useful for progress bars and global loading indicators.',
+      example: `const { isTransitioning } = useTransition()
+
+<Show when={isTransitioning()}>
+  <ProgressBar />
+</Show>`,
+      seeAlso: ['useRouter', 'useRoute'],
+    },
+    {
+      name: 'useMiddlewareData',
+      kind: 'hook',
+      signature: 'useMiddlewareData<T>(): T',
+      summary:
+        'Read data set by `RouteMiddleware` in the middleware chain. Middleware functions receive `ctx` with a mutable `ctx.data` object — properties set there are available to all downstream components via this hook.',
+      example: `// Middleware:
+const authMiddleware: RouteMiddleware = async (ctx) => {
+  ctx.data.user = await getUser(ctx.to)
+}
+
+// Component:
+const data = useMiddlewareData<{ user: User }>()
+// data.user is available`,
+      seeAlso: ['createRouter', 'useLoaderData'],
+    },
+    {
+      name: 'useLoaderData',
+      kind: 'hook',
+      signature: 'useLoaderData<T>(): T',
+      summary:
+        'Access the data returned by the current route\'s `loader` function. The loader runs before the route component mounts; its return value is cached and available synchronously via this hook. Generic over the loader return type.',
+      example: `// Route: { path: "/user/:id", component: User, loader: ({ params }) => fetchUser(params.id) }
+
+const User = () => {
+  const data = useLoaderData<UserData>()
+  return <div>{data.name}</div>
+}`,
+      seeAlso: ['useMiddlewareData', 'useRoute'],
+    },
+    {
+      name: 'useSearchParams',
+      kind: 'hook',
+      signature:
+        'useSearchParams<T>(defaults?: T): [get: () => T, set: (updates: Partial<T>) => Promise<void>]',
+      summary:
+        'Access and update URL search params as a reactive tuple. Returns `[get, set]` where `get()` reads the current params and `set()` updates them via `replaceState`. For typed params with auto-coercion, prefer `useTypedSearchParams`.',
+      example: `const [search, setSearch] = useSearchParams({ page: "1", sort: "name" })
+
+// Read:
+search().page  // "1"
+
+// Write:
+setSearch({ page: "2" })`,
+      seeAlso: ['useTypedSearchParams', 'useRoute'],
+    },
+    {
+      name: 'useBlocker',
+      kind: 'hook',
+      signature: 'useBlocker(shouldBlock: () => boolean): Blocker',
+      summary:
+        'Block navigation when a condition is true (e.g., unsaved form changes). Returns a `Blocker` object with `proceed()` and `reset()` methods. Also hooks into the browser\'s `beforeunload` event to warn on tab close. Uses a shared ref-counted listener for `beforeunload` — N blockers share one event handler.',
+      example: `const blocker = useBlocker(() => form.isDirty())
+
+<Show when={blocker.isBlocked()}>
+  <Dialog>
+    <p>Unsaved changes. Leave anyway?</p>
+    <button onClick={blocker.proceed}>Leave</button>
+    <button onClick={blocker.reset}>Stay</button>
+  </Dialog>
+</Show>`,
+      seeAlso: ['useRouter'],
+    },
+    {
+      name: 'onBeforeRouteLeave',
+      kind: 'function',
+      signature: 'onBeforeRouteLeave(guard: NavigationGuard): void',
+      summary:
+        'Register a per-component navigation guard that fires when leaving the current route. Return `false` to cancel, a string path to redirect, or `undefined` to allow. Must be called during component setup.',
+      example: `onBeforeRouteLeave((to, from) => {
+  if (hasUnsavedChanges()) return false  // cancel navigation
+})`,
+      seeAlso: ['onBeforeRouteUpdate', 'useBlocker'],
+    },
+    {
+      name: 'onBeforeRouteUpdate',
+      kind: 'function',
+      signature: 'onBeforeRouteUpdate(guard: NavigationGuard): void',
+      summary:
+        'Register a per-component navigation guard that fires when the route updates but the same component stays mounted (e.g., param change `/user/1` to `/user/2`). Same return semantics as `onBeforeRouteLeave`.',
+      example: `onBeforeRouteUpdate((to, from) => {
+  if (to.params.id === from.params.id) return  // no change
+  // reload data for new ID...
+})`,
+      seeAlso: ['onBeforeRouteLeave', 'useRoute'],
+    },
+  ],
+  gotchas: [
+    {
+      label: 'View Transitions — what push() awaits',
+      note: '`await router.push()` resolves after `updateCallbackDone` (DOM commit), NOT after animation finishes. It does NOT wait for `.finished` (~200-300ms). `.ready` and `.finished` get empty `.catch()` handlers so `AbortError: Transition was skipped` rejections (from interrupted transitions) do not leak as unhandled promise rejections.',
+    },
+    {
+      label: 'Hash mode uses pushState',
+      note: 'Hash mode uses `history.pushState` — NOT `window.location.hash` assignment — to avoid double-update from the hashchange event. Reading `location.hash` directly will not reflect router state; use `useRoute()` instead.',
+    },
+    {
+      label: 'Imperative navigation in render body',
+      note: '`router.push()` or `navigate()` called synchronously in the component function body causes an infinite render loop. Wrap in `onMount`, event handlers, `effect`, or any deferred execution context. The `pyreon/no-imperative-navigate-in-render` lint rule catches this.',
+    },
+    {
+      label: 'Hook ordering with View Transitions',
+      note: '`afterEach` hooks and scroll restoration fire AFTER the View Transition callback completes — not before. This means hooks see the NEW route state, which is the correct per-spec behavior but a subtle change from pre-VT versions.',
+    },
+    {
+      label: 'For uses by, not key',
+      note: '`<For>` in route lists uses `by` not `key`. `<For each={routes()} key={r => r.path}>` silently passes the key to VNode reconciliation instead of the list reconciler. Use `by={r => r.path}`.',
+    },
+  ],
+})

package/src/router.ts

@@ -144,6 +144,31 @@ export function onBeforeRouteUpdate(guard: NavigationGuard): () => void {
  * })
  * // later: blocker.remove()
  */
+// Shared beforeunload handler — single listener for all active blockers.
+// Attached when the first blocker registers, detached when the last one is
+// removed. Avoids listener accumulation from multiple useBlocker() calls.
+let _beforeUnloadRefCount = 0
+const _beforeUnloadHandler = (e: BeforeUnloadEvent) => {
+  e.preventDefault()
+}
+
+function retainBeforeUnload(): void {
+  if (!_isBrowser) return
+  if (_beforeUnloadRefCount === 0) {
+    window.addEventListener('beforeunload', _beforeUnloadHandler)
+  }
+  _beforeUnloadRefCount++
+}
+
+function releaseBeforeUnload(): void {
+  if (!_isBrowser) return
+  _beforeUnloadRefCount--
+  if (_beforeUnloadRefCount <= 0) {
+    _beforeUnloadRefCount = 0
+    window.removeEventListener('beforeunload', _beforeUnloadHandler)
+  }
+}
+
 export function useBlocker(fn: BlockerFn): Blocker {
   const router = (useContext(RouterContext) ?? _activeRouter) as RouterInstance | null
   if (!router)
@@ -151,22 +176,11 @@ export function useBlocker(fn: BlockerFn): Blocker {
       '[Pyreon] No router installed. Wrap your app in <RouterProvider router={router}>.',
     )
   router._blockers.add(fn)
-
-  // Warn before tab/window close while this blocker is registered
-  const beforeUnloadHandler = _isBrowser
-    ? (e: BeforeUnloadEvent) => {
-        e.preventDefault()
-      }
-    : null
-  if (beforeUnloadHandler) {
-    window.addEventListener('beforeunload', beforeUnloadHandler)
-  }
+  retainBeforeUnload()
 
   const remove = () => {
     router._blockers.delete(fn)
-    if (beforeUnloadHandler) {
-      window.removeEventListener('beforeunload', beforeUnloadHandler)
-    }
+    releaseBeforeUnload()
   }
 
   // Auto-remove when the component that called useBlocker unmounts
@@ -924,9 +938,12 @@ export function createRouter(options: RouterOptions | RouteRecord[]): Router {
       )
       // Run loaders for the matched path — uses the same code path SSR
       // already relied on, so loader data ends up in `_loaderData` under the
-      // matched route records.
+      // matched route records. Uses a LOCAL AbortController: `preload` is
+      // a prefetch operation and must NOT clobber `router._abortController`,
+      // which belongs to the active navigation. Without this, calling
+      // `router.preload(...)` during a navigation destroyed the nav's
+      // abort capability.
       const ac = new AbortController()
-      router._abortController = ac
       await Promise.all(
         resolved.matched
           .filter((r) => r.loader)
@@ -946,11 +963,15 @@ export function createRouter(options: RouterOptions | RouteRecord[]): Router {
       if (_hashchangeHandler) window.removeEventListener('hashchange', _hashchangeHandler)
       guards.length = 0
       afterHooks.length = 0
+      // Release beforeunload for any remaining blockers
+      for (let i = router._blockers.size; i > 0; i--) releaseBeforeUnload()
       router._blockers.clear()
       componentCache.clear()
       router._loaderData.clear()
       router._abortController?.abort()
       router._abortController = null
+      // Clear global ref so stale router doesn't survive in SSR or re-creation
+      if (_activeRouter === router) _activeRouter = null
     },
 
     _resolve: (rawPath: string) => resolveRoute(rawPath, routes),

package/src/scroll.ts

@@ -6,6 +6,12 @@ import type { ResolvedRoute, RouterOptions } from './types'
  * Saves scroll position before each navigation and restores it when
  * navigating back to a previously visited path.
  */
+// LRU cap — in SPAs with unbounded URL space (`/user/:id`, query-string
+// variations, etc.) the `_positions` Map would grow per unique path
+// forever. 100 entries covers typical back-navigation depth; beyond that,
+// scroll restoration is a nice-to-have not a correctness requirement.
+const MAX_SCROLL_POSITIONS = 100
+
 export class ScrollManager {
   private readonly _positions = new Map<string, number>()
   private readonly _behavior: RouterOptions['scrollBehavior']
@@ -21,7 +27,14 @@ export class ScrollManager {
     // callsite (the `no-window-in-ssr` lint rule can't AST-trace indirect
     // calls from router setup).
     if (typeof window === 'undefined') return
+    // LRU: re-insert moves the entry to newest. Evict oldest when over cap.
+    if (this._positions.has(fromPath)) this._positions.delete(fromPath)
     this._positions.set(fromPath, window.scrollY)
+    while (this._positions.size > MAX_SCROLL_POSITIONS) {
+      const oldest = this._positions.keys().next().value
+      if (oldest === undefined) break
+      this._positions.delete(oldest)
+    }
   }
 
   /** Call after navigation is committed — applies scroll behavior */

package/src/tests/loader.test.ts

@@ -78,6 +78,24 @@ describe('loader data serialization — edge cases', () => {
     expect(values[0]).toEqual(complexData)
   })
 
+  test('prefetchLoaderData does NOT clobber router._abortController', async () => {
+    // Regression: `prefetchLoaderData` used to overwrite
+    // `router._abortController` with its own fresh controller. Hovering
+    // a <Link> during an in-flight navigation destroyed the nav's
+    // abort capability — subsequent navigations couldn't cancel the
+    // first one. Fix: prefetch uses a LOCAL controller.
+    const routes: RouteRecord[] = [
+      { path: '/data', component: Home, loader: async () => 'ok' },
+    ]
+    const router = createRouter({ routes, url: '/' }) as RouterInstance
+    const navController = new AbortController()
+    router._abortController = navController
+    await prefetchLoaderData(router, '/data')
+    // Prefetch finished; nav's controller must be untouched.
+    expect(router._abortController).toBe(navController)
+    expect(navController.signal.aborted).toBe(false)
+  })
+
   test('prefetchLoaderData passes AbortSignal to loaders', async () => {
     let receivedSignal: AbortSignal | undefined
     const routes: RouteRecord[] = [