fastify 5.8.5 → 5.9.0

package/docs/Reference/Logging.md

@@ -13,8 +13,8 @@ As Fastify is focused on performance, it uses
 [pino](https://github.com/pinojs/pino) as its logger, with the default log
 level set to `'info'` when enabled.
 
-#### Basic logging setup
-Enabling the production JSON logger:
+#### Basic Logging Setup
+The following enables the production JSON logger:
 
 ```js
 const fastify = require('fastify')({
@@ -23,8 +23,8 @@ const fastify = require('fastify')({
 ```
 
 #### Environment-Specific Configuration
-Enabling the logger with appropriate configuration for local development,
-production, and test environments requires more configuration:
+Enabling the logger for local development, production, and test environments
+requires additional configuration:
 
 ```js
 const envToLogger = {
@@ -41,11 +41,13 @@ const envToLogger = {
   test: false,
 }
 const fastify = require('fastify')({
-  logger: envToLogger[environment] ?? true // defaults to true if no entry matches in the map
+  logger: envToLogger[environment] ?? true // defaults to true if no matching environment is found
 })
 ```
-⚠️ `pino-pretty` needs to be installed as a dev dependency. It is not included
-by default for performance reasons.
+
+> ⚠ Warning:
+> `pino-pretty` needs to be installed as a dev dependency. It is not included
+> by default for performance reasons.
 
 ### Usage
 The logger can be used in route handlers as follows:
@@ -57,22 +59,22 @@ fastify.get('/', options, function (request, reply) {
 })
 ```
 
-Trigger new logs outside route handlers using the Pino instance from the Fastify
-instance:
+To log outside route handlers, use the logger available on the Fastify instance:
+
 ```js
-fastify.log.info('Something important happened!');
+fastify.log.info('Something important happened!')
 ```
 
 #### Passing Logger Options
 To pass options to the logger, provide them to Fastify. See the
 [Pino documentation](https://github.com/pinojs/pino/blob/main/docs/api.md#options)
-for available options. To specify a file destination, use:
+for the full list of available options. To specify a file destination, use:
 
 ```js
 const fastify = require('fastify')({
   logger: {
     level: 'info',
-    file: '/path/to/file' // Will use pino.destination()
+    file: '/path/to/file' // Uses pino.destination()
   }
 })
 
@@ -103,20 +105,19 @@ const fastify = require('fastify')({
 #### Request ID Tracking
 By default, Fastify adds an ID to every request for easier tracking. If the
 `requestIdHeader` option is set and the corresponding header is present, its
-value is used; otherwise, a new incremental ID is generated. See Fastify Factory
-[`requestIdHeader`](./Server.md#factory-request-id-header) and Fastify Factory
+value is used; otherwise, a new incremental ID is generated. See the Fastify
+factory options [`requestIdHeader`](./Server.md#factory-request-id-header) and
 [`genReqId`](./Server.md#genreqid) for customization options.
 
 > ⚠ Warning:
-> Enabling `requestIdHeader` allows any callers to set `reqId` to a
-> value of their choosing.
-> No validation is performed on `requestIdHeader`.
+> Enabling `requestIdHeader` allows callers to set `reqId` to an arbitrary
+> value. No validation is performed on the header value.
 
 #### Serializers
 The default logger uses standard serializers for objects with `req`, `res`, and
 `err` properties. The `req` object is the Fastify [`Request`](./Request.md)
 object, and the `res` object is the Fastify [`Reply`](./Reply.md) object. This
-behavior can be customized with custom serializers.
+behavior can be overridden with custom serializers.
 
 ```js
 const fastify = require('fastify')({
@@ -129,8 +130,12 @@ const fastify = require('fastify')({
   }
 })
 ```
-For example, the response payload and headers could be logged using the approach
-below (not recommended):
+
+> ⚠ Warning:
+> Logging response headers may expose sensitive data, including authentication
+> data, and may violate privacy regulations.
+> Use [log redaction](#log-redaction) to remove sensitive information.
+> The following example is for demonstration purposes only:
 
 ```js
 const fastify = require('fastify')({
@@ -151,22 +156,19 @@ const fastify = require('fastify')({
           url: request.url,
           path: request.routeOptions.url,
           parameters: request.params,
-          // Including headers in the log could violate privacy laws,
-          // e.g., GDPR. Use the "redact" option to remove sensitive
-          // fields. It could also leak authentication data in the logs.
           headers: request.headers
-        };
+        }
       }
     }
   }
-});
+})
 ```
 
 > ℹ️ Note:
 > In some cases, the [`Reply`](./Reply.md) object passed to the `res`
 > serializer cannot be fully constructed. When writing a custom `res`
-> serializer, check for the existence of any properties on `reply` aside from
-> `statusCode`, which is always present. For example, verify the existence of
+> serializer, verify that any properties other than `statusCode` exist on
+> `reply` before accessing them. For example, verify the existence of
 > `getHeaders` before calling it:
 
 ```js
@@ -187,15 +189,15 @@ const fastify = require('fastify')({
       },
     }
   }
-});
+})
 ```
 
 > ℹ️ Note:
-> The body cannot be serialized inside a `req` method because the
+> The body cannot be serialized inside the `req` serializer because the
 > request is serialized when the child logger is created. At that time, the body
 > is not yet parsed.
 
-See the following approach to log `req.body`:
+To log `req.body`, use the `preHandler` hook:
 
 ```js
 app.addHook('preHandler', function (req, reply, done) {
@@ -207,18 +209,20 @@ app.addHook('preHandler', function (req, reply, done) {
 ```
 
 > ℹ️ Note:
-> Ensure serializers never throw errors, as this can cause the Node
+> Ensure serializers never throw errors, as this can cause the Node.js
 > process to exit. See the
-> [Pino documentation](https://getpino.io/#/docs/api?id=opt-serializers) for more
-> information.
+> [Pino documentation](https://getpino.io/#/docs/api?id=opt-serializers) for
+> more information.
 
-*Any logger other than Pino will ignore this option.*
+*Any logger other than Pino will ignore the `serializers` option.*
 
 ### Using Custom Loggers
 A custom logger instance can be supplied by passing it as `loggerInstance`. The
-logger must conform to the Pino interface, with methods: `info`, `error`,
-`debug`, `fatal`, `warn`, `trace`, `silent`, `child`, and a string property
-`level`.
+logger must conform to the Pino interface with the following:
+
+- **Methods:** `info`, `error`, `debug`, `fatal`, `warn`, `trace`, `silent`,
+  `child`
+- **Properties:** `level` (string)
 
 Example:
 
@@ -239,7 +243,7 @@ fastify.get('/', function (request, reply) {
 
 ### Log Redaction
 
-[Pino](https://getpino.io) supports low-overhead log redaction for obscuring
+[Pino](https://getpino.io) supports low-overhead log redaction for masking
 values of specific properties in recorded logs. For example, log all HTTP
 headers except the `Authorization` header for security:
 
@@ -265,4 +269,5 @@ const fastify = Fastify({
 })
 ```
 
-See https://getpino.io/#/docs/redaction for more details.
+See the [Pino redaction documentation](https://getpino.io/#/docs/redaction) for
+more details.

package/docs/Reference/Middleware.md

@@ -2,15 +2,13 @@
 
 ## Middleware
 
-Starting with Fastify v3.0.0, middleware is not supported out of the box and
-requires an external plugin such as
+As of Fastify v3.0.0, middleware is not supported out of the box and requires
+an external plugin such as
 [`@fastify/express`](https://github.com/fastify/fastify-express) or
 [`@fastify/middie`](https://github.com/fastify/middie).
 
-
-An example of registering the
-[`@fastify/express`](https://github.com/fastify/fastify-express) plugin to `use`
-Express middleware:
+The following example registers the `@fastify/express` plugin and uses Express
+middleware:
 
 ```js
 await fastify.register(require('@fastify/express'))
@@ -22,37 +20,35 @@ fastify.use(require('ienoopen')())
 fastify.use(require('x-xss-protection')())
 ```
 
-[`@fastify/middie`](https://github.com/fastify/middie) can also be used,
-which provides support for simple Express-style middleware with improved
-performance:
+[`@fastify/middie`](https://github.com/fastify/middie) can also be used, which
+provides support for simple Express-style middleware with improved performance:
 
 ```js
 await fastify.register(require('@fastify/middie'))
 fastify.use(require('cors')())
 ```
 
-Middleware can be encapsulated, allowing control over where it runs using
-`register` as explained in the [plugins guide](../Guides/Plugins-Guide.md).
+Middleware can be encapsulated using `register`, which controls where it runs,
+as explained in the [Plugins Guide](../Guides/Plugins-Guide.md).
 
-Fastify middleware does not expose the `send` method or other methods specific
-to the Fastify [Reply](./Reply.md#reply) instance. This is because Fastify wraps
-the incoming `req` and `res` Node instances using the
-[Request](./Request.md#request) and [Reply](./Reply.md#reply) objects
-internally, but this is done after the middleware phase. To create middleware,
-use the Node `req` and `res` instances. Alternatively, use the `preHandler` hook
-that already has the Fastify [Request](./Request.md#request) and
-[Reply](./Reply.md#reply) instances. For more information, see
-[Hooks](./Hooks.md#hooks).
+This is because Fastify wraps the incoming Node.js `req` and `res` objects into
+[Request](./Request.md#request) and [Reply](./Reply.md#reply) instances after
+the middleware phase. As a result, Fastify middleware does not expose the `send`
+method or other methods specific to the Fastify [Reply](./Reply.md#reply)
+instance. To create middleware, use the Node.js `req` and `res` objects.
+Alternatively, use the `preHandler` hook, which has access to the Fastify
+[Request](./Request.md#request) and [Reply](./Reply.md#reply) instances. For
+more information, see [Hooks](./Hooks.md).
 
-#### Restrict middleware execution to certain paths
+### Restrict Middleware Execution to Certain Paths
 <a id="restrict-usage"></a>
 
-To run middleware under certain paths, pass the path as the first parameter to
+To restrict middleware to specific paths, pass the path as the first argument to
 `use`.
 
 > ℹ️ Note:
 > This does not support routes with parameters
-> (e.g. `/user/:id/comments`) and wildcards are not supported in multiple paths.
+> (e.g., `/user/:id/comments`). Wildcards are not supported in multiple paths.
 
 ```js
 const path = require('node:path')
@@ -68,9 +64,9 @@ fastify.use('/css/(.*)', serveStatic(path.join(__dirname, '/assets')))
 fastify.use(['/css', '/js'], serveStatic(path.join(__dirname, '/assets')))
 ```
 
-### Alternatives
+### Fastify Alternatives
 
-Fastify offers alternatives to commonly used middleware, such as
+Fastify offers native alternatives to commonly used middleware, such as
 [`@fastify/helmet`](https://github.com/fastify/fastify-helmet) for
 [`helmet`](https://github.com/helmetjs/helmet),
 [`@fastify/cors`](https://github.com/fastify/fastify-cors) for

package/docs/Reference/Principles.md

@@ -3,8 +3,8 @@
 Every decision in the Fastify framework and its official plugins is guided by
 the following technical principles:
 
-1. “Zero” overhead in production
-2. “Good” developer experience
+1. "Zero" overhead in production
+2. "Good" developer experience
 3. Works great for small & big projects alike
 4. Easy to migrate to microservices (or even serverless) and back
 5. Security & data validation

package/docs/Reference/Reply.md

@@ -219,7 +219,7 @@ reply.getHeaders() // { 'x-foo': 'foo', 'x-bar': 'bar' }
 ```
 
 ### .removeHeader(key)
-<a id="getHeader"></a>
+<a id="removeHeader"></a>
 
 Remove the value of a previously set header.
 ```js
@@ -705,6 +705,11 @@ If you are sending a stream and you have not set a `'Content-Type'` header,
 As noted above, streams are considered to be pre-serialized, so they will be
 sent unmodified without response validation.
 
+When sending streams over HTTP/2, Fastify does not change the chunks emitted by
+the stream. If a stream can emit very large chunks, split them in your
+application code, for example by using `fs.createReadStream()` or a transform
+stream that emits smaller chunks.
+
 See special note about error handling for streams in
 [`setErrorHandler`](./Server.md#seterrorhandler).
 

package/docs/Reference/Request.md

@@ -16,28 +16,39 @@ Request is a core Fastify object containing the following fields:
   [encapsulation context](./Encapsulation.md).
 - `id` - The request ID.
 - `log` - The logger instance of the incoming request.
-- `ip` - The IP address of the incoming request.
-- `ips` - An array of the IP addresses, ordered from closest to furthest, in the
-  `X-Forwarded-For` header of the incoming request (only when the
-  [`trustProxy`](./Server.md#factory-trust-proxy) option is enabled).
+- `ip` - The IP address of the incoming request. This value is taken from
+  `socket.remoteAddress` (or from `X-Forwarded-For` when
+  [`trustProxy`](./Server.md#factory-trust-proxy) is enabled).
+- `ips` - An array of IP addresses, ordered from closest to furthest, from
+  `X-Forwarded-For` (only when
+  [`trustProxy`](./Server.md#factory-trust-proxy) is enabled).
 - `host` - The host of the incoming request (derived from `X-Forwarded-Host`
-  header when the [`trustProxy`](./Server.md#factory-trust-proxy) option is
-  enabled). For HTTP/2 compatibility, it returns `:authority` if no host header
-  exists. The host header may return an empty string if `requireHostHeader` is
-  `false`, not provided with HTTP/1.0, or removed by schema validation.
-  ⚠ Security: this value comes from client-controlled headers; only trust it
-  when you control proxy behavior and have validated or allow-listed hosts.
-  No additional validation is performed beyond RFC parsing (see
-  [RFC 9110, section 7.2](https://www.rfc-editor.org/rfc/rfc9110#section-7.2) and
-  [RFC 3986, section 3.2.2](https://www.rfc-editor.org/rfc/rfc3986#section-3.2.2)).
-- `hostname` - The hostname derived from the `host` property of the incoming request.
-- `port` - The port from the `host` property, which may refer to the port the
+  when [`trustProxy`](./Server.md#factory-trust-proxy) is enabled). For HTTP/2
+  compatibility, it returns `:authority` if no host header exists. The host
+  header may return an empty string if `requireHostHeader` is `false`, not
+  provided with HTTP/1.0, or removed by schema validation.
+- `hostname` - The hostname parsed from `request.host`.
+- `port` - The port parsed from `request.host`, which may refer to the port the
   server is listening on.
-- `protocol` - The protocol of the incoming request (`https` or `http`).
+- `protocol` - The protocol of the incoming request (`https` or `http`). This
+  value comes from `socket.encrypted` (or `X-Forwarded-Proto` when
+  [`trustProxy`](./Server.md#factory-trust-proxy) is enabled).
+
+> ⚠️ Security:
+> `request.ip`, `request.ips`, `request.host`, `request.hostname`,
+> `request.port`, and `request.protocol` come from request metadata
+> (socket and/or forwarding headers) and should be treated as untrusted input.
+> Fastify does not perform security validation for business logic.
+> If these values are used in security-sensitive decisions, they must 
+> be validated explicitly (for example: trusted proxy configuration,
+> allow-lists, strict parsing, and normalization).
+
 - `method` - The method of the incoming request.
 - `url` - The URL of the incoming request.
 - `originalUrl` - Similar to `url`, allows access to the original `url` in
   case of internal re-routing.
+- `mediaType` - The media type extracted from `Content-Type` header. When `Content-Type`
+  header is missing, it will return `undefined`.
 - `is404` - `true` if request is being handled by 404 handler, `false` otherwise.
 - `socket` - The underlying connection of the incoming request.
 - `signal` - An `AbortSignal` that aborts when the handler timeout

package/docs/Reference/Routes.md

@@ -102,7 +102,7 @@ fastify.route(options)
   schemas for request validations. See the [Validation and
   Serialization](./Validation-and-Serialization.md#schema-validator)
   documentation.
-* `serializerCompiler({ { schema, method, url, httpStatus, contentType } })`:
+* `serializerCompiler({ schema, method, url, httpStatus, contentType })`:
   function that builds schemas for response serialization. See the [Validation and
   Serialization](./Validation-and-Serialization.md#schema-serializer)
   documentation.
@@ -513,6 +513,9 @@ See the `prefixTrailingSlash` route option above to change this behavior.
 Different log levels can be set for routes in Fastify by passing the `logLevel`
 option to the plugin or route with the desired
 [value](https://github.com/pinojs/pino/blob/main/docs/api.md#level-string).
+If a route `logLevel` is invalid, Fastify throws
+[`FST_ERR_ROUTE_LOG_LEVEL_INVALID`](./Errors.md#fst_err_route_log_level_invalid)
+during route registration.
 
 Be aware that setting `logLevel` at the plugin level also affects
 [`setNotFoundHandler`](./Server.md#setnotfoundhandler) and
@@ -670,7 +673,7 @@ fastify.inject({
 
 > ⚠ Warning:
 > Set a
-> [`Vary`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Vary)
+> [`Vary`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Vary)
 > header in responses with the value used for versioning
 > (e.g., `'Accept-Version'`) to prevent cache poisoning attacks.
 > This can also be configured in a Proxy/CDN.

package/docs/Reference/Server.md

@@ -48,6 +48,7 @@ describes the properties available in that options object.
     - [`ignoreTrailingSlash`](#ignoretrailingslash)
     - [`maxParamLength`](#maxparamlength)
     - [`onBadUrl`](#onbadurl)
+    - [`onMaxParamLength`](#onmaxparamlength)
     - [`querystringParser`](#querystringparser)
     - [`useSemicolonDelimiter`](#usesemicolondelimiter)
 - [Instance](#instance)
@@ -560,6 +561,12 @@ For more examples, refer to the
 You may access the `ip`, `ips`, `host` and `protocol` values on the
 [`request`](./Request.md) object.
 
+> ⚠️ Security:
+> These values are derived from socket/forwarding metadata and must be treated
+> as untrusted input unless your proxy chain is explicitly trusted and
+> validated. Do not use them directly for authorization or other
+> security-sensitive decisions without explicit validation.
+
 ```js
 fastify.get('/', (request, reply) => {
   console.log(request.ip)
@@ -720,7 +727,7 @@ const fastify = require('fastify')({
       res.code(400)
       return res.send("Provided header is not valid")
     } else {
-      res.send(err)
+      res.send(error)
     }
   }
 })
@@ -921,7 +928,7 @@ const fastify = require('fastify')({
 ```
 
 ### `defaultRoute`
-<a id="on-bad-url"></a>
+<a id="default-route"></a>
 
 Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) which supports,
 can pass a default route with the option defaultRoute.
@@ -1037,6 +1044,27 @@ const fastify = require('fastify')({
 As with `defaultRoute`, `req` and `res` are the raw Node.js request/response
 objects and do not provide Fastify's decorated helpers.
 
+### `onMaxParamLength`
+<a id="on-max-param-length"></a>
+
+Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) which supports,
+the use case of a provide custom handler when `maxParamLength ` is exceed.
+
+```js
+const fastify = require('fastify')({
+  routerOptions: {
+    maxParamLength: 10,
+    onMaxParamLength: (path, req, res) => {
+      res.statusCode = 414
+      res.end(`Bad path: ${path}`)
+    }
+  }
+})
+```
+
+As with `defaultRoute`, `req` and `res` are the raw Node.js request/response
+objects and do not provide Fastify's decorated helpers.
+
 ### `querystringParser`
 <a id="querystringparser"></a>
 
@@ -2249,7 +2277,7 @@ fastify.get('/', {
       return
     }
 
-    fastify.errorHandler(error, request, response)
+    fastify.errorHandler(error, request, reply)
   }
 }, handler)
 ```

package/docs/Reference/Type-Providers.md

@@ -23,8 +23,7 @@ See also the Type Provider wrapper packages for each of the packages respectivel
 
 - [`@fastify/type-provider-json-schema-to-ts`](https://github.com/fastify/fastify-type-provider-json-schema-to-ts)
 - [`@fastify/type-provider-typebox`](https://github.com/fastify/fastify-type-provider-typebox)
-- [`fastify-type-provider-zod`](https://github.com/turkerdev/fastify-type-provider-zod)
- (3rd party)
+- [`@fastify/type-provider-zod`](https://github.com/fastify/fastify-type-provider-zod)
 
 ### Json Schema to Ts
 
@@ -88,14 +87,39 @@ server.get('/route', {
 ```
 
 See the [TypeBox
-documentation](https://sinclairzx81.github.io/typebox/#/docs/overview/2_setup)
+documentation](https://sinclairzx81.github.io/typebox/)
 for setting-up AJV to work with TypeBox.
 
 ### Zod
 
-See [official documentation](https://github.com/turkerdev/fastify-type-provider-zod)
-for Zod Type Provider instructions.
+The following sets up a Zod Type Provider:
 
+```bash
+$ npm i zod @fastify/type-provider-zod
+```
+
+```typescript
+import fastify from 'fastify'
+import { ZodTypeProvider, serializerCompiler, validatorCompiler } from '@fastify/type-provider-zod'
+import { z } from 'zod/v4'
+
+const server = fastify()
+server.setValidatorCompiler(validatorCompiler)
+server.setSerializerCompiler(serializerCompiler)
+
+server.withTypeProvider<ZodTypeProvider>().get('/route', {
+  schema: {
+    querystring: z.object({
+      foo: z.number(),
+      bar: z.string()
+    })
+  }
+}, (request, reply) => {
+
+  // type Query = { foo: number, bar: string }
+  const { foo, bar } = request.query // type safe!
+})
+```
 
 ### Scoped Type-Provider
 

package/docs/Reference/Validation-and-Serialization.md

@@ -300,6 +300,12 @@ Note that Ajv will try to [coerce](https://ajv.js.org/coercion.html) values to
 the types specified in the schema `type` keywords, both to pass validation and
 to use the correctly typed data afterwards.
 
+> ⚠ Important:
+> Fastify uses a custom [AJV configuration][1] such as `coerceTypes: 'array'`.
+> Evaluate its behavior and verify if it meets the project requirements.
+
+[1]: https://github.com/fastify/ajv-compiler?tab=readme-ov-file#ajv-configuration
+
 The Ajv default configuration in Fastify supports coercing array parameters in
 `querystring`. Example:
 
@@ -583,6 +589,11 @@ fastify.post('/the/url', {
 }, handler)
 ```
 
+Fastify supports different JSON Schema validators via
+`setValidatorCompiler`. Community plugins that integrate alternative JSON
+Schema validators are listed on the
+[Ecosystem](https://fastify.dev/docs/latest/Guides/Ecosystem/) page.
+
 ##### Custom Validator Best Practices
 
 When implementing custom validators, follow these patterns to ensure compatibility
@@ -920,8 +931,10 @@ For custom error responses in the schema, see
 [example](https://github.com/fastify/example/blob/HEAD/validation-messages/custom-errors-messages.js)
 usage.
 
-> Install version 1.0.1 of `ajv-errors`, as later versions are not compatible
-> with AJV v6 (the version shipped by Fastify v3).
+> Fastify v5 uses AJV v8 and requires a compatible `ajv-errors` version.
+> Fastify v3 requires `ajv-errors@1.0.1`, which supports AJV v6.
+> See the [AJV compiler versions table](https://github.com/fastify/ajv-compiler/#versions)
+> for the AJV version used by each Fastify release.
 
 Below is an example showing how to add **custom error messages for each
 property** of a schema by supplying custom AJV options. Inline comments in the

package/docs/Reference/Warnings.md

@@ -6,7 +6,8 @@
   - [Warnings In Fastify](#warnings-in-fastify)
   - [Fastify Warning Codes](#fastify-warning-codes)
     - [FSTWRN001](#FSTWRN001)
-    - [FSTWRN002](#FSTWRN002)
+    - [FSTWRN003](#FSTWRN003)
+    - [FSTWRN004](#FSTWRN004)
   - [Fastify Deprecation Codes](#fastify-deprecation-codes)
     - [FSTDEP022](#FSTDEP022)
 
@@ -14,7 +15,7 @@
 
 ### Warnings In Fastify
 
-Fastify uses Node.js's [warning event](https://nodejs.org/api/process.html#event-warning)
+Fastify uses the Node.js [warning event](https://nodejs.org/api/process.html#event-warning)
 API to notify users of deprecated features and coding mistakes. Fastify's
 warnings are recognizable by the `FSTWRN` and `FSTDEP` prefixes. When
 encountering such a warning, it is highly recommended to determine the cause
@@ -22,7 +23,7 @@ using the [`--trace-warnings`](https://nodejs.org/api/cli.html#trace-warnings)
 and [`--trace-deprecation`](https://nodejs.org/api/cli.html#trace-deprecation)
 flags. These produce stack traces pointing to where the issue occurs in the
 application's code. Issues opened about warnings without this information will
-be closed due to lack of details.
+be closed.
 
 Warnings can also be disabled, though it is not recommended. If necessary, use
 one of the following methods:
@@ -33,15 +34,15 @@ one of the following methods:
 
 For more information on disabling warnings, see [Node's documentation](https://nodejs.org/api/cli.html).
 
-Disabling warnings may cause issues when upgrading Fastify versions. Only
-experienced users should consider disabling warnings.
+Disabling warnings is not recommended and may cause unexpected behavior.
 
 ### Fastify Warning Codes
 
 | Code | Description | How to solve | Discussion |
 | ---- | ----------- | ------------ | ---------- |
 | <a id="FSTWRN001">FSTWRN001</a> | The specified schema for a route is missing. This may indicate the schema is not well specified. | Check the schema for the route. | [#4647](https://github.com/fastify/fastify/pull/4647) |
-| <a id="FSTWRN002">FSTWRN002</a> | The %s plugin being registered mixes async and callback styles, which will result in an error in `fastify@5`. | Do not mix async and callback style. | [#5139](https://github.com/fastify/fastify/pull/5139) |
+| <a id="FSTWRN003">FSTWRN003</a> | The `%s` plugin mixes async and callback styles, which may lead to unhandled rejections. | Do not mix async and callback style. | [#6011](https://github.com/fastify/fastify/pull/6011) |
+| <a id="FSTWRN004">FSTWRN004</a> | An `errorHandler` is being overridden in the same scope, which can lead to subtle bugs. | Avoid calling `setErrorHandler` more than once in the same scope. For more information, see [Server documentation](https://fastify.dev/docs/latest/Reference/Server/#allowerrorhandleroverride). | [#6104](https://github.com/fastify/fastify/pull/6104) |
 
 
 ### Fastify Deprecation Codes

package/eslint.config.js

@@ -6,8 +6,7 @@ module.exports = [
     ignores: [
       'lib/config-validator.js',
       'lib/error-serializer.js',
-      'test/same-shape.test.js',
-      'test/types/import.js'
+      'test/same-shape.test.js'
     ],
     ts: true
   }),
@@ -31,5 +30,11 @@ module.exports = [
     rules: {
       'max-len': 'off'
     }
+  },
+  {
+    files: ['test/types/**/*'],
+    rules: {
+      '@typescript-eslint/no-unused-vars': 'off'
+    }
   }
 ]