fastify 5.8.4 → 5.9.0

package/test/types/using.tst.ts

@@ -0,0 +1,14 @@
+import { expect, test } from 'tstyche'
+import fastify, { FastifyInstance } from '../../fastify.js'
+
+test("has 'Symbol.dispose' when declared with 'using'", async () => {
+  await using app = fastify()
+  expect(app).type.toBeAssignableTo<FastifyInstance>()
+  expect(app[Symbol.asyncDispose]).type.toBe<() => Promise<undefined>>()
+})
+
+test("has 'Symbol.dispose'", async () => {
+  await using app = fastify()
+  expect(app).type.toBeAssignableTo<FastifyInstance>()
+  expect(app[Symbol.asyncDispose]).type.toBe<() => Promise<undefined>>()
+})

package/types/errors.d.ts

@@ -65,6 +65,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE' |
   'FST_ERR_DUPLICATED_ROUTE' |
   'FST_ERR_BAD_URL' |
+  'FST_ERR_MAX_PARAM_LENGTH' |
   'FST_ERR_ASYNC_CONSTRAINT' |
   'FST_ERR_INVALID_URL' |
   'FST_ERR_ROUTE_OPTIONS_NOT_OBJ' |
@@ -73,6 +74,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_ROUTE_MISSING_HANDLER' |
   'FST_ERR_ROUTE_METHOD_INVALID' |
   'FST_ERR_ROUTE_METHOD_NOT_SUPPORTED' |
+  'FST_ERR_ROUTE_LOG_LEVEL_INVALID' |
   'FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED' |
   'FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT' |
   'FST_ERR_HANDLER_TIMEOUT' |
@@ -84,6 +86,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_PLUGIN_VERSION_MISMATCH' |
   'FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE' |
   'FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER' |
+  'FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED' |
   'FST_ERR_PLUGIN_CALLBACK_NOT_FN' |
   'FST_ERR_PLUGIN_NOT_VALID' |
   'FST_ERR_ROOT_PLG_BOOTED' |

package/types/request.d.ts

@@ -71,22 +71,43 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
    * @deprecated Use `raw` property
    */
   readonly req: RawRequest & RouteGeneric['Headers']; // this enables the developer to extend the existing http(s|2) headers list
+  /**
+   * Derived from request socket metadata or forwarding headers.
+   * Treat as untrusted input and validate before security-sensitive use.
+   */
   readonly ip: string;
+  /**
+   * Derived from forwarding headers when trustProxy is enabled.
+   * Treat as untrusted input and validate before security-sensitive use.
+   */
   readonly ips?: string[];
+  /**
+   * Derived from Host/:authority/X-Forwarded-Host request metadata.
+   * Treat as untrusted input and validate before security-sensitive use.
+   */
   readonly host: string;
+  /**
+   * Parsed from request host metadata.
+   * Treat as untrusted input and validate before security-sensitive use.
+   */
   readonly port: number | null;
   readonly hostname: string;
   readonly url: string;
   readonly originalUrl: string;
+  /**
+   * Derived from socket state or forwarding headers.
+   * Treat as untrusted input and validate before security-sensitive use.
+   */
   readonly protocol: 'http' | 'https';
   readonly method: string;
   readonly routeOptions: Readonly<RequestRouteOptions<ContextConfig, SchemaCompiler>>
   readonly is404: boolean;
   readonly socket: RawRequest['socket'];
   readonly signal: AbortSignal;
+  readonly mediaType: string | undefined;
 
-  getValidationFunction(httpPart: HTTPRequestPart): ValidationFunction
-  getValidationFunction(schema: { [key: string]: any }): ValidationFunction
+  getValidationFunction(httpPart: HTTPRequestPart): ValidationFunction | undefined
+  getValidationFunction(schema: { [key: string]: any }): ValidationFunction | undefined
   compileValidationSchema(schema: { [key: string]: any }, httpPart?: HTTPRequestPart): ValidationFunction
   validateInput(input: any, schema: { [key: string]: any }, httpPart?: HTTPRequestPart): boolean
   validateInput(input: any, httpPart?: HTTPRequestPart): boolean

