diff --git a/docs/guide/pages-routing/overview.md b/docs/guide/pages-routing/overview.md
index 08ad304eb..004b9a3ef 100644
--- a/docs/guide/pages-routing/overview.md
+++ b/docs/guide/pages-routing/overview.md
@@ -265,6 +265,65 @@ export default function PostPage() {
 }
 ```
 
+### Active links
+
+`Link` marks the link to the current page with `aria-current="page"` and `data-void-active`. Use them to style navigation:
+
+```css
+nav a[data-void-active] {
+  font-weight: 600;
+}
+```
+
+A link is active only on its own path by default. Set `activeMatch="prefix"` to keep it active on nested pages:
+
+::: code-group
+
+```tsx [React]
+<nav>
+  <Link href="/">Home</Link>
+  <Link href="/users" activeMatch="prefix">
+    Users
+  </Link>
+</nav>
+```
+
+```vue [Vue]
+<nav>
+  <Link href="/">Home</Link>
+  <Link href="/users" active-match="prefix">Users</Link>
+</nav>
+```
+
+```svelte [Svelte]
+<nav>
+  <Link href="/">Home</Link>
+  <Link href="/users" activeMatch="prefix">Users</Link>
+</nav>
+```
+
+```tsx [Solid]
+<nav>
+  <Link href="/">Home</Link>
+  <Link href="/users" activeMatch="prefix">
+    Users
+  </Link>
+</nav>
+```
+
+:::
+
+| Current URL     | `href="/users"` | `href="/users" activeMatch="prefix"` |
+| --------------- | --------------- | ------------------------------------ |
+| `/users`        | both attributes | both attributes                      |
+| `/users?page=2` | both attributes | both attributes                      |
+| `/users/42`     | none            | `data-void-active`                   |
+| `/users-admin`  | none            | none                                 |
+
+`aria-current="page"` marks only the exact page, so select `[aria-current="page"]` to style it differently from its section. A link to `/` is active only on the home page.
+
+Paths match the way pages are routed: letter case and trailing slashes count, while the query string and hash are ignored. Links to other origins and non-GET links are never active. An `aria-current` or `data-void-active` you pass to `Link` replaces the computed value.
+
 ## Scroll Restoration
 
 Void manages scroll position for Pages automatically:
diff --git a/docs/reference/api/pages.md b/docs/reference/api/pages.md
index b577e75ee..dd10cd0fd 100644
--- a/docs/reference/api/pages.md
+++ b/docs/reference/api/pages.md
@@ -53,16 +53,16 @@ interface VoidVueOptions {
 
 Imported from `"@void/vue"`.
 
-| Export                             | Description                                                                                                                                                                                                                                       |
-| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Link`                             | Vue component for SPA navigation. Renders `<a>` for GET, `<button>` for non-GET methods. Props: `href`, `method`, `data`, `prefetch`, `cacheFor`, `preserveScroll`, `preserveState`, `replace`, `reloadDocument`, `viewTransition`, `onNavigate`. |
-| `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`.                                                                        |
-| `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                               |
-| `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                             |
-| `useForm(url, defaults, options?)` | Typed reactive form helper bound to a page action URL. Returns `{ data, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, setError, clearErrors, clearError }`.                             |
-| `useIslandForm(defaults)`          | Form helper for island components. Same form state as `useForm()`, plus `submit(url, method)`. `post(url)`, `put(url)`, `patch(url)`, and `delete(url)` take the action URL and submit with `fetch()`.                                            |
-| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                         |
-| `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                          |
+| Export                             | Description                                                                                                                                                                                                                                                                                                                                                                                                              |
+| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `Link`                             | Vue component for SPA navigation. Renders `<a>` for GET, `<button>` for non-GET methods. Props: `href`, `method`, `data`, `prefetch`, `cacheFor`, `preserveScroll`, `preserveState`, `replace`, `reloadDocument`, `viewTransition`, `activeMatch`, `onNavigate`. Adds `aria-current="page"` and `data-void-active` to the link to the current page ([active links](../../guide/pages-routing/overview.md#active-links)). |
+| `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`.                                                                                                                                                                                                                                               |
+| `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                                                                                                                                                                                                      |
+| `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                                                                                                                                                                                                    |
+| `useForm(url, defaults, options?)` | Typed reactive form helper bound to a page action URL. Returns `{ data, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, setError, clearErrors, clearError }`.                                                                                                                                                                                                    |
+| `useIslandForm(defaults)`          | Form helper for island components. Same form state as `useForm()`, plus `submit(url, method)`. `post(url)`, `put(url)`, `patch(url)`, and `delete(url)` take the action URL and submit with `fetch()`.                                                                                                                                                                                                                   |
+| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                                                                                                                                                                                                |
+| `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                                                                                                                                                                                                 |
 
 Vue `Link` GET `data` is merged into the rendered `href` query string. Primitive values are serialized with `String(value)`, arrays become repeated keys, `null` and `undefined` are omitted, and nested objects throw. `prefetch` and `reloadDocument` are GET-only and throw for mutation links.
 
