jishushell 0.6.5 → 0.7.3

package/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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'
+    }
   }
 ]

package/node_modules/fastify/fastify.d.ts

@@ -6,7 +6,7 @@ import { Socket } from 'node:net'
 import { BuildCompilerFromPool, ValidatorFactory } from '@fastify/ajv-compiler'
 import { FastifyError } from '@fastify/error'
 import { Options as FJSOptions, SerializerFactory } from '@fastify/fast-json-stringify-compiler'
-import { Config as FindMyWayConfig, ConstraintStrategy, HTTPVersion } from 'find-my-way'
+import { ConstraintStrategy, Config as FindMyWayConfig, HTTPVersion } from 'find-my-way'
 import { InjectOptions, CallbackFunc as LightMyRequestCallback, Chain as LightMyRequestChain, Response as LightMyRequestResponse } from 'light-my-request'
 
 import { AddContentTypeParser, ConstructorAction, FastifyBodyParser, FastifyContentTypeParser, getDefaultJsonParser, hasContentTypeParser, ProtoAction } from './types/content-type-parser'
@@ -28,7 +28,7 @@ import { FastifyRegister, FastifyRegisterOptions, RegisterOptions } from './type
 import { FastifyReply } from './types/reply'
 import { FastifyRequest, RequestGenericInterface } from './types/request'
 import { RouteGenericInterface, RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler } from './types/route'