package/AGENTS.md

@@ -1,290 +0,0 @@
-# AGENTS.md - Guide for AI Agents Working with Fastify
-
-This document provides information and guidelines for AI agents (such as GitHub Copilot, Cursor, pi, or other AI coding assistants) working with the Fastify codebase.
-
-## Project Overview
-
-Fastify is a high-performance web framework for Node.js focused on:
-- **Speed**: One of the fastest Node.js web frameworks
-- **Extensibility**: Powerful plugin architecture with hooks and decorators
-- **Schema-based**: JSON Schema validation and serialization
-- **Developer experience**: Expressive API with minimal overhead
-- **TypeScript support**: Full type definitions included
-
-**Current Version**: 5.7.1 (main branch)
-**Repository**: https://github.com/fastify/fastify
-
-## Repository Structure
-
-```
-fastify/
-├── docs/                 # Documentation (Guides and Reference)
-│   ├── Guides/          # Tutorials and how-to guides
-│   └── Reference/       # API documentation
-├── examples/            # Example applications and benchmarks
-├── lib/                 # Core library code
-├── test/                # Test files
-├── types/               # TypeScript type definitions
-├── build/               # Build scripts
-├── integration/         # Integration tests
-├── fastify.js           # Main entry point
-├── fastify.d.ts         # Main TypeScript definitions
-└── package.json         # Dependencies and scripts
-```
-
-## Key Files for Agents
-
-### Core Files
-- **`fastify.js`** - Main Fastify class and entry point
-- **`fastify.d.ts`** - TypeScript type definitions (keep these in sync)
-- **`lib/`** - All core functionality:
-  - `route.js` - Route handling
-  - `req-res.js` - Request and Reply objects
-  - `hooks.js` - Lifecycle hooks
-  - `plugin.js` - Plugin system
-  - `validation.js` - Schema validation
-  - `content-type-parser.js` - Body parsing
-  - `logger.js` - Pino logger integration
-
-### Configuration Files
-- **`package.json`** - Scripts, dependencies, and contributors
-- **`eslint.config.js`** - Linting configuration (uses neostandard)
-- **`.markdownlint-cli2.yaml`** - Markdown linting rules
-
-### Documentation Files
-- **`README.md`** - Project overview and quick start
-- **`CONTRIBUTING.md`** - Contribution guidelines
-- **`GOVERNANCE.md`** - Links to organization governance
-- **`SECURITY.md`** - Security policy
-- **`docs/Guides/Contributing.md`** - Detailed contributing guide
-- **`docs/Guides/Style-Guide.md`** - Coding style conventions
-
-## Testing Conventions
-
-### Test Framework
-Fastify uses **Borp** (a custom test runner) for testing.
-
-### Test Structure
-- Tests are in the **`test/`** directory
-- Test files follow the pattern: `test/<module>.test.js`
-- Integration tests are in **`integration/`** directory
-
-### Running Tests
-
-```bash
-# Run all tests
-npm test
-
-# Run unit tests only
-npm run unit
-
-# Run tests with coverage
-npm run coverage
-
-# Run tests in watch mode
-npm run test:watch
-
-# Run TypeScript type tests
-npm run test:typescript
-
-# Run CI tests (minimal)
-npm run test:ci
-```
-
-### Test Requirements
-- **100% line coverage** is required for all changes (enforced by CI)
-- Tests must pass on all supported Node.js versions
-- TypeScript types must be tested (using `tsd`)
-
-## Code Style and Conventions
-
-### Linting
-- Uses **Neostandard** JavaScript style guide
-- ESLint is configured in `eslint.config.js`
-- Run `npm run lint` to check code style
-- Run `npm run lint:fix` to auto-fix issues
-
-### Key Style Rules (from Style-Guide.md)
-- Use `const` and `let`, never `var`
-- Use arrow functions for callbacks
-- Use async/await instead of promises
-- Follow semicolon usage (neostandard enforces this)
-- Use template literals for string interpolation
-- Prefer functional methods (`map`, `filter`, `reduce`) over loops
-- Error-first callback pattern for async operations where needed
-
-### Naming Conventions
-- **Files**: kebab-case (`content-type-parser.js`)
-- **Variables**: camelCase
-- **Constants**: UPPER_SNAKE_CASE
-- **Classes**: PascalCase
-- **Private methods**: prefixed with `_`
-
-## Common Tasks
-
-### Adding a New Feature
-1. Implement the feature in `lib/`
-2. Add tests in `test/`
-3. Update TypeScript types in `fastify.d.ts` or `types/`
-4. Update documentation in `docs/`
-5. Run `npm test` to ensure all tests pass
-6. Run `npm run lint` to check code style
-7. Add changelog entry for release
-
-### Fixing a Bug
-1. Add a failing test case in `test/`
-2. Fix the bug in `lib/`
-3. Ensure all tests pass
-4. Check if TypeScript types need updating
-5. Update documentation if behavior changes
-
-### Working with Plugins
-- See `docs/Guides/Write-Plugin.md` for plugin authoring
-- See `docs/Guides/Plugins-Guide.md` for plugin usage
-- Plugin example: `lib/plugin.js`
-
-## Architecture Highlights
-
-### Core Components
-
-1. **Server (`fastify.js`)**
-   - Main Fastify class
-   - Server initialization and configuration
-   - Plugin system integration (via `avvio`)
-
-2. **Routing (`lib/route.js`)**
-   - Uses `find-my-way` for fast route matching
-   - Route registration and lookup
-   - Shorthand methods (get, post, put, delete, etc.)
-
-3. **Request/Response (`lib/req-res.js`)**
-   - Request object extensions
-   - Reply object with fluent API
-   - Decorator support
-
-4. **Hooks (`lib/hooks.js`)**
-   - Lifecycle hooks (onRequest, preHandler, etc.)
-   - Hook execution order and timing
-
-5. **Validation (`lib/validation.js`)**
-   - JSON Schema validation via AJV
-   - Response serialization
-   - Built-in error serializer
-
-6. **Content Type Parser (`lib/content-type-parser.js`)**
-   - Request body parsing
-   - Custom parser support
-   - JSON and other formats
-
-### Plugin System
-- Plugins are loaded asynchronously via `avvio`
-- Supports encapsulation (scoped plugins)
-- Hooks and decorators can be scoped
-- See `lib/plugin.js` for implementation
-
-## TypeScript Integration
-
-- TypeScript definitions are in `fastify.d.ts` and `types/`
-- Types must be tested with `tsd`
-- Run `npm run test:typescript` to verify types
-- Keep types in sync with JavaScript implementation
-
-## Performance Considerations
-
-Fastify prioritizes performance:
-- **Routes**: Pre-compiled functions for fast matching
-- **Validation**: Compiled JSON Schema validators
-- **Serialization**: Compiled serializers (fast-json-stringify)
-- **Logging**: Low-overhead Pino logger
-- **Caching**: Route context caching with `toad-cache`
-
-When making changes:
-- Profile performance impact for hot paths
-- Use benchmarks in `examples/benchmark/`
-- Run `npm run benchmark` to measure
-
-## Documentation Updates
-
-Documentation is critical for Fastify. When changing behavior:
-
-1. Update relevant docs in `docs/Reference/` for API changes
-2. Update `docs/Guides/` for usage pattern changes
-3. Check for broken links (CI validates this)
-4. Update examples in `examples/` if needed
-5. Run `npm run lint:markdown` to check docs
-
-## Pre-commit Checks
-
-Before submitting changes, ensure:
-
-1. ✅ All tests pass: `npm test`
-2. ✅ 100% coverage: `npm run coverage`
-3. ✅ Linting passes: `npm run lint`
-4. ✅ TypeScript types pass: `npm run test:typescript`
-5. ✅ Markdown linting passes: `npm run lint:markdown`
-6. ✅ Documentation is updated
-7. ✅ Examples still work if affected
-
-## Working with CI
-
-Fastify uses GitHub Actions for CI. Workflows are in `.github/workflows/`:
-- **`ci.yml`** - Main CI pipeline
-- **`package-manager-ci.yml`** - Tests multiple package managers
-- **`website.yml`** - Website deployment
-
-## Agent-Specific Tips
-
-### When Generating Code
-1. Check existing patterns in `lib/` before creating new patterns
-2. Follow the established error handling patterns
-3. Use async/await consistently
-4. Add appropriate hooks if extending lifecycle
-5. Consider TypeScript types from the start
-
-### When Refactoring
-1. Ensure all tests still pass
-2. Don't change public APIs without semver consideration
-3. Update TypeScript definitions if signatures change
-4. Check for deprecation needs
-5. Update documentation for changed behavior
-
-### When Analyzing Issues
-1. Check `test/` for usage examples
-2. Review relevant `docs/Reference/` files
-3. Look at similar implementations in `lib/`
-4. Consider the plugin system and encapsulation
-5. Check hook timing and order
-
-### Common Gotchas
-- **Encapsulation**: Plugins are isolated - decorators don't leak
-- **Hook order**: Hooks run in specific order (see docs/Reference/Hooks.md)
-- **Async boot**: Server starts asynchronously - use `ready()` or `after()`
-- **Error handling**: Use Fastify error classes from `@fastify/error`
-- **Validation**: Schemas are compiled - changes require recompilation
-
-## Key Dependencies
-
-- **`avvio`** - Plugin loading and boot
-- **`find-my-way`** - Fast HTTP router
-- **`fast-json-stringify`** - Response serialization
-- **`pino`** - Logging
-- **`@fastify/ajv-compiler`** - JSON Schema validation
-- **`light-my-request`** - HTTP injection for testing
-
-## Contact and Resources
-
-- **Documentation**: https://fastify.dev/
-- **Discord**: https://discord.gg/fastify
-- **GitHub Issues**: https://github.com/fastify/fastify/issues
-- **GitHub Discussions**: https://github.com/fastify/fastify/discussions
-- **Help**: https://github.com/fastify/help
-
-## Version Information
-
-- **Main branch**: Fastify v5
-- **v4 branch**: https://github.com/fastify/fastify/tree/4.x
-- **LTS Policy**: See `docs/Reference/LTS.md`
-
----
-
-This document is maintained by the Fastify team. For questions or suggestions, please open an issue or discussion.

