docs: add documentation versioning

2026-04-16 14:46:24 +02:00 · 2026-03-11 15:04:20 -04:00
55 changed files with 1248 additions and 7812 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -6,9 +6,6 @@ on:
  pull_request:
    branches: [main]

-permissions:
-  contents: read
-
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
@@ -96,7 +93,7 @@ jobs:

      - name: Upload coverage to Codecov
        if: matrix.python-version == '3.14'
-        uses: codecov/codecov-action@v6
+        uses: codecov/codecov-action@v5
        with:
          token: ${{ secrets.CODECOV_TOKEN }}
          report_type: coverage
@@ -105,7 +102,7 @@ jobs:

      - name: Upload test results to Codecov
        if: matrix.python-version == '3.14'
-        uses: codecov/codecov-action@v6
+        uses: codecov/codecov-action@v5
        with:
          token: ${{ secrets.CODECOV_TOKEN }}
          report_type: test_results
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -6,48 +6,51 @@ on:

 permissions:
  contents: write
+  pages: write
+  id-token: write

 jobs:
  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0

+      - name: Configure git
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
      - name: Install uv
        uses: astral-sh/setup-uv@v7

      - name: Set up Python
        run: uv python install 3.13

-      - run: uv sync --group dev
+      - run: uv sync --group docs

-      - name: Configure git
+      - name: Install mkdocs shim
+        run: cp scripts/mkdocs .venv/bin/mkdocs && chmod +x .venv/bin/mkdocs
+
+      - name: Deploy docs version
        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
+          VERSION="${GITHUB_REF_NAME#v}"
+          MINOR_VERSION="${VERSION%.*}"
+          uv run mike deploy --push --update-aliases "$MINOR_VERSION" latest
+          uv run mike set-default --push latest

-      - name: Deploy documentation
-        run: |
-          VERSION=${GITHUB_REF_NAME#v}
-          MAJOR=$(echo "$VERSION" | cut -d. -f1)
-          DEPLOY_VERSION="v$(echo "$VERSION" | cut -d. -f1-2)"
+      - name: Prepare site artifact
+        run: git worktree add site gh-pages

-          # On new major: keep only the latest feature version of the previous major
-          PREV_MAJOR=$((MAJOR - 1))
-          OLD_FEATURE_VERSIONS=$(uv run mike list 2>/dev/null | grep -oE "^v${PREV_MAJOR}\.[0-9]+" || true)
+      - uses: actions/configure-pages@v5

-          if [ -n "$OLD_FEATURE_VERSIONS" ]; then
-            LATEST_PREV=$(echo "$OLD_FEATURE_VERSIONS" | sort -t. -k2 -n | tail -1)
-            echo "$OLD_FEATURE_VERSIONS" | while read -r OLD_V; do
-              if [ "$OLD_V" != "$LATEST_PREV" ]; then
-                echo "Deleting $OLD_V"
-                uv run mike delete "$OLD_V"
-              fi
-            done
-          fi
+      - uses: actions/upload-pages-artifact@v4
+        with:
+          path: site

-          uv run mike deploy --update-aliases "$DEPLOY_VERSION" stable
-          uv run mike set-default stable
-          git push origin gh-pages
+      - uses: actions/deploy-pages@v4
+        id: deployment
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,34 +0,0 @@
-# See https://pre-commit.com for more information
-# See https://pre-commit.com/hooks.html for more hooks
-repos:
-    - repo: https://github.com/pre-commit/pre-commit-hooks
-      rev: v6.0.0
-      hooks:
-          - id: check-added-large-files
-            args: ["--maxkb=750"]
-            exclude: ^uv.lock$
-          - id: end-of-file-fixer
-          - id: trailing-whitespace
-
-    - repo: local
-      hooks:
-          - id: local-ruff-check
-            name: ruff check
-            entry: uv run ruff check --force-exclude --fix --exit-non-zero-on-fix .
-            require_serial: true
-            language: unsupported
-            types: [python]
-
-          - id: local-ruff-format
-            name: ruff format
-            entry: uv run ruff format --force-exclude --exit-non-zero-on-format .
-            require_serial: true
-            language: unsupported
-            types: [python]
-
-          - id: local-ty
-            name: ty check
-            entry: uv run ty check
-            require_serial: true
-            language: unsupported
-            pass_filenames: false
--- a/README.md
+++ b/README.md
@@ -48,9 +48,8 @@ uv add "fastapi-toolsets[all]"
 - **Database**: Session management, transaction helpers, table locking, and polling-based row change detection
 - **Dependencies**: FastAPI dependency factories (`PathDependency`, `BodyDependency`) for automatic DB lookups from path or body parameters
 - **Fixtures**: Fixture system with dependency management, context support, and pytest integration
- **Model Mixins**: SQLAlchemy mixins for common column patterns (`UUIDMixin`, `UUIDv7Mixin`, `CreatedAtMixin`, `UpdatedAtMixin`, `TimestampMixin`)
- **Lifecycle Events**: Post-commit event system (`EventSession`, `listens_for`) that dispatches async/sync callbacks for insert, update, and delete operations
- **Standardized API Responses**: Consistent response format with `Response`, `ErrorResponse`, `PaginatedResponse`, `CursorPaginatedResponse` and `OffsetPaginatedResponse`.
+- **Model Mixins**: SQLAlchemy mixins for common column patterns (`UUIDMixin`, `CreatedAtMixin`, `UpdatedAtMixin`, `TimestampMixin`)
+- **Standardized API Responses**: Consistent response format with `Response`, `PaginatedResponse`, and `PydanticBase`
 - **Exception Handling**: Structured error responses with automatic OpenAPI documentation
 - **Logging**: Logging configuration with uvicorn integration via `configure_logging` and `get_logger`

--- a/docs/examples/pagination-search.md
+++ b/docs/examples/pagination-search.md
@@ -42,17 +42,12 @@ Declare `searchable_fields`, `facet_fields`, and `order_fields` once on [`CrudFa


 ## Routes
-
-```python title="routes.py:1:16"
--8<-- "docs_src/examples/pagination_search/routes.py:1:16"
-```
-
 ### Offset pagination

 Best for admin panels or any UI that needs a total item count and numbered pages.

-```python title="routes.py:19:37"
--8<-- "docs_src/examples/pagination_search/routes.py:19:37"
+```python title="routes.py:1:36"
+--8<-- "docs_src/examples/pagination_search/routes.py:1:36"
 ```

 **Example request**
@@ -66,13 +61,11 @@ GET /articles/offset?page=2&items_per_page=10&search=fastapi&status=published&or
 ```json
 {
  "status": "SUCCESS",
-  "pagination_type": "offset",
  "data": [
    { "id": "3f47ac69-...", "title": "FastAPI tips", "status": "published", ... }
  ],
  "pagination": {
    "total_count": 42,
-    "pages": 5,
    "page": 2,
    "items_per_page": 10,
    "has_more": true
@@ -86,14 +79,12 @@ GET /articles/offset?page=2&items_per_page=10&search=fastapi&status=published&or

 `filter_attributes` always reflects the values visible **after** applying the active filters. Use it to populate filter dropdowns on the client.

-To skip the `COUNT(*)` query for better performance on large tables, pass `include_total=False`. `pagination.total_count` will be `null` in the response, while `has_more` remains accurate.
-
 ### Cursor pagination

 Best for feeds, infinite scroll, or any high-throughput API where offset performance degrades.

-```python title="routes.py:40:58"
--8<-- "docs_src/examples/pagination_search/routes.py:40:58"
+```python title="routes.py:39:59"
+--8<-- "docs_src/examples/pagination_search/routes.py:39:59"
 ```

 **Example request**
@@ -107,7 +98,6 @@ GET /articles/cursor?items_per_page=10&status=published&order_by=created_at&orde
 ```json
 {
  "status": "SUCCESS",
-  "pagination_type": "cursor",
  "data": [
    { "id": "3f47ac69-...", "title": "FastAPI tips", "status": "published", ... }
  ],
@@ -126,47 +116,6 @@ GET /articles/cursor?items_per_page=10&status=published&order_by=created_at&orde

 Pass `next_cursor` as the `cursor` query parameter on the next request to advance to the next page.

-### Unified endpoint (both strategies)
-
-!!! info "Added in `v2.3.0`"
-
-[`paginate()`](../module/crud.md#unified-paginate--both-strategies-on-one-endpoint) lets a single endpoint support both strategies via a `pagination_type` query parameter. The `pagination_type` field in the response acts as a discriminator for frontend tooling.
-
-```python title="routes.py:61:79"
--8<-- "docs_src/examples/pagination_search/routes.py:61:79"
-```
-
-**Offset request** (default)
-
-```
-GET /articles/?pagination_type=offset&page=1&items_per_page=10
-```
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "offset",
-  "data": ["..."],
-  "pagination": { "total_count": 42, "pages": 5, "page": 1, "items_per_page": 10, "has_more": true }
-}
-```
-
-**Cursor request**
-
-```
-GET /articles/?pagination_type=cursor&items_per_page=10
-GET /articles/?pagination_type=cursor&items_per_page=10&cursor=eyJ2YWx1ZSI6...
-```
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "cursor",
-  "data": ["..."],
-  "pagination": { "next_cursor": "eyJ2YWx1ZSI6...", "prev_cursor": null, "items_per_page": 10, "has_more": true }
-}
-```
-
 ## Search behaviour

 Both endpoints inherit the same `searchable_fields` declared on `ArticleCrud`:
--- a/docs/index.md
+++ b/docs/index.md
@@ -48,9 +48,8 @@ uv add "fastapi-toolsets[all]"
 - **Database**: Session management, transaction helpers, table locking, and polling-based row change detection
 - **Dependencies**: FastAPI dependency factories (`PathDependency`, `BodyDependency`) for automatic DB lookups from path or body parameters
 - **Fixtures**: Fixture system with dependency management, context support, and pytest integration
- **Model Mixins**: SQLAlchemy mixins for common column patterns (`UUIDMixin`, `UUIDv7Mixin`, `CreatedAtMixin`, `UpdatedAtMixin`, `TimestampMixin`).
- **Lifecycle Events**: Post-commit event system (`EventSession`, `listens_for`) that dispatches async/sync callbacks for insert, update, and delete operations.
- **Standardized API Responses**: Consistent response format with `Response`, `ErrorResponse`, `PaginatedResponse`, `CursorPaginatedResponse` and `OffsetPaginatedResponse`.
+- **Model Mixins**: SQLAlchemy mixins for common column patterns (`UUIDMixin`, `CreatedAtMixin`, `UpdatedAtMixin`, `TimestampMixin`)
+- **Standardized API Responses**: Consistent response format with `Response`, `PaginatedResponse`, and `PydanticBase`
 - **Exception Handling**: Structured error responses with automatic OpenAPI documentation
 - **Logging**: Logging configuration with uvicorn integration via `configure_logging` and `get_logger`

--- a/docs/migration/v3.md
+++ b/docs/migration/v3.md
@@ -1,180 +0,0 @@
-# Migrating to v3.0
-
-This page covers every breaking change introduced in **v3.0** and the steps required to update your code.
-
---
-
-## CRUD
-
-### Facet keys now always use the full relationship chain
-
-In `v2`, relationship facet fields used only the terminal column key (e.g. `"name"` for `Role.name`) and only prepended the relationship name when two facet fields shared the same column key. In `v3`, facet keys **always** include the full relationship chain joined by `__`, regardless of collisions.
-
-=== "Before (`v2`)"
-
-    ```
-    User.status -> status
-    (User.role, Role.name) -> name
-    (User.role, Role.permission, Permission.name) -> name
-    ```
-
-=== "Now (`v3`)"
-
-    ```
-    User.status -> status
-    (User.role, Role.name) -> role__name
-    (User.role, Role.permission, Permission.name) -> role__permission__name
-    ```
-
---
-
-### `*_params` dependencies consolidated into per-paginate methods
-
-The six individual dependency methods (`offset_params`, `cursor_params`, `paginate_params`, `filter_params`, `search_params`, `order_params`) have been **removed** and replaced by three consolidated methods that bundle pagination, search, filter, and order into a single `Depends()` call.
-
-| Removed | Replacement |
-|---|---|
-| `offset_params()` + `filter_params()` + `search_params()` + `order_params()` | `offset_paginate_params()` |
-| `cursor_params()` + `filter_params()` + `search_params()` + `order_params()` | `cursor_paginate_params()` |
-| `paginate_params()` + `filter_params()` + `search_params()` + `order_params()` | `paginate_params()` |
-
-Each new method accepts `search`, `filter`, and `order` boolean toggles (all `True` by default) to disable features you don't need.
-
-=== "Before (`v2`)"
-
-    ```python
-    from fastapi_toolsets.crud import OrderByClause
-
-    @router.get("/offset")
-    async def list_articles_offset(
-        session: SessionDep,
-        params: Annotated[dict, Depends(ArticleCrud.offset_params(default_page_size=20))],
-        filter_by: Annotated[dict, Depends(ArticleCrud.filter_params())],
-        order_by: Annotated[OrderByClause | None, Depends(ArticleCrud.order_params(default_field=Article.created_at))],
-        search: str | None = None,
-    ) -> OffsetPaginatedResponse[ArticleRead]:
-        return await ArticleCrud.offset_paginate(
-            session=session,
-            **params,
-            search=search,
-            filter_by=filter_by or None,
-            order_by=order_by,
-            schema=ArticleRead,
-        )
-    ```
-
-=== "Now (`v3`)"
-
-    ```python
-    @router.get("/offset")
-    async def list_articles_offset(
-        session: SessionDep,
-        params: Annotated[
-            dict,
-            Depends(
-                ArticleCrud.offset_paginate_params(
-                    default_page_size=20,
-                    default_order_field=Article.created_at,
-                )
-            ),
-        ],
-    ) -> OffsetPaginatedResponse[ArticleRead]:
-        return await ArticleCrud.offset_paginate(session=session, **params, schema=ArticleRead)
-    ```
-
-The same pattern applies to `cursor_paginate_params()` and `paginate_params()`. To disable a feature, pass the toggle:
-
-```python
-# No search or ordering, only pagination + filtering
-ArticleCrud.offset_paginate_params(search=False, order=False)
-```
-
---
-
-## Models
-
-The lifecycle event system has been rewritten. Callbacks are now registered with a module-level [`listens_for`](../reference/models.md#fastapi_toolsets.models.listens_for) decorator and dispatched by [`EventSession`](../reference/models.md#fastapi_toolsets.models.EventSession), replacing the mixin-based approach from `v2`.
-
-### `WatchedFieldsMixin` and `@watch` removed
-
-Importing `WatchedFieldsMixin` or `watch` will raise `ImportError`.
-
-Model method callbacks (`on_create`, `on_delete`, `on_update`) and the `@watch` decorator are replaced by:
-
-1. **`__watched_fields__`** — a plain class attribute to restrict which field changes trigger `UPDATE` events (replaces `@watch`).
-2. **`@listens_for`** — a module-level decorator to register callbacks for one or more [`ModelEvent`](../reference/models.md#fastapi_toolsets.models.ModelEvent) types (replaces `on_create` / `on_delete` / `on_update` methods).
-
-=== "Before (`v2`)"
-
-    ```python
-    from fastapi_toolsets.models import WatchedFieldsMixin, watch
-
-    @watch("status")
-    class Order(Base, UUIDMixin, WatchedFieldsMixin):
-        __tablename__ = "orders"
-
-        status: Mapped[str]
-
-        async def on_create(self):
-            await notify_new_order(self.id)
-
-        async def on_update(self, changes):
-            if "status" in changes:
-                await notify_status_change(self.id, changes["status"])
-
-        async def on_delete(self):
-            await notify_order_cancelled(self.id)
-    ```
-
-=== "Now (`v3`)"
-
-    ```python
-    from fastapi_toolsets.models import ModelEvent, UUIDMixin, listens_for
-
-    class Order(Base, UUIDMixin):
-        __tablename__ = "orders"
-        __watched_fields__ = ("status",)
-
-        status: Mapped[str]
-
-    @listens_for(Order, [ModelEvent.CREATE])
-    async def on_order_created(order: Order, event_type: ModelEvent, changes: None):
-        await notify_new_order(order.id)
-
-    @listens_for(Order, [ModelEvent.UPDATE])
-    async def on_order_updated(order: Order, event_type: ModelEvent, changes: dict):
-        if "status" in changes:
-            await notify_status_change(order.id, changes["status"])
-
-    @listens_for(Order, [ModelEvent.DELETE])
-    async def on_order_deleted(order: Order, event_type: ModelEvent, changes: None):
-        await notify_order_cancelled(order.id)
-    ```
-
-### `EventSession` now required
-
-Without `EventSession`, lifecycle callbacks will silently stop firing.
-
-Callbacks are now dispatched inside `EventSession.commit()` rather than via background tasks. Pass it as the session class when creating your session factory:
-
-=== "Before (`v2`)"
-
-    ```python
-    from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-
-    engine = create_async_engine("postgresql+asyncpg://...")
-    SessionLocal = async_sessionmaker(engine, expire_on_commit=False)
-    ```
-
-=== "Now (`v3`)"
-
-    ```python
-    from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-    from fastapi_toolsets.models import EventSession
-
-    engine = create_async_engine("postgresql+asyncpg://...")
-    SessionLocal = async_sessionmaker(engine, expire_on_commit=False, class_=EventSession)
-    ```
-
-!!! note
-    If you use `create_db_session` from `fastapi_toolsets.pytest`, the session already uses `EventSession` — no changes needed in tests.
--- a/docs/module/crud.md
+++ b/docs/module/crud.md
@@ -7,12 +7,10 @@ Generic async CRUD operations for SQLAlchemy models with search, pagination, and

 ## Overview

-The `crud` module provides [`AsyncCrud`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud), a base class with a full suite of async database operations, and [`CrudFactory`](../reference/crud.md#fastapi_toolsets.crud.factory.CrudFactory), a convenience function to instantiate it for a given model.
+The `crud` module provides [`AsyncCrud`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud), an abstract base class with a full suite of async database operations, and [`CrudFactory`](../reference/crud.md#fastapi_toolsets.crud.factory.CrudFactory), a convenience function to instantiate it for a given model.

 ## Creating a CRUD class

-### Factory style
-
 ```python
 from fastapi_toolsets.crud import CrudFactory
 from myapp.models import User
@@ -20,65 +18,7 @@ from myapp.models import User
 UserCrud = CrudFactory(model=User)
 ```

-[`CrudFactory`](../reference/crud.md#fastapi_toolsets.crud.factory.CrudFactory) dynamically creates a class named `AsyncUserCrud` with `User` as its model. This is the most concise option for straightforward CRUD with no custom logic.
-
-### Subclass style
-
-!!! info "Added in `v2.3.0`"
-
-```python
-from fastapi_toolsets.crud.factory import AsyncCrud
-from myapp.models import User
-
-class UserCrud(AsyncCrud[User]):
-    model = User
-    searchable_fields = [User.username, User.email]
-    default_load_options = [selectinload(User.role)]
-```
-
-Subclassing [`AsyncCrud`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud) directly is the preferred style when you need to add custom methods or when the configuration is complex enough to benefit from a named class body.
-
-### Adding custom methods
-
-```python
-class UserCrud(AsyncCrud[User]):
-    model = User
-
-    @classmethod
-    async def get_active(cls, session: AsyncSession) -> list[User]:
-        return await cls.get_multi(session, filters=[User.is_active == True])
-```
-
-### Sharing a custom base across multiple models
-
-Define a generic base class with the shared methods, then subclass it for each model:
-
-```python
-from typing import Generic, TypeVar
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import DeclarativeBase
-from fastapi_toolsets.crud.factory import AsyncCrud
-
-T = TypeVar("T", bound=DeclarativeBase)
-
-class AuditedCrud(AsyncCrud[T], Generic[T]):
-    """Base CRUD with custom function"""
-
-    @classmethod
-    async def get_active(cls, session: AsyncSession):
-        return await cls.get_multi(session, filters=[cls.model.is_active == True])
-
-
-class UserCrud(AuditedCrud[User]):
-    model = User
-    searchable_fields = [User.username, User.email]
-```
-
-You can also use the factory shorthand with the same base by passing `base_class`:
-
-```python
-UserCrud = CrudFactory(User, base_class=AuditedCrud)
-```
+[`CrudFactory`](../reference/crud.md#fastapi_toolsets.crud.factory.CrudFactory) dynamically creates a class named `AsyncUserCrud` with `User` as its model.

 ## Basic operations

@@ -145,41 +85,44 @@ user = await UserCrud.first(session=session, filters=[User.is_active == True])

 !!! info "Added in `v1.1` (only offset_pagination via `paginate` if `<v1.1`)"

-Three pagination methods are available.  All return a typed response whose `pagination_type` field tells clients which strategy was used.
+Two pagination strategies are available. Both return a [`PaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse) but differ in how they navigate through results.

-| | `offset_paginate` | `cursor_paginate` | `paginate` |
-|---|---|---|---|
-| Return type | `OffsetPaginatedResponse` | `CursorPaginatedResponse` | either, based on `pagination_type` param |
-| Total count | Yes | No | / |
-| Jump to arbitrary page | Yes | No | / |
-| Performance on deep pages | Degrades | Constant | / |
-| Stable under concurrent inserts | No | Yes | / |
-| Use case | Admin panels, numbered pagination | Feeds, APIs, infinite scroll | single endpoint, both strategies |
+| | `offset_paginate` | `cursor_paginate` |
+|---|---|---|
+| Total count | Yes | No |
+| Jump to arbitrary page | Yes | No |
+| Performance on deep pages | Degrades | Constant |
+| Stable under concurrent inserts | No | Yes |
+| Search compatible | Yes | Yes |
+| Use case | Admin panels, numbered pagination | Feeds, APIs, infinite scroll |

 ### Offset pagination

 ```python
-from typing import Annotated
-from fastapi import Depends
-
-@router.get("")
+@router.get(
+    "",
+    response_model=PaginatedResponse[User],
+)
 async def get_users(
    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.offset_paginate_params())],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await UserCrud.offset_paginate(session=session, **params, schema=UserRead)
+    items_per_page: int = 50,
+    page: int = 1,
+):
+    return await crud.UserCrud.offset_paginate(
+        session=session,
+        items_per_page=items_per_page,
+        page=page,
+    )
 ```

-The [`offset_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.offset_paginate) method returns an [`OffsetPaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.OffsetPaginatedResponse):
+The [`offset_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.offset_paginate) method returns a [`PaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse) whose `pagination` field is an [`OffsetPagination`](../reference/schemas.md#fastapi_toolsets.schemas.OffsetPagination) object:

 ```json
 {
  "status": "SUCCESS",
-  "pagination_type": "offset",
  "data": ["..."],
  "pagination": {
    "total_count": 100,
-    "pages": 5,
    "page": 1,
    "items_per_page": 20,
    "has_more": true
@@ -187,38 +130,30 @@ The [`offset_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.Async
 }
 ```

-#### Skipping the COUNT query
-
-!!! info "Added in `v2.4.1`"
-
-By default `offset_paginate` runs two queries: one for the page items and one `COUNT(*)` for `total_count`. On large tables the `COUNT` can be expensive. Pass `include_total=False` to `offset_paginate_params()` to skip it:
-
-```python
-@router.get("")
-async def get_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.offset_paginate_params(include_total=False))],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await UserCrud.offset_paginate(session=session, **params, schema=UserRead)
-```
-
 ### Cursor pagination

 ```python
-@router.get("")
+@router.get(
+    "",
+    response_model=PaginatedResponse[UserRead],
+)
 async def list_users(
    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.cursor_paginate_params())],
