diff --git a/docs/guide/pages-routing/overview.md b/docs/guide/pages-routing/overview.md
index 01fab3c9c..174b72fc6 100644
--- a/docs/guide/pages-routing/overview.md
+++ b/docs/guide/pages-routing/overview.md
@@ -94,6 +94,8 @@ Pages can be flat files such as `about.vue` or directory-based routes such as `a
 
 <PagesFileTree />
 
+Keep one file per route. Void reports an error when two page files resolve to the same path, such as `about.vue` and `about/index.vue`, or the same page in two route groups.
+
 Each page can have a companion `.server.ts` file that runs exclusively on the server. It can export:
 
 - A [**loader**](./loaders), which runs on `GET` and returns the data that becomes the page component's props
diff --git a/packages/react/src/runtime/pages-client.ts b/packages/react/src/runtime/pages-client.ts
index 97688b3a5..3b050f3a4 100644
--- a/packages/react/src/runtime/pages-client.ts
+++ b/packages/react/src/runtime/pages-client.ts
@@ -48,7 +48,8 @@ export type ReactPagesConfig = Readonly<{
   components: Record<string, () => Promise<ComponentModule>>;
   layoutTree: Record<string, Array<string>>;
   routeMeta: Record<string, { island?: boolean }>;
-  matchRoute(url: string): string | null;
+  /** Page id for a decoded pathname. */
+  matchRoute(path: string): string | null;
   staticPageData: boolean;
   staticPageDataFastPath: boolean;
   viewTransitions: boolean;
diff --git a/packages/void/src/application-routing.ts b/packages/void/src/application-routing.ts
index 48d7c6fb7..fd21d1660 100644
--- a/packages/void/src/application-routing.ts
+++ b/packages/void/src/application-routing.ts
@@ -10,6 +10,8 @@ export async function completeApplicationAnalysis(
   const scan = await scanRoutes(analysis.root, {
     output: analysis.config.output,
     paths: analysis.paths,
+    // A framework app's pages/ follows that framework's rules, not Void Pages.
+    checkPageRoutes: !analysis.framework,
     inventory: {
       routes: analysis.routes,
       middleware: analysis.middleware,
diff --git a/packages/void/src/pages/manifest.ts b/packages/void/src/pages/manifest.ts
index e6485cb33..b0757b123 100644
--- a/packages/void/src/pages/manifest.ts
+++ b/packages/void/src/pages/manifest.ts
@@ -8,11 +8,24 @@ import type { PageScanResult } from './types.ts';
  * Client entries load this eagerly, so it grows with every page. Each page id
  * is written once, identical layout chains are shared, and static routes are
  * matched by exact lookup instead of a RegExp per page. The emitted bindings
- * (`components`, `layoutTree`, `routeMeta`, `matchRoute`) keep their shape.
+ * (`components`, `layoutTree`, `routeMeta`, `matchRoute`) keep their shape;
+ * `matchRoute` takes a decoded pathname (see `decodePagePath`).
  */
 export function generateComponentManifest(scan: PageScanResult, pagesDir: string): string {
   const load = (filePath: string) => `() => import(${JSON.stringify(`${pagesDir}/${filePath}`)})`;
 
+  // A page in a folder named "layout" (layout/index.tsx) has the id of the
+  // layout file beside it (layout.tsx). No page path has a segment starting
+  // with "_", so that layout is keyed "_layout" instead.
+  const pageIds = new Set(scan.pages.map((page) => page.componentId));
+  const layoutKey = (id: string): string => {
+    if (!pageIds.has(id)) {
+      return id;
+    }
+    const slash = id.lastIndexOf('/');
+    return id.slice(0, slash + 1) + '_' + id.slice(slash + 1);
+  };
+
   const chains: Array<string> = [];
   const chainIndexes = new Map<string, number>();
   const staticRows: Array<string> = [];
@@ -21,7 +34,9 @@ export function generateComponentManifest(scan: PageScanResult, pagesDir: string
   // can be looked up exactly without changing which route matches first.
   let inStaticPrefix = true;
   for (const page of scan.pages) {
-    const chain = JSON.stringify(resolveLayoutIds(page, scan.layouts, scan.namedLayouts));
+    const chain = JSON.stringify(
+      resolveLayoutIds(page, scan.layouts, scan.namedLayouts).map(layoutKey),
+    );
     let chainIndex = chain === '[]' ? -1 : chainIndexes.get(chain);
     if (chainIndex === undefined) {
       chainIndex = chains.push(chain) - 1;
@@ -60,9 +75,10 @@ for (const [pattern, id, load, chain] of __voidDynamicRoutes) {
   if (chain >= 0) layoutTree[id] = __voidLayoutChains[chain];
   routes.push({ pattern, id });
 }`);