package/test/types/content-type-parser.test-d.ts

@@ -1,72 +0,0 @@
-import fastify, { FastifyBodyParser } from '../../fastify'
-import { expectError, expectType } from 'tsd'
-import { IncomingMessage } from 'node:http'
-import { FastifyRequest } from '../../types/request'
-
-expectType<void>(fastify().addContentTypeParser('contentType', function (request, payload, done) {
-  expectType<FastifyRequest>(request)
-  expectType<IncomingMessage>(payload)
-  done(null)
-}))
-
-// Body limit options
-
-expectType<void>(fastify().addContentTypeParser('contentType', { bodyLimit: 99 }, function (request, payload, done) {
-  expectType<FastifyRequest>(request)
-  expectType<IncomingMessage>(payload)
-  done(null)
-}))
-
-// Array for contentType
-
-expectType<void>(fastify().addContentTypeParser(['contentType'], function (request, payload, done) {
-  expectType<FastifyRequest>(request)
-  expectType<IncomingMessage>(payload)
-  done(null)
-}))
-
-// Body Parser - the generic after addContentTypeParser enforces the type of the `body` parameter as well as the value of the `parseAs` property
-
-expectType<void>(fastify().addContentTypeParser<string>('bodyContentType', { parseAs: 'string' }, function (request, body, done) {
-  expectType<FastifyRequest>(request)
-  expectType<string>(body)
-  done(null)
-}))
-
-expectType<void>(fastify().addContentTypeParser<Buffer>('bodyContentType', { parseAs: 'buffer' }, function (request, body, done) {
-  expectType<FastifyRequest>(request)
-  expectType<Buffer>(body)
-  done(null)
-}))
-
-expectType<void>(fastify().addContentTypeParser('contentType', async function (request: FastifyRequest, payload: IncomingMessage) {
-  expectType<FastifyRequest>(request)
-  expectType<IncomingMessage>(payload)
-  return null
-}))
-
-expectType<void>(fastify().addContentTypeParser<string>('bodyContentType', { parseAs: 'string' }, async function (request: FastifyRequest, body: string) {
-  expectType<FastifyRequest>(request)
-  expectType<string>(body)
-  return null
-}))
-
-expectType<void>(fastify().addContentTypeParser<Buffer>('bodyContentType', { parseAs: 'buffer' }, async function (request: FastifyRequest, body: Buffer) {
-  expectType<FastifyRequest>(request)
-  expectType<Buffer>(body)
-  return null
-}))
-
-expectType<FastifyBodyParser<string>>(fastify().getDefaultJsonParser('error', 'ignore'))
-
-expectError(fastify().getDefaultJsonParser('error', 'skip'))
-
-expectError(fastify().getDefaultJsonParser('nothing', 'ignore'))
-
-expectType<void>(fastify().removeAllContentTypeParsers())
-expectError(fastify().removeAllContentTypeParsers('contentType'))
-
-expectType<void>(fastify().removeContentTypeParser('contentType'))
-expectType<void>(fastify().removeContentTypeParser(/contentType+.*/))
-expectType<void>(fastify().removeContentTypeParser(['contentType', /contentType+.*/]))
-expectError(fastify().removeContentTypeParser({}))

