fastify 3.24.0 → 3.25.2

package/docs/{Hooks.md → Reference/Hooks.md}

@@ -2,9 +2,12 @@
 
 ## Hooks
 
-Hooks are registered with the `fastify.addHook` method and allow you to listen to specific events in the application or request/response lifecycle. You have to register a hook before the event is triggered, otherwise, the event is lost.
+Hooks are registered with the `fastify.addHook` method and allow you to listen
+to specific events in the application or request/response lifecycle. You have to
+register a hook before the event is triggered, otherwise, the event is lost.
 
-By using hooks you can interact directly with the lifecycle of Fastify. There are Request/Reply hooks and application hooks:
+By using hooks you can interact directly with the lifecycle of Fastify. There
+are Request/Reply hooks and application hooks:
 
 - [Request/Reply Hooks](#requestreply-hooks)
   - [onRequest](#onrequest)
@@ -25,18 +28,26 @@ By using hooks you can interact directly with the lifecycle of Fastify. There ar
   - [onRegister](#onregister)
 - [Scope](#scope)
 - [Route level hooks](#route-level-hooks)
+- [Diagnostics Channel Hooks](#diagnostics-channel-hooks)
 
-**Notice:** the `done` callback is not available when using `async`/`await` or returning a `Promise`. If you do invoke a `done` callback in this situation unexpected behavior may occur, e.g. duplicate invocation of handlers.
+**Notice:** the `done` callback is not available when using `async`/`await` or
+returning a `Promise`. If you do invoke a `done` callback in this situation
+unexpected behavior may occur, e.g. duplicate invocation of handlers.
 
 ## Request/Reply Hooks
 
-[Request](Request.md) and [Reply](Reply.md) are the core Fastify objects.<br/>
-`done` is the function to continue with the [lifecycle](Lifecycle.md).
+[Request](./Request.md) and [Reply](./Reply.md) are the core Fastify objects.
 
-It is easy to understand where each hook is executed by looking at the [lifecycle page](Lifecycle.md).<br>
-Hooks are affected by Fastify's encapsulation, and can thus be applied to selected routes. See the [Scopes](#scope) section for more information.
+`done` is the function to continue with the [lifecycle](./Lifecycle.md).
 
-There are eight different hooks that you can use in Request/Reply *(in order of execution)*:
+It is easy to understand where each hook is executed by looking at the
+[lifecycle page](./Lifecycle.md).
+
+Hooks are affected by Fastify's encapsulation, and can thus be applied to
+selected routes. See the [Scopes](#scope) section for more information.
+
+There are eight different hooks that you can use in Request/Reply *(in order of
+execution)*:
 
 ### onRequest
 ```js
@@ -53,13 +64,18 @@ fastify.addHook('onRequest', async (request, reply) => {
 })
 ```
 
-**Notice:** in the [onRequest](#onrequest) hook, `request.body` will always be `null`, because the body parsing happens before the [preValidation](#prevalidation) hook.
+**Notice:** in the [onRequest](#onrequest) hook, `request.body` will always be
+`null`, because the body parsing happens before the
+[preValidation](#prevalidation) hook.
 
 ### preParsing
 
-If you are using the `preParsing` hook, you can transform the request payload stream before it is parsed. It receives the request and reply objects as other hooks, and a stream with the current request payload.
+If you are using the `preParsing` hook, you can transform the request payload
+stream before it is parsed. It receives the request and reply objects as other
+hooks, and a stream with the current request payload.
 
-If it returns a value (via `return` or via the callback function), it must return a stream.
+If it returns a value (via `return` or via the callback function), it must
+return a stream.
 
 For instance, you can uncompress the request body:
 
@@ -78,15 +94,23 @@ fastify.addHook('preParsing', async (request, reply, payload) => {
 })
 ```
 
-**Notice:** in the [preParsing](#preparsing) hook, `request.body` will always be `null`, because the body parsing happens before the [preValidation](#prevalidation) hook.
+**Notice:** in the [preParsing](#preparsing) hook, `request.body` will always be
+`null`, because the body parsing happens before the
+[preValidation](#prevalidation) hook.
 
-**Notice:** you should also add a `receivedEncodedLength` property to the returned stream. This property is used to correctly match the request payload with the `Content-Length` header value. Ideally, this property should be updated on each received chunk.
+**Notice:** you should also add a `receivedEncodedLength` property to the
+returned stream. This property is used to correctly match the request payload
+with the `Content-Length` header value. Ideally, this property should be updated
+on each received chunk.
 
-**Notice**: The old syntaxes `function(request, reply, done)` and `async function(request, reply)` for the parser are still supported but they are deprecated.
+**Notice**: The old syntaxes `function(request, reply, done)` and `async
+function(request, reply)` for the parser are still supported but they are
+deprecated.
 
 ### preValidation
 
-If you are using the `preValidation` hook, you can change the payload before it is validated. For example:
+If you are using the `preValidation` hook, you can change the payload before it
+is validated. For example:
 
 ```js
 fastify.addHook('preValidation', (request, reply, done) => {
@@ -118,7 +142,8 @@ fastify.addHook('preHandler', async (request, reply) => {
 ```
 ### preSerialization
 
-If you are using the `preSerialization` hook, you can change (or replace) the payload before it is serialized. For example:
+If you are using the `preSerialization` hook, you can change (or replace) the
+payload before it is serialized. For example:
 
 ```js
 fastify.addHook('preSerialization', (request, reply, payload, done) => {
@@ -134,7 +159,8 @@ fastify.addHook('preSerialization', async (request, reply, payload) => {
 })
 ```
 
-Note: the hook is NOT called if the payload is a `string`, a `Buffer`, a `stream`, or `null`.
+Note: the hook is NOT called if the payload is a `string`, a `Buffer`, a
+`stream`, or `null`.
 
 ### onError
 ```js
@@ -150,10 +176,19 @@ fastify.addHook('onError', async (request, reply, error) => {
   // You should not use this hook to update the error
 })
 ```
-This hook is useful if you need to do some custom error logging or add some specific header in case of error.<br/>
-It is not intended for changing the error, and calling `reply.send` will throw an exception.<br/>
-This hook will be executed only after the `customErrorHandler` has been executed, and only if the `customErrorHandler` sends an error back to the user *(Note that the default `customErrorHandler` always sends the error back to the user)*.<br/>
-**Notice:** unlike the other hooks, pass an error to the `done` function is not supported.
+This hook is useful if you need to do some custom error logging or add some
+specific header in case of error.
+
+It is not intended for changing the error, and calling `reply.send` will throw
+an exception.
+
+This hook will be executed only after the `customErrorHandler` has been
+executed, and only if the `customErrorHandler` sends an error back to the user
+*(Note that the default `customErrorHandler` always sends the error back to the
+user)*.
+
+**Notice:** unlike the other hooks, pass an error to the `done` function is not
+supported.
 
 ### onSend
 If you are using the `onSend` hook, you can change the payload. For example:
@@ -173,7 +208,8 @@ fastify.addHook('onSend', async (request, reply, payload) => {
 })
 ```
 
-You can also clear the payload to send a response with an empty body by replacing the payload with `null`:
+You can also clear the payload to send a response with an empty body by
+replacing the payload with `null`:
 
 ```js
 fastify.addHook('onSend', (request, reply, payload, done) => {
@@ -183,14 +219,17 @@ fastify.addHook('onSend', (request, reply, payload, done) => {
 })
 ```
 
-> You can also send an empty body by replacing the payload with the empty string `''`, but be aware that this will cause the `Content-Length` header to be set to `0`, whereas the `Content-Length` header will not be set if the payload is `null`.
+> You can also send an empty body by replacing the payload with the empty string
+> `''`, but be aware that this will cause the `Content-Length` header to be set
+> to `0`, whereas the `Content-Length` header will not be set if the payload is
+> `null`.
 
-Note: If you change the payload, you may only change it to a `string`, a `Buffer`, a `stream`, or `null`.
+Note: If you change the payload, you may only change it to a `string`, a
+`Buffer`, a `stream`, or `null`.
 
 
 ### onResponse
 ```js
-
 fastify.addHook('onResponse', (request, reply, done) => {
   // Some code
   done()
@@ -204,12 +243,13 @@ fastify.addHook('onResponse', async (request, reply) => {
 })
 ```
 
-The `onResponse` hook is executed when a response has been sent, so you will not be able to send more data to the client. It can however be useful for sending data to external services, for example, to gather statistics.
+The `onResponse` hook is executed when a response has been sent, so you will not
+be able to send more data to the client. It can however be useful for sending
+data to external services, for example, to gather statistics.
 
 ### onTimeout
 
 ```js
-
 fastify.addHook('onTimeout', (request, reply, done) => {
   // Some code
   done()
@@ -222,11 +262,16 @@ fastify.addHook('onTimeout', async (request, reply) => {
   await asyncMethod()
 })
 ```
-`onTimeout` is useful if you need to monitor the request timed out in your service (if the `connectionTimeout` property is set on the Fastify instance). The `onTimeout` hook is executed when a request is timed out and the HTTP socket has been hanged up. Therefore, you will not be able to send data to the client.
+`onTimeout` is useful if you need to monitor the request timed out in your
+service (if the `connectionTimeout` property is set on the Fastify instance).
+The `onTimeout` hook is executed when a request is timed out and the HTTP socket
+has been hanged up. Therefore, you will not be able to send data to the client.
 
 
 ### Manage Errors from a hook
-If you get an error during the execution of your hook, just pass it to `done()` and Fastify will automatically close the request and send the appropriate error code to the user.
+If you get an error during the execution of your hook, just pass it to `done()`
+and Fastify will automatically close the request and send the appropriate error
+code to the user.
 
 ```js
 fastify.addHook('onRequest', (request, reply, done) => {
@@ -241,7 +286,7 @@ fastify.addHook('preHandler', (request, reply, done) => {
   done(new Error('Some error'))
 })
 ```
-*The error will be handled by [`Reply`](Reply.md#errors).*
+*The error will be handled by [`Reply`](./Reply.md#errors).*
 
 Or if you're using `async/await` you can just throw an error:
 ```js
@@ -252,20 +297,19 @@ fastify.addHook('onResponse', async (request, reply) => {
 
 ### Respond to a request from a hook
 
-If needed, you can respond to a request before you reach the route handler,
-for example when implementing an authentication hook.
-Replying from a hook implies that the hook chain is __stopped__ and
-the rest of the hooks and handlers are not executed. If the hook is
-using the callback approach, i.e. it is not an `async` function or it
-returns a `Promise`, it is as simple as calling `reply.send()` and avoiding
-calling the callback. If the hook is `async`, `reply.send()` __must__ be
-called _before_ the function returns or the promise resolves, otherwise, the
-request will proceed. When `reply.send()` is called outside of the
-promise chain, it is important to `return reply` otherwise the request
-will be executed twice.
-
-It is important to __not mix callbacks and `async`/`Promise`__, otherwise
-the hook chain will be executed twice.
+If needed, you can respond to a request before you reach the route handler, for
+example when implementing an authentication hook. Replying from a hook implies
+that the hook chain is __stopped__ and the rest of the hooks and handlers are
+not executed. If the hook is using the callback approach, i.e. it is not an
+`async` function or it returns a `Promise`, it is as simple as calling
+`reply.send()` and avoiding calling the callback. If the hook is `async`,
+`reply.send()` __must__ be called _before_ the function returns or the promise
+resolves, otherwise, the request will proceed. When `reply.send()` is called
+outside of the promise chain, it is important to `return reply` otherwise the
+request will be executed twice.
+
+It is important to __not mix callbacks and `async`/`Promise`__, otherwise the
+hook chain will be executed twice.
 
 If you are using `onRequest` or `preHandler` use `reply.send`.
 
@@ -282,7 +326,10 @@ fastify.addHook('preHandler', async (request, reply) => {
 })
 ```
 
-If you want to respond with a stream, you should avoid using an `async` function for the hook. If you must use an `async` function, your code will need to follow the pattern in [test/hooks-async.js](https://github.com/fastify/fastify/blob/94ea67ef2d8dce8a955d510cd9081aabd036fa85/test/hooks-async.js#L269-L275).
+If you want to respond with a stream, you should avoid using an `async` function
+for the hook. If you must use an `async` function, your code will need to follow
+the pattern in
+[test/hooks-async.js](https://github.com/fastify/fastify/blob/94ea67ef2d8dce8a955d510cd9081aabd036fa85/test/hooks-async.js#L269-L275).
 
 ```js
 fastify.addHook('onRequest', (request, reply, done) => {
@@ -291,8 +338,8 @@ fastify.addHook('onRequest', (request, reply, done) => {
 })
 ```
 
-If you are sending a response without `await` on it, make sure to always
-`return reply`:
+If you are sending a response without `await` on it, make sure to always `return
+reply`:
 
 ```js
 fastify.addHook('preHandler', async (request, reply) => {
@@ -321,10 +368,11 @@ You can hook into the application-lifecycle as well.
 - [onRegister](#onregister)
 
 ### onReady
-Triggered before the server starts listening for requests and when `.ready()` is invoked. It cannot change the routes or add new hooks.
-Registered hook functions are executed serially.
-Only after all `onReady` hook functions have completed will the server start listening for requests.
-Hook functions accept one argument: a callback, `done`, to be invoked after the hook function is complete.
+Triggered before the server starts listening for requests and when `.ready()` is
+invoked. It cannot change the routes or add new hooks. Registered hook functions
+are executed serially. Only after all `onReady` hook functions have completed
+will the server start listening for requests. Hook functions accept one
+argument: a callback, `done`, to be invoked after the hook function is complete.
 Hook functions are invoked with `this` bound to the associated Fastify instance.
 
 ```js
@@ -342,20 +390,35 @@ fastify.addHook('onReady', async function () {
 })
 ```
 
-<a name="on-close"></a>
 ### onClose
-Triggered when `fastify.close()` is invoked to stop the server. It is useful when [plugins](Plugins.md) need a "shutdown" event, for example, to close an open connection to a database.<br>
-The first argument is the Fastify instance, the second one the `done` callback.
+<a id="on-close"></a>
+
+Triggered when `fastify.close()` is invoked to stop the server. It is useful
+when [plugins](./Plugins.md) need a "shutdown" event, for example, to close an
+open connection to a database.
+
+The hook function takes the Fastify instance as a first argument, 
+and a `done` callback for synchronous hook functions.
 ```js
+// callback style
 fastify.addHook('onClose', (instance, done) => {
   // Some code
   done()
 })
+
+// or async/await style
+fastify.addHook('onClose', async (instance) => {
+  // Some async code
+  await closeDatabaseConnections()
+})
 ```
 
-<a name="on-route"></a>
 ### onRoute
-Triggered when a new route is registered. Listeners are passed a `routeOptions` object as the sole parameter. The interface is synchronous, and, as such, the listeners are not passed a callback. This hook is encapsulated.
+<a id="on-route"></a>
+
+Triggered when a new route is registered. Listeners are passed a `routeOptions`
+object as the sole parameter. The interface is synchronous, and, as such, the
+listeners are not passed a callback. This hook is encapsulated.
 ```js
 fastify.addHook('onRoute', (routeOptions) => {
   //Some code
@@ -371,7 +434,8 @@ fastify.addHook('onRoute', (routeOptions) => {
 })
 ```
 
-If you are authoring a plugin and you need to customize application routes, like modifying the options or adding new route hooks, this is the right place.
+If you are authoring a plugin and you need to customize application routes, like
+modifying the options or adding new route hooks, this is the right place.
 
 ```js
 fastify.addHook('onRoute', (routeOptions) => {
@@ -384,11 +448,18 @@ fastify.addHook('onRoute', (routeOptions) => {
 })
 ```
 
-<a name="on-register"></a>
 ### onRegister
-Triggered when a new plugin is registered and a new encapsulation context is created. The hook will be executed **before** the registered code.<br/>
-This hook can be useful if you are developing a plugin that needs to know when a plugin context is formed, and you want to operate in that specific context, thus this hook is encapsulated.<br/>
-**Note:** This hook will not be called if a plugin is wrapped inside [`fastify-plugin`](https://github.com/fastify/fastify-plugin).
+<a id="on-register"></a>
+
+Triggered when a new plugin is registered and a new encapsulation context is
+created. The hook will be executed **before** the registered code.
+
+This hook can be useful if you are developing a plugin that needs to know when a
+plugin context is formed, and you want to operate in that specific context, thus
+this hook is encapsulated.
+
+**Note:** This hook will not be called if a plugin is wrapped inside
+[`fastify-plugin`](https://github.com/fastify/fastify-plugin).
 ```js
 fastify.decorate('data', [])
 
@@ -418,9 +489,14 @@ fastify.addHook('onRegister', (instance, opts) => {
 })
 ```
 
-<a name="scope"></a>
 ## Scope
-Except for [onClose](#onclose), all hooks are encapsulated. This means that you can decide where your hooks should run by using `register` as explained in the [plugins guide](Plugins-Guide.md). If you pass a function, that function is bound to the right Fastify context and from there you have full access to the Fastify API.
+<a id="scope"></a>
+
+Except for [onClose](#onclose), all hooks are encapsulated. This means that you
+can decide where your hooks should run by using `register` as explained in the
+[plugins guide](../Guides/Plugins-Guide.md). If you pass a function, that
+function is bound to the right Fastify context and from there you have full
+access to the Fastify API.
 
 ```js
 fastify.addHook('onRequest', function (request, reply, done) {
@@ -429,7 +505,8 @@ fastify.addHook('onRequest', function (request, reply, done) {
 })
 ```
 
-Note that the Fastify context in each hook is the same as the plugin where the route was registered, for example:
+Note that the Fastify context in each hook is the same as the plugin where the
+route was registered, for example:
 
 ```js
 fastify.addHook('onRequest', async function (req, reply) {
@@ -455,15 +532,25 @@ fastify.register(async function plugin (fastify, opts) {
 })
 ```
 
-Warn: if you declare the function with an [arrow function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions), the `this` will not be Fastify, but the one of the current scope.
+Warn: if you declare the function with an [arrow
+function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions),
+the `this` will not be Fastify, but the one of the current scope.
 
-<a name="route-hooks"></a>
 
 ## Route level hooks
-You can declare one or more custom lifecycle hooks ([onRequest](#onrequest), [onResponse](#onresponse), [preParsing](#preparsing), [preValidation](#prevalidation), [preHandler](#prehandler), [preSerialization](#preserialization), [onSend](#onsend), [onTimeout](#ontimeout), and [onError](#onerror)) hook(s) that will be **unique** for the route.
-If you do so, those hooks are always executed as the last hook in their category. <br/>
-This can be useful if you need to implement authentication, where the [preParsing](#preparsing) or [preValidation](#prevalidation) hooks are exactly what you need.
-Multiple route-level hooks can also be specified as an array.
+<a id="route-hooks"></a>
+
+You can declare one or more custom lifecycle hooks ([onRequest](#onrequest),
+[onResponse](#onresponse), [preParsing](#preparsing),
+[preValidation](#prevalidation), [preHandler](#prehandler),
+[preSerialization](#preserialization), [onSend](#onsend),
+[onTimeout](#ontimeout), and [onError](#onerror)) hook(s) that will be
+**unique** for the route. If you do so, those hooks are always executed as the
+last hook in their category.
+
+This can be useful if you need to implement authentication, where the
+[preParsing](#preparsing) or [preValidation](#prevalidation) hooks are exactly
+what you need. Multiple route-level hooks can also be specified as an array.
 
 ```js
 fastify.addHook('onRequest', (request, reply, done) => {

package/docs/Reference/Index.md

@@ -0,0 +1,71 @@
+<h1 align="center">Fastify</h1>
+
+## Core Documents
+<a id="reference-core-docs"></a>
+
+For the full table of contents (TOC), see [below](#reference-toc). The following
+list is a subset of the full TOC that detail core Fastify APIs and concepts in
+order of most likely importance to the reader:
+
++ [Server](./Server.md): Documents the core Fastify API. Includes documentation
+  for the factory function and the object returned by the factory function.
++ [Lifecycle](./Lifecycle.md): Explains the Fastify request lifecycle and
+  illustrates where [Hooks](./Hooks.md) are available for integrating with it.
++ [Routes](./Routes.md): Details how to register routes with Fastify and how
+  Fastify builds and evaluates the routing trie.
++ [Request](./Request.md): Details Fastify's request object that is passed into
+  each request handler.
++ [Reply](./Reply.md): Details Fastify's response object available to each
+  request handler.
++ [Validation and Serialization](./Validation-and-Serialization.md): Details
+  Fastify's support for validating incoming data and how Fastify serializes data
+  for responses.
++ [Plugins](./Plugins.md): Explains Fastify's plugin architecture and API.
++ [Encapsulation](./Encapsulation.md): Explains a core concept upon which all
+  Fastify plugins are built.
++ [Decorators](./Decorators.md): Explains the server, request, and response
+  decorator APIs.
++ [Hooks](./Hooks.md): Details the API by which Fastify plugins can inject
+  themselves into Fastify's handling of the request lifecycle.
+
+
+## Reference Documentation Table Of Contents
+<a id="reference-toc"></a>
+
+This table of contents is in alphabetical order.
+
++ [Content Type Parser](./ContentTypeParser.md): Documents Fastify's default
+  content type parser and how to add support for new content types.
++ [Decorators](./Decorators.md): Explains the server, request, and response
+  decorator APIs.
++ [Encapsulation](./Encapsulation.md): Explains a core concept upon which all
+  Fastify plugins are built.
++ [Errors](./Errors.md): Details how Fastify handles errors and lists the
+  standard set of errors Fastify generates.
++ [Hooks](./Hooks.md): Details the API by which Fastify plugins can inject
+  themselves into Fastify's handling of the request lifecycle.
++ [HTTP2](./HTTP2.md): Details Fastify's HTTP2 support.
++ [Lifecycle](./Lifecycle.md): Explains the Fastify request lifecycle and
+  illustrates where [Hooks](./Hooks.md) are available for integrating with it.
++ [Logging](./Logging.md): Details Fastify's included logging and how to
+  customize it.
++ [Long Term Support](./LTS.md): Explains Fastify's long term support (LTS)
+  guarantee and the exceptions possible to the [semver](https://semver.org)
+  contract.
++ [Middleware](./Middleware.md): Details Fastify's support for Express.js style
+  middleware.
++ [Plugins](./Plugins.md): Explains Fastify's plugin architecture and API.
++ [Reply](./Reply.md): Details Fastify's response object available to each
+  request handler.
++ [Request](./Request.md): Details Fastify's request object that is passed into
+  each request handler.
++ [Routes](./Routes.md): Details how to register routes with Fastify and how
+  Fastify builds and evaluates the routing trie.
++ [Server](./Server.md): Documents the core Fastify API. Includes documentation
+  for the factory function and the object returned by the factory function.
++ [TypeScript](./TypeScript.md): Documents Fastify's TypeScript support and
+  provides recommendations for writing applications in TypeScript that utilize
+  Fastify.
++ [Validation and Serialization](./Validation-and-Serialization.md): Details
+  Fastify's support for validating incoming data and how Fastify serializes data
+  for responses.

package/docs/{LTS.md → Reference/LTS.md}

@@ -1,49 +1,47 @@
 <h1 align="center">Fastify</h1>
 
-<a name="lts"></a>
-
 ## Long Term Support
+<a id="lts"></a>
 
-Fastify's Long Term Support (LTS) is provided according to the schedule laid
-out in this document:
+Fastify's Long Term Support (LTS) is provided according to the schedule laid out
+in this document:
 
 1. Major releases, "X" release of [semantic versioning][semver] X.Y.Z release
    versions, are supported for a minimum period of six months from their release
    date. The release date of any specific version can be found at
    [https://github.com/fastify/fastify/releases](https://github.com/fastify/fastify/releases).
 
-1. Major releases will receive security updates for an additional six months
-   from the release of the next major release. After this period
-   we will still review and release security fixes as long as they are
-   provided by the community and they do not violate other constraints,
-   e.g. minimum supported Node.js version.
+2. Major releases will receive security updates for an additional six months
+   from the release of the next major release. After this period we will still
+   review and release security fixes as long as they are provided by the
+   community and they do not violate other constraints, e.g. minimum supported
+   Node.js version.
 
-1. Major releases will be tested and verified against all Node.js
-   release lines that are supported by the
-   [Node.js LTS policy](https://github.com/nodejs/Release) within the
-   LTS period of that given Fastify release line. This implies that only
-   the latest Node.js release of a given line is supported.
+3. Major releases will be tested and verified against all Node.js release lines
+   that are supported by the [Node.js LTS
+   policy](https://github.com/nodejs/Release) within the LTS period of that
+   given Fastify release line. This implies that only the latest Node.js release
+   of a given line is supported.
 
 A "month" is defined as 30 consecutive days.
 
 > ## Security Releases and Semver
 >
-> As a consequence of providing long-term support for major releases, there
-> are occasions where we need to release breaking changes as a _minor_
-> version release. Such changes will _always_ be noted in the
-> [release notes](https://github.com/fastify/fastify/releases).
+> As a consequence of providing long-term support for major releases, there are
+> occasions where we need to release breaking changes as a _minor_ version
+> release. Such changes will _always_ be noted in the [release
+> notes](https://github.com/fastify/fastify/releases).
 >
-> To avoid automatically receiving breaking security updates it is possible to use
-> the tilde (`~`) range qualifier. For example, to get patches for the 3.15
-> release, and avoid automatically updating to the 3.16 release, specify
-> the dependency as `"fastify": "~3.15.x"`. This will leave your application vulnerable,
-> so please use with caution.
+> To avoid automatically receiving breaking security updates it is possible to
+> use the tilde (`~`) range qualifier. For example, to get patches for the 3.15
+> release, and avoid automatically updating to the 3.16 release, specify the
+> dependency as `"fastify": "~3.15.x"`. This will leave your application
+> vulnerable, so please use with caution.
 
 [semver]: https://semver.org/
 
-<a name="lts-schedule"></a>
-
 ### Schedule
+<a id="lts-schedule"></a>
 
 | Version | Release Date | End Of LTS Date | Node.js              |
 | :------ | :----------- | :-------------- | :------------------- |
@@ -51,14 +49,14 @@ A "month" is defined as 30 consecutive days.
 | 2.0.0   | 2019-02-25   | 2021-01-31      | 6, 8, 10, 12, 14     |
 | 3.0.0   | 2020-07-07   | TBD             | 10, 12, 14, 16       |
 
-<a name="supported-os"></a>
-
 ### CI tested operating systems
+<a id="supported-os"></a>
 
-Fastify uses GitHub Actions for CI testing, please refer to
-[GitHub's documentation regarding workflow runners](https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#supported-runners-and-hardware-resources)
-for further details on what the latest virtual environment is in relation to
-the YAML workflow labels below:
+Fastify uses GitHub Actions for CI testing, please refer to [GitHub's
+documentation regarding workflow
+runners](https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#supported-runners-and-hardware-resources)
+for further details on what the latest virtual environment is in relation to the
+YAML workflow labels below:
 
 | OS      | YAML Workflow Label    | Package Manager           | Node.js      |
 |---------|------------------------|---------------------------|--------------|
@@ -67,4 +65,5 @@ the YAML workflow labels below:
 | Windows | `windows-latest`       | npm                       | 10,12,14,16  |
 | MacOS   | `macos-latest`         | npm                       | 10,12,14,16  |
 
-Using [yarn](https://yarnpkg.com/) might require passing the `--ignore-engines` flag.
+Using [yarn](https://yarnpkg.com/) might require passing the `--ignore-engines`
+flag.

package/docs/{Lifecycle.md → Reference/Lifecycle.md}

@@ -1,8 +1,12 @@
 <h1 align="center">Fastify</h1>
 
 ## Lifecycle
-Following the schema of the internal lifecycle of Fastify.<br>
-On the right branch of every section there is the next phase of the lifecycle, on the left branch there is the corresponding error code that will be generated if the parent throws an error *(note that all the errors are automatically handled by Fastify)*.
+Following the schema of the internal lifecycle of Fastify.
+
+On the right branch of every section there is the next phase of the lifecycle,
+on the left branch there is the corresponding error code that will be generated
+if the parent throws an error *(note that all the errors are automatically
+handled by Fastify)*.
 
 ```
 Incoming Request
@@ -36,11 +40,13 @@ Incoming Request
                                                                             └─▶ onResponse Hook
 ```
 
-At any point before or during the `User Handler`, `reply.hijack()` can be called to prevent Fastify from:
+At any point before or during the `User Handler`, `reply.hijack()` can be called
+to prevent Fastify from:
 - Running all the following hooks and user handler
 - Sending the response automatically
 
-NB (*): If `reply.raw` is used to send a response back to the user, `onResponse` hooks will still be executed
+NB (*): If `reply.raw` is used to send a response back to the user, `onResponse`
+hooks will still be executed
 
 ## Reply Lifecycle
 
@@ -51,7 +57,8 @@ Whenever the user handles the request, the result may be:
 - in sync handler: it sends a payload
 - in sync handler: it sends an `Error` instance
 
-If the reply was hijacked, we skip all the below steps. Otherwise, when it is being submitted, the data flow performed is the following:
+If the reply was hijacked, we skip all the below steps. Otherwise, when it is
+being submitted, the data flow performed is the following:
 
 ```
                         ★ schema validation Error
@@ -73,6 +80,7 @@ If the reply was hijacked, we skip all the below steps. Otherwise, when it is be
 
 Note: `reply sent` means that the JSON payload will be serialized by:
 
-- the [reply serialized](Server.md#setreplyserializer) if set
-- or by the [serializer compiler](Server.md#setserializercompiler) when a JSON schema has been set for the returning HTTP status code
+- the [reply serialized](./Server.md#setreplyserializer) if set
+- or by the [serializer compiler](./Server.md#setserializercompiler) when a JSON
+  schema has been set for the returning HTTP status code
 - or by the default `JSON.stringify` function