@nuxt/docs-nightly 4.5.1-29752449.30d24817 → 4.5.2-2610052030-052d82e

package/4.api/5.kit/12.nitro.md

@@ -8,7 +8,7 @@ links:
     size: xs
 ---
 
-Nitro is an open source TypeScript framework to build ultra-fast web servers. Nuxt uses Nitro as its server engine. You can use `useNitro` to access the Nitro instance, `addServerHandler` to add a server handler, `addDevServerHandler` to add a server handler to be used only in development mode, `addServerPlugin` to add a plugin to extend Nitro's runtime behavior, and `addPrerenderRoutes` to add routes to be prerendered by Nitro.
+Nitro is an open source TypeScript framework to build ultra-fast web servers. Nuxt uses Nitro as its server engine. You can use `useNitro` to access the Nitro instance (or `tryUseNitro` if your module should also work without Nitro), `addServerHandler` to add a server handler, `addDevServerHandler` to add a server handler to be used only in development mode, `addNitroPlugin` to add a plugin to extend Nitro's runtime behavior, and `addPrerenderRoutes` to add routes to be prerendered by Nitro.
 
 ## `addServerHandler`
 
@@ -34,7 +34,7 @@ export default defineNuxtModule({
 ### Type
 
 ```ts
-function addServerHandler (handler: NitroEventHandler): void
+function addServerHandler (handler: ServerHandlerInput): void
 ```
 
 ### Parameters
@@ -43,12 +43,18 @@ function addServerHandler (handler: NitroEventHandler): void
 
 | Property     | Type      | Required | Description                                                                                                                                   |
 |--------------|-----------|----------|-----------------------------------------------------------------------------------------------------------------------------------------------|
-| `handler`    | `string`  | `true`   | Path to event handler.                                                                                                                        |
-| `route`      | `string`  | `false`  | Path prefix or route. If an empty string used, will be used as a middleware.                                                                  |
+| `handler`    | `string \| { nuxt?: string, nitro2?: string, nitro3?: string }`  | `true`   | Path to the event handler, or one path per server API. Nuxt registers the implementation the application's server can run.                     |
+| `route`      | `string`  | `false`  | The route to match, exactly. End it in `/**` to match the paths below it as well. If an empty string is used, the handler is registered as middleware. |
 | `middleware` | `boolean` | `false`  | Specifies this is a middleware handler. Middleware are called on every route and should normally return nothing to pass to the next handlers. |
 | `lazy`       | `boolean` | `false`  | Use lazy loading to import the handler. This is useful when you only want to load the handler on demand.                                      |
 | `method`     | `string`  | `false`  | Router method matcher. If handler name contains method name, it will be used as a default value.                                              |
 
+A route ending in `/**` matches its base path too, so `route: '/_fonts/**'` serves `/_fonts` and everything below it. On a Nitro 2 host, whose router matches only the paths below the base, Nuxt registers the base path as a second route so that one registration behaves the same on both.
+
+::read-more{to="/docs/guide/modules/server-compatibility"}
+Learn when to register one path per server API, and which key to write your handler against.
+::
+
 ### Example
 
 #### Basic Usage
@@ -115,11 +121,8 @@ export default defineNuxtModule({
 
 ### Type
 
-```ts twoslash
-// @errors: 2391
-import type { NitroDevEventHandler } from 'nitropack/types'
-// ---cut---
-function addDevServerHandler (handler: NitroDevEventHandler): void
+```ts
+function addDevServerHandler (handler: DevServerHandlerInput): void
 ```
 
 ### Parameters
@@ -189,10 +192,48 @@ export default defineNuxtModule({
 function useNitro (): Nitro
 ```
 
-## `addServerPlugin`
+## `tryUseNitro`
+
+Returns the Nitro instance, or `undefined` when there is none.
+
+There is no Nitro instance before the `ready` hook has run, and none at all when the
+configured [`server.builder`](/docs/api/nuxt-config#builder-1) does not use Nitro, such as a
+builder that outputs a client-only SPA. Use this rather than `useNitro()` for anything that
+should keep working without a server: server routes, route rules and prerendering are all
+absent in that case.
+
+### Usage
+
+```ts
+import { defineNuxtModule, tryUseNitro } from '@nuxt/kit'
+
+export default defineNuxtModule({
+  setup (options, nuxt) {
+    nuxt.hook('ready', () => {
+      const nitro = tryUseNitro()
+      if (!nitro) {
+        // no server: skip anything that would only run there
+        return
+      }
+    })
+  },
+})
+```
+
+### Type
+
+```ts
+function tryUseNitro (): Nitro | undefined
+```
+
+## `addNitroPlugin`
 
 Add plugin to extend Nitro's runtime behavior.
 
+::note
+This was named `addServerPlugin` before Nuxt v4.6.
+::
+
 ::tip
 You can read more about Nitro plugins in the [Nitro documentation](https://nitro.build/guide/plugins).
 ::
@@ -204,12 +245,12 @@ It is necessary to explicitly import `defineNitroPlugin` from `nitropack/runtime
 ### Usage
 
 ```ts twoslash
-import { addServerPlugin, createResolver, defineNuxtModule } from '@nuxt/kit'
+import { addNitroPlugin, createResolver, defineNuxtModule } from '@nuxt/kit'
 
 export default defineNuxtModule({
   setup () {
     const { resolve } = createResolver(import.meta.url)
-    addServerPlugin(resolve('./runtime/plugin.ts'))
+    addNitroPlugin(resolve('./runtime/plugin.ts'))
   },
 })
 ```
@@ -217,26 +258,26 @@ export default defineNuxtModule({
 ### Type
 
 ```ts
-function addServerPlugin (plugin: string): void
+function addNitroPlugin (plugin: string | { nitro2?: string, nitro3?: string }): void
 ```
 
 ### Parameters
 
 | Property | Type     | Required | Description                                                                                                   |
 |----------|----------|----------|---------------------------------------------------------------------------------------------------------------|
-| `plugin` | `string` | `true`   | Path to the plugin. The plugin must export a default function that accepts the Nitro instance as an argument. |
+| `plugin` | `string \| { nitro2?: string, nitro3?: string }` | `true`   | Path to the plugin, or one path per nitro major for a module shipping an implementation for each. The plugin must export a default function that accepts the Nitro instance as an argument. |
 
 ### Example
 
 ::code-group
 
 ```ts [module.ts]
-import { addServerPlugin, createResolver, defineNuxtModule } from '@nuxt/kit'
+import { addNitroPlugin, createResolver, defineNuxtModule } from '@nuxt/kit'
 
 export default defineNuxtModule({
   setup () {
     const { resolve } = createResolver(import.meta.url)
-    addServerPlugin(resolve('./runtime/plugin.ts'))
+    addNitroPlugin(resolve('./runtime/plugin.ts'))
   },
 })
 ```
@@ -302,7 +343,7 @@ function addPrerenderRoutes (routes: string | string[]): void
 Add imports to the server. It makes your imports available in Nitro without the need to import them manually.
 
 ::warning
-If you want to provide a utility that works in both server and client contexts and is usable in the [`shared/`](/docs/4.x/directory-structure/shared) directory, the function must be imported from the same source file for both [`addImports`](/docs/4.x/api/kit/autoimports#addimports) and `addServerImports` and should have identical signature. That source file should not import anything context-specific (i.e., Nitro context, Nuxt app context) or else it might cause errors during type-checking.
+If you want to provide a utility that works in both server and client contexts and is usable in the [`shared/`](/docs/directory-structure/shared) directory, the function must be imported from the same source file for both [`addImports`](/docs/api/kit/autoimports#addimports) and `addServerImports` and should have identical signature. That source file should not import anything context-specific (i.e., Nitro context, Nuxt app context) or else it might cause errors during type-checking.
 ::
 
 ### Usage
@@ -330,7 +371,7 @@ export default defineNuxtModule({
 ### Type
 
 ```ts
-function addServerImports (dirs: Import | Import[]): void
+function addServerImports (dirs: NuxtImport | NuxtImport[]): void
 ```
 
 ### Parameters

package/4.api/5.kit/14.logging.md

@@ -31,14 +31,14 @@ export default defineNuxtModule({
 ### Type
 
 ```ts
-function useLogger (tag?: string, options?: Partial<ConsolaOptions>): ConsolaInstance
+function useLogger (tag?: string, options?: NuxtLoggerOptions): NuxtLogger
 ```
 
 ### Parameters
 
 **`tag`**: A tag to suffix all log messages with, displayed on the right near the timestamp.
 
-**`options`**: Consola configuration options.
+**`options`**: Logger options, such as `level`, `reporters`, `defaults` and `formatOptions`.
 
 ### Example
 
@@ -53,3 +53,57 @@ export default defineNuxtModule({
   },
 })
 ```
+
+## `useTerminal`
+
+Returns a set of primitives for interacting with the user's terminal. When Nuxt is running inside an interactive host such as the `nuxt dev` terminal UI, prompts, tasks and notifications are handed to it, so they are answerable and rendered in one place. Otherwise they fall back to logging.
+
+### Usage
+
+```ts twoslash
+declare function runPackageInstall (name: string): Promise<void>
+// ---cut---
+import { defineNuxtModule, useTerminal } from '@nuxt/kit'
+
+export default defineNuxtModule({
+  async setup () {
+    const terminal = useTerminal()
+
+    const install = await terminal.prompt('Do you want to install `my-module`?', { type: 'confirm' })
+    if (!install) {
+      return
+    }
+
+    const task = terminal.startTask('Installing `my-module`...')
+    // run your actual task
+    await runPackageInstall('my-module')
+    task.stop('Installed `my-module`')
+  },
+})
+```
+
+### Type
+
+```ts
+function useTerminal (): NuxtTerminal
+
+interface NuxtTerminal {
+  readonly interactive: boolean
+  withTerminal: <T>(work: () => Promise<T>) => Promise<T>
+  prompt: (message: string, options?: NuxtPromptOptions) => Promise<any>
+  startTask: (label: string) => NuxtTerminalTask
+  notify: (notification: NuxtTerminalNotification) => NuxtTerminalNotice
+}
+```
+
+### Properties
+
+**`interactive`**: Whether an interactive host is present. When `false`, the primitives below log to the current process streams instead.
+
+**`withTerminal`**: Borrows the terminal for the duration of `work`, suspending any host UI and releasing `stdin`. Use it when you need to write to the terminal or read from `stdin` directly. Concurrent callers are serialised, and a nested call from within a borrow runs immediately.
+
+**`prompt`**: Asks the user a question, borrowing the terminal for as long as the prompt is open. Takes the same options as `logger.prompt`.
+
+**`startTask`**: Starts a long-running task, rendered on the host's status surface where available. Finish it with `task.stop(message?, outcome?)`, or change its label with `task.update(label)`.
+
+**`notify`**: Shows a message and holds it on screen until the user acknowledges it or `notice.dismiss()` is called. `notice.dismissed` settles once the notice is gone.

package/4.api/5.kit/15.builder.md

@@ -330,7 +330,7 @@ function addBuildPlugin (pluginFactory: AddBuildPluginFactory, options?: ExtendC
 
 Set a build output provider for the given key. Build outputs are the contract between builders (Vite, webpack, Rspack, or a custom builder) and the Nitro server runtime: each key maps to a `nuxt/*` subpath import the server runtime resolves at build time. This is typically called from inside a builder, or from a module that participates in the build.
 
-::read-more{to="/docs/4.x/guide/going-further/builders#the-build-output-contract"}
+::read-more{to="/docs/guide/going-further/builders#the-build-output-contract"}
 Learn how the build output contract works.
 ::
 

package/4.api/5.kit/18.dependencies.md

@@ -0,0 +1,90 @@
+---
+title: "Dependencies"
+description: Nuxt Kit provides utilities to check that optional dependencies are installed and to tell users how to install them.
+links:
+  - label: Source
+    icon: i-simple-icons-github
+    to: https://github.com/nuxt/nuxt/blob/main/packages/kit/src/dependency.ts
+    size: xs
+---
+
+Modules often depend on a package that only some projects need, or that the user is expected to install themselves. Rather than assuming the package is there, or printing an install command for a package manager the user does not use, Nuxt Kit can check whether a dependency is resolvable and offer to install it with the project's own package manager.
+
+## `ensureDependencyInstalled`
+
+Check that one or more dependencies are installed, prompting the user to install any that are missing.
+
+### Usage
+
+```ts twoslash
+import { defineNuxtModule, ensureDependencyInstalled } from '@nuxt/kit'
+
+export default defineNuxtModule({
+  async setup () {
+    if (!await ensureDependencyInstalled('sass')) {
+      return
+    }
+  },
+})
+```
+
+### Type
+
+```ts
+function ensureDependencyInstalled (names: string, options?: EnsureDependencyInstalledOptions): Promise<boolean>
+function ensureDependencyInstalled (names: string[], options?: EnsureDependencyInstalledOptions): Promise<true | string[]>
+```
+
+### Parameters
+
+**`names`**: One or more package names to check, and to install if they are missing.
+
+**`options`**:
+
+| Property      | Type       | Default     | Description                                                                                                                                                            |
+| ------------- | ---------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `rootDir`     | `string`   | `nuxt.options.rootDir` | Directory to resolve packages from and to install into.                                                                                                     |
+| `searchPaths` | `string[]` | `nuxt.options.modulesDir` | Additional directories to resolve packages from.                                                                                                         |
+| `from`        | `string`   | `undefined` | An extra URL or path to resolve packages from, such as `import.meta.url`. Useful when your own package ships the dependency as a peer dependency.                       |
+| `prompt`      | `boolean`  | `undefined` | Whether to prompt before installing. `true` always prompts, `false` never prompts (and installs automatically on StackBlitz), and leaving it unset prompts everywhere except StackBlitz. |
+
+### Return Value
+
+Passing a single package name returns `true` if it is available and `false` if it is not. Passing an array returns `true` if every package is available, or an array of the package names that are still missing (because the user declined, the install failed, or there was no interactive terminal).
+
+::note
+Nothing is installed in CI or when there is no interactive terminal. In that case the missing packages are reported as a diagnostic that includes the install command, and the function reports them as missing so your module can degrade gracefully.
+::
+
+## `getAddDependencyCommand`
+
+Get the command a user should run to add dependencies to their project, using the package manager detected from `cwd` and falling back to `npm`. Use it whenever you print an install instruction, so the command matches the project's package manager.
+
+### Usage
+
+```ts twoslash
+import { defineNuxtModule, getAddDependencyCommand, useLogger } from '@nuxt/kit'
+
+export default defineNuxtModule({
+  async setup (options, nuxt) {
+    const logger = useLogger('my-module')
+    const command = await getAddDependencyCommand('sass', nuxt.options.rootDir, { dev: true })
+
+    logger.warn(`\`sass\` is required. Run \`${command}\` to install it.`)
+  },
+})
+```
+
+### Type
+
+```ts
+function getAddDependencyCommand (names: string | string[], cwd: string, options?: { dev?: boolean }): Promise<string>
+```
+
+### Parameters
+
+**`names`**: One or more package names to install.
+
+**`cwd`**: Directory to detect the package manager from.
+
+**`options.dev`**: Whether the command should install the packages as dev dependencies.

package/4.api/5.kit/2.programmatic.md

@@ -55,7 +55,84 @@ function loadNuxtConfig (options: LoadNuxtConfigOptions): Promise<NuxtOptions>
 
 ### Parameters
 
-**`options`**: Options to pass in [`c12`](https://github.com/unjs/c12#options) `loadConfig` call.
+**`options`**: Options controlling how configuration is located, merged and loaded.
+
+| Property            | Type                                                | Default          | Description                                                                                                                                        |
+| ------------------- | --------------------------------------------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `cwd`               | `string`                                            | `process.cwd()`  | Directory to load `nuxt.config` from.                                                                                                              |
+| `configFile`        | `string`                                            | `'nuxt.config'`  | Name of the config file to load, without an extension.                                                                                             |
+| `rcFile`            | `string \| false`                                   | `'.nuxtrc'`      | Name of the `.rc` file to load alongside the config file, or `false` to load none.                                                                  |
+| `globalRc`          | `boolean`                                           | `true`           | Also load the user-level and workspace-level `.nuxtrc` files.                                                                                       |
+| `overrides`         | `NuxtConfig`                                        | `undefined`      | Configuration applied above every layer, including the root project's own `nuxt.config`.                                                            |
+| `defaults`          | `NuxtConfig`                                        | `undefined`      | Configuration applied below every layer, before schema defaults.                                                                                   |
+| `dotenv`            | `boolean \| NuxtDotenvOptions`                      | `true`           | Load `.env` files into `process.env` before resolving configuration. Set to `false` when the environment has already been populated.                |
+| `envName`           | `string \| false`                                   | `undefined`      | Environment name used to select `$env.*` configuration overrides. Takes precedence over `envName` set in `nuxt.config`.                             |
+| `resolve`           | `(source, context) => ResolvedNuxtLayer \| nullish` | `undefined`      | Resolve an `extends` entry to a layer yourself. Return a nullish value to fall back to the default resolution for that source.                      |
+| `import`            | `(id: string) => Promise<unknown>`                  | `undefined`      | Import config files with a custom loader rather than the default one, for example to load TypeScript config without Nuxt reaching for `jiti`.       |
+| `onConfigResolved`  | `(context: ResolvedNuxtConfigContext) => void`      | `undefined`      | Called once, and awaited, after configuration has loaded successfully. Not called if loading throws.                                               |
+
+### `onConfigResolved`
+
+The context passed to `onConfigResolved` describes what was loaded:
+
+| Property     | Type                | Description                                                                                                                                                                                     |
+| ------------ | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `rawConfig`  | `NuxtConfig`        | User configuration merged across all layers, with no schema defaults applied and with `overrides`, `defaults` and `defaultConfig` excluded, so repeated loads of an unchanged project produce an unchanged snapshot. |
+| `layers`     | `NuxtConfigLayer[]` | Resolved config layers, highest priority first.                                                                                                                                                 |
+| `configFile` | `string?`           | Absolute path of the root `nuxt.config` file, if one was found.                                                                                                                                  |
+| `cwd`        | `string`            | Directory the configuration was loaded from.                                                                                                                                                    |
+
+## `diffNuxtConfig`
+
+Compare two `rawConfig` snapshots (as provided to `onConfigResolved`) and return the differences between them. This is useful when you watch config files yourself and need to know which keys changed before deciding whether to restart.
+
+### Type
+
+```ts
+function diffNuxtConfig (oldConfig: NuxtConfig, newConfig: NuxtConfig): NuxtConfigDiffEntry[]
+```
+
+### Parameters
+
+**`oldConfig`**: The previous `rawConfig` snapshot.
+
+**`newConfig`**: The current `rawConfig` snapshot.
+
+### Return Value
+
+An array of entries, one per difference. Each entry has:
+
+| Property   | Type                       | Description                                                                                                                                                       |
+| ---------- | -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `type`     | `'added' \| 'removed' \| 'changed'` | How the value changed.                                                                                                                                    |
+| `path`     | `Array<string \| number>`  | Property path of the changed value, with array indices as numbers, such as `['runtimeConfig', 'public', 'foo']`. Prefer this when reading the value back out of a config object. |
+| `label`    | `string`                   | `path` written as a property accessor, for display or for matching against a known key, such as `runtimeConfig.public.foo` or `modules[0]`.                        |
+| `newValue` | `unknown`                  | Present for `added` and `changed` entries.                                                                                                                        |
+| `oldValue` | `unknown`                  | Present for `removed` and `changed` entries.                                                                                                                      |
+
+Functions whose source is unchanged are not reported as changes, so a config that declares inline functions does not diff against itself on every load.
+
+### Example
+
+```ts
+import { diffNuxtConfig, loadNuxtConfig } from '@nuxt/kit'
+
+let previous
+
+async function load () {
+  await loadNuxtConfig({
+    cwd: process.cwd(),
+    onConfigResolved ({ rawConfig }) {
+      if (previous) {
+        for (const entry of diffNuxtConfig(previous, rawConfig)) {
+          console.log(`${entry.label} was ${entry.type}`)
+        }
+      }
+      previous = rawConfig
+    },
+  })
+}
+```
 
 ## `writeTypes`
 

package/4.api/5.kit/3.compatibility.md

@@ -63,7 +63,7 @@ function assertNuxtCompatibility (constraints: NuxtCompatibility, nuxt?: Nuxt):
 
 ### Parameters
 
-**`constraints`**: Version and builder constraints to check against. Refer to the [constraints table in `checkNuxtCompatibility`](/docs/4.x/api/kit/compatibility#parameters) for details.
+**`constraints`**: Version and builder constraints to check against. Refer to the [constraints table in `checkNuxtCompatibility`](/docs/api/kit/compatibility#parameters) for details.
 
 **`nuxt`**: Nuxt instance. If not provided, it will be retrieved from the context via `useNuxt()` call.
 
@@ -96,7 +96,7 @@ function hasNuxtCompatibility (constraints: NuxtCompatibility, nuxt?: Nuxt): Pro
 
 ### Parameters
 
-**`constraints`**: Version and builder constraints to check against. Refer to the [constraints table in `checkNuxtCompatibility`](/docs/4.x/api/kit/compatibility#parameters) for details.
+**`constraints`**: Version and builder constraints to check against. Refer to the [constraints table in `checkNuxtCompatibility`](/docs/api/kit/compatibility#parameters) for details.
 
 **`nuxt`**: Nuxt instance. If not provided, it will be retrieved from the context via `useNuxt()` call.
 

package/4.api/5.kit/4.autoimports.md

@@ -15,7 +15,7 @@ With Nuxt Kit you can also add your own auto-imports. `addImports` and `addImpor
 These utilities are powered by [`unimport`](https://github.com/unjs/unimport), which provides the underlying auto-import mechanism used in Nuxt.
 
 ::note
-These functions are designed for registering your own utils, composables and Vue APIs. For pages, components and plugins, please refer to the specific sections: [Pages](/docs/4.x/api/kit/pages), [Components](/docs/4.x/api/kit/components), [Plugins](/docs/4.x/api/kit/plugins).
+These functions are designed for registering your own utils, composables and Vue APIs. For pages, components and plugins, please refer to the specific sections: [Pages](/docs/api/kit/pages), [Components](/docs/api/kit/components), [Plugins](/docs/api/kit/plugins).
 ::
 
 ::tip{icon="i-lucide-video" to="https://vueschool.io/lessons/expanding-nuxt-s-auto-imports?friend=nuxt" target="_blank"}
@@ -27,7 +27,7 @@ Watch Vue School video about Auto-imports Nuxt Kit utilities.
 Add imports to the Nuxt application. It makes your imports available in the Nuxt app context without the need to import them manually.
 
 ::tip
-To add imports for the Nitro server context, refer to the [`addServerImports`](/docs/4.x/api/kit/nitro#addserverimports) function.
+To add imports for the Nitro server context, refer to the [`addServerImports`](/docs/api/kit/nitro#addserverimports) function.
 ::
 
 ### Usage
@@ -55,7 +55,7 @@ export default defineNuxtModule({
 ### Type
 
 ```ts
-function addImports (imports: Import | Import[]): void
+function addImports (imports: NuxtImport | NuxtImport[]): void
 ```
 
 ### Parameters
@@ -138,22 +138,22 @@ export default defineNuxtModule({
 ### Type
 
 ```ts
-function addImportsSources (importSources: Preset | Preset[]): void
+function addImportsSources (importSources: NuxtImportPresetSource | NuxtImportPresetSource[]): void
 ```
 
 ### Parameters
 
 **importSources**: An object or an array of objects with the following properties:
 
-- InlinePreset
+- `NuxtImportPreset`
 
-| Property  | Type                                        | Required | Description                                                                                    |
-|-----------|---------------------------------------------|----------|------------------------------------------------------------------------------------------------|
-| `from`    | `string`                                    | `true`   | Module specifier to import from.                                                               |
-| `imports` | `PresetImport \| ImportSource[]`{lang="ts"} | `true`   | An object or an array of objects, which can be import names, import objects or import sources. |
+| Property  | Type                                                 | Required | Description                                                                       |
+|-----------|------------------------------------------------------|----------|-----------------------------------------------------------------------------------|
+| `from`    | `string`                                             | `true`   | Module specifier to import from.                                                  |
+| `imports` | `(NuxtImportEntry \| NuxtImportPreset)[]`{lang="ts"} | `true`   | An array of entries, which can be import names, import objects or nested presets. |
 
-- PackagePreset
+- `NuxtPackageImportPreset`
 
-| Property  | Type                                        | Required | Description                                                                                    |
-|-----------|---------------------------------------------|----------|------------------------------------------------------------------------------------------------|
-| `package` | `string`                                    | `true`   | Name of the package.                                                               |
+| Property  | Type     | Required | Description          |
+|-----------|----------|----------|----------------------|
+| `package` | `string` | `true`   | Name of the package. |

package/4.api/5.kit/5.components.md

@@ -58,7 +58,7 @@ function addComponentsDir (dir: ComponentsDir, opts: { prepend?: boolean } = {})
 | `isAsync`         | `boolean`                                                                                | `false`  | This flag indicates, component should be loaded async (with a separate chunk) regardless of using Lazy prefix or not.                                                                                                                                   |
 | `extendComponent` | `(component: Component) => Promise<Component \| void> \| (Component \| void)`{lang="ts"} | `false`  | A function that will be called for each component found in the directory. It accepts a component object and should return a component object or a promise that resolves to a component object.                                                          |
 | `global`          | `boolean`                                                                                | `false`  | If enabled, registers components to be globally available.                                                                                                                                                                                              |
-| `island`          | `boolean`                                                                                | `false`  | If enabled, registers components as islands. You can read more about islands in [`<NuxtIsland/>`](/docs/4.x/api/components/nuxt-island) component description.                                                                                          |
+| `island`          | `boolean`                                                                                | `false`  | If enabled, registers components as islands. You can read more about islands in [`<NuxtIsland/>`](/docs/api/components/nuxt-island) component description.                                                                                          |
 | `watch`           | `boolean`                                                                                | `false`  | Watch specified path for changes, including file additions and file deletions.                                                                                                                                                                          |
 | `extensions`      | `string[]`                                                                               | `false`  | Extensions supported by Nuxt builder.                                                                                                                                                                                                                   |
 | `transpile`       | `'auto' \| boolean`{lang="ts"}                                                           | `false`  | Transpile specified path using build.transpile. If set to `'auto'`, it will set `transpile: true` if `node_modules/` is in path.                                                                                                                        |
@@ -113,7 +113,7 @@ function addComponent (options: AddComponentOptions): void
 |-------------------|--------------------------------------------|----------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|  
 | `name`            | `string`                                   | `true`   | Component name.                                                                                                                                                                                                                                         |
 | `filePath`        | `string`                                   | `true`   | Path to the component.                                                                                                                                                                                                                                  |
-| `declarationPath` | `string`                                   | `false`  | Path to component's declaration file. It is used to generate components' [type templates](/docs/4.x/api/kit/templates#addtypetemplate); if not provided, `filePath` is used instead.                                                                    |
+| `declarationPath` | `string`                                   | `false`  | Path to component's declaration file. It is used to generate components' [type templates](/docs/api/kit/templates#addtypetemplate); if not provided, `filePath` is used instead.                                                                    |
 | `pascalName`      | `string`                                   | `false`  | Pascal case component name. If not provided, it will be generated from the component name.                                                                                                                                                              |
 | `kebabName`       | `string`                                   | `false`  | Kebab case component name. If not provided, it will be generated from the component name.                                                                                                                                                               |
 | `export`          | `string`                                   | `false`  | Specify named or default export. If not provided, it will be set to `'default'`.                                                                                                                                                                        |
@@ -122,7 +122,7 @@ function addComponent (options: AddComponentOptions): void
 | `prefetch`        | `boolean`                                  | `false`  | These properties (prefetch/preload) are used in production to configure how components with Lazy prefix are handled by webpack via its magic comments. Learn more on [webpack documentation](https://webpack.js.org/api/module-methods/#magic-comments) |  
 | `preload`         | `boolean`                                  | `false`  | These properties (prefetch/preload) are used in production to configure how components with Lazy prefix are handled by webpack via its magic comments. Learn more on [webpack documentation](https://webpack.js.org/api/module-methods/#magic-comments) |
 | `global`          | `boolean`                                  | `false`  | If enabled, registers component to be globally available.                                                                                                                                                                                               |
-| `island`          | `boolean`                                  | `false`  | If enabled, registers component as island. You can read more about islands in [`<NuxtIsland/>`](/docs/4.x/api/components/nuxt-island) component description.                                                                                            |
+| `island`          | `boolean`                                  | `false`  | If enabled, registers component as island. You can read more about islands in [`<NuxtIsland/>`](/docs/api/components/nuxt-island) component description.                                                                                            |
 | `mode`            | `'client' \| 'server' \| 'all'`{lang="ts"} | `false`  | This options indicates if component should render on client, server or both. By default, it will render on both client and server.                                                                                                                      |
 | `priority`        | `number`                                   | `false`  | Priority of the component, if multiple components have the same name, the one with the highest priority will be used.                                                                                                                                   |
 

package/4.api/5.kit/6.context.md

@@ -47,10 +47,10 @@ The `useNuxt` function returns the Nuxt instance, which contains all the options
 | Property   | Type                                                                      | Description                                                                                               |
 | ---------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
 | `options`  | `NuxtOptions`                                                             | The resolved Nuxt configuration.                                                                          |
-| `hooks`    | `Hookable<NuxtHooks>`                                                     | The Nuxt hook system. Allows registering and listening to lifecycle events.                               |
+| `hooks`    | `NuxtHookRegistry<NuxtHooks>`                                             | The Nuxt hook system. Allows registering and listening to lifecycle events.                               |
 | `hook`     | `(name: string, (...args: any[]) => Promise<void> \| void) => () => void` | Shortcut for `nuxt.hooks.hook`. Registers a single callback for a specific lifecycle hook.                |
 | `callHook` | `(name: string, ...args: any[]) => Promise<any>`                          | Shortcut for `nuxt.hooks.callHook`. Triggers a lifecycle hook manually and runs all registered callbacks. |
-| `addHooks` | `(configHooks: NestedHooks) => () => void`                                | Shortcut for `nuxt.hooks.addHooks`. Registers multiple hooks at once.                                     |
+| `addHooks` | `(configHooks: NuxtNestedHooks) => () => void`                            | Shortcut for `nuxt.hooks.addHooks`. Registers multiple hooks at once.                                     |
 
 ### Example
 

package/4.api/5.kit/7.pages.md

@@ -51,11 +51,42 @@ function extendPages (callback: (pages: NuxtPage[]) => void): void
 | `name`     | `string`                           | `false`  | The name of the route. Useful for programmatic navigation and identifying routes.            |
 | `path`     | `string`                           | `false`  | The route URL path. If not set, Nuxt will infer it from the file location.                   |
 | `file`     | `string`                           | `false`  | Path to the Vue file that should be used as the component for the route.                     |
-| `meta`     | `Record<string, any>`{lang="ts"}   | `false`  | Custom metadata for the route. Can be used in layouts, middlewares, or navigation guards.    |
+| `meta`     | `NuxtPageMeta`{lang="ts"}          | `false`  | Custom metadata for the route. Can be used in layouts, middlewares, or navigation guards.    |
 | `alias`    | `string[] \| string`{lang="ts"}    | `false`  | One or more alias paths for the route. Useful for supporting multiple URLs.                  |
 | `redirect` | `RouteLocationRaw`{lang="ts"}      | `false`  | Redirect rule for the route. Supports named routes, objects, or string paths.                |
 | `children` | `NuxtPage[]`{lang="ts"}            | `false`  | Nested child routes under this route for layout or view nesting.                             |
 
+### Typing Custom Page Metadata
+
+You can augment the `NuxtPageMeta` interface to add type-safe custom metadata for pages when using `extendPages` or the `pages:extend` hook:
+
+```ts [index.d.ts]
+declare module '@nuxt/schema' {
+  interface NuxtPageMeta {
+    requiresAuth?: boolean
+  }
+}
+
+export {}
+```
+
+```ts [modules/auth.ts]
+import { defineNuxtModule, extendPages } from '@nuxt/kit'
+
+export default defineNuxtModule({
+  setup () {
+    extendPages((pages) => {
+      for (const page of pages) {
+        // requiresAuth is now typed as boolean | undefined
+        if (page.meta?.requiresAuth) {
+          // ...
+        }
+      }
+    })
+  },
+})
+```
+
 ## `extendRouteRules`
 
 Nuxt is powered by the [Nitro](https://nitro.build/) server engine. With Nitro, you can incorporate high-level logic directly into your configuration, which is useful for actions like redirects, proxying, caching, and appending headers to routes. This configuration works by associating route patterns with specific route settings.
@@ -113,7 +144,7 @@ function extendRouteRules (route: string, rule: NitroRouteConfig, options?: Exte
 **rule**: A route rule configuration to apply to the matched route.
 
 ::tip
-About route rules configurations, you can get more detail in [Hybrid Rendering > Route Rules](/docs/4.x/guide/concepts/rendering#route-rules).
+About route rules configurations, you can get more detail in [Hybrid Rendering > Route Rules](/docs/guide/concepts/rendering#route-rules).
 ::
 
 **options**: An object to pass to the route configuration. If `override` is set to `true`, it will override the existing route configuration.
@@ -126,10 +157,10 @@ About route rules configurations, you can get more detail in [Hybrid Rendering >
 
 Registers route middlewares to be available for all routes or for specific routes.
 
-Route middlewares can be also defined in plugins via [`addRouteMiddleware`](/docs/4.x/api/utils/add-route-middleware) composable.
+Route middlewares can be also defined in plugins via [`addRouteMiddleware`](/docs/api/utils/add-route-middleware) composable.
 
 ::tip
-Read more about route middlewares in the [Route middleware documentation](/docs/4.x/getting-started/routing#route-middleware).
+Read more about route middlewares in the [Route middleware documentation](/docs/getting-started/routing#route-middleware).
 ::
 
 ::tip{icon="i-lucide-video" to="https://vueschool.io/lessons/adding-route-rules-and-route-middlewares?friend=nuxt" target="_blank"}

package/4.api/5.kit/8.layout.md

@@ -15,7 +15,7 @@ Layouts is used to be a wrapper around your pages. It can be used to wrap your p
 Register template as layout and add it to the layouts.
 
 ::note
-In Nuxt 2 `error` layout can also be registered using this utility. In Nuxt 3+ `error` layout [replaced](/docs/4.x/getting-started/error-handling#error-page) with `error.vue` page in project root.
+In Nuxt 2 `error` layout can also be registered using this utility. In Nuxt 3+ `error` layout [replaced](/docs/getting-started/error-handling#error-page) with `error.vue` page in project root.
 ::
 
 ### Usage