@nuxt/docs 3.20.2 → 3.21.1

package/3.guide/{4.going-further → 6.going-further}/1.experimental-features.md

@@ -3,14 +3,44 @@ title: "Experimental Features"
 description: "Enable Nuxt experimental features to unlock new possibilities."
 ---
 
-The Nuxt experimental features can be enabled in the Nuxt configuration file.
+Nuxt includes experimental features that you can enable in your configuration file.
 
-Internally, Nuxt uses `@nuxt/schema` to define these experimental features. You can refer to the [API documentation](/docs/3.x/api/configuration/nuxt-config#experimental) or the [source code](https://github.com/nuxt/nuxt/blob/main/packages/schema/src/config/experimental.ts) for more information.
+Internally, Nuxt uses `@nuxt/schema` to define these experimental features. You can refer to the [API documentation](/docs/3.x/guide/going-further/experimental-features) or the [source code](https://github.com/nuxt/nuxt/blob/main/packages/schema/src/config/experimental.ts) for more information.
 
 ::note
 Note that these features are experimental and could be removed or modified in the future.
 ::
 
+## alwaysRunFetchOnKeyChange
+
+Whether to run `useFetch` when the key changes, even if it is set to `immediate: false` and it has not been triggered yet.
+
+`useFetch` and `useAsyncData` will always run when the key changes if `immediate: true` or if it has been already triggered.
+
+This flag is disabled by default, but you can enable this feature:
+
+```ts twoslash [nuxt.config.ts]
+export default defineNuxtConfig({
+  experimental: {
+    alwaysRunFetchOnKeyChange: true,
+  },
+})
+```
+
+## appManifest
+
+Use app manifests to respect route rules on client-side.
+
+This flag is enabled by default, but you can disable this feature:
+
+```ts twoslash [nuxt.config.ts]
+export default defineNuxtConfig({
+  experimental: {
+    appManifest: false,
+  },
+})
+```
+
 ## asyncContext
 
 Enable native async context to be accessible for nested composables in Nuxt and in Nitro. This opens the possibility to use composables inside async composables and reduce the chance to get the `Nuxt instance is unavailable` error.
@@ -43,12 +73,12 @@ export default defineNuxtConfig({
 
 Externalizes `vue`, `@vue/*` and `vue-router` when building.
 
-*Enabled by default.*
+This flag is enabled by default, but you can disable this feature:
 
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
   experimental: {
-    externalVue: true,
+    externalVue: false,
   },
 })
 ```
@@ -57,20 +87,6 @@ export default defineNuxtConfig({
 This feature will likely be removed in a near future.
 ::
 
-## treeshakeClientOnly
-
-Tree shakes contents of client-only components from server bundle.
-
-*Enabled by default.*
-
-```ts twoslash [nuxt.config.ts]
-export default defineNuxtConfig({
-  experimental: {
-    treeshakeClientOnly: true,
-  },
-})
-```
-
 ## extractAsyncDataHandlers
 
 Extracts handler functions from `useAsyncData` and `useLazyAsyncData` calls into separate chunks for improved code splitting and caching efficiency.
@@ -113,7 +129,9 @@ This feature is only recommended for **static builds** with payload extraction,
 
 Emits `app:chunkError` hook when there is an error loading vite/webpack chunks. Default behavior is to perform a reload of the new route on navigation to a new route when a chunk fails to load.
 
-If you set this to `'automatic-immediate'` Nuxt will reload the current route immediately, instead of waiting for a navigation. This is useful for chunk errors that are not triggered by navigation, e.g., when your Nuxt app fails to load a [lazy component](/docs/3.x/directory-structure/components#dynamic-imports). A potential downside of this behavior is undesired reloads, e.g., when your app does not need the chunk that caused the error.
+By default, Nuxt will also perform a reload of the new route when a chunk fails to load when navigating to a new route (`automatic`).
+
+Setting `automatic-immediate` will lead Nuxt to perform a reload of the current route right when a chunk fails to load (instead of waiting for navigation). This is useful for chunk errors that are not triggered by navigation, e.g., when your Nuxt app fails to load a [lazy component](/docs/3.x/directory-structure/components#dynamic-imports). A potential downside of this behavior is undesired reloads, e.g., when your app does not need the chunk that caused the error.
 
 You can disable automatic handling by setting this to `false`, or handle chunk errors manually by setting it to `manual`.
 
@@ -125,6 +143,20 @@ export default defineNuxtConfig({
 })
 ```
 
+## enforceModuleCompatibility
+
+Whether Nuxt should throw an error (and fail to load) if a Nuxt module is incompatible.
+
+This feature is disabled by default.
+
+```ts twoslash [nuxt.config.ts]
+export default defineNuxtConfig({
+  experimental: {
+    enforceModuleCompatibility: true,
+  },
+})
+```
+
 ## restoreState
 
 Allows Nuxt app state to be restored from `sessionStorage` when reloading the page after a chunk error or manual [`reloadNuxtApp()`](/docs/3.x/api/utils/reload-nuxt-app) call.
@@ -158,22 +190,22 @@ export default defineNuxtConfig({
 
 Matching route rules will be created, based on the page's `path`.
 
-::read-more{to="/docs/api/utils/define-route-rules" icon="i-lucide-square-function"}
+::read-more{to="/docs/3.x/api/utils/define-route-rules" icon="i-lucide-square-function"}
 Read more in `defineRouteRules` utility.
 ::
 
-:read-more{to="/docs/guide/concepts/rendering#hybrid-rendering" icon="i-lucide-medal"}
+:read-more{to="/docs/3.x/guide/concepts/rendering#hybrid-rendering" icon="i-lucide-medal"}
 
 ## renderJsonPayloads
 
 Allows rendering of JSON payloads with support for revivifying complex types.
 
-*Enabled by default.*
+This flag is enabled by default, but you can disable this feature:
 
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
   experimental: {
-    renderJsonPayloads: true,
+    renderJsonPayloads: false,
   },
 })
 ```
@@ -190,6 +222,20 @@ export default defineNuxtConfig({
 })
 ```
 
+## parseErrorData
+
+Whether to parse `error.data` when rendering a server error page.
+
+This flag is enabled by default, but you can disable this feature:
+
+```ts twoslash [nuxt.config.ts]
+export default defineNuxtConfig({
+  experimental: {
+    parseErrorData: false,
+  },
+})
+```
+
 ## payloadExtraction
 
 Enables extraction of payloads of pages generated with `nuxt generate`.
@@ -202,6 +248,21 @@ export default defineNuxtConfig({
 })
 ```
 
+Payload extraction also works for routes using ISR (Incremental Static Regeneration) or SWR (Stale-While-Revalidate) caching strategies. This allows CDNs to cache payload files alongside HTML, improving client-side navigation performance for cached routes.
+
+```ts twoslash [nuxt.config.ts]
+export default defineNuxtConfig({
+  experimental: {
+    payloadExtraction: true,
+  },
+  routeRules: {
+    // Payload files will be generated for these cached routes
+    '/products/**': { isr: 3600 },
+    '/blog/**': { swr: true },
+  },
+})
+```
+
 ## clientFallback
 
 Enables the experimental [`<NuxtClientFallback>`](/docs/3.x/api/components/nuxt-client-fallback) component for rendering content on the client if there's an error in SSR.
@@ -244,7 +305,7 @@ export default defineNuxtConfig({
 
 :link-example{to="https://stackblitz.com/edit/nuxt-view-transitions?file=app.vue" target="_blank"}
 
-::read-more{icon="i-simple-icons-mdnwebdocs" to="https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API" target="_blank"}
+::read-more{icon="i-simple-icons-mdnwebdocs" to="https://developer.mozilla.org/en-US/docs/Web/API/View_Transition_API" target="_blank"}
 Read more about the **View Transition API**.
 ::
 
@@ -272,60 +333,22 @@ export default defineNuxtConfig({
 })
 ```
 
-:read-more{to="/docs/guide/directory-structure/components#server-components"}
+:read-more{to="/docs/3.x/directory-structure/components#server-components"}
 
 ::read-more{icon="i-simple-icons-github" to="https://github.com/nuxt/nuxt/issues/19772" target="_blank"}
 You can follow the server components roadmap on GitHub.
 ::
 
-## configSchema
-
-Enables config schema support.
-
-*Enabled by default.*
-
-```ts twoslash [nuxt.config.ts]
-export default defineNuxtConfig({
-  experimental: {
-    configSchema: true,
-  },
-})
-```
-
-## polyfillVueUseHead
-
-Adds a compatibility layer for modules, plugins, or user code relying on the old `@vueuse/head` API.
-
-```ts twoslash [nuxt.config.ts]
-export default defineNuxtConfig({
-  experimental: {
-    polyfillVueUseHead: false,
-  },
-})
-```
-
-## respectNoSSRHeader
-
-Allow disabling Nuxt SSR responses by setting the `x-nuxt-no-ssr` header.
-
-```ts twoslash [nuxt.config.ts]
-export default defineNuxtConfig({
-  experimental: {
-    respectNoSSRHeader: false,
-  },
-})
-```
-
 ## localLayerAliases
 
 Resolve `~`, `~~`, `@` and `@@` aliases located within layers with respect to their layer source and root directories.
 
-*Enabled by default.*
+This flag is enabled by default, but you can disable this feature:
 
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
   experimental: {
-    localLayerAliases: true,
+    localLayerAliases: false,
   },
 })
 ```
@@ -374,14 +397,14 @@ export default defineNuxtConfig({
 
 ## sharedPrerenderData
 
-Enabling this feature automatically shares payload *data* between pages that are prerendered. This can result
-in a significant performance improvement when prerendering sites that use `useAsyncData` or `useFetch` and
-fetch the same data in different pages.
+Nuxt automatically shares payload *data* between pages that are prerendered. This can result in a significant performance improvement when prerendering sites that use `useAsyncData` or `useFetch` and fetch the same data in different pages.
+
+You can disable this feature if needed.
 
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
   experimental: {
-    sharedPrerenderData: true,
+    sharedPrerenderData: false,
   },
 })
 ```
