msgspec-fastapi 0.0.1__tar.gz

msgspec_fastapi-0.0.1/.github/workflows/publish.yml

@@ -0,0 +1,45 @@
+name: Publish
+
+on:
+  push:
+    tags:
+      - "v[0-9]*"
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39  # v8.2.0
+        with:
+          enable-cache: false
+      - name: Check that the tag matches the version
+        run: test "${GITHUB_REF_NAME#v}" = "$(uv version --short)"
+      - name: Run tests
+        run: uv run --python 3.13 --group test pytest
+      - name: Build
+        run: uv build
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/msgspec-fastapi/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33  # v1.14.2

msgspec_fastapi-0.0.1/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+dist/
+uv.lock

msgspec_fastapi-0.0.1/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Aleksandr Tseluiko
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

msgspec_fastapi-0.0.1/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.5
+Name: msgspec-fastapi
+Version: 0.0.1
+Summary: Experimental FastAPI router that decodes request bodies and encodes responses with msgspec
+Project-URL: Source, https://github.com/Siyet/msgspec-fastapi
+Project-URL: Issues, https://github.com/Siyet/msgspec-fastapi/issues
+Author: Aleksandr Tseluiko
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: FastAPI
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: fastapi<0.144,>=0.142.2
+Requires-Dist: msgspec>=0.22.0
+Description-Content-Type: text/markdown
+
+# msgspec-fastapi
+
+An experimental FastAPI router that uses msgspec for JSON request bodies and responses.
+
+This is a prototype. Its API may change, and it relies on private FastAPI internals, so
+it is pinned to FastAPI 0.142.2 to 0.143.x. It is a personal project, not part of
+msgspec; feedback is welcome in the issues.
+
+## Installation
+
+```sh
+pip install msgspec-fastapi
+```
+
+## Usage
+
+```python
+import msgspec
+from fastapi import FastAPI
+from msgspec_fastapi import MsgspecRouter, install_openapi
+
+
+class City(msgspec.Struct):
+    name: str
+    population: int
+
+
+router = MsgspecRouter()
+
+
+@router.post('/cities')
+async def create_city(city: City) -> City:
+    return city
+
+
+app = FastAPI()
+app.include_router(router)
+install_openapi(app, router)
+```
+
+## What it does
+
+- A msgspec body parameter (a Struct or another type msgspec can decode) is decoded from
+  the raw request bytes by a `msgspec.json.Decoder` built once at route registration.
+  A non-JSON content type returns 415, malformed JSON returns 400, and a missing or
+  invalid body returns 422. Bodies are decoded in msgspec strict mode: for example, the
+  JSON string `"1"` is not accepted for an `int` field, unlike FastAPI with Pydantic.
+- A msgspec response type, from the return annotation or `response_model`, is encoded
+  with msgspec. An instance of exactly the declared Struct class is encoded without
+  revalidation, as FastAPI does for a Pydantic `response_model`; other values are
+  validated against the declared type. Nested values and type parameters of a trusted
+  instance are not checked.
+- Responses of routes without a return annotation or `response_model` are also encoded
+  with msgspec, so the output can differ from FastAPI's `jsonable_encoder` (for example,
+  `bytes` are base64-encoded and `Decimal` is encoded as a string).
+- Path, query, header and cookie parameters keep FastAPI extraction, aliases and
+  defaults, but are converted with `msgspec.convert(strict=False)` instead of Pydantic,
+  so coercion differs for some inputs (for example, `" 1.5"` is rejected for `float`
+  and `"nan"` is accepted for `Decimal`). Parameter types must be supported by msgspec;
+  Pydantic-specific types such as `AnyUrl` raise `TypeError` at route registration.
+- `install_openapi` adds the msgspec JSON schemas to the OpenAPI document. It is required
+  for a valid document: call it once after including the routers, passing every
+  `MsgspecRouter` that is not included directly in another `MsgspecRouter`.
+- A Pydantic body or response model is left to FastAPI; the route parameters are still
+  validated with msgspec.
+
+## Limitations
+
+- Only one msgspec body parameter per route, and it cannot be combined with other
+  FastAPI body fields. Only JSON bodies are supported: `application/json`,
+  `application/*+json`, or a request without a content type.
+- Structs, alone or inside containers, are not supported as path, query, header or
+  cookie parameters.
+- `response_model_include`, `response_model_exclude`, `response_model_exclude_*` and
+  `response_model_by_alias=False` are rejected for typed msgspec responses.
+
+## Development
+
+```sh
+uv run --group test pytest
+```

msgspec_fastapi-0.0.1/README.md

@@ -0,0 +1,81 @@
+# msgspec-fastapi
+
+An experimental FastAPI router that uses msgspec for JSON request bodies and responses.
+
+This is a prototype. Its API may change, and it relies on private FastAPI internals, so
+it is pinned to FastAPI 0.142.2 to 0.143.x. It is a personal project, not part of
+msgspec; feedback is welcome in the issues.
+
+## Installation
+
+```sh
+pip install msgspec-fastapi
+```
+
+## Usage
+
+```python
+import msgspec
+from fastapi import FastAPI
+from msgspec_fastapi import MsgspecRouter, install_openapi
+
+
+class City(msgspec.Struct):
+    name: str
+    population: int
+
+
+router = MsgspecRouter()
+
+
+@router.post('/cities')
+async def create_city(city: City) -> City:
+    return city
+
+
+app = FastAPI()
+app.include_router(router)
+install_openapi(app, router)
+```
+
+## What it does
+
+- A msgspec body parameter (a Struct or another type msgspec can decode) is decoded from
+  the raw request bytes by a `msgspec.json.Decoder` built once at route registration.
+  A non-JSON content type returns 415, malformed JSON returns 400, and a missing or
+  invalid body returns 422. Bodies are decoded in msgspec strict mode: for example, the
+  JSON string `"1"` is not accepted for an `int` field, unlike FastAPI with Pydantic.
+- A msgspec response type, from the return annotation or `response_model`, is encoded
+  with msgspec. An instance of exactly the declared Struct class is encoded without
+  revalidation, as FastAPI does for a Pydantic `response_model`; other values are
+  validated against the declared type. Nested values and type parameters of a trusted
+  instance are not checked.
+- Responses of routes without a return annotation or `response_model` are also encoded
+  with msgspec, so the output can differ from FastAPI's `jsonable_encoder` (for example,
+  `bytes` are base64-encoded and `Decimal` is encoded as a string).
+- Path, query, header and cookie parameters keep FastAPI extraction, aliases and
+  defaults, but are converted with `msgspec.convert(strict=False)` instead of Pydantic,
+  so coercion differs for some inputs (for example, `" 1.5"` is rejected for `float`
+  and `"nan"` is accepted for `Decimal`). Parameter types must be supported by msgspec;
+  Pydantic-specific types such as `AnyUrl` raise `TypeError` at route registration.
+- `install_openapi` adds the msgspec JSON schemas to the OpenAPI document. It is required
+  for a valid document: call it once after including the routers, passing every
+  `MsgspecRouter` that is not included directly in another `MsgspecRouter`.
+- A Pydantic body or response model is left to FastAPI; the route parameters are still
+  validated with msgspec.
+
+## Limitations
+
+- Only one msgspec body parameter per route, and it cannot be combined with other
+  FastAPI body fields. Only JSON bodies are supported: `application/json`,
+  `application/*+json`, or a request without a content type.
+- Structs, alone or inside containers, are not supported as path, query, header or
+  cookie parameters.
+- `response_model_include`, `response_model_exclude`, `response_model_exclude_*` and
+  `response_model_by_alias=False` are rejected for typed msgspec responses.
+
+## Development
+
+```sh
+uv run --group test pytest
+```

