@@ -25,7 +25,7 @@ import {
 } from 'h3'
 import type { H3Event } from 'h3'
 import { useNitroApp, useRuntimeConfig as useNitroRuntimeConfig } from 'nitropack/runtime'
-import { joinURL } from 'ufo'
+import { decodePath, joinURL } from 'ufo'
 import type { AppRouteRules, RuntimeConfig } from 'nuxt/schema'
 import type { EventHandler, ForwardedOptions, NuxtErrorLike, NuxtServerHooks, NuxtServerRendererHooks, ServerFetchInit, ServerHookable } from 'nuxt/server'
 
@@ -226,33 +226,56 @@ export function getRouterParam (event: H3Event, name: string, options?: { decode
 function getEncodedParams (event: H3Event): Record<string, string | undefined> {
   const params = event.context.params || {}
   const route = (event.context.matchedRoute as { path?: string } | undefined)?.path
-  if (!route) {
+  const url = event.node.req.originalUrl || event.node.req.url || ''
+  const query = url.includes('?') ? url.slice(url.indexOf('?')) : ''
+  if (!route || !event.path.endsWith(query)) {
     return params
   }
-  const pattern = route.split('/')
-  const decoded = event.path.split('?')[0]!.split('/')
-  const raw = (event.node.req.originalUrl || event.node.req.url || '').split('?')[0]!.split('/')
-  const offset = raw.length - decoded.length
-  if (offset < 0 || (pattern.length !== decoded.length && !pattern.some(segment => segment.startsWith('**')))) {
+  const raw = url.slice(0, url.length - query.length).split('/')
+  const decoded = event.path.slice(0, event.path.length - query.length)
+  const offset = raw.length - decoded.split('/').length
+  if (offset < 0) {
     return params
   }
+  // h3 routes the path up to its first `?`, which can be a decoded `%3F`, without one trailing slash
+  const end = decoded.indexOf('?')
+  const matched = (end === -1 ? decoded : decoded.slice(0, end)).split('/')
+  const last = matched.length - 1
+  if (last > 1 && matched[last] === '') {
+    matched.pop()
+  }
+  const segments = raw.slice(offset, offset + matched.length)
+  if (end !== -1 && last < segments.length) {
+    segments[last] = segments[last]!.replace(ENCODED_QUERY_RE, '')
+  }
   const encoded: Record<string, string | undefined> = { ...params }
   let unnamed = 0
-  for (let index = 0; index < pattern.length; index++) {
-    const segment = pattern[index]!
-    if (segment.startsWith('**')) {
-      encoded[segment.slice(3) || '_'] = raw.slice(offset + index).join('/')
-      break
+  for (const [index, segment] of route.split('/').entries()) {
+    const catchAll = segment.startsWith('**')
+    const name = catchAll ? segment.slice(3) || '_' : segment === '*' ? `_${unnamed++}` : segment.startsWith(':') ? segment.slice(1) : undefined
+    if (name === undefined) {
+      continue
+    }
+    const value = catchAll ? segments.slice(index).join('/') : segments[index]
+    if (value === undefined || decodeH3Path(value) !== params[name]) {
+      return params
     }
-    if (segment === '*') {
-      encoded[`_${unnamed++}`] = raw[offset + index]
-    } else if (segment.startsWith(':')) {
-      encoded[segment.slice(1)] = raw[offset + index]
+    encoded[name] = value
+    if (catchAll) {
+      break
     }
   }
   return encoded
 }
 
+const ENCODED_QUERY_RE = /%3f[\s\S]*$/i
+const ENCODED_PERCENT_RE = /%25/g
+
+/** Decodes a path the way h3 v1 does before routing, keeping `%25` and `%2F` encoded. */
+function decodeH3Path (path: string): string {
+  return decodePath(path.replace(ENCODED_PERCENT_RE, '%2525'))
+}
+
 /** @see {@link import('nuxt/server').readBody} */
 export function readBody<T = unknown> (event: H3Event): Promise<T> {
   return readH3Body(event) as Promise<T>
 
@@ -6,7 +6,8 @@ import { rollup } from 'rollup'
 import { build } from 'tsdown'
 import tsdownConfig from '../tsdown.config.ts'
 import { resolveModuleExportNames } from '@nuxt/kit/internal'
-import { createEvent } from 'h3'
+import fc from 'fast-check'
+import { createApp, createEvent, createRouter, eventHandler, toPlainHandler } from 'h3'
 import type { H3Event } from 'h3'
 import * as shipped from '../../nuxt/src/server/index.ts'
 import type { RequestEvent } from '../../nuxt/src/server/index.ts'
@@ -133,6 +134,70 @@ describe('the shape of what it reads off an h3 v1 event', () => {
     expect(delegate.getRouterParams(e)).toEqual({ id: 'a b' })
   })
 
+  describe.each(['/', '/base/'])('router params routed by h3 under %s', (base) => {
+    const router = createRouter({ preemptive: true })
+    for (const route of ['/api/auth/**:slug', '/api/users/:id', '/api/users/:id/**:rest', '/api/items/*/x']) {
+      router.use(route, eventHandler(event => ({
+        matched: event.context.params,
+        params: delegate.getRouterParams(event),
+        decoded: delegate.getRouterParams(event, { decode: true }),
+      })))
+    }
+    const app = createApp()
+    app.use(base, router.handler)
+    const handle = toPlainHandler(app)
+
+    async function request (path: string) {
+      const response = await handle({ method: 'GET', path: base.slice(0, -1) + path, headers: {} })
+      expect(response.status).toBe(200)
+      return JSON.parse(response.body as string) as Record<'matched' | 'params' | 'decoded', Record<string, string>>
+    }
+
+    it.for([
+      ['/api/auth/private%3Fignored/public', { slug: 'private' }],
+      ['/api/auth/private%3fignored/public', { slug: 'private' }],
+      ['/api/auth/a/b%3F/c', { slug: 'a/b' }],
+      ['/api/auth/a/%3Fb/c', { slug: 'a' }],
+      ['/api/auth/a%3Fb?c=%3F/d', { slug: 'a' }],
+      ['/api/auth/a%253Fb/c', { slug: 'a%253Fb/c' }],
+      ['/api/auth/a%23b/c', { slug: 'a%23b/c' }],
+      ['/api/auth/a%2Fb/c', { slug: 'a%2Fb/c' }],
+      ['/api/auth/a%2F%3Fb/c', { slug: 'a%2F' }],
+      ['/api/auth/caf%C3%A9/', { slug: 'caf%C3%A9' }],
+      ['/api/auth/a//', { slug: 'a/' }],
+      ['/api/auth/a%20b?x=1', { slug: 'a%20b' }],
+      ['/api/users/a%3Fb', { id: 'a' }],
+      ['/api/users/a%20b/', { id: 'a%20b' }],
+      ['/api/users/a%20b/c%3F/d', { id: 'a%20b', rest: 'c' }],
+      ['/api/users/a%3F/b/c', { id: 'a' }],
+      ['/api/items/a%2Fb/x', { _0: 'a%2Fb' }],
+      ['/api/items/a%23b/x?y', { _0: 'a%23b' }],
+    ] as const)('reads %s as h3 matched it', async ([path, params]) => {
+      const { matched, params: encoded, decoded } = await request(path)
+      expect(encoded).toEqual(params)
+      for (const key in matched) {
+        expect(decoded[key]).toBe(shipped.getRouterParam({ context: { params: matched } }, key, { decode: true }))
+      }
+    })
+
+    it('reads the same params h3 matched for any path', async () => {
+      const segment = fc.array(fc.constantFrom('a', 'é', '%20', '%3F', '%3f', '%23', '%2F', '%25', '%253F', '%2525', '%C3%A9', '?', '#', ''), { maxLength: 4 }).map(parts => parts.join(''))
+      const prefix = fc.constantFrom('/api/auth/', '/api/users/', '/api/items/')
+      await fc.assert(fc.asyncProperty(prefix, fc.array(segment, { minLength: 1, maxLength: 4 }), async (prefix, segments) => {
+        const path = prefix + segments.join('/')
+        const response = await handle({ method: 'GET', path: base.slice(0, -1) + path, headers: {} })
+        if (response.status !== 200) {
+          return
+        }
+        const { matched, params, decoded } = JSON.parse(response.body as string)
+        expect(decoded).toEqual(shipped.getRouterParams({ context: { params: matched } }, { decode: true }))
+        for (const value of Object.values(params)) {
+          expect(path).toContain(value)
+        }
+      }))
+    })
+  })
+
   it('reads the client IP from the socket, and the first forwarded hop only when opted in', () => {
     const e = event('/', { headers: { 'x-forwarded-for': '203.0.113.1, 10.0.0.1' }, ip: '198.51.100.7' })
     expect(delegate.getRequestIP(e)).toBe('198.51.100.7')
 
@@ -153,6 +153,9 @@ describe.skipIf(!runsOnceInMatrix)('server api', () => {
       decoded: 'a b%2Fc',
       forwardedIP: '203.0.113.1',
     })
+
+    const truncated = await fetch('/api/portable-extras/a%3Fpage=2/c')
+    expect(await truncated.json()).toMatchObject({ params: { id: 'a' }, decoded: 'a' })
   })
 
   it('should answer a CORS preflight with `nuxt/server`', async () => {