-  // Layouts are set after pages, so a layout keeps an id it shares with a page.
   for (const layout of [...scan.layouts, ...scan.namedLayouts]) {
-    lines.push(`components[${JSON.stringify(toLayoutId(layout))}] = ${load(layout.filePath)};`);
+    lines.push(
+      `components[${JSON.stringify(layoutKey(toLayoutId(layout)))}] = ${load(layout.filePath)};`,
+    );
   }
 
   // Route metadata (sparse — only island pages)
@@ -74,8 +90,7 @@ for (const [pattern, id, load, chain] of __voidDynamicRoutes) {
   }
   lines.push('};');
 
-  lines.push(`function matchRoute(url) {
-  const path = new URL(url, "http://x").pathname;
+  lines.push(`function matchRoute(path) {
   const id = __voidStaticRouteIds.get(path);
   if (id !== undefined) return id;
   for (const r of routes) {
@@ -106,7 +121,8 @@ function isStaticPattern(pattern: string): boolean {
   return pattern.split('/').every((segment) => captureGroup(segment) === undefined);
 }
 
-function patternToRegex(pattern: string): string {
+/** The RegExp literal a page pattern matches with, the same on the client and the server. */
+export function patternToRegex(pattern: string): string {
   const regexSource = pattern
     .split('/')
     .map((segment) => {
diff --git a/packages/void/src/pages/navigation-engine.ts b/packages/void/src/pages/navigation-engine.ts
index 62b869ad2..217981c09 100644
--- a/packages/void/src/pages/navigation-engine.ts
+++ b/packages/void/src/pages/navigation-engine.ts
@@ -8,7 +8,7 @@ import { PrefetchCache, parseCacheFor } from './prefetch.ts';
 import type { CacheForInput, CacheForResult } from './prefetch.ts';
 import type { PageObject } from './protocol.ts';
 import { createScrollRestoration } from './scroll-restoration.ts';
-import { isSameOrigin } from './url.ts';
+import { decodePagePath, isSameOrigin } from './url.ts';
 
 /**
  * The server leaves a named action's key out of the page URL. When the page URL
@@ -77,7 +77,8 @@ export type PageNavigationEngineConfig = {
   components: Record<string, () => Promise<PageComponentModule>>;
   layoutTree: Record<string, Array<string>>;
   routeMeta: Record<string, { island?: boolean }>;
-  matchRoute(url: string): string | null;
+  /** Page id for a decoded pathname (see `decodePagePath`). */
+  matchRoute(path: string): string | null;
   staticPageData?: boolean;
   staticPageDataFastPath?: boolean;
   viewTransitions: boolean;
@@ -239,7 +240,6 @@ export async function createPageNavigationEngine(
     components,
     layoutTree,
     routeMeta,
-    matchRoute,
     staticPageData: STATIC_PAGE_DATA_ENABLED = false,
     staticPageDataFastPath: STATIC_PAGE_DATA_FAST_PATH = STATIC_PAGE_DATA_ENABLED,
     prefetchHoverDelay: PREFETCH_HOVER_DELAY,
@@ -247,6 +247,9 @@ export async function createPageNavigationEngine(
     cacheVisitedPageData: CACHE_VISITED_PAGE_DATA = false,
   } = config;
 
+  const matchRoute = (url: string) =>
+    config.matchRoute(decodePagePath(new URL(url, 'http://x').pathname));
+
   const _prefetchCache = new PrefetchCache();
   let _nextNavigationId = 0;
   let _pendingResource: PageNavigationResource | null = null;
diff --git a/packages/void/src/pages/scan.ts b/packages/void/src/pages/scan.ts
index e8f53635c..53fd11823 100644
--- a/packages/void/src/pages/scan.ts
+++ b/packages/void/src/pages/scan.ts
@@ -19,6 +19,7 @@ import {
 import { staticExportInitializers, staticLiteral } from '../shared/static-exports.ts';
 import { scriptBlocks } from './island-imports.ts';
 import { resolveNamedLayout } from './layout-resolution.ts';
+import { patternToRegex } from './manifest.ts';
 import type {
   ExplicitBoolean,
   PageDefinition,
@@ -37,6 +38,8 @@ export const MAX_REVALIDATE = 31536000; // 1 year in seconds
 
 /** Layout paths already reported; a dev server rescans pages on every file change. */
 const warnedLayoutPaths = new Set<string>();
+/** Unreachable pages already reported, for the same reason. */
+const warnedShadowedPages = new Set<string>();
 
 type PageRenderingSource = {
   componentPath: string;
@@ -49,7 +52,13 @@ type PageRenderingSource = {
   hasGetPrerenderPaths?: boolean;
 };
 
-type PageScanOptions = { output?: 'server' | 'static'; paths?: ProjectPaths; pagesDir?: string };
+type PageScanOptions = {
+  output?: 'server' | 'static';
+  paths?: ProjectPaths;
+  pagesDir?: string;
+  /** Report pages that share a route. Off when another framework owns pages/ (Nuxt nests users.vue and users/index.vue). */
+  checkRoutes?: boolean;
+};
 
 type ResolvedPageRendering = {
   ssrMode: SsrMode;
@@ -363,6 +372,11 @@ export async function scanPages(root: string, options?: PageScanOptions): Promis
     return a.pattern.localeCompare(b.pattern);
   });
 
+  if (options?.checkRoutes !== false) {
+    assertOnePagePerRoute(pages);
+    warnShadowedPages(pagesDir, pages);
+  }
+
   // Validate: throw when regular pages are under island layouts
   for (const page of pages) {
     if (page.island) {
@@ -405,6 +419,84 @@ export async function scanPages(root: string, options?: PageScanOptions): Promis
   return { pages, layouts, namedLayouts };
 }
 
+function compareText(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+/** Group sorted pages by `key`, keeping only groups with more than one page. */
+function pagesSharing(
+  pages: Array<PageDefinition>,
+  key: (page: PageDefinition) => string,
+): Array<Array<PageDefinition>> {
+  const groups = new Map<string, Array<PageDefinition>>();
+  for (const page of pages) {
+    const group = groups.get(key(page));
+    if (group) {
+      group.push(page);
+    } else {
+      groups.set(key(page), [page]);
+    }
+  }
+  return [...groups.values()].filter((group) => group.length > 1);
+}
+
+/**
+ * Two files for one path have no stable winner: the server and the client can
+ * each pick a different one, and the order can change between runs.
+ */
+function assertOnePagePerRoute(pages: Array<PageDefinition>): void {
+  assertNoneShare(
+    pages,
+    (page) => page.pattern,
+    'pages: Multiple page files resolve to the same route:',
+    'Keep one page file per route and rename or remove the others.',
+  );
+  // index.tsx and index/index.tsx have different routes but the same page id.
+  assertNoneShare(
+    pages,
+    (page) => page.componentId,
+    'pages: Multiple page files resolve to the same page id:',
+    'Rename or remove one of them.',
+  );
+}
+
+function assertNoneShare(
+  pages: Array<PageDefinition>,
+  key: (page: PageDefinition) => string,
+  title: string,
+  hint: string,
+): void {
+  const clashes = pagesSharing(pages, key)
+    .map((group) => ({
+      key: key(group[0]),
+      files: group.map((page) => page.componentPath).sort(compareText),
+    }))
+    .sort((left, right) => compareText(left.key, right.key))
+    .map(
+      (clash) =>
+        `  ${JSON.stringify(clash.key)}: ${clash.files.map((file) => JSON.stringify(file)).join(', ')}`,
+    );
+  if (clashes.length > 0) {
+    throw new Error([title, ...clashes, hint].join('\n'));
+  }
+}
+
+/** Dynamic routes that match the same URLs, such as [id] and [slug]: only the first is ever used. */
+function warnShadowedPages(pagesDir: string, pages: Array<PageDefinition>): void {
+  for (const [used, ...shadowed] of pagesSharing(pages, (page) => patternToRegex(page.pattern))) {
+    for (const page of shadowed) {
+      const key = `${pagesDir}\0${used.componentPath}\0${page.componentPath}`;
+      if (warnedShadowedPages.has(key)) {
+        continue;
+      }
+      warnedShadowedPages.add(key);
+      voidWarn(
+        `pages: Page '${page.componentPath}' (${page.pattern}) is never used: '${used.componentPath}' (${used.pattern}) matches the same URLs first. Remove one of them.`,
+      );
+    }
+  }
+}
+
 // Same leading-script rule as @void/md's extractScript: a markdown page may open
 // with a <script> block, and its frontmatter starts right after that block.
 const LEADING_SCRIPT_RE = /^<script\b[^>]*>[\s\S]*?<\/script>\s*\n?/;
diff --git a/packages/void/src/pages/url.ts b/packages/void/src/pages/url.ts
index e6e62cc57..8c49af7a9 100644
--- a/packages/void/src/pages/url.ts
+++ b/packages/void/src/pages/url.ts
@@ -6,3 +6,50 @@ export function isSameOrigin(url: URL, origin: string): boolean {
   }
   return url.origin === origin;
 }
+
+function isHexDigit(char: string | undefined): boolean {
+  return (
+    char !== undefined &&
+    ((char >= '0' && char <= '9') || (char >= 'a' && char <= 'f') || (char >= 'A' && char <= 'F'))
+  );
+}
+
+function tryDecodeURI(text: string): string {
+  try {
+    return decodeURI(text);
+  } catch {
+    return text;
+  }
+}
+
+/**
+ * The path a page is matched on, decoded the way the server (Hono's getPath)
+ * decodes it: `/caf%C3%A9` becomes `/café`, while `%25`, reserved escapes such
+ * as `%2F` and malformed escapes stay encoded.
+ */
+export function decodePagePath(path: string): string {
+  if (!path.includes('%')) {
+    return path;
+  }
+  const escaped = path.split('%25').join('%2525');
+  try {
+    return decodeURI(escaped);
+  } catch {
+    // Decode each run of escapes on its own, keeping the runs that fail.
+  }
+  let decoded = '';
+  let index = 0;
+  while (index < escaped.length) {
+    let end = index;
+    while (escaped[end] === '%' && isHexDigit(escaped[end + 1]) && isHexDigit(escaped[end + 2])) {
+      end += 3;
+    }
+    if (end === index) {
+      decoded += escaped[index++];
+    } else {
+      decoded += tryDecodeURI(escaped.slice(index, end));
+      index = end;
+    }
+  }
+  return decoded;
+}
diff --git a/packages/void/src/plugin-routing.ts b/packages/void/src/plugin-routing.ts
index a4305d29d..a6f2e6c5f 100644
--- a/packages/void/src/plugin-routing.ts
+++ b/packages/void/src/plugin-routing.ts
@@ -680,7 +680,26 @@ export function routingPlugin(root: string, options: RoutingPluginOptions): Plug
         // Re-scan and invalidate the virtual module in ALL environments.
         // The route table virtual module lives in the workerd environment,
         // not the client — so we must iterate all environments.
-        await rescan(true);
+        try {
+          await rescan(true);
+        } catch (error) {
+          // Keep the last good route table; the next change rescans.
+          const message = error instanceof Error ? error.message : String(error);
+          // An adapter's pages plugin rescans page adds, removals and .md saves
+          // and logs the same page error, so log it once.
+          const adapterLogs =
+            message.startsWith('pages:') &&
+            isInDirectory(normalizedPath, normalizedPagesDir) &&
+            (event !== 'change' || normalizedPath.endsWith('.md')) &&
+            resolvedConfig?.plugins?.some((plugin) => plugin.name.endsWith(':pages')) === true;
+          if (!adapterLogs) {
+            devServer.config.logger.error(message, {
+              error: error instanceof Error ? error : undefined,
+              timestamp: true,
+            });
+          }
+          return;
+        }
         resolveAuthCompileOptions();
         const shouldRestartForAssetRouting =
           event !== 'change' &&
diff --git a/packages/void/src/router/scan.ts b/packages/void/src/router/scan.ts
index 32f648717..981938b7b 100644
--- a/packages/void/src/router/scan.ts
+++ b/packages/void/src/router/scan.ts
@@ -75,10 +75,15 @@ export async function scanRoutes(
     output?: 'server' | 'static';
     paths: ProjectPaths;
     inventory: Omit<ScanResult, 'pages'>;
+    checkPageRoutes?: boolean;
   },
 ): Promise<ScanResult> {
   const { paths, inventory } = options;
-  const pages = await scanPages(root, { output: options.output, paths });
+  const pages = await scanPages(root, {
+    output: options.output,
+    paths,
+    checkRoutes: options.checkPageRoutes,
+  });
   const routes = inventory.routes
     .map((route) => ({
       ...route,
diff --git a/packages/void/test/unit/pages-manifest.test.ts b/packages/void/test/unit/pages-manifest.test.ts
index 333ce1df9..878203777 100644
--- a/packages/void/test/unit/pages-manifest.test.ts
+++ b/packages/void/test/unit/pages-manifest.test.ts
@@ -1,3 +1,4 @@
+import { Hono } from 'hono';
 import { describe, expect, it } from 'vite-plus/test';
 import { resolveLayoutIds } from '../../src/pages/layout-resolution.ts';
 import { generateComponentManifest } from '../../src/pages/manifest.ts';
@@ -7,6 +8,12 @@ import type {
   PageDefinition,
   PageScanResult,
 } from '../../src/pages/types.ts';
+import { decodePagePath } from '../../src/pages/url.ts';
+
+/** Look a URL up the way the navigation engine does. */
+function byUrl(matchRoute: (path: string) => string | null): (url: string) => string | null {
+  return (url) => matchRoute(decodePagePath(new URL(url, 'http://x').pathname));
+}
 
 function matchRouteFor(pattern: string): (url: string) => string | null {
   const page: PageDefinition = {
@@ -26,9 +33,7 @@ function matchRouteFor(pattern: string): (url: string) => string | null {
     { pages: [page], layouts: [], namedLayouts: [] },
     '/project/pages',
   );
-  return new Function('URL', `${source}\nreturn matchRoute;`)(URL) as (
-    url: string,
-  ) => string | null;
+  return byUrl(new Function(`${source}\nreturn matchRoute;`)() as (path: string) => string | null);
 }
 
 describe('generated Pages client route manifest', () => {
@@ -50,10 +55,10 @@ type GeneratedManifest = {
 
 function evaluateManifest(scan: PageScanResult): GeneratedManifest {
   const source = generateComponentManifest(scan, '/project/pages');
-  return new Function(
-    'URL',
+  const manifest = new Function(
     `${source}\nreturn { components, layoutTree, routeMeta, matchRoute };`,
-  )(URL) as GeneratedManifest;
+  )() as GeneratedManifest;
+  return { ...manifest, matchRoute: byUrl(manifest.matchRoute) };
 }
 
 function definePage(
@@ -175,4 +180,88 @@ describe('compact Pages route manifest', () => {
     );
     expect(source).not.toContain('/^');
   });
+
+  it('keeps a page in a "layout" folder apart from the layout beside it', () => {
+    const manifest = evaluateManifest({
+      pages: [
+        definePage('layout', '/layout', 'layout/index.tsx'),
+        definePage('blog/layout', '/blog/layout', 'blog/layout/index.island.tsx', {
+          island: true,
+        }),
+      ],
+      layouts,
+      namedLayouts: [],
+    });
+
+    expect(String(manifest.components.layout)).toContain('"/project/pages/layout/index.tsx"');
+    expect(String(manifest.components._layout)).toContain('"/project/pages/layout.tsx"');
+    expect(String(manifest.components['blog/layout'])).toContain(
+      '"/project/pages/blog/layout/index.island.tsx"',
+    );
+    expect(String(manifest.components['blog/_layout'])).toContain(
+      '"/project/pages/blog/layout.tsx"',
+    );
+    expect(manifest.layoutTree).toEqual({
+      layout: ['_layout'],
+      'blog/layout': ['_layout', 'blog/_layout'],
+    });
+    expect(manifest.routeMeta).toEqual({ 'blog/layout': { island: true } });
+    expect(manifest.matchRoute('/layout')).toBe('layout');
+  });
+
+  it('matches page file names that need URL encoding the same way as the server', async () => {
+    const staticPages = [
+      definePage('café', '/café', 'café.tsx'),
+      definePage('a b', '/a b', 'a b.tsx'),
+      definePage('100%', '/100%', '100%.tsx'),
+      definePage('50%25', '/50%25', '50%25.tsx'),
+      definePage('a+b', '/a+b', 'a+b.tsx'),
+      definePage('x/y', '/x/y', 'x/y.tsx'),
+    ];
+    const dynamicPages = [
+      definePage('blog/[slug]', '/blog/:slug', 'blog/[slug].tsx', { params: ['slug'] }),
+      definePage('café/[id]', '/café/:id', 'café/[id].tsx', { params: ['id'] }),
+      definePage('files/[...rest]', '/files/:rest{.+}', 'files/[...rest].tsx', {
+        params: ['rest'],
+        catchAll: true,
+      }),
+    ];
+    const rootSlug = definePage('[slug]', '/:slug', '[slug].tsx', { params: ['slug'] });
+    const urls = [
+      '/caf%C3%A9',
+      '/caf%c3%a9',
+      '/café',
+      '/a%20b',
+      '/100%',
+      '/100%25',
+      '/50%25',
+      '/50%2525',
+      '/a+b',
+      '/a%2Bb',
+      '/x%2Fy',
+      '/x/y',
+      '/caf%C3%A9/1',
+      '/blog/a%2Fb',
+      '/blog/%zz',
+      '/caf%C3',
+      '/files/a%0Ab',
+      '/abo%75t',
+      '/caf%C3%A9?q=%C3%A9#top',
+    ];
+    for (const pages of [
+      [...staticPages, ...dynamicPages],
+      [...staticPages, rootSlug, ...dynamicPages],
+    ]) {
+      const { matchRoute } = evaluateManifest({ pages, layouts: [], namedLayouts: [] });
+      const server = new Hono();
+      for (const page of pages) {
+        server.get(page.pattern, (c) => c.text(page.componentId));
+      }
+      for (const url of urls) {
+        const response = await server.request(url);
+        const expected = response.status === 200 ? await response.text() : null;
+        expect([url, matchRoute(url)]).toEqual([url, expected]);
+      }
+    }
+  });
 });
diff --git a/packages/void/test/unit/pages-scan.test.ts b/packages/void/test/unit/pages-scan.test.ts
index 9550b8949..61c11a5b3 100644
--- a/packages/void/test/unit/pages-scan.test.ts
+++ b/packages/void/test/unit/pages-scan.test.ts
@@ -814,6 +814,84 @@ const example = 'export const layout = "home"';
       }
     });
   });
+
+  describe('route clashes', () => {
+    it('throws once, listing every route that more than one page file resolves to', async () => {
+      writeFile('about.tsx', 'export default () => null;');
+      writeFile('about/index.tsx', 'export default () => null;');
+      writeFile('(a)/team.tsx', 'export default () => null;');
+      writeFile('(b)/team.tsx', 'export default () => null;');
+      writeFile('docs/x.tsx', 'export default () => null;');
+      writeFile('docs/x.vue', '<template><div /></template>');
+      writeFile('docs/y.tsx', 'export default () => null;');
+      writeFile('docs/y.island.tsx', 'export default () => null;');
+
+      await expect(scanPages(TMP)).rejects.toThrow(
+        [
+          'pages: Multiple page files resolve to the same route:',
+          '  "/about": "about.tsx", "about/index.tsx"',
+          '  "/docs/x": "docs/x.tsx", "docs/x.vue"',
+          '  "/docs/y": "docs/y.island.tsx", "docs/y.tsx"',
+          '  "/team": "(a)/team.tsx", "(b)/team.tsx"',
+          'Keep one page file per route and rename or remove the others.',
+        ].join('\n'),
+      );
+    });
+
+    it('throws when two page files on different routes get the same page id', async () => {
+      writeFile('index.tsx', 'export default () => null;');
+      writeFile('index/index.tsx', 'export default () => null;');
+
+      await expect(scanPages(TMP)).rejects.toThrow(
+        [
+          'pages: Multiple page files resolve to the same page id:',
+          '  "index": "index.tsx", "index/index.tsx"',
+          'Rename or remove one of them.',
+        ].join('\n'),
+      );
+    });
+
+    it('warns once about a dynamic page another page with the same shape hides', async () => {
+      const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+      try {
+        writeFile('shadow/[id].tsx', 'export default () => null;');
+        writeFile('shadow/[slug].tsx', 'export default () => null;');
+        const { pages } = await scanPages(TMP);
+        await scanPages(TMP);
+
+        expect(pages.map((page) => page.componentId)).toEqual(['shadow/[id]', 'shadow/[slug]']);
+        expect(log).toHaveBeenCalledOnce();
+        expect(log.mock.calls[0][0]).toContain(
+          "pages: Page 'shadow/[slug].tsx' (/shadow/:slug) is never used: 'shadow/[id].tsx' (/shadow/:id) matches the same URLs first. Remove one of them.",
+        );
+      } finally {
+        log.mockRestore();
+      }
+    });
+
+    it('allows the same param under different names on different routes', async () => {
+      const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+      try {
+        writeFile('users/[id].tsx', 'export default () => null;');
+        writeFile('users/[id]/edit.tsx', 'export default () => null;');
+        writeFile('users/[userId]/posts.tsx', 'export default () => null;');
+        writeFile('layout.tsx', 'export default ({ children }) => children;');
+        writeFile('layout/index.tsx', 'export default () => null;');
+
+        const { pages } = await scanPages(TMP);
+
+        expect(pages.map((page) => page.pattern).sort()).toEqual([
+          '/layout',
+          '/users/:id',
+          '/users/:id/edit',
+          '/users/:userId/posts',
+        ]);
+        expect(log).not.toHaveBeenCalled();
+      } finally {
+        log.mockRestore();
+      }
+    });
+  });
 });
 
 describe('resolveLayoutChain', () => {
diff --git a/packages/void/test/unit/plugin-routing.test.ts b/packages/void/test/unit/plugin-routing.test.ts
index e936a03dd..e5a920b80 100644
--- a/packages/void/test/unit/plugin-routing.test.ts
+++ b/packages/void/test/unit/plugin-routing.test.ts
@@ -41,12 +41,16 @@ function runConfig(plugin: RoutingPlugin, env: ConfigEnv): void {
   (getHookHandler(plugin.config) as (config: UserConfig, env: ConfigEnv) => unknown)({}, env);
 }
 
-function resolveConfig(plugin: RoutingPlugin, command: 'build' | 'serve'): void {
+function resolveConfig(
+  plugin: RoutingPlugin,
+  command: 'build' | 'serve',
+  plugins: Array<{ name: string }> = [],
+): void {
   (getHookHandler(plugin.configResolved) as (config: ResolvedConfig) => void)({
     build: { assetsDir: 'assets' },
     command,
     mode: command === 'build' ? 'production' : 'development',
-    plugins: [],
+    plugins,
   } as unknown as ResolvedConfig);
 }
 
@@ -58,8 +62,10 @@ function fakeDevServer(moduleIds: Array<string> = []) {
   const handlers = new Map<string, Array<(path: string) => Promise<void> | void>>();
   const invalidated: Array<string> = [];
   const restart = vi.fn(async () => {});
+  const logError = vi.fn();
   const modules = new Map(moduleIds.map((id) => [id, { id }]));
   const server = {
+    config: { logger: { error: logError } },
     watcher: {
       on(event: string, handler: (path: string) => Promise<void> | void) {
         handlers.set(event, [...(handlers.get(event) ?? []), handler]);
@@ -85,7 +91,7 @@ function fakeDevServer(moduleIds: Array<string> = []) {
       await handler(path);
     }
   }
-  return { server, invalidated, restart, emit };
+  return { server, invalidated, restart, emit, logError };
 }
 
 function startDevServer(plugin: RoutingPlugin, moduleIds?: Array<string>) {
@@ -293,6 +299,42 @@ describe('routingPlugin', () => {
     expect(invalidated).toEqual(PAGE_MODULE_IDS);
   });
 
+  it.each([
+    ['logs it', [], 1],
+    ['leaves the log to the adapter pages plugin', [{ name: 'void-react:pages' }], 0],
+  ])(
+    'keeps the last route table when a page added in dev clashes, and %s',
+    async (_, plugins, logs) => {
+      const root = createTempRoot();
+      mkdirSync(join(root, 'pages', 'about'), { recursive: true });
+      const flatPath = join(root, 'pages', 'about.tsx');
+      writeFileSync(flatPath, 'export default function About() { return null; }');
+
+      const plugin = createRoutingPlugin(root, { isAuthEnabled: () => false });
+      resolveConfig(plugin, 'serve', plugins);
+      const { emit, invalidated, logError } = startDevServer(plugin, PAGE_MODULE_IDS);
+
+      // Moving about.tsx to about/index.tsx adds the new file before the old one goes.
+      const indexPath = join(root, 'pages', 'about', 'index.tsx');
+      writeFileSync(indexPath, 'export default function About() { return null; }');
+      await emit('add', indexPath);
+
+      expect(logError).toHaveBeenCalledTimes(logs);
+      if (logs) {
+        expect(logError.mock.calls[0][0]).toContain(
+          'pages: Multiple page files resolve to the same route:',
+        );
+      }
+      expect(invalidated).toEqual([]);
+
+      rmSync(flatPath);
+      await emit('unlink', flatPath);
+
+      expect(logError).toHaveBeenCalledTimes(logs);
+      expect(invalidated).toEqual(PAGE_MODULE_IDS);
+    },
+  );
+
   it('does not invalidate page renderer modules for component-only page saves', async () => {
     const root = createTempRoot();
     mkdirSync(join(root, 'pages'), { recursive: true });
diff --git a/packages/void/test/unit/scan.test.ts b/packages/void/test/unit/scan.test.ts
index 0e8bc489e..b572b778c 100644
--- a/packages/void/test/unit/scan.test.ts
+++ b/packages/void/test/unit/scan.test.ts
@@ -28,6 +28,25 @@ describe('scanRoutes', () => {
     rmSync(TMP, { recursive: true, force: true });
   });
 
+  it.each([
+    ['a Void Pages app', {}, true],
+    ['a Nuxt app, whose pages/ nests routes', { nuxt: '1.0.0' }, false],
+  ])('checks page routes in %s', async (_, dependencies, throws) => {
+    createFile('package.json', JSON.stringify({ dependencies }));
+    createFile('pages/users.vue', '<template><NuxtPage /></template>');
+    createFile('pages/users/index.vue', '<template><div /></template>');
+
+    const scan = scanRoutes(TMP);
+    if (throws) {
+      await expect(scan).rejects.toThrow('pages: Multiple page files resolve to the same route:');
+    } else {
+      expect((await scan).pages.pages.map((page) => page.componentPath).sort()).toEqual([
+        'users.vue',
+        'users/index.vue',
+      ]);
+    }
+  });
+
   it('discovers route files with methods from exports', async () => {
     createFile('routes/api/hello.ts', 'export const GET = () => {}');
     createFile(
diff --git a/platform/packages/api/src/admin/react/AdminNavigationFallback.tsx b/platform/packages/api/src/admin/react/AdminNavigationFallback.tsx
index 3fa418dbc..4a0abce1f 100644
--- a/platform/packages/api/src/admin/react/AdminNavigationFallback.tsx
+++ b/platform/packages/api/src/admin/react/AdminNavigationFallback.tsx
@@ -38,7 +38,8 @@ const TITLES: Partial<Record<AdminPageId, string>> = {
 
 export function AdminNavigationFallback({ initialPageData }: { initialPageData: PageObject }) {
   const navigation = useNavigation();
-  const path = navigation.location?.pathname ?? initialPageData.url;
+  const path =
+    navigation.location?.pathname ?? new URL(initialPageData.url, 'https://void.invalid').pathname;
   const title = TITLES[matchAdminRoute(path) ?? 'adminError'] ?? 'Admin';
   const platformName = String(initialPageData.props.platformName ?? 'Void');
   const username =
diff --git a/platform/packages/api/src/admin/react/pages.ts b/platform/packages/api/src/admin/react/pages.ts
index 74cb2e31b..59cb0144f 100644
--- a/platform/packages/api/src/admin/react/pages.ts
+++ b/platform/packages/api/src/admin/react/pages.ts
@@ -77,8 +77,8 @@ export const adminLayoutTree: Record<AdminPageId, Array<string>> = Object.fromEn
     .map((name) => [name, ['adminLayout']]),
 ) as Record<AdminPageId, Array<string>>;
 
-export function matchAdminRoute(url: string): AdminPageId | null {
-  const path = new URL(url, 'https://void.invalid').pathname;
+/** Page id for a decoded pathname, as the Pages navigation engine passes it. */
+export function matchAdminRoute(path: string): AdminPageId | null {
   if (path === '/admin/connected-apps') {
     return 'connectedApps';
   }