-import { FastifySchema, FastifySchemaValidationError, FastifySchemaCompiler, FastifySerializerCompiler, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
+import { FastifySchema, FastifySchemaCompiler, FastifySchemaValidationError, FastifySerializerCompiler, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
 import { FastifyServerFactory, FastifyServerFactoryHandler } from './types/server-factory'
 import { FastifyTypeProvider, FastifyTypeProviderDefault, SafePromiseLike } from './types/type-provider'
 import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, RequestBodyDefault, RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from './types/utils'
@@ -90,7 +90,7 @@ declare namespace fastify {
 
   type TrustProxyFunction = (address: string, hop: number) => boolean
 
-  export type FastifyRouterOptions<RawServer extends RawServerBase> = Omit<FindMyWayConfigForServer<RawServer>, 'defaultRoute' | 'onBadUrl' | 'querystringParser'> & {
+  export type FastifyRouterOptions<RawServer extends RawServerBase> = Omit<FindMyWayConfigForServer<RawServer>, 'defaultRoute' | 'onBadUrl' | 'onMaxParamLength' | 'querystringParser'> & {
     defaultRoute?: (
       req: RawRequestDefaultExpression<RawServer>,
       res: RawReplyDefaultExpression<RawServer>
@@ -100,6 +100,11 @@ declare namespace fastify {
       req: RawRequestDefaultExpression<RawServer>,
       res: RawReplyDefaultExpression<RawServer>
     ) => void,
+    onMaxParamLength?: (
+      path: string,
+      req: RawRequestDefaultExpression<RawServer>,
+      res: RawReplyDefaultExpression<RawServer>
+    ) => void,
     querystringParser?: (str: string) => { [key: string]: unknown }
   }
 

package/node_modules/fastify/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '5.8.5'
+const VERSION = '5.9.0'
 
 const Avvio = require('avvio')
 const http = require('node:http')
@@ -63,6 +63,7 @@ const { defaultInitOptions } = getSecuredInitialConfig
 const {
   FST_ERR_ASYNC_CONSTRAINT,
   FST_ERR_BAD_URL,
+  FST_ERR_MAX_PARAM_LENGTH,
   FST_ERR_OPTIONS_NOT_OBJ,
   FST_ERR_QSP_NOT_FN,
   FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN,
@@ -92,7 +93,7 @@ function fastify (serverOptions) {
     disableRequestLogging,
     hasLogger,
     initialConfig
-  } = processOptions(serverOptions, defaultRoute, onBadUrl)
+  } = processOptions(serverOptions, defaultRoute, onBadUrl, onMaxParamLength)
 
   // Default router
   const router = buildRouting(options.routerOptions)
@@ -381,8 +382,7 @@ function fastify (serverOptions) {
       hookRunnerApplication('preClose', fastify[kAvvioBoot], fastify, function () {
         if (fastify[kState].listening) {
           /* istanbul ignore next: Cannot test this without Node.js core support */
-          if (forceCloseConnections === 'idle') {
-            // Not needed in Node 19
+          if (forceCloseConnections === 'idle' && options.serverFactory) {
             instance.server.closeIdleConnections()
             /* istanbul ignore next: Cannot test this without Node.js core support */
           } else if (serverHasCloseAllConnections && forceCloseConnections) {
@@ -423,8 +423,8 @@ function fastify (serverOptions) {
     })
   })
 
-  // Create bad URL context
-  const onBadUrlContext = new Context({
+  // Create route event (bad URL, max param length, etc) context
+  const routeEventContext = new Context({
     server: fastify,
     config: {}
   })
@@ -637,10 +637,10 @@ function fastify (serverOptions) {
 
   function onBadUrl (path, req, res) {
     if (options.frameworkErrors) {
-      const id = getGenReqId(onBadUrlContext.server, req)
-      const childLogger = createChildLogger(onBadUrlContext, options.logger, req, id)
+      const id = getGenReqId(routeEventContext.server, req)
+      const childLogger = createChildLogger(routeEventContext, options.logger, req, id)
 
-      const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
+      const request = new Request(id, null, req, null, childLogger, routeEventContext)
       const reply = new Reply(res, request, childLogger)
 
       const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
@@ -663,15 +663,43 @@ function fastify (serverOptions) {
     res.end(body)
   }
 
+  function onMaxParamLength (path, req, res) {
+    if (options.frameworkErrors) {
+      const id = getGenReqId(routeEventContext.server, req)
+      const childLogger = createChildLogger(routeEventContext, options.logger, req, id)
+
+      const request = new Request(id, null, req, null, childLogger, routeEventContext)
+      const reply = new Reply(res, request, childLogger)
+
+      const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
+      if (resolvedDisableRequestLogging === false) {
+        childLogger.info({ req: request }, 'incoming request')
+      }
+
+      return options.frameworkErrors(new FST_ERR_MAX_PARAM_LENGTH(path), request, reply)
+    }
+    const body = JSON.stringify({
+      error: 'Bad Request',
+      code: 'FST_ERR_MAX_PARAM_LENGTH',
+      message: `'${path}' is exceeding the max param length`,
+      statusCode: 414
+    })
+    res.writeHead(414, {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(body)
+    })
+    res.end(body)
+  }
+
   function buildAsyncConstraintCallback (isAsync, req, res) {
     if (isAsync === false) return undefined
     return function onAsyncConstraintError (err) {
       if (err) {
         if (options.frameworkErrors) {
-          const id = getGenReqId(onBadUrlContext.server, req)
-          const childLogger = createChildLogger(onBadUrlContext, options.logger, req, id)
+          const id = getGenReqId(routeEventContext.server, req)
+          const childLogger = createChildLogger(routeEventContext, options.logger, req, id)
 
-          const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
+          const request = new Request(id, null, req, null, childLogger, routeEventContext)
           const reply = new Reply(res, request, childLogger)
 
           const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
@@ -748,7 +776,7 @@ function fastify (serverOptions) {
     if (!options.allowErrorHandlerOverride && this[kErrorHandlerAlreadySet]) {
       throw new FST_ERR_ERROR_HANDLER_ALREADY_SET()
     } else if (this[kErrorHandlerAlreadySet]) {
-      FSTWRN004("To disable this behavior, set 'allowErrorHandlerOverride' to false or ignore this message. For more information, visit: https://fastify.dev/docs/latest/Reference/Server/#allowerrorhandleroverride")
+      FSTWRN004()
     }
 
     this[kErrorHandlerAlreadySet] = true
@@ -821,7 +849,7 @@ function fastify (serverOptions) {
   }
 }
 
-function processOptions (options, defaultRoute, onBadUrl) {
+function processOptions (options, defaultRoute, onBadUrl, onMaxParamLength) {
   // Options validations
   if (options && typeof options !== 'object') {
     throw new FST_ERR_OPTIONS_NOT_OBJ()
@@ -890,6 +918,7 @@ function processOptions (options, defaultRoute, onBadUrl) {
   options.routerOptions = buildRouterOptions(options, {
     defaultRoute,
     onBadUrl,
+    onMaxParamLength,
     ignoreTrailingSlash: defaultInitOptions.ignoreTrailingSlash,
     ignoreDuplicateSlashes: defaultInitOptions.ignoreDuplicateSlashes,
     maxParamLength: defaultInitOptions.maxParamLength,

package/node_modules/fastify/lib/content-type-parser.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { AsyncResource } = require('node:async_hooks')
-const { FifoMap: Fifo } = require('toad-cache')
+const { FifoMap: Fifo, LruMap: Lru } = require('toad-cache')
 const { parse: secureJsonParse } = require('secure-json-parse')
 const ContentType = require('./content-type')
 const {
@@ -39,6 +39,15 @@ function ContentTypeParser (bodyLimit, onProtoPoisoning, onConstructorPoisoning)
   this.parserList = ['application/json', 'text/plain']
   this.parserRegExpList = []
   this.cache = new Fifo(100)
+  this.ctCache = new Lru(100)
+}
+
+ContentTypeParser.prototype.getContentType = function (raw) {
+  let ct = this.ctCache.get(raw)
+  if (ct !== undefined) return ct
+  ct = new ContentType(raw)
+  this.ctCache.set(raw, ct)
+  return ct
 }
 
 ContentTypeParser.prototype.add = function (contentType, opts, parserFn) {
@@ -118,6 +127,8 @@ ContentTypeParser.prototype.existingParser = function (contentType) {
 
 ContentTypeParser.prototype.getParser = function (contentType) {
   if (typeof contentType === 'string') {
+    const cached = this.cache.get(contentType)
+    if (cached !== undefined) return cached
     contentType = new ContentType(contentType)
   }
   const ct = contentType.toString()
@@ -158,6 +169,7 @@ ContentTypeParser.prototype.removeAll = function () {
   this.parserRegExpList = []
   this.parserList = []
   this.cache = new Fifo(100)
+  this.ctCache = new Lru(100)
 }
 
 ContentTypeParser.prototype.remove = function (contentType) {