msgspec_fastapi-0.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "msgspec-fastapi"
+version = "0.0.1"
+description = "Experimental FastAPI router that decodes request bodies and encodes responses with msgspec"
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [{ name = "Aleksandr Tseluiko" }]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Framework :: FastAPI",
+    "Programming Language :: Python :: 3",
+]
+dependencies = [
+    "fastapi>=0.142.2,<0.144",
+    "msgspec>=0.22.0",
+]
+
+[project.urls]
+Source = "https://github.com/Siyet/msgspec-fastapi"
+Issues = "https://github.com/Siyet/msgspec-fastapi/issues"
+
+[dependency-groups]
+test = ["pytest", "httpx", "httpx2"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/msgspec_fastapi"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

msgspec_fastapi-0.0.1/src/msgspec_fastapi/__init__.py

@@ -0,0 +1,4 @@
+from .responses import MsgspecJSONResponse
+from .router import MsgspecRouter, install_openapi
+
+__all__ = ['MsgspecJSONResponse', 'MsgspecRouter', 'install_openapi']

msgspec_fastapi-0.0.1/src/msgspec_fastapi/responses.py

@@ -0,0 +1,10 @@
+from typing import Any
+import msgspec
+from starlette.responses import JSONResponse
+
+_JSON_ENCODER = msgspec.json.Encoder()
+
+class MsgspecJSONResponse(JSONResponse):
+    """Encode JSON with msgspec; use MsgspecRouter for output validation."""
+    def render(self, content: Any) -> bytes:
+        return _JSON_ENCODER.encode(content)

msgspec_fastapi-0.0.1/src/msgspec_fastapi/router.py

@@ -0,0 +1,406 @@
+from __future__ import annotations
+
+import inspect
+from copy import deepcopy
+from functools import partial, wraps
+from hashlib import sha256
+from typing import Annotated, get_args, get_origin, get_type_hints
+
+import msgspec
+from pydantic import BaseModel
+from fastapi import APIRouter, FastAPI, HTTPException, Request, Response
+from fastapi.datastructures import DefaultPlaceholder
+from fastapi.exceptions import RequestValidationError, ResponseValidationError
+from fastapi.openapi.utils import validation_error_definition, validation_error_response_definition
+from fastapi.params import Body, Depends, Param
+from fastapi.routing import APIRoute, _effective_route_context_var, iter_route_contexts
+from starlette.concurrency import run_in_threadpool
+
+from .responses import MsgspecJSONResponse
+from .validation import base_type, constrained_type, prepare_parameters, structured_type, uses_pydantic
+
+
+def _untyped_encode_hook(value):
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode='json', by_alias=True)
+    raise TypeError(f'Encoding objects of type {type(value).__name__} is unsupported')
+
+
+def _contains_struct(annotation):
+    value = base_type(annotation)
+    return (isinstance(value, type) and issubclass(value, msgspec.Struct)) or any(
+        _contains_struct(arg) for arg in get_args(value)
+    )
+
+
+def _body_type(annotation):
+    value = base_type(annotation)
+    if structured_type(value):
+        return True
+    if get_origin(value) in (list, dict, tuple, set, frozenset):
+        return True
+    return any(_body_type(arg) for arg in get_args(value))
+
+
+def _metadata(parameter, annotation):
+    items = list(get_args(annotation)[1:]) if get_origin(annotation) is Annotated else []
+    return [*items, parameter.default]
+
+
+def _merge_components(target, incoming):
+    for name, schema in incoming.items():
+        if name in target and target[name] != schema:
+            raise ValueError(f'Conflicting OpenAPI component: {name}')
+        target[name] = deepcopy(schema)
+
+
+def _schema(annotation, components):
+    (schema,), definitions = msgspec.json.schema_components(
+        [annotation], ref_template='#/components/schemas/{name}'
+    )
+    _merge_components(components, definitions)
+    return schema
+
+
+def _json_type(annotation):
+    if annotation in (inspect.Signature.empty, None) or uses_pydantic(annotation):
+        return False
+    value = base_type(annotation)
+    if isinstance(value, type) and issubclass(value, Response):
+        return False
+    try:
+        msgspec.json.Decoder(type=annotation)
+        msgspec.json.schema(annotation)
+    except (TypeError, ValueError):
+        return False
+    return True
+
+
+def _hints(endpoint):
+    target = endpoint
+    while isinstance(target, partial):
+        target = target.func
+    if not inspect.isfunction(target) and not inspect.ismethod(target):
+        target = target.__call__
+    return get_type_hints(target, include_extras=True)
+
+
+def _parse_body(request, raw, config):
+    decoder, default, embedded = config
+    if not raw:
+        if default is inspect.Signature.empty:
+            raise RequestValidationError([{'loc': ('body',), 'msg': 'Field required', 'type': 'missing'}])
+        return deepcopy(default)
+    media_type = request.headers.get('content-type', '').split(';')[0].strip().lower()
+    if media_type and media_type != 'application/json' and not (
+        media_type.startswith('application/') and media_type.endswith('+json')
+    ):
+        raise HTTPException(415, 'Expected a JSON request body')
+    try:
+        value = decoder.decode(raw)
+    except msgspec.ValidationError as exc:
+        # Typed decoding can stop on a field error before discovering invalid syntax.
+        try:
+            msgspec.json.decode(raw)
+        except (msgspec.DecodeError, UnicodeError) as syntax:
+            raise HTTPException(400, f'Malformed JSON body: {syntax}') from syntax
+        raise RequestValidationError([{'loc': ('body',), 'msg': str(exc), 'type': 'value_error.msgspec'}]) from exc
+    except (msgspec.DecodeError, UnicodeError) as exc:
+        raise HTTPException(400, f'Malformed JSON body: {exc}') from exc
+    return value.value if embedded else value
+
+
+class MsgspecRoute(APIRoute):
+    def get_route_handler(self):
+        context = _effective_route_context_var.get()
+        route = context if context is not None and context.original_route is self else self
+        prepare_parameters(route.dependant)
+        handler = super().get_route_handler()
+        config = getattr(self.endpoint, '_msgspec_body_config', None)
+        if config is None:
+            return handler
+        if route.body_field is not None:
+            raise TypeError('Other FastAPI body fields cannot be combined with a msgspec body')
+
+        async def handle(request):
+            # Invalid JSON must be rejected before dependency side effects.
+            request.scope['_msgspec_body_value'] = _parse_body(request, await request.body(), config)
+            return await handler(request)
+        return handle
+
+
+def install_openapi(app: FastAPI, *routers: 'MsgspecRouter') -> None:
+    """Install once after including routers, before serving the application."""
+    if not routers:
+        raise TypeError('Pass the MsgspecRouter instances included in the app')
+    if getattr(app, '_msgspec_openapi_installed', False):
+        raise RuntimeError('msgspec OpenAPI is already installed')
+    # FastAPI builds included contexts lazily; validate them before serving.
+    list(iter_route_contexts(app.routes))
+    original = app.openapi
+    app.openapi_schema = None
+
+    def openapi():
+        document = original()
+        components = document.setdefault('components', {}).setdefault('schemas', {})
+        for router in routers:
+            _merge_components(components, router.msgspec_components)
+        for route in iter_route_contexts(app.routes):
+            original_route = getattr(route, 'original_route', route)
+            if not isinstance(original_route, MsgspecRoute):
+                continue
+            fields = []
+            def collect(dependant):
+                for group in ('path_params', 'query_params', 'header_params', 'cookie_params'):
+                    fields.extend(getattr(dependant, group))
+                for dependency in dependant.dependencies:
+                    collect(dependency)
+            collect(route.dependant)
+            for method in route.methods:
+                operation = document.get('paths', {}).get(route.path_format, {}).get(method.lower(), {})
+                for parameter in operation.get('parameters', []):
+                    for field in fields:
+                        if (getattr(field, '_msgspec_parameter', False)
+                            and parameter['in'] == field.field_info.in_.value
+                            and parameter['name'] == field.alias):
+                            schema = deepcopy(field._msgspec_schema)
+                            for key in ('title', 'description', 'default'):
+                                if key in parameter.get('schema', {}):
+                                    schema[key] = parameter['schema'][key]
+                            parameter['schema'] = schema
+        return document
+
+    app.openapi = openapi
+    app._msgspec_openapi_installed = True
+
+
+class MsgspecRouter(APIRouter):
+    """Typed msgspec JSON bodies and validated responses for ordinary CRUD routes."""
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('route_class', MsgspecRoute)
+        kwargs.setdefault('default_response_class', MsgspecJSONResponse)
+        if not issubclass(kwargs['route_class'], MsgspecRoute):
+            raise TypeError('route_class must extend MsgspecRoute')
+        super().__init__(*args, **kwargs)
+        self.msgspec_components = {}
+
+    def include_router(self, router, *args, **kwargs):
+        if isinstance(router, MsgspecRouter):
+            _merge_components(self.msgspec_components, router.msgspec_components)
+        return super().include_router(router, *args, **kwargs)
+
+    def add_api_route(self, path, endpoint, **kwargs):
+        override = kwargs.get('route_class_override')
+        if override is not None and not issubclass(override, MsgspecRoute):
+            raise TypeError('route_class_override must extend MsgspecRoute')
+        # Included routes already have a prepared signature and response metadata.
+        if getattr(endpoint, '_msgspec_prepared', False):
+            return super().add_api_route(path, endpoint, **kwargs)
+        signature = inspect.signature(endpoint)
+        hints = _hints(endpoint)
+        parameters = [p.replace(annotation=hints.get(p.name, p.annotation)) for p in signature.parameters.values()]
+        return_type = hints.get('return', signature.return_annotation)
+        explicit = kwargs.get('response_model', inspect.Signature.empty)
+        inferred = explicit is inspect.Signature.empty or isinstance(explicit, DefaultPlaceholder)
+        output_type = return_type if inferred else explicit
+        validates_output = _json_type(output_type)
+        if validates_output:
+            output_type, output_strict = constrained_type(output_type)
+            if output_strict is False:
+                raise TypeError('JSON msgspec responses use strict validation')
+        output_decoder = msgspec.json.Decoder(type=output_type) if validates_output else None
+        # Like FastAPI with a Pydantic response_model at the top level: an instance of exactly
+        # the declared Struct class is trusted and encoded once; other top-level values,
+        # including subclass instances, are validated against the schema. Unlike Pydantic,
+        # values nested in a trusted instance are encoded as they are (a nested subclass keeps
+        # its extra fields, and the type parameters of a generic Struct are not checked).
+        output_class = (get_origin(base_type(output_type)) or base_type(output_type)) if validates_output else None
+        trusts_instances = isinstance(output_class, type) and issubclass(output_class, msgspec.Struct)
+        output_encoder = msgspec.json.Encoder() if validates_output else None
+        response_class = kwargs.get('response_class')
+        if response_class is None or isinstance(response_class, DefaultPlaceholder):
+            response_class = self.default_response_class
+        if isinstance(response_class, DefaultPlaceholder):
+            response_class = response_class.value
+        serializes_untyped_output = (
+            output_type in (inspect.Signature.empty, None)
+            and not uses_pydantic(return_type)
+            and response_class is MsgspecJSONResponse
+        )
+        handles_output = validates_output or serializes_untyped_output or (
+            explicit is None and _contains_struct(return_type)
+        )
+        untyped_encoder = (
+            msgspec.json.Encoder(enc_hook=_untyped_encode_hook)
+            if serializes_untyped_output else None
+        )
+        body = None
+        body_meta = None
+        for parameter in parameters:
+            metadata = _metadata(parameter, parameter.annotation)
+            if any(isinstance(x, Depends) for x in metadata):
+                continue
+            is_body = _contains_struct(parameter.annotation) or any(isinstance(x, Body) for x in metadata)
+            if _body_type(parameter.annotation) and not any(isinstance(x, Param) for x in metadata):
+                is_body = True
+            if is_body and _json_type(parameter.annotation):
+                if any(isinstance(x, Param) for x in metadata):
+                    raise TypeError('msgspec Struct query/path/header/cookie parameters are not supported')
+                if body is not None:
+                    raise TypeError('Only one msgspec body parameter is supported; other body fields cannot be combined')
+                body = parameter
+                body_meta = next((x for x in metadata if isinstance(x, Body)), None)
+
+        if body is None and not handles_output:
+            return super().add_api_route(path, endpoint, **kwargs)
+        if any(p.kind in (p.VAR_KEYWORD, p.VAR_POSITIONAL) for p in parameters):
+            raise TypeError('Variadic msgspec endpoints are not supported')
+        if handles_output:
+            if validates_output:
+                for option in ('response_model_include', 'response_model_exclude',
+                               'response_model_exclude_unset', 'response_model_exclude_defaults',
+                               'response_model_exclude_none'):
+                    if kwargs.get(option):
+                        raise TypeError(f'{option} is not supported for msgspec responses')
+                if kwargs.get('response_model_by_alias', True) is False:
+                    raise TypeError('msgspec responses use encoded field names')
+            if validates_output and kwargs.get('status_code') in (204, 304):
+                raise TypeError('A typed msgspec response requires a response body')
+            response_class = kwargs.get('response_class')
+            if response_class is not None and not isinstance(response_class, DefaultPlaceholder) and response_class is not MsgspecJSONResponse:
+                raise TypeError('Custom response_class is not supported for typed msgspec responses')
+            kwargs['response_model'] = None
+            kwargs['response_class'] = MsgspecJSONResponse
+
+        components = {}
+        responses = deepcopy(kwargs.get('responses') or {})
+        openapi_extra = deepcopy(kwargs.get('openapi_extra') or {})
+        default = inspect.Signature.empty
+        decoder = None
+        embedded = False
+        if body is not None:
+            metadata = [x for x in get_args(body.annotation)[1:] if not isinstance(x, Body)] if get_origin(body.annotation) is Annotated else []
+            body_type, body_strict = constrained_type(base_type(body.annotation), metadata)
+            if body_strict is False:
+                raise TypeError('JSON msgspec bodies use strict validation')
+            if body_meta is not None:
+                if body_meta.media_type != 'application/json':
+                    raise TypeError('Only application/json msgspec bodies are supported')
+                body_type, body_strict = constrained_type(body_type, body_meta.metadata)
+                if body_strict is False:
+                    raise TypeError('JSON msgspec bodies use strict validation')
+                embedded = body_meta.embed is True
+                default = body_meta.default
+                from pydantic_core import PydanticUndefined
+                if default is PydanticUndefined or default is Ellipsis:
+                    default = inspect.Signature.empty
+                if not isinstance(body.default, Body) and body.default is not inspect.Signature.empty:
+                    default = body.default
+                if body_meta.default_factory is not None:
+                    raise TypeError('Body default_factory is not supported')
+            else:
+                default = body.default
+            decode_type = body_type
+            if embedded:
+                # One explicit JSON envelope, preserving a possible Body alias.
+                field = ('value', body_type) if default is inspect.Signature.empty else (
+                    'value', body_type, msgspec.field(default_factory=lambda: deepcopy(default))
+                )
+                identity = {'schema': msgspec.json.schema(body_type), 'alias': body_meta.alias or body.name,
+                            'required': default is inspect.Signature.empty}
+                if default is not inspect.Signature.empty:
+                    identity['default'] = default
+                name = 'MsgspecBody_' + sha256(msgspec.json.encode(identity)).hexdigest()[:16]
+                decode_type = msgspec.defstruct(name, [field],
+                                               rename={'value': body_meta.alias or body.name})
+            decoder = msgspec.json.Decoder(type=decode_type)
+            body_schema = _schema(decode_type, components)
+            openapi_extra['requestBody'] = {'required': default is inspect.Signature.empty,
+                'content': {'application/json': {'schema': body_schema}}}
+            responses.setdefault(400, {'description': 'Malformed JSON'})
+            responses.setdefault(422, {'description': 'Validation Error', 'content': {
+                'application/json': {'schema': {'$ref': '#/components/schemas/HTTPValidationError'}}}})
+            _merge_components(components, {'HTTPValidationError': validation_error_response_definition,
+                                           'ValidationError': validation_error_definition})
+        if validates_output:
+            code = kwargs.get('status_code') or 200
+            key = str(code) if str(code) in responses else code
+            result_meta = responses.setdefault(key, {})
+            result_meta.setdefault('description', kwargs.get('response_description', 'Successful Response'))
+            result_meta.setdefault('content', {})['application/json'] = {'schema': _schema(output_type, components)}
+        previous_components = deepcopy(self.msgspec_components)
+        _merge_components(self.msgspec_components, components)
+        kwargs['responses'] = responses
+        kwargs['openapi_extra'] = openapi_extra
+
+        remaining = [p for p in parameters if p is not body]
+        def injected_name(type_, fallback):
+            for p in remaining:
+                annotation = base_type(p.annotation)
+                if isinstance(annotation, type) and issubclass(annotation, type_):
+                    return p.name, False
+            names = {p.name for p in parameters}
+            while fallback in names:
+                fallback += '_'
+            remaining.append(inspect.Parameter(fallback, kind=inspect.Parameter.KEYWORD_ONLY, annotation=type_))
+            return fallback, True
+        request_name, remove_request = injected_name(Request, '__msgspec_request') if body else (None, False)
+        response_name, remove_response = injected_name(Response, '__msgspec_response') if handles_output else (None, False)
+
+        is_async = inspect.iscoroutinefunction(endpoint) or inspect.iscoroutinefunction(getattr(endpoint, '__call__', None))
+        @wraps(endpoint)
+        async def wrapper(**values):
+            sub_response = values.get(response_name)
+            if remove_response:
+                values.pop(response_name)
+            if body is not None:
+                request = values[request_name]
+                if remove_request:
+                    values.pop(request_name)
+                value = request.scope['_msgspec_body_value']
+                values[body.name] = value
+            if is_async:
+                result = await endpoint(**values)
+            else:
+                result = await run_in_threadpool(endpoint, **values)
+                if inspect.isawaitable(result):
+                    result = await result
+            if isinstance(result, Response):
+                return result
+            if not handles_output:
+                return msgspec.to_builtins(result) if _contains_struct(return_type) else result
+            if validates_output and not (trusts_instances and type(result) is output_class):
+                try:
+                    # Typed decoding validates fields and Meta, even for existing Structs.
+                    result = output_decoder.decode(output_encoder.encode(result))
+                except (TypeError, ValueError, OverflowError) as exc:
+                    raise ResponseValidationError([{'loc': ('response',), 'msg': str(exc), 'type': 'value_error.msgspec'}]) from exc
+            status_code = sub_response.status_code or kwargs.get('status_code') or 200
+            if untyped_encoder is not None:
+                response = Response(untyped_encoder.encode(result), status_code=status_code,
+                                    media_type='application/json')
+            else:
+                response = MsgspecJSONResponse(result, status_code=status_code)
+            if response.status_code < 200 or response.status_code in (204, 205, 304):
+                response.body = b''
+                if 'content-length' in response.headers:
+                    del response.headers['content-length']
+            response.raw_headers.extend(sub_response.raw_headers)
+            return response
+
+        wrapper.__signature__ = signature.replace(parameters=remaining, return_annotation=inspect.Signature.empty if handles_output else return_type)
+        wrapper._msgspec_prepared = True
+        if body is not None:
+            wrapper._msgspec_body_config = (decoder, default, embedded)
+        route_count = len(self.routes)
+        try:
+            result = super().add_api_route(path, wrapper, **kwargs)
+            if body is not None and self.routes[-1].body_field is not None:
+                raise TypeError('Other FastAPI body fields cannot be combined with a msgspec body')
+            return result
+        except Exception:
+            del self.routes[route_count:]
+            self.msgspec_components = previous_components
+            raise
+