@@ -105,17 +105,17 @@ interface VoidReactOptions {
 
 Imported from `"@void/react"`.
 
-| Export                             | Description                                                                                                                                                                                                                                         |
-| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Link`                             | React component for SPA navigation. Renders `<a>` for GET, `<button>` for non-GET methods. Props: `href`, `method`, `data`, `prefetch`, `cacheFor`, `preserveScroll`, `preserveState`, `replace`, `reloadDocument`, `viewTransition`, `onNavigate`. |
-| `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`. React navigations are scheduled as transitions.                          |
-| `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                                 |
-| `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                               |
-| `useForm(url, defaults, options?)` | Form helper hook. Returns `{ data, setData, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, setError, clearErrors, clearError }`.                                                           |
-| `useIslandForm(defaults)`          | Form helper hook for island components. Same form state as `useForm()`. `post(url)`, `put(url)`, `patch(url)`, and `delete(url)` take the action URL and submit with `fetch()`.                                                                     |
-| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                           |
-| `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                            |
-| `Deferred<T>`                      | React-only prop type for `defer()` results. It is `Promise<T>` and is consumed with React `use()`.                                                                                                                                                  |
+| Export                             | Description                                                                                                                                                                                                                                                                                                                                                                                                                |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Link`                             | React component for SPA navigation. Renders `<a>` for GET, `<button>` for non-GET methods. Props: `href`, `method`, `data`, `prefetch`, `cacheFor`, `preserveScroll`, `preserveState`, `replace`, `reloadDocument`, `viewTransition`, `activeMatch`, `onNavigate`. Adds `aria-current="page"` and `data-void-active` to the link to the current page ([active links](../../guide/pages-routing/overview.md#active-links)). |
+| `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`. React navigations are scheduled as transitions.                                                                                                                                                                                                 |
+| `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                                                                                                                                                                                                        |
+| `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                                                                                                                                                                                                      |
+| `useForm(url, defaults, options?)` | Form helper hook. Returns `{ data, setData, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, setError, clearErrors, clearError }`.                                                                                                                                                                                                                                  |
+| `useIslandForm(defaults)`          | Form helper hook for island components. Same form state as `useForm()`. `post(url)`, `put(url)`, `patch(url)`, and `delete(url)` take the action URL and submit with `fetch()`.                                                                                                                                                                                                                                            |
+| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                                                                                                                                                                                                  |
+| `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                                                                                                                                                                                                   |
+| `Deferred<T>`                      | React-only prop type for `defer()` results. It is `Promise<T>` and is consumed with React `use()`.                                                                                                                                                                                                                                                                                                                         |
 
 React `Link` GET `data` is merged into the rendered `href` query string. Primitive values are serialized with `String(value)`, arrays become repeated keys, `null` and `undefined` are omitted, and nested objects throw. `prefetch` and `reloadDocument` are GET-only and throw for mutation links.
 
@@ -184,16 +184,16 @@ interface VoidSvelteOptions {
 
 Imported from `"@void/svelte"`.
 
-| Export                             | Description                                                                                                                                                                                                                                          |
-| ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Link`                             | Svelte component for SPA navigation. Renders `<a>` for GET, `<button>` for non-GET methods. Props: `href`, `method`, `data`, `prefetch`, `cacheFor`, `preserveScroll`, `preserveState`, `replace`, `reloadDocument`, `viewTransition`, `onNavigate`. |
-| `useForm(url, defaults, options?)` | Form helper using Svelte 5 runes. Returns `{ data, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, setError, clearErrors, clearError }`.                                                     |
-| `useIslandForm(defaults)`          | Form helper for island components. Same form state as `useForm()`, plus `submit(url, method)`. `post(url)`, `put(url)`, `patch(url)`, and `delete(url)` take the action URL and submit with `fetch()`.                                               |
-| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                            |
-| `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                             |
-| `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`.                                                                           |
-| `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                                  |
-| `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                                |
+| Export                             | Description                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Link`                             | Svelte component for SPA navigation. Renders `<a>` for GET, `<button>` for non-GET methods. Props: `href`, `method`, `data`, `prefetch`, `cacheFor`, `preserveScroll`, `preserveState`, `replace`, `reloadDocument`, `viewTransition`, `activeMatch`, `onNavigate`. Adds `aria-current="page"` and `data-void-active` to the link to the current page ([active links](../../guide/pages-routing/overview.md#active-links)). |
+| `useForm(url, defaults, options?)` | Form helper using Svelte 5 runes. Returns `{ data, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, setError, clearErrors, clearError }`.                                                                                                                                                                                                                            |
+| `useIslandForm(defaults)`          | Form helper for island components. Same form state as `useForm()`, plus `submit(url, method)`. `post(url)`, `put(url)`, `patch(url)`, and `delete(url)` take the action URL and submit with `fetch()`.                                                                                                                                                                                                                      |
+| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                                                                                                                                                                                                   |
+| `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                                                                                                                                                                                                    |
+| `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`.                                                                                                                                                                                                                                                  |
+| `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                                                                                                                                                                                                         |
+| `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                                                                                                                                                                                                       |
 
 Svelte `Link` GET `data` is merged into the rendered `href` query string. Primitive values are serialized with `String(value)`, arrays become repeated keys, `null` and `undefined` are omitted, and nested objects throw. `prefetch` and `reloadDocument` are GET-only and throw for mutation links.
 
@@ -234,16 +234,16 @@ interface VoidSolidOptions {
 
 Imported from `"@void/solid"`.
 
-| Export                             | Description                                                                                                                                                                                                                                         |
-| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Link`                             | Solid component for SPA navigation. Renders `<a>` for GET, `<button>` for non-GET methods. Props: `href`, `method`, `data`, `prefetch`, `cacheFor`, `preserveScroll`, `preserveState`, `replace`, `reloadDocument`, `viewTransition`, `onNavigate`. |
-| `useForm(url, defaults, options?)` | Form helper using Solid stores. Returns `{ data, setData, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, setError, clearErrors, clearError }`.                                             |
-| `useIslandForm(defaults)`          | Form helper for island components. Same form state as `useForm()`. `post(url)`, `put(url)`, `patch(url)`, and `delete(url)` take the action URL and submit with `fetch()`.                                                                          |
-| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                           |
-| `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                            |
-| `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`.                                                                          |
-| `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                                 |
-| `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                               |
+| Export                             | Description                                                                                                                                                                                                                                                                                                                                                                                                                |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Link`                             | Solid component for SPA navigation. Renders `<a>` for GET, `<button>` for non-GET methods. Props: `href`, `method`, `data`, `prefetch`, `cacheFor`, `preserveScroll`, `preserveState`, `replace`, `reloadDocument`, `viewTransition`, `activeMatch`, `onNavigate`. Adds `aria-current="page"` and `data-void-active` to the link to the current page ([active links](../../guide/pages-routing/overview.md#active-links)). |
+| `useForm(url, defaults, options?)` | Form helper using Solid stores. Returns `{ data, setData, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, setError, clearErrors, clearError }`.                                                                                                                                                                                                                    |
+| `useIslandForm(defaults)`          | Form helper for island components. Same form state as `useForm()`. `post(url)`, `put(url)`, `patch(url)`, and `delete(url)` take the action URL and submit with `fetch()`.                                                                                                                                                                                                                                                 |
+| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                                                                                                                                                                                                  |
+| `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                                                                                                                                                                                                   |
+| `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`.                                                                                                                                                                                                                                                 |
+| `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                                                                                                                                                                                                        |
+| `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                                                                                                                                                                                                      |
 
 Solid `Link` GET `data` is merged into the rendered `href` query string. Primitive values are serialized with `String(value)`, arrays become repeated keys, `null` and `undefined` are omitted, and nested objects throw. `prefetch` and `reloadDocument` are GET-only and throw for mutation links.
 
diff --git a/packages/react/src/plugin-pages.ts b/packages/react/src/plugin-pages.ts
index ca184ab04..4a8105cdd 100644
--- a/packages/react/src/plugin-pages.ts
+++ b/packages/react/src/plugin-pages.ts
@@ -170,12 +170,13 @@ ${generateComponentManifest(scan, pagesDir)}
 
 	const PREAMBLE_SCRIPT = ${JSON.stringify(preambleScript)};
 	
-	export async function renderPage(pageObj, assetTags) {
+	export async function renderPage(pageObj, assetTags, requestUrl) {
 	  return renderReactPage({
 	    pageObj,
 	    assetTags,
 	    components,
 	    layoutTree,
+	    requestUrl,
 	    preambleScript: PREAMBLE_SCRIPT,
 	  });
 }
diff --git a/packages/react/src/runtime/link.tsx b/packages/react/src/runtime/link.tsx
index 0e583d2c1..3c73e02bb 100644
--- a/packages/react/src/runtime/link.tsx
+++ b/packages/react/src/runtime/link.tsx
@@ -10,6 +10,7 @@ import type {
 } from 'react';
 import {
   handleLinkClick,
+  linkActiveAttributes,
   linkPrefetchStrategies,
   observeLinkVisible,
   prefetchLink,
@@ -33,6 +34,7 @@ export function Link({
   viewTransition,
   prefetch = false,
   cacheFor,
+  activeMatch,
   onNavigate,
   children,
   style,
@@ -55,6 +57,11 @@ export function Link({
     () => linkPrefetchStrategies({ prefetch, reloadDocument }),
     [prefetch, reloadDocument],
   );
+  // The router context changes with the route URL, so this follows navigations.
+  const activeAttributes = useMemo(
+    () => linkActiveAttributes(router, link, activeMatch),
+    [activeMatch, link, router],
+  );
   const hoverDelay = router?._hoverDelay ?? 75;
 
   const doPrefetch = useCallback(
@@ -227,6 +234,7 @@ export function Link({
         ref={elementRef as RefObject<HTMLAnchorElement>}
         href={link.href}
         style={resolvedStyle}
+        {...activeAttributes}
         {...rest}
         {...eventHandlers}
       >
diff --git a/packages/react/src/runtime/pages-server.ts b/packages/react/src/runtime/pages-server.ts
index c4392040b..933287f6b 100644
--- a/packages/react/src/runtime/pages-server.ts
+++ b/packages/react/src/runtime/pages-server.ts
@@ -22,6 +22,7 @@ export type ReactPagesServerConfig = Readonly<{
   assetTags: { css: string; preloads: string; body: string };
   components: Record<string, () => Promise<ComponentModule>>;
   layoutTree: Record<string, Array<string>>;
+  requestUrl?: string;
   preambleScript?: string;
 }>;
 
@@ -55,6 +56,7 @@ export async function renderReactPage({
   assetTags,
   components,
   layoutTree,
+  requestUrl,
   preambleScript = '',
 }: ReactPagesServerConfig): Promise<ReadableStream<Uint8Array>> {
   const PageComponent = (await components[pageObj.component]()).default;
@@ -71,7 +73,7 @@ export async function renderReactPage({
 
   element = React.createElement(
     RouterContext.Provider,
-    { value: createSsrRouter(pageObj.url || '/', pageObj.params ?? {}) },
+    { value: createSsrRouter(pageObj.url || '/', pageObj.params ?? {}, requestUrl) },
     React.createElement(
       NavigationContext.Provider,
       { value: idleNavigationState() },
diff --git a/packages/react/test/unit/link.test.ts b/packages/react/test/unit/link.test.ts
index dfb864f5e..a3b71c65b 100644
--- a/packages/react/test/unit/link.test.ts
+++ b/packages/react/test/unit/link.test.ts
@@ -1,9 +1,40 @@
 import { createElement } from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
 import { describe, expect, it } from 'vite-plus/test';
-import { Link } from '../../src/runtime/link.tsx';
+import { createSsrRouter } from 'void/pages-client';
+import { RouterContext } from '../../src/runtime/context.ts';
+import { Link, type LinkProps } from '../../src/runtime/link.tsx';
+
+function renderAt(url: string | null, props: LinkProps): string {
+  return renderToStaticMarkup(
+    createElement(
+      RouterContext.Provider,
+      { value: url === null ? null : createSsrRouter(url) },
+      createElement(Link, props, 'Users'),
+    ),
+  );
+}
 
 describe('Link', () => {
+  it('marks the link to the current page', () => {
+    const current = renderAt('/users', { href: '/users' });
+    expect(current).toContain('aria-current="page"');
+    expect(current).toContain('data-void-active=""');
+
+    const nested = renderAt('/users/1', { href: '/users', activeMatch: 'prefix' });
+    expect(nested).not.toContain('aria-current');
+    expect(nested).toContain('data-void-active=""');
+
+    expect(renderAt('/users/1', { href: '/users' })).not.toContain('data-void-active');
+    expect(renderAt(null, { href: '/users' })).not.toContain('data-void-active');
+  });
+
+  it('lets passed attributes override the active state', () => {
+    const markup = renderAt('/checkout', { href: '/checkout', 'aria-current': 'step' });
+    expect(markup).toContain('aria-current="step"');
+    expect(markup).toContain('data-void-active=""');
+  });
+
   it('preserves dot-segment relative hrefs when merging GET data', () => {
     const markup = renderToStaticMarkup(
       createElement(
diff --git a/packages/solid/src/plugin-pages.ts b/packages/solid/src/plugin-pages.ts
index 8b423ea8e..550dd318b 100644
--- a/packages/solid/src/plugin-pages.ts
+++ b/packages/solid/src/plugin-pages.ts
@@ -66,7 +66,7 @@ import { serializePageData } from "void/pages-server";
 
 ${generateComponentManifest(scan, pagesDir)}
 
-export async function renderPage(pageObj, assetTags) {
+export async function renderPage(pageObj, assetTags, requestUrl) {
   const PageComponent = (await components[pageObj.component]()).default;
   const layoutIds = layoutTree[pageObj.component] || [];
   const layoutComponents = await Promise.all(
@@ -81,7 +81,7 @@ export async function renderPage(pageObj, assetTags) {
           value: pageObj.errors || {},
           get children() {
             return createComponent(RouterContext.Provider, {
-              value: createSsrRouter(pageObj.url || "/", pageObj.params || {}),
+              value: createSsrRouter(pageObj.url || "/", pageObj.params || {}, requestUrl),
               get children() {
                 return createComponent(NavigationContext.Provider, {
                   value: () => idleNavigationState(),
diff --git a/packages/solid/src/runtime/link.tsx b/packages/solid/src/runtime/link.tsx
index 3cc53f507..e71b7b5d5 100644
--- a/packages/solid/src/runtime/link.tsx
+++ b/packages/solid/src/runtime/link.tsx
@@ -2,6 +2,7 @@ import { createMemo, onCleanup, onMount, splitProps, useContext } from 'solid-js
 import type { JSX } from 'solid-js';
 import {
   handleLinkClick,
+  linkActiveAttributes,
   linkPrefetchStrategies,
   observeLinkVisible,
   prefetchLink,
@@ -51,6 +52,7 @@ export function Link(props: LinkProps): JSX.Element {
     'viewTransition',
     'prefetch',
     'cacheFor',
+    'activeMatch',
     'onNavigate',
     'children',
     'style',
@@ -66,6 +68,10 @@ export function Link(props: LinkProps): JSX.Element {
   const link = createMemo(() => resolveLink(local));
   const strategies = createMemo(() => linkPrefetchStrategies(local));
   const resolvedStyle = createMemo(() => mergeStyle(local.style));
+  // Reading router.url tracks the route URL, so this follows navigations.
+  const activeAttributes = createMemo(() =>
+    linkActiveAttributes(router, link(), local.activeMatch),
+  );
 
   function doPrefetch() {
     prefetchLink(router, link().href, local.cacheFor);
@@ -169,6 +175,7 @@ export function Link(props: LinkProps): JSX.Element {
             el = r;
           }}
           href={link().href}
+          {...activeAttributes()}
           {...rest}
           style={resolvedStyle()}
           {...eventHandlers()}
diff --git a/packages/svelte/src/plugin-pages.ts b/packages/svelte/src/plugin-pages.ts
index 5a7c9fd27..63bf382dd 100644
--- a/packages/svelte/src/plugin-pages.ts
+++ b/packages/svelte/src/plugin-pages.ts
@@ -97,7 +97,7 @@ import { serializePageData } from "void/pages-server";
 
 ${generateComponentManifest(scan, pagesDir)}
 
-export async function renderPage(pageObj, assetTags) {
+export async function renderPage(pageObj, assetTags, requestUrl) {
   const PageComponent = (await components[pageObj.component]()).default;
   const layoutIds = layoutTree[pageObj.component] || [];
   const layoutComponents = await Promise.all(
@@ -111,7 +111,7 @@ export async function renderPage(pageObj, assetTags) {
       pageProps: pageObj.props,
       shared: pageObj.shared || {},
       params: pageObj.params || {},
-      router: createSsrRouter(pageObj.url || "/", pageObj.params || {}),
+      router: createSsrRouter(pageObj.url || "/", pageObj.params || {}, requestUrl),
       routeUrl: pageObj.url || "/",
       navigation: idleNavigationState(),
       stores: null,
diff --git a/packages/svelte/src/runtime/App.svelte b/packages/svelte/src/runtime/App.svelte
index 7f747ab6e..f9a8f2682 100644
--- a/packages/svelte/src/runtime/App.svelte
+++ b/packages/svelte/src/runtime/App.svelte
@@ -28,7 +28,7 @@
   let params = $state(init.params || {});
   let routeUrl = $state(init.routeUrl || "/");
   let navigation = $state(init.navigation || idleNavigationState());
-  const router = createRouterFacade(init.router, () => routeUrl, () => params);
+  const router = init.router ? createRouterFacade(init.router, () => routeUrl, () => params) : null;
 
   // Pages and layouts keep the objects returned by useShared() and useParams()
   // across navigations, so update them in place.
diff --git a/packages/svelte/src/runtime/Link.svelte b/packages/svelte/src/runtime/Link.svelte
index 3752361ed..3a7015601 100644
--- a/packages/svelte/src/runtime/Link.svelte
+++ b/packages/svelte/src/runtime/Link.svelte
@@ -2,6 +2,7 @@
   import { getContext, onDestroy, onMount } from "svelte";
   import {
     handleLinkClick,
+    linkActiveAttributes,
     linkPrefetchStrategies,
     observeLinkVisible,
     prefetchLink,
@@ -21,6 +22,7 @@
     viewTransition = undefined,
     prefetch: prefetchProp = false,
     cacheFor = undefined,
+    activeMatch = undefined,
     onNavigate = undefined,
     children,
     onclick: onclickProp = undefined,
@@ -116,6 +118,8 @@
     resolveLink({ href, method, data, prefetch: prefetchProp, reloadDocument }),
   );
   const strategies = $derived(linkPrefetchStrategies({ prefetch: prefetchProp, reloadDocument }));
+  // Reading router.url tracks the route URL, so this follows navigations.
+  const activeAttributes = $derived(linkActiveAttributes(router, link, activeMatch));
   const resolvedStyle = $derived(
     style ? `touch-action: manipulation; ${style}` : "touch-action: manipulation",
   );
@@ -125,6 +129,7 @@
   <a
     bind:this={el}
     href={link.href}
+    {...activeAttributes}
     {...rest}
     style={resolvedStyle}
     onclick={onClick}
diff --git a/packages/void/AGENTS.md b/packages/void/AGENTS.md
index eb66a1102..fadcc7af3 100644
--- a/packages/void/AGENTS.md
+++ b/packages/void/AGENTS.md
@@ -43,6 +43,8 @@ Production non-CF Pages pass a filesystem-backed `ASSETS` provider to the genera
 
 ### Runtime Framework
 
+Pages navigation payloads keep `url` as a path and query string. The render callback receives the full request URL separately; preserve its origin through each adapter's SSR router and router facade.
+
 **Hono** is used as the runtime framework. The generated virtual module creates a Hono app with file-based routes and middleware. Route handlers receive a Hono `Context` object (`c`) and can use the full Hono API (`c.json()`, `c.text()`, `c.req.param()`, etc.) plus the Hono middleware ecosystem.
 
 - `defineHandler(fn)` — wraps a route handler `(c: CloudContext) => R`, returns `TypedHandler<{}, R>`
diff --git a/packages/void/skills/void/SKILL.md b/packages/void/skills/void/SKILL.md
index d8da88959..96967184a 100644
--- a/packages/void/skills/void/SKILL.md
+++ b/packages/void/skills/void/SKILL.md
@@ -84,6 +84,9 @@ the app's existing saved destination, including when the target project is new.
   guides and use `void info` to preserve resource names and instance keys.
 - Declare application environment keys in `env.ts` and access them through
   `void/env`; follow `docs/guide/env-vars.md` for local and production values.
+- In Pages navigation, style the current link with `Link`'s `aria-current` and `data-void-active`
+  attributes (`activeMatch="prefix"` for sections) instead of comparing `useRouter().path`; see
+  `docs/guide/pages-routing/overview.md#active-links`.
 - For platform setup, follow the pages linked from
   `docs/guide/self-hosted-platform.md`. Use `void platform list` to find the
   installation slug for maintenance. For recovery, use its documented resume
diff --git a/packages/void/src/pages/client.ts b/packages/void/src/pages/client.ts
index 285cf80df..3d02c8c96 100644
--- a/packages/void/src/pages/client.ts
+++ b/packages/void/src/pages/client.ts
@@ -24,11 +24,14 @@ import { isSameOrigin } from './url.ts';
 export { getValidationErrors, isModifiedEvent, mergeDataIntoHref } from './adapter-helpers.ts';
 export {
   handleLinkClick,
+  linkActiveAttributes,
   linkPrefetchStrategies,
   observeLinkVisible,
   prefetchLink,
   resolveLink,
   type BaseLinkProps,
+  type LinkActiveAttributes,
+  type LinkActiveMatch,
   type LinkNavigateEvent,
   type LinkPrefetchStrategy,
   type ResolvedLink,
@@ -170,7 +173,7 @@ export function createRouterFacade(
     },
 
     get url() {
-      return toUrl(getCurrentUrl());
+      return new URL(getCurrentUrl() || '/', router.url);
     },
 
     get path() {
@@ -207,11 +210,15 @@ export function createRouterFacade(
   };
 }
 
-export function createSsrRouter(url = '/', params: Record<string, string> = {}): VoidRouter {
+export function createSsrRouter(
+  url = '/',
+  params: Record<string, string> = {},
+  requestUrl?: string,
+): VoidRouter {
   const router = {
     _hoverDelay: 75,
     get url() {
-      return toUrl(url);
+      return new URL(url || '/', requestUrl ?? getUrlBase());
     },
     get path() {
       return this.url.pathname;
diff --git a/packages/void/src/pages/link.ts b/packages/void/src/pages/link.ts
index 6f11dfe1d..8a978194f 100644
--- a/packages/void/src/pages/link.ts
+++ b/packages/void/src/pages/link.ts
@@ -4,9 +4,17 @@ import { isModifiedEvent, mergeDataIntoHref } from './adapter-helpers.ts';
 import type { NavigationMethod, VoidRouter } from './client.ts';
 import type { PrefetchOptions } from './navigation-engine.ts';
 import type { CacheForInput } from './prefetch.ts';
+import { decodePagePath } from './url.ts';
 
 export type LinkPrefetchStrategy = 'hover' | 'click' | 'mount' | 'visible';
 export type LinkNavigateEvent = { preventDefault(): void };
+export type LinkActiveMatch = 'exact' | 'prefix';
+
+/** Present only when the link matches the current URL. */
+export type LinkActiveAttributes = {
+  'aria-current'?: 'page';
+  'data-void-active'?: '';
+};
 
 /** Props every adapter's Link accepts. Adapters add element attributes and children. */
 export type BaseLinkProps = {
@@ -20,6 +28,7 @@ export type BaseLinkProps = {
   viewTransition?: boolean;
   prefetch?: boolean | LinkPrefetchStrategy | ReadonlyArray<LinkPrefetchStrategy>;
   cacheFor?: CacheForInput;
+  activeMatch?: LinkActiveMatch;
   onNavigate?: (event: LinkNavigateEvent) => void;
 };
 
@@ -95,6 +104,51 @@ export function linkPrefetchStrategies(
   return prefetch;
 }
 
+/**
+ * Marks a GET link to the current page. Pathnames compare the way the server
+ * matches pages: case-sensitive, trailing slash significant, decoded like Hono's
+ * getPath. The query and hash are ignored. `prefix` also matches nested pages by
+ * whole segment, except for `/`, but only an exact match is `aria-current`.
+ * Spread the result before the user's attributes so theirs win.
+ */
+export function linkActiveAttributes(
+  router: VoidRouter | null | undefined,
+  link: ResolvedLink,
+  match: LinkActiveMatch = 'exact',
+): LinkActiveAttributes {
+  if (!router || !link.isGet) {
+    return {};
+  }
+
+  const current = router.url;
+  let target: URL;
+  try {
+    target = new URL(link.href, current);
+  } catch {
+    // A malformed href still renders; it just never matches.
+    return {};
+  }
+  // Protocol and host rather than `origin`, which is opaque for custom schemes such as capacitor:.
+  if (target.protocol !== current.protocol || target.host !== current.host) {
+    return {};
+  }
+
+  const currentPath = decodePagePath(current.pathname);
+  const linkPath = decodePagePath(target.pathname);
+  if (linkPath === currentPath) {
+    return { 'aria-current': 'page', 'data-void-active': '' };
+  }
+
+  if (match === 'prefix' && linkPath !== '/') {
+    const parent = linkPath.endsWith('/') ? linkPath : `${linkPath}/`;
+    if (currentPath.startsWith(parent)) {
+      return { 'data-void-active': '' };
+    }
+  }
+
+  return {};
+}
+
 export function prefetchLink(
   router: VoidRouter | null | undefined,
   href: Href,
diff --git a/packages/void/src/pages/protocol.ts b/packages/void/src/pages/protocol.ts
index 332aa489f..e1a72e701 100644
--- a/packages/void/src/pages/protocol.ts
+++ b/packages/void/src/pages/protocol.ts
@@ -72,7 +72,11 @@ type AssetTags = {
   devCss?: Array<DevCssAsset>;
   devCssNonce?: string;
 };
-type RenderPage = (pageObj: PageObject, assetTags: AssetTags) => Promise<PageRenderResult>;
+type RenderPage = (
+  pageObj: PageObject,
+  assetTags: AssetTags,
+  requestUrl: string,
+) => Promise<PageRenderResult>;
 type RenderPageWithMetadata = RenderPage & {
   preambleScript?: string;
 };
@@ -198,9 +202,10 @@ async function renderWithAssetTags(
   renderFn: RenderPage,
   pageObj: PageObject,
   assetTags: AssetTags,
+  requestUrl: string,
 ): Promise<PageRenderResult> {
   try {
-    return await renderFn(pageObj, assetTags);
+    return await renderFn(pageObj, assetTags, requestUrl);
   } catch (error) {
     attachRenderErrorAssetTags(error, assetTags);
   }
@@ -237,10 +242,11 @@ async function renderPageHtml(
   getAssetTags: GetAssetTags,
 ): Promise<{ html: PageRenderResult; assetTags: AssetTags }> {
   const assetTags = prepareAssetTags(await getAssetTags(c.req.raw, c.env, componentId));
+  // Keep the request origin in render context, rather than serialized navigation URLs.
   const html =
     renderMode === 'client'
       ? renderClientOnlyPage(pageObj, assetTags, renderFn)
-      : await renderWithAssetTags(renderFn, pageObj, assetTags);
+      : await renderWithAssetTags(renderFn, pageObj, assetTags, c.req.url);
   return { html, assetTags };
 }
 
diff --git a/packages/void/test/unit/pages-link.test.ts b/packages/void/test/unit/pages-link.test.ts
index c7fa046cf..be6b4ca64 100644
--- a/packages/void/test/unit/pages-link.test.ts
+++ b/packages/void/test/unit/pages-link.test.ts
@@ -1,11 +1,14 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vite-plus/test';
-import type { VoidRouter } from '../../src/pages/client.ts';
+import { createRouterFacade, createSsrRouter, type VoidRouter } from '../../src/pages/client.ts';
 import {
   handleLinkClick,
+  linkActiveAttributes,
   linkPrefetchStrategies,
   observeLinkVisible,
   prefetchLink,
   resolveLink,
+  type BaseLinkProps,
+  type LinkActiveMatch,
 } from '../../src/pages/link.ts';
 
 function createRouter() {
@@ -97,6 +100,92 @@ describe('linkPrefetchStrategies', () => {
   });
 });
 
+describe('linkActiveAttributes', () => {
+  const page = { 'aria-current': 'page', 'data-void-active': '' };
+  const nested = { 'data-void-active': '' };
+
+  function attributes(
+    url: string,
+    props: Pick<BaseLinkProps, 'href' | 'method' | 'data'>,
+    match?: LinkActiveMatch,
+  ) {
+    const router = { url: new URL(url, 'https://app.test') } as VoidRouter;
+    return linkActiveAttributes(router, resolveLink(props), match);
+  }
+
+  it('marks only the current page by default', () => {
+    expect(attributes('/admin/users', { href: '/admin/users' })).toEqual(page);
+    expect(attributes('/admin/users/42', { href: '/admin/users' })).toEqual({});
+    expect(attributes('/admin', { href: '/admin/users' })).toEqual({});
+  });
+
+  it('also marks nested pages by whole segment with prefix', () => {
+    expect(attributes('/admin/users', { href: '/admin/users' }, 'prefix')).toEqual(page);
+    expect(attributes('/admin/users/42', { href: '/admin/users' }, 'prefix')).toEqual(nested);
+    expect(attributes('/admin/users/42/edit', { href: '/admin/users' }, 'prefix')).toEqual(nested);
+    expect(attributes('/admin/users', { href: '/admin/' }, 'prefix')).toEqual(nested);
+    expect(attributes('/admin/users-archive', { href: '/admin/users' }, 'prefix')).toEqual({});
+    expect(attributes('/admin', { href: '/admin/users' }, 'prefix')).toEqual({});
+  });
+
+  it('only matches / on the home page', () => {
+    expect(attributes('/', { href: '/' }, 'prefix')).toEqual(page);
+    expect(attributes('/admin/users', { href: '/' }, 'prefix')).toEqual({});
+  });
+
+  it('ignores the query and hash', () => {
+    expect(attributes('/inbox?page=2', { href: '/inbox' })).toEqual(page);
+    expect(attributes('/settings?tab=billing', { href: '/settings?tab=profile' })).toEqual(page);
+    expect(attributes('/search', { href: '/search', data: { q: 'void' } })).toEqual(page);
+    expect(attributes('/docs', { href: '/docs#install' })).toEqual(page);
+    expect(attributes('/docs#install', { href: '#usage' })).toEqual(page);
+  });
+
+  it('compares paths the way the router matches them', () => {
+    expect(attributes('/admin', { href: '/Admin' })).toEqual({});
+    expect(attributes('/admin', { href: '/admin/' })).toEqual({});
+    expect(attributes('/admin/', { href: '/admin' })).toEqual({});
+    expect(attributes('/caf%C3%A9', { href: '/café' })).toEqual(page);
+    expect(attributes('/caf%c3%a9', { href: '/caf%C3%A9' })).toEqual(page);
+  });
+
+  it('resolves relative and absolute hrefs against the current URL', () => {
+    expect(attributes('/admin/users/42', { href: '42' })).toEqual(page);
+    expect(attributes('/admin/users/42', { href: '../users' }, 'prefix')).toEqual(nested);
+    expect(attributes('/admin', { href: 'https://app.test/admin' })).toEqual(page);
+    expect(attributes('/', { href: 'https://example.com/' })).toEqual({});
+    expect(attributes('/', { href: 'http://app.test/' })).toEqual({});
+  });
+
+  it('uses the request origin when the SSR page URL is relative', () => {
+    vi.stubGlobal('window', undefined);
+    const router = createSsrRouter('/users?view=all', {}, 'https://app.test/users?view=all');
+    expect(router.url.href).toBe('https://app.test/users?view=all');
+    expect(linkActiveAttributes(router, resolveLink({ href: 'https://app.test/users' }))).toEqual(
+      page,
+    );
+    expect(linkActiveAttributes(router, resolveLink({ href: '//app.test/users' }))).toEqual(page);
+    expect(linkActiveAttributes(router, resolveLink({ href: 'http://localhost/users' }))).toEqual(
+      {},
+    );
+  });
+
+  it('preserves the router origin in a server-side facade', () => {
+    vi.stubGlobal('window', undefined);
+    const router = createRouterFacade(createSsrRouter('https://app.test/previous'), () => '/users');
+    expect(router.url.href).toBe('https://app.test/users');
+    expect(linkActiveAttributes(router, resolveLink({ href: '//app.test/users' }))).toEqual(page);
+    expect(linkActiveAttributes(router, resolveLink({ href: 'http://localhost/users' }))).toEqual(
+      {},
+    );
+  });
+
+  it('never marks links that are not GET or have no router', () => {
+    expect(attributes('/logout', { href: '/logout', method: 'post' })).toEqual({});
+    expect(linkActiveAttributes(null, resolveLink({ href: '/' }))).toEqual({});
+  });
+});
+
 describe('prefetchLink', () => {
   it('prefetches other destinations with cacheFor only when given', () => {
     const router = createRouter();
diff --git a/packages/void/test/unit/pages-protocol.test.ts b/packages/void/test/unit/pages-protocol.test.ts
index 6386fc188..40a5b75c4 100644
--- a/packages/void/test/unit/pages-protocol.test.ts
+++ b/packages/void/test/unit/pages-protocol.test.ts
@@ -172,6 +172,7 @@ describe('handlePageGet', () => {
         url: '/posts/abc-123',
       }),
       expect.anything(),
+      'http://localhost/posts/abc-123',
     );
   });
 
diff --git a/packages/vue/src/plugin-pages.ts b/packages/vue/src/plugin-pages.ts
index ed1fbcb51..39542dd44 100644
--- a/packages/vue/src/plugin-pages.ts
+++ b/packages/vue/src/plugin-pages.ts
@@ -206,7 +206,7 @@ ${generateComponentManifest(scan, pagesDir)}
 
 ${PATCH_PROPS_RUNTIME}
 
-export async function renderPage(pageObj, assetTags) {
+export async function renderPage(pageObj, assetTags, requestUrl) {
   const PageComponent = (await components[pageObj.component]()).default;
   const layoutIds = layoutTree[pageObj.component] || [];
   const layoutComponents = await Promise.all(
@@ -217,7 +217,7 @@ export async function renderPage(pageObj, assetTags) {
     setup() {
       provide("__void_shared", reactive(pageObj.shared || {}));
       provide("__void_params", reactive(pageObj.params || {}));
-      provide("__void_router", createSsrRouter(pageObj.url || "/", pageObj.params || {}));
+      provide("__void_router", createSsrRouter(pageObj.url || "/", pageObj.params || {}, requestUrl));
       provide("__void_navigation", idleNavigationState());
       return () => {
         patchProps(PageComponent, pageObj.props);
diff --git a/packages/vue/src/runtime/link.ts b/packages/vue/src/runtime/link.ts
index 0a04ce520..12d1c62ed 100644
--- a/packages/vue/src/runtime/link.ts
+++ b/packages/vue/src/runtime/link.ts
@@ -1,10 +1,12 @@
 import {
   handleLinkClick,
+  linkActiveAttributes,
   linkPrefetchStrategies,
   observeLinkVisible,
   prefetchLink,
   resolveLink,
   type BaseLinkProps,
+  type LinkActiveMatch,
   type LinkNavigateEvent,
   type LinkPrefetchStrategy,
   type VoidRouter,
@@ -55,6 +57,7 @@ const linkPropOptions = {
     type: [Number, String, Array] as PropType<number | string | [string, string]>,
     default: undefined,
   },
+  activeMatch: { type: String as PropType<LinkActiveMatch>, default: undefined },
 } as const;
 
 // isolatedDeclarations needs the public props written out. This fails to compile if
@@ -86,6 +89,10 @@ const LinkComponent = defineComponent({
     const elRef = ref<HTMLElement | null>(null);
     const link = computed(() => resolveLink(props));
     const strategies = computed(() => linkPrefetchStrategies(props));
+    // Reading router.url tracks the route URL, so this follows navigations.
+    const activeAttributes = computed(() =>
+      linkActiveAttributes(router, link.value, props.activeMatch),
+    );
 
     function doPrefetch() {
       prefetchLink(router, link.value.href, props.cacheFor);
@@ -176,6 +183,7 @@ const LinkComponent = defineComponent({
       return h(
         tag,
         {
+          ...activeAttributes.value,
           ...attrs,
           ref: elRef,
           ...(isGet ? { href } : { type: 'button' }),
diff --git a/packages/vue/test/unit/link.typecheck.ts b/packages/vue/test/unit/link.typecheck.ts
index ca12feff4..1690efd27 100644
--- a/packages/vue/test/unit/link.typecheck.ts
+++ b/packages/vue/test/unit/link.typecheck.ts
@@ -12,11 +12,14 @@ export function checkLinkPassThroughAttributes(): void {
     rel: 'noopener',
     onClick: track,
     onMouseenter: () => {},
+    activeMatch: 'prefix',
   };
   void h(Link, props);
   // @ts-expect-error href is required
   const missingHref: LinkProps = { target: '_blank' };
   // @ts-expect-error Void props keep their own types
   const badPrefetch: LinkProps = { href: '/users', prefetch: 'sometimes' };
-  void [missingHref, badPrefetch];
+  // @ts-expect-error activeMatch is exact or prefix
+  const badActiveMatch: LinkProps = { href: '/users', activeMatch: 'nested' };
+  void [missingHref, badPrefetch, badActiveMatch];
 }
diff --git a/playground/react-pages/pages/layout.tsx b/playground/react-pages/pages/layout.tsx
index b02598ad6..162226a8f 100644
--- a/playground/react-pages/pages/layout.tsx
+++ b/playground/react-pages/pages/layout.tsx
@@ -9,7 +9,7 @@ export default function Layout({ children }: { children: React.ReactNode }) {
           Home
         </Link>{' '}
         |{' '}
-        <Link href="/users" prefetch>
+        <Link href="/users" activeMatch="prefix" prefetch>
           Users
         </Link>{' '}
         |{' '}
diff --git a/playground/react-pages/pages/link-behavior.server.ts b/playground/react-pages/pages/link-behavior.server.ts
index 1e7f79d8b..270c38e2f 100644
--- a/playground/react-pages/pages/link-behavior.server.ts
+++ b/playground/react-pages/pages/link-behavior.server.ts
@@ -1,7 +1,10 @@
 import { defineHandler, defineHead } from 'void';
+import type { Href } from 'void/routes';
 
 export type Props = Readonly<{
   title: string;
+  absoluteUrl: Href;
+  protocolRelativeUrl: Href;
 }>;
 
 function sleep(ms: number): Promise<void> {
@@ -13,7 +16,13 @@ export const loader = defineHandler<Props>(async (c) => {
     await sleep(1000);
   }
 
-  return { title: 'Link Behavior' };
+  const url = new URL(c.req.url);
+  // Exercise browser URL forms independently of the typed route inventory.
+  return {
+    title: 'Link Behavior',
+    absoluteUrl: `${url.origin}/link-behavior` as Href,
+    protocolRelativeUrl: `//${url.host}/link-behavior` as Href,
+  };
 });
 
 export const head = defineHead<Props>((c, props) => {
diff --git a/playground/react-pages/pages/link-behavior.tsx b/playground/react-pages/pages/link-behavior.tsx
index 355578aab..c02f9be00 100644
--- a/playground/react-pages/pages/link-behavior.tsx
+++ b/playground/react-pages/pages/link-behavior.tsx
@@ -11,7 +11,7 @@ type LinkBehaviorWindow = Window & {
   __preventedNavigate?: boolean;
 };
 
-export default function LinkBehaviorPage({ title }: Props) {
+export default function LinkBehaviorPage({ title, absoluteUrl, protocolRelativeUrl }: Props) {
   const [abortTestStatus, setAbortTestStatus] = useState('Not run');
 
   useEffect(() => {
@@ -81,6 +81,17 @@ export default function LinkBehaviorPage({ title }: Props) {
   return (
     <div>
       <h1>{title}</h1>
+      <p>
+        <Link href={absoluteUrl} data-testid="absolute-current-link">
+          Current page (absolute)
+        </Link>
+        <Link href={protocolRelativeUrl} data-testid="protocol-relative-current-link">
+          Current page (protocol-relative)
+        </Link>
+        <Link href="http://localhost/link-behavior" data-testid="external-localhost-link">
+          External localhost
+        </Link>
+      </p>
       <p>
         <button
           data-testid="typed-visit"
diff --git a/playground/solid-pages/pages/layout.tsx b/playground/solid-pages/pages/layout.tsx
index 77441a621..6f07d6348 100644
--- a/playground/solid-pages/pages/layout.tsx
+++ b/playground/solid-pages/pages/layout.tsx
@@ -10,7 +10,7 @@ export default function Layout(props: { children: JSX.Element }) {
           Home
         </Link>{' '}
         |{' '}
-        <Link href="/users" prefetch>
+        <Link href="/users" activeMatch="prefix" prefetch>
           Users
         </Link>{' '}
         |{' '}
diff --git a/playground/solid-pages/pages/link-behavior.server.ts b/playground/solid-pages/pages/link-behavior.server.ts
index b45ae3bca..cd01192f7 100644
--- a/playground/solid-pages/pages/link-behavior.server.ts
+++ b/playground/solid-pages/pages/link-behavior.server.ts
@@ -1,11 +1,20 @@
 import { defineHandler, defineHead } from 'void';
+import type { Href } from 'void/routes';
 
 export type Props = Readonly<{
   title: string;
+  absoluteUrl: Href;
+  protocolRelativeUrl: Href;
 }>;
 
-export const loader = defineHandler<Props>(() => {
-  return { title: 'Link Behavior' };
+export const loader = defineHandler<Props>((c) => {
+  const url = new URL(c.req.url);
+  // Exercise browser URL forms independently of the typed route inventory.
+  return {
+    title: 'Link Behavior',
+    absoluteUrl: `${url.origin}/link-behavior` as Href,
+    protocolRelativeUrl: `//${url.host}/link-behavior` as Href,
+  };
 });
 
 export const head = defineHead<Props>((c, props) => {
diff --git a/playground/solid-pages/pages/link-behavior.tsx b/playground/solid-pages/pages/link-behavior.tsx
index c2fbfdb00..0c98bda9e 100644
--- a/playground/solid-pages/pages/link-behavior.tsx
+++ b/playground/solid-pages/pages/link-behavior.tsx
@@ -25,6 +25,17 @@ export default function LinkBehaviorPage(props: Props) {
   return (
     <div>
       <h1>{props.title}</h1>
+      <p>
+        <Link href={props.absoluteUrl} data-testid="absolute-current-link">
+          Current page (absolute)
+        </Link>
+        <Link href={props.protocolRelativeUrl} data-testid="protocol-relative-current-link">
+          Current page (protocol-relative)
+        </Link>
+        <Link href="http://localhost/link-behavior" data-testid="external-localhost-link">
+          External localhost
+        </Link>
+      </p>
       <p>
         <button
           data-testid="typed-visit"
diff --git a/playground/svelte-pages/pages/layout.svelte b/playground/svelte-pages/pages/layout.svelte
index f075f5ed9..83064bf33 100644
--- a/playground/svelte-pages/pages/layout.svelte
+++ b/playground/svelte-pages/pages/layout.svelte
@@ -8,7 +8,7 @@
 
 <div>
   <nav>
-    <Link href="/" prefetch>Home</Link> | <Link href="/users" prefetch>Users</Link> |
+    <Link href="/" prefetch>Home</Link> | <Link href="/users" activeMatch="prefix" prefetch>Users</Link> |
     <Link href="/blog" prefetch>Blog</Link> |
     <Link href="/deferred" prefetch>Deferred</Link> |
     <span>{shared.appName}</span>
diff --git a/playground/svelte-pages/pages/link-behavior.server.ts b/playground/svelte-pages/pages/link-behavior.server.ts
index b45ae3bca..cd01192f7 100644
--- a/playground/svelte-pages/pages/link-behavior.server.ts
+++ b/playground/svelte-pages/pages/link-behavior.server.ts
@@ -1,11 +1,20 @@
 import { defineHandler, defineHead } from 'void';
+import type { Href } from 'void/routes';
 
 export type Props = Readonly<{
   title: string;
+  absoluteUrl: Href;
+  protocolRelativeUrl: Href;
 }>;
 
-export const loader = defineHandler<Props>(() => {
-  return { title: 'Link Behavior' };
+export const loader = defineHandler<Props>((c) => {
+  const url = new URL(c.req.url);
+  // Exercise browser URL forms independently of the typed route inventory.
+  return {
+    title: 'Link Behavior',
+    absoluteUrl: `${url.origin}/link-behavior` as Href,
+    protocolRelativeUrl: `//${url.host}/link-behavior` as Href,
+  };
 });
 
 export const head = defineHead<Props>((c, props) => {
diff --git a/playground/svelte-pages/pages/link-behavior.svelte b/playground/svelte-pages/pages/link-behavior.svelte
index 355aa7673..db1f94e40 100644
--- a/playground/svelte-pages/pages/link-behavior.svelte
+++ b/playground/svelte-pages/pages/link-behavior.svelte
@@ -8,7 +8,7 @@
     __preventedNavigate?: boolean;
   };
 
-  let { title }: Props = $props();
+  let { title, absoluteUrl, protocolRelativeUrl }: Props = $props();
   const router = useRouter();
 
   function setClicked() {
@@ -28,6 +28,20 @@
 
 <div>
   <h1>{title}</h1>
+  <p>
+    <Link href={absoluteUrl} data-testid="absolute-current-link">
+      Current page (absolute)
+    </Link>
+    <Link
+      href={protocolRelativeUrl}
+      data-testid="protocol-relative-current-link"
+    >
+      Current page (protocol-relative)
+    </Link>
+    <Link href="http://localhost/link-behavior" data-testid="external-localhost-link">
+      External localhost
+    </Link>
+  </p>
   <p>
     <button
       data-testid="typed-visit"
diff --git a/playground/vue-pages/pages/layout.vue b/playground/vue-pages/pages/layout.vue
index 43022dea1..a9be0d580 100644
--- a/playground/vue-pages/pages/layout.vue
+++ b/playground/vue-pages/pages/layout.vue
@@ -7,7 +7,8 @@ const shared = useShared();
 <template>
   <div>
     <nav>
-      <Link href="/" prefetch>Home</Link> | <Link href="/users" prefetch>Users</Link> |
+      <Link href="/" prefetch>Home</Link> |
+      <Link href="/users" active-match="prefix" prefetch>Users</Link> |
       <Link href="/blog" prefetch>Blog</Link> | <Link href="/deferred" prefetch>Deferred</Link> |
       <span>{{ shared.appName }}</span>
     </nav>
diff --git a/playground/vue-pages/pages/link-behavior.server.ts b/playground/vue-pages/pages/link-behavior.server.ts
index b45ae3bca..cd01192f7 100644
--- a/playground/vue-pages/pages/link-behavior.server.ts
+++ b/playground/vue-pages/pages/link-behavior.server.ts
@@ -1,11 +1,20 @@
 import { defineHandler, defineHead } from 'void';
+import type { Href } from 'void/routes';
 
 export type Props = Readonly<{
   title: string;
+  absoluteUrl: Href;
+  protocolRelativeUrl: Href;
 }>;
 
-export const loader = defineHandler<Props>(() => {
-  return { title: 'Link Behavior' };
+export const loader = defineHandler<Props>((c) => {
+  const url = new URL(c.req.url);
+  // Exercise browser URL forms independently of the typed route inventory.
+  return {
+    title: 'Link Behavior',
+    absoluteUrl: `${url.origin}/link-behavior` as Href,
+    protocolRelativeUrl: `//${url.host}/link-behavior` as Href,
+  };
 });
 
 export const head = defineHead<Props>((c, props) => {
diff --git a/playground/vue-pages/pages/link-behavior.vue b/playground/vue-pages/pages/link-behavior.vue
index cd2ce8b90..bbbe28b6c 100644
--- a/playground/vue-pages/pages/link-behavior.vue
+++ b/playground/vue-pages/pages/link-behavior.vue
@@ -29,6 +29,15 @@ function preventNavigate(event: { preventDefault(): void }) {
 <template>
   <div>
     <h1>{{ title }}</h1>
+    <p>
+      <Link :href="absoluteUrl" data-testid="absolute-current-link">Current page (absolute)</Link>
+      <Link :href="protocolRelativeUrl" data-testid="protocol-relative-current-link"
+        >Current page (protocol-relative)</Link
+      >
+      <Link href="http://localhost/link-behavior" data-testid="external-localhost-link"
+        >External localhost</Link
+      >
+    </p>
     <p>
       <button
         data-testid="typed-visit"
diff --git a/test/pages-client-contract.ts b/test/pages-client-contract.ts
index 46898400a..4ce110c29 100644
--- a/test/pages-client-contract.ts
+++ b/test/pages-client-contract.ts
@@ -131,6 +131,104 @@ export function registerSharedClientTests({
     }
   });
 
+  it('Link matches absolute URLs consistently during SSR and hydration', async ({ expect }) => {
+    const page = await newPage();
+    const hydrationErrors: Array<string> = [];
+    page.on('console', (message) => {
+      if (/hydrat/i.test(message.text()) && ['warning', 'error'].includes(message.type())) {
+        hydrationErrors.push(message.text());
+      }
+    });
+    const links = (html = '') =>
+      page.evaluate((html) => {
+        const root = html ? new DOMParser().parseFromString(html, 'text/html') : document;
+        return [
+          'absolute-current-link',
+          'protocol-relative-current-link',
+          'external-localhost-link',
+        ].map((id) => {
+          const link = root.querySelector(`[data-testid="${id}"]`)!;
+          return [
+            link.getAttribute('href'),
+            link.getAttribute('aria-current'),
+            link.getAttribute('data-void-active'),
+          ];
+        });
+      }, html);
+    const expected = [
+      [`${BASE}/link-behavior`, 'page', ''],
+      [`//${new URL(BASE).host}/link-behavior`, 'page', ''],
+      ['http://localhost/link-behavior', null, null],
+    ];
+    try {
+      const response = await page.goto(BASE + '/link-behavior');
+      const html = await response!.text();
+      expect(await links(html)).toEqual(expected);
+      await waitForHydration(page);
+      expect(await links()).toEqual(expected);
+      expect(hydrationErrors).toEqual([]);
+
+      // The request origin is render context; serialized navigation URLs stay relative.
+      const pageUrl = await page.evaluate(
+        () => JSON.parse(document.getElementById('__VOID_PAGE_DATA__')!.textContent!).url,
+      );
+      expect(pageUrl).toBe('/link-behavior');
+      await page.getByTestId('query-only-link').click();
+      await page.waitForURL(BASE + '/link-behavior?view=compact');
+      expect(await links()).toEqual(expected);
+    } finally {
+      await page.context().close();
+    }
+  });
+
+  it('Link marks the link to the current page', async ({ expect }) => {
+    const page = await newPage();
+    // Users uses activeMatch="prefix" in every playground layout; Home matches exactly.
+    const state = (html: string, href: string) =>
+      page.evaluate(
+        ({ html, href }) => {
+          const root = html ? new DOMParser().parseFromString(html, 'text/html') : document;
+          const link = root.querySelector(`nav a[href="${href}"]`);
+          if (!link) {
+            throw new Error(`No nav link to ${href}`);
+          }
+          return [link.getAttribute('aria-current'), link.getAttribute('data-void-active')];
+        },
+        { html, href },
+      );
+    const navLinks = (html = '') => Promise.all([state(html, '/'), state(html, '/users')]);
+    try {
+      await page.goto(BASE + '/users');
+      const serverHtml = await (await page.request.get(BASE + '/users/1')).text();
+      expect(await navLinks(serverHtml)).toEqual([
+        [null, null],
+        [null, ''],
+      ]);
+
+      await waitForHydration(page);
+      expect(await navLinks()).toEqual([
+        [null, null],
+        ['page', ''],
+      ]);
+
+      await page.click('a[href="/users/1"]');
+      await page.waitForSelector('nav a[href="/users"][data-void-active]:not([aria-current])');
+      expect(await navLinks()).toEqual([
+        [null, null],
+        [null, ''],
+      ]);
+
+      await page.click('nav a[href="/"]');
+      await page.waitForSelector('nav a[href="/"][aria-current="page"]');
+      expect(await navLinks()).toEqual([
+        ['page', ''],
+        [null, null],
+      ]);
+    } finally {
+      await page.context().close();
+    }
+  });
+
   it('restores scroll after browser Back from an ordinary document link', async ({ expect }) => {
     const page = await newPage();
     const errors: Array<string> = [];
diff --git a/test/pages-island-contract.ts b/test/pages-island-contract.ts
index 965bdae9b..4e9c70886 100644
--- a/test/pages-island-contract.ts
+++ b/test/pages-island-contract.ts
@@ -44,6 +44,19 @@ function registerIslandTests(
     return page;
   }
 
+  it('island layouts leave links inactive without a router', async () => {
+    const page = await newPage();
+    try {
+      const response = await page.goto(BASE + '/blog');
+      expect(response!.status()).toBe(200);
+      await waitForIslandsHydrated(page, 2);
+      expect(await page.locator('nav a').count()).toBeGreaterThan(0);
+      expect(await page.locator('nav a[aria-current], nav a[data-void-active]').count()).toBe(0);
+    } finally {
+      await page.context().close();
+    }
+  });
+
   it('island hydration and interaction: counter increments on click', async () => {
     const page = await newPage();
     try {