@@ -422,11 +445,11 @@ globalThis.Buffer ||= Buffer
 
 ## scanPageMeta
 
-This option allows exposing some route metadata defined in `definePageMeta` at build-time to modules (specifically `alias`, `name`, `path`, `redirect`, `props` and `middleware`).
+Nuxt exposing some route metadata defined in `definePageMeta` at build-time to modules (specifically `alias`, `name`, `path`, `redirect`, `props` and `middleware`).
 
 This only works with static or strings/arrays rather than variables or conditional assignment. See [original issue](https://github.com/nuxt/nuxt/issues/24770) for more information and context.
 
-It is also possible to scan page metadata only after all routes have been registered in `pages:extend`. Then another hook, `pages:resolved` will be called. To enable this behavior, set `scanPageMeta: 'after-resolve'`.
+By default page metadata is only scanned after all routes have been registered in `pages:extend`. Then another hook, `pages:resolved` will be called.
 
 You can disable this feature if it causes issues in your project.
 
@@ -442,10 +465,12 @@ export default defineNuxtConfig({
 
 Enables CookieStore support to listen for cookie updates (if supported by the browser) and refresh `useCookie` ref values.
 
+This flag is enabled by default, but you can disable this feature:
+
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
   experimental: {
-    cookieStore: true,
+    cookieStore: false,
   },
 })
 ```
@@ -458,6 +483,10 @@ Read more about the **CookieStore**.
 
 Caches Nuxt build artifacts based on a hash of the configuration and source files.
 
+This only works for source files within `srcDir` and `serverDir` for the Vue/Nitro parts of your app.
+
+This flag is disabled by default, but you can enable it:
+
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
   experimental: {
@@ -486,6 +515,20 @@ In addition, any changes to files within `srcDir` will trigger a rebuild of the
 A maximum of 10 cache tarballs are kept.
 ::
 
+## checkOutdatedBuildInterval
+
+Set the time interval (in ms) to check for new builds. Disabled when `experimental.appManifest` is `false`.
+
+Set to `false` to disable.
+
+```ts twoslash [nuxt.config.ts]
+export default defineNuxtConfig({
+  experimental: {
+    checkOutdatedBuildInterval: 3600000, // 1 hour, or false to disable
+  },
+})
+```
+
 ## extraPageMetaExtractionKeys
 
 The `definePageMeta()` macro is a useful way to collect build-time meta about pages. Nuxt itself provides a set list of supported keys which is used to power some of the internal features such as redirects, page aliases and custom paths.
@@ -515,15 +558,32 @@ export default defineNuxtConfig({
 
 This allows modules to access additional metadata from the page metadata in the build context. If you are using this within a module, it's recommended also to [augment the `NuxtPage` types with your keys](/docs/3.x/directory-structure/pages#typing-custom-metadata).
 
+## navigationRepaint
+
+Wait for a single animation frame before navigation, which gives an opportunity for the browser to repaint, acknowledging user interaction.
+
+It can reduce INP when navigating on prerendered routes.
+
+This flag is enabled by default, but you can disable this feature:
+
+```ts twoslash [nuxt.config.ts]
+export default defineNuxtConfig({
+  experimental: {
+    navigationRepaint: false,
+  },
+})
+```
+
 ## normalizeComponentNames
 
-Ensure that auto-generated Vue component names match the full component name
-you would use to auto-import the component.
+Nuxt updates auto-generated Vue component names to match the full component name you would use to auto-import the component.
+
+If you encounter issues, you can disable this feature.
 
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
   experimental: {
-    normalizeComponentNames: true,
+    normalizeComponentNames: false,
   },
 })
 ```
@@ -545,7 +605,7 @@ By setting `experimental.normalizeComponentNames`, these two values match, and V
 
 ## spaLoadingTemplateLocation
 
-When rendering a client-only page (with `ssr: false`), we optionally render a loading screen (from `app/spa-loading-template.html`).
+When rendering a client-only page (with `ssr: false`), we optionally render a loading screen (from `~/spa-loading-template.html`).
 
 It can be set to `within`, which will render it like this:
 
@@ -620,15 +680,17 @@ export default defineNuxtConfig({
 })
 ```
 
-::read-more{icon="i-simple-icons-github" color="gray" to="/docs/guide/directory-structure/components#delayed-or-lazy-hydration"}
+::read-more{icon="i-simple-icons-github" color="gray" to="/docs/3.x/directory-structure/components#delayed-or-lazy-hydration"}
 Read more about lazy hydration.
 ::
 
 ## templateImportResolution
 
-Controls how imports in Nuxt templates are resolved. By default, Nuxt attempts to resolve imports in templates relative to the module that added them.
+Disable resolving imports into Nuxt templates from the path of the module that added the template.
 
-This is enabled by default, so if you're experiencing resolution conflicts in certain environments, you can disable this behavior:
+By default, Nuxt attempts to resolve imports in templates relative to the module that added them. Setting this to `false` disables this behavior, which may be useful if you're experiencing resolution conflicts in certain environments.
+
+This flag is enabled by default, but you can disable this feature:
 
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
@@ -642,6 +704,22 @@ export default defineNuxtConfig({
 See PR #31175 for implementation details.
 ::
 
+## templateRouteInjection
+
+By default the route object returned by the auto-imported `useRoute()` composable is kept in sync with the current page in view in `<NuxtPage>`. This is not true for `vue-router`'s exported `useRoute` or for the default `$route` object available in your Vue templates.
+
+By enabling this option a mixin will be injected to keep the `$route` template object in sync with Nuxt's managed `useRoute()`.
+
+This flag is enabled by default, but you can disable this feature:
+
+```ts twoslash [nuxt.config.ts]
+export default defineNuxtConfig({
+  experimental: {
+    templateRouteInjection: false,
+  },
+})
+```
+
 ## decorators
 
 This option enables enabling decorator syntax across your entire Nuxt/Nitro app, powered by [esbuild](https://github.com/evanw/esbuild/releases/tag/v0.21.3).
@@ -680,10 +758,38 @@ const value = new SomeClass().someMethod()
 // this will return 'decorated'
 ```
 
+## defaults
+
+This allows specifying the default options for core Nuxt components and composables.
+
+These options will likely be moved elsewhere in the future, such as into `app.config` or into the `app/` directory.
+
+```ts twoslash [nuxt.config.ts]
+export default defineNuxtConfig({
+  experimental: {
+    defaults: {
+      nuxtLink: {
+        componentName: 'NuxtLink',
+        prefetch: true,
+        prefetchOn: {
+          visibility: true,
+        },
+      },
+      useAsyncData: {
+        deep: true,
+      },
+    },
+  },
+})
+```
+
 ## purgeCachedData
 
-Nuxt will automatically purge cached data from `useAsyncData` and `nuxtApp.static.data`. This helps prevent memory leaks
-and ensures fresh data is loaded when needed, but it is possible to disable it:
+Whether to clean up Nuxt static and asyncData caches on route navigation.
+
+Nuxt will automatically purge cached data from `useAsyncData` and `nuxtApp.static.data`. This helps prevent memory leaks and ensures fresh data is loaded when needed, but it is possible to disable it.
+
+This flag is enabled by default, but you can disable this feature:
 
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
@@ -701,10 +807,12 @@ See PR #31379 for implementation details.
 
 Whether to call and use the result from `getCachedData` when refreshing data for `useAsyncData` and `useFetch` (whether by `watch`, `refreshNuxtData()`, or a manual `refresh()` call.
 
+This flag is enabled by default, but you can disable this feature:
+
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
   experimental: {
-    granularCachedData: true,
+    granularCachedData: false,
   },
 })
 ```
@@ -713,16 +821,33 @@ export default defineNuxtConfig({
 See PR #31373 for implementation details.
 ::
 
+## headNext
+
+Use head optimisations:
+
+- Add the capo.js head plugin in order to render tags in of the head in a more performant way.
+- Uses the hash hydration plugin to reduce initial hydration
+
+This flag is enabled by default, but you can disable this feature:
+
+```ts twoslash [nuxt.config.ts]
+export default defineNuxtConfig({
+  experimental: {
+    headNext: false,
+  },
+})
+```
+
 ## pendingWhenIdle
 
-If set to `false`, the `pending` object returned from `useAsyncData`, `useFetch`, `useLazyAsyncData` and `useLazyFetch` will be a computed property that is `true` only when `status` is also pending.
+For `useAsyncData` and `useFetch`, whether `pending` should be `true` when data has not yet started to be fetched.
 
-That means that when `immediate: false` is passed, `pending` will be `false` until the first request is made.
+This flag is disabled by default, but you can enable this feature:
 
 ```ts twoslash [nuxt.config.ts]
 export default defineNuxtConfig({
   experimental: {
-    pendingWhenIdle: false,
+    pendingWhenIdle: true,
   },
 })
 ```
@@ -803,7 +928,7 @@ export default defineNuxtConfig({
 The Vite Environment API provides better consistency between development and production builds, more granular control over environment-specific configuration, and improved performance.
 
 ::important
-Enabling this feature changes how Vite plugins are registered and configured. See the [Vite Environment API migration guide](/docs/4.x/getting-started/upgrade#migration-to-vite-environment-api) for details on updating your plugins.
+Enabling this feature changes how Vite plugins are registered and configured. See the [Vite Environment API migration guide](/docs/3.x/getting-started/upgrade#migration-to-vite-environment-api) for details on updating your plugins.
 ::
 
 ::read-more{to="https://vite.dev/guide/api-environment" target="_blank"}

package/3.guide/6.going-further/1.features.md

@@ -0,0 +1,108 @@
+---
+title: "Features"
+description: "Enable or disable optional Nuxt features to unlock new possibilities."
+---
+
+Some features of Nuxt are available on an opt-in basis, or can be disabled based on your needs.
+
+## `features`
+
+### devLogs
+
+Stream server logs to the client as you are developing. These logs can be handled in the `dev:ssr-logs` hook.
+
+By default, this is enabled in development (when test mode is not active).
+
+If set to `silent`, the logs will not be printed to the browser console.
+
+```ts [nuxt.config.ts]
+export default defineNuxtConfig({
+  features: {
+    devLogs: true,
+  },
+})
+```
+
+### inlineStyles
+
+Inlines styles when rendering HTML. This is currently available only when using Vite.
+
+You can also pass a function that receives the path of a Vue component and returns a boolean indicating whether to inline the styles for that component.
+
+It defaults to `(id) => id.includes('.vue')`.
+
+```ts [nuxt.config.ts]
+export default defineNuxtConfig({
+  features: {
+    inlineStyles: false, // or a function to determine inlining
+  },
+})
+```
+
+### noScripts
+
+Turn off rendering of Nuxt scripts and JavaScript resource hints. Can also be configured granularly within `routeRules`.
+
+You can also disable scripts more granularly within `routeRules`.
+
+If set to 'production' or `true`, JavaScript will be disabled in production mode only. If set to 'all', JavaScript will be disabled in both development and production modes.
+
+```ts [nuxt.config.ts]
+export default defineNuxtConfig({
+  features: {
+    noScripts: true, // or 'production' | 'all' | false
+  },
+})
+```
+
+## `future`
+
+There is also a `future` namespace for early opting-in to new features that will become default in a future (possibly major) version of the framework.
+
+### compatibilityVersion
+
+This enables early access to Nuxt features or flags.
+
+Setting `compatibilityVersion` to `5` changes defaults throughout your Nuxt configuration to opt in to Nuxt v5 behaviour, including enabling the [Vite Environment API](/docs/3.x/guide/going-further/experimental-features#viteenvironmentapi).
+
+```ts
+export default defineNuxtConfig({
+  future: {
+    compatibilityVersion: 5,
+  },
+})
+```
+
+::read-more{to="/docs/3.x/getting-started/upgrade#testing-nuxt-5"}
+Learn more about testing Nuxt 5.
+::
+
+### multiApp
+
+This enables early access to the experimental multi-app support. You can follow the [tracker issue #21635](https://github.com/nuxt/nuxt/issues/21635) to see the progress of multi-app support in Nuxt.
+
+```ts [nuxt.config.ts]
+export default defineNuxtConfig({
+  future: {
+    multiApp: true,
+  },
+})
+```
+
+### typescriptBundlerResolution
+
+This enables 'Bundler' module resolution mode for TypeScript, which is the recommended setting for frameworks like Nuxt and [Vite](https://vite.dev/guide/performance#reduce-resolve-operations).
+
+It improves type support when using modern libraries with `exports`.
+
+See [the original TypeScript pull request](https://github.com/microsoft/TypeScript/pull/51669).
+
+You can set it to false to use the legacy 'Node' mode, which is the default for TypeScript.
+
+```ts [nuxt.config.ts]
+export default defineNuxtConfig({
+  future: {
+    typescriptBundlerResolution: false,
+  },
+})
+```

package/3.guide/{4.going-further → 6.going-further}/1.internals.md

@@ -1,6 +1,7 @@
 ---
 title: "How Nuxt Works?"
 description: "Nuxt is a minimal but highly customizable framework to build web applications."
+navigation: false
 ---
 
 This guide helps you better understand Nuxt internals to develop new solutions and module integrations on top of Nuxt.
@@ -15,7 +16,7 @@ allowing different components to communicate with each other. You can think of i
 This context is globally available to be used with [Nuxt Kit](/docs/3.x/guide/going-further/kit) composables.
 Therefore only one instance of Nuxt is allowed to run per process.
 
-To extend the Nuxt interface and hook into different stages of the build process, we can use [Nuxt Modules](/docs/3.x/guide/going-further/modules).
+To extend the Nuxt interface and hook into different stages of the build process, we can use [Nuxt modules](/docs/3.x/guide/modules).
 
 For more details, check out [the source code](https://github.com/nuxt/nuxt/blob/main/packages/nuxt/src/core/nuxt.ts).
 
@@ -76,6 +77,6 @@ Nuxt builds and bundles project using Node.js but also has a runtime side.
 
 While both areas can be extended, that runtime context is isolated from build-time. Therefore, they are not supposed to share state, code, or context other than runtime configuration!
 
-`nuxt.config` and [Nuxt Modules](/docs/3.x/guide/going-further/modules) can be used to extend the build context, and [Nuxt Plugins](/docs/3.x/directory-structure/plugins) can be used to extend runtime.
+`nuxt.config` and [Nuxt modules](/docs/3.x/guide/modules) can be used to extend the build context, and [Nuxt Plugins](/docs/3.x/directory-structure/plugins) can be used to extend runtime.
 
-When building an application for production, `nuxt build` will generate a standalone build in the `.output` directory, independent of `nuxt.config` and [Nuxt modules](/docs/3.x/guide/going-further/modules).
+When building an application for production, `nuxt build` will generate a standalone build in the `.output` directory, independent of `nuxt.config` and [Nuxt modules](/docs/3.x/guide/modules).

package/3.guide/{4.going-further → 6.going-further}/10.runtime-config.md

@@ -41,11 +41,11 @@ Instead of passing non-serializable objects or functions into your application f
 
 ### Environment Variables
 
-The most common way to provide configuration is by using [Environment Variables](https://medium.com/chingu/an-introduction-to-environment-variables-and-how-to-use-them-f602f66d15fa).
+The most common way to provide configuration is by using environment variables.
 
 ::note
 The Nuxt CLI has built-in support for reading your `.env` file in development, build and generate. But when you run your built server, **your `.env` file will not be read**.
-:read-more{to="/docs/guide/directory-structure/env"}
+:read-more{to="/docs/3.x/directory-structure/env"}
 ::
 
 Runtime config values are **automatically replaced by matching environment variables at runtime**.

package/3.guide/{4.going-further → 6.going-further}/11.nightly-release-channel.md

@@ -57,6 +57,6 @@ To try the latest version of [nuxt/cli](https://github.com/nuxt/cli):
 npx @nuxt/cli-nightly@latest [command]
 ```
 
-::read-more{to="/docs/api/commands"}
+::read-more{to="/docs/3.x/api/commands"}
 Read more about the available commands.
 ::