msgspec_fastapi-0.0.1/src/msgspec_fastapi/validation.py

@@ -0,0 +1,239 @@
+"""Route-local validation for HTTP parameters; no global FastAPI changes."""
+import re
+
+from typing import Annotated, Any, Literal, Union, get_args, get_origin, get_type_hints
+from dataclasses import is_dataclass
+from typing_extensions import is_typeddict
+from types import UnionType
+
+import annotated_types
+import msgspec
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+
+def base_type(annotation):
+    return get_args(annotation)[0] if get_origin(annotation) is Annotated else annotation
+
+
+def structured_type(annotation):
+    value = get_origin(base_type(annotation)) or base_type(annotation)
+    return isinstance(value, type) and (
+        issubclass(value, msgspec.Struct) or is_typeddict(value) or is_dataclass(value)
+        or (issubclass(value, tuple) and hasattr(value, '_fields'))
+    )
+
+
+def uses_pydantic(annotation):
+    value = base_type(annotation)
+    return (isinstance(value, type) and issubclass(value, BaseModel)) or any(
+        uses_pydantic(item) for item in get_args(value)
+    )
+
+
+def _check_structured_metadata(annotation, seen=None):
+    if seen is None:
+        seen = set()
+    if get_origin(annotation) is Annotated:
+        annotation, *metadata = get_args(annotation)
+        if any(not isinstance(item, msgspec.Meta) for item in metadata):
+            raise TypeError('Use msgspec.Meta inside structured model fields')
+    origin = get_origin(annotation)
+    value = origin or annotation
+    structured = structured_type(annotation)
+    if structured and value not in seen:
+        seen.add(value)
+        for field_type in get_type_hints(value, include_extras=True).values():
+            _check_structured_metadata(field_type, seen)
+    for arg in get_args(annotation):
+        _check_structured_metadata(arg, seen)
+
+
+def constrained_type(annotation, metadata=()):
+    """Translate supported FastAPI constraints, rejecting unhandled validation."""
+    if get_origin(annotation) is Annotated:
+        annotation, *extras = get_args(annotation)
+        metadata = (*extras, *metadata)
+    origin, args = get_origin(annotation), get_args(annotation)
+    if structured_type(annotation):
+        _check_structured_metadata(annotation)
+    if args and origin is not Literal:
+        converted = []
+        for arg in args:
+            if arg is Ellipsis:
+                converted.append(arg)
+                continue
+            target, nested_strict = constrained_type(arg)
+            if nested_strict is not None:
+                raise TypeError('Nested strict constraints are not supported; use a strict top-level parameter')
+            converted.append(target)
+        converted = tuple(converted)
+        if hasattr(annotation, 'copy_with'):
+            annotation = annotation.copy_with(converted)
+        elif origin in (Union, UnionType):
+            annotation = Union[converted]
+        else:
+            annotation = origin[converted[0] if len(converted) == 1 else converted]
+    expanded = []
+    for item in metadata:
+        if isinstance(item, FieldInfo):
+            expanded.extend(item.metadata)
+        else:
+            expanded.append(item)
+    metadata = expanded
+    constraints = {}
+    metas = []
+    strict = None
+    for item in metadata:
+        if isinstance(item, msgspec.Meta):
+            metas.append(item)
+        elif isinstance(item, (annotated_types.Gt, annotated_types.Ge, annotated_types.Lt,
+                               annotated_types.Le, annotated_types.MultipleOf,
+                               annotated_types.MinLen, annotated_types.MaxLen)):
+            name = {'MinLen': 'min_length', 'MaxLen': 'max_length'}.get(type(item).__name__,
+                       {'MultipleOf': 'multiple_of'}.get(type(item).__name__, type(item).__name__.lower()))
+            constraints[name] = getattr(item, name)
+        elif type(item).__module__.startswith('pydantic') and type(item).__name__ == 'Strict':
+            strict = item.strict
+        elif type(item).__module__.startswith('pydantic') and type(item).__name__ == '_PydanticGeneralMetadata':
+            for name, value in vars(item).items():
+                if name not in ('pattern',):
+                    raise TypeError(f'Unsupported msgspec parameter constraint: {name}')
+                constraints[name] = value
+        else:
+            raise TypeError(f'Unsupported msgspec parameter metadata: {type(item).__name__}')
+    if constraints:
+        metas.append(msgspec.Meta(**constraints))
+    if metas:
+        # FastAPI constraints on nullable scalars apply to the non-null branch.
+        args = get_args(annotation)
+        if get_origin(annotation) in (Union, UnionType) and type(None) in args and len(args) == 2:
+            inner = next(arg for arg in args if arg is not type(None))
+            target = Union[Annotated[inner, *metas], type(None)]
+        else:
+            target = Annotated[annotation, *metas]
+    else:
+        target = annotation
+    return target, strict
+
+
+
+# Unicode White_Space used by Rust str::trim, excluding Python's extra C0 separators.
+_HTTP_WHITESPACE = '\t\n\v\f\r \x85\xa0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000'
+_HTTP_INTEGER = re.compile(r'-?(?:0|[1-9][0-9]*)\Z')
+
+
+def _http_int(value):
+    """Match pydantic-core 2.46.5 str_as_int/clean_int_str on HTTP strings."""
+    if not isinstance(value, str):
+        return value
+    # Preserve the direct parser's size/error behavior before its cleanup fallback.
+    if _HTTP_INTEGER.fullmatch(value):
+        return int(value)
+    number = value.strip(_HTTP_WHITESPACE)
+    if number.startswith('+'):
+        number = number[1:]
+        if number.startswith('-'):
+            raise ValueError('Invalid integer parameter')
+    negative = number.startswith('-')
+    if negative:
+        number = number[1:]
+        if number.startswith(('-', '+')):
+            raise ValueError('Invalid integer parameter')
+    if not number or number[0] not in '0123456789-':
+        raise ValueError('Invalid integer parameter')
+    if number[0] == '0':
+        for offset in range(1, len(number)):
+            char = number[offset]
+            if char in '0_':
+                continue
+            if char in '123456789-':
+                number = number[offset:]
+                break
+            if char == '.':
+                number = number[offset - 1:]
+                break
+            raise ValueError('Invalid integer parameter')
+        else:
+            number = number[-1:]
+    if '.' in number:
+        whole, decimal = number.split('.', 1)
+        if decimal and all(char == '0' for char in decimal):
+            number = whole
+    if ('_' in number and not number.startswith('_') and not number.endswith('_')
+            and '__' not in number):
+        number = number.replace('_', '')
+    if negative:
+        number = '-' + number
+    if not _HTTP_INTEGER.fullmatch(number):
+        raise ValueError('Invalid integer parameter')
+    return int(number)
+
+def _http_normalizer(annotation):
+    """Compile supported transport coercions once at route registration."""
+    annotation = base_type(annotation)
+    origin, args = get_origin(annotation), get_args(annotation)
+    if origin in (Union, UnionType) and type(None) in args and len(args) == 2:
+        return _http_normalizer(next(arg for arg in args if arg is not type(None)))
+    if origin in (list, set, frozenset, tuple):
+        if origin is tuple and args and args[-1] is not Ellipsis:
+            children = tuple(_http_normalizer(arg) for arg in args)
+            if not any(children):
+                return None
+            def normalize_tuple(value):
+                return [children[i](item) if i < len(children) and children[i] else item
+                        for i, item in enumerate(value)] if isinstance(value, (list, tuple)) else value
+            return normalize_tuple
+        child = _http_normalizer(args[0]) if args else None
+        if child is None:
+            return None
+        def normalize_sequence(value):
+            return [child(item) for item in value] if isinstance(value, (list, tuple)) else value
+        return normalize_sequence
+    if annotation is int:
+        return _http_int
+    if annotation is bool:
+        def normalize_bool(value):
+            if isinstance(value, str):
+                lowered = value.lower()
+                if lowered in ('yes', 'on', 'y', 't'):
+                    return True
+                if lowered in ('no', 'off', 'n', 'f'):
+                    return False
+            return value
+        return normalize_bool
+    if annotation is bytes:
+        return lambda value: value.encode('utf-8') if isinstance(value, str) else value
+    return None
+
+
+def _parameter_validator(target, strict):
+    normalizer = None if strict else _http_normalizer(target)
+    convert = msgspec.convert
+    def validate(value: Any, values=None, *, loc=()):
+        try:
+            if normalizer is not None:
+                value = normalizer(value)
+            return convert(value, type=target, strict=strict), []
+        except (ValueError, UnicodeError, OverflowError) as exc:
+            return None, [{'loc': loc, 'msg': str(exc), 'type': 'value_error.msgspec'}]
+    return validate
+
+
+def prepare_parameters(dependant):
+    """Keep FastAPI extraction/aliases/defaults; replace supported validators."""
+    for group in ('path_params', 'query_params', 'header_params', 'cookie_params'):
+        for field in getattr(dependant, group):
+            if uses_pydantic(field.field_info.annotation):
+                continue
+            if getattr(field, '_msgspec_parameter', False):
+                continue
+            target, strict = constrained_type(field.field_info.annotation, field.field_info.metadata)
+            strict = bool(strict)
+            schema = msgspec.json.schema(target)
+
+            field.validate = _parameter_validator(target, strict)
+            field._msgspec_parameter = True
+            field._msgspec_schema = schema
+    for dependency in dependant.dependencies:
+        prepare_parameters(dependency)