-) -> CursorPaginatedResponse[UserRead]:
-    return await UserCrud.cursor_paginate(session=session, **params, schema=UserRead)
+    cursor: str | None = None,
+    items_per_page: int = 20,
+):
+    return await UserCrud.cursor_paginate(
+        session=session,
+        cursor=cursor,
+        items_per_page=items_per_page,
+    )
 ```

-The [`cursor_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.cursor_paginate) method returns a [`CursorPaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.CursorPaginatedResponse):
+The [`cursor_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.cursor_paginate) method returns a [`PaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse) whose `pagination` field is a [`CursorPagination`](../reference/schemas.md#fastapi_toolsets.schemas.CursorPagination) object:

 ```json
 {
  "status": "SUCCESS",
-  "pagination_type": "cursor",
  "data": ["..."],
  "pagination": {
    "next_cursor": "eyJ2YWx1ZSI6ICIzZjQ3YWM2OS0uLi4ifQ==",
@@ -245,7 +180,7 @@ The cursor column is set once on [`CrudFactory`](../reference/crud.md#fastapi_to
 !!! note
    `cursor_column` is required. Calling [`cursor_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.cursor_paginate) on a CRUD class that has no `cursor_column` configured raises a `ValueError`.

-The cursor value is URL-safe base64-encoded (no padding) when returned to the client and decoded back to the correct Python type on the next request. The following SQLAlchemy column types are supported:
+The cursor value is base64-encoded when returned to the client and decoded back to the correct Python type on the next request. The following SQLAlchemy column types are supported:

 | SQLAlchemy type | Python type |
 |---|---|
@@ -263,28 +198,6 @@ PostCrud = CrudFactory(model=Post, cursor_column=Post.id)
 PostCrud = CrudFactory(model=Post, cursor_column=Post.created_at)
 ```

-### Unified endpoint (both strategies)
-
-!!! info "Added in `v2.3.0`"
-
-[`paginate()`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.paginate) dispatches to `offset_paginate` or `cursor_paginate` based on a `pagination_type` query parameter, letting you expose **one endpoint** that supports both strategies.  The `pagination_type` field in the response tells clients which strategy was used, enabling frontend discriminated-union typing.
-
-```python
-from fastapi_toolsets.schemas import PaginatedResponse
-
-@router.get("")
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.paginate_params())],
-) -> PaginatedResponse[UserRead]:
-    return await UserCrud.paginate(session, **params, schema=UserRead)
-```
-
-```
-GET /users?pagination_type=offset&page=2&items_per_page=10
-GET /users?pagination_type=cursor&cursor=eyJ2YWx1ZSI6...&items_per_page=10
-```
-
 ## Search

 Two search strategies are available, both compatible with [`offset_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.offset_paginate) and [`cursor_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.cursor_paginate).
@@ -299,9 +212,6 @@ Two search strategies are available, both compatible with [`offset_paginate`](..

 ### Full-text search

-!!! info "Added in `v2.2.1`"
-    The model's primary key is always included in `searchable_fields` automatically, so searching by ID works out of the box without any configuration. When no `searchable_fields` are declared, only the primary key is searched.
-
 Declare `searchable_fields` on the CRUD class. Relationship traversal is supported via tuples:

 ```python
@@ -324,63 +234,53 @@ result = await UserCrud.offset_paginate(
 )
 ```

-Or via the dependency to narrow which fields are exposed as query parameters:
-
-```python
-params = UserCrud.offset_paginate_params(search_fields=[Post.title])
-```
-
 This allows searching with both [`offset_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.offset_paginate) and [`cursor_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.cursor_paginate):

 ```python
-@router.get("")
+@router.get(
+    "",
+    response_model=PaginatedResponse[User],
+)
 async def get_users(
    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.offset_paginate_params())],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await UserCrud.offset_paginate(session=session, **params, schema=UserRead)
+    items_per_page: int = 50,
+    page: int = 1,
+    search: str | None = None,
+):
+    return await crud.UserCrud.offset_paginate(
+        session=session,
+        items_per_page=items_per_page,
+        page=page,
+        search=search,
+    )
 ```

 ```python
-@router.get("")
+@router.get(
+    "",
+    response_model=PaginatedResponse[User],
+)
 async def get_users(
    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.cursor_paginate_params())],
-) -> CursorPaginatedResponse[UserRead]:
-    return await UserCrud.cursor_paginate(session=session, **params, schema=UserRead)
+    cursor: str | None = None,
+    items_per_page: int = 50,
+    search: str | None = None,
+):
+    return await crud.UserCrud.cursor_paginate(
+        session=session,
+        items_per_page=items_per_page,
+        cursor=cursor,
+        search=search,
+    )
 ```

-The dependency adds two query parameters to the endpoint:
-
-| Parameter       | Type          |
-| --------------- | ------------- |
-| `search`        | `str \| null` |
-| `search_column` | `str \| null` |
-
-```
-GET /posts?search=hello                        → search all configured columns
-GET /posts?search=hello&search_column=title    → search only Post.title
-```
-
-The available search column keys are returned in the `search_columns` field of [`PaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse). Use them to populate a column picker in the UI, or to validate `search_column` values on the client side:
-
-```json
-{
-  "status": "SUCCESS",
-  "data": ["..."],
-  "pagination": { "..." },
-  "search_columns": ["content", "author__username", "title"]
-}
-```
-
-!!! info "Key format uses `__` as a separator for relationship chains."
-    A direct column `Post.title` produces `"title"`. A relationship tuple `(Post.author, User.username)` produces `"author__username"`. An unknown `search_column` value raises [`InvalidSearchColumnError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.InvalidSearchColumnError) (HTTP 422).
-
 ### Faceted search

 !!! info "Added in `v1.2`"

-Declare `facet_fields` on the CRUD class to return distinct column values alongside paginated results. This is useful for populating filter dropdowns or building faceted search UIs. Relationship traversal is supported via tuples, using the same syntax as `searchable_fields`:
+Declare `facet_fields` on the CRUD class to return distinct column values alongside paginated results. This is useful for populating filter dropdowns or building faceted search UIs.
+
+Facet fields use the same syntax as `searchable_fields` — direct columns or relationship tuples:

 ```python
 UserCrud = CrudFactory(
@@ -402,47 +302,7 @@ result = await UserCrud.offset_paginate(
 )
 ```

-Or via the dependency to narrow which fields are exposed as query parameters:
-
-```python
-params = UserCrud.offset_paginate_params(facet_fields=[User.country])
-```
-
-Facet filtering is built into the consolidated params dependencies. When `filter=True` (the default), each facet field is exposed as a query parameter and values are collected into `filter_by` automatically:
-
-```python
-from typing import Annotated
-
-from fastapi import Depends
-
-@router.get("", response_model_exclude_none=True)
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.offset_paginate_params())],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await UserCrud.offset_paginate(session=session, **params, schema=UserRead)
-```
-
-```python
-@router.get("", response_model_exclude_none=True)
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.cursor_paginate_params())],
-) -> CursorPaginatedResponse[UserRead]:
-    return await UserCrud.cursor_paginate(session=session, **params, schema=UserRead)
-```
-
-Both single-value and multi-value query parameters work:
-
-```
-GET /users?status=active                      → filter_by={"status": ["active"]}
-GET /users?status=active&country=FR           → filter_by={"status": ["active"], "country": ["FR"]}
-GET /users?role__name=admin&role__name=editor → filter_by={"role__name": ["admin", "editor"]}  (IN clause)
-```
-
-`filter_by` and `filters` can be combined — both are applied with AND logic.
-
-The distinct values for each facet field are returned in the `filter_attributes` field of [`PaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse). Use them to populate filter dropdowns in the UI, or to validate `filter_by` keys on the client side:
+The distinct values are returned in the `filter_attributes` field of [`PaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse):

 ```json
 {
@@ -452,19 +312,56 @@ The distinct values for each facet field are returned in the `filter_attributes`
  "filter_attributes": {
    "status": ["active", "inactive"],
    "country": ["DE", "FR", "US"],
-    "role__name": ["admin", "editor", "viewer"]
+    "name": ["admin", "editor", "viewer"]
  }
 }
 ```

-!!! info "Key format uses `__` as a separator for relationship chains."
-    A direct column `User.status` produces `"status"`. A relationship tuple `(User.role, Role.name)` produces `"role__name"`. A deeper chain `(User.role, Role.permission, Permission.name)` produces `"role__permission__name"`. An unknown `filter_by` key raises [`InvalidFacetFilterError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.InvalidFacetFilterError) (HTTP 422).
+Use `filter_by` to pass the client's chosen filter values directly — no need to build SQLAlchemy conditions by hand. Any unknown key raises [`InvalidFacetFilterError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.InvalidFacetFilterError).
+
+!!! info "The keys in `filter_by` are the same keys the client received in `filter_attributes`."
+    Keys are normally the terminal `column.key` (e.g. `"name"` for `Role.name`). When two facet fields share the same column key (e.g. `(Build.project, Project.name)` and `(Build.os, Os.name)`), the relationship name is prepended automatically: `"project__name"` and `"os__name"`.
+
+`filter_by` and `filters` can be combined — both are applied with AND logic.
+
+Use [`filter_params()`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.filter_params) to generate a dict with the facet filter values from the query parameters:
+
+```python
+from typing import Annotated
+
+from fastapi import Depends
+
+UserCrud = CrudFactory(
+    model=User,
+    facet_fields=[User.status, User.country, (User.role, Role.name)],
+)
+
+@router.get("", response_model_exclude_none=True)
+async def list_users(
+    session: SessionDep,
+    page: int = 1,
+    filter_by: Annotated[dict[str, list[str]], Depends(UserCrud.filter_params())],
+) -> PaginatedResponse[UserRead]:
+    return await UserCrud.offset_paginate(
+        session=session,
+        page=page,
+        filter_by=filter_by,
+    )
+```
+
+Both single-value and multi-value query parameters work:
+
+```
+GET /users?status=active              → filter_by={"status": ["active"]}
+GET /users?status=active&country=FR   → filter_by={"status": ["active"], "country": ["FR"]}
+GET /users?role=admin&role=editor     → filter_by={"role": ["admin", "editor"]}  (IN clause)
+```

 ## Sorting

 !!! info "Added in `v1.3`"

-Declare `order_fields` on the CRUD class. Relationship traversal is supported via tuples, using the same syntax as `searchable_fields` and `facet_fields`:
+Declare `order_fields` on the CRUD class to expose client-driven column ordering via `order_by` and `order` query parameters.

 ```python
 UserCrud = CrudFactory(
@@ -472,80 +369,46 @@ UserCrud = CrudFactory(
    order_fields=[
        User.name,
        User.created_at,
-        (User.role, Role.name),  # sort by a related model column
    ],
 )
 ```

-You can override `order_fields` per call:
-
-```python
-result = await UserCrud.offset_paginate(
-    session=session,
-    order_fields=[User.name],
-)
-```
-
-Or via the dependency to narrow which fields are exposed as query parameters:
-
-```python
-params = UserCrud.offset_paginate_params(order_fields=[User.name])
-```
-
-Sorting is built into the consolidated params dependencies. When `order=True` (the default), `order_by` and `order` query parameters are exposed and resolved into an `OrderByClause` automatically:
+Call [`order_params()`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.order_params) to generate a FastAPI dependency that maps the query parameters to an [`OrderByClause`](../reference/crud.md#fastapi_toolsets.crud.factory.OrderByClause) expression:

 ```python
 from typing import Annotated

 from fastapi import Depends
+from fastapi_toolsets.crud import OrderByClause

@router.get("")
 async def list_users(
    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.offset_paginate_params())],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await UserCrud.offset_paginate(session=session, **params, schema=UserRead)
-```
-
-```python
-@router.get("")
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.cursor_paginate_params())],
-) -> CursorPaginatedResponse[UserRead]:
-    return await UserCrud.cursor_paginate(session=session, **params, schema=UserRead)
+    order_by: Annotated[OrderByClause | None, Depends(UserCrud.order_params())],
+) -> PaginatedResponse[UserRead]:
+    return await UserCrud.offset_paginate(session=session, order_by=order_by)
 ```

 The dependency adds two query parameters to the endpoint:

 | Parameter  | Type            |
 | ---------- | --------------- |
-| `order_by` | `str \| null`  |
+| `order_by` | `str | null`   |
 | `order`    | `asc` or `desc` |

 ```
-GET /users?order_by=name&order=asc         → ORDER BY users.name ASC
-GET /users?order_by=role__name&order=desc  → LEFT JOIN roles ON ... ORDER BY roles.name DESC
+GET /users?order_by=name&order=asc   → ORDER BY users.name ASC
+GET /users?order_by=name&order=desc  → ORDER BY users.name DESC
 ```

-!!! info "Relationship tuples are joined automatically."
-    When a relation field is selected, the related table is LEFT OUTER JOINed automatically. An unknown `order_by` value raises [`InvalidOrderFieldError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.InvalidOrderFieldError) (HTTP 422).
+An unknown `order_by` value raises [`InvalidOrderFieldError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.InvalidOrderFieldError) (HTTP 422).

+You can also pass `order_fields` directly to `order_params()` to override the class-level defaults without modifying them:

-The available sort keys are returned in the `order_columns` field of [`PaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse). Use them to populate a sort picker in the UI, or to validate `order_by` values on the client side:
-
-```json
-{
-  "status": "SUCCESS",
-  "data": ["..."],
-  "pagination": { "..." },
-  "order_columns": ["created_at", "name", "role__name"]
-}
+```python
+UserOrderParams = UserCrud.order_params(order_fields=[User.name])
 ```

-!!! info "Key format uses `__` as a separator for relationship chains."
-    A direct column `User.name` produces `"name"`. A relationship tuple `(User.role, Role.name)` produces `"role__name"`.
-
 ## Relationship loading

 !!! info "Added in `v1.1`"
@@ -630,11 +493,12 @@ async def get_user(session: SessionDep, uuid: UUID) -> Response[UserRead]:
    )

@router.get("")
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(crud.UserCrud.offset_paginate_params())],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await crud.UserCrud.offset_paginate(session=session, **params, schema=UserRead)
+async def list_users(session: SessionDep, page: int = 1) -> PaginatedResponse[UserRead]:
+    return await crud.UserCrud.offset_paginate(
+        session=session,
+        page=page,
+        schema=UserRead,
+    )
 ```

 The schema must have `from_attributes=True` (or inherit from [`PydanticBase`](../reference/schemas.md#fastapi_toolsets.schemas.PydanticBase)) so it can be built from SQLAlchemy model instances.
--- a/docs/module/dependencies.md
+++ b/docs/module/dependencies.md
@@ -13,13 +13,8 @@ The `dependencies` module provides two factory functions that create FastAPI dep
 ```python
 from fastapi_toolsets.dependencies import PathDependency

-# Plain callable
 UserDep = PathDependency(model=User, field=User.id, session_dep=get_db)

-# Annotated
-SessionDep = Annotated[AsyncSession, Depends(get_db)]
-UserDep = PathDependency(model=User, field=User.id, session_dep=SessionDep)
-
@router.get("/users/{user_id}")
 async def get_user(user: User = UserDep):
    return user
@@ -42,14 +37,8 @@ async def get_user(user: User = UserDep):
 ```python
 from fastapi_toolsets.dependencies import BodyDependency

-# Plain callable
 RoleDep = BodyDependency(model=Role, field=Role.id, session_dep=get_db, body_field="role_id")

-# Annotated
-SessionDep = Annotated[AsyncSession, Depends(get_db)]
-RoleDep = BodyDependency(model=Role, field=Role.id, session_dep=SessionDep, body_field="role_id")
-
-
@router.post("/users")
 async def create_user(body: UserCreateSchema, role: Role = RoleDep):
    user = User(username=body.username, role=role)
--- a/docs/module/fixtures.md
+++ b/docs/module/fixtures.md
@@ -38,20 +38,18 @@ By context with [`load_fixtures_by_context`](../reference/fixtures.md#fastapi_to
 from fastapi_toolsets.fixtures import load_fixtures_by_context

 async with db_context() as session:
-    await load_fixtures_by_context(session, fixtures, Context.TESTING)
+    await load_fixtures_by_context(session=session, registry=fixtures, context=Context.TESTING)
 ```

-Directly by name with [`load_fixtures`](../reference/fixtures.md#fastapi_toolsets.fixtures.utils.load_fixtures):
+Directly with [`load_fixtures`](../reference/fixtures.md#fastapi_toolsets.fixtures.utils.load_fixtures):

 ```python
 from fastapi_toolsets.fixtures import load_fixtures

 async with db_context() as session:
-    await load_fixtures(session, fixtures, "roles", "test_users")
+    await load_fixtures(session=session, registry=fixtures)
 ```

-Both functions return a `dict[str, list[...]]` mapping each fixture name to the list of loaded instances.
-
 ## Contexts

 [`Context`](../reference/fixtures.md#fastapi_toolsets.fixtures.enum.Context) is an enum with predefined values:
@@ -60,60 +58,10 @@ Both functions return a `dict[str, list[...]]` mapping each fixture name to the
 |---------|-------------|
 | `Context.BASE` | Core data required in all environments |
 | `Context.TESTING` | Data only loaded during tests |
-| `Context.DEVELOPMENT` | Data only loaded in development |
 | `Context.PRODUCTION` | Data only loaded in production |

 A fixture with no `contexts` defined takes `Context.BASE` by default.

-### Custom contexts
-
-Plain strings and any `Enum` subclass are accepted wherever a `Context` enum is expected.
-
-```python
-from enum import Enum
-
-class AppContext(str, Enum):
-    STAGING = "staging"
-    DEMO = "demo"
-
-@fixtures.register(contexts=[AppContext.STAGING])
-def staging_data():
-    return [Config(key="feature_x", enabled=True)]
-
-await load_fixtures_by_context(session, fixtures, AppContext.STAGING)
-```
-
-### Default context for a registry
-
-Pass `contexts` to `FixtureRegistry` to set a default for all fixtures registered in it:
-
-```python
-testing_registry = FixtureRegistry(contexts=[Context.TESTING])
-
-@testing_registry.register          # implicitly contexts=[Context.TESTING]
-def test_orders():
-    return [Order(id=1, total=99)]
-```
-
-### Same fixture name, multiple context variants
-
-The same fixture name may be registered under different (non-overlapping) context sets. When multiple contexts are loaded together, all matching variants are merged:
-
-```python
-@fixtures.register(contexts=[Context.BASE])
-def users():
-    return [User(id=1, username="admin")]
-
-@fixtures.register(contexts=[Context.TESTING])
-def users():
-    return [User(id=2, username="tester")]
-
-# loads both admin and tester
-await load_fixtures_by_context(session, fixtures, Context.BASE, Context.TESTING)
-```
-
-Registering two variants with overlapping context sets raises `ValueError`.
-
 ## Load strategies

 [`LoadStrategy`](../reference/fixtures.md#fastapi_toolsets.fixtures.enum.LoadStrategy) controls how the fixture loader handles rows that already exist:
@@ -121,44 +69,20 @@ Registering two variants with overlapping context sets raises `ValueError`.
 | Strategy | Description |
 |----------|-------------|
 | `LoadStrategy.INSERT` | Insert only, fail on duplicates |
-| `LoadStrategy.MERGE` | Insert or update on conflict (default) |
-| `LoadStrategy.SKIP_EXISTING` | Skip rows that already exist |
-
-```python
-await load_fixtures_by_context(
-    session, fixtures, Context.BASE, strategy=LoadStrategy.SKIP_EXISTING
-)
-```
+| `LoadStrategy.UPSERT` | Insert or update on conflict |
+| `LoadStrategy.SKIP` | Skip rows that already exist |

 ## Merging registries

-Split fixture definitions across modules and merge them:
+Split fixtures definitions across modules and merge them:

 ```python
 from myapp.fixtures.dev import dev_fixtures
 from myapp.fixtures.prod import prod_fixtures

-fixtures = FixtureRegistry()
+fixtures = fixturesRegistry()
 fixtures.include_registry(registry=dev_fixtures)
 fixtures.include_registry(registry=prod_fixtures)
-```
-
-Fixtures with the same name are allowed as long as their context sets do not overlap. Conflicting contexts raise `ValueError`.
-
-## Looking up fixture instances
-
-[`get_obj_by_attr`](../reference/fixtures.md#fastapi_toolsets.fixtures.utils.get_obj_by_attr) retrieves a specific instance from a fixture function by attribute value — useful when building cross-fixture `depends_on` relationships:
-
-```python
-from fastapi_toolsets.fixtures import get_obj_by_attr
-
-@fixtures.register(depends_on=["roles"])
-def users():
-    admin_role = get_obj_by_attr(roles, "name", "admin")
-    return [User(id=1, username="alice", role_id=admin_role.id)]
-```
-
-Raises `StopIteration` if no matching instance is found.

 ## Pytest integration

@@ -187,6 +111,7 @@ async def test_user_can_login(fixture_users: list[User], fixture_roles: list[Rol
    ...
 ```

+
 The load order is resolved automatically from the `depends_on` declarations in your registry. Each generated fixture receives `db_session` as a dependency and returns the list of loaded model instances.

 ## CLI integration
--- a/docs/module/models.md
+++ b/docs/module/models.md
@@ -18,15 +18,13 @@ class Article(Base, UUIDMixin, TimestampMixin):
    content: Mapped[str]
 ```

-All timestamp columns are timezone-aware (`TIMESTAMPTZ`). All defaults are server-side (`clock_timestamp()`), so they are also applied when inserting rows via raw SQL outside the ORM.
+All timestamp columns are timezone-aware (`TIMESTAMPTZ`). All defaults are server-side, so they are also applied when inserting rows via raw SQL outside the ORM.

 ## Mixins

 ### [`UUIDMixin`](../reference/models.md#fastapi_toolsets.models.UUIDMixin)

-Adds a `id: UUID` primary key generated server-side by PostgreSQL using `gen_random_uuid()`. The value is retrieved via `RETURNING` after insert, so it is available on the Python object immediately after `flush()`.
-
-!!! warning "Requires PostgreSQL 13+"
+Adds a `id: UUID` primary key generated server-side by PostgreSQL using `gen_random_uuid()` (requires PostgreSQL 13+). The value is retrieved via `RETURNING` after insert, so it is available on the Python object immediately after `flush()`.

 ```python
 from fastapi_toolsets.models import UUIDMixin
@@ -38,37 +36,13 @@ class User(Base, UUIDMixin):

 # id is None before flush
 user = User(username="alice")
-session.add(user)
 await session.flush()
 print(user.id)  # UUID('...')
 ```

-### [`UUIDv7Mixin`](../reference/models.md#fastapi_toolsets.models.UUIDv7Mixin)
-
-!!! info "Added in `v2.3`"
-
-Adds a `id: UUID` primary key generated server-side by PostgreSQL using `uuidv7()`. It's a time-ordered UUID format that encodes a millisecond-precision timestamp in the most significant bits, making it naturally sortable and index-friendly.
-
-!!! warning "Requires PostgreSQL 18+"
-
-```python
-from fastapi_toolsets.models import UUIDv7Mixin
-
-class Event(Base, UUIDv7Mixin):
-    __tablename__ = "events"
-
-    name: Mapped[str]
-
-# id is None before flush
-event = Event(name="user.signup")
-session.add(event)
-await session.flush()
-print(event.id)  # UUID('019...')
-```
-
 ### [`CreatedAtMixin`](../reference/models.md#fastapi_toolsets.models.CreatedAtMixin)

-Adds a `created_at: datetime` column set to `clock_timestamp()` on insert. The column has no `onupdate` hook — it is intentionally immutable after the row is created.
+Adds a `created_at: datetime` column set to `NOW()` on insert. The column has no `onupdate` hook — it is intentionally immutable after the row is created.

 ```python
 from fastapi_toolsets.models import UUIDMixin, CreatedAtMixin
@@ -81,7 +55,7 @@ class Order(Base, UUIDMixin, CreatedAtMixin):

 ### [`UpdatedAtMixin`](../reference/models.md#fastapi_toolsets.models.UpdatedAtMixin)

-Adds an `updated_at: datetime` column set to `clock_timestamp()` on insert and automatically updated to `clock_timestamp()` on every ORM-level update (via SQLAlchemy's `onupdate` hook).
+Adds an `updated_at: datetime` column set to `NOW()` on insert and automatically updated to `NOW()` on every ORM-level update (via SQLAlchemy's `onupdate` hook).

 ```python
 from fastapi_toolsets.models import UUIDMixin, UpdatedAtMixin
@@ -117,118 +91,23 @@ class Article(Base, UUIDMixin, TimestampMixin):
    title: Mapped[str]
 ```

-## Lifecycle events
+## Composing mixins

-The event system provides lifecycle callbacks that fire **after commit**. If the transaction rolls back, no callback fires.
-
-### Setup
-
-Event dispatch requires [`EventSession`](../reference/models.md#fastapi_toolsets.models.EventSession). Pass it as the session class when creating your session factory:
+All mixins can be combined in any order. The only constraint is that exactly one primary key must be defined — either via `UUIDMixin` or directly on the model.

 ```python
-from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-from fastapi_toolsets.models import EventSession
+from fastapi_toolsets.models import UUIDMixin, TimestampMixin

-engine = create_async_engine("postgresql+asyncpg://...")
-SessionLocal = async_sessionmaker(engine, expire_on_commit=False, class_=EventSession)
+class Event(Base, UUIDMixin, TimestampMixin):
+    __tablename__ = "events"
+    name: Mapped[str]
+
+class Counter(Base, UpdatedAtMixin):
+    __tablename__ = "counters"
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    value: Mapped[int]
 ```

-!!! info "Callbacks fire on `session.commit()` only — not on savepoints."
-    Savepoints created by [`get_transaction`](db.md) or `begin_nested()` do **not**
-    trigger callbacks. All events accumulated across flushes are dispatched once
-    when the outermost `commit()` is called.
-
-### Events
-
-Three event types are available, each corresponding to a [`ModelEvent`](../reference/models.md#fastapi_toolsets.models.ModelEvent) value:
-
-| Event | Trigger |
-|---|---|
-| `ModelEvent.CREATE` | After `INSERT` commit |
-| `ModelEvent.DELETE` | After `DELETE` commit |
-| `ModelEvent.UPDATE` | After `UPDATE` commit on a watched field |
-
-!!! warning "Callbacks fire only for ORM-level changes. Rows updated via raw SQL (`UPDATE ... SET ...`) are not detected."
-
-### Watched fields
-
-Set `__watched_fields__` on the model to restrict which field changes trigger `UPDATE` events. It must be a `tuple[str, ...]` — any other type raises `TypeError`:
-
-| Class attribute | `UPDATE` behaviour |
-|---|---|
-| `__watched_fields__ = ("status", "role")` | Only fires when `status` or `role` changes |
-| *(not set)* | Fires when **any** mapped field changes |
-
-`__watched_fields__` is inherited through the class hierarchy via normal Python MRO. A subclass can override it:
-
-```python
-class Order(Base, UUIDMixin):
-    __watched_fields__ = ("status",)
-    ...
-
-class UrgentOrder(Order):
-    # inherits __watched_fields__ = ("status",)
-    ...
-
-class PriorityOrder(Order):
-    __watched_fields__ = ("priority",)
-    # overrides parent — UPDATE fires only for priority changes
-    ...
-```
-
-### Registering handlers
-
-Register handlers with the [`listens_for`](../reference/models.md#fastapi_toolsets.models.listens_for) decorator. Every callback receives three arguments: the model instance, the [`ModelEvent`](../reference/models.md#fastapi_toolsets.models.ModelEvent) that triggered it, and a `changes` dict (`None` for `CREATE` and `DELETE`):
-
-```python
-from fastapi_toolsets.models import ModelEvent, UUIDMixin, listens_for
-
-class Order(Base, UUIDMixin):
-    __tablename__ = "orders"
-    __watched_fields__ = ("status",)
-
-    status: Mapped[str]
-
-@listens_for(Order, [ModelEvent.CREATE])
-async def on_order_created(order: Order, event_type: ModelEvent, changes: None):
-    await notify_new_order(order.id)
-
-@listens_for(Order, [ModelEvent.DELETE])
-async def on_order_deleted(order: Order, event_type: ModelEvent, changes: None):
-    await notify_order_cancelled(order.id)
-
-@listens_for(Order, [ModelEvent.UPDATE])
-async def on_order_updated(order: Order, event_type: ModelEvent, changes: dict):
-    if "status" in changes:
-        await notify_status_change(order.id, changes["status"])
-```
-
-Multiple handlers can be registered for the same model and event. Handlers registered on a parent class also fire for subclass instances.
-
-A single handler can listen for multiple events at once. When `event_types` is omitted, the handler fires for all events:
-
-```python
-@listens_for(Order, [ModelEvent.CREATE, ModelEvent.UPDATE])
-async def on_order_changed(order: Order, event_type: ModelEvent, changes: dict | None):
-    await invalidate_cache(order.id)
-
-@listens_for(Order)  # all events
-async def on_any_order_event(order: Order, event_type: ModelEvent, changes: dict | None):
-    await audit_log(order.id, event_type)
-```
-
-### Field changes format
-
-The `changes` dict maps each watched field that changed to `{"old": ..., "new": ...}`. Only fields that actually changed are included. For `CREATE` and `DELETE` events, `changes` is `None`:
-
-```python
-# CREATE / DELETE → changes is None
-# status changed   → {"status": {"old": "pending", "new": "shipped"}}
-# two fields changed → {"status": {...}, "assigned_to": {...}}
-```
-
-!!! info "Multiple flushes in one transaction are merged: the earliest `old` and latest `new` are preserved, and `on_update` fires only once per commit."
-
 ---

 [:material-api: API Reference](../reference/models.md)
--- a/docs/module/pytest.md
+++ b/docs/module/pytest.md
@@ -79,6 +79,9 @@ The examples above are already compatible with parallel test execution with `pyt

 ## Cleaning up tables

+!!! warning
+    Since `V2.1.0` `cleanup_tables` now live in `fastapi_toolsets.db`. For backward compatibility the function is still available in `fastapi_toolsets.pytest`, but this will be remove in `V3.0.0`.
+
 If you want to manually clean up a database you can use [`cleanup_tables`](../reference/db.md#fastapi_toolsets.db.cleanup_tables), this will truncate all tables between tests for fast isolation:

 ```python
--- a/docs/module/schemas.md
+++ b/docs/module/schemas.md
@@ -20,115 +20,50 @@ async def get_user(user: User = UserDep) -> Response[UserSchema]:
    return Response(data=user, message="User retrieved")
 ```

-### Paginated response models
+### [`PaginatedResponse[T]`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse)

-Three classes wrap paginated list results. Pick the one that matches your endpoint's strategy:
+Wraps a list of items with pagination metadata and optional facet values. The `pagination` field accepts either [`OffsetPagination`](../reference/schemas.md#fastapi_toolsets.schemas.OffsetPagination) or [`CursorPagination`](../reference/schemas.md#fastapi_toolsets.schemas.CursorPagination) depending on the strategy used.

-| Class | `pagination` type | `pagination_type` field | Use when |
-|---|---|---|---|
-| [`OffsetPaginatedResponse[T]`](#offsetpaginatedresponset) | `OffsetPagination` | `"offset"` (fixed) | endpoint always uses offset |
-| [`CursorPaginatedResponse[T]`](#cursorpaginatedresponset) | `CursorPagination` | `"cursor"` (fixed) | endpoint always uses cursor |
-| [`PaginatedResponse[T]`](#paginatedresponset) | `OffsetPagination \| CursorPagination` | — | unified endpoint supporting both strategies |
+#### [`OffsetPagination`](../reference/schemas.md#fastapi_toolsets.schemas.OffsetPagination)

-#### [`OffsetPaginatedResponse[T]`](../reference/schemas.md#fastapi_toolsets.schemas.OffsetPaginatedResponse)
-
-!!! info "Added in `v2.3.0`"
-
-Use as the return type when the endpoint always uses [`offset_paginate`](crud.md#offset-pagination).  The `pagination` field is guaranteed to be an [`OffsetPagination`](../reference/schemas.md#fastapi_toolsets.schemas.OffsetPagination) object; the response always includes a `pagination_type: "offset"` discriminator.
+Page-number based. Requires `total_count` so clients can compute the total number of pages.

 ```python
-from fastapi_toolsets.schemas import OffsetPaginatedResponse
+from fastapi_toolsets.schemas import PaginatedResponse, OffsetPagination

@router.get("/users")
-async def list_users(
-    page: int = 1,
-    items_per_page: int = 20,
-) -> OffsetPaginatedResponse[UserSchema]:
-    return await UserCrud.offset_paginate(
-        session, page=page, items_per_page=items_per_page, schema=UserSchema
+async def list_users() -> PaginatedResponse[UserSchema]:
+    return PaginatedResponse(
+        data=users,
+        pagination=OffsetPagination(
+            total_count=100,
+            items_per_page=10,
+            page=1,
+            has_more=True,
+        ),
    )
 ```

-**Response shape:**
+#### [`CursorPagination`](../reference/schemas.md#fastapi_toolsets.schemas.CursorPagination)

-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "offset",
-  "data": ["..."],
-  "pagination": {
-    "total_count": 100,
-    "page": 1,
-    "items_per_page": 20,
-    "has_more": true
-  }
-}
-```
-
-#### [`CursorPaginatedResponse[T]`](../reference/schemas.md#fastapi_toolsets.schemas.CursorPaginatedResponse)
-
-!!! info "Added in `v2.3.0`"
-
-Use as the return type when the endpoint always uses [`cursor_paginate`](crud.md#cursor-pagination).  The `pagination` field is guaranteed to be a [`CursorPagination`](../reference/schemas.md#fastapi_toolsets.schemas.CursorPagination) object; the response always includes a `pagination_type: "cursor"` discriminator.
+Cursor based. Efficient for large or frequently updated datasets where offset pagination is impractical. Provides opaque `next_cursor` / `prev_cursor` tokens; no total count is exposed.

 ```python
-from fastapi_toolsets.schemas import CursorPaginatedResponse
+from fastapi_toolsets.schemas import PaginatedResponse, CursorPagination

@router.get("/events")
-async def list_events(
-    cursor: str | None = None,
-    items_per_page: int = 20,
-) -> CursorPaginatedResponse[EventSchema]:
-    return await EventCrud.cursor_paginate(
-        session, cursor=cursor, items_per_page=items_per_page, schema=EventSchema
+async def list_events() -> PaginatedResponse[EventSchema]:
+    return PaginatedResponse(
+        data=events,
+        pagination=CursorPagination(
+            next_cursor="eyJpZCI6IDQyfQ==",
+            prev_cursor=None,
+            items_per_page=20,
+            has_more=True,
+        ),
    )
 ```

-**Response shape:**
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "cursor",
-  "data": ["..."],
-  "pagination": {
-    "next_cursor": "eyJpZCI6IDQyfQ==",
-    "prev_cursor": null,
-    "items_per_page": 20,
-    "has_more": true
-  }
-}
-```
-
-#### [`PaginatedResponse[T]`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse)
-
-Return type for endpoints that support **both** pagination strategies via a `pagination_type` query parameter (using [`paginate()`](crud.md#unified-paginate--both-strategies-on-one-endpoint)).
-
-When used as a return annotation, `PaginatedResponse[T]` automatically expands to `Annotated[Union[CursorPaginatedResponse[T], OffsetPaginatedResponse[T]], Field(discriminator="pagination_type")]`, so FastAPI emits a proper `oneOf` + discriminator in the OpenAPI schema with no extra boilerplate:
-
-```python
-from fastapi_toolsets.crud import PaginationType
-from fastapi_toolsets.schemas import PaginatedResponse
-
-@router.get("/users")
-async def list_users(
-    pagination_type: PaginationType = PaginationType.OFFSET,
-    page: int = 1,
-    cursor: str | None = None,
-    items_per_page: int = 20,
-) -> PaginatedResponse[UserSchema]:
-    return await UserCrud.paginate(
-        session,
-        pagination_type=pagination_type,
-        page=page,
-        cursor=cursor,
-        items_per_page=items_per_page,
-        schema=UserSchema,
-    )
-```
-
-#### Pagination metadata models
-
 The optional `filter_attributes` field is populated when `facet_fields` are configured on the CRUD class (see [Filter attributes](crud.md#filter-attributes-facets)). It is `None` by default and can be hidden from API responses with `response_model_exclude_none=True`.

 ### [`ErrorResponse`](../reference/schemas.md#fastapi_toolsets.schemas.ErrorResponse)
--- a/docs/overrides/partials/header.html
+++ b/docs/overrides/partials/header.html
@@ -0,0 +1,69 @@
+{#-
+  Override of partials/header.html — adds version selector slot missing in Zensical.
+-#}
+{% set class = "md-header" %}
+{% if "navigation.tabs.sticky" in features %}
+  {% set class = class ~ " md-header--shadow md-header--lifted" %}
+{% elif "navigation.tabs" not in features %}
+  {% set class = class ~ " md-header--shadow" %}
+{% endif %}
+<header class="{{ class }}" data-md-component="header">
+  <nav class="md-header__inner md-grid" aria-label="{{ lang.t('header') }}">
+    <a href="{{ config.extra.homepage | d(nav.homepage.url, true) | url }}" title="{{ config.site_name | e }}" class="md-header__button md-logo" aria-label="{{ config.site_name }}" data-md-component="logo">
+      {% include "partials/logo.html" %}
+    </a>
+    <label class="md-header__button md-icon" for="__drawer">
+      {% set icon = config.theme.icon.menu or "material/menu" %}
+      {% include ".icons/" ~ icon ~ ".svg" %}
+    </label>
+    <div class="md-header__title" data-md-component="header-title">
+      <div class="md-header__ellipsis">
+        <div class="md-header__topic">
+          <span class="md-ellipsis">
+            {{ config.site_name }}
+          </span>
+        </div>
+        <div class="md-header__topic" data-md-component="header-topic">
+          <span class="md-ellipsis">
+            {% if page.meta and page.meta.title %}
+              {{ page.meta.title }}
+            {% else %}
+              {{ page.title }}
+            {% endif %}
+          </span>
+        </div>
+      </div>
+    </div>
+    {% if config.theme.palette %}
+      {% if not config.theme.palette is mapping %}
+        {% include "partials/palette.html" %}
+      {% endif %}
+    {% endif %}
+    {% if not config.theme.palette is mapping %}
+      {% include "partials/javascripts/palette.html" %}
+    {% endif %}
+    {% if config.extra.alternate %}
+      {% include "partials/alternate.html" %}
+    {% endif %}
+    {% if "search" in config.plugins %}
+      {% set search = config.plugins["search"] | attr("config") %}
+      {% if search.enabled %}
+        <label class="md-header__button md-icon" for="__search">
+          {% set icon = config.theme.icon.search or "material/magnify" %}
+          {% include ".icons/" ~ icon ~ ".svg" %}
+        </label>
+        {% include "partials/search.html" %}
+      {% endif %}
+    {% endif %}
+    <div class="md-header__source">
+      {% if config.repo_url %}
+        {% include "partials/source.html" %}
+      {% endif %}
+    </div>
+  </nav>
+  {% if "navigation.tabs.sticky" in features %}
+    {% if "navigation.tabs" in features %}
+      {% include "partials/tabs.html" %}
+    {% endif %}
+  {% endif %}
+</header>
--- a/docs/reference/models.md
+++ b/docs/reference/models.md
@@ -6,29 +6,17 @@ You can import them directly from `fastapi_toolsets.models`:

 ```python
 from fastapi_toolsets.models import (
-    EventSession,
-    ModelEvent,
    UUIDMixin,
-    UUIDv7Mixin,
    CreatedAtMixin,
    UpdatedAtMixin,
    TimestampMixin,
-    listens_for,
 )
 ```

-## ::: fastapi_toolsets.models.EventSession
-
-## ::: fastapi_toolsets.models.ModelEvent
-
 ## ::: fastapi_toolsets.models.UUIDMixin

-## ::: fastapi_toolsets.models.UUIDv7Mixin
-
 ## ::: fastapi_toolsets.models.CreatedAtMixin

 ## ::: fastapi_toolsets.models.UpdatedAtMixin

 ## ::: fastapi_toolsets.models.TimestampMixin
-
-## ::: fastapi_toolsets.models.listens_for
--- a/docs/reference/schemas.md
+++ b/docs/reference/schemas.md
@@ -14,10 +14,7 @@ from fastapi_toolsets.schemas import (
    ErrorResponse,
    OffsetPagination,
    CursorPagination,
-    PaginationType,
    PaginatedResponse,
-    OffsetPaginatedResponse,
-    CursorPaginatedResponse,
 )
 ```

@@ -37,10 +34,4 @@ from fastapi_toolsets.schemas import (

 ## ::: fastapi_toolsets.schemas.CursorPagination

-## ::: fastapi_toolsets.schemas.PaginationType
-
 ## ::: fastapi_toolsets.schemas.PaginatedResponse
-
-## ::: fastapi_toolsets.schemas.OffsetPaginatedResponse
-
-## ::: fastapi_toolsets.schemas.CursorPaginatedResponse
--- a/docs/stylesheets/version.css
+++ b/docs/stylesheets/version.css
@@ -0,0 +1,100 @@
+/* Version selector styles for Zensical modern theme (backported from classic theme).
+   The JS appends .md-version into .md-header__topic, so we make that flex. */
+.md-header__topic:has(.md-version) {
+  display: flex;
+  align-items: center;
+}
+
+
+:root {
+  --md-version-icon: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 512"><path fill="currentColor" d="M140.3 376.8c12.6 10.2 31.1 9.5 42.8-2.2l128-128c9.2-9.2 11.9-22.9 6.9-34.9S301.4 192 288.5 192h-256c-12.9 0-24.6 7.8-29.6 19.8s-2.2 25.7 7 34.8l128 128z"/></svg>');
+}
+
+.md-version {
+  flex-shrink: 0;
+  font-size: .8rem;
+  height: 2.4rem;
+}
+
+[dir=ltr] .md-version__current { margin-left: 1.4rem; margin-right: .4rem; }
+[dir=rtl] .md-version__current { margin-left: .4rem; margin-right: 1.4rem; }
+
+.md-version__current {
+  color: inherit;
+  cursor: pointer;
+  outline: none;
+  position: relative;
+  top: .05rem;
+}
+
+[dir=ltr] .md-version__current:after { margin-left: .4rem; }
+[dir=rtl] .md-version__current:after { margin-right: .4rem; }
+
+.md-version__current:after {
+  background-color: currentcolor;
+  content: "";
+  display: inline-block;
+  height: .6rem;
+  -webkit-mask-image: var(--md-version-icon);
+  mask-image: var(--md-version-icon);
+  -webkit-mask-position: center;
+  mask-position: center;
+  -webkit-mask-repeat: no-repeat;
+  mask-repeat: no-repeat;
+  -webkit-mask-size: contain;
+  mask-size: contain;
+  width: .4rem;
+}
+
+.md-version__alias {
+  margin-left: .3rem;
+  opacity: .7;
+}
+
+.md-version__list {
+  background-color: var(--md-default-bg-color);
+  border-radius: .1rem;
+  box-shadow: var(--md-shadow-z2);
+  color: var(--md-default-fg-color);
+  list-style-type: none;
+  margin: .2rem .8rem;
+  max-height: 0;
+  opacity: 0;
+  overflow: auto;
+  padding: 0;
+  position: absolute;
+  scroll-snap-type: y mandatory;
+  top: .15rem;
+  transition: max-height 0ms .5s, opacity .25s .25s;
+  z-index: 3;
+}
+
+.md-version:focus-within .md-version__list,
+.md-version:hover .md-version__list {
+  max-height: 10rem;
+  opacity: 1;
+  transition: max-height 0ms, opacity .25s;
+}
+
+.md-version:hover .md-version__list { animation: hoverfix .25s forwards; }
+.md-version:focus-within .md-version__list { animation: none; }
+
+.md-version__item { line-height: 1.8rem; }
+
+[dir=ltr] .md-version__link { padding-left: .6rem; padding-right: 1.2rem; }
+[dir=rtl] .md-version__link { padding-left: 1.2rem; padding-right: .6rem; }
+
+.md-version__link {
+  cursor: pointer;
+  display: block;
+  outline: none;
+  scroll-snap-align: start;
+  transition: color .25s, background-color .25s;
+  white-space: nowrap;
+  width: 100%;
+}
+
+.md-version__link:focus,
+.md-version__link:hover { color: var(--md-accent-fg-color); }
+
+.md-version__link:focus { background-color: var(--md-default-fg-color--lightest); }
--- a/docs_src/examples/pagination_search/models.py
+++ b/docs_src/examples/pagination_search/models.py
@@ -1,10 +1,9 @@
+import datetime
 import uuid

-from sqlalchemy import Boolean, ForeignKey, String, Text
+from sqlalchemy import Boolean, DateTime, ForeignKey, String, Text, func
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship

-from fastapi_toolsets.models import CreatedAtMixin
-

 class Base(DeclarativeBase):
    pass
@@ -19,10 +18,13 @@ class Category(Base):
    articles: Mapped[list["Article"]] = relationship(back_populates="category")


-class Article(Base, CreatedAtMixin):
+class Article(Base):
    __tablename__ = "articles"

    id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
+    created_at: Mapped[datetime.datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
    title: Mapped[str] = mapped_column(String(256))
    body: Mapped[str] = mapped_column(Text)
    status: Mapped[str] = mapped_column(String(32))
--- a/docs_src/examples/pagination_search/routes.py
+++ b/docs_src/examples/pagination_search/routes.py
@@ -1,12 +1,9 @@
 from typing import Annotated

-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, Query

-from fastapi_toolsets.schemas import (
-    CursorPaginatedResponse,
-    OffsetPaginatedResponse,
-    PaginatedResponse,
-)
+from fastapi_toolsets.crud import OrderByClause
+from fastapi_toolsets.schemas import PaginatedResponse

 from .crud import ArticleCrud
 from .db import SessionDep
@@ -19,20 +16,22 @@ router = APIRouter(prefix="/articles")
@router.get("/offset")
 async def list_articles_offset(
    session: SessionDep,
-    params: Annotated[
-        dict,
-        Depends(
-            ArticleCrud.offset_paginate_params(
-                default_page_size=20,
-                max_page_size=100,
-                default_order_field=Article.created_at,
-            )
-        ),
+    filter_by: Annotated[dict[str, list[str]], Depends(ArticleCrud.filter_params())],
+    order_by: Annotated[
+        OrderByClause | None,
+        Depends(ArticleCrud.order_params(default_field=Article.created_at)),
    ],
-) -> OffsetPaginatedResponse[ArticleRead]:
+    page: int = Query(1, ge=1),
+    items_per_page: int = Query(20, ge=1, le=100),
+    search: str | None = None,
+) -> PaginatedResponse[ArticleRead]:
    return await ArticleCrud.offset_paginate(
        session=session,
-        **params,
+        page=page,
+        items_per_page=items_per_page,
+        search=search,
+        filter_by=filter_by or None,
+        order_by=order_by,
        schema=ArticleRead,
    )

@@ -40,40 +39,21 @@ async def list_articles_offset(
@router.get("/cursor")
 async def list_articles_cursor(
    session: SessionDep,
-    params: Annotated[
-        dict,
-        Depends(
-            ArticleCrud.cursor_paginate_params(
-                default_page_size=20,
-                max_page_size=100,
-                default_order_field=Article.created_at,
-            )
-        ),
+    filter_by: Annotated[dict[str, list[str]], Depends(ArticleCrud.filter_params())],
+    order_by: Annotated[
+        OrderByClause | None,
+        Depends(ArticleCrud.order_params(default_field=Article.created_at)),
    ],
-) -> CursorPaginatedResponse[ArticleRead]:
+    cursor: str | None = None,
+    items_per_page: int = Query(20, ge=1, le=100),
+    search: str | None = None,
+) -> PaginatedResponse[ArticleRead]:
    return await ArticleCrud.cursor_paginate(
        session=session,
-        **params,
-        schema=ArticleRead,
-    )
-
-
-@router.get("/")
-async def list_articles(
-    session: SessionDep,
-    params: Annotated[
-        dict,
-        Depends(
-            ArticleCrud.paginate_params(
-                default_page_size=20,
-                max_page_size=100,
-                default_order_field=Article.created_at,
-            )
-        ),
-    ],
-) -> PaginatedResponse[ArticleRead]:
-    return await ArticleCrud.paginate(
-        session,
-        **params,
+        cursor=cursor,
+        items_per_page=items_per_page,
+        search=search,
+        filter_by=filter_by or None,
+        order_by=order_by,
        schema=ArticleRead,
    )
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -0,0 +1,5 @@
+# Minimal stub for mike compatibility.
+# The actual build is handled by zensical (see scripts/mkdocs shim).
+site_name: FastAPI Toolsets
+docs_dir: docs
+site_dir: site
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-toolsets"
-version = "3.0.3"
+version = "2.2.0"
 description = "Production-ready utilities for FastAPI applications"
 readme = "README.md"
 license = "MIT"
@@ -67,7 +67,6 @@ dev = [
    {include-group = "tests"},
    {include-group = "docs"},
    "fastapi-toolsets[all]",
-    "prek>=0.3.8",
    "ruff>=0.1.0",
    "ty>=0.0.1a0",
 ]
@@ -80,13 +79,12 @@ tests = [
    "pytest>=8.0.0",
 ]
 docs = [
-    "mike",
    "mkdocstrings-python>=2.0.2",
-    "zensical>=0.0.30",
+    "zensical>=0.0.23",
 ]

 [build-system]
-requires = ["uv_build>=0.10,<0.12.0"]
+requires = ["uv_build>=0.10,<0.11.0"]
 build-backend = "uv_build"

 [tool.pytest.ini_options]
@@ -105,6 +103,3 @@ exclude_lines = [
    "if TYPE_CHECKING:",
    "raise NotImplementedError",
 ]
-
-[tool.uv.sources]
-mike = { git = "https://github.com/squidfunk/mike.git", tag = "2.2.0+zensical-0.1.0" }
--- a/scripts/mkdocs
+++ b/scripts/mkdocs
@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""mkdocs shim for mike compatibility.
+
+mike parses mkdocs.yml (valid YAML stub) for its Python internals, then calls
+`mkdocs build --config-file <mike-injected-temp.yml>` as a subprocess.
+
+This shim intercepts that subprocess call, ignores the temp config, and
+delegates the actual build to `zensical build -f zensical.toml` instead.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+
+def main() -> None:
+    args = sys.argv[1:]
+
+    # mike calls `mkdocs --version` to embed in the commit message
+    if args and args[0] == "--version":
+        print("mkdocs, version 1.0.0 (zensical shim)")
+        return
+
+    if not args or args[0] != "build":
+        result = subprocess.run(["python3", "-m", "mkdocs"] + args)
+        sys.exit(result.returncode)
+
+    config_file = "mkdocs.yml"
+    clean = False
+
+    i = 1
+    while i < len(args):
+        if args[i] in ("-f", "--config-file") and i + 1 < len(args):
+            config_file = args[i + 1]
+            i += 2
+        elif args[i] in ("-c", "--clean"):
+            clean = True
+            i += 1
+        elif args[i] == "--dirty":
+            i += 1
+        else:
+            i += 1
+
+    # mike creates a temp file prefixed with "mike-mkdocs"; always delegate
+    # the actual build to zensical regardless of which config was passed.
+    del config_file  # unused — zensical auto-discovers zensical.toml
+
+    cmd = ["zensical", "build"]
+    if clean:
+        cmd.append("--clean")
+
+    env = os.environ.copy()
+    result = subprocess.run(cmd, env=env)
+    sys.exit(result.returncode)
+
+
+if __name__ == "__main__":
+    main()
--- a/src/fastapi_toolsets/init.py
+++ b/src/fastapi_toolsets/init.py
@@ -21,4 +21,4 @@ Example usage:
        return Response(data={"user": user.username}, message="Success")
 """

-__version__ = "3.0.3"
+__version__ = "2.2.0"
--- a/src/fastapi_toolsets/crud/init.py
+++ b/src/fastapi_toolsets/crud/init.py
@@ -1,37 +1,25 @@
 """Generic async CRUD operations for SQLAlchemy models."""

-from ..exceptions import (
-    InvalidFacetFilterError,
-    InvalidSearchColumnError,
-    NoSearchableFieldsError,
-    UnsupportedFacetTypeError,
-)
-from ..schemas import PaginationType
+from ..exceptions import InvalidFacetFilterError, NoSearchableFieldsError
 from ..types import (
    FacetFieldType,
    JoinType,
    M2MFieldType,
    OrderByClause,
-    OrderFieldType,
    SearchFieldType,
 )
-from .factory import AsyncCrud, CrudFactory
+from .factory import CrudFactory
 from .search import SearchConfig, get_searchable_fields

 __all__ = [
-    "AsyncCrud",
    "CrudFactory",
    "FacetFieldType",
    "get_searchable_fields",
    "InvalidFacetFilterError",
-    "InvalidSearchColumnError",
    "JoinType",
    "M2MFieldType",
    "NoSearchableFieldsError",
    "OrderByClause",
-    "OrderFieldType",
-    "PaginationType",
    "SearchConfig",
    "SearchFieldType",
-    "UnsupportedFacetTypeError",
 ]
--- a/src/fastapi_toolsets/crud/factory.py
+++ b/src/fastapi_toolsets/crud/factory.py
--- a/src/fastapi_toolsets/crud/search.py
+++ b/src/fastapi_toolsets/crud/search.py
@@ -2,32 +2,17 @@

 import asyncio
 import functools
+from collections import Counter
 from collections.abc import Sequence
 from dataclasses import dataclass, replace
 from typing import TYPE_CHECKING, Any, Literal

-from sqlalchemy import String, and_, func, or_, select
+from sqlalchemy import String, and_, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.orm.attributes import InstrumentedAttribute
-from sqlalchemy.types import (
-    ARRAY,
-    Boolean,
-    Date,
-    DateTime,
-    Enum,
-    Integer,
-    Numeric,
-    Time,
-    Uuid,
-)

-from ..exceptions import (
-    InvalidFacetFilterError,
-    InvalidSearchColumnError,
-    NoSearchableFieldsError,
-    UnsupportedFacetTypeError,
-)
+from ..exceptions import InvalidFacetFilterError, NoSearchableFieldsError
 from ..types import FacetFieldType, SearchFieldType

 if TYPE_CHECKING:
@@ -97,7 +82,6 @@ def build_search_filters(
    search: str | SearchConfig,
    search_fields: Sequence[SearchFieldType] | None = None,
    default_fields: Sequence[SearchFieldType] | None = None,
-    search_column: str | None = None,
 ) -> tuple[list["ColumnElement[bool]"], list[InstrumentedAttribute[Any]]]:
    """Build SQLAlchemy filter conditions for search.

@@ -106,8 +90,6 @@ def build_search_filters(
        search: Search string or SearchConfig
        search_fields: Fields specified per-call (takes priority)
        default_fields: Default fields (from ClassVar)
-        search_column: Optional key to narrow search to a single field.
-            Must match one of the resolved search field keys.

    Returns:
        Tuple of (filter_conditions, joins_needed)
@@ -134,14 +116,6 @@ def build_search_filters(
    if not fields:
        raise NoSearchableFieldsError(model)

-    # Narrow to a single column when search_column is specified
-    if search_column is not None:
-        keys = search_field_keys(fields)
-        index = {k: f for k, f in zip(keys, fields)}
-        if search_column not in index:
-            raise InvalidSearchColumnError(search_column, sorted(index))
-        fields = [index[search_column]]
-
    query = config.query.strip()
    filters: list[ColumnElement[bool]] = []
    joins: list[InstrumentedAttribute[Any]] = []
@@ -176,13 +150,8 @@ def build_search_filters(
        return filters, joins


-def search_field_keys(fields: Sequence[SearchFieldType]) -> list[str]:
-    """Return a human-readable key for each search field."""
-    return facet_keys(fields)
-
-
 def facet_keys(facet_fields: Sequence[FacetFieldType]) -> list[str]:
-    """Return a key for each facet field.
+    """Return a key for each facet field, disambiguating duplicate column keys.

    Args:
        facet_fields: Sequence of facet fields — either direct columns or
@@ -191,12 +160,22 @@ def facet_keys(facet_fields: Sequence[FacetFieldType]) -> list[str]:
    Returns:
        A list of string keys, one per facet field, in the same order.
    """
-    keys: list[str] = []
+    raw: list[tuple[str, str | None]] = []
    for field in facet_fields:
        if isinstance(field, tuple):
-            keys.append("__".join(el.key for el in field))
+            rel = field[-2]
+            column = field[-1]
+            raw.append((column.key, rel.key))
        else:
-            keys.append(field.key)
+            raw.append((field.key, None))
+
+    counts = Counter(col_key for col_key, _ in raw)
+    keys: list[str] = []
+    for col_key, rel_key in raw:
+        if counts[col_key] > 1 and rel_key is not None:
+            keys.append(f"{rel_key}__{col_key}")
+        else:
+            keys.append(col_key)
    return keys


@@ -233,47 +212,23 @@ async def build_facets(
            rels = ()
            column = field

-        col_type = column.property.columns[0].type
-        is_array = isinstance(col_type, ARRAY)
+        q = select(column).select_from(model).distinct()

-        if is_array:
-            unnested = func.unnest(column).label(column.key)
-            q = select(unnested).select_from(model).distinct()
-        else:
-            q = select(column).select_from(model).distinct()
-
-        # Apply base joins (deduplicated) — needed here independently
-        seen_joins: set[str] = set()
+        # Apply base joins (already done on main query, but needed here independently)
        for rel in base_joins or []:
-            rel_key = str(rel)
-            if rel_key not in seen_joins:
-                seen_joins.add(rel_key)
-                q = q.outerjoin(rel)
+            q = q.outerjoin(rel)

-        # Add any extra joins required by this facet field that aren't already applied
+        # Add any extra joins required by this facet field that aren't already in base_joins
        for rel in rels:
-            rel_key = str(rel)
-            if rel_key not in existing_join_keys and rel_key not in seen_joins:
-                seen_joins.add(rel_key)
+            if str(rel) not in existing_join_keys:
                q = q.outerjoin(rel)

        if base_filters:
            q = q.where(and_(*base_filters))

-        if is_array:
-            q = q.order_by(unnested)
-        else:
-            q = q.order_by(column)
+        q = q.order_by(column)
        result = await session.execute(q)
-        col_type = column.property.columns[0].type
-        enum_class = getattr(col_type, "enum_class", None)
-        values = [
-            row[0].name
-            if (enum_class is not None and isinstance(row[0], enum_class))
-            else row[0]
-            for row in result.all()
-            if row[0] is not None
-        ]
+        values = [row[0] for row in result.all() if row[0] is not None]
        return key, values

    pairs = await asyncio.gather(
@@ -282,22 +237,6 @@ async def build_facets(
    return dict(pairs)


-_EQUALITY_TYPES = (String, Integer, Numeric, Date, DateTime, Time, Enum, Uuid)
-"""Column types that support equality / IN filtering in build_filter_by."""
-
-
-def _coerce_bool(value: Any) -> bool:
-    """Coerce a string value to a Python bool for Boolean column filtering."""
-    if isinstance(value, bool):
-        return value
-    if isinstance(value, str):
-        if value.lower() == "true":
-            return True
-        if value.lower() == "false":
-            return False
-    raise ValueError(f"Cannot coerce {value!r} to bool")
-
-
 def build_filter_by(
    filter_by: dict[str, Any],
    facet_fields: Sequence[FacetFieldType],
@@ -343,42 +282,9 @@ def build_filter_by(
                joins.append(rel)
                added_join_keys.add(rel_key)

-        col_type = column.property.columns[0].type
-        if isinstance(col_type, Boolean):
-            coerce = _coerce_bool
-            if isinstance(value, list):
-                filters.append(column.in_([coerce(v) for v in value]))
-            else:
-                filters.append(column == coerce(value))
-        elif isinstance(col_type, ARRAY):
-            if isinstance(value, list):
-                filters.append(column.overlap(value))
-            else:
-                filters.append(column.any(value))
-        elif isinstance(col_type, Enum):
-            enum_class = col_type.enum_class
-            if enum_class is not None:
-
-                def _coerce_enum(v: Any) -> Any:
-                    if isinstance(v, enum_class):
-                        return v
-                    return enum_class[v]  # lookup by name: "PENDING", "RED"
-
-                if isinstance(value, list):
-                    filters.append(column.in_([_coerce_enum(v) for v in value]))
-                else:
-                    filters.append(column == _coerce_enum(value))
-            else:  # pragma: no cover
-                if isinstance(value, list):
-                    filters.append(column.in_(value))
-                else:
-                    filters.append(column == value)
-        elif isinstance(col_type, _EQUALITY_TYPES):
-            if isinstance(value, list):
-                filters.append(column.in_(value))
-            else:
-                filters.append(column == value)
+        if isinstance(value, list):
+            filters.append(column.in_(value))
        else:
-            raise UnsupportedFacetTypeError(key, type(col_type).__name__)
+            filters.append(column == value)

    return filters, joins
--- a/src/fastapi_toolsets/db.py
+++ b/src/fastapi_toolsets/db.py
@@ -24,12 +24,9 @@ __all__ = [
 ]


-_SessionT = TypeVar("_SessionT", bound=AsyncSession)
-
-
 def create_db_dependency(
-    session_maker: async_sessionmaker[_SessionT],
-) -> Callable[[], AsyncGenerator[_SessionT, None]]:
+    session_maker: async_sessionmaker[AsyncSession],
+) -> Callable[[], AsyncGenerator[AsyncSession, None]]:
    """Create a FastAPI dependency for database sessions.

    Creates a dependency function that yields a session and auto-commits
@@ -57,9 +54,8 @@ def create_db_dependency(
        ```
    """

-    async def get_db() -> AsyncGenerator[_SessionT, None]:
+    async def get_db() -> AsyncGenerator[AsyncSession, None]:
        async with session_maker() as session:
-            await session.connection()
            yield session
            if session.in_transaction():
                await session.commit()
@@ -68,8 +64,8 @@ def create_db_dependency(


 def create_db_context(
-    session_maker: async_sessionmaker[_SessionT],
-) -> Callable[[], AbstractAsyncContextManager[_SessionT]]:
+    session_maker: async_sessionmaker[AsyncSession],
+) -> Callable[[], AbstractAsyncContextManager[AsyncSession]]:
    """Create a context manager for database sessions.

    Creates a context manager for use outside of FastAPI request handlers,
--- a/src/fastapi_toolsets/dependencies.py
+++ b/src/fastapi_toolsets/dependencies.py
@@ -1,12 +1,10 @@
 """Dependency factories for FastAPI routes."""

 import inspect
-import typing
 from collections.abc import Callable
 from typing import Any, cast

 from fastapi import Depends
-from fastapi.params import Depends as DependsClass
 from sqlalchemy.ext.asyncio import AsyncSession

 from .crud import CrudFactory
@@ -15,15 +13,6 @@ from .types import ModelType, SessionDependency
 __all__ = ["BodyDependency", "PathDependency"]


-def _unwrap_session_dep(session_dep: SessionDependency) -> Callable[..., Any]:
-    """Extract the plain callable from ``Annotated[AsyncSession, Depends(fn)]`` if needed."""
-    if typing.get_origin(session_dep) is typing.Annotated:
-        for arg in typing.get_args(session_dep)[1:]:
-            if isinstance(arg, DependsClass):
-                return arg.dependency
-    return session_dep
-
-
 def PathDependency(
    model: type[ModelType],
    field: Any,
@@ -55,7 +44,6 @@ def PathDependency(
        ): ...
        ```
    """
-    session_callable = _unwrap_session_dep(session_dep)
    crud = CrudFactory(model)
    name = (
        param_name
@@ -65,7 +53,7 @@ def PathDependency(
    python_type = field.type.python_type

    async def dependency(
-        session: AsyncSession = Depends(session_callable), **kwargs: Any
+        session: AsyncSession = Depends(session_dep), **kwargs: Any
    ) -> ModelType:
        value = kwargs[name]
        return await crud.get(session, filters=[field == value])
@@ -82,7 +70,7 @@ def PathDependency(
                    "session",
                    inspect.Parameter.KEYWORD_ONLY,
                    annotation=AsyncSession,
-                    default=Depends(session_callable),
+                    default=Depends(session_dep),
                ),
            ]
        ),
@@ -124,12 +112,11 @@ def BodyDependency(
        ): ...
        ```
    """
-    session_callable = _unwrap_session_dep(session_dep)
    crud = CrudFactory(model)
    python_type = field.type.python_type

    async def dependency(
-        session: AsyncSession = Depends(session_callable), **kwargs: Any
+        session: AsyncSession = Depends(session_dep), **kwargs: Any
    ) -> ModelType:
        value = kwargs[body_field]
        return await crud.get(session, filters=[field == value])
@@ -146,7 +133,7 @@ def BodyDependency(
                    "session",
                    inspect.Parameter.KEYWORD_ONLY,
                    annotation=AsyncSession,
-                    default=Depends(session_callable),
+                    default=Depends(session_dep),
                ),
            ]
        ),
--- a/src/fastapi_toolsets/exceptions/init.py
+++ b/src/fastapi_toolsets/exceptions/init.py
@@ -7,11 +7,9 @@ from .exceptions import (
    ForbiddenError,
    InvalidFacetFilterError,
    InvalidOrderFieldError,
-    InvalidSearchColumnError,
    NoSearchableFieldsError,
    NotFoundError,
    UnauthorizedError,
-    UnsupportedFacetTypeError,
    generate_error_responses,
 )
 from .handler import init_exceptions_handlers
@@ -25,9 +23,7 @@ __all__ = [
    "init_exceptions_handlers",
    "InvalidFacetFilterError",
    "InvalidOrderFieldError",
-    "InvalidSearchColumnError",
    "NoSearchableFieldsError",
    "NotFoundError",
    "UnauthorizedError",
-    "UnsupportedFacetTypeError",
 ]
--- a/src/fastapi_toolsets/exceptions/exceptions.py
+++ b/src/fastapi_toolsets/exceptions/exceptions.py
@@ -144,61 +144,6 @@ class InvalidFacetFilterError(ApiException):
        )


-class UnsupportedFacetTypeError(ApiException):
-    """Raised when a facet field has a column type not supported by filter_by."""
-
-    api_error = ApiError(
-        code=400,
-        msg="Unsupported Facet Type",
-        desc="The column type is not supported for facet filtering.",
-        err_code="FACET-TYPE-400",
-    )
-
-    def __init__(self, key: str, col_type: str) -> None:
-        """Initialize the exception.
-
-        Args:
-            key: The facet field key.
-            col_type: The unsupported column type name.
-        """
-        self.key = key
-        self.col_type = col_type
-        super().__init__(
-            desc=(
-                f"Facet field '{key}' has unsupported column type '{col_type}'. "
-                f"Supported types: String, Integer, Numeric, Boolean, "
-                f"Date, DateTime, Time, Enum, Uuid, ARRAY."
-            )
-        )
-
-
-class InvalidSearchColumnError(ApiException):
-    """Raised when search_column is not one of the configured searchable fields."""
-
-    api_error = ApiError(
-        code=400,
-        msg="Invalid Search Column",
-        desc="The requested search column is not a configured searchable field.",
-        err_code="SEARCH-COL-400",
-    )
-
-    def __init__(self, column: str, valid_columns: list[str]) -> None:
-        """Initialize the exception.
-
-        Args:
-            column: The unknown search column provided by the caller.
-            valid_columns: List of valid search column keys.
-        """
-        self.column = column
-        self.valid_columns = valid_columns
-        super().__init__(
-            desc=(
-                f"'{column}' is not a searchable column. "
-                f"Valid columns: {valid_columns}."
-            )
-        )
-
-
 class InvalidOrderFieldError(ApiException):
    """Raised when order_by contains a field not in the allowed order fields."""

--- a/src/fastapi_toolsets/exceptions/handler.py
+++ b/src/fastapi_toolsets/exceptions/handler.py
@@ -30,7 +30,7 @@ def init_exceptions_handlers(app: FastAPI) -> FastAPI:
    """
    _register_exception_handlers(app)
    _original_openapi = app.openapi
-    app.openapi = lambda: _patched_openapi(app, _original_openapi)  # type: ignore[method-assign]  # ty:ignore[invalid-assignment]
+    app.openapi = lambda: _patched_openapi(app, _original_openapi)  # type: ignore[method-assign]
    return app


@@ -122,7 +122,7 @@ def _format_validation_error(
    )

    return JSONResponse(
-        status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
        content=error_response.model_dump(),
    )

--- a/src/fastapi_toolsets/fixtures/registry.py
+++ b/src/fastapi_toolsets/fixtures/registry.py
@@ -2,7 +2,6 @@

 from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
-from enum import Enum
 from typing import Any, cast

 from sqlalchemy.orm import DeclarativeBase
@@ -13,13 +12,6 @@ from .enum import Context
 logger = get_logger()


-def _normalize_contexts(
-    contexts: list[str | Enum] | tuple[str | Enum, ...],
-) -> list[str]:
-    """Convert a sequence of any Enum subclass and/or plain strings to a list of strings."""
-    return [c.value if isinstance(c, Enum) else c for c in contexts]
-
-
@dataclass
 class Fixture:
    """A fixture definition with metadata."""
@@ -58,51 +50,26 @@ class FixtureRegistry:
                Post(id=1, title="Test", user_id=1),
            ]
        ```
-
-    Fixtures with the same name may be registered for **different** contexts.
-    When multiple contexts are loaded together, their instances are merged:
-
-        ```python
-        @fixtures.register(contexts=[Context.BASE])
-        def users():
-            return [User(id=1, username="admin")]
-
-        @fixtures.register(contexts=[Context.TESTING])
-        def users():
-            return [User(id=2, username="tester")]
-        # load_fixtures_by_context(..., Context.BASE, Context.TESTING)
-        # → loads both User(admin) and User(tester) under the "users" name
-        ```
    """

    def __init__(
        self,
-        contexts: list[str | Enum] | None = None,
+        contexts: list[str | Context] | None = None,
    ) -> None:
-        self._fixtures: dict[str, list[Fixture]] = {}
+        self._fixtures: dict[str, Fixture] = {}
        self._default_contexts: list[str] | None = (
-            _normalize_contexts(contexts) if contexts else None
+            [c.value if isinstance(c, Context) else c for c in contexts]
+            if contexts
+            else None
        )

-    def _validate_no_context_overlap(self, name: str, new_contexts: list[str]) -> None:
-        """Raise ``ValueError`` if any existing variant for *name* overlaps."""
-        existing_variants = self._fixtures.get(name, [])
-        new_set = set(new_contexts)
-        for variant in existing_variants:
-            if set(variant.contexts) & new_set:
-                raise ValueError(
-                    f"Fixture '{name}' already exists in the current registry "
-                    f"with overlapping contexts. Use distinct context sets for "
-                    f"each variant of the same fixture name."
-                )
-
    def register(
        self,
        func: Callable[[], Sequence[DeclarativeBase]] | None = None,
        *,
        name: str | None = None,
        depends_on: list[str] | None = None,
-        contexts: list[str | Enum] | None = None,
+        contexts: list[str | Context] | None = None,
    ) -> Callable[..., Any]:
        """Register a fixture function.

@@ -112,8 +79,7 @@ class FixtureRegistry:
            func: Fixture function returning list of model instances
            name: Fixture name (defaults to function name)
            depends_on: List of fixture names this depends on
-            contexts: List of contexts this fixture belongs to.  Both
-                :class:`Context` enum values and plain strings are accepted.
+            contexts: List of contexts this fixture belongs to

        Example:
            ```python
@@ -124,6 +90,7 @@ class FixtureRegistry:
            @fixtures.register(depends_on=["roles"], contexts=[Context.TESTING])
            def test_users():
                return [User(id=1, username="test", role_id=1)]
+            ```
        """

        def decorator(
@@ -131,20 +98,19 @@ class FixtureRegistry:
        ) -> Callable[[], Sequence[DeclarativeBase]]:
            fixture_name = name or cast(Any, fn).__name__
            if contexts is not None:
-                fixture_contexts = _normalize_contexts(contexts)
+                fixture_contexts = [
+                    c.value if isinstance(c, Context) else c for c in contexts
+                ]
            elif self._default_contexts is not None:
                fixture_contexts = self._default_contexts
            else:
                fixture_contexts = [Context.BASE.value]

-            self._validate_no_context_overlap(fixture_name, fixture_contexts)
-            self._fixtures.setdefault(fixture_name, []).append(
-                Fixture(
-                    name=fixture_name,
-                    func=fn,
-                    depends_on=depends_on or [],
-                    contexts=fixture_contexts,
-                )
+            self._fixtures[fixture_name] = Fixture(
+                name=fixture_name,
+                func=fn,
+                depends_on=depends_on or [],
+                contexts=fixture_contexts,
            )
            return fn

@@ -155,14 +121,11 @@ class FixtureRegistry:
    def include_registry(self, registry: "FixtureRegistry") -> None:
        """Include another `FixtureRegistry` in the same current `FixtureRegistry`.

-        Fixtures with the same name are allowed as long as their context sets
-        do not overlap.  Conflicting contexts raise :class:`ValueError`.
-
        Args:
            registry: The `FixtureRegistry` to include

        Raises:
-            ValueError: If a fixture name already exists with overlapping contexts
+            ValueError: If a fixture name already exists in the current registry

        Example:
            ```python
@@ -176,73 +139,31 @@ class FixtureRegistry:
            registry.include_registry(registry=dev_registry)
            ```
        """
-        for name, variants in registry._fixtures.items():
-            for fixture in variants:
-                self._validate_no_context_overlap(name, fixture.contexts)
-                self._fixtures.setdefault(name, []).append(fixture)
+        for name, fixture in registry._fixtures.items():
+            if name in self._fixtures:
+                raise ValueError(
+                    f"Fixture '{name}' already exists in the current registry"
+                )
+            self._fixtures[name] = fixture

    def get(self, name: str) -> Fixture:
-        """Get a fixture by name.
-
-        Raises:
-            KeyError: If no fixture with *name* is registered.
-            ValueError: If the fixture has multiple context variants — use
-                :meth:`get_variants` in that case.
-        """
+        """Get a fixture by name."""
        if name not in self._fixtures:
            raise KeyError(f"Fixture '{name}' not found")
-        variants = self._fixtures[name]
-        if len(variants) > 1:
-            raise ValueError(
-                f"Fixture '{name}' has {len(variants)} context variants. "
-                f"Use get_variants('{name}') to retrieve them."
-            )
-        return variants[0]
-
-    def get_variants(self, name: str, *contexts: str | Enum) -> list[Fixture]:
-        """Return all registered variants for *name*, optionally filtered by context.
-
-        Args:
-            name: Fixture name.
-            *contexts: If given, only return variants whose context set
-                intersects with these values.  Both :class:`Context` enum
-                values and plain strings are accepted.
-
-        Returns:
-            List of matching :class:`Fixture` objects (may be empty when a
-            context filter is applied and nothing matches).
-
-        Raises:
-            KeyError: If no fixture with *name* is registered.
-        """
-        if name not in self._fixtures:
-            raise KeyError(f"Fixture '{name}' not found")
-        variants = self._fixtures[name]
-        if not contexts:
-            return list(variants)
-        context_values = set(_normalize_contexts(contexts))
-        return [v for v in variants if set(v.contexts) & context_values]
+        return self._fixtures[name]

    def get_all(self) -> list[Fixture]:
-        """Get all registered fixtures (all variants of all names)."""
-        return [f for variants in self._fixtures.values() for f in variants]
+        """Get all registered fixtures."""
+        return list(self._fixtures.values())

-    def get_by_context(self, *contexts: str | Enum) -> list[Fixture]:
+    def get_by_context(self, *contexts: str | Context) -> list[Fixture]:
        """Get fixtures for specific contexts."""
-        context_values = set(_normalize_contexts(contexts))
-        return [
-            f
-            for variants in self._fixtures.values()
-            for f in variants
-            if set(f.contexts) & context_values
-        ]
+        context_values = {c.value if isinstance(c, Context) else c for c in contexts}
+        return [f for f in self._fixtures.values() if set(f.contexts) & context_values]

    def resolve_dependencies(self, *names: str) -> list[str]:
        """Resolve fixture dependencies in topological order.

-        When a fixture name has multiple context variants, the union of all
-        variants' ``depends_on`` lists is used.
-
        Args:
            *names: Fixture names to resolve

@@ -264,20 +185,9 @@ class FixtureRegistry:
                raise ValueError(f"Circular dependency detected: {name}")

            visiting.add(name)
-            variants = self._fixtures.get(name)
-            if variants is None:
-                raise KeyError(f"Fixture '{name}' not found")
+            fixture = self.get(name)

-            # Union of depends_on across all variants, preserving first-seen order.
-            seen_deps: set[str] = set()
-            all_deps: list[str] = []
-            for variant in variants:
-                for dep in variant.depends_on:
-                    if dep not in seen_deps:
-                        all_deps.append(dep)
-                        seen_deps.add(dep)
-
-            for dep in all_deps:
+            for dep in fixture.depends_on:
                visit(dep)

            visiting.remove(name)
@@ -289,7 +199,7 @@ class FixtureRegistry:

        return resolved

-    def resolve_context_dependencies(self, *contexts: str | Enum) -> list[str]:
+    def resolve_context_dependencies(self, *contexts: str | Context) -> list[str]:
        """Resolve all fixtures for contexts with dependencies.

        Args:
@@ -299,9 +209,7 @@ class FixtureRegistry:
            List of fixture names in load order
        """
        context_fixtures = self.get_by_context(*contexts)
-        # Deduplicate names while preserving first-seen order (a name can
-        # appear multiple times if it has variants in different contexts).
-        names = list(dict.fromkeys(f.name for f in context_fixtures))
+        names = [f.name for f in context_fixtures]

        all_deps: set[str] = set()
        for name in names:
--- a/src/fastapi_toolsets/fixtures/utils.py
+++ b/src/fastapi_toolsets/fixtures/utils.py
@@ -1,11 +1,8 @@
 """Fixture loading utilities for database seeding."""

 from collections.abc import Callable, Sequence
-from enum import Enum
 from typing import Any

-from sqlalchemy import inspect as sa_inspect
-from sqlalchemy.dialects.postgresql import insert as pg_insert
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import DeclarativeBase

@@ -13,177 +10,23 @@ from ..db import get_transaction
 from ..logger import get_logger
 from ..types import ModelType
 from .enum import LoadStrategy
-from .registry import FixtureRegistry, _normalize_contexts
+from .registry import Context, FixtureRegistry

 logger = get_logger()


-def _instance_to_dict(instance: DeclarativeBase) -> dict[str, Any]:
-    """Extract column values from a model instance, skipping unset server-default columns."""
-    state = sa_inspect(instance)
-    state_dict = state.dict
-    result: dict[str, Any] = {}
-    for prop in state.mapper.column_attrs:
-        if prop.key not in state_dict:
-            continue
-        val = state_dict[prop.key]
-        if val is None:
-            col = prop.columns[0]
-
-            if (
-                col.server_default is not None
-                or (col.default is not None and col.default.is_callable)
-                or col.autoincrement is True
-            ):
-                continue
-        result[prop.key] = val
-    return result
-
-
-def _group_by_type(
-    instances: list[DeclarativeBase],
-) -> list[tuple[type[DeclarativeBase], list[DeclarativeBase]]]:
-    """Group instances by their concrete model class, preserving insertion order."""
-    groups: dict[type[DeclarativeBase], list[DeclarativeBase]] = {}
-    for instance in instances:
-        groups.setdefault(type(instance), []).append(instance)
-    return list(groups.items())
-
-
-def _group_by_column_set(
-    dicts: list[dict[str, Any]],
-    instances: list[DeclarativeBase],
-) -> list[tuple[list[dict[str, Any]], list[DeclarativeBase]]]:
-    """Group (dict, instance) pairs by their dict key sets."""
-    groups: dict[
-        frozenset[str], tuple[list[dict[str, Any]], list[DeclarativeBase]]
-    ] = {}
-    for d, inst in zip(dicts, instances):
-        key = frozenset(d)
-        if key not in groups:
-            groups[key] = ([], [])
-        groups[key][0].append(d)
-        groups[key][1].append(inst)
-    return list(groups.values())
-
-
-async def _batch_insert(
-    session: AsyncSession,
-    model_cls: type[DeclarativeBase],
-    instances: list[DeclarativeBase],
-) -> None:
-    """INSERT all instances — raises on conflict (no duplicate handling)."""
-    dicts = [_instance_to_dict(i) for i in instances]
-    for group_dicts, _ in _group_by_column_set(dicts, instances):
-        await session.execute(pg_insert(model_cls).values(group_dicts))
-
-
-async def _batch_merge(
-    session: AsyncSession,
-    model_cls: type[DeclarativeBase],
-    instances: list[DeclarativeBase],
-) -> None:
-    """UPSERT: insert new rows, update existing ones with the provided values."""
-    mapper = model_cls.__mapper__
-    pk_names = [col.name for col in mapper.primary_key]
-    pk_names_set = set(pk_names)
-    non_pk_cols = [
-        prop.key
-        for prop in mapper.column_attrs
-        if not any(col.name in pk_names_set for col in prop.columns)
-    ]
-
-    dicts = [_instance_to_dict(i) for i in instances]
-    for group_dicts, _ in _group_by_column_set(dicts, instances):
-        stmt = pg_insert(model_cls).values(group_dicts)
-
-        inserted_keys = set(group_dicts[0])
-        update_cols = [col for col in non_pk_cols if col in inserted_keys]
-
-        if update_cols:
-            stmt = stmt.on_conflict_do_update(
-                index_elements=pk_names,
-                set_={col: stmt.excluded[col] for col in update_cols},
-            )
-        else:
-            stmt = stmt.on_conflict_do_nothing(index_elements=pk_names)
-
-        await session.execute(stmt)
-
-
-async def _batch_skip_existing(
-    session: AsyncSession,
-    model_cls: type[DeclarativeBase],
-    instances: list[DeclarativeBase],
-) -> list[DeclarativeBase]:
-    """INSERT only rows that do not already exist; return the inserted ones."""
-    mapper = model_cls.__mapper__
-    pk_names = [col.name for col in mapper.primary_key]
-
-    no_pk: list[DeclarativeBase] = []
-    with_pk_pairs: list[tuple[DeclarativeBase, Any]] = []
-    for inst in instances:
-        pk = _get_primary_key(inst)
-        if pk is None:
-            no_pk.append(inst)
-        else:
-            with_pk_pairs.append((inst, pk))
-
-    loaded: list[DeclarativeBase] = list(no_pk)
-    if no_pk:
-        no_pk_dicts = [_instance_to_dict(i) for i in no_pk]
-        for group_dicts, _ in _group_by_column_set(no_pk_dicts, no_pk):
-            await session.execute(pg_insert(model_cls).values(group_dicts))
-
-    if with_pk_pairs:
-        with_pk = [i for i, _ in with_pk_pairs]
-        with_pk_dicts = [_instance_to_dict(i) for i in with_pk]
-        for group_dicts, group_insts in _group_by_column_set(with_pk_dicts, with_pk):
-            stmt = (
-                pg_insert(model_cls)
-                .values(group_dicts)
-                .on_conflict_do_nothing(index_elements=pk_names)
-            )
-            result = await session.execute(stmt.returning(*mapper.primary_key))
-            inserted_pks = {
-                row[0] if len(pk_names) == 1 else tuple(row) for row in result
-            }
-            loaded.extend(
-                inst
-                for inst, pk in zip(
-                    group_insts, [_get_primary_key(i) for i in group_insts]
-                )
-                if pk in inserted_pks
-            )
-
-    return loaded
-
-
 async def _load_ordered(
    session: AsyncSession,
    registry: FixtureRegistry,
    ordered_names: list[str],
    strategy: LoadStrategy,
-    contexts: tuple[str, ...] | None = None,
 ) -> dict[str, list[DeclarativeBase]]:
-    """Load fixtures in order using batch Core INSERT statements."""
+    """Load fixtures in order."""
    results: dict[str, list[DeclarativeBase]] = {}

    for name in ordered_names:
-        variants = (
-            registry.get_variants(name, *contexts)
-            if contexts is not None
-            else registry.get_variants(name)
-        )
-
-        if contexts is not None and not variants:
-            variants = registry.get_variants(name)
-
-        if not variants:
-            results[name] = []
-            continue
-
-        instances = [inst for v in variants for inst in v.func()]
+        fixture = registry.get(name)
+        instances = list(fixture.func())

        if not instances:
            results[name] = []
@@ -193,17 +36,25 @@ async def _load_ordered(
        loaded: list[DeclarativeBase] = []

        async with get_transaction(session):
-            for model_cls, group in _group_by_type(instances):
-                match strategy:
-                    case LoadStrategy.INSERT:
-                        await _batch_insert(session, model_cls, group)
-                        loaded.extend(group)
-                    case LoadStrategy.MERGE:
-                        await _batch_merge(session, model_cls, group)
-                        loaded.extend(group)
-                    case LoadStrategy.SKIP_EXISTING:
-                        inserted = await _batch_skip_existing(session, model_cls, group)
-                        loaded.extend(inserted)
+            for instance in instances:
+                if strategy == LoadStrategy.INSERT:
+                    session.add(instance)
+                    loaded.append(instance)
+
+                elif strategy == LoadStrategy.MERGE:
+                    merged = await session.merge(instance)
+                    loaded.append(merged)
+
+                else:  # LoadStrategy.SKIP_EXISTING
+                    pk = _get_primary_key(instance)
+                    if pk is not None:
+                        existing = await session.get(type(instance), pk)
+                        if existing is None:
+                            session.add(instance)
+                            loaded.append(instance)
+                    else:
+                        session.add(instance)
+                        loaded.append(instance)

        results[name] = loaded
        logger.info(f"Loaded fixture '{name}': {len(loaded)} {model_name}(s)")
@@ -258,8 +109,6 @@ async def load_fixtures(
 ) -> dict[str, list[DeclarativeBase]]:
    """Load specific fixtures by name with dependencies.

-    All context variants of each requested fixture are loaded and merged.
-
    Args:
        session: Database session
        registry: Fixture registry
@@ -276,7 +125,7 @@ async def load_fixtures(
 async def load_fixtures_by_context(
    session: AsyncSession,
    registry: FixtureRegistry,
-    *contexts: str | Enum,
+    *contexts: str | Context,
    strategy: LoadStrategy = LoadStrategy.MERGE,
 ) -> dict[str, list[DeclarativeBase]]:
    """Load all fixtures for specific contexts.
@@ -284,15 +133,11 @@ async def load_fixtures_by_context(
    Args:
        session: Database session
        registry: Fixture registry
-        *contexts: Contexts to load (e.g., ``Context.BASE``, ``Context.TESTING``,
-            or plain strings for custom contexts)
+        *contexts: Contexts to load (e.g., Context.BASE, Context.TESTING)
        strategy: How to handle existing records

    Returns:
        Dict mapping fixture names to loaded instances
    """
-    context_strings = tuple(_normalize_contexts(contexts))
    ordered = registry.resolve_context_dependencies(*contexts)
-    return await _load_ordered(
-        session, registry, ordered, strategy, contexts=context_strings
-    )
+    return await _load_ordered(session, registry, ordered, strategy)
--- a/src/fastapi_toolsets/logger.py
+++ b/src/fastapi_toolsets/logger.py
@@ -66,7 +66,7 @@ def configure_logging(
 _SENTINEL = object()


-def get_logger(name: str | None = _SENTINEL) -> logging.Logger:  # type: ignore[assignment]  # ty:ignore[invalid-parameter-default]
+def get_logger(name: str | None = _SENTINEL) -> logging.Logger:  # type: ignore[assignment]
    """Return a logger with the given *name*.

    A thin convenience wrapper around :func:`logging.getLogger` that keeps
--- a/src/fastapi_toolsets/metrics/handler.py
+++ b/src/fastapi_toolsets/metrics/handler.py
@@ -1,6 +1,6 @@
 """Prometheus metrics endpoint for FastAPI applications."""

-import inspect
+import asyncio
 import os

 from fastapi import FastAPI
@@ -55,10 +55,10 @@ def init_metrics(

    # Partition collectors and cache env check at startup — both are stable for the app lifetime.
    async_collectors = [
-        c for c in registry.get_collectors() if inspect.iscoroutinefunction(c.func)
+        c for c in registry.get_collectors() if asyncio.iscoroutinefunction(c.func)
    ]
    sync_collectors = [
-        c for c in registry.get_collectors() if not inspect.iscoroutinefunction(c.func)
+        c for c in registry.get_collectors() if not asyncio.iscoroutinefunction(c.func)
    ]
    multiprocess_mode = _is_multiprocess()

--- a/src/fastapi_toolsets/models/columns.py
+++ b/src/fastapi_toolsets/models/columns.py
@@ -1,11 +1,18 @@
-"""SQLAlchemy column mixins for common column patterns."""
+"""SQLAlchemy model mixins for common column patterns."""

 import uuid
 from datetime import datetime

-from sqlalchemy import DateTime, Uuid, text
+from sqlalchemy import DateTime, Uuid, func, text
 from sqlalchemy.orm import Mapped, mapped_column

+__all__ = [
+    "UUIDMixin",
+    "CreatedAtMixin",
+    "UpdatedAtMixin",
+    "TimestampMixin",
+]
+

 class UUIDMixin:
    """Mixin that adds a UUID primary key auto-generated by the database."""
@@ -17,22 +24,12 @@ class UUIDMixin:
    )


-class UUIDv7Mixin:
-    """Mixin that adds a UUIDv7 primary key auto-generated by the database."""
-
-    id: Mapped[uuid.UUID] = mapped_column(
-        Uuid,
-        primary_key=True,
-        server_default=text("uuidv7()"),
-    )
-
-
 class CreatedAtMixin:
    """Mixin that adds a ``created_at`` timestamp column."""

    created_at: Mapped[datetime] = mapped_column(
        DateTime(timezone=True),
-        server_default=text("clock_timestamp()"),
+        server_default=func.now(),
    )


@@ -41,8 +38,8 @@ class UpdatedAtMixin:

    updated_at: Mapped[datetime] = mapped_column(
        DateTime(timezone=True),
-        server_default=text("clock_timestamp()"),
-        onupdate=text("clock_timestamp()"),
+        server_default=func.now(),
+        onupdate=func.now(),
    )


--- a/src/fastapi_toolsets/models/init.py
+++ b/src/fastapi_toolsets/models/init.py
@@ -1,21 +0,0 @@
-"""SQLAlchemy model mixins for common column patterns."""
-
-from .columns import (
-    CreatedAtMixin,
-    TimestampMixin,
-    UUIDMixin,
-    UUIDv7Mixin,
-    UpdatedAtMixin,
-)
-from .watched import EventSession, ModelEvent, listens_for
-
-__all__ = [
-    "EventSession",
-    "ModelEvent",
-    "UUIDMixin",
-    "UUIDv7Mixin",
-    "CreatedAtMixin",
-    "UpdatedAtMixin",
-    "TimestampMixin",
-    "listens_for",
-]
--- a/src/fastapi_toolsets/models/watched.py
+++ b/src/fastapi_toolsets/models/watched.py
@@ -1,290 +0,0 @@
-"""Field-change monitoring via SQLAlchemy session events."""
-
-import inspect
-from collections.abc import Callable
-from enum import Enum
-from typing import Any
-
-from sqlalchemy import event
-from sqlalchemy import inspect as sa_inspect
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm.attributes import set_committed_value as _sa_set_committed_value
-
-from ..logger import get_logger
-
-_logger = get_logger()
-
-
-class ModelEvent(str, Enum):
-    """Event types dispatched by :class:`EventSession`."""
-
-    CREATE = "create"
-    DELETE = "delete"
-    UPDATE = "update"
-
-
-_CALLBACK_ERROR_MSG = "Event callback raised an unhandled exception"
-_SESSION_CREATES = "_ft_creates"
-_SESSION_DELETES = "_ft_deletes"
-_SESSION_UPDATES = "_ft_updates"
-_DEFERRED_STRATEGY_KEY = (("deferred", True), ("instrument", True))
-_EVENT_HANDLERS: dict[tuple[type, ModelEvent], list[Callable[..., Any]]] = {}
-_WATCHED_MODELS: set[type] = set()
-_WATCHED_CACHE: dict[type, bool] = {}
-_HANDLER_CACHE: dict[tuple[type, ModelEvent], list[Callable[..., Any]]] = {}
-
-
-def _invalidate_caches() -> None:
-    """Clear lookup caches after handler registration."""
-    _WATCHED_CACHE.clear()
-    _HANDLER_CACHE.clear()
-
-
-def listens_for(
-    model_class: type,
-    event_types: list[ModelEvent] | None = None,
-) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
-    """Register a callback for one or more model lifecycle events.
-
-    Args:
-        model_class: The SQLAlchemy model class to listen on.
-        event_types: List of :class:`ModelEvent` values to listen for.
-            Defaults to all event types.
-    """
-    evs = event_types if event_types is not None else list(ModelEvent)
-
-    def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
-        for ev in evs:
-            _EVENT_HANDLERS.setdefault((model_class, ev), []).append(fn)
-        _WATCHED_MODELS.add(model_class)
-        _invalidate_caches()
-        return fn
-
-    return decorator
-
-
-def _is_watched(obj: Any) -> bool:
-    """Return True if *obj*'s type (or any ancestor) has registered handlers."""
-    cls = type(obj)
-    try:
-        return _WATCHED_CACHE[cls]
-    except KeyError:
-        result = any(klass in _WATCHED_MODELS for klass in cls.__mro__)
-        _WATCHED_CACHE[cls] = result
-        return result
-
-
-def _get_handlers(cls: type, ev: ModelEvent) -> list[Callable[..., Any]]:
-    """Return registered handlers for *cls* and *ev*, walking the MRO."""
-    key = (cls, ev)
-    try:
-        return _HANDLER_CACHE[key]
-    except KeyError:
-        handlers: list[Callable[..., Any]] = []
-        for klass in cls.__mro__:
-            handlers.extend(_EVENT_HANDLERS.get((klass, ev), []))
-        _HANDLER_CACHE[key] = handlers
-        return handlers
-
-
-def _snapshot_column_attrs(obj: Any) -> dict[str, Any]:
-    """Read currently-loaded column values into a plain dict."""
-    state = sa_inspect(obj)  # InstanceState
-    state_dict = state.dict
-    snapshot: dict[str, Any] = {}
-    for prop in state.mapper.column_attrs:
-        if prop.key in state_dict:
-            snapshot[prop.key] = state_dict[prop.key]
-        elif (  # pragma: no cover
-            not state.expired
-            and prop.strategy_key != _DEFERRED_STRATEGY_KEY
-            and all(
-                col.nullable
-                and col.server_default is None
-                and col.server_onupdate is None
-                for col in prop.columns
-            )
-        ):
-            snapshot[prop.key] = None
-    return snapshot
-
-
-def _get_watched_fields(cls: type) -> tuple[str, ...] | None:
-    """Return the watched fields for *cls*."""
-    fields = getattr(cls, "__watched_fields__", None)
-    if fields is not None and (
-        not isinstance(fields, tuple) or not all(isinstance(f, str) for f in fields)
-    ):
-        raise TypeError(
-            f"{cls.__name__}.__watched_fields__ must be a tuple[str, ...], "
-            f"got {type(fields).__name__}"
-        )
-    return fields
-
-
-def _upsert_changes(
-    pending: dict[int, tuple[Any, dict[str, dict[str, Any]]]],
-    obj: Any,
-    changes: dict[str, dict[str, Any]],
-) -> None:
-    """Insert or merge *changes* into *pending* for *obj*."""
-    key = id(obj)
-    if key in pending:
-        existing = pending[key][1]
-        for field, change in changes.items():
-            if field in existing:
-                existing[field]["new"] = change["new"]
-            else:
-                existing[field] = change
-    else:
-        pending[key] = (obj, changes)
-
-
-@event.listens_for(AsyncSession.sync_session_class, "after_flush")
-def _after_flush(session: Any, flush_context: Any) -> None:
-    # New objects: capture reference. Attributes will be refreshed after commit.
-    for obj in session.new:
-        if _is_watched(obj):
-            session.info.setdefault(_SESSION_CREATES, []).append(obj)
-
-    # Deleted objects: snapshot now while attributes are still loaded.
-    for obj in session.deleted:
-        if _is_watched(obj):
-            snapshot = _snapshot_column_attrs(obj)
-            session.info.setdefault(_SESSION_DELETES, []).append((obj, snapshot))
-
-    # Dirty objects: read old/new from SQLAlchemy attribute history.
-    for obj in session.dirty:
-        if not _is_watched(obj):
-            continue
-
-        watched = _get_watched_fields(type(obj))
-        changes: dict[str, dict[str, Any]] = {}
-
-        inst_attrs = sa_inspect(obj).attrs
-        attrs = (
-            ((field, inst_attrs[field]) for field in watched)
-            if watched is not None
-            else ((s.key, s) for s in inst_attrs)
-        )
-        for field, attr_state in attrs:
-            history = attr_state.history
-            if history.has_changes() and history.deleted:
-                changes[field] = {
-                    "old": history.deleted[0],
-                    "new": history.added[0] if history.added else None,
-                }
-
-        if changes:
-            _upsert_changes(
-                session.info.setdefault(_SESSION_UPDATES, {}),
-                obj,
-                changes,
-            )
-
-
-@event.listens_for(AsyncSession.sync_session_class, "after_rollback")
-def _after_rollback(session: Any) -> None:
-    if session.in_transaction():
-        return
-    session.info.pop(_SESSION_CREATES, None)
-    session.info.pop(_SESSION_DELETES, None)
-    session.info.pop(_SESSION_UPDATES, None)
-
-
-async def _invoke_callback(
-    fn: Callable[..., Any],
-    obj: Any,
-    event_type: ModelEvent,
-    changes: dict[str, dict[str, Any]] | None,
-) -> None:
-    """Call *fn* and await the result if it is awaitable."""
-    result = fn(obj, event_type, changes)
-    if inspect.isawaitable(result):
-        await result
-
-
-class EventSession(AsyncSession):
-    """AsyncSession subclass that dispatches lifecycle callbacks after commit."""
-
-    async def commit(self) -> None:  # noqa: C901
-        await super().commit()
-
-        creates: list[Any] = self.info.pop(_SESSION_CREATES, [])
-        deletes: list[tuple[Any, dict[str, Any]]] = self.info.pop(_SESSION_DELETES, [])
-        field_changes: dict[int, tuple[Any, dict[str, dict[str, Any]]]] = self.info.pop(
-            _SESSION_UPDATES, {}
-        )
-
-        if not creates and not deletes and not field_changes:
-            return
-
-        # Suppress transient objects (created + deleted in same transaction).
-        if creates and deletes:
-            created_ids = {id(o) for o in creates}
-            deleted_ids = {id(o) for o, _ in deletes}
-            transient_ids = created_ids & deleted_ids
-            if transient_ids:
-                creates = [o for o in creates if id(o) not in transient_ids]
-                deletes = [(o, s) for o, s in deletes if id(o) not in transient_ids]
-                field_changes = {
-                    k: v for k, v in field_changes.items() if k not in transient_ids
-                }
-
-        # Suppress updates for deleted objects (row is gone, refresh would fail).
-        if deletes and field_changes:
-            deleted_ids = {id(o) for o, _ in deletes}
-            field_changes = {
-                k: v for k, v in field_changes.items() if k not in deleted_ids
-            }
-
-        # Suppress updates for newly created objects (CREATE-only semantics).
-        if creates and field_changes:
-            create_ids = {id(o) for o in creates}
-            field_changes = {
-                k: v for k, v in field_changes.items() if k not in create_ids
-            }
-
-        # Dispatch CREATE callbacks.
-        for obj in creates:
-            try:
-                state = sa_inspect(obj, raiseerr=False)
-                if (
-                    state is None or state.detached or state.transient
-                ):  # pragma: no cover
-                    continue
-                await self.refresh(obj)
-                for handler in _get_handlers(type(obj), ModelEvent.CREATE):
-                    await _invoke_callback(handler, obj, ModelEvent.CREATE, None)
-            except Exception as exc:
-                _logger.error(_CALLBACK_ERROR_MSG, exc_info=exc)
-
-        # Dispatch DELETE callbacks (restore snapshot; row is gone).
-        for obj, snapshot in deletes:
-            try:
-                for key, value in snapshot.items():
-                    _sa_set_committed_value(obj, key, value)
-                for handler in _get_handlers(type(obj), ModelEvent.DELETE):
-                    await _invoke_callback(handler, obj, ModelEvent.DELETE, None)
-            except Exception as exc:
-                _logger.error(_CALLBACK_ERROR_MSG, exc_info=exc)
-
-        # Dispatch UPDATE callbacks.
-        for obj, changes in field_changes.values():
-            try:
-                state = sa_inspect(obj, raiseerr=False)
-                if (
-                    state is None or state.detached or state.transient
-                ):  # pragma: no cover
-                    continue
-                await self.refresh(obj)
-                for handler in _get_handlers(type(obj), ModelEvent.UPDATE):
-                    await _invoke_callback(handler, obj, ModelEvent.UPDATE, changes)
-            except Exception as exc:
-                _logger.error(_CALLBACK_ERROR_MSG, exc_info=exc)
-
-    async def rollback(self) -> None:
-        await super().rollback()
-        self.info.pop(_SESSION_CREATES, None)
-        self.info.pop(_SESSION_DELETES, None)
-        self.info.pop(_SESSION_UPDATES, None)
--- a/src/fastapi_toolsets/pytest/utils.py
+++ b/src/fastapi_toolsets/pytest/utils.py
@@ -1,12 +1,12 @@
 """Pytest helper utilities for FastAPI testing."""

 import os
+import warnings
 from collections.abc import AsyncGenerator, Callable
 from contextlib import asynccontextmanager
 from typing import Any

 from httpx import ASGITransport, AsyncClient
-from sqlalchemy import text
 from sqlalchemy.engine import make_url
 from sqlalchemy.ext.asyncio import (
    AsyncSession,
@@ -15,8 +15,33 @@ from sqlalchemy.ext.asyncio import (
 )
 from sqlalchemy.orm import DeclarativeBase

-from ..db import cleanup_tables, create_database
-from ..models.watched import EventSession
+from sqlalchemy import text
+
+from ..db import (
+    cleanup_tables as _cleanup_tables,
+    create_database,
+    create_db_context,
+)
+
+
+async def cleanup_tables(
+    session: AsyncSession,
+    base: type[DeclarativeBase],
+) -> None:
+    """Truncate all tables for fast between-test cleanup.
+
+    .. deprecated::
+        Import ``cleanup_tables`` from ``fastapi_toolsets.db`` instead.
+        This re-export will be removed in v3.0.0.
+    """
+    warnings.warn(
+        "Importing cleanup_tables from fastapi_toolsets.pytest is deprecated "
+        "and will be removed in v3.0.0. "
+        "Use 'from fastapi_toolsets.db import cleanup_tables' instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    await _cleanup_tables(session=session, base=base)


 def _get_xdist_worker(default_test_db: str) -> str:
@@ -104,8 +129,7 @@ async def create_worker_database(
    worker_url = worker_database_url(
        database_url=database_url, default_test_db=default_test_db
    )
-    worker_db_name = make_url(worker_url).database
-    assert worker_db_name is not None
+    worker_db_name: str = make_url(worker_url).database  # type: ignore[assignment]

    engine = create_async_engine(database_url, isolation_level="AUTOCOMMIT")
    try:
@@ -244,14 +268,15 @@ async def create_db_session(
        async with engine.begin() as conn:
            await conn.run_sync(base.metadata.create_all)

-        session_maker = async_sessionmaker(
-            engine, expire_on_commit=expire_on_commit, class_=EventSession
-        )
-        async with session_maker() as session:
+        # Create session using existing db context utility
+        session_maker = async_sessionmaker(engine, expire_on_commit=expire_on_commit)
+        get_session = create_db_context(session_maker)
+
+        async with get_session() as session:
            yield session

            if cleanup:
-                await cleanup_tables(session=session, base=base)
+                await cleanup_tables(session, base)

        if drop_tables:
            async with engine.begin() as conn:
--- a/src/fastapi_toolsets/schemas.py
+++ b/src/fastapi_toolsets/schemas.py
@@ -1,22 +1,18 @@
 """Base Pydantic schemas for API responses."""

-import math
 from enum import Enum
-from typing import Annotated, Any, ClassVar, Generic, Literal, TypeVar, Union
+from typing import Any, ClassVar, Generic

-from pydantic import BaseModel, ConfigDict, Field, computed_field
+from pydantic import BaseModel, ConfigDict

 from .types import DataT

 __all__ = [
    "ApiError",
    "CursorPagination",
-    "CursorPaginatedResponse",
    "ErrorResponse",
    "OffsetPagination",
-    "OffsetPaginatedResponse",
    "PaginatedResponse",
-    "PaginationType",
    "PydanticBase",
    "Response",
    "ResponseStatus",
@@ -99,29 +95,17 @@ class OffsetPagination(PydanticBase):
    """Pagination metadata for offset-based list responses.

    Attributes:
-        total_count: Total number of items across all pages.
-            ``None`` when ``include_total=False``.
+        total_count: Total number of items across all pages
        items_per_page: Number of items per page
        page: Current page number (1-indexed)
        has_more: Whether there are more pages
-        pages: Total number of pages
    """

-    total_count: int | None
+    total_count: int
    items_per_page: int
    page: int
    has_more: bool

-    @computed_field
-    @property
-    def pages(self) -> int | None:
-        """Total number of pages, or ``None`` when ``total_count`` is unknown."""
-        if self.total_count is None:
-            return None
-        if self.items_per_page == 0:
-            return 0
-        return math.ceil(self.total_count / self.items_per_page)
-

 class CursorPagination(PydanticBase):
    """Pagination metadata for cursor-based list responses.
@@ -139,68 +123,9 @@ class CursorPagination(PydanticBase):
    has_more: bool


-class PaginationType(str, Enum):
-    """Pagination strategy selector for :meth:`.AsyncCrud.paginate`."""
-
-    OFFSET = "offset"
-    CURSOR = "cursor"
-
-
 class PaginatedResponse(BaseResponse, Generic[DataT]):
-    """Paginated API response for list endpoints.
-
-    Base class and return type for endpoints that support both pagination
-    strategies.  Use :class:`OffsetPaginatedResponse` or
-    :class:`CursorPaginatedResponse` when the strategy is fixed.
-
-    When used as ``PaginatedResponse[T]`` in a return annotation, subscripting
-    returns ``Annotated[Union[CursorPaginatedResponse[T], OffsetPaginatedResponse[T]], Field(discriminator="pagination_type")]``
-    so FastAPI emits a proper ``oneOf`` + discriminator in the OpenAPI schema.
-    """
+    """Paginated API response for list endpoints."""

    data: list[DataT]
    pagination: OffsetPagination | CursorPagination
-    pagination_type: PaginationType | None = None
    filter_attributes: dict[str, list[Any]] | None = None
-    search_columns: list[str] | None = None
-    order_columns: list[str] | None = None
-
-    _discriminated_union_cache: ClassVar[dict[Any, Any]] = {}
-
-    def __class_getitem__(  # ty:ignore[invalid-method-override]
-        cls, item: type[Any] | tuple[type[Any], ...]
-    ) -> type[Any]:
-        if cls is PaginatedResponse and not isinstance(item, TypeVar):
-            cached = cls._discriminated_union_cache.get(item)
-            if cached is None:
-                cached = Annotated[
-                    Union[CursorPaginatedResponse[item], OffsetPaginatedResponse[item]],  # ty:ignore[invalid-type-form]
-                    Field(discriminator="pagination_type"),
-                ]
-                cls._discriminated_union_cache[item] = cached
-            return cached  # ty:ignore[invalid-return-type]
-        return super().__class_getitem__(item)
-
-
-class OffsetPaginatedResponse(PaginatedResponse[DataT]):
-    """Paginated response with typed offset-based pagination metadata.
-
-    The ``pagination_type`` field is always ``"offset"`` and acts as a
-    discriminator, allowing frontend clients to narrow the union type returned
-    by a unified ``paginate()`` endpoint.
-    """
-
-    pagination: OffsetPagination
-    pagination_type: Literal[PaginationType.OFFSET] = PaginationType.OFFSET
-
-
-class CursorPaginatedResponse(PaginatedResponse[DataT]):
-    """Paginated response with typed cursor-based pagination metadata.
-
-    The ``pagination_type`` field is always ``"cursor"`` and acts as a
-    discriminator, allowing frontend clients to narrow the union type returned
-    by a unified ``paginate()`` endpoint.
-    """
-
-    pagination: CursorPagination
-    pagination_type: Literal[PaginationType.CURSOR] = PaginationType.CURSOR
--- a/src/fastapi_toolsets/types.py
+++ b/src/fastapi_toolsets/types.py
@@ -15,14 +15,13 @@ ModelType = TypeVar("ModelType", bound=DeclarativeBase)
 SchemaType = TypeVar("SchemaType", bound=BaseModel)

 # CRUD type aliases
-JoinType = list[tuple[type[DeclarativeBase] | Any, Any]]
+JoinType = list[tuple[type[DeclarativeBase], Any]]
 M2MFieldType = Mapping[str, QueryableAttribute[Any]]
 OrderByClause = ColumnElement[Any] | QueryableAttribute[Any]

-# Search / facet / order type aliases
+# Search / facet type aliases
 SearchFieldType = InstrumentedAttribute[Any] | tuple[InstrumentedAttribute[Any], ...]
 FacetFieldType = SearchFieldType
-OrderFieldType = SearchFieldType

 # Dependency type aliases
-SessionDependency = Callable[[], AsyncGenerator[AsyncSession, None]] | Any
+SessionDependency = Callable[[], AsyncGenerator[AsyncSession, None]]
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -2,7 +2,6 @@

 import os
 import uuid
-from enum import Enum

 import pytest
 from pydantic import BaseModel
@@ -13,16 +12,13 @@ from sqlalchemy import (
    Column,
    Date,
    DateTime,
-    Enum as SAEnum,
    ForeignKey,
    Integer,
-    JSON,
    Numeric,
    String,
    Table,
    Uuid,
 )
-from sqlalchemy.dialects.postgresql import ARRAY
 from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship

@@ -61,7 +57,6 @@ class User(Base):
    username: Mapped[str] = mapped_column(String(50), unique=True)
    email: Mapped[str] = mapped_column(String(100), unique=True)
    is_active: Mapped[bool] = mapped_column(default=True)
-    notes: Mapped[str | None]
    role_id: Mapped[uuid.UUID | None] = mapped_column(
        ForeignKey("roles.id"), nullable=True
    )
@@ -141,57 +136,6 @@ class Post(Base):
    tags: Mapped[list[Tag]] = relationship(secondary=post_tags)


-class OrderStatus(int, Enum):
-    """Integer-backed enum for order status."""
-
-    PENDING = 1
-    PROCESSING = 2
-    SHIPPED = 3
-    CANCELLED = 4
-
-
-class Color(str, Enum):
-    """String-backed enum for color."""
-
-    RED = "red"
-    GREEN = "green"
-    BLUE = "blue"
-
-
-class Order(Base):
-    """Test model with an IntEnum column (Enum(int, Enum)) and a raw Integer column."""
-
-    __tablename__ = "orders"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    name: Mapped[str] = mapped_column(String(100))
-    status: Mapped[OrderStatus] = mapped_column(SAEnum(OrderStatus))
-    priority: Mapped[int] = mapped_column(Integer)
-    color: Mapped[Color] = mapped_column(SAEnum(Color))
-
-
-class Transfer(Base):
-    """Test model with two FKs to the same table (users)."""
-
-    __tablename__ = "transfers"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    amount: Mapped[str] = mapped_column(String(50))
-    sender_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
-    receiver_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
-
-
-class Article(Base):
-    """Test article model with ARRAY and JSON columns."""
-
-    __tablename__ = "articles"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    title: Mapped[str] = mapped_column(String(200))
-    labels: Mapped[list[str]] = mapped_column(ARRAY(String))
-    metadata_: Mapped[dict | None] = mapped_column("metadata", JSON, nullable=True)
-
-
 class RoleCreate(BaseModel):
    """Schema for creating a role."""

@@ -326,61 +270,6 @@ class ProductCreate(BaseModel):
    price: decimal.Decimal


-class ArticleCreate(BaseModel):
-    """Schema for creating an article."""
-
-    id: uuid.UUID | None = None
-    title: str
-    labels: list[str] = []
-
-
-class ArticleRead(PydanticBase):
-    """Schema for reading an article."""
-
-    id: uuid.UUID
-    title: str
-    labels: list[str]
-
-
-class OrderCreate(BaseModel):
-    """Schema for creating an order."""
-
-    id: uuid.UUID | None = None
-    name: str
-    status: OrderStatus
-    priority: int = 0
-    color: Color = Color.RED
-
-
-class OrderRead(PydanticBase):
-    """Schema for reading an order."""
-
-    id: uuid.UUID
-    name: str
-    status: OrderStatus
-    priority: int
-    color: Color
-
-
-class TransferCreate(BaseModel):
-    """Schema for creating a transfer."""
-
-    id: uuid.UUID | None = None
-    amount: str
-    sender_id: uuid.UUID
-    receiver_id: uuid.UUID
-
-
-class TransferRead(PydanticBase):
-    """Schema for reading a transfer."""
-
-    id: uuid.UUID
-    amount: str
-
-
-OrderCrud = CrudFactory(Order)
-TransferCrud = CrudFactory(Transfer)
-ArticleCrud = CrudFactory(Article)
 RoleCrud = CrudFactory(Role)
 RoleCursorCrud = CrudFactory(Role, cursor_column=Role.id)
 IntRoleCursorCrud = CrudFactory(IntRole, cursor_column=IntRole.id)
@@ -432,3 +321,30 @@ async def db_session(engine):
        # Drop tables after test
        async with engine.begin() as conn:
            await conn.run_sync(Base.metadata.drop_all)
+
+
+@pytest.fixture
+def sample_role_data() -> RoleCreate:
+    """Sample role creation data."""
+    return RoleCreate(name="admin")
+
+
+@pytest.fixture
+def sample_user_data() -> UserCreate:
+    """Sample user creation data."""
+    return UserCreate(
+        username="testuser",
+        email="test@example.com",
+        is_active=True,
+    )
+
+
+@pytest.fixture
+def sample_post_data() -> PostCreate:
+    """Sample post creation data."""
+    return PostCreate(
+        title="Test Post",
+        content="Test content",
+        is_published=True,
+        author_id=uuid.uuid4(),
+    )
--- a/tests/test_crud.py
+++ b/tests/test_crud.py
@@ -6,8 +6,8 @@ import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload

-from fastapi_toolsets.crud import CrudFactory, PaginationType
-from fastapi_toolsets.crud.factory import AsyncCrud, _CursorDirection
+from fastapi_toolsets.crud import CrudFactory
+from fastapi_toolsets.crud.factory import AsyncCrud
 from fastapi_toolsets.exceptions import NotFoundError

 from .conftest import (
@@ -38,10 +38,6 @@ from .conftest import (
    Tag,
    TagCreate,
    TagCrud,
-    Transfer,
-    TransferCreate,
-    TransferCrud,
-    TransferRead,
    User,
    UserCreate,
    UserCrud,
@@ -90,101 +86,6 @@ class TestCrudFactory:
        assert crud_with.default_load_options == options
        assert crud_without.default_load_options is None

-    def test_base_class_custom_methods_inherited(self):
-        """CrudFactory with base_class inherits custom methods from that base."""
-        from typing import Generic, TypeVar
-
-        from sqlalchemy.orm import DeclarativeBase
-
-        T = TypeVar("T", bound=DeclarativeBase)
-
-        class CustomBase(AsyncCrud[T], Generic[T]):
-            @classmethod
-            def custom_method(cls) -> str:
-                return f"custom:{cls.model.__name__}"
-
-        UserCrudCustom = CrudFactory(User, base_class=CustomBase)
-        PostCrudCustom = CrudFactory(Post, base_class=CustomBase)
-
-        assert issubclass(UserCrudCustom, CustomBase)
-        assert issubclass(PostCrudCustom, CustomBase)
-        assert UserCrudCustom.custom_method() == "custom:User"
-        assert PostCrudCustom.custom_method() == "custom:Post"
-
-    def test_base_class_pk_injected(self):
-        """PK is still injected when using a custom base_class."""
-        from typing import Generic, TypeVar
-
-        from sqlalchemy.orm import DeclarativeBase
-
-        T = TypeVar("T", bound=DeclarativeBase)
-
-        class CustomBase(AsyncCrud[T], Generic[T]):
-            pass
-
-        crud = CrudFactory(User, base_class=CustomBase)
-        assert crud.searchable_fields is not None
-        assert User.id in crud.searchable_fields
-
-
-class TestAsyncCrudSubclass:
-    """Tests for direct AsyncCrud subclassing (alternative to CrudFactory)."""
-
-    def test_subclass_with_model_only(self):
-        """Subclassing with just model auto-injects PK into searchable_fields."""
-
-        class UserCrudDirect(AsyncCrud[User]):
-            model = User
-
-        assert UserCrudDirect.searchable_fields == [User.id]
-
-    def test_subclass_with_explicit_fields_prepends_pk(self):
-        """Subclassing with searchable_fields prepends PK automatically."""
-
-        class UserCrudDirect(AsyncCrud[User]):
-            model = User
-            searchable_fields = [User.username]
-
-        assert UserCrudDirect.searchable_fields == [User.id, User.username]
-
-    def test_subclass_with_pk_already_in_fields(self):
-        """PK is not duplicated when already in searchable_fields."""
-
-        class UserCrudDirect(AsyncCrud[User]):
-            model = User
-            searchable_fields = [User.id, User.username]
-
-        assert UserCrudDirect.searchable_fields == [User.id, User.username]
-
-    def test_subclass_has_default_class_vars(self):
-        """Other ClassVars are None by default on a direct subclass."""
-
-        class UserCrudDirect(AsyncCrud[User]):
-            model = User
-
-        assert UserCrudDirect.facet_fields is None
-        assert UserCrudDirect.default_load_options is None
-        assert UserCrudDirect.cursor_column is None
-
-    def test_subclass_with_load_options(self):
-        """Direct subclass can declare default_load_options."""
-        opts = [selectinload(User.role)]
-
-        class UserCrudDirect(AsyncCrud[User]):
-            model = User
-            default_load_options = opts
-
-        assert UserCrudDirect.default_load_options is opts
-
-    def test_abstract_base_without_model_not_processed(self):
-        """Intermediate abstract class without model is not processed."""
-
-        class AbstractCrud(AsyncCrud[User]):
-            pass
-
-        # Should not raise, and searchable_fields inherits base default (None)
-        assert AbstractCrud.searchable_fields is None
-

 class TestResolveLoadOptions:
    """Tests for _resolve_load_options logic."""
@@ -215,92 +116,6 @@ class TestResolveLoadOptions:
        assert crud._resolve_load_options([]) == []


-class TestResolveSearchColumns:
-    """Tests for _resolve_search_columns logic."""
-
-    def test_returns_none_when_no_searchable_fields(self):
-        """Returns None when cls.searchable_fields is None and no search_fields passed."""
-
-        class AbstractCrud(AsyncCrud[User]):
-            pass
-
-        assert AbstractCrud._resolve_search_columns(None) is None
-
-    def test_returns_none_when_empty_search_fields_passed(self):
-        """Returns None when an empty list is passed explicitly."""
-        crud = CrudFactory(User)
-        assert crud._resolve_search_columns([]) is None
-
-    def test_returns_keys_from_class_searchable_fields(self):
-        """Returns column keys from cls.searchable_fields when no override passed."""
-        crud = CrudFactory(User, searchable_fields=[User.username])
-        result = crud._resolve_search_columns(None)
-        assert result is not None
-        assert "username" in result
-
-    def test_search_fields_override_takes_priority(self):
-        """Explicit search_fields override cls.searchable_fields."""
-        crud = CrudFactory(User, searchable_fields=[User.username])
-        result = crud._resolve_search_columns([User.email])
-        assert result is not None
-        assert "email" in result
-        assert "username" not in result
-
-
-class TestResolveOrderColumns:
-    """Tests for _resolve_order_columns logic."""
-
-    def test_returns_none_when_no_order_fields(self):
-        """Returns None when cls.order_fields is None and no order_fields passed."""
-
-        class AbstractCrud(AsyncCrud[User]):
-            pass
-
-        assert AbstractCrud._resolve_order_columns(None) is None
-
-    def test_returns_none_when_empty_order_fields_passed(self):
-        """Returns None when an empty list is passed explicitly."""
-        crud = CrudFactory(User)
-        assert crud._resolve_order_columns([]) is None
-
-    def test_returns_keys_from_class_order_fields(self):
-        """Returns sorted column keys from cls.order_fields when no override passed."""
-        crud = CrudFactory(User, order_fields=[User.username])
-        result = crud._resolve_order_columns(None)
-        assert result is not None
-        assert "username" in result
-
-    def test_order_fields_override_takes_priority(self):
-        """Explicit order_fields override cls.order_fields."""
-        crud = CrudFactory(User, order_fields=[User.username])
-        result = crud._resolve_order_columns([User.email])
-        assert result is not None
-        assert "email" in result
-        assert "username" not in result
-
-    def test_returns_sorted_keys(self):
-        """Keys are returned in sorted order."""
-        crud = CrudFactory(User, order_fields=[User.email, User.username])
-        result = crud._resolve_order_columns(None)
-        assert result is not None
-        assert result == sorted(result)
-
-    def test_relation_tuple_produces_dunder_key(self):
-        """A (rel, column) tuple produces a 'rel__column' key."""
-        crud = CrudFactory(User, order_fields=[(User.role, Role.name)])
-        result = crud._resolve_order_columns(None)
-        assert result == ["role__name"]
-
-    def test_mixed_flat_and_relation_fields(self):
-        """Flat and relation fields can be mixed; keys are sorted."""
-        crud = CrudFactory(User, order_fields=[User.username, (User.role, Role.name)])
-        result = crud._resolve_order_columns(None)
-        assert result is not None
-        assert "username" in result
-        assert "role__name" in result
-        assert result == sorted(result)
-
-
 class TestDefaultLoadOptionsIntegration:
    """Integration tests for default_load_options with real DB queries."""

@@ -380,43 +195,6 @@ class TestDefaultLoadOptionsIntegration:
        assert result.data[0].role is not None
        assert result.data[0].role.name == "admin"

-    @pytest.mark.anyio
-    async def test_default_load_options_applied_to_create(
-        self, db_session: AsyncSession
-    ):
-        """default_load_options loads relationships after create()."""
-        UserWithDefaultLoad = CrudFactory(
-            User, default_load_options=[selectinload(User.role)]
-        )
-        role = await RoleCrud.create(db_session, RoleCreate(name="admin"))
-        user = await UserWithDefaultLoad.create(
-            db_session,
-            UserCreate(username="alice", email="alice@test.com", role_id=role.id),
-        )
-        assert user.role is not None
-        assert user.role.name == "admin"
-
-    @pytest.mark.anyio
-    async def test_default_load_options_applied_to_update(
-        self, db_session: AsyncSession
-    ):
-        """default_load_options loads relationships after update()."""
-        UserWithDefaultLoad = CrudFactory(
-            User, default_load_options=[selectinload(User.role)]
-        )
-        role = await RoleCrud.create(db_session, RoleCreate(name="admin"))
-        user = await UserCrud.create(
-            db_session,
-            UserCreate(username="alice", email="alice@test.com"),
-        )
-        updated = await UserWithDefaultLoad.update(
-            db_session,
-            UserUpdate(role_id=role.id),
-            filters=[User.id == user.id],
-        )
-        assert updated.role is not None
-        assert updated.role.name == "admin"
-
    @pytest.mark.anyio
    async def test_load_options_overrides_default_load_options(
        self, db_session: AsyncSession
@@ -1377,128 +1155,6 @@ class TestCrudJoins:
        assert users[0].username == "multi_join"


-class TestCrudAliasedJoins:
-    """Tests for CRUD operations with aliased joins (same table joined twice)."""
-
-    @pytest.mark.anyio
-    async def test_get_multi_with_aliased_joins(self, db_session: AsyncSession):
-        """Aliased joins allow joining the same table twice."""
-        from sqlalchemy.orm import aliased
-
-        alice = await UserCrud.create(
-            db_session, UserCreate(username="alice", email="alice@test.com")
-        )
-        bob = await UserCrud.create(
-            db_session, UserCreate(username="bob", email="bob@test.com")
-        )
-        await TransferCrud.create(
-            db_session,
-            TransferCreate(amount="100", sender_id=alice.id, receiver_id=bob.id),
-        )
-
-        Sender = aliased(User)
-        Receiver = aliased(User)
-
-        results = await TransferCrud.get_multi(
-            db_session,
-            joins=[
-                (Sender, Transfer.sender_id == Sender.id),
-                (Receiver, Transfer.receiver_id == Receiver.id),
-            ],
-            filters=[Sender.username == "alice", Receiver.username == "bob"],
-        )
-        assert len(results) == 1
-        assert results[0].amount == "100"
-
-    @pytest.mark.anyio
-    async def test_get_multi_aliased_no_match(self, db_session: AsyncSession):
-        """Aliased joins correctly filter out non-matching rows."""
-        from sqlalchemy.orm import aliased
-
-        alice = await UserCrud.create(
-            db_session, UserCreate(username="alice", email="alice@test.com")
-        )
-        bob = await UserCrud.create(
-            db_session, UserCreate(username="bob", email="bob@test.com")
-        )
-        await TransferCrud.create(
-            db_session,
-            TransferCreate(amount="100", sender_id=alice.id, receiver_id=bob.id),
-        )
-
-        Sender = aliased(User)
-        Receiver = aliased(User)
-
-        # bob is receiver, not sender — should return nothing
-        results = await TransferCrud.get_multi(
-            db_session,
-            joins=[
-                (Sender, Transfer.sender_id == Sender.id),
-                (Receiver, Transfer.receiver_id == Receiver.id),
-            ],
-            filters=[Sender.username == "bob", Receiver.username == "alice"],
-        )
-        assert len(results) == 0
-
-    @pytest.mark.anyio
-    async def test_paginate_with_aliased_joins(self, db_session: AsyncSession):
-        """Aliased joins work with offset_paginate."""
-        from sqlalchemy.orm import aliased
-
-        alice = await UserCrud.create(
-            db_session, UserCreate(username="alice", email="alice@test.com")
-        )
-        bob = await UserCrud.create(
-            db_session, UserCreate(username="bob", email="bob@test.com")
-        )
-        await TransferCrud.create(
-            db_session,
-            TransferCreate(amount="50", sender_id=alice.id, receiver_id=bob.id),
-        )
-        await TransferCrud.create(
-            db_session,
-            TransferCreate(amount="75", sender_id=bob.id, receiver_id=alice.id),
-        )
-
-        Sender = aliased(User)
-        result = await TransferCrud.offset_paginate(
-            db_session,
-            joins=[(Sender, Transfer.sender_id == Sender.id)],
-            filters=[Sender.username == "alice"],
-            schema=TransferRead,
-        )
-        assert result.pagination.total_count == 1
-        assert result.data[0].amount == "50"
-
-    @pytest.mark.anyio
-    async def test_count_with_aliased_join(self, db_session: AsyncSession):
-        """Aliased joins work with count."""
-        from sqlalchemy.orm import aliased
-
-        alice = await UserCrud.create(
-            db_session, UserCreate(username="alice", email="alice@test.com")
-        )
-        bob = await UserCrud.create(
-            db_session, UserCreate(username="bob", email="bob@test.com")
-        )
-        await TransferCrud.create(
-            db_session,
-            TransferCreate(amount="10", sender_id=alice.id, receiver_id=bob.id),
-        )
-        await TransferCrud.create(
-            db_session,
-            TransferCreate(amount="20", sender_id=alice.id, receiver_id=bob.id),
-        )
-
-        Sender = aliased(User)
-        count = await TransferCrud.count(
-            db_session,
-            joins=[(Sender, Transfer.sender_id == Sender.id)],
-            filters=[Sender.username == "alice"],
-        )
-        assert count == 2
-
-
 class TestCrudFactoryM2M:
    """Tests for CrudFactory with m2m_fields parameter."""

@@ -2008,52 +1664,6 @@ class TestSchemaResponse:
        assert result.data[0].username == "pg_user"
        assert not hasattr(result.data[0], "email")

-    @pytest.mark.anyio
-    async def test_include_total_false_skips_count(self, db_session: AsyncSession):
-        """offset_paginate with include_total=False returns total_count=None."""
-        from fastapi_toolsets.schemas import OffsetPagination
-
-        for i in range(5):
-            await RoleCrud.create(db_session, RoleCreate(name=f"role{i:02d}"))
-
-        result = await RoleCrud.offset_paginate(
-            db_session, items_per_page=10, include_total=False, schema=RoleRead
-        )
-
-        assert isinstance(result.pagination, OffsetPagination)
-        assert result.pagination.total_count is None
-        assert len(result.data) == 5
-        assert result.pagination.has_more is False
-
-    @pytest.mark.anyio
-    async def test_include_total_false_has_more_true(self, db_session: AsyncSession):
-        """offset_paginate with include_total=False sets has_more via extra-row probe."""
-        for i in range(15):
-            await RoleCrud.create(db_session, RoleCreate(name=f"role{i:02d}"))
-
-        result = await RoleCrud.offset_paginate(
-            db_session, items_per_page=10, include_total=False, schema=RoleRead
-        )
-
-        assert result.pagination.total_count is None
-        assert result.pagination.has_more is True
-        assert len(result.data) == 10
-
-    @pytest.mark.anyio
-    async def test_include_total_false_exact_page_boundary(
-        self, db_session: AsyncSession
-    ):
-        """offset_paginate with include_total=False: has_more=False when items == page size."""
-        for i in range(10):
-            await RoleCrud.create(db_session, RoleCreate(name=f"role{i:02d}"))
-
-        result = await RoleCrud.offset_paginate(
-            db_session, items_per_page=10, include_total=False, schema=RoleRead
-        )
-
-        assert result.pagination.has_more is False
-        assert len(result.data) == 10
-

 class TestCursorPaginate:
    """Tests for cursor-based pagination via cursor_paginate()."""
@@ -2264,8 +1874,11 @@ class TestCursorPaginatePrevCursor:
        assert page2.pagination.prev_cursor is not None

    @pytest.mark.anyio
-    async def test_prev_cursor_navigates_back(self, db_session: AsyncSession):
-        """prev_cursor on page 2 navigates back to the same items as page 1."""
+    async def test_prev_cursor_points_to_first_item(self, db_session: AsyncSession):
+        """prev_cursor encodes the value of the first item on the current page."""
+        import base64
+        import json
+
        for i in range(10):
            await RoleCrud.create(db_session, RoleCreate(name=f"role{i:02d}"))

@@ -2284,83 +1897,12 @@ class TestCursorPaginatePrevCursor:
        assert isinstance(page2.pagination, CursorPagination)
        assert page2.pagination.prev_cursor is not None

-        # Using prev_cursor should return the same items as page 1
-        back_to_page1 = await RoleCursorCrud.cursor_paginate(
-            db_session,
-            cursor=page2.pagination.prev_cursor,
-            items_per_page=5,
-            schema=RoleRead,
+        # Decode prev_cursor and compare to first item's id
+        decoded = json.loads(
+            base64.b64decode(page2.pagination.prev_cursor.encode()).decode()
        )
-        assert isinstance(back_to_page1.pagination, CursorPagination)
-        assert [r.id for r in back_to_page1.data] == [r.id for r in page1.data]
-        assert back_to_page1.pagination.prev_cursor is None
-
-    @pytest.mark.anyio
-    async def test_prev_cursor_empty_result_when_no_items_before(
-        self, db_session: AsyncSession
-    ):
-        """Going backward past the first item returns an empty page."""
-        from fastapi_toolsets.crud.factory import _encode_cursor
-        from fastapi_toolsets.schemas import CursorPagination
-
-        await IntRoleCursorCrud.create(db_session, IntRoleCreate(name="role00"))
-
-        page1 = await IntRoleCursorCrud.cursor_paginate(
-            db_session, items_per_page=5, schema=IntRoleRead
-        )
-        assert isinstance(page1.pagination, CursorPagination)
-
-        # Manually craft a backward cursor before any existing id
-        before_all = _encode_cursor(0, direction=_CursorDirection.PREV)
-        empty = await IntRoleCursorCrud.cursor_paginate(
-            db_session, cursor=before_all, items_per_page=5, schema=IntRoleRead
-        )
-
-        assert isinstance(empty.pagination, CursorPagination)
-        assert empty.data == []
-        assert empty.pagination.next_cursor is None
-        assert empty.pagination.prev_cursor is None
-
-    @pytest.mark.anyio
-    async def test_prev_cursor_set_when_more_pages_behind(
-        self, db_session: AsyncSession
-    ):
-        """Going backward on page 2 (of 3) still exposes a prev_cursor for page 1."""
-        for i in range(9):
-            await RoleCrud.create(db_session, RoleCreate(name=f"role{i:02d}"))
-
-        from fastapi_toolsets.schemas import CursorPagination
-
-        page1 = await RoleCursorCrud.cursor_paginate(
-            db_session, items_per_page=3, schema=RoleRead
-        )
-        assert isinstance(page1.pagination, CursorPagination)
-        page2 = await RoleCursorCrud.cursor_paginate(
-            db_session,
-            cursor=page1.pagination.next_cursor,
-            items_per_page=3,
-            schema=RoleRead,
-        )
-        assert isinstance(page2.pagination, CursorPagination)
-        page3 = await RoleCursorCrud.cursor_paginate(
-            db_session,
-            cursor=page2.pagination.next_cursor,
-            items_per_page=3,
-            schema=RoleRead,
-        )
-        assert isinstance(page3.pagination, CursorPagination)
-        assert page3.pagination.prev_cursor is not None
-
-        # Going back to page 2 should still have a prev_cursor pointing at page 1
-        back_to_page2 = await RoleCursorCrud.cursor_paginate(
-            db_session,
-            cursor=page3.pagination.prev_cursor,
-            items_per_page=3,
-            schema=RoleRead,
-        )
-        assert isinstance(back_to_page2.pagination, CursorPagination)
-        assert [r.id for r in back_to_page2.data] == [r.id for r in page2.data]
-        assert back_to_page2.pagination.prev_cursor is not None
+        first_item_id = str(page2.data[0].id)
+        assert decoded == first_item_id


 class TestCursorPaginateWithSearch:
@@ -2747,89 +2289,3 @@ class TestCursorPaginateColumnTypes:
        page1_ids = {p.id for p in page1.data}
        page2_ids = {p.id for p in page2.data}
        assert page1_ids.isdisjoint(page2_ids)
-
-
-class TestPaginate:
-    """Tests for the unified paginate() method."""
-
-    @pytest.mark.anyio
-    async def test_offset_pagination(self, db_session: AsyncSession):
-        """paginate() with OFFSET returns OffsetPaginatedResponse."""
-        from fastapi_toolsets.schemas import OffsetPagination
-
-        await RoleCrud.create(db_session, RoleCreate(name="admin"))
-        await RoleCrud.create(db_session, RoleCreate(name="user"))
-
-        result = await RoleCrud.paginate(
-            db_session,
-            pagination_type=PaginationType.OFFSET,
-            schema=RoleRead,
-        )
-
-        assert isinstance(result.pagination, OffsetPagination)
-        assert result.pagination_type == PaginationType.OFFSET
-
-    @pytest.mark.anyio
-    async def test_cursor_pagination(self, db_session: AsyncSession):
-        """paginate() with CURSOR returns CursorPaginatedResponse."""
-        from fastapi_toolsets.schemas import CursorPagination
-
-        await RoleCursorCrud.create(db_session, RoleCreate(name="admin"))
-
-        result = await RoleCursorCrud.paginate(
-            db_session,
-            pagination_type=PaginationType.CURSOR,
-            schema=RoleRead,
-        )
-
-        assert isinstance(result.pagination, CursorPagination)
-        assert result.pagination_type == PaginationType.CURSOR
-
-    @pytest.mark.anyio
-    async def test_invalid_items_per_page_raises(self, db_session: AsyncSession):
-        """paginate() raises ValueError when items_per_page < 1."""
-        with pytest.raises(ValueError, match="items_per_page"):
-            await RoleCrud.paginate(
-                db_session,
-                pagination_type=PaginationType.OFFSET,
-                items_per_page=0,
-                schema=RoleRead,
-            )
-
-    @pytest.mark.anyio
-    async def test_invalid_page_raises(self, db_session: AsyncSession):
-        """paginate() raises ValueError when page < 1 for offset pagination."""
-        with pytest.raises(ValueError, match="page"):
-            await RoleCrud.paginate(
-                db_session,
-                pagination_type=PaginationType.OFFSET,
-                page=0,
-                schema=RoleRead,
-            )
-
-    @pytest.mark.anyio
-    async def test_unknown_pagination_type_raises(self, db_session: AsyncSession):
-        """paginate() raises ValueError for unknown pagination_type."""
-        with pytest.raises(ValueError, match="Unknown pagination_type"):
-            await RoleCrud.paginate(
-                db_session,
-                pagination_type="unknown",
-                schema=RoleRead,
-            )  # type: ignore[no-matching-overload]  # ty:ignore[no-matching-overload]
-
-    @pytest.mark.anyio
-    async def test_offset_include_total_false(self, db_session: AsyncSession):
-        """paginate() passes include_total=False through to offset_paginate."""
-        from fastapi_toolsets.schemas import OffsetPagination
-
-        await RoleCrud.create(db_session, RoleCreate(name="admin"))
-
-        result = await RoleCrud.paginate(
-            db_session,
-            pagination_type=PaginationType.OFFSET,
-            include_total=False,
-            schema=RoleRead,
-        )
-
-        assert isinstance(result.pagination, OffsetPagination)
-        assert result.pagination.total_count is None
--- a/tests/test_crud_search.py
+++ b/tests/test_crud_search.py
--- a/tests/test_db.py
+++ b/tests/test_db.py
@@ -68,55 +68,6 @@ class TestCreateDbDependency:
                await conn.run_sync(Base.metadata.drop_all)
            await engine.dispose()

-    @pytest.mark.anyio
-    async def test_in_transaction_on_yield(self):
-        """Session is already in a transaction when the endpoint body starts."""
-        engine = create_async_engine(DATABASE_URL, echo=False)
-        session_factory = async_sessionmaker(engine, expire_on_commit=False)
-        get_db = create_db_dependency(session_factory)
-
-        async for session in get_db():
-            assert session.in_transaction()
-            break
-
-        await engine.dispose()
-
-    @pytest.mark.anyio
-    async def test_update_after_lock_tables_is_persisted(self):
-        """Changes made after lock_tables exits (before endpoint returns) are committed.
-
-        Regression: without the auto-begin fix, lock_tables would start and commit a
-        real outer transaction, leaving the session idle. Any modifications after that
-        point were silently dropped.
-        """
-        engine = create_async_engine(DATABASE_URL, echo=False)
-        session_factory = async_sessionmaker(engine, expire_on_commit=False)
-
-        async with engine.begin() as conn:
-            await conn.run_sync(Base.metadata.create_all)
-
-        try:
-            get_db = create_db_dependency(session_factory)
-
-            async for session in get_db():
-                async with lock_tables(session, [Role]):
-                    role = Role(name="lock_then_update")
-                    session.add(role)
-                    await session.flush()
-                # lock_tables has exited — outer transaction must still be open
-                assert session.in_transaction()
-                role.name = "updated_after_lock"
-
-            async with session_factory() as verify:
-                result = await RoleCrud.first(
-                    verify, [Role.name == "updated_after_lock"]
-                )
-                assert result is not None
-        finally:
-            async with engine.begin() as conn:
-                await conn.run_sync(Base.metadata.drop_all)
-            await engine.dispose()
-

 class TestCreateDbContext:
    """Tests for create_db_context."""
@@ -412,8 +363,7 @@ class TestCreateDatabase:
            .set(database="test_create_db_general")
            .render_as_string(hide_password=False)
        )
-        expected_db = make_url(target_url).database
-        assert expected_db is not None
+        expected_db: str = make_url(target_url).database  # type: ignore[assignment]

        engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
        try:
--- a/tests/test_dependencies.py
+++ b/tests/test_dependencies.py
@@ -3,42 +3,20 @@
 import inspect
 import uuid
 from collections.abc import AsyncGenerator
-from typing import Annotated, Any, cast
+from typing import Any, cast

 import pytest
 from fastapi.params import Depends
 from sqlalchemy.ext.asyncio import AsyncSession

-from fastapi_toolsets.dependencies import (
-    BodyDependency,
-    PathDependency,
-    _unwrap_session_dep,
-)
+from fastapi_toolsets.dependencies import BodyDependency, PathDependency

 from .conftest import Role, RoleCreate, RoleCrud, User


 async def mock_get_db() -> AsyncGenerator[AsyncSession, None]:
    """Mock session dependency for testing."""
-    yield None  # type: ignore[misc]  # ty:ignore[invalid-yield]
-
-
-MockSessionDep = Annotated[AsyncSession, Depends(mock_get_db)]
-
-
-class TestUnwrapSessionDep:
-    def test_plain_callable_returned_as_is(self):
-        """Plain callable is returned unchanged."""
-        assert _unwrap_session_dep(mock_get_db) is mock_get_db
-
-    def test_annotated_with_depends_unwrapped(self):
-        """Annotated form with Depends is unwrapped to the plain callable."""
-        assert _unwrap_session_dep(MockSessionDep) is mock_get_db
-
-    def test_annotated_without_depends_returned_as_is(self):
-        """Annotated form with no Depends falls back to returning session_dep as-is."""
-        annotated_no_dep = Annotated[AsyncSession, "not_a_depends"]
-        assert _unwrap_session_dep(annotated_no_dep) is annotated_no_dep
+    yield None


 class TestPathDependency:
@@ -117,39 +95,6 @@ class TestPathDependency:
        assert result.id == role.id
        assert result.name == "test_role"

-    def test_annotated_session_dep_returns_depends_instance(self):
-        """PathDependency accepts Annotated[AsyncSession, Depends(...)] form."""
-        dep = PathDependency(Role, Role.id, session_dep=MockSessionDep)
-        assert isinstance(dep, Depends)
-
-    def test_annotated_session_dep_signature(self):
-        """PathDependency with Annotated session_dep produces a valid signature."""
-        dep = cast(Any, PathDependency(Role, Role.id, session_dep=MockSessionDep))
-        sig = inspect.signature(dep.dependency)
-
-        assert "role_id" in sig.parameters
-        assert "session" in sig.parameters
-        assert isinstance(sig.parameters["session"].default, Depends)
-
-    def test_annotated_session_dep_unwraps_callable(self):
-        """PathDependency with Annotated form uses the underlying callable, not the Annotated type."""
-        dep = cast(Any, PathDependency(Role, Role.id, session_dep=MockSessionDep))
-        sig = inspect.signature(dep.dependency)
-
-        inner_dep = sig.parameters["session"].default
-        assert inner_dep.dependency is mock_get_db
-
-    @pytest.mark.anyio
-    async def test_annotated_session_dep_fetches_object(self, db_session):
-        """PathDependency with Annotated session_dep correctly fetches object from database."""
-        role = await RoleCrud.create(db_session, RoleCreate(name="annotated_role"))
-
-        dep = cast(Any, PathDependency(Role, Role.id, session_dep=MockSessionDep))
-        result = await dep.dependency(session=db_session, role_id=role.id)
-
-        assert result.id == role.id
-        assert result.name == "annotated_role"
-

 class TestBodyDependency:
    """Tests for BodyDependency factory."""
@@ -239,39 +184,3 @@ class TestBodyDependency:

        assert result.id == role.id
        assert result.name == "body_test_role"
-
-    def test_annotated_session_dep_returns_depends_instance(self):
-        """BodyDependency accepts Annotated[AsyncSession, Depends(...)] form."""
-        dep = BodyDependency(
-            Role, Role.id, session_dep=MockSessionDep, body_field="role_id"
-        )
-        assert isinstance(dep, Depends)
-
-    def test_annotated_session_dep_unwraps_callable(self):
-        """BodyDependency with Annotated form uses the underlying callable, not the Annotated type."""
-        dep = cast(
-            Any,
-            BodyDependency(
-                Role, Role.id, session_dep=MockSessionDep, body_field="role_id"
-            ),
-        )
-        sig = inspect.signature(dep.dependency)
-
-        inner_dep = sig.parameters["session"].default
-        assert inner_dep.dependency is mock_get_db
-
-    @pytest.mark.anyio
-    async def test_annotated_session_dep_fetches_object(self, db_session):
-        """BodyDependency with Annotated session_dep correctly fetches object from database."""
-        role = await RoleCrud.create(db_session, RoleCreate(name="body_annotated_role"))
-
-        dep = cast(
-            Any,
-            BodyDependency(
-                Role, Role.id, session_dep=MockSessionDep, body_field="role_id"
-            ),
-        )
-        result = await dep.dependency(session=db_session, role_id=role.id)
-
-        assert result.id == role.id
-        assert result.name == "body_annotated_role"
--- a/tests/test_example_pagination_search.py
+++ b/tests/test_example_pagination_search.py
@@ -10,13 +10,12 @@ import datetime
 import pytest
 from fastapi import FastAPI
 from httpx import ASGITransport, AsyncClient
-from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine

 from docs_src.examples.pagination_search.db import get_db
 from docs_src.examples.pagination_search.models import Article, Base, Category
 from docs_src.examples.pagination_search.routes import router
 from fastapi_toolsets.exceptions import init_exceptions_handlers
-from fastapi_toolsets.pytest import create_db_session

 from .conftest import DATABASE_URL

@@ -36,8 +35,20 @@ def build_app(session: AsyncSession) -> FastAPI:
@pytest.fixture(scope="function")
 async def ex_db_session():
    """Isolated session for the example models (separate tables from conftest)."""
-    async with create_db_session(DATABASE_URL, Base) as session:
+    engine = create_async_engine(DATABASE_URL, echo=False)
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    session_factory = async_sessionmaker(engine, expire_on_commit=False)
+    session = session_factory()
+
+    try:
        yield session
+    finally:
+        await session.close()
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.drop_all)
+        await engine.dispose()


@pytest.fixture
@@ -97,7 +108,7 @@ class TestAppSessionDep:
        gen = get_db()
        session = await gen.__anext__()
        assert isinstance(session, AsyncSession)
-        await gen.aclose()
+        await session.close()


 class TestOffsetPagination:
@@ -182,7 +193,8 @@ class TestOffsetPagination:
        body = resp.json()
        fa = body["filter_attributes"]
        assert set(fa["status"]) == {"draft", "published"}
-        assert set(fa["category__name"]) == {"backend", "python"}
+        # "name" is unique across all facet fields — no prefix needed
+        assert set(fa["name"]) == {"backend", "python"}

    @pytest.mark.anyio
    async def test_filter_attributes_scoped_to_filter(
@@ -381,105 +393,3 @@ class TestCursorSorting:
        body = resp.json()
        assert body["error_code"] == "SORT-422"
        assert body["status"] == "FAIL"
-
-
-class TestPaginateUnified:
-    """Tests for the unified GET /articles/ endpoint using paginate()."""
-
-    @pytest.mark.anyio
-    async def test_defaults_to_offset_pagination(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """Without pagination_type, defaults to offset pagination."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination_type"] == "offset"
-        assert "total_count" in body["pagination"]
-        assert body["pagination"]["total_count"] == 3
-
-    @pytest.mark.anyio
-    async def test_explicit_offset_pagination(self, client: AsyncClient, ex_db_session):
-        """pagination_type=offset returns OffsetPagination metadata."""
-        await seed(ex_db_session)
-
-        resp = await client.get(
-            "/articles/?pagination_type=offset&page=1&items_per_page=2"
-        )
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination_type"] == "offset"
-        assert body["pagination"]["total_count"] == 3
-        assert body["pagination"]["page"] == 1
-        assert body["pagination"]["has_more"] is True
-        assert len(body["data"]) == 2
-
-    @pytest.mark.anyio
-    async def test_cursor_pagination_type(self, client: AsyncClient, ex_db_session):
-        """pagination_type=cursor returns CursorPagination metadata."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/?pagination_type=cursor&items_per_page=2")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination_type"] == "cursor"
-        assert "next_cursor" in body["pagination"]
-        assert "total_count" not in body["pagination"]
-        assert body["pagination"]["has_more"] is True
-        assert len(body["data"]) == 2
-
-    @pytest.mark.anyio
-    async def test_cursor_pagination_navigate_pages(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """Cursor from first page can be used to fetch the next page."""
-        await seed(ex_db_session)
-
-        first = await client.get("/articles/?pagination_type=cursor&items_per_page=2")
-        assert first.status_code == 200
-        first_body = first.json()
-        next_cursor = first_body["pagination"]["next_cursor"]
-        assert next_cursor is not None
-
-        second = await client.get(
-            f"/articles/?pagination_type=cursor&items_per_page=2&cursor={next_cursor}"
-        )
-        assert second.status_code == 200
-        second_body = second.json()
-        assert second_body["pagination_type"] == "cursor"
-        assert second_body["pagination"]["has_more"] is False
-        assert len(second_body["data"]) == 1
-
-    @pytest.mark.anyio
-    async def test_cursor_pagination_with_search(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """paginate() with cursor type respects search parameter."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/?pagination_type=cursor&search=fastapi")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination_type"] == "cursor"
-        assert len(body["data"]) == 1
-        assert body["data"][0]["title"] == "FastAPI tips"
-
-    @pytest.mark.anyio
-    async def test_offset_pagination_with_filter(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """paginate() with offset type respects filter_by parameter."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/?pagination_type=offset&status=published")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination_type"] == "offset"
-        assert body["pagination"]["total_count"] == 2
--- a/tests/test_fixtures.py
+++ b/tests/test_fixtures.py
@@ -1,7 +1,6 @@
 """Tests for fastapi_toolsets.fixtures module."""

 import uuid
-from enum import Enum

 import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -14,22 +13,10 @@ from fastapi_toolsets.fixtures import (
    load_fixtures,
    load_fixtures_by_context,
 )
-from fastapi_toolsets.fixtures.utils import _get_primary_key, _instance_to_dict

-from .conftest import IntRole, Permission, Role, RoleCreate, RoleCrud, User, UserCrud
+from fastapi_toolsets.fixtures.utils import _get_primary_key

-
-class AppContext(str, Enum):
-    """Example user-defined str+Enum context."""
-
-    STAGING = "staging"
-    DEMO = "demo"
-
-
-class PlainEnumContext(Enum):
-    """Example user-defined plain Enum context (no str mixin)."""
-
-    STAGING = "staging"
+from .conftest import IntRole, Permission, Role, User


 class TestContext:
@@ -52,86 +39,6 @@ class TestContext:
        assert Context.TESTING.value == "testing"


-class TestCustomEnumContext:
-    """Custom Enum types are accepted wherever Context/str are expected."""
-
-    def test_cannot_subclass_context_with_members(self):
-        """Python prohibits extending an Enum that already has members."""
-        with pytest.raises(TypeError):
-
-            class MyContext(Context):  # noqa: F841  # ty: ignore[subclass-of-final-class]
-                STAGING = "staging"
-
-    def test_custom_enum_values_interchangeable_with_context(self):
-        """A custom enum with the same .value as a built-in Context member is
-        treated as the same context — fixtures registered under one are found
-        by the other."""
-
-        class AppContextFull(str, Enum):
-            BASE = "base"
-            STAGING = "staging"
-
-        registry = FixtureRegistry()
-
-        @registry.register(contexts=[Context.BASE])
-        def roles():
-            return []
-
-        # AppContextFull.BASE has value "base" — same as Context.BASE
-        fixtures = registry.get_by_context(AppContextFull.BASE)
-        assert len(fixtures) == 1
-
-    def test_custom_enum_registry_default_contexts(self):
-        """FixtureRegistry(contexts=[...]) accepts a custom Enum."""
-        registry = FixtureRegistry(contexts=[AppContext.STAGING])
-
-        @registry.register
-        def data():
-            return []
-
-        fixture = registry.get("data")
-        assert fixture.contexts == ["staging"]
-
-    def test_custom_enum_resolve_context_dependencies(self):
-        """resolve_context_dependencies accepts a custom Enum context."""
-        registry = FixtureRegistry()
-
-        @registry.register(contexts=[AppContext.STAGING])
-        def staging_roles():
-            return []
-
-        order = registry.resolve_context_dependencies(AppContext.STAGING)
-        assert "staging_roles" in order
-
-    @pytest.mark.anyio
-    async def test_custom_enum_e2e(self, db_session: AsyncSession):
-        """End-to-end: register with custom Enum, load with the same Enum."""
-        registry = FixtureRegistry()
-
-        @registry.register(contexts=[AppContext.STAGING])
-        def staging_roles():
-            return [Role(id=uuid.uuid4(), name="staging-admin")]
-
-        result = await load_fixtures_by_context(
-            db_session, registry, AppContext.STAGING
-        )
-        assert len(result["staging_roles"]) == 1
-
-    @pytest.mark.anyio
-    async def test_plain_enum_e2e(self, db_session: AsyncSession):
-        """End-to-end: register with plain Enum, load with the same Enum."""
-        registry = FixtureRegistry()
-
-        @registry.register(contexts=[PlainEnumContext.STAGING])
-        def staging_roles():
-            return [Role(id=uuid.uuid4(), name="plain-staging-admin")]
-
-        result = await load_fixtures_by_context(
-            db_session, registry, PlainEnumContext.STAGING
-        )
-        assert len(result["staging_roles"]) == 1
-
-
 class TestLoadStrategy:
    """Tests for LoadStrategy enum."""

@@ -500,37 +407,6 @@ class TestDependencyResolution:
        with pytest.raises(ValueError, match="Circular dependency"):
            registry.resolve_dependencies("a")

-    def test_resolve_raises_for_unknown_dependency(self):
-        """KeyError when depends_on references an unregistered fixture."""
-        registry = FixtureRegistry()
-
-        @registry.register(depends_on=["ghost"])
-        def users():
-            return []
-
-        with pytest.raises(KeyError, match="ghost"):
-            registry.resolve_dependencies("users")
-
-    def test_resolve_deduplicates_shared_depends_on_across_variants(self):
-        """A dep shared by two same-name variants appears only once in the order."""
-        registry = FixtureRegistry()
-
-        @registry.register(contexts=[Context.BASE])
-        def roles():
-            return []
-
-        @registry.register(depends_on=["roles"], contexts=[Context.BASE])
-        def items():
-            return []
-
-        @registry.register(depends_on=["roles"], contexts=[Context.TESTING])
-        def items():  # noqa: F811
-            return []
-
-        order = registry.resolve_dependencies("items")
-        assert order.count("roles") == 1
-        assert order.index("roles") < order.index("items")
-
    def test_resolve_context_dependencies(self):
        """Resolve all fixtures for a context with dependencies."""
        registry = FixtureRegistry()
@@ -571,6 +447,8 @@ class TestLoadFixtures:
        assert "roles" in result
        assert len(result["roles"]) == 2

+        from .conftest import RoleCrud
+
        count = await RoleCrud.count(db_session)
        assert count == 2

@@ -601,6 +479,8 @@ class TestLoadFixtures:
        assert "roles" in result
        assert "users" in result

+        from .conftest import RoleCrud, UserCrud
+
        assert await RoleCrud.count(db_session) == 1
        assert await UserCrud.count(db_session) == 1

@@ -617,55 +497,11 @@ class TestLoadFixtures:
        await load_fixtures(db_session, registry, "roles", strategy=LoadStrategy.MERGE)
        await load_fixtures(db_session, registry, "roles", strategy=LoadStrategy.MERGE)

+        from .conftest import RoleCrud
+
        count = await RoleCrud.count(db_session)
        assert count == 1

-    @pytest.mark.anyio
-    async def test_merge_does_not_overwrite_omitted_nullable_columns(
-        self, db_session: AsyncSession
-    ):
-        """MERGE must not clear nullable columns that the fixture didn't set.
-
-        When a fixture omits a nullable column (e.g. role_id or notes), a re-merge
-        must leave the existing DB value untouched — not overwrite it with NULL.
-        """
-        registry = FixtureRegistry()
-        admin = await RoleCrud.create(db_session, RoleCreate(name="admin"))
-        uid = uuid.uuid4()
-
-        # First load: user has role_id and notes set
-        @registry.register
-        def users():
-            return [
-                User(
-                    id=uid,
-                    username="alice",
-                    email="a@test.com",
-                    role_id=admin.id,
-                    notes="original",
-                )
-            ]
-
-        await load_fixtures(db_session, registry, "users", strategy=LoadStrategy.MERGE)
-
-        # Second load: fixture omits role_id and notes
-        registry2 = FixtureRegistry()
-
-        @registry2.register
-        def users():  # noqa: F811
-            return [User(id=uid, username="alice-updated", email="a@test.com")]
-
-        await load_fixtures(db_session, registry2, "users", strategy=LoadStrategy.MERGE)
-
-        from sqlalchemy import select
-
-        row = (
-            await db_session.execute(select(User).where(User.id == uid))
-        ).scalar_one()
-        assert row.username == "alice-updated"  # updated column changed
-        assert row.role_id == admin.id  # omitted → preserved
-        assert row.notes == "original"  # omitted → preserved
-
    @pytest.mark.anyio
    async def test_load_with_skip_existing_strategy(self, db_session: AsyncSession):
        """Load fixtures with SKIP_EXISTING strategy."""
@@ -690,6 +526,8 @@ class TestLoadFixtures:
            db_session, registry, "roles", strategy=LoadStrategy.SKIP_EXISTING
        )

+        from .conftest import RoleCrud
+
        role = await RoleCrud.first(db_session, [Role.id == role_id])
        assert role is not None
        assert role.name == "original"
@@ -715,6 +553,8 @@ class TestLoadFixtures:
        assert "roles" in result
        assert len(result["roles"]) == 2

+        from .conftest import RoleCrud
+
        count = await RoleCrud.count(db_session)
        assert count == 2

@@ -754,6 +594,8 @@ class TestLoadFixtures:
        assert "roles" in result
        assert "other_roles" in result

+        from .conftest import RoleCrud
+
        count = await RoleCrud.count(db_session)
        assert count == 2

@@ -818,6 +660,8 @@ class TestLoadFixturesByContext:

        await load_fixtures_by_context(db_session, registry, Context.BASE)

+        from .conftest import RoleCrud
+
        count = await RoleCrud.count(db_session)
        assert count == 1

@@ -844,6 +688,8 @@ class TestLoadFixturesByContext:
            db_session, registry, Context.BASE, Context.TESTING
        )

+        from .conftest import RoleCrud
+
        count = await RoleCrud.count(db_session)
        assert count == 2

@@ -871,6 +717,8 @@ class TestLoadFixturesByContext:

        await load_fixtures_by_context(db_session, registry, Context.TESTING)

+        from .conftest import RoleCrud, UserCrud
+
        assert await RoleCrud.count(db_session) == 1
        assert await UserCrud.count(db_session) == 1

@@ -965,511 +813,3 @@ class TestGetPrimaryKey:
        instance = Permission(subject="post")  # action is None
        pk = _get_primary_key(instance)
        assert pk is None
-
-
-class TestRegistryGetVariants:
-    """Tests for FixtureRegistry.get and get_variants edge cases."""
-
-    def test_get_raises_value_error_for_multi_variant(self):
-        """get() raises ValueError when the fixture has multiple context variants."""
-        registry = FixtureRegistry()
-
-        @registry.register(contexts=[Context.BASE])
-        def items():
-            return []
-
-        @registry.register(contexts=[Context.TESTING])
-        def items():  # noqa: F811
-            return []
-
-        with pytest.raises(ValueError, match="get_variants"):
-            registry.get("items")
-
-    def test_get_variants_raises_key_error_for_unknown(self):
-        """get_variants() raises KeyError for an unregistered name."""
-        registry = FixtureRegistry()
-        with pytest.raises(KeyError, match="not found"):
-            registry.get_variants("no_such_fixture")
-
-
-class TestInstanceToDict:
-    """Unit tests for the _instance_to_dict helper."""
-
-    def test_explicit_values_included(self):
-        """All explicitly set column values appear in the result."""
-        role_id = uuid.uuid4()
-        instance = Role(id=role_id, name="admin")
-        d = _instance_to_dict(instance)
-        assert d["id"] == role_id
-        assert d["name"] == "admin"
-
-    def test_callable_default_none_excluded(self):
-        """A column whose value is None but has a callable Python-side default
-        (e.g. ``default=uuid.uuid4``) is excluded so the DB generates it."""
-        instance = Role(id=None, name="admin")
-        d = _instance_to_dict(instance)
-        assert "id" not in d
-        assert d["name"] == "admin"
-
-    def test_autoincrement_none_excluded(self):
-        """A column whose value is None but has autoincrement=True is excluded
-        so the DB generates the value via its sequence."""
-        instance = IntRole(id=None, name="admin")
-        d = _instance_to_dict(instance)
-        assert "id" not in d
-        assert d["name"] == "admin"
-
-    def test_nullable_none_included(self):
-        """None on a nullable column with no default is kept (explicit NULL)."""
-        instance = User(id=uuid.uuid4(), username="u", email="e@e.com", role_id=None)
-        d = _instance_to_dict(instance)
-        assert "role_id" in d
-        assert d["role_id"] is None
-
-    def test_nullable_str_no_default_omitted_not_in_dict(self):
-        """Mapped[str | None] with no default, not provided in constructor, is absent from dict."""
-        instance = User(id=uuid.uuid4(), username="u", email="e@e.com")
-        d = _instance_to_dict(instance)
-        assert "notes" not in d
-
-    def test_nullable_str_no_default_explicit_none_included(self):
-        """Mapped[str | None] with no default, explicitly set to None, is included as NULL."""
-        instance = User(id=uuid.uuid4(), username="u", email="e@e.com", notes=None)
-        d = _instance_to_dict(instance)
-        assert "notes" in d
-        assert d["notes"] is None
-
-    def test_nullable_str_no_default_with_value_included(self):
-        """Mapped[str | None] with no default and a value set is included normally."""
-        instance = User(id=uuid.uuid4(), username="u", email="e@e.com", notes="hello")
-        d = _instance_to_dict(instance)
-        assert d["notes"] == "hello"
-
-    @pytest.mark.anyio
-    async def test_nullable_str_no_default_insert_roundtrip(
-        self, db_session: AsyncSession
-    ):
-        """Fixture loading works for models with Mapped[str | None] (no default).
-
-        Both the omitted-value (→ NULL) and explicit-None paths must insert without error.
-        """
-        registry = FixtureRegistry()
-
-        uid_a = uuid.uuid4()
-        uid_b = uuid.uuid4()
-        uid_c = uuid.uuid4()
-
-        @registry.register
-        def users():
-            return [
-                User(
-                    id=uid_a, username="no_notes", email="a@test.com"
-                ),  # notes omitted
-                User(
-                    id=uid_b, username="null_notes", email="b@test.com", notes=None
-                ),  # explicit None
-                User(
-                    id=uid_c, username="has_notes", email="c@test.com", notes="hi"
-                ),  # value set
-            ]
-
-        result = await load_fixtures(db_session, registry, "users")
-
-        from sqlalchemy import select
-
-        rows = (
-            (await db_session.execute(select(User).order_by(User.username)))
-            .scalars()
-            .all()
-        )
-        by_username = {r.username: r for r in rows}
-
-        assert by_username["no_notes"].notes is None
-        assert by_username["null_notes"].notes is None
-        assert by_username["has_notes"].notes == "hi"
-        assert len(result["users"]) == 3
-
-
-class TestBatchMergeNonPkColumns:
-    """Batch MERGE on a model with no non-PK columns (PK-only table)."""
-
-    @pytest.mark.anyio
-    async def test_merge_pk_only_model(self, db_session: AsyncSession):
-        """MERGE strategy on a PK-only model uses on_conflict_do_nothing."""
-        registry = FixtureRegistry()
-
-        @registry.register
-        def permissions():
-            return [
-                Permission(subject="post", action="read"),
-                Permission(subject="post", action="write"),
-            ]
-
-        result = await load_fixtures(
-            db_session, registry, "permissions", strategy=LoadStrategy.MERGE
-        )
-        assert len(result["permissions"]) == 2
-
-        # Run again — conflicts are silently ignored.
-        result2 = await load_fixtures(
-            db_session, registry, "permissions", strategy=LoadStrategy.MERGE
-        )
-        assert len(result2["permissions"]) == 2
-
-
-class TestBatchNullableColumnEdgeCases:
-    """Deep tests for nullable column handling during batch import."""
-
-    @pytest.mark.anyio
-    async def test_insert_batch_mixed_nullable_fk(self, db_session: AsyncSession):
-        """INSERT batch where some rows set a nullable FK and others don't.
-
-        After normalization the omitted role_id becomes None.  For INSERT this
-        is acceptable — both rows should insert successfully with the correct
-        values (one with FK, one with NULL).
-        """
-        registry = FixtureRegistry()
-        admin = await RoleCrud.create(db_session, RoleCreate(name="admin"))
-        uid1 = uuid.uuid4()
-        uid2 = uuid.uuid4()
-
-        @registry.register
-        def users():
-            return [
-                User(
-                    id=uid1, username="with_role", email="a@test.com", role_id=admin.id
-                ),
-                User(id=uid2, username="no_role", email="b@test.com"),
-            ]
-
-        await load_fixtures(db_session, registry, "users", strategy=LoadStrategy.INSERT)
-
-        from sqlalchemy import select
-
-        rows = {
-            r.username: r
-            for r in (await db_session.execute(select(User))).scalars().all()
-        }
-        assert rows["with_role"].role_id == admin.id
-        assert rows["no_role"].role_id is None
-
-    @pytest.mark.anyio
-    async def test_insert_batch_mixed_nullable_notes(self, db_session: AsyncSession):
-        """INSERT batch where some rows have notes and others don't.
-
-        Ensures normalization doesn't break the insert and that each row gets
-        the intended value.
-        """
-        registry = FixtureRegistry()
-        uid1 = uuid.uuid4()
-        uid2 = uuid.uuid4()
-        uid3 = uuid.uuid4()
-
-        @registry.register
-        def users():
-            return [
-                User(
-                    id=uid1,
-                    username="has_notes",
-                    email="a@test.com",
-                    notes="important",
-                ),
-                User(id=uid2, username="no_notes", email="b@test.com"),
-                User(id=uid3, username="null_notes", email="c@test.com", notes=None),
-            ]
-
-        await load_fixtures(db_session, registry, "users", strategy=LoadStrategy.INSERT)
-
-        from sqlalchemy import select
-
-        rows = {
-            r.username: r
-            for r in (await db_session.execute(select(User))).scalars().all()
-        }
-        assert rows["has_notes"].notes == "important"
-        assert rows["no_notes"].notes is None
-        assert rows["null_notes"].notes is None
-
-    @pytest.mark.anyio
-    async def test_merge_batch_mixed_nullable_does_not_overwrite(
-        self, db_session: AsyncSession
-    ):
-        """MERGE batch where one row sets a nullable column and another omits it.
-
-        If both rows already exist in DB, the row that omits the column must
-        NOT have its existing value overwritten with NULL.
-
-        This is the core normalization bug: _normalize_rows fills missing keys
-        with None, and then MERGE's SET clause includes that column for ALL rows.
-        """
-        from sqlalchemy import select
-
-        admin = await RoleCrud.create(db_session, RoleCreate(name="admin"))
-        uid1 = uuid.uuid4()
-        uid2 = uuid.uuid4()
-
-        # Pre-populate: both users have role_id and notes
-        registry_initial = FixtureRegistry()
-
-        @registry_initial.register
-        def users():
-            return [
-                User(
-                    id=uid1,
-                    username="alice",
-                    email="a@test.com",
-                    role_id=admin.id,
-                    notes="alice notes",
-                ),
-                User(
-                    id=uid2,
-                    username="bob",
-                    email="b@test.com",
-                    role_id=admin.id,
-                    notes="bob notes",
-                ),
-            ]
-
-        await load_fixtures(
-            db_session, registry_initial, "users", strategy=LoadStrategy.INSERT
-        )
-
-        # Re-merge: alice updates notes, bob omits notes entirely
-        registry_merge = FixtureRegistry()
-
-        @registry_merge.register
-        def users():  # noqa: F811
-            return [
-                User(
-                    id=uid1,
-                    username="alice",
-                    email="a@test.com",
-                    role_id=admin.id,
-                    notes="updated",
-                ),
-                User(
-                    id=uid2,
-                    username="bob",
-                    email="b@test.com",
-                    role_id=admin.id,
-                ),  # notes omitted
-            ]
-
-        await load_fixtures(
-            db_session, registry_merge, "users", strategy=LoadStrategy.MERGE
-        )
-
-        rows = {
-            r.username: r
-            for r in (await db_session.execute(select(User))).scalars().all()
-        }
-        assert rows["alice"].notes == "updated"
-        # Bob's notes must be preserved, NOT overwritten with NULL
-        assert rows["bob"].notes == "bob notes"
-
-    @pytest.mark.anyio
-    async def test_merge_batch_mixed_nullable_fk_preserves_existing(
-        self, db_session: AsyncSession
-    ):
-        """MERGE batch where one row sets role_id and another omits it.
-
-        The row that omits role_id must keep its existing DB value.
-        """
-        from sqlalchemy import select
-
-        admin = await RoleCrud.create(db_session, RoleCreate(name="admin"))
-        editor = await RoleCrud.create(db_session, RoleCreate(name="editor"))
-        uid1 = uuid.uuid4()
-        uid2 = uuid.uuid4()
-
-        # Pre-populate
-        registry_initial = FixtureRegistry()
-
-        @registry_initial.register
-        def users():
-            return [
-                User(
-                    id=uid1,
-                    username="alice",
-                    email="a@test.com",
-                    role_id=admin.id,
-                ),
-                User(
-                    id=uid2,
-                    username="bob",
-                    email="b@test.com",
-                    role_id=editor.id,
-                ),
-            ]
-
-        await load_fixtures(
-            db_session, registry_initial, "users", strategy=LoadStrategy.INSERT
-        )
-
-        # Re-merge: alice changes role, bob omits role_id
-        registry_merge = FixtureRegistry()
-
-        @registry_merge.register
-        def users():  # noqa: F811
-            return [
-                User(
-                    id=uid1,
-                    username="alice",
-                    email="a@test.com",
-                    role_id=editor.id,
-                ),
-                User(id=uid2, username="bob", email="b@test.com"),  # role_id omitted
-            ]
-
-        await load_fixtures(
-            db_session, registry_merge, "users", strategy=LoadStrategy.MERGE
-        )
-
-        rows = {
-            r.username: r
-            for r in (await db_session.execute(select(User))).scalars().all()
-        }
-        assert rows["alice"].role_id == editor.id  # updated
-        assert rows["bob"].role_id == editor.id  # must be preserved, NOT NULL
-
-    @pytest.mark.anyio
-    async def test_insert_batch_mixed_pk_presence(self, db_session: AsyncSession):
-        """INSERT batch where some rows have explicit PK and others rely on
-        the callable default (uuid.uuid4).
-
-        Normalization adds the PK key with None to rows that omitted it,
-        which can cause NOT NULL violations on the PK column.
-        """
-        registry = FixtureRegistry()
-        explicit_id = uuid.uuid4()
-
-        @registry.register
-        def roles():
-            return [
-                Role(id=explicit_id, name="admin"),
-                Role(name="user"),  # PK omitted, relies on default=uuid.uuid4
-            ]
-
-        await load_fixtures(db_session, registry, "roles", strategy=LoadStrategy.INSERT)
-
-        from sqlalchemy import select
-
-        rows = (await db_session.execute(select(Role))).scalars().all()
-        assert len(rows) == 2
-        names = {r.name for r in rows}
-        assert names == {"admin", "user"}
-        # The "admin" row must have the explicit ID
-        admin = next(r for r in rows if r.name == "admin")
-        assert admin.id == explicit_id
-        # The "user" row must have a generated UUID (not None)
-        user = next(r for r in rows if r.name == "user")
-        assert user.id is not None
-
-    @pytest.mark.anyio
-    async def test_skip_existing_batch_mixed_nullable(self, db_session: AsyncSession):
-        """SKIP_EXISTING with mixed nullable columns inserts correctly.
-
-        Only new rows are inserted; existing rows are untouched regardless of
-        which columns the fixture provides.
-        """
-        from sqlalchemy import select
-
-        admin = await RoleCrud.create(db_session, RoleCreate(name="admin"))
-        uid1 = uuid.uuid4()
-        uid2 = uuid.uuid4()
-
-        # Pre-populate uid1 with notes
-        registry_initial = FixtureRegistry()
-
-        @registry_initial.register
-        def users():
-            return [
-                User(
-                    id=uid1,
-                    username="alice",
-                    email="a@test.com",
-                    role_id=admin.id,
-                    notes="keep me",
-                ),
-            ]
-
-        await load_fixtures(
-            db_session, registry_initial, "users", strategy=LoadStrategy.INSERT
-        )
-
-        # Load again with SKIP_EXISTING: uid1 already exists, uid2 is new
-        registry_skip = FixtureRegistry()
-
-        @registry_skip.register
-        def users():  # noqa: F811
-            return [
-                User(id=uid1, username="alice-updated", email="a@test.com"),  # exists
-                User(
-                    id=uid2,
-                    username="bob",
-                    email="b@test.com",
-                    notes="new user",
-                ),  # new
-            ]
-
-        result = await load_fixtures(
-            db_session, registry_skip, "users", strategy=LoadStrategy.SKIP_EXISTING
-        )
-        assert len(result["users"]) == 1  # only bob inserted
-
-        rows = {
-            r.username: r
-            for r in (await db_session.execute(select(User))).scalars().all()
-        }
-        # alice untouched
-        assert rows["alice"].role_id == admin.id
-        assert rows["alice"].notes == "keep me"
-        # bob inserted correctly
-        assert rows["bob"].notes == "new user"
-
-    @pytest.mark.anyio
-    async def test_insert_batch_every_row_different_nullable_columns(
-        self, db_session: AsyncSession
-    ):
-        """Each row in the batch sets a different combination of nullable columns.
-
-        Tests that normalization produces valid SQL for all rows.
-        """
-        registry = FixtureRegistry()
-        admin = await RoleCrud.create(db_session, RoleCreate(name="admin"))
-        uid1 = uuid.uuid4()
-        uid2 = uuid.uuid4()
-        uid3 = uuid.uuid4()
-
-        @registry.register
-        def users():
-            return [
-                User(
-                    id=uid1,
-                    username="all_set",
-                    email="a@test.com",
-                    role_id=admin.id,
-                    notes="full",
-                ),
-                User(
-                    id=uid2, username="only_role", email="b@test.com", role_id=admin.id
-                ),
-                User(
-                    id=uid3, username="only_notes", email="c@test.com", notes="partial"
-                ),
-            ]
-
-        await load_fixtures(db_session, registry, "users", strategy=LoadStrategy.INSERT)
-
-        from sqlalchemy import select
-
-        rows = {
-            r.username: r
-            for r in (await db_session.execute(select(User))).scalars().all()
-        }
-        assert rows["all_set"].role_id == admin.id
-        assert rows["all_set"].notes == "full"
-        assert rows["only_role"].role_id == admin.id
-        assert rows["only_role"].notes is None
-        assert rows["only_notes"].role_id is None
-        assert rows["only_notes"].notes == "partial"
--- a/tests/test_imports.py
+++ b/tests/test_imports.py
@@ -101,7 +101,7 @@ class TestMetricsImportGuard:
            with patch("builtins.__import__", side_effect=blocking_import):
                mod = importlib.import_module("fastapi_toolsets.metrics")
                with pytest.raises(ImportError, match="prometheus_client"):
-                    mod.init_metrics(None, None)  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
+                    mod.init_metrics(None, None)  # type: ignore[arg-type]
        finally:
            for key in list(sys.modules):
                if key.startswith("fastapi_toolsets.metrics"):
@@ -171,15 +171,8 @@ class TestPytestImportGuard:
 class TestCliImportGuard:
    """Tests for CLI module import guard when typer is missing."""

-    @pytest.mark.parametrize(
-        "expected_match",
-        [
-            "typer",
-            r"pip install fastapi-toolsets\[cli\]",
-        ],
-    )
-    def test_import_raises_without_typer(self, expected_match):
-        """Importing cli.app raises when typer is missing, with an informative error message."""
+    def test_import_raises_without_typer(self):
+        """Importing cli.app raises when typer is missing."""
        saved, blocking_import = _reload_without_package(
            "fastapi_toolsets.cli.app", ["typer"]
        )
@@ -193,7 +186,33 @@ class TestCliImportGuard:

        try:
            with patch("builtins.__import__", side_effect=blocking_import):
-                with pytest.raises(ImportError, match=expected_match):
+                with pytest.raises(ImportError, match="typer"):
+                    importlib.import_module("fastapi_toolsets.cli.app")
+        finally:
+            for key in list(sys.modules):
+                if key.startswith("fastapi_toolsets.cli.app") or key.startswith(
+                    "fastapi_toolsets.cli.config"
+                ):
+                    sys.modules.pop(key, None)
+            sys.modules.update(saved)
+
+    def test_error_message_suggests_cli_extra(self):
+        """Error message suggests installing the cli extra."""
+        saved, blocking_import = _reload_without_package(
+            "fastapi_toolsets.cli.app", ["typer"]
+        )
+        config_keys = [
+            k for k in sys.modules if k.startswith("fastapi_toolsets.cli.config")
+        ]
+        for key in config_keys:
+            if key not in saved:
+                saved[key] = sys.modules.pop(key)
+
+        try:
+            with patch("builtins.__import__", side_effect=blocking_import):
+                with pytest.raises(
+                    ImportError, match=r"pip install fastapi-toolsets\[cli\]"
+                ):
                    importlib.import_module("fastapi_toolsets.cli.app")
        finally:
            for key in list(sys.modules):
--- a/tests/test_metrics.py
+++ b/tests/test_metrics.py
@@ -1,5 +1,6 @@
 """Tests for fastapi_toolsets.metrics module."""

+import os
 import tempfile
 from unittest.mock import AsyncMock, MagicMock

@@ -286,16 +287,6 @@ class TestIncludeRegistry:
 class TestInitMetrics:
    """Tests for init_metrics function."""

-    @pytest.fixture
-    def metrics_client(self):
-        """Create a FastAPI app with MetricsRegistry and return a TestClient."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        init_metrics(app, registry)
-        client = TestClient(app)
-        yield client
-        client.close()
-
    def test_returns_app(self):
        """Returns the FastAPI app."""
        app = FastAPI()
@@ -303,14 +294,26 @@ class TestInitMetrics:
        result = init_metrics(app, registry)
        assert result is app

-    def test_metrics_endpoint_responds(self, metrics_client):
+    def test_metrics_endpoint_responds(self):
        """The /metrics endpoint returns 200."""
-        response = metrics_client.get("/metrics")
+        app = FastAPI()
+        registry = MetricsRegistry()
+        init_metrics(app, registry)
+
+        client = TestClient(app)
+        response = client.get("/metrics")
+
        assert response.status_code == 200

-    def test_metrics_endpoint_content_type(self, metrics_client):
+    def test_metrics_endpoint_content_type(self):
        """The /metrics endpoint returns prometheus content type."""
-        response = metrics_client.get("/metrics")
+        app = FastAPI()
+        registry = MetricsRegistry()
+        init_metrics(app, registry)
+
+        client = TestClient(app)
+        response = client.get("/metrics")
+
        assert "text/plain" in response.headers["content-type"]

    def test_custom_path(self):
@@ -442,33 +445,36 @@ class TestInitMetrics:
 class TestMultiProcessMode:
    """Tests for multi-process Prometheus mode."""

-    def test_multiprocess_with_env_var(self, monkeypatch):
+    def test_multiprocess_with_env_var(self):
        """Multi-process mode works when PROMETHEUS_MULTIPROC_DIR is set."""
        with tempfile.TemporaryDirectory() as tmpdir:
-            monkeypatch.setenv("PROMETHEUS_MULTIPROC_DIR", tmpdir)
-            # Use a separate registry to avoid conflicts with default
-            prom_registry = CollectorRegistry()
-            app = FastAPI()
-            registry = MetricsRegistry()
+            os.environ["PROMETHEUS_MULTIPROC_DIR"] = tmpdir
+            try:
+                # Use a separate registry to avoid conflicts with default
+                prom_registry = CollectorRegistry()
+                app = FastAPI()
+                registry = MetricsRegistry()

-            @registry.register
-            def mp_counter():
-                return Counter(
-                    "mp_test_counter",
-                    "A multiprocess counter",
-                    registry=prom_registry,
-                )
+                @registry.register
+                def mp_counter():
+                    return Counter(
+                        "mp_test_counter",
+                        "A multiprocess counter",
+                        registry=prom_registry,
+                    )

-            init_metrics(app, registry)
+                init_metrics(app, registry)

-            client = TestClient(app)
-            response = client.get("/metrics")
+                client = TestClient(app)
+                response = client.get("/metrics")

-            assert response.status_code == 200
+                assert response.status_code == 200
+            finally:
+                del os.environ["PROMETHEUS_MULTIPROC_DIR"]

-    def test_single_process_without_env_var(self, monkeypatch):
+    def test_single_process_without_env_var(self):
        """Single-process mode when PROMETHEUS_MULTIPROC_DIR is not set."""
-        monkeypatch.delenv("PROMETHEUS_MULTIPROC_DIR", raising=False)
+        os.environ.pop("PROMETHEUS_MULTIPROC_DIR", None)

        app = FastAPI()
        registry = MetricsRegistry()
--- a/tests/test_models.py
+++ b/tests/test_models.py
--- a/tests/test_pytest.py
+++ b/tests/test_pytest.py
@@ -7,10 +7,9 @@ from fastapi import Depends, FastAPI
 from httpx import AsyncClient
 from sqlalchemy import select, text
 from sqlalchemy.engine import make_url
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
 from sqlalchemy.orm import selectinload

-from fastapi_toolsets.db import get_transaction
 from fastapi_toolsets.fixtures import Context, FixtureRegistry
 from fastapi_toolsets.pytest import (
    create_async_client,
@@ -337,42 +336,6 @@ class TestCreateDbSession:
            result = await session.execute(select(Role))
            assert result.all() == []

-    @pytest.mark.anyio
-    async def test_get_transaction_commits_visible_to_separate_session(self):
-        """Data written via get_transaction() is committed and visible to other sessions."""
-        role_id = uuid.uuid4()
-
-        async with create_db_session(DATABASE_URL, Base, drop_tables=False) as session:
-            # Simulate what _create_fixture_function does: insert via get_transaction
-            # with no explicit commit afterward.
-            async with get_transaction(session):
-                role = Role(id=role_id, name="visible_to_other_session")
-                session.add(role)
-
-            # The data must have been committed (begin/commit, not a savepoint),
-            # so a separate engine/session can read it.
-            other_engine = create_async_engine(DATABASE_URL, echo=False)
-            try:
-                other_session_maker = async_sessionmaker(
-                    other_engine, expire_on_commit=False
-                )
-                async with other_session_maker() as other:
-                    result = await other.execute(select(Role).where(Role.id == role_id))
-                    fetched = result.scalar_one_or_none()
-                    assert fetched is not None, (
-                        "Fixture data inserted via get_transaction() must be committed "
-                        "and visible to a separate session. If create_db_session uses "
-                        "create_db_context, auto-begin forces get_transaction() into "
-                        "savepoints instead of real commits."
-                    )
-                    assert fetched.name == "visible_to_other_session"
-            finally:
-                await other_engine.dispose()
-
-        # Cleanup
-        async with create_db_session(DATABASE_URL, Base, drop_tables=True) as _:
-            pass
-

 class TestGetXdistWorker:
    """Tests for _get_xdist_worker helper."""
--- a/tests/test_schemas.py
+++ b/tests/test_schemas.py
@@ -6,12 +6,9 @@ from pydantic import ValidationError
 from fastapi_toolsets.schemas import (
    ApiError,
    CursorPagination,
-    CursorPaginatedResponse,
    ErrorResponse,
    OffsetPagination,
-    OffsetPaginatedResponse,
    PaginatedResponse,
-    PaginationType,
    Response,
    ResponseStatus,
 )
@@ -201,88 +198,6 @@ class TestOffsetPagination:
        assert data["page"] == 2
        assert data["has_more"] is True

-    def test_total_count_can_be_none(self):
-        """total_count accepts None (include_total=False mode)."""
-        pagination = OffsetPagination(
-            total_count=None,
-            items_per_page=20,
-            page=1,
-            has_more=True,
-        )
-        assert pagination.total_count is None
-
-    def test_serialization_with_none_total_count(self):
-        """OffsetPagination serializes total_count=None correctly."""
-        pagination = OffsetPagination(
-            total_count=None,
-            items_per_page=20,
-            page=1,
-            has_more=False,
-        )
-        data = pagination.model_dump()
-        assert data["total_count"] is None
-
-    def test_pages_computed(self):
-        """pages is ceil(total_count / items_per_page)."""
-        pagination = OffsetPagination(
-            total_count=42,
-            items_per_page=10,
-            page=1,
-            has_more=True,
-        )
-        assert pagination.pages == 5
-
-    def test_pages_exact_division(self):
-        """pages is exact when total_count is evenly divisible."""
-        pagination = OffsetPagination(
-            total_count=40,
-            items_per_page=10,
-            page=1,
-            has_more=False,
-        )
-        assert pagination.pages == 4
-
-    def test_pages_zero_total(self):
-        """pages is 0 when total_count is 0."""
-        pagination = OffsetPagination(
-            total_count=0,
-            items_per_page=10,
-            page=1,
-            has_more=False,
-        )
-        assert pagination.pages == 0
-
-    def test_pages_zero_items_per_page(self):
-        """pages is 0 when items_per_page is 0."""
-        pagination = OffsetPagination(
-            total_count=100,
-            items_per_page=0,
-            page=1,
-            has_more=False,
-        )
-        assert pagination.pages == 0
-
-    def test_pages_none_when_total_count_none(self):
-        """pages is None when total_count is None (include_total=False)."""
-        pagination = OffsetPagination(
-            total_count=None,
-            items_per_page=20,
-            page=1,
-            has_more=True,
-        )
-        assert pagination.pages is None
-
-    def test_pages_in_serialization(self):
-        """pages appears in model_dump output."""
-        pagination = OffsetPagination(
-            total_count=25,
-            items_per_page=10,
-            page=1,
-            has_more=True,
-        )
-        data = pagination.model_dump()
-        assert data["pages"] == 3
-

 class TestCursorPagination:
    """Tests for CursorPagination schema."""
@@ -386,7 +301,7 @@ class TestPaginatedResponse:
            page=1,
            has_more=False,
        )
-        response = PaginatedResponse(
+        response = PaginatedResponse[dict](
            data=[],
            pagination=pagination,
        )
@@ -395,32 +310,13 @@ class TestPaginatedResponse:
        assert response.data == []
        assert response.pagination.total_count == 0

-    def test_class_getitem_with_concrete_type_returns_discriminated_union(self):
-        """PaginatedResponse[T] with a concrete type returns a discriminated Annotated union."""
-        import typing
-
-        alias = PaginatedResponse[dict]
-        args = typing.get_args(alias)
-        # args[0] is the Union, args[1] is the FieldInfo discriminator
-        union_args = typing.get_args(args[0])
-        assert CursorPaginatedResponse[dict] in union_args
-        assert OffsetPaginatedResponse[dict] in union_args
-
-    def test_class_getitem_is_cached(self):
-        """Repeated subscripting with the same type returns the identical cached object."""
-        assert PaginatedResponse[dict] is PaginatedResponse[dict]
-
-    def test_class_getitem_with_typevar_returns_generic(self):
-        """PaginatedResponse[TypeVar] falls through to Pydantic generic parametrisation."""
-        from typing import TypeVar
-
-        T = TypeVar("T")
-        alias = PaginatedResponse[T]
-        # Should be a generic alias, not an Annotated union
-        assert not hasattr(alias, "__metadata__")
-
    def test_generic_type_hint(self):
        """PaginatedResponse supports generic type hints."""
+
+        class UserOut:
+            id: int
+            name: str
+
        pagination = OffsetPagination(
            total_count=1,
            items_per_page=10,
@@ -475,191 +371,6 @@ class TestPaginatedResponse:
        assert isinstance(response.pagination, CursorPagination)


-class TestPaginationType:
-    """Tests for PaginationType enum."""
-
-    def test_offset_value(self):
-        """OFFSET has string value 'offset'."""
-        assert PaginationType.OFFSET == "offset"
-        assert PaginationType.OFFSET.value == "offset"
-
-    def test_cursor_value(self):
-        """CURSOR has string value 'cursor'."""
-        assert PaginationType.CURSOR == "cursor"
-        assert PaginationType.CURSOR.value == "cursor"
-
-    def test_is_string_enum(self):
-        """PaginationType is a string enum."""
-        assert isinstance(PaginationType.OFFSET, str)
-        assert isinstance(PaginationType.CURSOR, str)
-
-    def test_members(self):
-        """PaginationType has exactly two members."""
-        assert set(PaginationType) == {PaginationType.OFFSET, PaginationType.CURSOR}
-
-
-class TestOffsetPaginatedResponse:
-    """Tests for OffsetPaginatedResponse schema."""
-
-    def test_pagination_type_is_offset(self):
-        """pagination_type is always PaginationType.OFFSET."""
-        response = OffsetPaginatedResponse(
-            data=[],
-            pagination=OffsetPagination(
-                total_count=0, items_per_page=10, page=1, has_more=False
-            ),
-        )
-        assert response.pagination_type is PaginationType.OFFSET
-
-    def test_pagination_type_serializes_to_string(self):
-        """pagination_type serializes to 'offset' in JSON mode."""
-        response = OffsetPaginatedResponse(
-            data=[],
-            pagination=OffsetPagination(
-                total_count=0, items_per_page=10, page=1, has_more=False
-            ),
-        )
-        assert response.model_dump(mode="json")["pagination_type"] == "offset"
-
-    def test_pagination_field_is_typed(self):
-        """pagination field is OffsetPagination, not the union."""
-        response = OffsetPaginatedResponse(
-            data=[{"id": 1}],
-            pagination=OffsetPagination(
-                total_count=10, items_per_page=5, page=2, has_more=True
-            ),
-        )
-        assert isinstance(response.pagination, OffsetPagination)
-        assert response.pagination.total_count == 10
-        assert response.pagination.page == 2
-
-    def test_is_subclass_of_paginated_response(self):
-        """OffsetPaginatedResponse IS a PaginatedResponse."""
-        response = OffsetPaginatedResponse(
-            data=[],
-            pagination=OffsetPagination(
-                total_count=0, items_per_page=10, page=1, has_more=False
-            ),
-        )
-        assert isinstance(response, PaginatedResponse)
-
-    def test_pagination_type_default_cannot_be_overridden_to_cursor(self):
-        """pagination_type rejects values other than OFFSET."""
-        with pytest.raises(ValidationError):
-            OffsetPaginatedResponse(
-                data=[],
-                pagination=OffsetPagination(
-                    total_count=0, items_per_page=10, page=1, has_more=False
-                ),
-                pagination_type=PaginationType.CURSOR,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
-            )
-
-    def test_filter_attributes_defaults_to_none(self):
-        """filter_attributes defaults to None."""
-        response = OffsetPaginatedResponse(
-            data=[],
-            pagination=OffsetPagination(
-                total_count=0, items_per_page=10, page=1, has_more=False
-            ),
-        )
-        assert response.filter_attributes is None
-
-    def test_full_serialization(self):
-        """Full JSON serialization includes all expected fields."""
-        response = OffsetPaginatedResponse(
-            data=[{"id": 1}],
-            pagination=OffsetPagination(
-                total_count=1, items_per_page=10, page=1, has_more=False
-            ),
-            filter_attributes={"status": ["active"]},
-        )
-        data = response.model_dump(mode="json")
-
-        assert data["pagination_type"] == "offset"
-        assert data["status"] == "SUCCESS"
-        assert data["data"] == [{"id": 1}]
-        assert data["pagination"]["total_count"] == 1
-        assert data["filter_attributes"] == {"status": ["active"]}
-
-
-class TestCursorPaginatedResponse:
-    """Tests for CursorPaginatedResponse schema."""
-
-    def test_pagination_type_is_cursor(self):
-        """pagination_type is always PaginationType.CURSOR."""
-        response = CursorPaginatedResponse(
-            data=[],
-            pagination=CursorPagination(
-                next_cursor=None, items_per_page=10, has_more=False
-            ),
-        )
-        assert response.pagination_type is PaginationType.CURSOR
-
-    def test_pagination_type_serializes_to_string(self):
-        """pagination_type serializes to 'cursor' in JSON mode."""
-        response = CursorPaginatedResponse(
-            data=[],
-            pagination=CursorPagination(
-                next_cursor=None, items_per_page=10, has_more=False
-            ),
-        )
-        assert response.model_dump(mode="json")["pagination_type"] == "cursor"
-
-    def test_pagination_field_is_typed(self):
-        """pagination field is CursorPagination, not the union."""
-        response = CursorPaginatedResponse(
-            data=[{"id": 1}],
-            pagination=CursorPagination(
-                next_cursor="abc123",
-                prev_cursor=None,
-                items_per_page=20,
-                has_more=True,
-            ),
-        )
-        assert isinstance(response.pagination, CursorPagination)
-        assert response.pagination.next_cursor == "abc123"
-        assert response.pagination.has_more is True
-
-    def test_is_subclass_of_paginated_response(self):
-        """CursorPaginatedResponse IS a PaginatedResponse."""
-        response = CursorPaginatedResponse(
-            data=[],
-            pagination=CursorPagination(
-                next_cursor=None, items_per_page=10, has_more=False
-            ),
-        )
-        assert isinstance(response, PaginatedResponse)
-
-    def test_pagination_type_default_cannot_be_overridden_to_offset(self):
-        """pagination_type rejects values other than CURSOR."""
-        with pytest.raises(ValidationError):
-            CursorPaginatedResponse(
-                data=[],
-                pagination=CursorPagination(
-                    next_cursor=None, items_per_page=10, has_more=False
-                ),
-                pagination_type=PaginationType.OFFSET,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
-            )
-
-    def test_full_serialization(self):
-        """Full JSON serialization includes all expected fields."""
-        response = CursorPaginatedResponse(
-            data=[{"id": 1}],
-            pagination=CursorPagination(
-                next_cursor="tok_next",
-                prev_cursor="tok_prev",
-                items_per_page=10,
-                has_more=True,
-            ),
-        )
-        data = response.model_dump(mode="json")
-
-        assert data["pagination_type"] == "cursor"
-        assert data["status"] == "SUCCESS"
-        assert data["pagination"]["next_cursor"] == "tok_next"
-        assert data["pagination"]["prev_cursor"] == "tok_prev"
-
-
 class TestFromAttributes:
    """Tests for from_attributes config (ORM mode)."""

--- a/uv.lock
+++ b/uv.lock
@@ -113,101 +113,101 @@ wheels = [

 [[package]]
 name = "coverage"
-version = "7.13.5"
+version = "7.13.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/56/95b7e30fa389756cb56630faa728da46a27b8c6eb46f9d557c68fff12b65/coverage-7.13.4.tar.gz", hash = "sha256:e5c8f6ed1e61a8b2dcdf31eb0b9bbf0130750ca79c1c49eb898e2ad86f5ccc91", size = 827239, upload-time = "2026-02-09T12:59:03.86Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
-    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
-    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
-    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
-    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
-    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
-    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
-    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
-    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
-    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
-    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
-    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
-    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
-    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
-    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
-    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
-    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
-    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
-    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
-    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
-    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
-    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
-    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
-    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
-    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
-    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
-    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
-    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
-    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
-    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
-    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
-    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
-    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
-    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
-    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/ad/b59e5b451cf7172b8d1043dc0fa718f23aab379bc1521ee13d4bd9bfa960/coverage-7.13.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d490ba50c3f35dd7c17953c68f3270e7ccd1c6642e2d2afe2d8e720b98f5a053", size = 219278, upload-time = "2026-02-09T12:56:31.673Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/17/0cb7ca3de72e5f4ef2ec2fa0089beafbcaaaead1844e8b8a63d35173d77d/coverage-7.13.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:19bc3c88078789f8ef36acb014d7241961dbf883fd2533d18cb1e7a5b4e28b11", size = 219783, upload-time = "2026-02-09T12:56:33.104Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/63/325d8e5b11e0eaf6d0f6a44fad444ae58820929a9b0de943fa377fe73e85/coverage-7.13.4-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3998e5a32e62fdf410c0dbd3115df86297995d6e3429af80b8798aad894ca7aa", size = 250200, upload-time = "2026-02-09T12:56:34.474Z" },
+    { url = "https://files.pythonhosted.org/packages/76/53/c16972708cbb79f2942922571a687c52bd109a7bd51175aeb7558dff2236/coverage-7.13.4-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8e264226ec98e01a8e1054314af91ee6cde0eacac4f465cc93b03dbe0bce2fd7", size = 252114, upload-time = "2026-02-09T12:56:35.749Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/c2/7ab36d8b8cc412bec9ea2d07c83c48930eb4ba649634ba00cb7e4e0f9017/coverage-7.13.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a3aa4e7b9e416774b21797365b358a6e827ffadaaca81b69ee02946852449f00", size = 254220, upload-time = "2026-02-09T12:56:37.796Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/4d/cf52c9a3322c89a0e6febdfbc83bb45c0ed3c64ad14081b9503adee702e7/coverage-7.13.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:71ca20079dd8f27fcf808817e281e90220475cd75115162218d0e27549f95fef", size = 256164, upload-time = "2026-02-09T12:56:39.016Z" },
+    { url = "https://files.pythonhosted.org/packages/78/e9/eb1dd17bd6de8289df3580e967e78294f352a5df8a57ff4671ee5fc3dcd0/coverage-7.13.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e2f25215f1a359ab17320b47bcdaca3e6e6356652e8256f2441e4ef972052903", size = 250325, upload-time = "2026-02-09T12:56:40.668Z" },
+    { url = "https://files.pythonhosted.org/packages/71/07/8c1542aa873728f72267c07278c5cc0ec91356daf974df21335ccdb46368/coverage-7.13.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d65b2d373032411e86960604dc4edac91fdfb5dca539461cf2cbe78327d1e64f", size = 251913, upload-time = "2026-02-09T12:56:41.97Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d7/c62e2c5e4483a748e27868e4c32ad3daa9bdddbba58e1bc7a15e252baa74/coverage-7.13.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94eb63f9b363180aff17de3e7c8760c3ba94664ea2695c52f10111244d16a299", size = 249974, upload-time = "2026-02-09T12:56:43.323Z" },
+    { url = "https://files.pythonhosted.org/packages/98/9f/4c5c015a6e98ced54efd0f5cf8d31b88e5504ecb6857585fc0161bb1e600/coverage-7.13.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e856bf6616714c3a9fbc270ab54103f4e685ba236fa98c054e8f87f266c93505", size = 253741, upload-time = "2026-02-09T12:56:45.155Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/59/0f4eef89b9f0fcd9633b5d350016f54126ab49426a70ff4c4e87446cabdc/coverage-7.13.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:65dfcbe305c3dfe658492df2d85259e0d79ead4177f9ae724b6fb245198f55d6", size = 249695, upload-time = "2026-02-09T12:56:46.636Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2c/b7476f938deb07166f3eb281a385c262675d688ff4659ad56c6c6b8e2e70/coverage-7.13.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b507778ae8a4c915436ed5c2e05b4a6cecfa70f734e19c22a005152a11c7b6a9", size = 250599, upload-time = "2026-02-09T12:56:48.13Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/34/c3420709d9846ee3785b9f2831b4d94f276f38884032dca1457fa83f7476/coverage-7.13.4-cp311-cp311-win32.whl", hash = "sha256:784fc3cf8be001197b652d51d3fd259b1e2262888693a4636e18879f613a62a9", size = 221780, upload-time = "2026-02-09T12:56:50.479Z" },
+    { url = "https://files.pythonhosted.org/packages/61/08/3d9c8613079d2b11c185b865de9a4c1a68850cfda2b357fae365cf609f29/coverage-7.13.4-cp311-cp311-win_amd64.whl", hash = "sha256:2421d591f8ca05b308cf0092807308b2facbefe54af7c02ac22548b88b95c98f", size = 222715, upload-time = "2026-02-09T12:56:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/18/1a/54c3c80b2f056164cc0a6cdcb040733760c7c4be9d780fe655f356f433e4/coverage-7.13.4-cp311-cp311-win_arm64.whl", hash = "sha256:79e73a76b854d9c6088fe5d8b2ebe745f8681c55f7397c3c0a016192d681045f", size = 221385, upload-time = "2026-02-09T12:56:53.194Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/81/4ce2fdd909c5a0ed1f6dedb88aa57ab79b6d1fbd9b588c1ac7ef45659566/coverage-7.13.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:02231499b08dabbe2b96612993e5fc34217cdae907a51b906ac7fca8027a4459", size = 219449, upload-time = "2026-02-09T12:56:54.889Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/96/5238b1efc5922ddbdc9b0db9243152c09777804fb7c02ad1741eb18a11c0/coverage-7.13.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40aa8808140e55dc022b15d8aa7f651b6b3d68b365ea0398f1441e0b04d859c3", size = 219810, upload-time = "2026-02-09T12:56:56.33Z" },
+    { url = "https://files.pythonhosted.org/packages/78/72/2f372b726d433c9c35e56377cf1d513b4c16fe51841060d826b95caacec1/coverage-7.13.4-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5b856a8ccf749480024ff3bd7310adaef57bf31fd17e1bfc404b7940b6986634", size = 251308, upload-time = "2026-02-09T12:56:57.858Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/a0/2ea570925524ef4e00bb6c82649f5682a77fac5ab910a65c9284de422600/coverage-7.13.4-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c048ea43875fbf8b45d476ad79f179809c590ec7b79e2035c662e7afa3192e3", size = 254052, upload-time = "2026-02-09T12:56:59.754Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/ac/45dc2e19a1939098d783c846e130b8f862fbb50d09e0af663988f2f21973/coverage-7.13.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7b38448866e83176e28086674fe7368ab8590e4610fb662b44e345b86d63ffa", size = 255165, upload-time = "2026-02-09T12:57:01.287Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4d/26d236ff35abc3b5e63540d3386e4c3b192168c1d96da5cb2f43c640970f/coverage-7.13.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:de6defc1c9badbf8b9e67ae90fd00519186d6ab64e5cc5f3d21359c2a9b2c1d3", size = 257432, upload-time = "2026-02-09T12:57:02.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/55/14a966c757d1348b2e19caf699415a2a4c4f7feaa4bbc6326a51f5c7dd1b/coverage-7.13.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7eda778067ad7ffccd23ecffce537dface96212576a07924cbf0d8799d2ded5a", size = 251716, upload-time = "2026-02-09T12:57:04.056Z" },
+    { url = "https://files.pythonhosted.org/packages/77/33/50116647905837c66d28b2af1321b845d5f5d19be9655cb84d4a0ea806b4/coverage-7.13.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e87f6c587c3f34356c3759f0420693e35e7eb0e2e41e4c011cb6ec6ecbbf1db7", size = 253089, upload-time = "2026-02-09T12:57:05.503Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b4/8efb11a46e3665d92635a56e4f2d4529de6d33f2cb38afd47d779d15fc99/coverage-7.13.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8248977c2e33aecb2ced42fef99f2d319e9904a36e55a8a68b69207fb7e43edc", size = 251232, upload-time = "2026-02-09T12:57:06.879Z" },
+    { url = "https://files.pythonhosted.org/packages/51/24/8cd73dd399b812cc76bb0ac260e671c4163093441847ffe058ac9fda1e32/coverage-7.13.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:25381386e80ae727608e662474db537d4df1ecd42379b5ba33c84633a2b36d47", size = 255299, upload-time = "2026-02-09T12:57:08.245Z" },
+    { url = "https://files.pythonhosted.org/packages/03/94/0a4b12f1d0e029ce1ccc1c800944a9984cbe7d678e470bb6d3c6bc38a0da/coverage-7.13.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:ee756f00726693e5ba94d6df2bdfd64d4852d23b09bb0bc700e3b30e6f333985", size = 250796, upload-time = "2026-02-09T12:57:10.142Z" },
+    { url = "https://files.pythonhosted.org/packages/73/44/6002fbf88f6698ca034360ce474c406be6d5a985b3fdb3401128031eef6b/coverage-7.13.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fdfc1e28e7c7cdce44985b3043bc13bbd9c747520f94a4d7164af8260b3d91f0", size = 252673, upload-time = "2026-02-09T12:57:12.197Z" },
+    { url = "https://files.pythonhosted.org/packages/de/c6/a0279f7c00e786be75a749a5674e6fa267bcbd8209cd10c9a450c655dfa7/coverage-7.13.4-cp312-cp312-win32.whl", hash = "sha256:01d4cbc3c283a17fc1e42d614a119f7f438eabb593391283adca8dc86eff1246", size = 221990, upload-time = "2026-02-09T12:57:14.085Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4e/c0a25a425fcf5557d9abd18419c95b63922e897bc86c1f327f155ef234a9/coverage-7.13.4-cp312-cp312-win_amd64.whl", hash = "sha256:9401ebc7ef522f01d01d45532c68c5ac40fb27113019b6b7d8b208f6e9baa126", size = 222800, upload-time = "2026-02-09T12:57:15.944Z" },
+    { url = "https://files.pythonhosted.org/packages/47/ac/92da44ad9a6f4e3a7debd178949d6f3769bedca33830ce9b1dcdab589a37/coverage-7.13.4-cp312-cp312-win_arm64.whl", hash = "sha256:b1ec7b6b6e93255f952e27ab58fbc68dcc468844b16ecbee881aeb29b6ab4d8d", size = 221415, upload-time = "2026-02-09T12:57:17.497Z" },
+    { url = "https://files.pythonhosted.org/packages/db/23/aad45061a31677d68e47499197a131eea55da4875d16c1f42021ab963503/coverage-7.13.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b66a2da594b6068b48b2692f043f35d4d3693fb639d5ea8b39533c2ad9ac3ab9", size = 219474, upload-time = "2026-02-09T12:57:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/70/9b8b67a0945f3dfec1fd896c5cefb7c19d5a3a6d74630b99a895170999ae/coverage-7.13.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3599eb3992d814d23b35c536c28df1a882caa950f8f507cef23d1cbf334995ac", size = 219844, upload-time = "2026-02-09T12:57:20.66Z" },
+    { url = "https://files.pythonhosted.org/packages/97/fd/7e859f8fab324cef6c4ad7cff156ca7c489fef9179d5749b0c8d321281c2/coverage-7.13.4-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:93550784d9281e374fb5a12bf1324cc8a963fd63b2d2f223503ef0fd4aa339ea", size = 250832, upload-time = "2026-02-09T12:57:22.007Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/dc/b2442d10020c2f52617828862d8b6ee337859cd8f3a1f13d607dddda9cf7/coverage-7.13.4-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b720ce6a88a2755f7c697c23268ddc47a571b88052e6b155224347389fdf6a3b", size = 253434, upload-time = "2026-02-09T12:57:23.339Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/88/6728a7ad17428b18d836540630487231f5470fb82454871149502f5e5aa2/coverage-7.13.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7b322db1284a2ed3aa28ffd8ebe3db91c929b7a333c0820abec3d838ef5b3525", size = 254676, upload-time = "2026-02-09T12:57:24.774Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/bc/21244b1b8cedf0dff0a2b53b208015fe798d5f2a8d5348dbfece04224fff/coverage-7.13.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f4594c67d8a7c89cf922d9df0438c7c7bb022ad506eddb0fdb2863359ff78242", size = 256807, upload-time = "2026-02-09T12:57:26.125Z" },
+    { url = "https://files.pythonhosted.org/packages/97/a0/ddba7ed3251cff51006737a727d84e05b61517d1784a9988a846ba508877/coverage-7.13.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53d133df809c743eb8bce33b24bcababb371f4441340578cd406e084d94a6148", size = 251058, upload-time = "2026-02-09T12:57:27.614Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/55/e289addf7ff54d3a540526f33751951bf0878f3809b47f6dfb3def69c6f7/coverage-7.13.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76451d1978b95ba6507a039090ba076105c87cc76fc3efd5d35d72093964d49a", size = 252805, upload-time = "2026-02-09T12:57:29.066Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4e/cc276b1fa4a59be56d96f1dabddbdc30f4ba22e3b1cd42504c37b3313255/coverage-7.13.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7f57b33491e281e962021de110b451ab8a24182589be17e12a22c79047935e23", size = 250766, upload-time = "2026-02-09T12:57:30.522Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/1093b8f93018f8b41a8cf29636c9292502f05e4a113d4d107d14a3acd044/coverage-7.13.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1731dc33dc276dafc410a885cbf5992f1ff171393e48a21453b78727d090de80", size = 254923, upload-time = "2026-02-09T12:57:31.946Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/55/ea2796da2d42257f37dbea1aab239ba9263b31bd91d5527cdd6db5efe174/coverage-7.13.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:bd60d4fe2f6fa7dff9223ca1bbc9f05d2b6697bc5961072e5d3b952d46e1b1ea", size = 250591, upload-time = "2026-02-09T12:57:33.842Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/7c4bb72aacf8af5020675aa633e59c1fbe296d22aed191b6a5b711eb2bc7/coverage-7.13.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9181a3ccead280b828fae232df12b16652702b49d41e99d657f46cc7b1f6ec7a", size = 252364, upload-time = "2026-02-09T12:57:35.743Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/38/a8d2ec0146479c20bbaa7181b5b455a0c41101eed57f10dd19a78ab44c80/coverage-7.13.4-cp313-cp313-win32.whl", hash = "sha256:f53d492307962561ac7de4cd1de3e363589b000ab69617c6156a16ba7237998d", size = 222010, upload-time = "2026-02-09T12:57:37.25Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/0c/dbfafbe90a185943dcfbc766fe0e1909f658811492d79b741523a414a6cc/coverage-7.13.4-cp313-cp313-win_amd64.whl", hash = "sha256:e6f70dec1cc557e52df5306d051ef56003f74d56e9c4dd7ddb07e07ef32a84dd", size = 222818, upload-time = "2026-02-09T12:57:38.734Z" },
+    { url = "https://files.pythonhosted.org/packages/04/d1/934918a138c932c90d78301f45f677fb05c39a3112b96fd2c8e60503cdc7/coverage-7.13.4-cp313-cp313-win_arm64.whl", hash = "sha256:fb07dc5da7e849e2ad31a5d74e9bece81f30ecf5a42909d0a695f8bd1874d6af", size = 221438, upload-time = "2026-02-09T12:57:40.223Z" },
+    { url = "https://files.pythonhosted.org/packages/52/57/ee93ced533bcb3e6df961c0c6e42da2fc6addae53fb95b94a89b1e33ebd7/coverage-7.13.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40d74da8e6c4b9ac18b15331c4b5ebc35a17069410cad462ad4f40dcd2d50c0d", size = 220165, upload-time = "2026-02-09T12:57:41.639Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/e0/969fc285a6fbdda49d91af278488d904dcd7651b2693872f0ff94e40e84a/coverage-7.13.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4223b4230a376138939a9173f1bdd6521994f2aff8047fae100d6d94d50c5a12", size = 220516, upload-time = "2026-02-09T12:57:44.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b8/9531944e16267e2735a30a9641ff49671f07e8138ecf1ca13db9fd2560c7/coverage-7.13.4-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1d4be36a5114c499f9f1f9195e95ebf979460dbe2d88e6816ea202010ba1c34b", size = 261804, upload-time = "2026-02-09T12:57:45.989Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f3/e63df6d500314a2a60390d1989240d5f27318a7a68fa30ad3806e2a9323e/coverage-7.13.4-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:200dea7d1e8095cc6e98cdabe3fd1d21ab17d3cee6dab00cadbb2fe35d9c15b9", size = 263885, upload-time = "2026-02-09T12:57:47.42Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/67/7654810de580e14b37670b60a09c599fa348e48312db5b216d730857ffe6/coverage-7.13.4-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8eb931ee8e6d8243e253e5ed7336deea6904369d2fd8ae6e43f68abbf167092", size = 266308, upload-time = "2026-02-09T12:57:49.345Z" },
+    { url = "https://files.pythonhosted.org/packages/37/6f/39d41eca0eab3cc82115953ad41c4e77935286c930e8fad15eaed1389d83/coverage-7.13.4-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75eab1ebe4f2f64d9509b984f9314d4aa788540368218b858dad56dc8f3e5eb9", size = 267452, upload-time = "2026-02-09T12:57:50.811Z" },
+    { url = "https://files.pythonhosted.org/packages/50/6d/39c0fbb8fc5cd4d2090811e553c2108cf5112e882f82505ee7495349a6bf/coverage-7.13.4-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c35eb28c1d085eb7d8c9b3296567a1bebe03ce72962e932431b9a61f28facf26", size = 261057, upload-time = "2026-02-09T12:57:52.447Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/a2/60010c669df5fa603bb5a97fb75407e191a846510da70ac657eb696b7fce/coverage-7.13.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb88b316ec33760714a4720feb2816a3a59180fd58c1985012054fa7aebee4c2", size = 263875, upload-time = "2026-02-09T12:57:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d9/63b22a6bdbd17f1f96e9ed58604c2a6b0e72a9133e37d663bef185877cf6/coverage-7.13.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7d41eead3cc673cbd38a4417deb7fd0b4ca26954ff7dc6078e33f6ff97bed940", size = 261500, upload-time = "2026-02-09T12:57:56.012Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bf/69f86ba1ad85bc3ad240e4c0e57a2e620fbc0e1645a47b5c62f0e941ad7f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:fb26a934946a6afe0e326aebe0730cdff393a8bc0bbb65a2f41e30feddca399c", size = 265212, upload-time = "2026-02-09T12:57:57.5Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/f2/5f65a278a8c2148731831574c73e42f57204243d33bedaaf18fa79c5958f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:dae88bc0fc77edaa65c14be099bd57ee140cf507e6bfdeea7938457ab387efb0", size = 260398, upload-time = "2026-02-09T12:57:59.027Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/80/6e8280a350ee9fea92f14b8357448a242dcaa243cb2c72ab0ca591f66c8c/coverage-7.13.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:845f352911777a8e722bfce168958214951e07e47e5d5d9744109fa5fe77f79b", size = 262584, upload-time = "2026-02-09T12:58:01.129Z" },
+    { url = "https://files.pythonhosted.org/packages/22/63/01ff182fc95f260b539590fb12c11ad3e21332c15f9799cb5e2386f71d9f/coverage-7.13.4-cp313-cp313t-win32.whl", hash = "sha256:2fa8d5f8de70688a28240de9e139fa16b153cc3cbb01c5f16d88d6505ebdadf9", size = 222688, upload-time = "2026-02-09T12:58:02.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/43/89de4ef5d3cd53b886afa114065f7e9d3707bdb3e5efae13535b46ae483d/coverage-7.13.4-cp313-cp313t-win_amd64.whl", hash = "sha256:9351229c8c8407645840edcc277f4a2d44814d1bc34a2128c11c2a031d45a5dd", size = 223746, upload-time = "2026-02-09T12:58:05.362Z" },
+    { url = "https://files.pythonhosted.org/packages/35/39/7cf0aa9a10d470a5309b38b289b9bb07ddeac5d61af9b664fe9775a4cb3e/coverage-7.13.4-cp313-cp313t-win_arm64.whl", hash = "sha256:30b8d0512f2dc8c8747557e8fb459d6176a2c9e5731e2b74d311c03b78451997", size = 222003, upload-time = "2026-02-09T12:58:06.952Z" },
+    { url = "https://files.pythonhosted.org/packages/92/11/a9cf762bb83386467737d32187756a42094927150c3e107df4cb078e8590/coverage-7.13.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:300deaee342f90696ed186e3a00c71b5b3d27bffe9e827677954f4ee56969601", size = 219522, upload-time = "2026-02-09T12:58:08.623Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/28/56e6d892b7b052236d67c95f1936b6a7cf7c3e2634bf27610b8cbd7f9c60/coverage-7.13.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:29e3220258d682b6226a9b0925bc563ed9a1ebcff3cad30f043eceea7eaf2689", size = 219855, upload-time = "2026-02-09T12:58:10.176Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/69/233459ee9eb0c0d10fcc2fe425a029b3fa5ce0f040c966ebce851d030c70/coverage-7.13.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:391ee8f19bef69210978363ca930f7328081c6a0152f1166c91f0b5fdd2a773c", size = 250887, upload-time = "2026-02-09T12:58:12.503Z" },
+    { url = "https://files.pythonhosted.org/packages/06/90/2cdab0974b9b5bbc1623f7876b73603aecac11b8d95b85b5b86b32de5eab/coverage-7.13.4-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0dd7ab8278f0d58a0128ba2fca25824321f05d059c1441800e934ff2efa52129", size = 253396, upload-time = "2026-02-09T12:58:14.615Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/15/ea4da0f85bf7d7b27635039e649e99deb8173fe551096ea15017f7053537/coverage-7.13.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78cdf0d578b15148b009ccf18c686aa4f719d887e76e6b40c38ffb61d264a552", size = 254745, upload-time = "2026-02-09T12:58:16.162Z" },
+    { url = "https://files.pythonhosted.org/packages/99/11/bb356e86920c655ca4d61daee4e2bbc7258f0a37de0be32d233b561134ff/coverage-7.13.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:48685fee12c2eb3b27c62f2658e7ea21e9c3239cba5a8a242801a0a3f6a8c62a", size = 257055, upload-time = "2026-02-09T12:58:17.892Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/0f/9ae1f8cb17029e09da06ca4e28c9e1d5c1c0a511c7074592e37e0836c915/coverage-7.13.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4e83efc079eb39480e6346a15a1bcb3e9b04759c5202d157e1dd4303cd619356", size = 250911, upload-time = "2026-02-09T12:58:19.495Z" },
+    { url = "https://files.pythonhosted.org/packages/89/3a/adfb68558fa815cbc29747b553bc833d2150228f251b127f1ce97e48547c/coverage-7.13.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecae9737b72408d6a950f7e525f30aca12d4bd8dd95e37342e5beb3a2a8c4f71", size = 252754, upload-time = "2026-02-09T12:58:21.064Z" },
+    { url = "https://files.pythonhosted.org/packages/32/b1/540d0c27c4e748bd3cd0bd001076ee416eda993c2bae47a73b7cc9357931/coverage-7.13.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ae4578f8528569d3cf303fef2ea569c7f4c4059a38c8667ccef15c6e1f118aa5", size = 250720, upload-time = "2026-02-09T12:58:22.622Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/95/383609462b3ffb1fe133014a7c84fc0dd01ed55ac6140fa1093b5af7ebb1/coverage-7.13.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:6fdef321fdfbb30a197efa02d48fcd9981f0d8ad2ae8903ac318adc653f5df98", size = 254994, upload-time = "2026-02-09T12:58:24.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ba/1761138e86c81680bfc3c49579d66312865457f9fe405b033184e5793cb3/coverage-7.13.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b0f6ccf3dbe577170bebfce1318707d0e8c3650003cb4b3a9dd744575daa8b5", size = 250531, upload-time = "2026-02-09T12:58:26.271Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/8e/05900df797a9c11837ab59c4d6fe94094e029582aab75c3309a93e6fb4e3/coverage-7.13.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75fcd519f2a5765db3f0e391eb3b7d150cce1a771bf4c9f861aeab86c767a3c0", size = 252189, upload-time = "2026-02-09T12:58:27.807Z" },
+    { url = "https://files.pythonhosted.org/packages/00/bd/29c9f2db9ea4ed2738b8a9508c35626eb205d51af4ab7bf56a21a2e49926/coverage-7.13.4-cp314-cp314-win32.whl", hash = "sha256:8e798c266c378da2bd819b0677df41ab46d78065fb2a399558f3f6cae78b2fbb", size = 222258, upload-time = "2026-02-09T12:58:29.441Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/4d/1f8e723f6829977410efeb88f73673d794075091c8c7c18848d273dc9d73/coverage-7.13.4-cp314-cp314-win_amd64.whl", hash = "sha256:245e37f664d89861cf2329c9afa2c1fe9e6d4e1a09d872c947e70718aeeac505", size = 223073, upload-time = "2026-02-09T12:58:31.026Z" },
+    { url = "https://files.pythonhosted.org/packages/51/5b/84100025be913b44e082ea32abcf1afbf4e872f5120b7a1cab1d331b1e13/coverage-7.13.4-cp314-cp314-win_arm64.whl", hash = "sha256:ad27098a189e5838900ce4c2a99f2fe42a0bf0c2093c17c69b45a71579e8d4a2", size = 221638, upload-time = "2026-02-09T12:58:32.599Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/e4/c884a405d6ead1370433dad1e3720216b4f9fd8ef5b64bfd984a2a60a11a/coverage-7.13.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:85480adfb35ffc32d40918aad81b89c69c9cc5661a9b8a81476d3e645321a056", size = 220246, upload-time = "2026-02-09T12:58:34.181Z" },
+    { url = "https://files.pythonhosted.org/packages/81/5c/4d7ed8b23b233b0fffbc9dfec53c232be2e695468523242ea9fd30f97ad2/coverage-7.13.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:79be69cf7f3bf9b0deeeb062eab7ac7f36cd4cc4c4dd694bd28921ba4d8596cc", size = 220514, upload-time = "2026-02-09T12:58:35.704Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6f/3284d4203fd2f28edd73034968398cd2d4cb04ab192abc8cff007ea35679/coverage-7.13.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:caa421e2684e382c5d8973ac55e4f36bed6821a9bad5c953494de960c74595c9", size = 261877, upload-time = "2026-02-09T12:58:37.864Z" },
+    { url = "https://files.pythonhosted.org/packages/09/aa/b672a647bbe1556a85337dc95bfd40d146e9965ead9cc2fe81bde1e5cbce/coverage-7.13.4-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14375934243ee05f56c45393fe2ce81fe5cc503c07cee2bdf1725fb8bef3ffaf", size = 264004, upload-time = "2026-02-09T12:58:39.492Z" },
+    { url = "https://files.pythonhosted.org/packages/79/a1/aa384dbe9181f98bba87dd23dda436f0c6cf2e148aecbb4e50fc51c1a656/coverage-7.13.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25a41c3104d08edb094d9db0d905ca54d0cd41c928bb6be3c4c799a54753af55", size = 266408, upload-time = "2026-02-09T12:58:41.852Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5e/5150bf17b4019bc600799f376bb9606941e55bd5a775dc1e096b6ffea952/coverage-7.13.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f01afcff62bf9a08fb32b2c1d6e924236c0383c02c790732b6537269e466a72", size = 267544, upload-time = "2026-02-09T12:58:44.093Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/ed/f1de5c675987a4a7a672250d2c5c9d73d289dbf13410f00ed7181d8017dd/coverage-7.13.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eb9078108fbf0bcdde37c3f4779303673c2fa1fe8f7956e68d447d0dd426d38a", size = 260980, upload-time = "2026-02-09T12:58:45.721Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/e3/fe758d01850aa172419a6743fe76ba8b92c29d181d4f676ffe2dae2ba631/coverage-7.13.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0e086334e8537ddd17e5f16a344777c1ab8194986ec533711cbe6c41cde841b6", size = 263871, upload-time = "2026-02-09T12:58:47.334Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/76/b829869d464115e22499541def9796b25312b8cf235d3bb00b39f1675395/coverage-7.13.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:725d985c5ab621268b2edb8e50dfe57633dc69bda071abc470fed55a14935fd3", size = 261472, upload-time = "2026-02-09T12:58:48.995Z" },
+    { url = "https://files.pythonhosted.org/packages/14/9e/caedb1679e73e2f6ad240173f55218488bfe043e38da577c4ec977489915/coverage-7.13.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3c06f0f1337c667b971ca2f975523347e63ec5e500b9aa5882d91931cd3ef750", size = 265210, upload-time = "2026-02-09T12:58:51.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/10/0dd02cb009b16ede425b49ec344aba13a6ae1dc39600840ea6abcb085ac4/coverage-7.13.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:590c0ed4bf8e85f745e6b805b2e1c457b2e33d5255dd9729743165253bc9ad39", size = 260319, upload-time = "2026-02-09T12:58:53.081Z" },
+    { url = "https://files.pythonhosted.org/packages/92/8e/234d2c927af27c6d7a5ffad5bd2cf31634c46a477b4c7adfbfa66baf7ebb/coverage-7.13.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eb30bf180de3f632cd043322dad5751390e5385108b2807368997d1a92a509d0", size = 262638, upload-time = "2026-02-09T12:58:55.258Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/64/e5547c8ff6964e5965c35a480855911b61509cce544f4d442caa759a0702/coverage-7.13.4-cp314-cp314t-win32.whl", hash = "sha256:c4240e7eded42d131a2d2c4dec70374b781b043ddc79a9de4d55ca71f8e98aea", size = 223040, upload-time = "2026-02-09T12:58:56.936Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/96/38086d58a181aac86d503dfa9c47eb20715a79c3e3acbdf786e92e5c09a8/coverage-7.13.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4c7d3cc01e7350f2f0f6f7036caaf5673fb56b6998889ccfe9e1c1fe75a9c932", size = 224148, upload-time = "2026-02-09T12:58:58.645Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/72/8d10abd3740a0beb98c305e0c3faf454366221c0f37a8bcf8f60020bb65a/coverage-7.13.4-cp314-cp314t-win_arm64.whl", hash = "sha256:23e3f687cf945070d1c90f85db66d11e3025665d8dafa831301a0e0038f3db9b", size = 222172, upload-time = "2026-02-09T12:59:00.396Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/4a/331fe2caf6799d591109bb9c08083080f6de90a823695d412a935622abb2/coverage-7.13.4-py3-none-any.whl", hash = "sha256:1af1641e57cf7ba1bd67d677c9abdbcd6cc2ab7da3bca7fa1e2b7e50e65f2ad0", size = 211242, upload-time = "2026-02-09T12:59:02.032Z" },
 ]

 [package.optional-dependencies]
@@ -235,7 +235,7 @@ wheels = [

 [[package]]
 name = "fastapi"
-version = "0.135.3"
+version = "0.135.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "annotated-doc" },
@@ -244,14 +244,14 @@ dependencies = [
    { name = "typing-extensions" },
    { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f7/e6/7adb4c5fa231e82c35b8f5741a9f2d055f520c29af5546fd70d3e8e1cd2e/fastapi-0.135.3.tar.gz", hash = "sha256:bd6d7caf1a2bdd8d676843cdcd2287729572a1ef524fc4d65c17ae002a1be654", size = 396524, upload-time = "2026-04-01T16:23:58.188Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/7b/f8e0211e9380f7195ba3f3d40c292594fd81ba8ec4629e3854c353aaca45/fastapi-0.135.1.tar.gz", hash = "sha256:d04115b508d936d254cea545b7312ecaa58a7b3a0f84952535b4c9afae7668cd", size = 394962, upload-time = "2026-03-01T18:18:29.369Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/a4/5caa2de7f917a04ada20018eccf60d6cc6145b0199d55ca3711b0fc08312/fastapi-0.135.3-py3-none-any.whl", hash = "sha256:9b0f590c813acd13d0ab43dd8494138eb58e484bfac405db1f3187cfc5810d98", size = 117734, upload-time = "2026-04-01T16:23:59.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/72/42e900510195b23a56bde950d26a51f8b723846bfcaa0286e90287f0422b/fastapi-0.135.1-py3-none-any.whl", hash = "sha256:46e2fc5745924b7c840f71ddd277382af29ce1cdb7d5eab5bf697e3fb9999c9e", size = 116999, upload-time = "2026-03-01T18:18:30.831Z" },
 ]

 [[package]]
 name = "fastapi-toolsets"
-version = "3.0.3"
+version = "2.2.0"
 source = { editable = "." }
 dependencies = [
    { name = "asyncpg" },
@@ -285,9 +285,7 @@ dev = [
    { name = "coverage" },
    { name = "fastapi-toolsets", extra = ["all"] },
    { name = "httpx" },
-    { name = "mike" },
    { name = "mkdocstrings-python" },
-    { name = "prek" },
    { name = "pytest" },
    { name = "pytest-anyio" },
    { name = "pytest-cov" },
@@ -297,7 +295,6 @@ dev = [
    { name = "zensical" },
 ]
 docs = [
-    { name = "mike" },
    { name = "mkdocstrings-python" },
    { name = "zensical" },
 ]
@@ -330,21 +327,18 @@ dev = [
    { name = "coverage", specifier = ">=7.0.0" },
    { name = "fastapi-toolsets", extras = ["all"] },
    { name = "httpx", specifier = ">=0.25.0" },
-    { name = "mike", git = "https://github.com/squidfunk/mike.git?tag=2.2.0%2Bzensical-0.1.0" },
    { name = "mkdocstrings-python", specifier = ">=2.0.2" },
-    { name = "prek", specifier = ">=0.3.8" },
    { name = "pytest", specifier = ">=8.0.0" },
    { name = "pytest-anyio", specifier = ">=0.0.0" },
    { name = "pytest-cov", specifier = ">=4.0.0" },
    { name = "pytest-xdist", specifier = ">=3.0.0" },
    { name = "ruff", specifier = ">=0.1.0" },
    { name = "ty", specifier = ">=0.0.1a0" },
-    { name = "zensical", specifier = ">=0.0.30" },
+    { name = "zensical", specifier = ">=0.0.23" },
 ]
 docs = [
-    { name = "mike", git = "https://github.com/squidfunk/mike.git?tag=2.2.0%2Bzensical-0.1.0" },
    { name = "mkdocstrings-python", specifier = ">=2.0.2" },
-    { name = "zensical", specifier = ">=0.0.30" },
+    { name = "zensical", specifier = ">=0.0.23" },
 ]
 tests = [
    { name = "coverage", specifier = ">=7.0.0" },
@@ -423,7 +417,6 @@ wheels = [
 name = "griffelib"
 version = "2.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ad/06/eccbd311c9e2b3ca45dbc063b93134c57a1ccc7607c5e545264ad092c4a9/griffelib-2.0.0.tar.gz", hash = "sha256:e504d637a089f5cab9b5daf18f7645970509bf4f53eda8d79ed71cce8bd97934", size = 166312, upload-time = "2026-03-23T21:06:55.954Z" }
 wheels = [
    { url = "https://files.pythonhosted.org/packages/4d/51/c936033e16d12b627ea334aaaaf42229c37620d0f15593456ab69ab48161/griffelib-2.0.0-py3-none-any.whl", hash = "sha256:01284878c966508b6d6f1dbff9b6fa607bc062d8261c5c7253cb285b06422a7f", size = 142004, upload-time = "2026-02-09T19:09:40.561Z" },
 ]
@@ -608,17 +601,6 @@ wheels = [
    { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354, upload-time = "2021-02-05T18:55:29.583Z" },
 ]

-[[package]]
-name = "mike"
-version = "2.2.0+zensical.0.1.0"
-source = { git = "https://github.com/squidfunk/mike.git?tag=2.2.0%2Bzensical-0.1.0#0f62791256ebeba60d20d2f1d8fe6ec3b7d1e2b3" }
-dependencies = [
-    { name = "jinja2" },
-    { name = "pyparsing" },
-    { name = "verspec" },
-    { name = "zensical" },
-]
-
 [[package]]
 name = "mkdocs"
 version = "1.6.1"
@@ -738,30 +720,6 @@ wheels = [
    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
 ]

-[[package]]
-name = "prek"
-version = "0.3.8"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/62/ee/03e8180e3fda9de25b6480bd15cc2bde40d573868d50648b0e527b35562f/prek-0.3.8.tar.gz", hash = "sha256:434a214256516f187a3ab15f869d950243be66b94ad47987ee4281b69643a2d9", size = 400224, upload-time = "2026-03-23T08:23:35.981Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/84/40d2ddf362d12c4cd4a25a8c89a862edf87cdfbf1422aa41aac8e315d409/prek-0.3.8-py3-none-linux_armv6l.whl", hash = "sha256:6fb646ada60658fa6dd7771b2e0fb097f005151be222f869dada3eb26d79ed33", size = 5226646, upload-time = "2026-03-23T08:23:18.306Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/52/7308a033fa43b7e8e188797bd2b3b017c0f0adda70fa7af575b1f43ea888/prek-0.3.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:f3d7fdadb15efc19c09953c7a33cf2061a70f367d1e1957358d3ad5cc49d0616", size = 5620104, upload-time = "2026-03-23T08:23:40.053Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/b1/f106ac000a91511a9cd80169868daf2f5b693480ef5232cec5517a38a512/prek-0.3.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:72728c3295e79ca443f8c1ec037d2a5b914ec73a358f69cf1bc1964511876bf8", size = 5199867, upload-time = "2026-03-23T08:23:38.066Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/e9/970713f4b019f69de9844e1bab37b8ddb67558e410916f4eb5869a696165/prek-0.3.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:48efc28f2f53b5b8087efca9daaed91572d62df97d5f24a1c7a087fecb5017de", size = 5441801, upload-time = "2026-03-23T08:23:32.617Z" },
-    { url = "https://files.pythonhosted.org/packages/12/a4/7ef44032b181753e19452ec3b09abb3a32607cf6b0a0508f0604becaaf2b/prek-0.3.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f6ca9d63bacbc448a5c18e955c78d3ac5176c3a17c3baacdd949b1a623e08a36", size = 5155107, upload-time = "2026-03-23T08:23:31.021Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/77/4d9c8985dbba84149760785dfe07093ea1e29d710257dfb7c89615e2234c/prek-0.3.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1000f7029696b4fe712fb1fefd4c55b9c4de72b65509c8e50296370a06f9dc3f", size = 5566541, upload-time = "2026-03-23T08:23:45.694Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/1a/81e6769ac1f7f8346d09ce2ab0b47cf06466acd9ff72e87e5d1f0d98cd32/prek-0.3.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6ff0bed0e2c1286522987d982168a86cbbd0d069d840506a46c9fda983515517", size = 6552991, upload-time = "2026-03-23T08:23:21.958Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/fa/ce2df0dd2dc75a9437a52463239d0782998943d7b04e191fb89b83016c34/prek-0.3.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4fb087ac0ffda3ac65bbbae9a38326a7fd27ee007bb4a94323ce1eb539d8bbec", size = 5832972, upload-time = "2026-03-23T08:23:20.258Z" },
-    { url = "https://files.pythonhosted.org/packages/18/6b/9d4269df9073216d296244595a21c253b6475dfc9076c0bd2906be7a436c/prek-0.3.8-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:2e1e5e206ff7b31bd079cce525daddc96cd6bc544d20dc128921ad92f7a4c85d", size = 5448371, upload-time = "2026-03-23T08:23:41.835Z" },
-    { url = "https://files.pythonhosted.org/packages/60/1d/1e4d8a78abefa5b9d086e5a9f1638a74b5e540eec8a648d9946707701f29/prek-0.3.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:dcea3fe23832a4481bccb7c45f55650cb233be7c805602e788bb7dba60f2d861", size = 5270546, upload-time = "2026-03-23T08:23:24.231Z" },
-    { url = "https://files.pythonhosted.org/packages/77/07/34f36551a6319ae36e272bea63a42f59d41d2d47ab0d5fb00eb7b4e88e87/prek-0.3.8-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:4d25e647e9682f6818ab5c31e7a4b842993c14782a6ffcd128d22b784e0d677f", size = 5124032, upload-time = "2026-03-23T08:23:26.368Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/01/6d544009bb655e709993411796af77339f439526db4f3b3509c583ad8eb9/prek-0.3.8-py3-none-musllinux_1_1_i686.whl", hash = "sha256:de528b82935e33074815acff3c7c86026754d1212136295bc88fe9c43b4231d5", size = 5432245, upload-time = "2026-03-23T08:23:47.877Z" },
-    { url = "https://files.pythonhosted.org/packages/54/96/1237ee269e9bfa283ffadbcba1f401f48a47aed2b2563eb1002740d6079d/prek-0.3.8-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:6d660f1c25a126e6d9f682fe61449441226514f412a4469f5d71f8f8cad56db2", size = 5950550, upload-time = "2026-03-23T08:23:43.8Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/6b/a574411459049bc691047c9912f375deda10c44a707b6ce98df2b658f0b3/prek-0.3.8-py3-none-win32.whl", hash = "sha256:b0c291c577615d9f8450421dff0b32bfd77a6b0d223ee4115a1f820cb636fdf1", size = 4949501, upload-time = "2026-03-23T08:23:16.338Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/b4/46b59fe49f635acd9f6530778ce577f9d8b49452835726a5311ffc902c67/prek-0.3.8-py3-none-win_amd64.whl", hash = "sha256:bc147fdbdd4ec33fc7a987b893ecb69b1413ac100d95c9889a70f3fd58c73d06", size = 5346551, upload-time = "2026-03-23T08:23:34.501Z" },
-    { url = "https://files.pythonhosted.org/packages/53/05/9cca1708bb8c65264124eb4b04251e0f65ce5bfc707080bb6b492d5a0df7/prek-0.3.8-py3-none-win_arm64.whl", hash = "sha256:a2614647aeafa817a5802ccb9561e92eedc20dcf840639a1b00826e2c2442515", size = 5190872, upload-time = "2026-03-23T08:23:29.463Z" },
-]
-
 [[package]]
 name = "prometheus-client"
 version = "0.24.1"
@@ -885,33 +843,24 @@ wheels = [

 [[package]]
 name = "pygments"
-version = "2.20.0"
+version = "2.19.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
 ]

 [[package]]
 name = "pymdown-extensions"
-version = "10.21.2"
+version = "10.21"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "markdown" },
    { name = "pyyaml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/df/08/f1c908c581fd11913da4711ea7ba32c0eee40b0190000996bb863b0c9349/pymdown_extensions-10.21.2.tar.gz", hash = "sha256:c3f55a5b8a1d0edf6699e35dcbea71d978d34ff3fa79f3d807b8a5b3fa90fbdc", size = 853922, upload-time = "2026-03-29T15:01:55.233Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/63/06673d1eb6d8f83c0ea1f677d770e12565fb516928b4109c9e2055656a9e/pymdown_extensions-10.21.tar.gz", hash = "sha256:39f4a020f40773f6b2ff31d2cd2546c2c04d0a6498c31d9c688d2be07e1767d5", size = 853363, upload-time = "2026-02-15T20:44:06.748Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/27/a2fc51a4a122dfd1015e921ae9d22fee3d20b0b8080d9a704578bf9deece/pymdown_extensions-10.21.2-py3-none-any.whl", hash = "sha256:5c0fd2a2bea14eb39af8ff284f1066d898ab2187d81b889b75d46d4348c01638", size = 268901, upload-time = "2026-03-29T15:01:53.244Z" },
-]
-
-[[package]]
-name = "pyparsing"
-version = "3.3.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/2c/5b079febdc65e1c3fb2729bf958d18b45be7113828528e8a0b5850dd819a/pymdown_extensions-10.21-py3-none-any.whl", hash = "sha256:91b879f9f864d49794c2d9534372b10150e6141096c3908a455e45ca72ad9d3f", size = 268877, upload-time = "2026-02-15T20:44:05.464Z" },
 ]

 [[package]]
@@ -945,16 +894,16 @@ wheels = [

 [[package]]
 name = "pytest-cov"
-version = "7.1.0"
+version = "7.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "coverage", extra = ["toml"] },
    { name = "pluggy" },
    { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
 ]

 [[package]]
@@ -1064,27 +1013,27 @@ wheels = [

 [[package]]
 name = "ruff"
-version = "0.15.8"
+version = "0.15.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/14/b0/73cf7550861e2b4824950b8b52eebdcc5adc792a00c514406556c5b80817/ruff-0.15.8.tar.gz", hash = "sha256:995f11f63597ee362130d1d5a327a87cb6f3f5eae3094c620bcc632329a4d26e", size = 4610921, upload-time = "2026-03-26T18:39:38.675Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/31/d6e536cdebb6568ae75a7f00e4b4819ae0ad2640c3604c305a0428680b0c/ruff-0.15.4.tar.gz", hash = "sha256:3412195319e42d634470cc97aa9803d07e9d5c9223b99bcb1518f0c725f26ae1", size = 4569550, upload-time = "2026-02-26T20:04:14.959Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4a/92/c445b0cd6da6e7ae51e954939cb69f97e008dbe750cfca89b8cedc081be7/ruff-0.15.8-py3-none-linux_armv6l.whl", hash = "sha256:cbe05adeba76d58162762d6b239c9056f1a15a55bd4b346cfd21e26cd6ad7bc7", size = 10527394, upload-time = "2026-03-26T18:39:41.566Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/92/f1c662784d149ad1414cae450b082cf736430c12ca78367f20f5ed569d65/ruff-0.15.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:d3e3d0b6ba8dca1b7ef9ab80a28e840a20070c4b62e56d675c24f366ef330570", size = 10905693, upload-time = "2026-03-26T18:39:30.364Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/f2/7a631a8af6d88bcef997eb1bf87cc3da158294c57044aafd3e17030613de/ruff-0.15.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:6ee3ae5c65a42f273f126686353f2e08ff29927b7b7e203b711514370d500de3", size = 10323044, upload-time = "2026-03-26T18:39:33.37Z" },
-    { url = "https://files.pythonhosted.org/packages/67/18/1bf38e20914a05e72ef3b9569b1d5c70a7ef26cd188d69e9ca8ef588d5bf/ruff-0.15.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdce027ada77baa448077ccc6ebb2fa9c3c62fd110d8659d601cf2f475858d94", size = 10629135, upload-time = "2026-03-26T18:39:44.142Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/e9/138c150ff9af60556121623d41aba18b7b57d95ac032e177b6a53789d279/ruff-0.15.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:12e617fc01a95e5821648a6df341d80456bd627bfab8a829f7cfc26a14a4b4a3", size = 10348041, upload-time = "2026-03-26T18:39:52.178Z" },
-    { url = "https://files.pythonhosted.org/packages/02/f1/5bfb9298d9c323f842c5ddeb85f1f10ef51516ac7a34ba446c9347d898df/ruff-0.15.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:432701303b26416d22ba696c39f2c6f12499b89093b61360abc34bcc9bf07762", size = 11121987, upload-time = "2026-03-26T18:39:55.195Z" },
-    { url = "https://files.pythonhosted.org/packages/10/11/6da2e538704e753c04e8d86b1fc55712fdbdcc266af1a1ece7a51fff0d10/ruff-0.15.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d910ae974b7a06a33a057cb87d2a10792a3b2b3b35e33d2699fdf63ec8f6b17a", size = 11951057, upload-time = "2026-03-26T18:39:19.18Z" },
-    { url = "https://files.pythonhosted.org/packages/83/f0/c9208c5fd5101bf87002fed774ff25a96eea313d305f1e5d5744698dc314/ruff-0.15.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2033f963c43949d51e6fdccd3946633c6b37c484f5f98c3035f49c27395a8ab8", size = 11464613, upload-time = "2026-03-26T18:40:06.301Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/22/d7f2fabdba4fae9f3b570e5605d5eb4500dcb7b770d3217dca4428484b17/ruff-0.15.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f29b989a55572fb885b77464cf24af05500806ab4edf9a0fd8977f9759d85b1", size = 11257557, upload-time = "2026-03-26T18:39:57.972Z" },
-    { url = "https://files.pythonhosted.org/packages/71/8c/382a9620038cf6906446b23ce8632ab8c0811b8f9d3e764f58bedd0c9a6f/ruff-0.15.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:ac51d486bf457cdc985a412fb1801b2dfd1bd8838372fc55de64b1510eff4bec", size = 11169440, upload-time = "2026-03-26T18:39:22.205Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/0d/0994c802a7eaaf99380085e4e40c845f8e32a562e20a38ec06174b52ef24/ruff-0.15.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:c9861eb959edab053c10ad62c278835ee69ca527b6dcd72b47d5c1e5648964f6", size = 10605963, upload-time = "2026-03-26T18:39:46.682Z" },
-    { url = "https://files.pythonhosted.org/packages/19/aa/d624b86f5b0aad7cef6bbf9cd47a6a02dfdc4f72c92a337d724e39c9d14b/ruff-0.15.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8d9a5b8ea13f26ae90838afc33f91b547e61b794865374f114f349e9036835fb", size = 10357484, upload-time = "2026-03-26T18:39:49.176Z" },
-    { url = "https://files.pythonhosted.org/packages/35/c3/e0b7835d23001f7d999f3895c6b569927c4d39912286897f625736e1fd04/ruff-0.15.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c2a33a529fb3cbc23a7124b5c6ff121e4d6228029cba374777bd7649cc8598b8", size = 10830426, upload-time = "2026-03-26T18:40:03.702Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/51/ab20b322f637b369383adc341d761eaaa0f0203d6b9a7421cd6e783d81b9/ruff-0.15.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:75e5cd06b1cf3f47a3996cfc999226b19aa92e7cce682dcd62f80d7035f98f49", size = 11345125, upload-time = "2026-03-26T18:39:27.799Z" },
-    { url = "https://files.pythonhosted.org/packages/37/e6/90b2b33419f59d0f2c4c8a48a4b74b460709a557e8e0064cf33ad894f983/ruff-0.15.8-py3-none-win32.whl", hash = "sha256:bc1f0a51254ba21767bfa9a8b5013ca8149dcf38092e6a9eb704d876de94dc34", size = 10571959, upload-time = "2026-03-26T18:39:36.117Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/a2/ef467cb77099062317154c63f234b8a7baf7cb690b99af760c5b68b9ee7f/ruff-0.15.8-py3-none-win_amd64.whl", hash = "sha256:04f79eff02a72db209d47d665ba7ebcad609d8918a134f86cb13dd132159fc89", size = 11743893, upload-time = "2026-03-26T18:39:25.01Z" },
-    { url = "https://files.pythonhosted.org/packages/15/e2/77be4fff062fa78d9b2a4dea85d14785dac5f1d0c1fb58ed52331f0ebe28/ruff-0.15.8-py3-none-win_arm64.whl", hash = "sha256:cf891fa8e3bb430c0e7fac93851a5978fc99c8fa2c053b57b118972866f8e5f2", size = 11048175, upload-time = "2026-03-26T18:40:01.06Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/82/c11a03cfec3a4d26a0ea1e571f0f44be5993b923f905eeddfc397c13d360/ruff-0.15.4-py3-none-linux_armv6l.whl", hash = "sha256:a1810931c41606c686bae8b5b9a8072adac2f611bb433c0ba476acba17a332e0", size = 10453333, upload-time = "2026-02-26T20:04:20.093Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/5d/6a1f271f6e31dffb31855996493641edc3eef8077b883eaf007a2f1c2976/ruff-0.15.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5a1632c66672b8b4d3e1d1782859e98d6e0b4e70829530666644286600a33992", size = 10853356, upload-time = "2026-02-26T20:04:05.808Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/d8/0fab9f8842b83b1a9c2bf81b85063f65e93fb512e60effa95b0be49bfc54/ruff-0.15.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a4386ba2cd6c0f4ff75252845906acc7c7c8e1ac567b7bc3d373686ac8c222ba", size = 10187434, upload-time = "2026-02-26T20:03:54.656Z" },
+    { url = "https://files.pythonhosted.org/packages/85/cc/cc220fd9394eff5db8d94dec199eec56dd6c9f3651d8869d024867a91030/ruff-0.15.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2496488bdfd3732747558b6f95ae427ff066d1fcd054daf75f5a50674411e75", size = 10535456, upload-time = "2026-02-26T20:03:52.738Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/0f/bced38fa5cf24373ec767713c8e4cadc90247f3863605fb030e597878661/ruff-0.15.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f1c4893841ff2d54cbda1b2860fa3260173df5ddd7b95d370186f8a5e66a4ac", size = 10287772, upload-time = "2026-02-26T20:04:08.138Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/90/58a1802d84fed15f8f281925b21ab3cecd813bde52a8ca033a4de8ab0e7a/ruff-0.15.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:820b8766bd65503b6c30aaa6331e8ef3a6e564f7999c844e9a547c40179e440a", size = 11049051, upload-time = "2026-02-26T20:04:03.53Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ac/b7ad36703c35f3866584564dc15f12f91cb1a26a897dc2fd13d7cb3ae1af/ruff-0.15.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9fb74bab47139c1751f900f857fa503987253c3ef89129b24ed375e72873e85", size = 11890494, upload-time = "2026-02-26T20:04:10.497Z" },
+    { url = "https://files.pythonhosted.org/packages/93/3d/3eb2f47a39a8b0da99faf9c54d3eb24720add1e886a5309d4d1be73a6380/ruff-0.15.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f80c98765949c518142b3a50a5db89343aa90f2c2bf7799de9986498ae6176db", size = 11326221, upload-time = "2026-02-26T20:04:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/90/bf134f4c1e5243e62690e09d63c55df948a74084c8ac3e48a88468314da6/ruff-0.15.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451a2e224151729b3b6c9ffb36aed9091b2996fe4bdbd11f47e27d8f2e8888ec", size = 11168459, upload-time = "2026-02-26T20:04:00.969Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e5/a64d27688789b06b5d55162aafc32059bb8c989c61a5139a36e1368285eb/ruff-0.15.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a8f157f2e583c513c4f5f896163a93198297371f34c04220daf40d133fdd4f7f", size = 11104366, upload-time = "2026-02-26T20:03:48.099Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/f6/32d1dcb66a2559763fc3027bdd65836cad9eb09d90f2ed6a63d8e9252b02/ruff-0.15.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:917cc68503357021f541e69b35361c99387cdbbf99bd0ea4aa6f28ca99ff5338", size = 10510887, upload-time = "2026-02-26T20:03:45.771Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/92/22d1ced50971c5b6433aed166fcef8c9343f567a94cf2b9d9089f6aa80fe/ruff-0.15.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e9737c8161da79fd7cfec19f1e35620375bd8b2a50c3e77fa3d2c16f574105cc", size = 10285939, upload-time = "2026-02-26T20:04:22.42Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/f4/7c20aec3143837641a02509a4668fb146a642fd1211846634edc17eb5563/ruff-0.15.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:291258c917539e18f6ba40482fe31d6f5ac023994ee11d7bdafd716f2aab8a68", size = 10765471, upload-time = "2026-02-26T20:03:58.924Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/09/6d2f7586f09a16120aebdff8f64d962d7c4348313c77ebb29c566cefc357/ruff-0.15.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3f83c45911da6f2cd5936c436cf86b9f09f09165f033a99dcf7477e34041cbc3", size = 11263382, upload-time = "2026-02-26T20:04:24.424Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/fa/2ef715a1cd329ef47c1a050e10dee91a9054b7ce2fcfdd6a06d139afb7ec/ruff-0.15.4-py3-none-win32.whl", hash = "sha256:65594a2d557d4ee9f02834fcdf0a28daa8b3b9f6cb2cb93846025a36db47ef22", size = 10506664, upload-time = "2026-02-26T20:03:50.56Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/a8/c688ef7e29983976820d18710f955751d9f4d4eb69df658af3d006e2ba3e/ruff-0.15.4-py3-none-win_amd64.whl", hash = "sha256:04196ad44f0df220c2ece5b0e959c2f37c777375ec744397d21d15b50a75264f", size = 11651048, upload-time = "2026-02-26T20:04:17.191Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/0a/9e1be9035b37448ce2e68c978f0591da94389ade5a5abafa4cf99985d1b2/ruff-0.15.4-py3-none-win_arm64.whl", hash = "sha256:60d5177e8cfc70e51b9c5fad936c634872a74209f934c1e79107d11787ad5453", size = 10966776, upload-time = "2026-02-26T20:03:56.908Z" },
 ]

 [[package]]
@@ -1228,26 +1177,26 @@ wheels = [

 [[package]]
 name = "ty"
-version = "0.0.27"
+version = "0.0.20"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f4/de/e5cf1f151cf52fe1189e42d03d90909d7d1354fdc0c1847cbb63a0baa3da/ty-0.0.27.tar.gz", hash = "sha256:d7a8de3421d92420b40c94fe7e7d4816037560621903964dd035cf9bd0204a73", size = 5424130, upload-time = "2026-03-31T19:07:20.806Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/56/95/8de69bb98417227b01f1b1d743c819d6456c9fd140255b6124b05b17dfd6/ty-0.0.20.tar.gz", hash = "sha256:ebba6be7974c14efbb2a9adda6ac59848f880d7259f089dfa72a093039f1dcc6", size = 5262529, upload-time = "2026-03-02T15:51:36.587Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/20/2a9ea661758bd67f2bfd54ce9daacb5a26c56c5f8b49fbd9a43b365a8a7d/ty-0.0.27-py3-none-linux_armv6l.whl", hash = "sha256:eb14456b8611c9e8287aa9b633f4d2a0d9f3082a31796969e0b50bdda8930281", size = 10571211, upload-time = "2026-03-31T19:07:23.28Z" },
-    { url = "https://files.pythonhosted.org/packages/da/b2/8887a51f705d075ddbe78ae7f0d4755ef48d0a90235f67aee289e9cee950/ty-0.0.27-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:02e662184703db7586118df611cf24a000d35dae38d950053d1dd7b6736fd2c4", size = 10427576, upload-time = "2026-03-31T19:07:15.499Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/c3/79d88163f508fb709ce19bc0b0a66c7c64b53d372d4caa56172c3d9b3ae8/ty-0.0.27-py3-none-macosx_11_0_arm64.whl", hash = "sha256:be5fc2899441f7f8f7ef40f9ffd006075a5ff6b06c44e8d2aa30e1b900c12f51", size = 9870359, upload-time = "2026-03-31T19:07:36.852Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/4d/ed1b0db0e1e46b5ed4976bbfe0d1825faf003b4e3774ef28c785ed73e4bb/ty-0.0.27-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30231e652b14742a76b64755e54bf0cb1cd4c128bcaf625222e0ca92a2094887", size = 10380488, upload-time = "2026-03-31T19:07:31.268Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/f2/20372f6d510b01570028433064880adec2f8abe68bf0c4603be61a560bef/ty-0.0.27-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5a119b1168f64261b3205a37e40b5b6c4aac8fd58e4587988f4e4b22c3c79847", size = 10390248, upload-time = "2026-03-31T19:07:28.345Z" },
-    { url = "https://files.pythonhosted.org/packages/45/4b/46b31a7311306be1a560f7f20fdc37b5bf718787f60626cd265d9b637554/ty-0.0.27-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e38f4e187b6975d2cbebf0f1eb1221f8f64f6e509bad14d7bb2a91afc97e4956", size = 10878479, upload-time = "2026-03-31T19:07:39.393Z" },
-    { url = "https://files.pythonhosted.org/packages/42/ba/5231a2a1fb1cebe053a25de8fded95e1a30a1e77d3628a9e58487297bafc/ty-0.0.27-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a07b1a8fbb23844f6d22091275430d9ac617175f34aa99159b268193de210389", size = 11461232, upload-time = "2026-03-31T19:07:02.518Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/37/558abab3e1f6670493524f61280b4dfcc3219555f13889223e733381dfab/ty-0.0.27-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d3ec4033031f240836bb0337274bac5c49dde312c7c6d7575451ed719bf8ffa3", size = 11133002, upload-time = "2026-03-31T19:07:18.371Z" },
-    { url = "https://files.pythonhosted.org/packages/32/38/188c14a57f52160407ce62c6abb556011718fd0bcbe1dca690529ce84c46/ty-0.0.27-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:924a8849afd500d260bf5b7296165a05b7424fbb6b19113f30f3b999d682873f", size = 10986624, upload-time = "2026-03-31T19:07:13.066Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/f1/667a71393f47d2cd6ba9ed07541b8df3eb63aab1f2ee658e77d91b8362fa/ty-0.0.27-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d8270026c07e7423a1b3a3fd065b46ed1478748f0662518b523b57744f3fa025", size = 10366721, upload-time = "2026-03-31T19:07:00.131Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/aa/8edafe41be898bda774249abc5be6edd733e53fb1777d59ea9331e38537d/ty-0.0.27-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e26e9735d3bdfd95d881111ad1cf570eab8188d8c3be36d6bcaad044d38984d8", size = 10412239, upload-time = "2026-03-31T19:07:05.297Z" },
-    { url = "https://files.pythonhosted.org/packages/53/ff/8bafaed4a18d38264f46bdfc427de7ea2974cf9064e4e0bdb1b6e6c724e3/ty-0.0.27-py3-none-musllinux_1_2_i686.whl", hash = "sha256:7c09cc9a699810609acc0090af8d0db68adaee6e60a7c3e05ab80cc954a83db7", size = 10573507, upload-time = "2026-03-31T19:06:57.064Z" },
-    { url = "https://files.pythonhosted.org/packages/16/2e/63a8284a2fefd08ab56ecbad0fde7dd4b2d4045a31cf24c1d1fcd9643227/ty-0.0.27-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:2d3e02853bb037221a456e034b1898aaa573e6374fbb53884e33cb7513ccb85a", size = 11090233, upload-time = "2026-03-31T19:07:34.139Z" },
-    { url = "https://files.pythonhosted.org/packages/14/d3/d6fa1cafdfa2b34dbfa304fc6833af8e1669fc34e24d214fa76d2a2e5a25/ty-0.0.27-py3-none-win32.whl", hash = "sha256:34e7377f2047c14dbbb7bf5322e84114db7a5f2cb470db6bee63f8f3550cfc1e", size = 9984415, upload-time = "2026-03-31T19:07:07.98Z" },
-    { url = "https://files.pythonhosted.org/packages/85/e6/dd4e27da9632b3472d5711ca49dbd3709dbd3e8c73f3af6db9c254235ca9/ty-0.0.27-py3-none-win_amd64.whl", hash = "sha256:3f7e4145aad8b815ed69b324c93b5b773eb864dda366ca16ab8693ff88ce6f36", size = 10961535, upload-time = "2026-03-31T19:07:10.566Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/1a/824b3496d66852ed7d5d68d9787711131552b68dce8835ce9410db32e618/ty-0.0.27-py3-none-win_arm64.whl", hash = "sha256:95bf8d01eb96bb2ba3ffc39faff19da595176448e80871a7b362f4d2de58476c", size = 10376689, upload-time = "2026-03-31T19:07:25.732Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/2c/718abe48393e521bf852cd6b0f984766869b09c258d6e38a118768a91731/ty-0.0.20-py3-none-linux_armv6l.whl", hash = "sha256:7cc12769c169c9709a829c2248ee2826b7aae82e92caeac813d856f07c021eae", size = 10333656, upload-time = "2026-03-02T15:51:56.461Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0e/eb1c4cc4a12862e2327b72657bcebb10b7d9f17046f1bdcd6457a0211615/ty-0.0.20-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:3b777c1bf13bc0a95985ebb8a324b8668a4a9b2e514dde5ccf09e4d55d2ff232", size = 10168505, upload-time = "2026-03-02T15:51:51.895Z" },
+    { url = "https://files.pythonhosted.org/packages/89/7f/10230798e673f0dd3094dfd16e43bfd90e9494e7af6e8e7db516fb431ddf/ty-0.0.20-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b2a4a7db48bf8cba30365001bc2cad7fd13c1a5aacdd704cc4b7925de8ca5eb3", size = 9678510, upload-time = "2026-03-02T15:51:48.451Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/3d/59d9159577494edd1728f7db77b51bb07884bd21384f517963114e3ab5f6/ty-0.0.20-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6846427b8b353a43483e9c19936dc6a25612573b44c8f7d983dfa317e7f00d4c", size = 10162926, upload-time = "2026-03-02T15:51:40.558Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a8/b7273eec3e802f78eb913fbe0ce0c16ef263723173e06a5776a8359b2c66/ty-0.0.20-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:245ceef5bd88df366869385cf96411cb14696334f8daa75597cf7e41c3012eb8", size = 10171702, upload-time = "2026-03-02T15:51:44.069Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/32/5f1144f2f04a275109db06e3498450c4721554215b80ae73652ef412eeab/ty-0.0.20-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c4d21d1cdf67a444d3c37583c17291ddba9382a9871021f3f5d5735e09e85efe", size = 10682552, upload-time = "2026-03-02T15:51:33.102Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/db/9f1f637310792f12bd6ed37d5fc8ab39ba1a9b0c6c55a33865e9f1cad840/ty-0.0.20-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bd4ffd907d1bd70e46af9e9a2f88622f215e1bf44658ea43b32c2c0b357299e4", size = 11242605, upload-time = "2026-03-02T15:51:34.895Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/68/cc9cae2e732fcfd20ccdffc508407905a023fc8493b8771c392d915528dc/ty-0.0.20-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b6594b58d8b0e9d16a22b3045fc1305db4b132c8d70c17784ab8c7a7cc986807", size = 10974655, upload-time = "2026-03-02T15:51:46.011Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/c1/b9e3e3f28fe63486331e653f6aeb4184af8b1fe80542fcf74d2dda40a93d/ty-0.0.20-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3662f890518ce6cf4d7568f57d03906912d2afbf948a01089a28e325b1ef198c", size = 10761325, upload-time = "2026-03-02T15:51:26.818Z" },
+    { url = "https://files.pythonhosted.org/packages/39/9e/67db935bdedf219a00fb69ec5437ba24dab66e0f2e706dd54a4eca234b84/ty-0.0.20-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0e3ffbae58f9f0d17cdc4ac6d175ceae560b7ed7d54f9ddfb1c9f31054bcdc2c", size = 10145793, upload-time = "2026-03-02T15:51:38.562Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/de/b0eb815d4dc5a819c7e4faddc2a79058611169f7eef07ccc006531ce228c/ty-0.0.20-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:176e52bc8bb00b0e84efd34583962878a447a3a0e34ecc45fd7097a37554261b", size = 10189640, upload-time = "2026-03-02T15:51:50.202Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/71/63734923965cbb70df1da3e93e4b8875434e326b89e9f850611122f279bf/ty-0.0.20-py3-none-musllinux_1_2_i686.whl", hash = "sha256:b2bc73025418e976ca4143dde71fb9025a90754a08ac03e6aa9b80d4bed1294b", size = 10370568, upload-time = "2026-03-02T15:51:42.295Z" },
+    { url = "https://files.pythonhosted.org/packages/32/a0/a532c2048533347dff48e9ca98bd86d2c224356e101688a8edaf8d6973fb/ty-0.0.20-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:d52f7c9ec6e363e094b3c389c344d5a140401f14a77f0625e3f28c21918552f5", size = 10853999, upload-time = "2026-03-02T15:51:58.963Z" },
+    { url = "https://files.pythonhosted.org/packages/48/88/36c652c658fe96658043e4abc8ea97801de6fb6e63ab50aaa82807bff1d8/ty-0.0.20-py3-none-win32.whl", hash = "sha256:c7d32bfe93f8fcaa52b6eef3f1b930fd7da410c2c94e96f7412c30cfbabf1d17", size = 9744206, upload-time = "2026-03-02T15:51:54.183Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/a7/a4a13bed1d7fd9d97aaa3c5bb5e6d3e9a689e6984806cbca2ab4c9233cac/ty-0.0.20-py3-none-win_amd64.whl", hash = "sha256:a5e10f40fc4a0a1cbcb740a4aad5c7ce35d79f030836ea3183b7a28f43170248", size = 10711999, upload-time = "2026-03-02T15:51:29.212Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/7e/6bfd748a9f4ff9267ed3329b86a0f02cdf6ab49f87bc36c8a164852f99fc/ty-0.0.20-py3-none-win_arm64.whl", hash = "sha256:53f7a5c12c960e71f160b734f328eff9a35d578af4b67a36b0bb5990ac5cdc27", size = 10150143, upload-time = "2026-03-02T15:51:31.283Z" },
 ]

 [[package]]
@@ -1286,15 +1235,6 @@ wheels = [
    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
 ]

-[[package]]
-name = "verspec"
-version = "0.1.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e7/44/8126f9f0c44319b2efc65feaad589cadef4d77ece200ae3c9133d58464d0/verspec-0.1.0.tar.gz", hash = "sha256:c4504ca697b2056cdb4bfa7121461f5a0e81809255b41c03dda4ba823637c01e", size = 27123, upload-time = "2020-11-30T02:24:09.646Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a4/ce/3b6fee91c85626eaf769d617f1be9d2e15c1cca027bbdeb2e0d751469355/verspec-0.1.0-py3-none-any.whl", hash = "sha256:741877d5633cc9464c45a469ae2a31e801e6dbbaa85b9675d481cda100f11c31", size = 19640, upload-time = "2020-11-30T02:24:08.387Z" },
-]
-
 [[package]]
 name = "watchdog"
 version = "6.0.0"
@@ -1324,7 +1264,7 @@ wheels = [

 [[package]]
 name = "zensical"
-version = "0.0.31"
+version = "0.0.24"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "click" },
@@ -1334,18 +1274,18 @@ dependencies = [
    { name = "pymdown-extensions" },
    { name = "pyyaml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d5/1a/9b6f5285c5aef648db38f9132f49a7059bd2c9d748f68ef0c52ed8afcff3/zensical-0.0.31.tar.gz", hash = "sha256:9c12f07bde70c4bfdb13d6cae1bedf8d18064d257a6e81128a152502b28a8fc3", size = 3891758, upload-time = "2026-04-01T11:30:21.88Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3b/96/9c6cbdd7b351d1023cdbbcf7872d4cb118b0334cfe5821b99e0dd18e3f00/zensical-0.0.24.tar.gz", hash = "sha256:b5d99e225329bf4f98c8022bdf0a0ee9588c2fada7b4df1b7b896fcc62b37ec3", size = 3840688, upload-time = "2026-02-26T09:43:44.557Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/db/cc4e555d2e816f2d91304ff969d62cc3a401ee477dbb7c720b874bec67d6/zensical-0.0.31-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:b489936d670733dd204f16b689a2acc0e45b69e42cc4901f5131ae57658b8fbc", size = 12419980, upload-time = "2026-04-01T11:29:44.01Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/c1/6789f73164c7f5821f5defb8a80b1dba8d5af24bdec7db36876793c5afd9/zensical-0.0.31-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:d9f678efc0d9918e45eeb8bc62847b2cce23db7393c8c59c1be6d1c064bbaacd", size = 12292301, upload-time = "2026-04-01T11:29:47.277Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/9a/6a83ad209081a953e0285d5056e5452c4fbcabd2f104f3797d53e4bdd96f/zensical-0.0.31-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb2b50ecf674997f818e53f12f2a67875a21b0c79ed74c151dfaef2f1475e5bf", size = 12661472, upload-time = "2026-04-01T11:29:50.706Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/4a/a82f5c81893b7a607cf9d439b75c3c3894b4ef4d3e92d5d818b4fa5c6f23/zensical-0.0.31-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6fb5c634fe88254770a2d4db5c05b06f1c3ee5e29d2ae3e7efdae8905e435b1d", size = 12603784, upload-time = "2026-04-01T11:29:53.623Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/1c/79c198628b8e006be32dfb1c5b73561757a349a6cf3069600a67ffa62495/zensical-0.0.31-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:94e64630552793274db1ec66c971e49a15ad351536d5d12de67ec6da7358ac50", size = 12959832, upload-time = "2026-04-01T11:29:56.736Z" },
-    { url = "https://files.pythonhosted.org/packages/db/9d/45839d9ca0f69622e8a3b944f2d8d7f7d2b7c2da78201079c4feb275feb6/zensical-0.0.31-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:738a2fd5832e3b3c10ff642eebaf89c89ca1d28e4451dad0f36fdac53c415577", size = 12704024, upload-time = "2026-04-01T11:29:59.836Z" },
-    { url = "https://files.pythonhosted.org/packages/df/5f/451d7f4d94092bc38bd8d514826fb7b0329c188db506795b1d20bd07d517/zensical-0.0.31-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:bd601f6132e285ef6c3e4c3852be2094fc0473295a8080003db76a79760f84fb", size = 12837788, upload-time = "2026-04-01T11:30:03.048Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/39/390a8fc384fb174ebd4450343a0aa2877b3a31ddcedf5ef0b8d26944e12c/zensical-0.0.31-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:dc3b6a9dfb5903c0aa779ef65cd6185add2b8aa1db237be840874b8c9db761b8", size = 12876822, upload-time = "2026-04-01T11:30:06.418Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/60/640da2f095782cf38974cd851fb7afa62651d09a36543a1d8942b31aabdc/zensical-0.0.31-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:ddd4321b275e82c4897aa45b05038ce204b88fb311ad55f8c2af572173a9b56c", size = 13024036, upload-time = "2026-04-01T11:30:09.501Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/06/0564377cbfccea3653254adfa851c1b20d1696e4b16770c7b2e1dd1ef1d7/zensical-0.0.31-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:147ab4bc17f3088f703aa6c4b9c416411f4ea8ca64d26f6586beae49d97fd3c7", size = 12975505, upload-time = "2026-04-01T11:30:12.268Z" },
-    { url = "https://files.pythonhosted.org/packages/35/4b/b8a0c4e5937cb05882dcce667798403e00897135080a69f92363e5e3ff9f/zensical-0.0.31-cp310-abi3-win32.whl", hash = "sha256:03fa11e629a308507693489541f43e751697784e94365e7435b02104aefd1c2c", size = 12011233, upload-time = "2026-04-01T11:30:15.496Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/99/0eacdb466d344c0c86596932201268517be42f3e0bb6c78b2b0cd84c55f6/zensical-0.0.31-cp310-abi3-win_amd64.whl", hash = "sha256:d6621d4bb46af4143560045d4a18c8c76302db56bf1dbb6e2ce107d7fb643e09", size = 12207545, upload-time = "2026-04-01T11:30:19.054Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/aa/b8201af30e376a67566f044a1c56210edac5ae923fd986a836d2cf593c9c/zensical-0.0.24-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:d390c5453a5541ca35d4f9e1796df942b6612c546e3153dd928236d3b758409a", size = 12263407, upload-time = "2026-02-26T09:43:14.716Z" },
+    { url = "https://files.pythonhosted.org/packages/78/8e/3d910214471ade604fd39b080db3696864acc23678b5b4b8475c7dbfd2ce/zensical-0.0.24-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:81ac072869cf4d280853765b2bfb688653da0dfb9408f3ab15aca96455ab8223", size = 12142610, upload-time = "2026-02-26T09:43:17.546Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d7/eb0983640aa0419ddf670298cfbcf8b75629b6484925429b857851e00784/zensical-0.0.24-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5eb1dfa84cae8e960bfa2c6851d2bc8e9710c4c4c683bd3aaf23185f646ae46", size = 12508380, upload-time = "2026-02-26T09:43:20.114Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/04/4405b9e6f937a75db19f0d875798a7eb70817d6a3bec2a2d289a2d5e8aea/zensical-0.0.24-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:57d7c9e589da99c1879a1c703e67c85eaa6be4661cdc6ce6534f7bb3575983f4", size = 12440807, upload-time = "2026-02-26T09:43:22.679Z" },
+    { url = "https://files.pythonhosted.org/packages/12/dc/a7ca2a4224b3072a2c2998b6611ad7fd4f8f131ceae7aa23238d97d26e22/zensical-0.0.24-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:42fcc121c3095734b078a95a0dae4d4924fb8fbf16bf730456146ad6cab48ad0", size = 12782727, upload-time = "2026-02-26T09:43:25.347Z" },
+    { url = "https://files.pythonhosted.org/packages/42/37/22f1727da356ed3fcbd31f68d4a477f15c232997c87e270cfffb927459ac/zensical-0.0.24-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:832d4a2a051b9f49561031a2986ace502326f82d9a401ddf125530d30025fdd4", size = 12547616, upload-time = "2026-02-26T09:43:28.031Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ff/c75ff111b8e12157901d00752beef9d691dbb5a034b6a77359972262416a/zensical-0.0.24-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:e5fea3bb61238dba9f930f52669db67b0c26be98e1c8386a05eb2b1e3cb875dc", size = 12684883, upload-time = "2026-02-26T09:43:30.642Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/92/4f6ea066382e3d068d3cadbed99e9a71af25e46c84a403e0f747960472a2/zensical-0.0.24-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:75eef0428eec2958590633fdc82dc2a58af124879e29573aa7e153b662978073", size = 12713825, upload-time = "2026-02-26T09:43:33.273Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/fb/bf735b19bce0034b1f3b8e1c50b2896ebbd0c5d92d462777e759e78bb083/zensical-0.0.24-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:3c6b39659156394ff805b4831dac108c839483d9efa4c9b901eaa913efee1ac7", size = 12854318, upload-time = "2026-02-26T09:43:35.632Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/28/0ddab6c1237e3625e7763ff666806f31e5760bb36d18624135a6bb6e8643/zensical-0.0.24-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9eef82865a18b3ca4c3cd13e245dff09a865d1da3c861e2fc86eaa9253a90f02", size = 12818270, upload-time = "2026-02-26T09:43:37.749Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/93/d2cef3705d4434896feadffb5b3e44744ef9f1204bc41202c1b84a4eeef6/zensical-0.0.24-cp310-abi3-win32.whl", hash = "sha256:f4d0ff47d505c786a26c9332317aa3e9ad58d1382f55212a10dc5bafcca97864", size = 11857695, upload-time = "2026-02-26T09:43:39.906Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/26/9707587c0f6044dd1e1cc5bc3b9fa5fed81ce6c7bcdb09c21a9795e802d9/zensical-0.0.24-cp310-abi3-win_amd64.whl", hash = "sha256:e00a62cf04526dbed665e989b8f448eb976247f077a76dfdd84699ace4aa3ac3", size = 12057762, upload-time = "2026-02-26T09:43:42.627Z" },
 ]
--- a/zensical.toml
+++ b/zensical.toml
@@ -2,15 +2,10 @@
 site_name = "FastAPI Toolsets"
 site_description = "Production-ready utilities for FastAPI applications."
 site_author = "d3vyce"
-site_url = "https://fastapi-toolsets.d3vyce.fr/"
+site_url = "https://fastapi-toolsets.d3vyce.fr"
 copyright = "Copyright &copy; 2026 d3vyce"
 repo_url = "https://github.com/d3vyce/fastapi-toolsets"

-[project.extra.version]
-provider = "mike"
-default = "stable"
-alias = true
-
 [project.theme]
 custom_dir = "docs/overrides"
 language = "en"
@@ -145,7 +140,6 @@ Examples = [

 [[project.nav]]
 Migration = [
-    {"v3.0" = "migration/v3.md"},
    {"v2.0" = "migration/v2.md"},
 ]