package/test/types/errors.test-d.ts

@@ -1,90 +0,0 @@
-import { FastifyErrorConstructor } from '@fastify/error'
-import { expectAssignable } from 'tsd'
-import { errorCodes } from '../../fastify'
-
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_NOT_FOUND)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_OPTIONS_NOT_OBJ)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_QSP_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_VALIDATION)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LISTEN_OPTIONS_INVALID)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ERROR_HANDLER_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ERROR_HANDLER_ALREADY_SET)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_ALREADY_PRESENT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_EMPTY_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_PARSE_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_BODY_TOO_LARGE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_MEDIA_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_CONTENT_LENGTH)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_EMPTY_JSON_BODY)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_JSON_BODY)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INSTANCE_ALREADY_STARTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_ALREADY_PRESENT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_DEPENDENCY_INVALID_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_MISSING_DEPENDENCY)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_AFTER_START)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_REFERENCE_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_UNDECLARED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_INVALID_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_INVALID_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_NOT_SUPPORTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_MISSING_MIDDLEWARE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_TIMEOUT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_DESTINATION)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_LOGGER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_LOGGER_INSTANCE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_LOGGER_CONFIG)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_INVALID_PAYLOAD_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_RESPONSE_BODY_CONSUMED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_READABLE_STREAM_LOCKED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_ALREADY_SENT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_SENT_VALUE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SEND_INSIDE_ONERR)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SEND_UNDEFINED_ERR)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_BAD_STATUS_CODE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_BAD_TRAILER_NAME)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_BAD_TRAILER_VALUE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_FAILED_ERROR_SERIALIZATION)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_MISSING_SERIALIZATION_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REQ_INVALID_VALIDATION_INVOCATION)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_MISSING_ID)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_ALREADY_PRESENT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_CONTENT_MISSING_SCHEMA)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_DUPLICATE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_VALIDATION_BUILD)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_SERIALIZATION_BUILD)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INIT_OPTS_INVALID)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DUPLICATED_ROUTE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_BAD_URL)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ASYNC_CONSTRAINT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INVALID_URL)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_OPTIONS_NOT_OBJ)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_DUPLICATED_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_HANDLER_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_MISSING_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_METHOD_INVALID)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_METHOD_NOT_SUPPORTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_REWRITE_NOT_STR)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REOPENED_CLOSE_SERVER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REOPENED_SERVER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INSTANCE_ALREADY_LISTENING)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_VERSION_MISMATCH)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_CALLBACK_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_NOT_VALID)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROOT_PLG_BOOTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PARENT_PLUGIN_BOOTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_TIMEOUT)