msgspec_fastapi-0.0.1/tests/test_router.py

@@ -0,0 +1,321 @@
+"""Tests for MsgspecRouter request decoding, parameter validation and response encoding."""
+from typing import Annotated, Generic, TypeVar
+
+import msgspec
+import pytest
+from fastapi import APIRouter, Depends, FastAPI, Query, Response
+from fastapi.responses import HTMLResponse, PlainTextResponse
+from fastapi.testclient import TestClient
+from pydantic import BaseModel, Field
+
+from msgspec_fastapi import MsgspecRouter, install_openapi
+
+
+class City(msgspec.Struct):
+    population: Annotated[int, msgspec.Meta(ge=0)]
+
+
+class PrivateCity(City):
+    secret: str
+
+
+class PydCity(BaseModel):
+    population: Annotated[int, Field(ge=0)]
+
+
+class AliasModel(BaseModel):
+    internal: int = Field(alias='external')
+
+
+OMITTED = object()
+
+
+def setup(value, *, model=OMITTED, annotated=False, **options):
+    router = MsgspecRouter()
+    if model is not OMITTED:
+        options['response_model'] = model
+    if annotated:
+        async def endpoint() -> City:
+            return value
+    else:
+        async def endpoint():
+            return value
+    router.add_api_route('/value', endpoint, methods=['GET'], **options)
+    app = FastAPI()
+    app.include_router(router)
+    install_openapi(app, router)
+    return app
+
+
+def response(app, path='/value'):
+    return TestClient(app, raise_server_exceptions=False).get(path)
+
+
+@pytest.mark.parametrize('kind', ['explicit', 'inferred'])
+def test_declared_model_trusts_instance_like_pydantic(kind):
+    # Same as FastAPI with a Pydantic response_model: an existing instance of the
+    # declared class is not revalidated, so a later mutation is not detected.
+    value = City(1)
+    value.population = -1
+    app = setup(value, model=City if kind == 'explicit' else OMITTED, annotated=kind == 'inferred')
+    result = response(app)
+    assert result.status_code == 200 and result.json() == {'population': -1}
+
+
+def test_trusted_instance_encodes_nested_values_as_is():
+    # Documented difference from Pydantic: only the top-level class is checked, so a
+    # nested subclass inside a trusted instance keeps its extra fields.
+    class Holder(msgspec.Struct):
+        city: City
+
+    app = setup(Holder(PrivateCity(1, 'PRIVATE')), model=Holder)
+    assert response(app).json() == {'city': {'population': 1, 'secret': 'PRIVATE'}}
+
+
+def test_trusted_generic_instance_does_not_check_type_parameter():
+    # Documented difference from Pydantic: the type parameter of a generic Struct
+    # instance is not checked, only its class.
+    T = TypeVar('T')
+
+    class Box(msgspec.Struct, Generic[T]):
+        value: T
+
+    app = setup(Box('text'), model=Box[int])
+    assert response(app).json() == {'value': 'text'}
+
+
+@pytest.mark.parametrize('annotated,model', [(True, None), (False, None), (False, OMITTED)])
+def test_no_effective_model_serializes_mutated_struct(annotated, model):
+    value = City(1)
+    value.population = -1
+    result = response(setup(value, model=model, annotated=annotated))
+    assert result.status_code == 200 and result.json() == {'population': -1}
+
+
+@pytest.mark.parametrize('model,status', [(City, 500), (None, 200), (OMITTED, 200)])
+def test_raw_dict_constraints_follow_model_selection(model, status):
+    result = response(setup({'population': -1}, model=model))
+    assert result.status_code == status
+    if status == 200:
+        assert result.json() == {'population': -1}
+
+
+def test_no_model_disables_field_projection():
+    value = PrivateCity(1, 'PRIVATE')
+    assert response(setup(value, model=City)).json() == {'population': 1}
+    assert response(setup(value, model=None, annotated=True)).json() == {'population': 1, 'secret': 'PRIVATE'}
+
+
+@pytest.mark.parametrize('annotated,model,has_schema', [(True, OMITTED, True), (False, City, True), (True, None, False), (False, OMITTED, False)])
+def test_openapi_reflects_effective_response_model(annotated, model, has_schema):
+    app = setup(City(1), annotated=annotated, model=model)
+    schema = app.openapi()['paths']['/value']['get']['responses']['200']['content']['application/json']['schema']
+    if has_schema:
+        assert schema['$ref'].endswith('/City')
+    else:
+        assert schema == {}
+
+
+@pytest.mark.parametrize('model', [City, None, OMITTED])
+def test_explicit_response_bypasses_model_processing(model):
+    result = response(setup(Response(b'ready', status_code=203, headers={'X-Ready': 'yes'}), model=model))
+    assert result.status_code == 203 and result.content == b'ready'
+    assert result.headers['X-Ready'] == 'yes'
+
+
+@pytest.mark.parametrize('model', [City, None, OMITTED])
+def test_included_router_keeps_status_and_headers(model):
+    router = MsgspecRouter()
+    options = {} if model is OMITTED else {'response_model': model}
+
+    @router.get('/value', status_code=201, **options)
+    async def endpoint(response: Response):
+        response.status_code = 202
+        response.headers['X-Endpoint'] = 'kept'
+        return City(1)
+
+    parent = MsgspecRouter()
+    parent.include_router(router, prefix='/child')
+    app = FastAPI()
+    app.include_router(parent, prefix='/api')
+    install_openapi(app, parent)
+    result = response(app, '/api/child/value')
+    assert result.status_code == 202 and result.json() == {'population': 1}
+    assert result.headers['X-Endpoint'] == 'kept'
+
+
+@pytest.mark.parametrize('model', [None, OMITTED])
+def test_input_validation_remains_enabled_without_output_model(model):
+    router = MsgspecRouter()
+    options = {} if model is OMITTED else {'response_model': model}
+
+    @router.post('/value', **options)
+    async def endpoint(city: City):
+        return city
+
+    app = FastAPI()
+    app.include_router(router)
+    install_openapi(app, router)
+    client = TestClient(app, raise_server_exceptions=False)
+    assert client.post('/value', json={'population': -1}).status_code == 422
+    assert client.post('/value', content=b'{', headers={'Content-Type': 'application/json'}).status_code == 400
+    assert client.post('/value', json={'population': 1}).json() == {'population': 1}
+
+
+@pytest.mark.parametrize('cls', [PlainTextResponse, HTMLResponse])
+@pytest.mark.parametrize('at_router', [False, True])
+def test_untyped_custom_response_classes_remain_delegated(cls, at_router):
+    router = MsgspecRouter(**({'default_response_class': cls} if at_router else {}))
+    options = {} if at_router else {'response_class': cls}
+
+    @router.get('/value', **options)
+    async def endpoint():
+        return '<b>hello</b>'
+
+    app = FastAPI()
+    app.include_router(router)
+    result = response(app)
+    assert result.status_code == 200 and result.text == '<b>hello</b>'
+    assert result.headers['Content-Type'].startswith(cls.media_type)
+
+
+@pytest.mark.parametrize('status', [204, 304])
+def test_untyped_bodyless_status_keeps_empty_body(status):
+    result = response(setup(None, status_code=status))
+    assert result.status_code == status and result.content == b''
+    assert 'content-length' not in result.headers
+
+
+@pytest.mark.parametrize('nested', [False, True])
+def test_untyped_pydantic_values_use_public_json_aliases(nested):
+    value = AliasModel(external=1)
+    result = response(setup({'items': [value]} if nested else value))
+    assert result.status_code == 200
+    assert result.json() == ({'items': [{'external': 1}]} if nested else {'external': 1})
+
+
+def test_annotated_pydantic_route_is_still_delegated():
+    router = MsgspecRouter()
+
+    @router.get('/value')
+    async def endpoint() -> PydCity:
+        return {'population': -1}
+
+    app = FastAPI()
+    app.include_router(router)
+    assert response(app).status_code == 500
+
+
+@pytest.mark.parametrize('model', [None, OMITTED])
+@pytest.mark.parametrize('options', [
+    {'response_model_include': {'population'}},
+    {'response_model_exclude': {'extra'}},
+    {'response_model_exclude_unset': True},
+    {'response_model_exclude_defaults': True},
+    {'response_model_exclude_none': True},
+    {'response_model_by_alias': False},
+])
+def test_without_output_model_ignores_model_specific_options(model, options):
+    value = {'population': 1, 'extra': None}
+    result = response(setup(value, model=model, **options))
+    assert result.status_code == 200 and result.json() == value
+
+
+@pytest.mark.parametrize('options', [
+    {'response_model_exclude_none': True}, {'response_model_by_alias': False},
+])
+def test_typed_response_still_rejects_unsupported_model_options(options):
+    with pytest.raises(TypeError):
+        setup(City(1), model=City, **options)
+
+
+def test_non_json_body_is_rejected_before_dependencies():
+    calls = []
+
+    def dependency():
+        calls.append(1)
+
+    router = MsgspecRouter()
+
+    @router.post('/value', dependencies=[Depends(dependency)])
+    async def endpoint(city: City):
+        return city
+
+    app = FastAPI()
+    app.include_router(router)
+    client = TestClient(app, raise_server_exceptions=False)
+    assert client.post('/value', content=b'{', headers={'Content-Type': 'application/json'}).status_code == 400
+    assert client.post('/value', content=b'population=1', headers={'Content-Type': 'text/plain'}).status_code == 415
+    assert calls == []
+    assert client.post('/value', json={'population': 1}).status_code == 200
+    assert calls == [1]
+
+
+def test_body_is_decoded_strictly():
+    router = MsgspecRouter()
+
+    @router.post('/value')
+    async def endpoint(city: City):
+        return city
+
+    app = FastAPI()
+    app.include_router(router)
+    client = TestClient(app, raise_server_exceptions=False)
+    assert client.post('/value', json={'population': '1'}).status_code == 422
+
+
+@pytest.mark.parametrize('prefix', ['', '/api'])
+def test_parameters_are_validated_with_msgspec(prefix):
+    router = MsgspecRouter()
+
+    @router.get('/value/{item_id}')
+    async def endpoint(item_id: int, limit: Annotated[int, Query(ge=1, alias='max')] = 10,
+                       ratio: float = 0.5):
+        return {'item_id': item_id, 'limit': limit, 'ratio': ratio}
+
+    app = FastAPI()
+    if prefix:
+        parent = MsgspecRouter()
+        parent.include_router(router)
+        app.include_router(parent, prefix=prefix)
+        install_openapi(app, parent)
+    else:
+        app.include_router(router)
+        install_openapi(app, router)
+    client = TestClient(app, raise_server_exceptions=False)
+    assert client.get(f'{prefix}/value/3?max=2&ratio=1.5').json() == {'item_id': 3, 'limit': 2, 'ratio': 1.5}
+    assert client.get(f'{prefix}/value/3').json() == {'item_id': 3, 'limit': 10, 'ratio': 0.5}
+    assert client.get(f'{prefix}/value/x').status_code == 422
+    assert client.get(f'{prefix}/value/3?max=0').status_code == 422
+    # Pydantic accepts surrounding whitespace for float; msgspec.convert does not, so a
+    # 422 here shows that msgspec, not Pydantic, validated the included route.
+    assert client.get(f'{prefix}/value/3', params={'ratio': ' 1.5'}).status_code == 422
+    parameters = app.openapi()['paths'][f'{prefix}/value/{{item_id}}']['get']['parameters']
+    assert next(p for p in parameters if p['name'] == 'max')['schema']['minimum'] == 1
+
+
+def test_install_openapi_requires_routers():
+    with pytest.raises(TypeError):
+        install_openapi(FastAPI())
+
+
+@pytest.mark.parametrize('annotation,value', [
+    *((int, v) for v in ['5', '+5', '05', '1_0', '5.0', '5.5', ' 5 ', 'x']),
+    *((bool, v) for v in ['true', 'yes', 'off', 'f', '1', 'maybe']),
+])
+def test_scalar_query_coercion_matches_fastapi(annotation, value):
+    def make(router_class):
+        router = router_class()
+
+        async def endpoint(q: annotation):
+            return {'q': q}
+
+        router.add_api_route('/value', endpoint, methods=['GET'])
+        app = FastAPI()
+        app.include_router(router)
+        return TestClient(app, raise_server_exceptions=False).get('/value', params={'q': value})
+
+    expected, actual = make(APIRouter), make(MsgspecRouter)
+    assert actual.status_code == expected.status_code
+    if expected.status_code == 200:
+        assert actual.json() == expected.json()