nuxt
4.6.4 · 2 Nov 2026MIT3.6M / weekRepositoryHomepagenpmAtom feed
4.6.4 is the newest release of 4.x.
In short
3 security1 deprecated65 new13 faster104 fixed5 changed117 internal
- Deprecated
schema: deprecate
nitro.*options duplicated at the top level
Security
Fixes 1 advisory that affected 4.5.2
- LowNuxt: Incomplete fix for GHSA-934w-87qh-qr26: a `javascript:` URL prefixed with an ASCII control character executes from `<NuxtLink>` when `pages` is disabledGHSA-jjm6-p2m9-9w4x · 22 Oct 2026Fixed in 4.6.0
7 advisories affect 4.6.0; 4.6.4 fixes the others
- ModerateNuxt exposes the message and data of unhandled errors thrown during server renderingGHSA-96x6-fvhx-49hg · 16 Nov 2026No fix yet
- ModerateNuxt: Incomplete fix for GHSA-6gq8-jgmh-3ffp: an encoded slash (`%2F`) in the request path bypasses route rules on catch-all page routesGHSA-f3x9-2chm-73c8 · 16 Nov 2026No fix yet
- ModerateNuxt: Server-side route rules (`redirect`, `headers`, `proxy`, `ssr`) are skipped for case-variant paths when routing is case-insensitiveGHSA-vjh5-4x84-xrqp · 22 Oct 2026No fix yet
- LowNuxt: Colliding island props can share one `/__nuxt_island` path (incomplete fix for CVE-2026-46342)GHSA-hf59-9xwc-2g4p · 16 Nov 2026No fix yet
- ModerateNuxt payload URL generation has quadratic cost for repeated slashes in the request pathGHSA-r9jc-w898-3fv6 · 16 Nov 2026Fixed in 4.6.4
2 more
- ModerateNuxt: Dot segments in the request path bypass `server/middleware` path checks and server route rules on page routesGHSA-9v7c-q64q-vv33 · 30 Oct 2026Fixed in 4.6.3
- ModerateNuxt server islands render `useHeadSafe` input without sanitisationGHSA-xfq5-w38q-pc2x · 22 Oct 2026Fixed in 4.6.2
Release note
The section about nuxt of a note shared by several packages.
v4.6.0 is the next minor release.
Some news
Nuxt CLI v4
Alongside the release of Nuxt v4.6, today also brings a new major release of the Nuxt CLI: @nuxt/cli v4. It ships as a dependency of nuxt, so you'll get it automatically when you upgrade.
Most of what's new is in nuxt dev:
an interactive terminal UI, showing URLs, startup progress and keyboard shortcuts, with panels to dive into error logs, routes, network requests and more
the dev server gives you more info, such as why it reloaded or restarted, which
nuxt.configkeys changed, where the time went during a slow start or build, and how long each module took to set up
There's also a new nuxt docs "<query>" search, and nuxt preview --takeover can replace a running preview server. And in general nuxt/cli is a lot smaller and starts a lot faster:
| v3.37 | v4.0 | ||
|---|---|---|---|
@nuxt/cli install size | 13.1 MB | 3.5 MB | -73% |
@nuxt/cli dependencies | 70 | 31 | -56% |
nuxt dev: first paint | 330 ms | 50 ms | 6.6x faster |
nuxt dev: port bound | 338 ms | 104 ms | 3.2x faster |
nuxt dev: memory at rest (Linux) | 630 MB | 440 MB | -30% |
Although this is a major version, none of the changes should be breaking for Nuxt v4 users: we require Node.js v22.21+, v24.11+ or v26+, we drop nuxt init and only support npm create nuxt@latest, and Nuxt 2 and @nuxt/bridge are no longer supported.
👉 Check out the full Nuxt CLI v4 release notes for everything that's changed.
A server-agnostic Nuxt
The biggest thing about this release is our move towards making Nuxt server-agnostic.
I feel that freedom of choice is very much a fundamental value of the web, and one that unites the whole Nuxt team.
You can use pages/ (with vue-router) or not. You can use Vite, webpack or Rspack to bundle your code. You can pick from dozens of providers to deploy to, pick any image or font provider, choose any database adapter. In every case, the framework is the same.
The server side was different. #app composables imported h3 types, server code imported from h3 and nitropack, and every module that touched the server was tied to whichever major version of those packages Nuxt happened to depend on.
This has become particularly clear as we have been upgrading to new majors of h3 and nitro, which ship breaking changes with a cascading effect throughout the whole ecosystem.
👉 This release changes that.
Alongside explicitly defining our public API in nuxt/kit (which now does not refer to external packages), Nuxt now specifies our own types for the request event, route rules and typed $fetch, and we expose an import surface (nuxt/server) for the server utilities that will be needed by most apps.
This is the culmination of work we started almost a year ago, making it possible to use any server builder with Nuxt, not just Nitro (#33462).
Of course, under the hood, nuxt/server is still powered by Nitro by default - though we are also announcing a second, experimental implementation, @nuxt/vite-server, which allows pure-Vite server builds using the Vite Environment API.
Important
We believe that Nitro is still the right choice for almost everyone.
🌟 We see a number of key benefits for nuxt/server.
it smooths the upgrade to Nuxt 5, which moves to Nitro v3 and h3 v2. Server code written against
nuxt/serveron 4.6 runs unchanged there, so a module can ship one file for both.it decouples Nuxt from the Nitro release cycle. Because we 'own' the API, we can adapt to breaking changes in Nitro or h3 without requiring a future major - and we can release Nuxt majors without having to wait for upstream releases.
it makes Nuxt's code more maintainable. It helps us preserve the separation of concerns between our API -
/appand/server- and the bundler + server that you ultimately want to build your app.
... and there are a number of other benefits too, from a single type surface to being able to iterate more quickly on features.
Finally, I want to say a special thank-you to @pi0, whose relentless focus on server agnosticism and work on h3, Nitro and web-standard server primitives over the last few years is what makes a portable RequestEvent possible at all. Thank you, Pooya. ❤️
Almost every feature in this release is already in the Nuxt 5 branch, and most of the remaining Nuxt 5 defaults can be tested today with future.compatibilityVersion: 5 (more details below!).
Tip
Nuxt 3 reached end-of-life on July 31, 2026, so there is no 3.x release alongside this one. If you're still on v3, the upgrade guide is waiting for you.
Highlights
🤷 If you've read this far I'm afraid I have bad news for you: there's a lot more still to say! Nuxt 4.6 is one of our biggest minor releases, with over 420 commits since v4.5.2.
... so, you might want to grab a coffee! ☕️
nuxt/server
It has been asked for for a long time, and it now exists (#36275)!
nuxt/server is a new import source for server code: handlers, middleware and utilities - a complement to nuxt/app. Where nuxt/app is for the part of your application that also runs in the browser, nuxt/server is for the part that only runs on the server.
import { defineEventHandler, getQuery } from 'nuxt/server'
export default defineEventHandler((event) => {
const { name } = getQuery<{ name?: string }>(event)
return { message: `Hello, ${name ?? 'world'}!` }
})The utilities use web standards and are typed against a portable RequestEvent:
event.req // Request
event.url // URL
event.res // { status, statusText, headers }
event.res.headers // Headers
event.context // per-request contextUnder @nuxt/nitro-server they are backed by Nitro and h3, but you never import from either.
So the same handler runs under Nitro v2, Nitro v3 or @nuxt/vite-server, and a module that imports from nuxt/server doesn't need a peer dependency on h3 or nitropack.
We think this will make a big difference in smoothing out the upgrade to Nuxt v5 and Nitro v3.
There is a typing benefit too. We no longer hoist h3 or Nitro types into your app to type useRequestEvent, $fetch or route rules, which removes a source of type conflicts when versions differ (#36212, #36214, #36293).
The surface is small, and covers what published modules and user code typically need: defineEventHandler, createError/isNuxtError, request URL, headers, query, body (plain and validated with any Standard Schema library or a function), cookies, redirects, response status, getRouterParam(s), getRequestIP, handleCors, getRouteRules, useRuntimeConfig, useAppConfig and sessions.
import { defineEventHandler, readValidatedBody } from 'nuxt/server'
import { z } from 'zod'
export default defineEventHandler(async (event) => {
const user = await readValidatedBody(event, z.object({ name: z.string() }))
return { created: user.name }
})We encourage you to use web APIs (event.req.headers, for example), or raise an issue if there's functionality you're missing from nuxt/server 🙏
If you do need to step outside nuxt/server for a particular handler, don't worry! Nothing has been taken away: import defineEventHandler and the helpers you need from h3 or nitropack/runtime as before, and that handler works exactly as it did on Nuxt 4.5.
import { defineEventHandler, readMultipartFormData } from 'h3'
export default defineEventHandler(async (event) => {
const parts = await readMultipartFormData(event)
return { received: parts?.length ?? 0 }
})Important
On Nuxt 4, the auto-imported defineEventHandler, getQuery, readBody and the rest are still h3's own helpers, which take a different shape of event. Import from nuxt/server explicitly, including defineEventHandler to use the new server runtime. If you mix the two, you'll see a NUXT_E8012 error which should tell you which import to change.
A few helpers also behave differently from their h3 v1 namesakes: sendRedirect returns the response rather than sending it, createError takes status and statusText, and response headers are set through event.res.headers. The upgrade guide has a table of the differences.
Nothing in this release requires a migration. But if you have server code you'd like to make portable ahead of Nuxt 5, this is the best way.
👉 Read the server imports guide.
appSecret and sessions
Nuxt now has a root application secret: runtimeConfig.appSecret, set with NUXT_APP_SECRET (#35874, thanks to @onmax). Modules and server features derive purpose-specific secrets from it with deriveSecret(purpose), so NUXT_APP_SECRET is the only secret you need to configure.
openssl rand -base64 32
In development Nuxt generates and persists one if none is configured (and warns the first time a derived secret is used). Builds never generate one.
The first thing to use it is a set of session helpers in nuxt/server (#36358). Sessions are sealed into a cookie with iron, so there's no server-side storage to configure:
import { defineEventHandler, useSession } from 'nuxt/server'
export default defineEventHandler(async (event) => {
const session = await useSession<{ visits: number }>(event)
await session.update(data => ({ visits: (data.visits ?? 0) + 1 }))
return { visits: session.data.visits }
})Note
As a reminder, runtime config keys prefixed with app (runtimeConfig.app, runtimeConfig.appSecret) are reserved for Nuxt.
Typed $fetch, rebuilt
$fetch and useFetch have been typed from your server routes for a long time. But the types were derived from Nitro's InternalApi interface, and past a few hundred routes they hit TypeScript's instantiation limit with the familiar TS2589: Type instantiation is excessively deep and possibly infinite.
We've rebuilt typed fetch on top of fetchdts (#36238). Nuxt compiles your server routes into a route tree with an exact-match table for static paths and accessors specialised to your route set. Resolution cost now scales with call sites, not with route count:
| routes | before | after |
|---|---|---|
| 100 | 1,397,361 instantiations / 0.77s | 51,558 / 0.26s |
| 300 | 5,774,425 / 3.49s (TS2589) | 51,558 / 0.16s |
| 1000 | 12,831,467 / 7.44s (TS2589) | 51,558 / 0.20s |
| 3000 (200 call sites) | 71,875,148 / 53.63s (TS2589) | 101,678 / 0.62s |
Peak memory for the same runs dropped from 946 MB to 140 MB. 🔥
Plus, the route set also carries the body, query and headers a handler validates, so calls are checked more tightly than before:
// server/api/users.post.ts validates { title: string, count: number }
await $fetch('/api/users', { method: 'post', body: { title: 'a', count: 1 } })
await $fetch('/api/users', { method: 'post', body: { title: 'a', count: 'no' } })
// ^ not assignable to number
await $fetch('/api/users', { method: 'post' })
// ^ body is requiredOn Nuxt 4 this is opt-in, because there are small changes to type inference, and hand-written ServerRoutes augmentations need a small rewrite. It is the default in Nuxt 5.
export default defineNuxtConfig({
experimental: {
routeTypedFetch: true,
},
})There's also a new experimental.strictRouteTypes option to reject calls to paths that don't exist (otherwise these just return unknown), and an 'isomorphic' mode that types your pages as GET routes too if you want to be able to $fetch from the Vue renderer with type safety.
👉 Read more in the experimental features docs.
Better errors in development with my-bad
Server-side errors in development used to look like this:
ReferenceError: foo is not defined
at Object.<anonymous> (/_nuxt/app/pages/index.vue:1:1)There was no source position or code frame, and the Youch iframe we rendered could not show you the frame in your own source either. Both are now fixed (#36258, nuxt/cli#1518).
Dev SSR stack traces are now mapped before anything reads the error, and the Youch overlay has been replaced with my-bad. It renders into your app's own error page as an overlay (or as a standalone page when the app can't render one), with the mapped stack trace and a code frame from your source, and the same report is printed in your terminal. We are still working with @atinux, @HugoRCD and @antfu to make these pages nicer still.
With Nuxt CLI v4, there is a single live error channel at the CLI level. It survives worker restarts, so (for example) a syntax error in nuxt.config.ts will live-reload the page once you fix it. Each error is rendered once rather than at every layer it passes through, and the same channel streams build progress and app logs to the dev panel.
A new loading screen, 404 and error pages
@HugoRCD has redrawn the loading screen you see while the dev server starts. It is now a WebGL2 particle field that traces a mountain range behind the Nuxt lockup (#36178), using a single shader and a single draw call. Without WebGL2 it falls back to the static lockup, and with prefers-reduced-motion the animation stops. Try hovering over it. 🏔️
Hugo also gave the built-in 404 and error pages a neutral palette and lighter type (#36255), and @MirkoJa added a back button to the 404 page (#35688).
Vue Vapor support
Nuxt now supports Vue 3.6's Vapor Mode in interop mode (#35759). Your app root stays on the virtual DOM, and you can opt individual components or pages into Vapor by adding the vapor attribute to <script setup>:
export default defineNuxtConfig({
vue: {
vapor: true,
},
})<script setup vapor lang="ts">
const count = ref(0)
</script>
<template>
<button @click="count++">
count is {{ count }}
</button>
</template>Routing, useAsyncData, layouts and most built-in components keep working unchanged. Along the way we made the auto-import loader, useAsyncData, definePageMeta and slot inspection Vapor-aware, and we now have a Vapor test suite so we can track what's supported.
Note
This requires Vue ^3.6.0-rc.2 or newer. See the known limitations and try it in a fresh project first.
Addons for useFetch and useAsyncData
@cernymatej has added an addons option to the createUseFetch and createUseAsyncData factories (#35797). An addon can declare custom call-site options, adjust the merged options, wrap the handler with middleware, and extend what the composable returns, and it can be reused across as many custom instances as you like.
const refreshOnFocus = defineUseFetchAddon({
setup: (options: UseFetchAddonOptions<{ refreshOnFocus?: boolean }>) => {
if (import.meta.server || !options.refreshOnFocus) { return }
return (asyncData) => {
const focused = useWindowFocus()
watch(focused, focused => focused && asyncData.refresh())
return { focused }
}
},
})
export const useApiFetch = createUseFetch({ baseURL: '/api', addons: [refreshOnFocus] })<script setup lang="ts">
const { data, focused } = await useApiFetch('/todos', { refreshOnFocus: true })
</script>This resolves a long list of feature requests for useAsyncData and useFetch (refresh on focus, polling, retries, auth headers and more) without making the core composables opinionated about any of them.
👉 Read about defineUseFetchAddon and defineUseAsyncDataAddon.
Performance
There is a lot of performance work in this release.
<NuxtLink>renders 58% faster on the server (#36015). Internal links are now rendered as a plain<a>with nouseLink, no computed and no reactive state. Rendering 200 links went from 1.36ms to 0.57ms, which is 1.4x faster than a bare<RouterLink>.ssr: falsepages are tree-shaken from the server bundle (#35836, thanks to @Austin1serb).Serializable
definePageMetakeys are extracted at build time (#35919), behindexperimental.extractSerializablePageMeta.Lazy impound tracing for builds (#36172), virtual module hooks filtered by id (#36077),
isVuechecks migrated to plugin filters (#36116) and anflruprerender cache (#36340).
Put together, on our benchmark machine (arm64 Linux, Node 24.15, medians of 5 runs):
| v4.5.2 | v4.6.0 | ||
|---|---|---|---|
@nuxt/kit install size | 6.4 MB | 2.1 MB | -67% |
@nuxt/kit transitive dependencies | 36 | 22 | -39% |
nuxt build, starter | 4.4 s | 3.6 s | -18% |
nuxt build, 200 pages / 200 components / 50 routes | 11.6 s | 10.3 s | -11% |
SSR throughput, page with 300 <NuxtLink>s | 110 req/s | 140 req/s | +26% |
Dev server start-up (spawn to first HTML) on the same machine is about 12% faster on a starter app, with the second request served in roughly half the time, though the CLI major changed alongside so not all of that is Nuxt.
Lighter payloads
useAsyncData and useFetch accept a serialize: false option to keep data out of the __NUXT_DATA__ payload (#35779). That's most useful inside components that never hydrate, and experimental.stripNeverHydratedData applies it automatically to data fetched within hydrate-never component trees.
Nuxt also warns in development when a page's payload exceeds 100 kB (#35777) and when a route rendered with noScripts relies on client-side JavaScript (#35780), and noScripts pages keep their non-script resource hints and attach their styles correctly (#35803, #36356, #36359).
<NuxtLink> now prefetches server-page islands (#35808), and @atinux made prefetch hints throttled and prioritised so a page full of links doesn't flood the network (#36261, #36324). Building on that, route chunks, layouts, middleware, payloads, islands and resource hints all now go through one client prefetch scheduler with per-kind concurrency caps, deduplication by key, and cancellation of in-flight work when you navigate away (#36391).
Nuxt 5 features, today
Most of what's new in Nuxt 5 is already in 4.6, either as the default or behind a flag. future.compatibilityVersion: 5 turns on the Nuxt 5 defaults in one go, and every one of them can be enabled (or disabled) individually.
export default defineNuxtConfig({
future: {
compatibilityVersion: 5,
},
})Newly gated behind the flag in this release:
Typed
$fetch(experimental.routeTypedFetch), described aboveCase-sensitive routing, matching Nitro (#35650, thanks to @Mateleo)
Early return from
navigateTo(experimental.navigateToEarlyReturn):navigateToin<script setup>short-circuits the rest of the setup, so redirects and 404s don't throw on missing dataNormalized page names,
clearNuxtStateresetting to defaults,experimental.watcher: 'builder', and no auto-imported server-only head composablesNo
baseUrlin generated tsconfigs (#36040, thanks to @oritwoen)
The upgrade guide now lists exactly what the flag changes on Nuxt 4.
Experimental: @nuxt/vite-server
Since v4.2 server.builder has been configurable. This release adds a second server builder: @nuxt/vite-server. It builds a Nuxt app with Vite alone (#36218, #36279, #36288).
This is all you need to do to configure it.
export default defineNuxtConfig({
server: {
builder: 'vite', // 'nitro' is the default
},
})It can produce a pure client SPA, a server-rendered app with a small Node entry, a web-standard fetch handler for platforms that provide the server (there are e2e examples for Cloudflare Workers, Netlify and universal deploy), as well as fully static output with nuxt generate.
Right now, this helps keep Nuxt's code agnostic, enforce the contract behind nuxt/server, and to give Vite plugins that provide a deploy target something to build on. It does not have Nitro's full feature set (there is no storage, caching, tasks or server plugins), and we expect most apps to keep using Nitro. Nitro remains the default.
Warning
This is highly experimental and the API will change. 'nitro' and 'vite' are new shorthands for @nuxt/nitro-server and @nuxt/vite-server.
Developer experience
app/types/andserver/types/are included in the right tsconfig, so ambient types and augmentations placed there are picked up (#35783, thanks to @Flo0806, who also added an augmentableNuxtPageMetafor typingNuxtPage.metain #34816).Grouping folders in
components/: a(group)/folder is excluded from the component name (#35699, thanks to @abaza738).Dynamic
expiresinuseCookie, accepting a function (#35628, thanks to @DarlanPrado).A warning when a
public/file shadows an application route (#35674, thanks to @Norbiros).$Fetchis exported fromnuxt/app(#35625) andShallowRefis in the Vue auto-import preset (#36266), both from @DamianGlowala;preloadComponentsand theNuxtIslandnameprop are typed (#35775), anduseLayout,useLoadingIndicatoranduseRequestHeaderare exported fromnuxt/app(#36033).typescript.tsConfigis now a shared baseline for all four generated tsconfigs, withappTsConfigandserverTsConfigfor per-context overrides (#35697, thanks to @chairulakmal).Top-level
prerenderoption, an alias fornitro.prerenderin the same wayruntimeConfigandrouteRulesare top-level (#32356). Nuxt now also points you towards top-level options where they exist, since those work across server builders (#36416).Links to
public/files just work. If the router has no route for a<NuxtLink>target (a PDF inpublic/, say, or a link from Markdown with Nuxt Content), Nuxt falls through to a full-page load instead of rendering your 404, soexternalis no longer required (#36169).Renaming a component in development refreshes its imports, so you no longer see stale references to the old file (#36165, thanks to @oritwoen).
For module authors
If you maintain a module with server code, we've enabled making modules compatible with both Nuxt 4 & 5, without requiring a major bump. (And we'll be opening PRs proactively after the release of Nuxt v4.6 to assist with preparing for a Nuxt v5 release...)
Nuxt-owned, augmentable server types:
ServerTypes,ServerRoutes,AppRouteRulesandNuxtRequestContext. Augment@nuxt/schemaonce;nuxt/schemamirrors it (#36293).useTerminalfor host-aware prompts, status messages and tasks in progress, rendered by the CLI's dev panel when there is one (#36162).module:beforeandmodule:donehooks, which Nuxt CLI v4 uses to show per-module setup time as it happens (#36173).onConfigResolvedanddiffNuxtConfigto see what changed between two config loads (#35853).ensureDependencyInstalledandgetAddDependencyCommandto check for and offer to install optional dependencies with the user's package manager (#34554).Template
dependenciesto say exactly what should invalidate a template (#35875).addServerImports,addServerImportsDirandaddServerTemplatework the same across Nitro versions; a server tsconfig and versioned route config types are generated for you (#36265).@nuxt/kithas an explicit public API (#36074) and@nuxt/schemais an optional peer (#36246).Modules can now set
experimental.asyncContext(#36175, thanks to @cernymatej), Vite plugins added via kit land at the top level rather than wrapped (#36037), and more build-time warnings have moved to diagnostic codes with docs pages (#36138).@nuxt/kitpeer dependency ranges are widened to the versions actually required rather than tracking the latest of each package (#36417), andupdateRuntimeConfigno longer warns when called before Nitro exists (#36403, thanks to @Neekoras).
Security
- Security
The internal error route is only served to an error render, and can no longer be reached from outside (259058cf4, #36305).
- Security
Dev error reports are scoped for remote peers, and the dev error channel is kept out of production builds (#36389, #36407).
- Security
Unhandled error data is no longer passed to the error page (38a40cfc0), oversized island bodies are drained before being rejected (#36320), and error-render recursion is tracked in request context rather than via a client-controllable header (d8c729435).
Important fixes
Awaited
useAsyncDatano longer resolves with unfetched data on hydration (#36124), awaited lazy async data resolves immediately (#36301), anduseAsyncDatatypes resolve for generic type params (#36316).useRequestFetchforwards request headers (#36180, thanks to @hdwebpros).navigateTomatches vue-router's path encoding (#36055), preserves percent-encoding in server redirects (#36112), and appliesbaseURLwithopen(#36197).Scoped styles apply to server component slots (#36047), island asset requests are deduped (#36048), lazy hydration no longer produces blank remounts (#36051), all from @oritwoen, and hydrated
nuxt-clientmarkup is stripped from cached island HTML (#36298).A batch of CSS fixes across Vite, webpack and rspack: duplicate CSS links for inlined chunks (#36056),
baseURLandurl()rewriting in inlined styles (#36137, #36143), island descendant CSS extraction (#36260) and stable style chunk names (#36361).View transitions handle interrupted and skipped navigations (#35537 from @Askerka00, #36314), and page transitions stay mounted for nested routes with no children (#36304).
The streaming shell head renders after the first render pass (#36120).
Payload URLs are parsed as origin-relative paths, so a path like
//x/_payload.jsonno longer serves the wrong payload (#36409, spotted/index.htmlis prerendered for client-only apps with islands (#36299).definePageMetaworks at the top level ofsetup()(#36245), and changed auto-import sources are rescanned before their consumers (#33671, thanks to @Flo0806).A template that never finishes compiling now fails the build instead of exiting 0 (#36322).
Error causes are preserved in development (#35632, thanks to @onmax).
Layout
onBeforeLeavereuses the pending transition promise (#36395), andbaseURLand middleware flags are respected in apps withoutpages/(#36034).stripNeverHydratedDatano longer mutates the options object (#36035), the dev error module is stubbed out of production builds (55e61d75d), and preloading a component that is not global now warns (47de80ece).
Upgrading
Our recommendation for upgrading is to run:
npx nuxt upgrade --dedupe
This will refresh your lockfile and pull in all the latest dependencies that Nuxt relies on, including Nuxt CLI v4.
Note
This release requires Node.js ^22.22.3 || ^24.15.0 || >=26.0.0.
If you have server code you'd like to make portable, read Moving to nuxt/server in the upgrade guide.
Changelog
Enhancements
nuxt: add addon support to
createUseFetchandcreateUseAsyncDatanuxt,nitro,schema: add
useServerHookstonuxt/servernuxt,nitro: add
serverFetchtonuxt/servernuxt,nitro: add forwarded url, cookie and route rule helpers to
nuxt/servernuxt,vite: add
hook,bundlerandmiddlewaretracing channelsnuxt: serve unmatched public asset paths on client-side navigation
nuxt,schema: add top-level
prerenderalias fornitro.prerendernuxt,vite-server: render the error page in the renderer itself
nuxt: unified client prefetch scheduler
nuxt: add
useAppConfigtonuxt/servernuxt: add
handleCorstonuxt/servernuxt: add
readValidatedBodyandgetValidatedQuerytonuxt/servernuxt: add
getRouterParam(s)andgetRequestIPtonuxt/servernuxt,nitro,vite,vite-server: scope dev error reports for remote peers
nuxt: add session utils to
nuxt/servernuxt,schema: add nuxt
appSecretnuxt: add server + client cookie jars to avoid unnecessary reads
nuxt,nitro,vite-server: compile nuxt core route rules
nuxt,schema: give
nuxt/serverhandlers a portable eventnuxt,kit,schema,nitro,vite-server: add
nuxt/servernuxt: add
ShallowReftype to vue presetnuxt: type
$fetchanduseFetchfrom generated server routeskit,nuxt,vite,vite-server: add experimental pure vite server
nuxt: add experimental early404 for unmatched page routes
nuxt: add experimental early return after
navigateTonuxt: support vue vapor
nuxt: use @nuxt/cli v4 prerelease
nitro,nuxt: improvements when rendering with
noScriptskit,nitro,nuxt,rspack,vite,webpack: use package manager in hints
nuxt: make file names clickable 🖱️
nitro,nuxt,schema: let templates declare dependencies
nuxt: prefetch server page islands via
<NuxtLink>nuxt,nitro: auto-import types from
app/typesandserver/typesdirectoriesnuxt: type
preloadComponentsandNuxtIslandnamenuxt: add
serializeoption to keep async data out of payloadnuxt: log template write paths when debugging
nuxt: export
$Fetchtypenuxt: add IDE hover docs for built-in components
nuxt: support grouping folders in component directories
nuxt: warn when public files override application routes
nuxt: support dynamic
expiresinuseCookie
Performance
nuxt: drop
unctxfrom client environment (+defuin single-object config)nitro,nuxt: use lazy impound tracing for builds
nuxt,vite: migrate
isVuecalls into plugin filterskit: remove
confboxandpkg-typesfrom dependenciesnuxt: filter virtual module load hooks by id
nuxt: render internal
<NuxtLink>anchors directly on servernuxt,kit: avoid loading
jitiunless it is needednuxt: tree-shake
ssr: falsepages from server bundlenuxt: extract serializable
definePageMetakeys at build time
Fixes
nuxt: resolve anchor hrefs through the router
nuxt: leave a newer async data entry alone when an old one is taken off
nuxt: await async layouts before navigation
nuxt,vite: show compile error overlay on client-only pages
nuxt: keep
CookieOptionscompatible with cookie serialize optionskit,nuxt: preserve types when building into a relocated build dir
nuxt,nitro: render html page errors + json server route errors
nuxt,vite-server: keep cookies + respond to json clients on errors
kit,nuxt: provide
nuxt/internal/dev-erroras a server runtime modulenuxt: allow
@nuxt/cliruntime imports in server runtimenuxt: type nitro type path helper with
NitroConfignuxt: refresh component imports after rename
nuxt: skip browser notices without error in dev overlay
- Deprecated
schema: deprecate
nitro.*options duplicated at the top level nuxt: respect base URL and clear middleware flags without
pages/(#36034)\nuxt,nitro: stub dev error module in production builds
nuxt: resolve
@nuxt/*type paths from nuxt's own resolutionnuxt: warn when preloading a component that is not global
nuxt: avoid mutating options when stripping never-hydrated data
nuxt: reuse pending transition promise in layout
onBeforeLeavenuxt: reject sealed values not issued by nuxt sessions
nuxt: parse payload url as origin-relative path
nuxt: invalidate auto-import consumers on the hmr-less ssr dev server
nuxt: accept
Endpoint-shapedServerRoutesaugmentations in theInternalApienginenuxt: share client app context across module instances
nuxt: explain nitro 2 env parsing when a derived secret is unusable
nuxt: prepend the vite unctx transform so it reaches page-meta macro modules
nuxt,vite: attach resources to pages served without scripts
nuxt: keep non-script resource hints on
noScriptsroutesnuxt: strip hydrated
nuxt-clientmarkup from cached island htmlnuxt: widen
nuxt/serverhelper event typesnuxt: keep a configured appSecret and warn when it is used
nuxt: keep session managers in step after
clearSessionnuxt: use a throttle approach for hint prefetching
kit,nuxt,schema: let a server build declare the module backing
fetchnuxt: apply nitro type paths in
prepare:typesin devnuxt: forward request headers with
useRequestFetchnuxt: resolve awaited lazy async data immediately
nuxt: resolve
useAsyncDatatype for generic type paramskit,nuxt: fail the build when a template never finishes compiling
nuxt: keep view transition state for interrupting navigations
nuxt: handle rejected
readypromise of skipped view transitionnuxt: skip scanning page meta if the scanner cannot parse
nuxt: keep page transition mounted for nested route with no children
nuxt: respect image prefetching as preload to respect Accept hea…
nuxt: listen to
link:prefetchhook before onNuxtReadykit,nuxt,schema,vite-server: let vite plugins own the deploy target
nuxt: avoid app config declaration conflicts
nuxt: rescan changed auto-import sources before their consumers
nuxt: resolve layout hydration guard when unmounted early
nuxt: bound island v-for on nuxt-client elements without selectiveClient
nuxt: only rewrite island uid marker in attribute position
nuxt: serialize numeric v-for island slot scopes 1-based
nuxt: support
definePageMetaat the top level ofsetup()nuxt: make
targetoptional if callingnavigateTow/ opennuxt: apply
baseURLwhen callingnavigateTowithopennuxt: expose shallow async data ref
nuxt: ignore grouping folders when collapsing repeated name segments
nuxt: register namespace binding alongside default import
nuxt: keep extracted
__proto__page meta keys as own propertiesnuxt: disable early 404 for page paths that cannot be decoded
nuxt: key dynamic meta by file path + nuxt instance
nuxt: validate component export name before code generation
nuxt: allow modules to set
experimental.asyncContextschema,nuxt: accept partial app config input + stop merging functions
nuxt: resolve layout name override in layout
isCurrentchecknuxt: bridge
AppConfigInputaugmentations intonuxt/schemanuxt: don't resolve awaited
useAsyncDatawith unfetched data on hydrationnuxt: preserve percent-encoding in server
navigateToredirectsnuxt: preserve regexp and function values when cloning import presets
nuxt: pass absolute paths to build cache ignore check
nuxt: hide internal dynamic page meta key behind a symbol
nuxt: keep page bundle restrictions out of the pages array
nuxt: avoid duplicate island asset requests
nuxt: keep
<NuxtTime>locale prop reactive after hydrationnuxt: validate
scopeIdprop passed to<NuxtIsland>nuxt: apply scoped styles to server component slots
nuxt: match vue-router path encoding in
navigateTonuxt: avoid blank lazy hydration remounts
nuxt: don't defer hydration route for trailing-slash-only diffs
nuxt: keep ref-initialised
useStateconnected to payload statenuxt: only compute
distURLin developmentnuxt: export
useLayout,useLoadingIndicatoranduseRequestHeadernuxt: only map test components for webpack and rspack
nuxt,nitro: unwrap route rule matches when resolving rules
nuxt: stub client-only components + map test components in server build
nuxt: do not write readonly cookies on client
nuxt: skip cookie watcher entirely when readonly
nitro,nuxt: hoist route matcher to prevent temporal dead zone
nuxt: resolve
ufofrom nuxt dependenciesnuxt: preserve error causes in development
nuxt: improve js type-checking
A whole project to check? Paste its package.json in the dependency check: every deprecated, outdated or vulnerable dependency, with what to upgrade to. Free, no account.