Address PR #143 review (CHANGES_REQUIRED)

P2.1: Point test_presence.py ISO-week scan at core.presence (the real
model since task 510c1f78); the integration's presence.py is now a
re-export shim, so scanning it was vacuous.

P2.2: Add direct core-builder unit tests to test_events.py — exact
payload key sets for completed/uncompleted/day-complete events,
was_on_time threading (True/False/None), event ordering (completed
fires before day-complete on the bus), and the four day-complete
outcomes (zero-quest day, non-today instance, partial day,
fully-cleared today). Add a shim timezone test that sets
hass.config.time_zone to a zone whose local date differs from UTC and
asserts the day-complete rule uses that local date.

P3.1: Split build_quest_completed_events into
build_quest_completed_event (single event, no day-complete state) and
build_child_day_complete_event (separate, returns the day-complete
event or None). The shim fires nestquest_quest_completed BEFORE it
reads the HA-local today and evaluates the day-complete rule,
restoring the pre-extraction ordering so a failure in the day-complete
DB reads or the ZoneInfo lookup cannot suppress the completed event.
Payloads and the day-complete rule are identical.

P3.2: test_startup_db.py glob -> rglob so core/ is scanned by the
'never unlinks or truncates DB files' guardrail (non-recursive glob
skipped the extracted core package).

P3.3: RELEASE_NOTES.md notes the children and admin_allowlist loggers
moved to .core.children / .core.admin_allowlist (parent logger still
catches them).

P3.4: Refresh the stale test_core_isolation.py docstring to cover the
whole core package (storage-layer task d0b691d8 + engines/business-
layer task 510c1f78).

uv run pytest -q = 1507 passed (baseline 1497 + 10 new).

api/__init__.py

@@ -1,19 +0,0 @@
-"""NestQuest API service.
-
-A standalone FastAPI deployable that owns the NestQuest database and
-exposes it over HTTP to the Home Assistant integration (panel plane) and
-the admin PWA (admin plane).  See Feature 16 (task cd03735b) in the
-project tracker for the full contract.
-
-This package imports the NestQuest domain ``core`` WITHOUT executing
-``custom_components/nestquest/__init__.py`` — that parent package's
-``__init__.py`` imports ``homeassistant``, which is absent from the
-API's runtime.  The coupling is encapsulated in
-:mod:`api.nestquest_core`, which loads ``core`` by file location with
-:mod:`importlib.util` and registers it under the distinct top-level name
-``nestquest_core`` (no ``sys.path`` mutation, no generic top-level
-names published).  It is a TRANSITIONAL coupling that Feature 18 will
-revisit: once the integration becomes a thin API client and ``core``
-moves out of the integration bundle, this helper goes away.
-"""
-from __future__ import annotations

api/app.py

@@ -1,99 +0,0 @@
-"""The NestQuest FastAPI application.
-
-This module builds the ASGI app for the NestQuest API service (Feature
-16).  The skeleton here wires the bundled ``core`` (Feature 15) and
-exposes the two endpoints every later task depends on:
-
-- ``GET /health`` — returns ``200`` with a JSON status body once the
-  app has imported core, opened the database, and applied migrations;
-  a cheap ``SELECT 1`` confirms the connection is live without leaking
-  the filesystem path on an unauthenticated route.
-- ``GET /docs`` — FastAPI's auto-served OpenAPI document (Swagger UI);
-  ``/openapi.json`` is the raw schema.  No extra wiring is needed;
-  FastAPI serves both by default.
-
-The database is opened and migrated in a FastAPI lifespan context so a
-startup failure (e.g. an unwritable path) surfaces as a startup error
-rather than the first request.  The connection is closed on shutdown.
-
-This module exports ONLY the :func:`create_app` factory — there is no
-module-level app instance, because building one at import time would
-read ``NESTQUEST_DB_PATH`` at import (and fail-fast on a missing value)
-before any worker is ready to report it.  Serve with::
-
-    uvicorn --factory api.app:create_app
-
-so the factory runs on each worker startup and reads the environment
-then.
-"""
-from __future__ import annotations
-
-from contextlib import asynccontextmanager
-from collections.abc import AsyncIterator
-
-from fastapi import FastAPI
-
-from api.config import ApiConfig
-from api.database import DatabaseState, make_database
-
-
-def _build_lifespan(db_path: str):
-    """Return a lifespan that opens+migrates then closes one database.
-
-    Captured as a closure so the app factory can hand the configured
-    path in without threading it through FastAPI's lifespan signature.
-    """
-
-    @asynccontextmanager
-    async def lifespan(app: FastAPI) -> AsyncIterator[None]:
-        state = make_database(db_path)
-        app.state.db = state
-        try:
-            await state.open_and_migrate()
-            yield
-        finally:
-            await state.close()
-
-    return lifespan
-
-
-def create_app(config: ApiConfig | None = None) -> FastAPI:
-    """Build the NestQuest API FastAPI app.
-
-    ``config`` defaults to one built from the process environment, so
-    ``uvicorn --factory api.app:create_app`` picks up
-    ``NESTQUEST_DB_PATH`` (and fails fast on startup if it is missing).
-    Tests pass an explicit config so each test gets a hermetic temp
-    SQLite file.
-    """
-    cfg = config if config is not None else ApiConfig.from_env()
-
-    app = FastAPI(
-        title="NestQuest API",
-        description=(
-            "Standalone HTTP service that owns the NestQuest database and "
-            "exposes it to the Home Assistant integration (panel plane) and "
-            "the admin PWA (admin plane)."
-        ),
-        version="0.1.0",
-        lifespan=_build_lifespan(cfg.db_path),
-    )
-
-    @app.get("/health", summary="Service health")
-    async def health() -> dict[str, str]:
-        """Return service health.
-
-        Returns ``200`` with ``{"status": "ok"}`` once the lifespan has
-        opened and migrated the database.  A cheap ``SELECT 1`` against
-        the live connection confirms the database is reachable WITHOUT
-        leaking the filesystem path on an unauthenticated route; if the
-        connection is dead the query raises and the probe fails.
-        """
-        state: DatabaseState = app.state.db
-        await state.database.fetch_one("SELECT 1")
-        return {"status": "ok"}
-
-    return app
-
-
-__all__ = ["create_app"]

api/config.py

@@ -1,68 +0,0 @@
-"""Configuration for the NestQuest API service.
-
-The API reads its single configuration knob — the SQLite database path —
-from the ``NESTQUEST_DB_PATH`` environment variable.  Unlike a dev
-convenience default, a missing or empty value is a configuration ERROR,
-not a silent fallback to a predictable world-writable temp path: the API
-owns the database (it is the writer of record per Feature 16's
-contract), and silently dropping data into ``$TMPDIR/nestquest.db``
-would lose it at reboot.  ``ApiConfig.from_env`` therefore RAISES when
-the variable is unset or empty.  This mirrors the integration's
-"explicit settings object" discipline (Feature 15's
-``core.settings``): the API never reads HA config; callers pass the
-resolved path into the database wiring.
-
-Serving: the app is built with the factory ``api.app:create_app`` — run
-it with ``uvicorn --factory api.app:create_app`` so the factory reads
-the environment on each worker startup rather than at import time.
-"""
-from __future__ import annotations
-
-import os
-from dataclasses import dataclass
-
-#: Environment variable holding the SQLite file path.  The API opens
-#: this file on startup (creating it if absent) and applies migrations.
-#: REQUIRED — unset or empty raises :class:`ConfigError` from
-#: :meth:`ApiConfig.from_env`.
-DB_PATH_ENV = "NESTQUEST_DB_PATH"
-
-
-class ConfigError(RuntimeError):
-    """Raised when required API configuration is missing or invalid."""
-
-
-@dataclass(frozen=True)
-class ApiConfig:
-    """Resolved API configuration.
-
-    Currently a single field — the SQLite path — but kept as a dataclass
-    so later tasks (auth, SSE, settings persistence) can extend it
-    without touching the call sites that read ``db_path``.
-    """
-
-    db_path: str
-
-    @classmethod
-    def from_env(cls, env: dict[str, str] | None = None) -> "ApiConfig":
-        """Build configuration from the process environment.
-
-        ``env`` defaults to ``os.environ``; tests pass an explicit dict
-        so they are hermetic (no monkeypatch of the global environ).
-
-        Raises :class:`ConfigError` when ``NESTQUEST_DB_PATH`` is unset
-        or empty/whitespace-only — there is no silent default, because a
-        default in the temp directory would silently lose data at reboot.
-        """
-        source = env if env is not None else os.environ
-        raw = source.get(DB_PATH_ENV, "").strip()
-        if not raw:
-            raise ConfigError(
-                f"{DB_PATH_ENV} must be set to a writable SQLite file path "
-                f"(it is unset or empty — the API will not fall back to a "
-                f"temp directory and silently lose data)"
-            )
-        return cls(db_path=raw)
-
-
-__all__ = ["ApiConfig", "ConfigError", "DB_PATH_ENV"]

api/database.py

@@ -1,82 +0,0 @@
-"""Database wiring for the NestQuest API service.
-
-The API owns the database (it is the writer of record per Feature 16's
-contract).  This module owns one application-lifetime
-:class:`core.db.NestQuestDatabase`: it opens the SQLite file at the
-configured path on startup, applies migrations (creating the schema on
-a fresh file), and closes the connection on shutdown.
-
-The executor callable passed into ``NestQuestDatabase`` mirrors the
-contract of ``hass.async_add_executor_job``: schedule a synchronous
-callable on a worker and await its result.  HA's own version lives on
-the event loop; the API is not HA, so it uses
-:func:`asyncio.to_thread` for the same effect — sqlite3 calls run on a
-worker thread and only plain data returns to the event loop.
-"""
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Any
-
-from api.nestquest_core import core_db, core_migrations
-
-LOGGER = logging.getLogger(__name__)
-
-#: The async SQLite wrapper.  Re-exported so route handlers and later
-#: tasks reach it through the API package, not the bundled core.
-NestQuestDatabase = core_db.NestQuestDatabase
-
-#: The migration runner.  Re-exported for the same reason.
-apply_migrations = core_migrations.apply_migrations
-
-
-async def _executor(fn: Any, *args: Any, **kwargs: Any) -> Any:
-    """Run a synchronous callable on a worker thread and await its result.
-
-    Mirrors the contract of ``hass.async_add_executor_job`` so the
-    bundled ``NestQuestDatabase`` (written against that contract) works
-    unchanged in the API process: sqlite3 calls never block the event
-    loop, and only plain Python data (row tuples,
-    :class:`core.db.ExecutionResult`) crosses back.
-    """
-    return await asyncio.to_thread(fn, *args, **kwargs)
-
-
-class DatabaseState:
-    """Holds the live database wrapper and its resolved path.
-
-    A small container so the lifespan and the route handlers share one
-    authoritative reference; FastAPI's lifespan stores one of these on
-    ``app.state.db`` and the health route reads it back.
-    """
-
-    __slots__ = ("database", "db_path")
-
-    def __init__(self, database: NestQuestDatabase, db_path: str) -> None:
-        self.database = database
-        self.db_path = db_path
-
-    async def open_and_migrate(self) -> None:
-        """Open the connection and apply migrations to the latest version."""
-        LOGGER.info("Opening NestQuest database at %s", self.db_path)
-        await self.database.open(self.db_path)
-        version = await apply_migrations(self.database)
-        LOGGER.info("NestQuest schema at version %d", version)
-
-    async def close(self) -> None:
-        """Close the connection; safe to call even if open failed."""
-        await self.database.close()
-
-
-def make_database(db_path: str) -> DatabaseState:
-    """Construct a :class:`DatabaseState` for the given path (not yet open)."""
-    return DatabaseState(NestQuestDatabase(_executor), db_path)
-
-
-__all__ = [
-    "DatabaseState",
-    "NestQuestDatabase",
-    "apply_migrations",
-    "make_database",
-]

api/nestquest_core.py

@@ -1,110 +0,0 @@
-"""Transitional coupling: import ``core`` without importing Home Assistant.
-
-The NestQuest domain ``core`` package (Feature 15) is bundled INSIDE the
-Home Assistant integration at ``custom_components/nestquest/core/``.
-Importing it the obvious way — ``import custom_components.nestquest.core``
-— would execute ``custom_components/nestquest/__init__.py``, which
-imports ``homeassistant``.  Home Assistant is NOT installed in the API
-service's runtime, so that import raises ``ModuleNotFoundError`` and the
-API cannot start.
-
-``core`` itself is a clean, Home-Assistant-free package: its
-``__init__.py`` is a bare docstring and every internal import is
-relative (``from .db import ...``).  It can therefore be imported by
-file location as a standalone package.
-
-This module loads ``core`` with :func:`importlib.util.spec_from_file_location`
-— registering it under the distinct top-level name ``nestquest_core``
-with ``submodule_search_locations`` set to the bundled ``core``
-directory — so its relative imports resolve against that directory
-without touching ``sys.path``.  No generic top-level name (``db``,
-``const``, ``schema``, ...) is published, so nothing here can silently
-shadow a future dependency, and the integration's HA-coupled
-``__init__.py`` is never executed: ``custom_components.nestquest`` is
-never imported.
-
-Usage::
-
-    from api.nestquest_core import core_db, core_migrations
-    # core_db.NestQuestDatabase, core_migrations.apply_migrations, ...
-
-This is a TRANSITIONAL coupling.  Feature 18 (task 430f7f98) converts
-the integration into a thin API client and moves ``core`` out of the
-integration bundle; once that lands, this bootstrap helper goes away and
-the API imports ``core`` as an ordinary installed dependency.
-
-NOTE on the pytest process: the suite's ``conftest.py`` stubs the
-parent integration package and imports ``custom_components.nestquest.core.*``
-BEFORE any API test runs, so two copies of the core package coexist in
-the pytest process — the one registered here as ``nestquest_core.*``
-(loaded by file location) and the conftest-stubbed
-``custom_components.nestquest.core.*``.  Later tasks must NOT compare
-class or exception identity across these two copies: a
-``nestquest_core.db.NestQuestDatabase`` is a DIFFERENT class object from
-``custom_components.nestquest.core.db.NestQuestDatabase`` even though
-they share source.  Operate on a single copy within any one code path.
-"""
-from __future__ import annotations
-
-import importlib
-import importlib.util
-import sys
-from pathlib import Path
-from types import ModuleType
-
-#: The repository root (this file is ``<root>/api/nestquest_core.py``).
-_REPO_ROOT: Path = Path(__file__).resolve().parent.parent
-
-#: The bundled ``core`` package directory, inside the HA integration.
-_CORE_DIR: Path = _REPO_ROOT / "custom_components" / "nestquest" / "core"
-
-#: The ``core`` package's ``__init__.py`` — a bare docstring, so loading
-#: it by file location executes no imports of its own.
-_CORE_INIT: Path = _CORE_DIR / "__init__.py"
-
-#: The distinct top-level name under which the bundled ``core`` package
-#: is registered in ``sys.modules``.  A distinctive name (rather than the
-#: generic ``core``) avoids publishing shadow-able top-level names and
-#: keeps the bundled copy separate from the conftest-stubbed
-#: ``custom_components.nestquest.core`` present in the pytest process.
-_CORE_MODULE_NAME = "nestquest_core"
-
-
-def _load_core() -> ModuleType:
-    """Load the bundled ``core`` package by file location and return it.
-
-    Registers the package under :data:`_CORE_MODULE_NAME` in
-    ``sys.modules`` with ``submodule_search_locations`` pointing at the
-    bundled directory, so its relative imports (``from .db import ...``)
-    resolve to ``nestquest_core.<submodule>`` against that directory
-    without mutating ``sys.path``.  Idempotent: a second call returns
-    the already-registered module.
-    """
-    existing = sys.modules.get(_CORE_MODULE_NAME)
-    if existing is not None:
-        return existing
-    spec = importlib.util.spec_from_file_location(
-        _CORE_MODULE_NAME,
-        _CORE_INIT,
-        submodule_search_locations=[str(_CORE_DIR)],
-    )
-    if spec is None or spec.loader is None:
-        raise ImportError(f"could not load core from {_CORE_INIT}")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[_CORE_MODULE_NAME] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-#: The bundled core package, loaded by file location and registered as
-#: ``nestquest_core`` in ``sys.modules``.  Held here so callers import the
-#: submodules through it (``nestquest_core.db``, ``nestquest_core.migrations``)
-#: the same relative way the integration does.
-core: ModuleType = _load_core()
-
-#: Re-exported for convenience; route handlers import these names from
-#: here rather than reaching into the core package directly.
-core_db = importlib.import_module(f"{_CORE_MODULE_NAME}.db")
-core_migrations = importlib.import_module(f"{_CORE_MODULE_NAME}.migrations")
-
-__all__ = ["core", "core_db", "core_migrations"]

custom_components/nestquest/__init__.py

@@ -18,13 +18,16 @@ from homeassistant.helpers.event import async_track_time_change
 
 from .const import (
     CONF_ADMIN_USER_IDS,
+    CONF_DAY_ROLLOVER_TIME,
+    CONF_HORIZON_DAYS,
     CONF_UPDATE_INTERVAL,
+    DEFAULT_DAY_ROLLOVER_TIME,
+    DEFAULT_HORIZON_DAYS,
     DEFAULT_UPDATE_INTERVAL,
     DOMAIN,
     LOGGER,
     PLATFORMS,
 )
-from .core.settings import NestQuestSettings
 from .frontend import async_register_frontend
 from .coordinator import NestQuestCoordinator
 from .db import NestQuestDatabase, make_database
@@ -237,7 +240,7 @@ class NestQuestRuntimeData:
     """Runtime data stored on a NestQuest config entry."""
 
     entry_id: str
-    settings: NestQuestSettings
+    options: dict[str, Any]
     database: NestQuestDatabase
     remove_update_listener: Callable[[], Any]
     remove_time_change_listener: Callable[[], Any]
@@ -266,10 +269,38 @@ async def _async_owner_user_ids(hass: HomeAssistant) -> list[str]:
     return owners
 
 
+def _day_rollover_hour_minute(options: dict[str, Any]) -> tuple[int, int]:
+    """Return the (hour, minute) the daily rollover fires at from ``options``.
+
+    The options flow validates ``day_rollover_time`` as a strict ``HH:MM``
+    string, so a stored value never needs re-validation here; a missing key
+    falls back to :data:`~.const.DEFAULT_DAY_ROLLOVER_TIME`.
+    """
+    rollover = options.get(CONF_DAY_ROLLOVER_TIME, DEFAULT_DAY_ROLLOVER_TIME)
+    hour, _, minute = rollover.partition(":")
+    return int(hour), int(minute)
+
+
+def _configured_horizon_days(options: dict[str, Any]) -> int:
+    """Return the configured generation horizon, validated, else the default.
+
+    The options flow already validates ``horizon_days`` as an integer >= 1,
+    but a stored ``entry.options`` dict could still carry a partial or
+    hand-edited value.  Re-checking here — and falling back to
+    :data:`~.const.DEFAULT_HORIZON_DAYS` on a missing, non-int or sub-1 value
+    — keeps a malformed option from shrinking or exploding the materialized
+    horizon.
+    """
+    value = options.get(CONF_HORIZON_DAYS, DEFAULT_HORIZON_DAYS)
+    if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+        return DEFAULT_HORIZON_DAYS
+    return value
+
+
 async def _run_horizon_materialization(
     hass: HomeAssistant,
     database: NestQuestDatabase,
-    settings: NestQuestSettings,
+    horizon_days: int = DEFAULT_HORIZON_DAYS,
 ) -> None:
     """Materialize the rolling horizon ``[today, today + horizon_days]``.
 
@@ -280,22 +311,23 @@ async def _run_horizon_materialization(
 
     This is the ONE generation path: the startup backfill, the daily rollover
     listener and the ``regenerate`` service all funnel through it, so there is
-    no duplicated materialization logic.  ``settings`` (REQUIRED — there is no
-    silent default; every caller already passes the entry's validated
-    :class:`NestQuestSettings`) carries the configured ``horizon_days``.  The
-    window itself comes from :meth:`settings.horizon_window` so the helper is
-    real and shared (not recomputed inline here).
+    no duplicated materialization logic.  ``horizon_days`` sizes the window
+    and defaults to :data:`~.const.DEFAULT_HORIZON_DAYS`; callers thread the
+    entry's validated option value through.
     """
     time_zone = ZoneInfo(hass.config.time_zone)
     today = datetime.datetime.now(time_zone).date()
-    start, end = settings.horizon_window(today)
-    await _materialize_run(database, start.isoformat(), end.isoformat(), today=today)
+    start_date = today.isoformat()
+    end_date = (
+        today + datetime.timedelta(days=horizon_days)
+    ).isoformat()
+    await _materialize_run(database, start_date, end_date, today=today)
 
 
 def _register_day_rollover_listener(
     hass: HomeAssistant,
     database: NestQuestDatabase,
-    settings: NestQuestSettings,
+    options: dict[str, Any],
 ) -> Callable[[], Any]:
     """Register the daily rollover listener and return its remover.
 
@@ -303,15 +335,16 @@ def _register_day_rollover_listener(
     first re-materializes the rolling horizon
     ``[today, today + horizon_days]`` through the shared
     :func:`_run_horizon_materialization` path (the entry's configured,
-    validated ``horizon_days`` carried on ``settings``), then runs the
-    Feature 11 missed sweep — announcing yesterday's still-open quests
-    as missed AFTER today's instances exist, watermark-guarded so a
-    re-fire of the listener the same night announces nothing twice.
+    validated ``horizon_days``), then runs the Feature 11 missed sweep
+    — announcing yesterday's still-open quests as missed AFTER today's
+    instances exist, watermark-guarded so a re-fire of the listener the
+    same night announces nothing twice.
     """
-    hour, minute = settings.day_rollover_hour_minute
+    hour, minute = _day_rollover_hour_minute(options)
+    horizon_days = _configured_horizon_days(options)
 
     async def _run_materialization(_now: datetime.datetime) -> None:
-        await _run_horizon_materialization(hass, database, settings)
+        await _run_horizon_materialization(hass, database, horizon_days)
         await run_missed_sweep(hass, database)
 
     return async_track_time_change(
@@ -326,9 +359,7 @@ def _find_live_runtime_data(hass: HomeAssistant) -> NestQuestRuntimeData | None:
     their own; they resolve whichever config entry's runtime data is
     currently live at call time, so none of them can hold a stale handle
     to a closed connection after another entry unloads.  The record also
-    carries that entry's validated ``settings`` (e.g. the configured
-    horizon) so service handlers read horizon days off it rather than
-    re-reading HA config.
+    carries that entry's options (e.g. the configured horizon).
     """
     for runtime_data in hass.data.get(DOMAIN, {}).values():
         database = getattr(runtime_data, "database", None)
@@ -348,8 +379,9 @@ def _make_regenerate_handler(hass: HomeAssistant):
                 "live database; ignoring"
             )
             return
+        horizon_days = _configured_horizon_days(runtime_data.options)
         await _run_horizon_materialization(
-            hass, runtime_data.database, runtime_data.settings
+            hass, runtime_data.database, horizon_days
         )
 
     return _regenerate
@@ -463,24 +495,18 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             context_user_id=context_user_id,
             owner_ids=owner_ids,
         )
-        # Build the explicit settings object from entry.options ONCE: the
-        # horizon materialization and the daily-rollover listener both
-        # consume it, so core never reads HA config itself.  A malformed
-        # stored option falls back PER FIELD (via from_options_resilient)
-        # so a single bad sibling option cannot reset the user's
-        # horizon_days or day_rollover_time — the two fields core
-        # consumes — to their defaults.
-        settings = NestQuestSettings.from_options_resilient(entry.options)
         remove_update_listener = entry.add_update_listener(_async_update_listener)
         remove_time_change_listener = _register_day_rollover_listener(
-            hass, database, settings
+            hass, database, dict(entry.options)
         )
         # Backfill any days the daily listener missed while the integration
         # was off (or freshly installed): run the one idempotent walk over
         # [today, today + horizon_days] once at setup, using the entry's
         # configured horizon.  This runs through the SAME path as the daily
         # listener and regenerate service.
-        await _run_horizon_materialization(hass, database, settings)
+        await _run_horizon_materialization(
+            hass, database, _configured_horizon_days(dict(entry.options))
+        )
         # The missed sweep runs at startup too (Feature 11): if HA was
         # down at the rollover time, the previous night's still-open
         # quests are announced as missed now instead of waiting for
@@ -503,7 +529,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         await coordinator.async_config_entry_first_refresh()
         runtime_data = NestQuestRuntimeData(
             entry_id=entry.entry_id,
-            settings=settings,
+            options=dict(entry.options),
             database=database,
             remove_update_listener=remove_update_listener,
             remove_time_change_listener=remove_time_change_listener,

custom_components/nestquest/core/const.py

@@ -2,19 +2,11 @@
 from __future__ import annotations
 
 import logging
-import re
 
 DOMAIN = "nestquest"
 LOGGER_NAME = "custom_components.nestquest"
 LOGGER = logging.getLogger(LOGGER_NAME)
 
-#: Strict 24-hour ``HH:MM`` pattern shared by the options flow and the
-#: settings object's time validation, so a stored option and a freshly
-#: validated form submit parse the same way.  Defined here (HA-free) so
-#: both the integration's options flow and the core settings module
-#: import ONE pattern instead of re-copying it.
-TIME_PATTERN = re.compile(r"(?:[01]\d|2[0-3]):[0-5]\d")
-
 # Platforms set up per config entry (Feature 10): the per-child day
 # sensors and binary sensors.
 PLATFORMS: list[str] = ["sensor", "binary_sensor"]

custom_components/nestquest/core/settings.py

@@ -1,379 +0,0 @@
-"""Explicit, Home-Assistant-free settings object for NestQuest core.
-
-The integration reads its configuration off a Home Assistant config
-entry (``entry.options``); the core package must not.  This module
-bridges that split: it defines a frozen, validation-carrying
-:class:`NestQuestSettings` dataclass that the integration constructs
-from ``entry.options`` (via :meth:`NestQuestSettings.from_options`, or
-:meth:`NestQuestSettings.from_options_resilient` for the per-field
-fallback used at setup) and then passes into the core paths that
-previously read HA config themselves — the rolling horizon
-(``horizon_days``) and the daily rollover time (``day_rollover_time``),
-plus the Feature 11 notification settings (notify target, the three
-summary/reminder/report times, and the four independent enable toggles).
-
-Nothing in this module imports ``homeassistant`` or touches a config
-entry; ``from_options`` accepts any plain mapping keyed by the
-:data:`~.const.CONF_*` names.  The validation semantics match the
-options flow's: ``horizon_days`` must be a real integer >= 1 (bool
-rejected), and ``day_rollover_time`` plus the three notification times
-must be strict ``HH:MM`` 24-hour strings.  Construction therefore can
-never yield a settings object whose horizon could shrink or explode the
-materialized window, or whose rollover fires at an unparsable time.
-
-The strict resolvers (:func:`_resolve_horizon_days`, :func:`_validate_hhmm`,
-:func:`_resolve_bool`, :func:`_resolve_optional_str`) reject ``None``; the
-``None``-as-absent mapping lives ONLY in :meth:`from_options` /
-:meth:`from_options_resilient` (via :func:`_option_value`), so a hand-built
-:class:`NestQuestSettings` cannot smuggle a ``None`` past
-:meth:`__post_init__`.
-"""
-from __future__ import annotations
-
-import datetime
-from collections.abc import Callable
-from dataclasses import dataclass
-from types import MappingProxyType
-from typing import Any, Mapping
-
-from .const import (
-    CONF_AFTERNOON_REMINDER_ENABLED,
-    CONF_AFTERNOON_REMINDER_TIME,
-    CONF_CELEBRATION_ENABLED,
-    CONF_DAY_ROLLOVER_TIME,
-    CONF_END_OF_DAY_REPORT_ENABLED,
-    CONF_END_OF_DAY_REPORT_TIME,
-    CONF_HORIZON_DAYS,
-    CONF_MORNING_SUMMARY_ENABLED,
-    CONF_MORNING_SUMMARY_TIME,
-    CONF_NOTIFY_TARGET,
-    DEFAULT_AFTERNOON_REMINDER_TIME,
-    DEFAULT_AUTOMATION_ENABLED,
-    DEFAULT_DAY_ROLLOVER_TIME,
-    DEFAULT_END_OF_DAY_REPORT_TIME,
-    DEFAULT_HORIZON_DAYS,
-    DEFAULT_MORNING_SUMMARY_TIME,
-    LOGGER,
-    TIME_PATTERN,
-)
-
-
-def _option_value(
-    opts: Mapping[str, Any], key: str, default: Any
-) -> Any:
-    """Return ``opts[key]`` when present and non-None, else ``default``.
-
-    This is the SOLE place the ``None``-as-absent mapping lives: a stored
-    ``None`` is treated the same as an absent key — the historical
-    ``horizon_days`` path mapped a missing-or-None value to the default,
-    and this keeps that forgiving semantics uniform across every field.
-    The per-field resolvers (:func:`_resolve_horizon_days`,
-    :func:`_validate_hhmm`, :func:`_resolve_bool`,
-    :func:`_resolve_optional_str`) are STRICT — they reject ``None`` —
-    so a partially-populated ``entry.options`` dict (or one migrated
-    across versions) never raises just because a key carries ``None``,
-    and a hand-built :class:`NestQuestSettings` cannot smuggle a
-    ``None`` past :meth:`NestQuestSettings.__post_init__`.
-    """
-    if key not in opts:
-        return default
-    value = opts[key]
-    return default if value is None else value
-
-
-def _validate_hhmm(value: Any, *, field: str) -> str:
-    """Validate a strict ``HH:MM`` string and return it; raise naming ``field``.
-
-    Uses the shared :data:`~.const.TIME_PATTERN` (the same compiled
-    regex the options flow applies), so a stored option and a freshly
-    validated form submit parse the same way.  ``None`` (and any
-    non-string) is rejected; the ``None``-as-absent mapping lives ONLY
-    in :meth:`NestQuestSettings.from_options` (via :func:`_option_value`).
-    """
-    if not isinstance(value, str) or TIME_PATTERN.fullmatch(value) is None:
-        raise ValueError(
-            f"{field} must be a strict HH:MM string, got {value!r}"
-        )
-    return value
-
-
-def _resolve_horizon_days(value: Any) -> int:
-    """Validate a horizon value and return the resolved day count.
-
-    A bool is rejected (SQLite binds ``True``/``False`` onto an int), a
-    non-int is rejected, and a sub-1 value is rejected — so a malformed
-    option can never shrink or explode the materialized horizon.
-    ``None`` is rejected here too; the ``None``-as-absent mapping lives
-    ONLY in :meth:`NestQuestSettings.from_options` (via
-    :func:`_option_value`), so a hand-built
-    :class:`NestQuestSettings(horizon_days=None)` raises in
-    :meth:`NestQuestSettings.__post_init__` rather than silently
-    constructing an object whose :meth:`NestQuestSettings.horizon_window`
-    would later raise ``TypeError`` on ``timedelta(days=None)``.
-    """
-    if isinstance(value, bool) or not isinstance(value, int) or value < 1:
-        raise ValueError(
-            f"horizon_days must be a positive integer, got {value!r}"
-        )
-    return value
-
-
-def _resolve_bool(value: Any) -> bool:
-    """Return a real bool; a non-bool (including ``None``) is rejected.
-
-    voluptuous ``bool`` would coerce strings, so the options flow uses a
-    strict-bool validator and this mirrors it.  The ``None``-as-absent
-    mapping lives ONLY in :meth:`NestQuestSettings.from_options` (via
-    :func:`_option_value`).
-    """
-    if not isinstance(value, bool):
-        raise ValueError(f"expected a boolean, got {value!r}")
-    return value
-
-
-def _resolve_optional_str(value: Any) -> str:
-    """Return a stripped notify target string; a non-str is rejected.
-
-    A padded or whitespace-only value is STRIPPED to its trim — the
-    shipped default is the empty string, meaning "no notifications are
-    configured yet".  This is intentionally MORE LENIENT than the options
-    flow, which REJECTS a target that differs from its own trim (so a
-    padded value never persists): the integration tolerates a stored
-    padded value (e.g. one migrated from an older schema) by normalizing
-    it rather than crashing setup.  The ``None``-as-absent mapping lives
-    ONLY in :meth:`NestQuestSettings.from_options` (via
-    :func:`_option_value`).  :meth:`NestQuestSettings.__post_init__`
-    applies this SAME normalizer so a hand-built
-    ``NestQuestSettings(notify_target=' x ')`` is stripped to ``'x'``
-    exactly like the options-flow path (no padded value can slip through
-    direct construction either).
-    """
-    if not isinstance(value, str):
-        raise ValueError(f"notify_target must be a string, got {value!r}")
-    return value.strip()
-
-
-#: The single field table the two builders share.  Each row is
-#: ``(field_name, CONF_* key, default, validator)``.  ``from_options``
-#: applies every validator (raising on the first invalid value) while
-#: ``from_options_resilient`` wraps each in its own try/except so a single
-#: bad sibling falls back to its default alone.  Driving both builders
-#: from this table avoids three-way drift between ``__post_init__``'s
-#: inline checks and the two option builders' field lists: the only
-#: places that enumerate the fields are this table and
-#: ``__post_init__`` (which validates a hand-built instance without the
-#: None->default mapping, so it stays inline).
-_FIELDS: tuple[tuple[str, str, Any, Callable[[Any], Any]], ...] = (
-    ("horizon_days", CONF_HORIZON_DAYS, DEFAULT_HORIZON_DAYS, _resolve_horizon_days),
-    (
-        "day_rollover_time",
-        CONF_DAY_ROLLOVER_TIME,
-        DEFAULT_DAY_ROLLOVER_TIME,
-        lambda v: _validate_hhmm(v, field="day_rollover_time"),
-    ),
-    ("notify_target", CONF_NOTIFY_TARGET, "", _resolve_optional_str),
-    (
-        "morning_summary_time",
-        CONF_MORNING_SUMMARY_TIME,
-        DEFAULT_MORNING_SUMMARY_TIME,
-        lambda v: _validate_hhmm(v, field="morning_summary_time"),
-    ),
-    (
-        "afternoon_reminder_time",
-        CONF_AFTERNOON_REMINDER_TIME,
-        DEFAULT_AFTERNOON_REMINDER_TIME,
-        lambda v: _validate_hhmm(v, field="afternoon_reminder_time"),
-    ),
-    (
-        "end_of_day_report_time",
-        CONF_END_OF_DAY_REPORT_TIME,
-        DEFAULT_END_OF_DAY_REPORT_TIME,
-        lambda v: _validate_hhmm(v, field="end_of_day_report_time"),
-    ),
-    (
-        "morning_summary_enabled",
-        CONF_MORNING_SUMMARY_ENABLED,
-        DEFAULT_AUTOMATION_ENABLED,
-        _resolve_bool,
-    ),
-    (
-        "afternoon_reminder_enabled",
-        CONF_AFTERNOON_REMINDER_ENABLED,
-        DEFAULT_AUTOMATION_ENABLED,
-        _resolve_bool,
-    ),
-    (
-        "end_of_day_report_enabled",
-        CONF_END_OF_DAY_REPORT_ENABLED,
-        DEFAULT_AUTOMATION_ENABLED,
-        _resolve_bool,
-    ),
-    (
-        "celebration_enabled",
-        CONF_CELEBRATION_ENABLED,
-        DEFAULT_AUTOMATION_ENABLED,
-        _resolve_bool,
-    ),
-)
-
-
-@dataclass(frozen=True)
-class NestQuestSettings:
-    """Explicit, HA-free configuration carried into core paths.
-
-    The integration builds this once from ``entry.options`` (via
-    :meth:`from_options`, or :meth:`from_options_resilient` for the
-    per-field fallback used at setup) and threads it into the horizon
-    materialization and the daily-rollover scheduling.  Core never
-    reads HA config itself; callers pass the resolved horizon and
-    rollover time in.
-
-    All fields are validated at construction; the dataclass is frozen so
-    a stale settings object cannot be mutated in place after the
-    integration hands it off.
-    """
-
-    horizon_days: int = DEFAULT_HORIZON_DAYS
-    day_rollover_time: str = DEFAULT_DAY_ROLLOVER_TIME
-    notify_target: str = ""
-    morning_summary_time: str = DEFAULT_MORNING_SUMMARY_TIME
-    afternoon_reminder_time: str = DEFAULT_AFTERNOON_REMINDER_TIME
-    end_of_day_report_time: str = DEFAULT_END_OF_DAY_REPORT_TIME
-    morning_summary_enabled: bool = DEFAULT_AUTOMATION_ENABLED
-    afternoon_reminder_enabled: bool = DEFAULT_AUTOMATION_ENABLED
-    end_of_day_report_enabled: bool = DEFAULT_AUTOMATION_ENABLED
-    celebration_enabled: bool = DEFAULT_AUTOMATION_ENABLED
-
-    def __post_init__(self) -> None:
-        # Validate STRICTLY at construction so a hand-built instance
-        # cannot carry an invalid value: the same rules from_options
-        # applies, but WITHOUT the None->default mapping (that lives
-        # only in from_options via _option_value).  A None horizon, time,
-        # or toggle raises here rather than later blowing up
-        # horizon_window or the rollover listener.
-        _resolve_horizon_days(self.horizon_days)
-        _validate_hhmm(self.day_rollover_time, field="day_rollover_time")
-        # ``notify_target`` is normalised the SAME way as from_options
-        # (via _resolve_optional_str): a non-str is rejected and a
-        # padded/whitespace-only value is STRIPPED to its trim.  This
-        # keeps a hand-built ``NestQuestSettings(notify_target=' x ')``
-        # behaving like the options flow (which strips on persist) so a
-        # padded value cannot slip through direct construction either.
-        # The dataclass is frozen, so the stripped value is written via
-        # object.__setattr__.
-        stripped_notify_target = _resolve_optional_str(self.notify_target)
-        object.__setattr__(self, "notify_target", stripped_notify_target)
-        _validate_hhmm(self.morning_summary_time, field="morning_summary_time")
-        _validate_hhmm(
-            self.afternoon_reminder_time, field="afternoon_reminder_time"
-        )
-        _validate_hhmm(
-            self.end_of_day_report_time, field="end_of_day_report_time"
-        )
-        for name in (
-            "morning_summary_enabled",
-            "afternoon_reminder_enabled",
-            "end_of_day_report_enabled",
-            "celebration_enabled",
-        ):
-            value = getattr(self, name)
-            if not isinstance(value, bool):
-                raise ValueError(
-                    f"{name} must be a boolean, got {value!r}"
-                )
-
-    @property
-    def day_rollover_hour_minute(self) -> tuple[int, int]:
-        """The (hour, minute) the daily rollover fires at."""
-        # The string is validated at construction, so a plain partition
-        # is safe and avoids re-running the regex on every access.
-        hour_str, _, minute_str = self.day_rollover_time.partition(":")
-        return int(hour_str), int(minute_str)
-
-    def horizon_window(
-        self, today: datetime.date
-    ) -> tuple[datetime.date, datetime.date]:
-        """Return the rolling horizon window ``[today, today + horizon_days]``.
-
-        ``today`` is REQUIRED (there is no host-clock default): the
-        integration passes the HA-local ``hass.config.time_zone`` date so
-        the horizon tracks the household's own day, and a silent
-        host-clock fallback would be a wrong-day footgun (a test or a
-        caller that forgets to pass ``today`` would otherwise materialize
-        against the machine's calendar, not the household's).  The
-        returned window is closed/inclusive — the same shape
-        :func:`~.materialize.materialize` walks.
-        """
-        end = today + datetime.timedelta(days=self.horizon_days)
-        return today, end
-
-    @classmethod
-    def from_options(
-        cls, options: Mapping[str, Any] | None = None
-    ) -> "NestQuestSettings":
-        """Build settings from a CONF_*-keyed mapping (e.g. ``entry.options``).
-
-        Reads the same keys the options flow persists, applying the
-        matching defaults when a key is absent OR ``None`` (via
-        :func:`_option_value`, the SOLE place the ``None``-as-absent
-        mapping lives) and validating STRICTLY: ``horizon_days`` is a
-        positive int (bool rejected), the four times are strict
-        ``HH:MM``, the four toggles are real booleans, and
-        ``notify_target`` is a string (stripped).  A malformed value
-        RAISES — the integration uses :meth:`from_options_resilient` at
-        setup to fall back per field instead of crashing.  A ``None``
-        mapping yields the all-defaults settings — useful for tests and
-        for a fresh install whose options dict is empty.
-
-        ``options`` is consumed read-only via
-        :class:`types.MappingProxyType`, so this method never mutates
-        the caller's mapping.
-        """
-        opts: Mapping[str, Any] = (
-            MappingProxyType({}) if options is None else MappingProxyType(options)
-        )
-        return cls(
-            **{
-                field: validator(_option_value(opts, key, default))
-                for field, key, default, validator in _FIELDS
-            }
-        )
-
-    @classmethod
-    def from_options_resilient(
-        cls, options: Mapping[str, Any] | None = None
-    ) -> "NestQuestSettings":
-        """Build settings, falling back PER FIELD on a malformed value.
-
-        Unlike :meth:`from_options` (which raises on the first invalid
-        field), this resolves EACH field in its own try/except: a
-        malformed value logs a :data:`~.const.LOGGER` warning naming the
-        field and falls back to that field's default.  The integration
-        uses this at setup so a single bad sibling option (e.g. a
-        migrated ``morning_summary_time`` of ``'25:00'``) cannot
-        silently reset the user's ``horizon_days`` or
-        ``day_rollover_time`` — the two fields core actually consumes.
-
-        An absent or ``None`` key maps to the default via
-        :func:`_option_value` WITHOUT a warning (that is the normal
-        missing-key path); only a present, non-``None``, invalid value
-        triggers a warning and a per-field fallback.
-        """
-        opts: Mapping[str, Any] = (
-            MappingProxyType({}) if options is None else MappingProxyType(options)
-        )
-        resolved: dict[str, Any] = {}
-        for field, key, default, validator in _FIELDS:
-            raw = _option_value(opts, key, default)
-            try:
-                resolved[field] = validator(raw)
-            except ValueError as err:
-                LOGGER.warning(
-                    "NestQuest option %s is invalid (%s); falling back "
-                    "to the default %r",
-                    field,
-                    err,
-                    default,
-                )
-                resolved[field] = default
-        return cls(**resolved)

custom_components/nestquest/options_flow.py

@@ -1,6 +1,7 @@
 """Options flow for NestQuest post-setup settings."""
 from __future__ import annotations
 
+import re
 from typing import Any
 
 import voluptuous as vol
@@ -32,17 +33,18 @@ from .const import (
     DEFAULT_UPDATE_INTERVAL,
     DOMAIN,
     MIN_UPDATE_INTERVAL,
-    TIME_PATTERN,
 )
 from .admin_allowlist import list_admin_ids, set_admin_ids
 
 MIN_HORIZON_DAYS = 1
 MIN_PANEL_IDLE_TIMEOUT = 30
 
+_TIME_PATTERN = re.compile(r"(?:[01]\d|2[0-3]):[0-5]\d")
+
 
 def _parse_time(value: str) -> bool:
     """Return True when value is a valid 24-hour HH:MM string."""
-    return TIME_PATTERN.fullmatch(value) is not None
+    return _TIME_PATTERN.fullmatch(value) is not None
 
 
 def _async_validate(user_input: dict[str, Any]) -> dict[str, str]:

custom_components/nestquest/services.py

@@ -24,6 +24,8 @@ from . import children as children_layer
 from . import completion as completion_layer
 from . import quest_definitions as quest_definitions_layer
 from .const import (
+    CONF_HORIZON_DAYS,
+    DEFAULT_HORIZON_DAYS,
     DOMAIN,
     DOMAIN_SERVICES,
     QUEST_WINDOWS,
@@ -256,7 +258,12 @@ async def _refresh_entities(runtime: Any) -> None:
 def _generation_kwargs(hass: HomeAssistant, runtime: Any) -> dict[str, Any]:
     time_zone = ZoneInfo(hass.config.time_zone)
     today = datetime.datetime.now(time_zone).date()
-    return {"today": today, "horizon_days": runtime.settings.horizon_days}
+    value = runtime.options.get(CONF_HORIZON_DAYS, DEFAULT_HORIZON_DAYS)
+    if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+        horizon_days = DEFAULT_HORIZON_DAYS
+    else:
+        horizon_days = value
+    return {"today": today, "horizon_days": horizon_days}
 
 
 def _actor_kwargs(call: Any) -> dict[str, Any]:

pyproject.toml

@@ -7,20 +7,11 @@ requires-python = ">=3.11"
 dependencies = []
 
 [dependency-groups]
-# fastapi and uvicorn live in the DEV group only so the monorepo's test
-# venv can exercise the API app (tests under tests/test_api_health.py).
-# They are NOT runtime dependencies of the NestQuest HA integration.
-# When the API deployable is packaged (Feature 17), its runtime
-# dependencies — fastapi, uvicorn, and any others — MUST be declared in
-# that deployable's own dependency manifest, not here.
 dev = [
-    "fastapi>=0.115",
-    "httpx>=0.28",
     "jinja2>=3",
     "pytest>=8.0.0",
     "pytest-asyncio>=0.24",
     "pyyaml>=6",
-    "uvicorn>=0.30",
     "voluptuous>=0.14",
 ]
 

tests/conftest.py

@@ -22,7 +22,6 @@ pytest -q``); it is never meant to run against a real HA install.
 from __future__ import annotations
 
 import asyncio
-import datetime
 import importlib.util
 import inspect
 import sys
@@ -917,40 +916,4 @@ def make_config_flow_entry():
     def _factory(domain: str, entry_id: str = "existing"):
         return SimpleNamespace(domain=domain, entry_id=entry_id)
 
-    return _factory
-
-
-def freeze_nestquest_clock(
-    monkeypatch, instant: datetime.datetime
-) -> tuple[datetime.datetime, list]:
-    """Freeze the integration's ``datetime`` clock to a fixed aware instant.
-
-    Only ``custom_components.nestquest``'s ``datetime`` binding is patched,
-    so the generation path's ``datetime.datetime.now`` reads this instant
-    (localized to whatever time zone it asks for) while every other module
-    and the test harness keep the real clock.  Returns ``(frozen, requested)``
-    where ``frozen`` is the instant normalized to UTC and ``requested`` is
-    the list of ``tzinfo`` objects the code under test passed to ``now`` —
-    so a caller can prove the generation path actually requested the
-    configured HA time zone rather than silently reading UTC.
-    """
-    import custom_components.nestquest as nestquest
-
-    frozen = instant.astimezone(datetime.timezone.utc)
-    requested: list = []
-
-    class _FrozenDatetime(datetime.datetime):
-        @classmethod
-        def now(cls, tz=None):
-            requested.append(tz)
-            if tz is None:
-                return frozen.replace(tzinfo=None)
-            return frozen.astimezone(tz)
-
-    fake_module = SimpleNamespace(
-        datetime=_FrozenDatetime,
-        timedelta=datetime.timedelta,
-        date=datetime.date,
-    )
-    monkeypatch.setattr(nestquest, "datetime", fake_module)
-    return frozen, requested
+    return _factory

tests/test_api_health.py

@@ -1,324 +0,0 @@
-"""FastAPI skeleton tests: health, OpenAPI, core wiring (task 042dfc5c).
-
-These tests start the NestQuest API app with httpx against the ASGI
-app and assert the skeleton contract of Feature 16's first task:
-
-- ``GET /health`` returns 200 with a JSON status body (``status: ok``)
-  and does NOT leak the filesystem path;
-- ``GET /docs`` (Swagger UI) is served, and ``GET /openapi.json``
-  returns the OpenAPI document;
-- the app wires core (opens the configured SQLite file and applies
-  migrations on startup via the lifespan) and closes the connection on
-  shutdown (``connected is False`` afterwards);
-- ``ApiConfig.from_env`` raises when ``NESTQUEST_DB_PATH`` is missing or
-  empty, and returns the value when set;
-- a startup failure (unwritable path / non-SQLite file) surfaces from
-  the lifespan rather than the first request;
-- each test is hermetic — it points ``NESTQUEST_DB_PATH`` at a fresh
-  temp file.
-
-A SEPARATE subprocess test asserts the stronger invariant the task
-calls out: the app imports the bundled ``core`` WITHOUT importing
-``homeassistant``.  That cannot run inside the pytest process because
-``tests/conftest.py`` installs mock ``homeassistant`` modules globally
-before any test imports the integration; a subprocess with a clean
-``sys.modules`` is the only honest proof (the same approach
-``tests/test_core_no_ha_smoke.py`` takes for the core bundle).
-"""
-from __future__ import annotations
-
-import subprocess
-import sys
-import tempfile
-import textwrap
-from pathlib import Path
-
-import httpx
-import pytest
-
-from api.app import create_app
-from api.config import ApiConfig, ConfigError
-from api.database import DatabaseState, _executor, make_database
-
-#: The repo root, so the no-HA subprocess can import the API package.
-_REPO_ROOT = Path(__file__).resolve().parent.parent
-
-#: The marker the no-HA subprocess prints on success.
-_SUCCESS_MARKER = "API NO-HA IMPORT OK"
-
-
-@pytest.fixture
-def temp_db_path(tmp_path: Path) -> str:
-    """A fresh per-test SQLite path under pytest's tmp_path."""
-    return str(tmp_path / "nestquest.db")
-
-
-class _AppRunner:
-    """Run the app's lifespan around an httpx AsyncClient.
-
-    httpx's :class:`ASGITransport` does NOT run the ASGI lifespan on its
-    own, so the database would never open.  Starlette exposes the app's
-    lifespan as ``app.router.lifespan_context``; wrapping the client
-    session in it drives the same startup/shutdown path uvicorn would,
-    so ``open_and_migrate`` runs before the first request and ``close``
-    runs after the last.
-
-    ``__aexit__`` uses try/finally so a client-side error still shuts
-    the lifespan down — otherwise a failure mid-test would leak the
-    database connection open.
-    """
-
-    def __init__(self, db_path: str) -> None:
-        self.app = create_app(ApiConfig(db_path=db_path))
-
-    async def __aenter__(self) -> httpx.AsyncClient:
-        self._lifespan = self.app.router.lifespan_context(self.app)
-        await self._lifespan.__aenter__()
-        self._client = httpx.AsyncClient(
-            transport=httpx.ASGITransport(app=self.app),
-            base_url="http://testserver",
-        )
-        return await self._client.__aenter__()
-
-    async def __aexit__(self, *exc) -> None:
-        try:
-            await self._client.__aexit__(*exc)
-        finally:
-            await self._lifespan.__aexit__(*exc)
-
-
-@pytest.fixture
-async def app_client(temp_db_path: str) -> httpx.AsyncClient:
-    async with _AppRunner(temp_db_path) as client:
-        yield client
-
-
-# --- ApiConfig.from_env -------------------------------------------------
-
-
-def test_from_env_returns_set_value() -> None:
-    """A set, non-empty NESTQUEST_DB_PATH is returned verbatim."""
-    cfg = ApiConfig.from_env({"NESTQUEST_DB_PATH": "/data/nq.db"})
-    assert cfg.db_path == "/data/nq.db"
-
-
-def test_from_env_raises_on_empty_value() -> None:
-    """An empty/whitespace-only value raises ConfigError (no silent default)."""
-    with pytest.raises(ConfigError):
-        ApiConfig.from_env({"NESTQUEST_DB_PATH": "   "})
-
-
-def test_from_env_raises_on_missing_value() -> None:
-    """A missing NESTQUEST_DB_PATH raises ConfigError (no silent default)."""
-    with pytest.raises(ConfigError):
-        ApiConfig.from_env({})
-
-
-# --- health / openapi / docs -------------------------------------------
-
-
-async def test_health_returns_200_with_status_body(
-    app_client: httpx.AsyncClient,
-) -> None:
-    """GET /health returns 200 with status ok and no filesystem path."""
-    response = await app_client.get("/health")
-    assert response.status_code == 200
-    body = response.json()
-    assert body == {"status": "ok"}
-    assert "db_path" not in body
-
-
-async def test_openapi_document_is_served(
-    app_client: httpx.AsyncClient,
-) -> None:
-    """GET /openapi.json returns the OpenAPI document."""
-    response = await app_client.get("/openapi.json")
-    assert response.status_code == 200
-    schema = response.json()
-    assert schema["openapi"].startswith("3.")
-    assert "/health" in schema["paths"]
-
-
-async def test_docs_swagger_ui_is_served(app_client: httpx.AsyncClient) -> None:
-    """GET /docs serves the Swagger UI HTML (OpenAPI at /docs)."""
-    response = await app_client.get("/docs")
-    assert response.status_code == 200
-    assert "swagger" in response.text.lower()
-
-
-# --- core wiring & shutdown --------------------------------------------
-
-
-async def test_app_wires_core_and_applies_migrations(
-    temp_db_path: str,
-) -> None:
-    """The lifespan opens the SQLite file and applies migrations.
-
-    After startup, the file exists and carries the NestQuest schema
-    version stamp — proving the app imported core, opened the database
-    at the configured path, and ran the migration runner.
-    """
-    async with _AppRunner(temp_db_path):
-        assert Path(temp_db_path).exists()
-    # Re-open the file with a fresh core database to read the version
-    # stamp independent of the app's connection.  Reuse the API's own
-    # executor so the test exercises the same wiring the app does.
-    from api.nestquest_core import core_db, core_migrations
-
-    database = core_db.NestQuestDatabase(_executor)
-    await database.open(temp_db_path)
-    try:
-        version = await core_migrations.read_schema_version(database)
-    finally:
-        await database.close()
-    assert version >= 1
-
-
-async def test_shutdown_closes_the_connection(temp_db_path: str) -> None:
-    """The lifespan closes the database connection on shutdown.
-
-    After the runner exits, ``DatabaseState.database.connected`` is
-    False — proving ``close()`` ran (the lifespan's finally block) even
-    on a clean exit.
-    """
-    runner = _AppRunner(temp_db_path)
-    async with runner as _client:
-        state: DatabaseState = runner.app.state.db
-        assert state.database.connected
-    assert not state.database.connected
-
-
-# --- startup failure ----------------------------------------------------
-
-
-async def test_startup_fails_on_unwritable_path(tmp_path: Path) -> None:
-    """A database path whose parent directory does not exist fails fast.
-
-    ``sqlite3.connect`` raises ``OperationalError`` for a path under a
-    non-existent directory; the lifespan surfaces that as a startup
-    error rather than the first request.  The connection is closed
-    through the lifespan's finally block (``close`` is a no-op on a
-    never-opened wrapper).
-    """
-    bad_path = str(tmp_path / "does_not_exist" / "nestquest.db")
-    runner = _AppRunner(bad_path)
-    with pytest.raises(Exception):
-        async with runner:
-            pass
-
-
-async def test_startup_fails_on_non_sqlite_file(tmp_path: Path) -> None:
-    """A path pointing at a non-SQLite file fails fast on startup.
-
-    Opening an existing file that is not a SQLite database makes the
-    ``PRAGMA journal_mode=WAL`` run during :meth:`open` raise
-    ``DatabaseError: file is not a database``; the lifespan surfaces it.
-    """
-    bad_file = tmp_path / "not_a_db.bin"
-    bad_file.write_bytes(b"this is not a sqlite database")
-    runner = _AppRunner(str(bad_file))
-    with pytest.raises(Exception):
-        async with runner:
-            pass
-
-
-# --- no-HA subprocess ---------------------------------------------------
-
-#: The no-HA subprocess script.  Runs with ``sys.executable -c`` so it
-#: starts with a clean ``sys.modules`` and no ``homeassistant`` installed
-#: (the suite's conftest stubs are not present in a subprocess).  It
-#: builds the app — which triggers the core bootstrap — and asserts
-#: neither ``homeassistant`` nor ``custom_components`` entered
-#: ``sys.modules``, and that the loaded core package's ``__file__``
-#: points at the bundled directory.
-_NO_HA_SCRIPT = textwrap.dedent(
-    """\
-    import sys
-    import tempfile
-    from pathlib import Path
-
-    sys.path.insert(0, sys.argv[1])
-    REPO_ROOT = Path(sys.argv[1])
-
-    # homeassistant must not be present before we touch the API.
-    assert "homeassistant" not in sys.modules, (
-        "homeassistant already in sys.modules before app import — the "
-        "subprocess is not a clean no-HA process"
-    )
-
-    from api.app import create_app
-    from api.config import ApiConfig
-    from api.nestquest_core import core
-
-    # The app build imports core via api.nestquest_core.  core is a
-    # Home-Assistant-free package; if it (or its loader) ever drags HA
-    # in, this fails.
-    assert "homeassistant" not in sys.modules, (
-        "homeassistant imported while building the NestQuest API app — "
-        "the core wiring is no longer Home-Assistant-free"
-    )
-    # The loader registers core under the distinct name "nestquest_core"
-    # WITHOUT executing custom_components.nestquest.__init__, so the
-    # parent integration package must never be registered, and no
-    # sys.path mutation places the integration directory on sys.path.
-    assert "custom_components" not in sys.modules, (
-        "custom_components registered in sys.modules — the core loader "
-        "executed the integration's HA-coupled __init__ instead of loading "
-        "core by file location"
-    )
-    assert "nestquest_core" in sys.modules, "core was not imported"
-
-    # core.__file__ must point at the bundled directory inside the
-    # integration, proving the file-location loader resolved against the
-    # bundled package rather than some other "core" on sys.path.
-    expected_core_dir = (
-        REPO_ROOT / "custom_components" / "nestquest" / "core"
-    )
-    assert Path(core.__file__).resolve() == (
-        expected_core_dir / "__init__.py"
-    ).resolve(), (
-        f"core.__file__={core.__file__} does not point at the bundled "
-        f"directory {expected_core_dir}"
-    )
-
-    # Build the app (the lifespan is NOT run here, so the path is never
-    # opened — it just needs to be a non-empty string to satisfy the
-    # fail-fast config check).  Use a temp path so nothing is created.
-    app = create_app(ApiConfig(db_path=str(
-        Path(tempfile.gettempdir()) / "nq-noha-buildonly.db"
-    )))
-    assert app is not None
-
-    print("API NO-HA IMPORT OK")
-    """
-)
-
-
-def test_app_imports_core_without_importing_homeassistant() -> None:
-    """The app imports core without importing homeassistant (subprocess).
-
-    Runs in a subprocess because ``tests/conftest.py`` installs mock
-    ``homeassistant`` modules into the pytest process's ``sys.modules``
-    before any test runs, so an in-process check could never
-    distinguish "core never touched HA" from "conftest already stubbed
-    HA for us".  The subprocess is a genuine no-HA process; if the
-    core loader (or core itself) ever grows a ``homeassistant``
-    import, the subprocess exits non-zero with ``ModuleNotFoundError``.
-    """
-    result = subprocess.run(
-        [sys.executable, "-c", _NO_HA_SCRIPT, str(_REPO_ROOT)],
-        capture_output=True,
-        text=True,
-        timeout=120,
-    )
-    if result.returncode != 0:
-        raise AssertionError(
-            f"no-HA app-import subprocess exited {result.returncode}.\n"
-            f"--- stdout ---\n{result.stdout}\n"
-            f"--- stderr ---\n{result.stderr}"
-        )
-    assert _SUCCESS_MARKER in result.stdout, (
-        f"success marker {_SUCCESS_MARKER!r} not printed.\n"
-        f"--- stdout ---\n{result.stdout}\n"
-        f"--- stderr ---\n{result.stderr}"
-    )

tests/test_core_no_ha_smoke.py

@@ -1,230 +0,0 @@
-"""No-HA end-to-end smoke test (task 628473ad).
-
-The bundled core package (``custom_components.nestquest.core``) is
-self-contained and Home-Assistant-free, but the parent integration
-package ``custom_components.nestquest`` is NOT: its ``__init__.py``
-imports ``homeassistant``.  A genuine "core runs with no Home
-Assistant installed" proof therefore cannot live inside the suite
-process — the suite's ``conftest.py`` installs mock ``homeassistant``
-modules globally before any test imports the integration, so an
-in-process exercise can never distinguish "core never touched HA"
-from "conftest already stubbed HA for us".
-
-This module runs the smoke test in a SUBPROCESS (``sys.executable -c
-<script>``) that starts with a clean ``sys.modules`` and no
-``homeassistant`` installed.  The subprocess script:
-
-- asserts ``homeassistant`` is NOT in ``sys.modules`` before importing
-  core;
-- installs a STUB parent package ``custom_components.nestquest`` (a
-  bare :class:`types.ModuleType` whose ``__path__`` points at the real
-  ``custom_components/nestquest`` directory) into ``sys.modules``
-  WITHOUT executing its ``__init__.py`` — so importing
-  ``custom_components.nestquest.core.<x>`` resolves the real core
-  subpackage without dragging the integration's HA imports along;
-- installs a ``custom_components`` namespace entry too, so the
-  subpackage resolves;
-- imports the core modules (db, migrations, children,
-  quest_definitions, materialize, completion, recurrence);
-- asserts ``homeassistant`` is STILL not in ``sys.modules`` after
-  those imports;
-- opens a FRESH SQLite file, applies migrations, creates two children
-  and one quest definition (a daily recurrence rule with a start date
-  and one ``morning`` window), runs :func:`materialize` over a 28-day
-  window, completes one instance via :func:`complete_instance`
-  (``actor_source='panel'``), and derives the instance state via
-  :func:`instance_state`, asserting it is ``done``;
-- prints a clear success marker.
-
-The pytest test asserts the subprocess exit code is 0 and the marker
-is printed, and fails with the subprocess stderr otherwise.  This
-guards the storage/engines/business extraction (tasks d0b691d8 /
-510c1f78 / 4dd8f870) from regressing into a HA-coupled bundle: the
-moment a core module grows a ``homeassistant`` import (direct or via
-the parent package's ``__init__``), this test fails in a process
-where HA is genuinely absent.
-"""
-from __future__ import annotations
-
-import subprocess
-import sys
-import textwrap
-from pathlib import Path
-
-import pytest
-
-#: The marker the subprocess prints on success.  Kept short and unique
-#: so the parent test can assert it survived intact in stdout.
-SUCCESS_MARKER = "NO-HA SMOKE TEST OK"
-
-#: The repo root, so the subprocess can locate the real
-#: ``custom_components/nestquest`` directory regardless of its own
-#: working directory.
-_REPO_ROOT = Path(__file__).resolve().parent.parent
-
-#: The smoke-test script, run with ``sys.executable -c``.  It is a
-#: real no-HA process: the suite's conftest stubs do not exist here,
-#: and ``homeassistant`` is not installed in this venv, so any core
-#: import of HA (direct or via the parent package ``__init__``) raises
-#: ``ModuleNotFoundError`` and the subprocess exits non-zero.
-_SCRIPT = textwrap.dedent(
-    """\
-    import asyncio
-    import datetime
-    import sys
-    import tempfile
-    import types
-    from pathlib import Path
-
-    REPO_ROOT = Path(sys.argv[1])
-    CC_PATH = REPO_ROOT / "custom_components"
-    NQ_PATH = CC_PATH / "nestquest"
-
-    # 1. homeassistant must not be imported before we touch core.
-    assert "homeassistant" not in sys.modules, (
-        "homeassistant already in sys.modules before core import — "
-        "the subprocess is not a clean no-HA process"
-    )
-
-    # 2. Stub the parent packages WITHOUT running their __init__.py.
-    #    custom_components is a namespace package; nestquest's __init__
-    #    imports homeassistant, so we install a bare ModuleType whose
-    #    __path__ points at the real directory instead of executing it.
-    cc = types.ModuleType("custom_components")
-    cc.__path__ = [str(CC_PATH)]
-    sys.modules["custom_components"] = cc
-
-    nq = types.ModuleType("custom_components.nestquest")
-    nq.__path__ = [str(NQ_PATH)]
-    nq.__package__ = "custom_components.nestquest"
-    sys.modules["custom_components.nestquest"] = nq
-    cc.nestquest = nq
-
-    # 3. Import the core modules directly from the bundle.
-    from custom_components.nestquest.core.db import NestQuestDatabase
-    from custom_components.nestquest.core.migrations import apply_migrations
-    from custom_components.nestquest.core.children import create_child
-    from custom_components.nestquest.core.quest_definitions import (
-        create_quest_definition,
-    )
-    from custom_components.nestquest.core.materialize import materialize
-    from custom_components.nestquest.core.completion import (
-        complete_instance,
-        instance_state,
-    )
-    from custom_components.nestquest.core.recurrence import (
-        RuleType,
-        ScheduleRule,
-    )
-    from custom_components.nestquest.core.dao_instances import (
-        QuestInstancesDao,
-    )
-
-    # 4. core must not have pulled in homeassistant.
-    assert "homeassistant" not in sys.modules, (
-        "homeassistant imported by core — the core bundle is no longer "
-        "Home-Assistant-free"
-    )
-
-
-    async def _executor(fn, *args, **kwargs):
-        return await asyncio.to_thread(fn, *args, **kwargs)
-
-
-    async def main() -> None:
-        db_path = Path(tempfile.mkdtemp(prefix="nq-noha-smoke-")) / "nestquest.db"
-        database = NestQuestDatabase(_executor)
-        await database.open(str(db_path))
-        try:
-            await apply_migrations(database)
-
-            # Two children.
-            child_a = await create_child(database, "Ada")
-            child_b = await create_child(database, "Bee")
-
-            # One quest definition: daily recurrence, one morning window.
-            today = datetime.date.today()
-            start_iso = today.isoformat()
-            rule = ScheduleRule(
-                rule_type=RuleType.DAILY, interval=1, start_date=start_iso
-            )
-            created = await create_quest_definition(
-                database,
-                "Brush teeth",
-                rule,
-                [child_a.id, child_b.id],
-                ["morning"],
-            )
-            assert created.definition.id is not None
-
-            # Materialize over a 28-day window (inclusive of both ends).
-            end_iso = (today + datetime.timedelta(days=27)).isoformat()
-            count = await materialize(database, start_iso, end_iso, today=today)
-            assert count > 0, (
-                f"materialize produced no instances over the 28-day "
-                f"window (count={count})"
-            )
-
-            # Complete one instance for child_a on the start date.
-            instances = QuestInstancesDao(database)
-            rows = await instances.list_by_child_and_date(
-                child_a.id, start_iso
-            )
-            assert rows, (
-                "no materialized instance for child_a on the start date"
-            )
-            instance = rows[0]
-
-            result = await complete_instance(
-                database,
-                instance.id,
-                actor_source="panel",
-                actor_child_id=child_a.id,
-                today=today,
-            )
-            assert result == "done", (
-                f"complete_instance returned {result!r}, expected 'done'"
-            )
-
-            state = await instance_state(database, instance.id, today=today)
-            assert state == "done", (
-                f"instance_state returned {state!r}, expected 'done'"
-            )
-        finally:
-            await database.close()
-
-        print("NO-HA SMOKE TEST OK")
-
-
-    asyncio.run(main())
-    """
-)
-
-
-def test_core_runs_end_to_end_without_homeassistant() -> None:
-    """Run the no-HA smoke test in a subprocess and assert its marker.
-
-    The subprocess is a genuine no-HA process: the suite's conftest
-    stubs are not present there, and ``homeassistant`` is not installed
-    in this venv.  If any core module ever grows a ``homeassistant``
-    import (directly or via the parent package ``__init__``), the
-    subprocess exits non-zero with a ``ModuleNotFoundError`` and this
-    test fails with the subprocess's stderr.
-    """
-    result = subprocess.run(
-        [sys.executable, "-c", _SCRIPT, str(_REPO_ROOT)],
-        capture_output=True,
-        text=True,
-        timeout=120,
-    )
-    if result.returncode != 0:
-        raise AssertionError(
-            f"no-HA smoke subprocess exited {result.returncode}.\n"
-            f"--- stdout ---\n{result.stdout}\n"
-            f"--- stderr ---\n{result.stderr}"
-        )
-    assert SUCCESS_MARKER in result.stdout, (
-        f"success marker {SUCCESS_MARKER!r} not printed by subprocess.\n"
-        f"--- stdout ---\n{result.stdout}\n"
-        f"--- stderr ---\n{result.stderr}"
-    )

tests/test_core_settings.py

@@ -1,912 +0,0 @@
-"""Tests for core/settings.py: the explicit, HA-free settings object.
-
-Covers the contracts from task 4dd8f870 plus the review fixes:
-
-- ``NestQuestSettings.from_options`` applies defaults when keys are
-  absent and rejects invalid horizon/rollover values; ``from_options``
-  is strict (raises), while ``from_options_resilient`` falls back PER
-  FIELD so a malformed sibling cannot reset horizon_days/rollover.
-- An AST scan asserts no module under
-  ``custom_components/nestquest/core/`` imports ``homeassistant``,
-  names ``hass``/``config_entry``, reads a ``.config``/``.options``/
-  ``.data`` attribute, or dynamically reads them via ``getattr``/
-  ``hasattr``.  (Docstring mentions are allowed.)  A negative-control
-  test feeds the scanner each bypass shape and asserts it flags them.
-- A settings object constructed with NON-default ``horizon_days`` and
-  ``day_rollover_time`` drives a materialization whose resulting window
-  matches the non-default horizon — via BOTH the core ``materialize``
-  path and the INTEGRATION path (``_run_horizon_materialization`` +
-  ``_register_day_rollover_listener``).
-"""
-from __future__ import annotations
-
-import ast
-import datetime
-from dataclasses import FrozenInstanceError
-from pathlib import Path
-from typing import Any
-
-import pytest
-
-import custom_components.nestquest.core as _core_mod
-from conftest import freeze_nestquest_clock
-
-from custom_components.nestquest.const import (
-    CONF_AFTERNOON_REMINDER_ENABLED,
-    CONF_AFTERNOON_REMINDER_TIME,
-    CONF_CELEBRATION_ENABLED,
-    CONF_DAY_ROLLOVER_TIME,
-    CONF_END_OF_DAY_REPORT_ENABLED,
-    CONF_END_OF_DAY_REPORT_TIME,
-    CONF_HORIZON_DAYS,
-    CONF_MORNING_SUMMARY_ENABLED,
-    CONF_MORNING_SUMMARY_TIME,
-    CONF_NOTIFY_TARGET,
-    DEFAULT_AFTERNOON_REMINDER_TIME,
-    DEFAULT_AUTOMATION_ENABLED,
-    DEFAULT_DAY_ROLLOVER_TIME,
-    DEFAULT_END_OF_DAY_REPORT_TIME,
-    DEFAULT_HORIZON_DAYS,
-    DEFAULT_MORNING_SUMMARY_TIME,
-)
-from custom_components.nestquest.core.settings import NestQuestSettings
-
-
-# ---------------------------------------------------------------------------
-# from_options: defaults + validation.
-# ---------------------------------------------------------------------------
-
-
-def test_from_options_none_yields_all_defaults() -> None:
-    """A None mapping yields a settings object with every default applied."""
-    s = NestQuestSettings.from_options(None)
-    assert s.horizon_days == DEFAULT_HORIZON_DAYS
-    assert s.day_rollover_time == DEFAULT_DAY_ROLLOVER_TIME
-    assert s.notify_target == ""
-    assert s.morning_summary_time == DEFAULT_MORNING_SUMMARY_TIME
-    assert s.afternoon_reminder_time == DEFAULT_AFTERNOON_REMINDER_TIME
-    assert s.end_of_day_report_time == DEFAULT_END_OF_DAY_REPORT_TIME
-    assert s.morning_summary_enabled is DEFAULT_AUTOMATION_ENABLED
-    assert s.afternoon_reminder_enabled is DEFAULT_AUTOMATION_ENABLED
-    assert s.end_of_day_report_enabled is DEFAULT_AUTOMATION_ENABLED
-    assert s.celebration_enabled is DEFAULT_AUTOMATION_ENABLED
-
-
-def test_from_options_empty_mapping_yields_all_defaults() -> None:
-    """An empty mapping also yields every default (the fresh-install case)."""
-    s = NestQuestSettings.from_options({})
-    assert s.horizon_days == DEFAULT_HORIZON_DAYS
-    assert s.day_rollover_time == DEFAULT_DAY_ROLLOVER_TIME
-
-
-def test_from_options_reads_keys() -> None:
-    """Each CONF_* key is read into the matching field."""
-    opts = {
-        CONF_HORIZON_DAYS: 21,
-        CONF_DAY_ROLLOVER_TIME: "03:30",
-        CONF_NOTIFY_TARGET: "notify.mobile_app_x",
-        CONF_MORNING_SUMMARY_TIME: "07:15",
-        CONF_AFTERNOON_REMINDER_TIME: "14:45",
-        CONF_END_OF_DAY_REPORT_TIME: "21:30",
-        CONF_MORNING_SUMMARY_ENABLED: False,
-        CONF_AFTERNOON_REMINDER_ENABLED: False,
-        CONF_END_OF_DAY_REPORT_ENABLED: False,
-        CONF_CELEBRATION_ENABLED: False,
-    }
-    s = NestQuestSettings.from_options(opts)
-    assert s.horizon_days == 21
-    assert s.day_rollover_time == "03:30"
-    assert s.notify_target == "notify.mobile_app_x"
-    assert s.morning_summary_time == "07:15"
-    assert s.afternoon_reminder_time == "14:45"
-    assert s.end_of_day_report_time == "21:30"
-    assert s.morning_summary_enabled is False
-    assert s.afternoon_reminder_enabled is False
-    assert s.end_of_day_report_enabled is False
-    assert s.celebration_enabled is False
-
-
-def test_from_options_does_not_mutate_caller_mapping() -> None:
-    """from_options consumes the mapping read-only."""
-    opts: dict[str, Any] = {CONF_HORIZON_DAYS: 9}
-    snapshot = dict(opts)
-    _ = NestQuestSettings.from_options(opts)
-    assert opts == snapshot
-
-
-@pytest.mark.parametrize(
-    "value",
-    [True, False, "5", 0, -3, 1.5],
-)
-def test_from_options_rejects_invalid_horizon(value: Any) -> None:
-    """A malformed horizon_days is rejected.
-
-    A key that is ABSENT (or present-but-None) falls back to the
-    default — see :func:`test_from_options_horizon_absent_falls_back_to_default`
-    and the None case below; any other invalid value raises, matching
-    the options flow's strict validation.
-    """
-    with pytest.raises(ValueError, match="horizon_days"):
-        NestQuestSettings.from_options({CONF_HORIZON_DAYS: value})
-
-
-def test_from_options_horizon_absent_falls_back_to_default() -> None:
-    """An absent (or None) horizon_days key falls back to the default."""
-    assert NestQuestSettings.from_options({}).horizon_days == DEFAULT_HORIZON_DAYS
-    assert (
-        NestQuestSettings.from_options(
-            {CONF_HORIZON_DAYS: None}
-        ).horizon_days
-        == DEFAULT_HORIZON_DAYS
-    )
-
-
-def test_from_options_horizon_validates_and_defaults() -> None:
-    """from_options returns the configured horizon, defaulting when absent/None.
-
-    A valid horizon is read; an absent or None key falls back to the
-    default; and a malformed value RAISES (the integration's
-    ``from_options_resilient`` handles the per-field fall-back at setup,
-    not this strict path).
-    """
-    assert NestQuestSettings.from_options({CONF_HORIZON_DAYS: 5}).horizon_days == 5
-    assert (
-        NestQuestSettings.from_options({}).horizon_days == DEFAULT_HORIZON_DAYS
-    )
-    assert (
-        NestQuestSettings.from_options(
-            {CONF_HORIZON_DAYS: None}
-        ).horizon_days
-        == DEFAULT_HORIZON_DAYS
-    )
-    for bad in (True, "5", 0):
-        with pytest.raises(ValueError):
-            NestQuestSettings.from_options({CONF_HORIZON_DAYS: bad})
-
-
-@pytest.mark.parametrize(
-    "value",
-    ["25:00", "00:60", "24:00", "9:5", "abc", "07:00:00", 700, ""],
-)
-def test_from_options_rejects_invalid_rollover(value: Any) -> None:
-    """A malformed day_rollover_time is rejected.
-
-    A key that is ABSENT (or present-but-None) falls back to the
-    default — a present-but-empty-string or non-HH:MM value raises,
-    matching the options flow's strict validation.
-    """
-    with pytest.raises(ValueError):
-        NestQuestSettings.from_options({CONF_DAY_ROLLOVER_TIME: value})
-
-
-def test_from_options_rollover_absent_falls_back_to_default() -> None:
-    """An absent (or None) day_rollover_time key falls back to the default."""
-    assert (
-        NestQuestSettings.from_options({}).day_rollover_time
-        == DEFAULT_DAY_ROLLOVER_TIME
-    )
-    assert (
-        NestQuestSettings.from_options(
-            {CONF_DAY_ROLLOVER_TIME: None}
-        ).day_rollover_time
-        == DEFAULT_DAY_ROLLOVER_TIME
-    )
-
-
-@pytest.mark.parametrize(
-    "key",
-    [
-        CONF_MORNING_SUMMARY_TIME,
-        CONF_AFTERNOON_REMINDER_TIME,
-        CONF_END_OF_DAY_REPORT_TIME,
-    ],
-)
-def test_from_options_rejects_invalid_notification_time(key: str) -> None:
-    """The three notification times are validated as strict HH:MM."""
-    with pytest.raises(ValueError):
-        NestQuestSettings.from_options({key: "25:99"})
-
-
-@pytest.mark.parametrize(
-    "key",
-    [
-        CONF_MORNING_SUMMARY_ENABLED,
-        CONF_AFTERNOON_REMINDER_ENABLED,
-        CONF_END_OF_DAY_REPORT_ENABLED,
-        CONF_CELEBRATION_ENABLED,
-    ],
-)
-def test_from_options_rejects_non_bool_toggle(key: str) -> None:
-    """Each toggle must be a real bool (no string coercion)."""
-    with pytest.raises(ValueError):
-        NestQuestSettings.from_options({key: "yes"})
-
-
-def test_from_options_rejects_non_string_notify_target() -> None:
-    """notify_target must be a string (or absent)."""
-    with pytest.raises(ValueError):
-        NestQuestSettings.from_options({CONF_NOTIFY_TARGET: 123})
-
-
-def test_from_options_strips_notify_target() -> None:
-    """A padded notify target is stripped; empty stays empty."""
-    s = NestQuestSettings.from_options({CONF_NOTIFY_TARGET: "  notify.x  "})
-    assert s.notify_target == "notify.x"
-    s_empty = NestQuestSettings.from_options({CONF_NOTIFY_TARGET: "   "})
-    assert s_empty.notify_target == ""
-
-
-# ---------------------------------------------------------------------------
-# from_options_resilient: per-field fallback.
-# ---------------------------------------------------------------------------
-
-
-def test_from_options_resilient_none_yields_all_defaults() -> None:
-    """A None mapping yields the all-defaults settings (no warnings)."""
-    s = NestQuestSettings.from_options_resilient(None)
-    assert s.horizon_days == DEFAULT_HORIZON_DAYS
-    assert s.day_rollover_time == DEFAULT_DAY_ROLLOVER_TIME
-
-
-def test_from_options_resilient_reads_valid_keys() -> None:
-    """Valid keys are read exactly as from_options would read them."""
-    s = NestQuestSettings.from_options_resilient(
-        {CONF_HORIZON_DAYS: 3, CONF_DAY_ROLLOVER_TIME: "03:30"}
-    )
-    assert s.horizon_days == 3
-    assert s.day_rollover_time == "03:30"
-
-
-def test_from_options_resilient_keeps_horizon_when_sibling_is_bad(
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """A malformed SIBLING field cannot reset horizon_days or day_rollover_time.
-
-    The old all-or-nothing fallback reset EVERY field when from_options
-    raised for ANY field: ``{horizon_days: 3, morning_summary_time:
-    '25:00'}`` yielded horizon 14 (was 3).  The resilient builder falls
-    back PER FIELD, so horizon_days=3 and day_rollover_time='03:30'
-    survive a malformed morning_summary_time, and the bad field alone
-    falls back to its default with a warning naming it.
-    """
-    s = NestQuestSettings.from_options_resilient(
-        {
-            CONF_HORIZON_DAYS: 3,
-            CONF_DAY_ROLLOVER_TIME: "03:30",
-            CONF_MORNING_SUMMARY_TIME: "25:00",
-        }
-    )
-    assert s.horizon_days == 3
-    assert s.day_rollover_time == "03:30"
-    # The malformed sibling fell back to its default.
-    assert s.morning_summary_time == DEFAULT_MORNING_SUMMARY_TIME
-    # A warning was logged naming the bad field.
-    assert any(
-        "morning_summary_time" in record.getMessage()
-        and record.levelname == "WARNING"
-        for record in caplog.records
-    )
-
-
-def test_from_options_resilient_bad_horizon_falls_back_with_warning(
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """A malformed horizon_days itself falls back to the default + warning."""
-    s = NestQuestSettings.from_options_resilient({CONF_HORIZON_DAYS: True})
-    assert s.horizon_days == DEFAULT_HORIZON_DAYS
-    assert any(
-        "horizon_days" in record.getMessage() and record.levelname == "WARNING"
-        for record in caplog.records
-    )
-
-
-def test_from_options_resilient_bad_rollover_falls_back_with_warning(
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """A malformed day_rollover_time falls back to the default + warning."""
-    s = NestQuestSettings.from_options_resilient(
-        {CONF_DAY_ROLLOVER_TIME: "99:99"}
-    )
-    assert s.day_rollover_time == DEFAULT_DAY_ROLLOVER_TIME
-    assert any(
-        "day_rollover_time" in record.getMessage()
-        and record.levelname == "WARNING"
-        for record in caplog.records
-    )
-
-
-def test_from_options_resilient_none_value_is_not_a_warning(
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """A None value maps to the default silently (it is absent, not malformed)."""
-    s = NestQuestSettings.from_options_resilient(
-        {CONF_HORIZON_DAYS: None, CONF_MORNING_SUMMARY_TIME: None}
-    )
-    assert s.horizon_days == DEFAULT_HORIZON_DAYS
-    assert s.morning_summary_time == DEFAULT_MORNING_SUMMARY_TIME
-    assert not [r for r in caplog.records if r.levelname == "WARNING"]
-
-
-# ---------------------------------------------------------------------------
-# Construction + frozenness.
-# ---------------------------------------------------------------------------
-
-
-def test_direct_construction_validates() -> None:
-    """Hand-built instances validate the same way from_options does."""
-    with pytest.raises(ValueError):
-        NestQuestSettings(horizon_days=0)
-    with pytest.raises(ValueError):
-        NestQuestSettings(day_rollover_time="bad")
-    with pytest.raises(ValueError):
-        NestQuestSettings(morning_summary_enabled="yes")
-
-
-@pytest.mark.parametrize(
-    "field,kwargs",
-    [
-        ("horizon_days", {"horizon_days": None}),
-        ("day_rollover_time", {"day_rollover_time": None}),
-        ("notify_target", {"notify_target": None}),
-        ("morning_summary_time", {"morning_summary_time": None}),
-        ("afternoon_reminder_time", {"afternoon_reminder_time": None}),
-        ("end_of_day_report_time", {"end_of_day_report_time": None}),
-        ("morning_summary_enabled", {"morning_summary_enabled": None}),
-        ("afternoon_reminder_enabled", {"afternoon_reminder_enabled": None}),
-        ("end_of_day_report_enabled", {"end_of_day_report_enabled": None}),
-        ("celebration_enabled", {"celebration_enabled": None}),
-    ],
-)
-def test_direct_construction_rejects_none(field: str, kwargs: dict[str, Any]) -> None:
-    """__post_init__ is STRICT: None is rejected for every field.
-
-    The None->default mapping lives ONLY in from_options (via
-    _option_value).  A hand-built NestQuestSettings(field=None) must raise
-    in __post_init__ rather than constructing and later blowing up
-    horizon_window (timedelta(days=None) -> TypeError) or the rollover
-    listener.
-    """
-    with pytest.raises(ValueError):
-        NestQuestSettings(**kwargs)
-
-
-@pytest.mark.parametrize("value", [True, False, "5", 1.5])
-def test_direct_construction_rejects_non_int_horizon(value: Any) -> None:
-    """A bool or non-int horizon is rejected at construction (not bool-as-int)."""
-    with pytest.raises(ValueError, match="horizon_days"):
-        NestQuestSettings(horizon_days=value)
-
-
-
-def test_direct_construction_strips_notify_target() -> None:
-    """__post_init__ normalises notify_target the SAME way from_options does.
-
-    P3: a hand-built ``NestQuestSettings(notify_target=' x ')`` is
-    stripped to ``'x'`` (and a whitespace-only value to ``''``) so direct
-    construction behaves like the options flow; a padded value cannot
-    slip through __post_init__ either.
-    """
-    assert NestQuestSettings(notify_target="  notify.x  ").notify_target == "notify.x"
-    assert NestQuestSettings(notify_target="   ").notify_target == ""
-    assert NestQuestSettings(notify_target="notify.x").notify_target == "notify.x"
-
-
-def test_settings_is_frozen() -> None:
-    """The dataclass is frozen so a stale settings object cannot be mutated."""
-    s = NestQuestSettings()
-    with pytest.raises(FrozenInstanceError):
-        s.horizon_days = 99  # type: ignore[misc]
-
-
-def test_day_rollover_hour_minute() -> None:
-    """day_rollover_hour_minute returns the parsed (hour, minute)."""
-    s = NestQuestSettings(day_rollover_time="03:30")
-    assert s.day_rollover_hour_minute == (3, 30)
-    assert NestQuestSettings().day_rollover_hour_minute == (0, 0)
-
-
-# ---------------------------------------------------------------------------
-# horizon_window.
-# ---------------------------------------------------------------------------
-
-
-def test_horizon_window_pinned_today() -> None:
-    """A pinned today is honored so the window is deterministic.
-
-    ``today`` is REQUIRED (no host-clock default) — see
-    :meth:`NestQuestSettings.horizon_window`.
-    """
-    s = NestQuestSettings(horizon_days=5)
-    pinned = datetime.date(2026, 3, 1)
-    start, end = s.horizon_window(pinned)
-    assert start == pinned
-    assert end == pinned + datetime.timedelta(days=5)
-
-
-def test_horizon_window_requires_today() -> None:
-    """horizon_window has no default today: omitting it raises TypeError."""
-    s = NestQuestSettings(horizon_days=5)
-    with pytest.raises(TypeError):
-        s.horizon_window()  # type: ignore[call-arg]
-
-
-def test_horizon_window_non_default_horizon() -> None:
-    """A non-default horizon_days widens the window accordingly."""
-    pinned = datetime.date(2026, 3, 1)
-    short = NestQuestSettings(horizon_days=3).horizon_window(pinned)
-    long_ = NestQuestSettings(horizon_days=30).horizon_window(pinned)
-    assert short[1] == pinned + datetime.timedelta(days=3)
-    assert long_[1] == pinned + datetime.timedelta(days=30)
-    assert (long_[1] - short[1]).days == 27
-
-
-# ---------------------------------------------------------------------------
-# AST: no HA config reads under core/.
-# ---------------------------------------------------------------------------
-
-CORE_PKG = Path(_core_mod.__file__).parent
-
-
-def _is_homeassistant(module: str) -> bool:
-    return module == "homeassistant" or module.startswith("homeassistant.")
-
-
-#: HA-specific identifiers with no legitimate core use.  ``entry`` is
-#: deliberately NOT in this set: core uses ``entry`` as a domain loop
-#: variable (iterating weekday_set entries in recurrence/presence/
-#: quest_definitions), so forbidding the bare name would false-positive.
-#: The config-entry attribute reads the bare-name check misses are
-#: caught by _CONFIG_ATTRS and _FORBIDDEN_ATTRS below.
-_FORBIDDEN_NAMES = frozenset({"hass", "config_entry"})
-
-#: Attribute names that signal a HA object reference (self.hass,
-#: self.entry, obj.config_entry).  No core module currently uses any of
-#: these as an attribute, so flagging them is false-positive-free.
-_FORBIDDEN_ATTRS = frozenset({"hass", "entry", "config_entry"})
-
-#: Config-entry attribute reads — the shapes ``hass.config``,
-#: ``config_entry.options``, ``self.entry.options``, ``runtime.options``,
-#: ``entry.data``.  Flagging the attribute ANYWHERE (regardless of root)
-#: catches ``runtime.options``, whose root name is not a forbidden
-#: identifier.  No core module currently reads any of these attributes.
-_CONFIG_ATTRS = frozenset({"config", "options", "data"})
-
-#: Dynamic config-entry reads via getattr/hasattr with a string argument.
-_GETATTR_FUNCS = frozenset({"getattr", "hasattr"})
-
-#: The dynamic-import function the string-based import bypass uses.
-#: ``importlib.import_module("homeassistant...")`` reaches the HA package
-#: without an ``import homeassistant`` statement the static import check
-#: sees, so the scanner must recognise the call shape too.
-_IMPORT_MODULE_FUNCS = frozenset({"import_module"})
-
-
-def _is_import_module_call(node: ast.Call) -> bool:
-    """True for ``importlib.import_module(...)`` or a bare ``import_module(...)``."""
-    func = node.func
-    if isinstance(func, ast.Attribute):
-        return func.attr in _IMPORT_MODULE_FUNCS
-    if isinstance(func, ast.Name):
-        return func.id in _IMPORT_MODULE_FUNCS
-    return False
-
-
-def _scan_source_for_ha_config(
-    source: str, *, name: str = "<snippet>"
-) -> list[str]:
-    """Return offender strings for HA-coupling in ``source``.
-
-    Flags (each closes a bypass a root-only ``hass``/``entry`` chain
-    check would not catch):
-
-    - any ``import homeassistant`` / ``from homeassistant ...``;
-    - any ``importlib.import_module('homeassistant...')`` (a string-based
-      import that reaches HA without an ``import homeassistant`` statement
-      the static import check can see);
-    - any ``Name``/``arg`` whose id is ``hass`` or ``config_entry``
-      (HA-specific identifiers with no legitimate core use);
-    - any call keyword whose name is ``hass`` or ``config_entry``
-      (catches ``foo(hass=...)`` / ``handler(config_entry=...)`` — the
-      bare-Name check misses keyword arguments);
-    - any attribute access whose ``attr`` is ``hass``/``entry``/
-      ``config_entry`` (catches ``self.hass``, ``self.entry``,
-      ``obj.config_entry`` — root names a root-only check could not see);
-    - any attribute access whose ``attr`` is ``config``/``options``/
-      ``data`` — these are Home Assistant config-entry attributes with no
-      legitimate core use (``.config`` reads ``hass.config``, ``.options``
-      reads ``config_entry.options``, ``.data`` reads ``config_entry.data``);
-      flagging the attribute ANYWHERE (regardless of root) is what catches
-      ``runtime.options``, whose root name is not a forbidden identifier.
-      No core module currently reads any of these attributes;
-    - any ``getattr``/``hasattr`` call whose string argument is
-      ``'config'``/``'options'``/``'data'`` (catches the dynamic read
-      ``getattr(hass, 'config')`` the static attribute check cannot see).
-
-    Docstring mentions are structurally exempt: AST only sees code, and
-    none of these node shapes appear inside a string literal.  The
-    existing docstring references to ``hass.config`` in ``core/events.py``
-    and ``core/store.py`` therefore pass.
-    """
-    tree = ast.parse(source, filename=name)
-    offenders: list[str] = []
-
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Import):
-            for alias in node.names:
-                if _is_homeassistant(alias.name):
-                    offenders.append(
-                        f"{name}:{node.lineno} homeassistant import: "
-                        f"import {alias.name}"
-                    )
-        elif isinstance(node, ast.ImportFrom):
-            base = node.module or ""
-            if _is_homeassistant(base):
-                offenders.append(
-                    f"{name}:{node.lineno} homeassistant import: from {base}"
-                )
-            for alias in node.names:
-                combined = f"{base}.{alias.name}" if base else alias.name
-                if _is_homeassistant(combined):
-                    offenders.append(
-                        f"{name}:{node.lineno} homeassistant import: "
-                        f"from {base} import {alias.name}"
-                    )
-        elif isinstance(node, ast.Name):
-            if node.id in _FORBIDDEN_NAMES:
-                offenders.append(
-                    f"{name}:{node.lineno} forbidden identifier: {node.id!r}"
-                )
-        elif isinstance(node, ast.arg):
-            if node.arg in _FORBIDDEN_NAMES:
-                offenders.append(
-                    f"{name}:{node.lineno} forbidden parameter: {node.arg!r}"
-                )
-        elif isinstance(node, ast.keyword):
-            # A call keyword like ``foo(hass=...)``: the bare-Name check
-            # sees the value, not the keyword's own name, so a HA object
-            # could be passed by keyword without tripping it.  ``arg`` is
-            # ``None`` for ``**kwargs`` unpacking, which is not a name.
-            if node.arg is not None and node.arg in _FORBIDDEN_NAMES:
-                offenders.append(
-                    f"{name}:{node.lineno} forbidden keyword argument: "
-                    f"{node.arg!r}"
-                )
-        elif isinstance(node, ast.Attribute):
-            if node.attr in _FORBIDDEN_ATTRS:
-                offenders.append(
-                    f"{name}:{node.lineno} forbidden attribute: .{node.attr}"
-                )
-            if node.attr in _CONFIG_ATTRS:
-                offenders.append(
-                    f"{name}:{node.lineno} config-entry attribute read: "
-                    f".{node.attr}"
-                )
-        elif isinstance(node, ast.Call):
-            if _is_import_module_call(node):
-                # The first positional argument is the module string; a
-                # constant ``'homeassistant...'`` is the bypass shape.
-                for arg in node.args:
-                    if (
-                        isinstance(arg, ast.Constant)
-                        and isinstance(arg.value, str)
-                        and _is_homeassistant(arg.value)
-                    ):
-                        offenders.append(
-                            f"{name}:{node.lineno} dynamic homeassistant "
-                            f"import: import_module({arg.value!r})"
-                        )
-            func = node.func
-            if isinstance(func, ast.Name) and func.id in _GETATTR_FUNCS:
-                for arg in node.args:
-                    if (
-                        isinstance(arg, ast.Constant)
-                        and isinstance(arg.value, str)
-                        and arg.value in _CONFIG_ATTRS
-                    ):
-                        offenders.append(
-                            f"{name}:{node.lineno} {func.id}() dynamic "
-                            f"config-entry read: {arg.value!r}"
-                        )
-
-    return offenders
-
-
-def _scan_module_for_ha_config(path: Path) -> list[str]:
-    """Scan a core module file for HA-coupling (file-backed scan)."""
-    return _scan_source_for_ha_config(
-        path.read_text(encoding="utf-8"), name=path.name
-    )
-
-
-def test_core_modules_have_no_ha_config_reads() -> None:
-    """No core module imports homeassistant or reads HA config / entry options.
-
-    The scan forbids the HA-specific identifiers ``hass``/``config_entry``,
-    the HA-object attributes ``.hass``/``.entry``/``.config_entry``, the
-    config-entry attribute reads ``.config``/``.options``/``.data``, and
-    dynamic ``getattr``/``hasattr`` reads of them — so a chain rooted at
-    ``self`` or ``runtime`` (whose root name is not a forbidden
-    identifier) is caught.  ``.config``/``.options``/``.data`` are banned
-    because they are Home Assistant config-entry attributes with no
-    legitimate core use: core receives the resolved values via the
-    explicit :class:`NestQuestSettings` object the integration builds
-    from ``entry.options``, so any read of those attributes in ``core/``
-    is a config-entry coupling the settings object exists to remove.
-    Docstring mentions pass: AST only sees code.
-    """
-    py_files = sorted(CORE_PKG.rglob("*.py"))
-    assert py_files, "core package not found"
-    all_offenders: list[str] = []
-    for py_file in py_files:
-        all_offenders.extend(_scan_module_for_ha_config(py_file))
-    assert all_offenders == [], (
-        "core package reads HA config / entry options:\n"
-        + "\n".join(all_offenders)
-    )
-
-
-def test_ast_scan_flags_each_bypass_shape() -> None:
-    """Negative control: the scanner flags each bypass a root-only check misses.
-
-    A root-only scan flags chains rooted at a literal name ``hass``/
-    ``entry``.  Each snippet below is a shape such a scan would miss;
-    this scanner must flag every one.
-    """
-    snippets: dict[str, str] = {
-        "self.hass.config": "x = self.hass.config\n",
-        "config_entry.options": "x = config_entry.options\n",
-        "self.entry.options": "x = self.entry.options\n",
-        "getattr(hass,'config')": "x = getattr(hass, 'config')\n",
-        "runtime.options": "x = runtime.options\n",
-        "hasattr(obj,'data')": "x = hasattr(obj, 'data')\n",
-        "importlib.import_module('homeassistant')": (
-            "import importlib\nimportlib.import_module('homeassistant')\n"
-        ),
-        "import_module('homeassistant.helpers')": (
-            "from importlib import import_module\n"
-            "import_module('homeassistant.helpers')\n"
-        ),
-        "handler(hass=...)": "handler(hass=obj)\n",
-        "handler(config_entry=...)": "handler(config_entry=obj)\n",
-    }
-    for label, src in snippets.items():
-        offenders = _scan_source_for_ha_config(src, name=label)
-        assert offenders, f"scanner missed {label!r}: {src!r}"
-
-
-def test_ast_scan_allows_non_homeassistant_import_module() -> None:
-    """A dynamic import of a NON-homeassistant module is not flagged.
-
-    ``importlib.import_module`` is a legitimate way to load a non-HA
-    module lazily; only a ``homeassistant...`` target is the bypass shape.
-    """
-    src = (
-        "import importlib\n"
-        "m = importlib.import_module('custom_components.nestquest.core')\n"
-    )
-    assert _scan_source_for_ha_config(src, name="non-ha-import") == []
-
-
-def test_ast_scan_allows_non_forbidden_keyword_arguments() -> None:
-    """A call with non-forbidden keyword arguments is not flagged.
-
-    Only ``hass=``/``config_entry=`` are forbidden as keyword names; an
-    unrelated keyword like ``hass_data=`` or ``entry_id=`` must not
-    false-positive (and ``**kwargs`` unpacking has ``arg=None``).
-    """
-    src = (
-        "foo(entry_id=1, name='x')\n"
-        "bar(**kwargs)\n"
-    )
-    assert _scan_source_for_ha_config(src, name="non-forbidden-kwargs") == []
-
-
-def test_ast_scan_allows_legitimate_entry_loop_var() -> None:
-    """A bare ``entry`` loop variable (a domain concept) is NOT flagged.
-
-    ``entry`` is used in core as a loop variable over weekday_set entries
-    (recurrence.py, presence.py, quest_definitions.py) — not a HA config
-    entry.  Forbidding the bare name would false-positive on those, so
-    only ``hass``/``config_entry`` are forbidden as bare names; the
-    config-entry reads via ``entry.options``/``entry.data`` are caught by
-    the ``_CONFIG_ATTRS`` attribute check instead.
-    """
-    offenders = _scan_source_for_ha_config(
-        "for entry in items:\n    pass\n", name="loop"
-    )
-    assert offenders == [], offenders
-
-
-def test_ast_scan_allows_clean_core_shape() -> None:
-    """A clean snippet with no HA coupling is not flagged (no false positives)."""
-    src = "opts = {'a': 1}\nx = opts.get('a')\nfor entry in items:\n    pass\n"
-    offenders = _scan_source_for_ha_config(src, name="clean")
-    assert offenders == [], offenders
-
-
-def test_settings_module_lives_under_core() -> None:
-    """settings.py is part of the core package (not the integration root)."""
-    assert (CORE_PKG / "settings.py").is_file()
-    # And it is importable as a core submodule.
-    import custom_components.nestquest.core.settings as mod
-
-    assert hasattr(mod, "NestQuestSettings")
-    assert isinstance(mod.NestQuestSettings, type)
-
-
-def test_settings_module_has_no_ha_imports() -> None:
-    """settings.py specifically carries no homeassistant import or config read."""
-    offenders = _scan_module_for_ha_config(CORE_PKG / "settings.py")
-    assert offenders == [], offenders
-
-
-# ---------------------------------------------------------------------------
-# Materialization over a non-default horizon: core path + integration path.
-# ---------------------------------------------------------------------------
-
-
-async def _prepare(path, executor):
-    """Open and migrate a database backed by ``executor`` (executor-only DB access)."""
-    from custom_components.nestquest.core.db import NestQuestDatabase
-    from custom_components.nestquest.core.migrations import apply_migrations
-
-    database = NestQuestDatabase(executor)
-    await database.open(path)
-    await apply_migrations(database)
-    return database
-
-
-async def test_materialize_over_non_default_horizon(hass, tmp_path) -> None:
-    """A settings object with a non-default horizon drives the matching window.
-
-    Constructs NestQuestSettings with horizon_days=3 and day_rollover_time
-    '03:30' (both non-default), builds the window via horizon_window, and
-    drives the CORE ``materialize`` over it; asserts the resulting instance
-    rows land exactly on the [today, today+3] window and NOT beyond it.
-    """
-    from custom_components.nestquest.core.dao_children import ChildrenDao
-    from custom_components.nestquest.core.dao_instances import (
-        QuestInstancesDao,
-    )
-    from custom_components.nestquest.core.materialize import materialize
-    from custom_components.nestquest.core.quest_definitions import (
-        create_quest_definition,
-    )
-    from custom_components.nestquest.core.recurrence import (
-        RuleType,
-        ScheduleRule,
-    )
-
-    database = await _prepare(tmp_path / "nq.db", hass.async_add_executor_job)
-    try:
-        settings = NestQuestSettings(
-            horizon_days=3, day_rollover_time="03:30"
-        )
-        assert settings.horizon_days == 3
-        assert settings.day_rollover_time == "03:30"
-
-        today = datetime.date(2026, 3, 1)
-        start, end = settings.horizon_window(today)
-        assert start == today
-        assert end == today + datetime.timedelta(days=3)
-
-        NOW = "2026-03-01T12:00:00+00:00"
-        child = await ChildrenDao(database).create("Ada", NOW)
-        await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(
-                rule_type=RuleType.DAILY, start_date=today.isoformat()
-            ),
-            [child.id],
-            ["morning"],
-        )
-
-        count = await materialize(
-            database,
-            start.isoformat(),
-            end.isoformat(),
-            today=today,
-        )
-        # 4 days (today..today+3 inclusive), one instance per day.
-        assert count == 4
-
-        records = await QuestInstancesDao(database).list_by_date_range(
-            child.id, start.isoformat(), end.isoformat()
-        )
-        dates = sorted({r.due_date for r in records})
-        assert dates == [
-            (today + datetime.timedelta(days=i)).isoformat()
-            for i in range(4)
-        ]
-
-        # Beyond the configured horizon: no instances.
-        beyond = (end + datetime.timedelta(days=1)).isoformat()
-        far = (end + datetime.timedelta(days=10)).isoformat()
-        assert await QuestInstancesDao(database).list_by_date_range(
-            child.id, beyond, far
-        ) == []
-    finally:
-        await database.close()
-
-
-async def test_integration_path_threads_settings(
-    hass, tmp_path, monkeypatch
-) -> None:
-    """The integration path threads ``settings`` through horizon_window + rollover.
-
-    ``_run_horizon_materialization`` calls
-    ``settings.horizon_window(today)`` (so the helper is real and shared,
-    not recomputed inline), and ``_register_day_rollover_listener``
-    registers at ``settings.day_rollover_hour_minute``.  This runs the
-    INTEGRATION path with ``horizon_days=3`` and
-    ``day_rollover_time='03:30'`` and asserts the resulting instance
-    window matches [today, today+3] AND the registered hour/minute are 3/30.
-    """
-    import custom_components.nestquest as nestquest
-    from custom_components.nestquest.core.dao_children import ChildrenDao
-    from custom_components.nestquest.core.dao_instances import (
-        QuestInstancesDao,
-    )
-    from custom_components.nestquest.core.quest_definitions import (
-        create_quest_definition,
-    )
-    from custom_components.nestquest.core.recurrence import (
-        RuleType,
-        ScheduleRule,
-    )
-
-    # Freeze the integration clock so "today" is deterministic (the
-    # hass fixture's config.time_zone is UTC, so 2026-03-01 12:00 UTC
-    # localizes to 2026-03-01).
-    freeze_nestquest_clock(
-        monkeypatch, datetime.datetime(2026, 3, 1, 12, 0, tzinfo=datetime.timezone.utc)
-    )
-
-    database = await _prepare(tmp_path / "nq.db", hass.async_add_executor_job)
-    try:
-        settings = NestQuestSettings(horizon_days=3, day_rollover_time="03:30")
-        today = datetime.date(2026, 3, 1)
-
-        NOW = "2026-03-01T12:00:00+00:00"
-        child = await ChildrenDao(database).create("Ada", NOW)
-        await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(
-                rule_type=RuleType.DAILY, start_date=today.isoformat()
-            ),
-            [child.id],
-            ["morning"],
-        )
-
-        # Integration path: the window comes from settings.horizon_window.
-        await nestquest._run_horizon_materialization(hass, database, settings)
-
-        end = today + datetime.timedelta(days=3)
-        records = await QuestInstancesDao(database).list_by_date_range(
-            child.id, today.isoformat(), end.isoformat()
-        )
-        dates = sorted({r.due_date for r in records})
-        assert dates == [
-            (today + datetime.timedelta(days=i)).isoformat()
-            for i in range(4)
-        ]
-        beyond = (end + datetime.timedelta(days=1)).isoformat()
-        far = (end + datetime.timedelta(days=10)).isoformat()
-        assert await QuestInstancesDao(database).list_by_date_range(
-            child.id, beyond, far
-        ) == []
-
-        # The rollover listener registers at the configured hour/minute.
-        remove = nestquest._register_day_rollover_listener(
-            hass, database, settings
-        )
-        try:
-            reg = hass.time_change.registrations[-1]
-            assert reg["hour"] == 3
-            assert reg["minute"] == 30
-        finally:
-            remove()
-    finally:
-        await database.close()

tests/test_lifecycle.py

@@ -12,7 +12,6 @@ from custom_components.nestquest.const import (
     CONF_ADMIN_USER_IDS,
     CONF_DAY_ROLLOVER_TIME,
     CONF_HORIZON_DAYS,
-    CONF_MORNING_SUMMARY_TIME,
     DEFAULT_HORIZON_DAYS,
     SERVICE_REGENERATE,
     DOMAIN as DOMAIN_CONST,
@@ -37,12 +36,12 @@ async def test_setup_stores_runtime_data_in_hass_data(hass, make_entry) -> None:
     assert hass.data[DOMAIN][entry.entry_id] is entry.runtime_data
 
 
-async def test_setup_runtime_data_has_entry_id_and_settings(hass, make_entry) -> None:
+async def test_setup_runtime_data_has_entry_id_and_options(hass, make_entry) -> None:
     entry = _wire(make_entry(options={"horizon_days": 7}), hass.registry)
     await async_setup_entry(hass, entry)
     runtime = entry.runtime_data
     assert runtime.entry_id == entry.entry_id
-    assert runtime.settings.horizon_days == 7
+    assert runtime.options == {"horizon_days": 7}
     assert callable(runtime.remove_update_listener)
 
 
@@ -527,78 +526,24 @@ async def test_setup_backfills_configured_horizon_days(hass, make_entry) -> None
     ).list_by_date_range(child_id, beyond, beyond_end) == []
 
 
-async def test_setup_succeeds_with_fully_malformed_options(
-    hass, make_entry
-) -> None:
-    """A fully malformed options dict falls back per field and setup succeeds.
+def test_configured_horizon_days_validates_and_falls_back() -> None:
+    """The configured horizon is validated; a malformed value uses the default."""
+    import custom_components.nestquest as nestquest
 
-    ``horizon_days=True``, ``day_rollover_time='99:99'`` and
-    ``morning_summary_time='25:00'`` are all invalid; the integration's
-    ``from_options_resilient`` falls each back to its default, so setup
-    SUCCEEDS, the day-rollover listener registers at the default hour 0
-    minute 0, and the startup backfill materializes the default horizon
-    window.
-    """
-    import datetime
-
-    from custom_components.nestquest.dao_instances import QuestInstancesDao
-    from custom_components.nestquest.db import NestQuestDatabase
-    from custom_components.nestquest.migrations import apply_migrations
-    from custom_components.nestquest.store import async_get_db_path
-
-    db_path = await async_get_db_path(hass)
-    pre = NestQuestDatabase(hass.async_add_executor_job)
-    await pre.open(db_path)
-    await apply_migrations(pre)
-    child_id = await _seed_daily_child_and_definition(pre, _local_today(hass))
-    await pre.close()
-
-    entry = _wire(
-        make_entry(
-            options={
-                CONF_HORIZON_DAYS: True,
-                CONF_DAY_ROLLOVER_TIME: "99:99",
-                CONF_MORNING_SUMMARY_TIME: "25:00",
-            }
-        ),
-        hass.registry,
+    assert nestquest._configured_horizon_days({CONF_HORIZON_DAYS: 5}) == 5
+    assert nestquest._configured_horizon_days({}) == DEFAULT_HORIZON_DAYS
+    assert (
+        nestquest._configured_horizon_days({CONF_HORIZON_DAYS: True})
+        == DEFAULT_HORIZON_DAYS
     )
-    assert await async_setup_entry(hass, entry) is True
-
-    # The day-rollover listener fell back to the default 00:00.
-    registration = hass.time_change.registrations[0]
-    assert registration["hour"] == 0
-    assert registration["minute"] == 0
-
-    # The startup backfill used the default horizon window.
-    today = _local_today(hass)
-    end = (today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat()
-    records = await QuestInstancesDao(
-        entry.runtime_data.database
-    ).list_by_date_range(child_id, today.isoformat(), end)
-    assert len(records) == DEFAULT_HORIZON_DAYS + 1
-
-
-async def test_setup_keeps_horizon_when_sibling_option_is_bad(
-    hass, make_entry
-) -> None:
-    """A malformed sibling option does not reset the configured horizon.
-
-    ``horizon_days=5`` is valid while ``morning_summary_time='25:00'`` is
-    invalid; ``from_options_resilient`` falls back ONLY the bad sibling,
-    so the entry's resolved settings keep ``horizon_days == 5``.
-    """
-    entry = _wire(
-        make_entry(
-            options={
-                CONF_HORIZON_DAYS: 5,
-                CONF_MORNING_SUMMARY_TIME: "25:00",
-            }
-        ),
-        hass.registry,
+    assert (
+        nestquest._configured_horizon_days({CONF_HORIZON_DAYS: "5"})
+        == DEFAULT_HORIZON_DAYS
+    )
+    assert (
+        nestquest._configured_horizon_days({CONF_HORIZON_DAYS: 0})
+        == DEFAULT_HORIZON_DAYS
     )
-    assert await async_setup_entry(hass, entry) is True
-    assert entry.runtime_data.settings.horizon_days == 5
 
 
 async def test_regenerate_service_registered_and_materializes(

tests/test_timezones.py

@@ -13,9 +13,7 @@ import datetime
 from types import SimpleNamespace
 from zoneinfo import ZoneInfo
 
-from conftest import freeze_nestquest_clock
 from custom_components.nestquest.const import DEFAULT_HORIZON_DAYS
-from custom_components.nestquest.core.settings import NestQuestSettings
 from custom_components.nestquest.dao_children import ChildrenDao
 from custom_components.nestquest.dao_instances import QuestInstancesDao
 from custom_components.nestquest.db import NestQuestDatabase
@@ -55,10 +53,35 @@ def _freeze_clock(
 ) -> tuple[datetime.datetime, list]:
     """Freeze the integration's ``datetime`` clock to a fixed aware instant.
 
-    Thin wrapper over :func:`conftest.freeze_nestquest_clock` kept for the
-    ``(frozen, requested)`` return shape the timezone assertions read.
+    Only ``custom_components.nestquest``'s ``datetime`` binding is patched, so
+    the generation path's "today" reads this instant (localized to whatever
+    time zone it asks for) while every other module and the test harness keep
+    the real clock.  Returns ``(frozen, requested)`` where ``frozen`` is the
+    instant normalized to UTC and ``requested`` is the list of ``tzinfo``
+    objects the code under test passed to ``now`` — so a test can prove the
+    generation path actually requested the configured HA time zone rather
+    than silently reading UTC.
     """
-    return freeze_nestquest_clock(monkeypatch, instant)
+    import custom_components.nestquest as nestquest
+
+    frozen = instant.astimezone(datetime.timezone.utc)
+    requested: list = []
+
+    class _FrozenDatetime(datetime.datetime):
+        @classmethod
+        def now(cls, tz=None):
+            requested.append(tz)
+            if tz is None:
+                return frozen.replace(tzinfo=None)
+            return frozen.astimezone(tz)
+
+    fake_module = SimpleNamespace(
+        datetime=_FrozenDatetime,
+        timedelta=datetime.timedelta,
+        date=datetime.date,
+    )
+    monkeypatch.setattr(nestquest, "datetime", fake_module)
+    return frozen, requested
 
 
 def _assert_requested_ha_timezone(requested, time_zone: str) -> None:
@@ -124,9 +147,7 @@ def test_horizon_uses_newyork_local_date_after_local_midnight(
         import custom_components.nestquest as nestquest
 
         child_id = await _seed_daily(database, local_today.isoformat())
-        await nestquest._run_horizon_materialization(
-            hass, database, NestQuestSettings()
-        )
+        await nestquest._run_horizon_materialization(hass, database)
         records = await QuestInstancesDao(database).list_by_date_range(
             child_id,
             local_today.isoformat(),
@@ -166,9 +187,7 @@ def test_horizon_uses_local_date_not_utc_when_host_ahead(
         import custom_components.nestquest as nestquest
 
         child_id = await _seed_daily(database, local_today.isoformat())
-        await nestquest._run_horizon_materialization(
-            hass, database, NestQuestSettings()
-        )
+        await nestquest._run_horizon_materialization(hass, database)
         records = await QuestInstancesDao(database).list_by_date_range(
             child_id,
             local_today.isoformat(),
@@ -212,9 +231,7 @@ def test_horizon_resolves_spring_forward_day_without_off_by_one(
             requested_batches.append(requested)
             local_today = instant.date()
             child_id = await _seed_daily(database, local_today.isoformat())
-            await nestquest._run_horizon_materialization(
-                hass, database, NestQuestSettings()
-            )
+            await nestquest._run_horizon_materialization(hass, database)
             records = await QuestInstancesDao(database).list_by_date_range(
                 child_id,
                 local_today.isoformat(),
@@ -263,9 +280,7 @@ def test_horizon_resolves_fall_back_day_without_off_by_one(
             requested_batches.append(requested)
             local_today = instant.date()
             child_id = await _seed_daily(database, local_today.isoformat())
-            await nestquest._run_horizon_materialization(
-                hass, database, NestQuestSettings()
-            )
+            await nestquest._run_horizon_materialization(hass, database)
             records = await QuestInstancesDao(database).list_by_date_range(
                 child_id,
                 local_today.isoformat(),

uv.lock

@@ -2,55 +2,6 @@ version = 1
 revision = 3
 requires-python = ">=3.11"
 
-[[package]]
-name = "annotated-doc"
-version = "0.0.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" },
-]
-
-[[package]]
-name = "annotated-types"
-version = "0.8.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" },
-]
-
-[[package]]
-name = "anyio"
-version = "4.15.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "idna" },
-    { name = "typing-extensions", marker = "python_full_version < '3.15'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" },
-]
-
-[[package]]
-name = "certifi"
-version = "2026.7.22"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" },
-]
-
-[[package]]
-name = "click"
-version = "8.5.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" },
-]
-
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -60,68 +11,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
 ]
 
-[[package]]
-name = "fastapi"
-version = "0.141.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "annotated-doc" },
-    { name = "pydantic" },
-    { name = "starlette" },
-    { name = "typing-extensions" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/8a/02/91e3416a8fdd715abb903a952a6bec7cdd8d14eed55d415fc8595524c319/fastapi-0.141.1.tar.gz", hash = "sha256:e8822fc40db1e1858054d7a949a888695bc9bdce70139178e33bd2871a453ca1", size = 425799, upload-time = "2026-07-29T17:18:05.568Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/03/10388a42375ee7e4ac9b94eb2c5c569c8b5795e377e701c9ac3ad63de890/fastapi-0.141.1-py3-none-any.whl", hash = "sha256:bfb91aa2d334c61cb35ba9a116fc123b3d3df31640b801cf57a7a78ec3f603b3", size = 131954, upload-time = "2026-07-29T17:18:04.364Z" },
-]
-
-[[package]]
-name = "h11"
-version = "0.16.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
-]
-
-[[package]]
-name = "httpcore"
-version = "1.0.9"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "h11" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
-]
-
-[[package]]
-name = "httpx"
-version = "0.28.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "certifi" },
-    { name = "httpcore" },
-    { name = "idna" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
-]
-
-[[package]]
-name = "idna"
-version = "3.20"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" },
-]
-
 [[package]]
 name = "iniconfig"
 version = "2.3.0"
@@ -224,13 +113,10 @@ source = { virtual = "." }
 
 [package.dev-dependencies]
 dev = [
-    { name = "fastapi" },
-    { name = "httpx" },
     { name = "jinja2" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "pyyaml" },
-    { name = "uvicorn" },
     { name = "voluptuous" },
 ]
 
@@ -238,13 +124,10 @@ dev = [
 
 [package.metadata.requires-dev]
 dev = [
-    { name = "fastapi", specifier = ">=0.115" },
-    { name = "httpx", specifier = ">=0.28" },
     { name = "jinja2", specifier = ">=3" },
     { name = "pytest", specifier = ">=8.0.0" },
     { name = "pytest-asyncio", specifier = ">=0.24" },
     { name = "pyyaml", specifier = ">=6" },
-    { name = "uvicorn", specifier = ">=0.30" },
     { name = "voluptuous", specifier = ">=0.14" },
 ]
 
@@ -266,123 +149,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 = "pydantic"
-version = "2.13.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "annotated-types" },
-    { name = "pydantic-core" },
-    { name = "typing-extensions" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/53/ef/fc4f868f4e2cee79f863883abffceff107875f569b848507319842d2a681/pydantic-2.13.5.tar.gz", hash = "sha256:51a9c5f7b2f8e636f04c6cada605d9b6a3bf1348fdf945a3d8869b19bba0ee08", size = 845750, upload-time = "2026-08-28T14:04:00.916Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/eb/47/c95ffc2009878c7aac0c5e08528022dcb885933252a88b5f170058014464/pydantic-2.13.5-py3-none-any.whl", hash = "sha256:346a034f080da3755d8e9cb5e00e8b07de1d39e4f6e2c87d8ab7cafa0b269a73", size = 472589, upload-time = "2026-08-28T14:03:59.136Z" },
-]
-
-[[package]]
-name = "pydantic-core"
-version = "2.46.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/af/f9/8a06bea35ef8daf588f707784c973a7046e0034c8d8cfb08828eeffb8b75/pydantic_core-2.46.5.tar.gz", hash = "sha256:10416c15b8839ecc4ef4d0885da76da6fd0f67333a0eb8aff6d93c4b8f2910fc", size = 472262, upload-time = "2026-08-28T10:01:31.677Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/b6/81d2d19ea0be2c03664381b59f65fa72fc7969decedae00bc2c4ad835708/pydantic_core-2.46.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a1dee1b804ff4d11c663636cf15d2ea47e9f79cd56c033fb1cbf08924842a48f", size = 2074737, upload-time = "2026-08-28T09:57:57.711Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/18/b70da8300e292df4099684ea11b1958043580d2f50d2dc8bf7e542bdd84a/pydantic_core-2.46.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d625a186a65201c23a9e3b8ed9c47e90a026e03256608cc91851c6709096844f", size = 1921751, upload-time = "2026-08-28T09:57:59.265Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/1a/0d590341b6ffa4b4aca83508e6b8db4761aaeacfc15a25ca3815876d4797/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f8507560a9284e1370bb048ed4282012fbef4e8d109875b95e884d228552061", size = 1948231, upload-time = "2026-08-28T09:58:00.678Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/1d/02eb35761c51f2f7b1b042d6ab4cda6600f0c8c88a2243b3f734376201e5/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f93c5fe914d75fbec9a49209b00da5f08e9e467d69da2b1510c81940cfd10be", size = 2020708, upload-time = "2026-08-28T09:58:02.267Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/ea/f86073830e35d508cc8ddf9c3d9e6e6840fcb88d34bf726b0b4710186f27/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c767f552b21b10f774aeac128e828eafb796adfa1b666a18bf6321453c3a", size = 2194914, upload-time = "2026-08-28T09:58:03.934Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/d7/fc36240d7791ce90939e51608568c33bfdae26202016f9770c229a487d86/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:701b2e04b560eeb4bddf7a25ab8ca476176e34fdbd9a0e18196f0d12d4685f0b", size = 2235622, upload-time = "2026-08-28T09:58:05.516Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/bc/3fa2d76b83162820a17da7f645b28d1cba99fc8e1e5fc6517067ec450fa1/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49776eab08766a08dfff7012f8b422dcd7e25e43b316eedf0477c24fcfa84b7c", size = 2062091, upload-time = "2026-08-28T09:58:07.135Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/9a/095d557bb492c90cd8a70a6dd048bf793d433d03d86c81c11e912e4cd049/pydantic_core-2.46.5-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:a2468d93d181667a7abd66e1b64bb9f76f361b0fef8faddf687456453576f5ee", size = 2089904, upload-time = "2026-08-28T09:58:08.814Z" },
-    { url = "https://files.pythonhosted.org/packages/24/98/7b76b1ad10a19a617a52aaa1d80e159115af939b095e86f8e756fd52e0df/pydantic_core-2.46.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:53feb344243bb9510a9dec7bf3cf1b64d88a98af5dc7872a5160465f8b198c8e", size = 2132244, upload-time = "2026-08-28T09:58:10.435Z" },
-    { url = "https://files.pythonhosted.org/packages/20/32/7d6ca365fadba186a0c8f85de1a701663bce81efd309d9479be58687622f/pydantic_core-2.46.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:cd5214352ae68f3b5e9af7768bdc5253695ee069675db3480518420b3be881f2", size = 2143901, upload-time = "2026-08-28T09:58:12.033Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/09/eb9a6aa57f22fd1541a9c0aa2a1f3aeef3ec65347d33e10a6da2f43e0ee9/pydantic_core-2.46.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:9432f3598db432cb51c5b37fdbf29a60fcccc79e30d37a05022776a6bc4ab689", size = 2299425, upload-time = "2026-08-28T09:58:13.614Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/f9/548a5bb9d4ba8cd26e26daf48052236f6b38bb61e7b7241fbc3c995719eb/pydantic_core-2.46.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8feeac04b5794e513e710af2f9c87d49f31a6dc47967bb264a1fed61a8989bec", size = 2318566, upload-time = "2026-08-28T09:58:15.199Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/20/06454d18834c02c406c9133f1a3b485305fd9ee984f9636c2f730bef6a9d/pydantic_core-2.46.5-cp311-cp311-win32.whl", hash = "sha256:892a881d5f68c2b9ea304b7a6c2c60d9343df578a311b0f86b94bc8f1ffe8129", size = 1954258, upload-time = "2026-08-28T09:58:16.813Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c2/718b9deb4b72453b5d8c7447a3b14cb77bef36917ef5f514e0948a4096a0/pydantic_core-2.46.5-cp311-cp311-win_amd64.whl", hash = "sha256:40375c2d05acec10323e45dfe2077ac44bc74659008614af5069034e2cfc781c", size = 2041030, upload-time = "2026-08-28T09:58:18.288Z" },
-    { url = "https://files.pythonhosted.org/packages/67/ea/c1d1a5b72d6e1ff7f377a4d9199f6591f095beb5b409a8a5d89f7238d939/pydantic_core-2.46.5-cp311-cp311-win_arm64.whl", hash = "sha256:28a6a556cd3b6066bea827857f9d9cce027c96f776e512f544a581f9e42161f8", size = 2009234, upload-time = "2026-08-28T09:58:19.929Z" },
-    { url = "https://files.pythonhosted.org/packages/82/3f/76358795aa7a8c6d4f36e2cb828ad1c90ee118e1393a9281664f5aade9d4/pydantic_core-2.46.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b9fe6fb92520e3fd61f2e49000b6911b188824f089b75973ea06d6267f0b476d", size = 2076516, upload-time = "2026-08-28T09:58:21.576Z" },
-    { url = "https://files.pythonhosted.org/packages/db/50/26b091836076ce4cb2fac264186936acc069e0595772cfd02a563bc4761a/pydantic_core-2.46.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a39ac25a9a2fa4072efdb429833c4a4c8009a51ff9eea3eeae131713cd27991e", size = 1922874, upload-time = "2026-08-28T09:58:23.766Z" },
-    { url = "https://files.pythonhosted.org/packages/09/f0/2a8ce3849e299d44e2d2c196b6082643a3235565a735cb51db7a6261f614/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fdc8b93a41521988916eeaa271173fcca7fa0803d62f87675aac8dcec1c8e29", size = 1951772, upload-time = "2026-08-28T09:58:25.435Z" },
-    { url = "https://files.pythonhosted.org/packages/87/46/ac0dc8bdd9e6048183a14eb127764e7ad9240021c17513074a4711b0e31e/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b98134087d9de723658d17a42c7d0da8d6e2ef08015dee7dc93889047315f5e4", size = 2031832, upload-time = "2026-08-28T09:58:27.102Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/c2/339de5bef7be36301a2231eaa52e62163742c2281f11b5f4892bc79785cd/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e652ab17569c94bff5475520f907b7148b8c24036a8ebbe5cf7cf7493d28579a", size = 2208645, upload-time = "2026-08-28T09:58:28.948Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/a0/9ff22b797724262da14427abaed4dd1d864a139693fc5e7809114376a716/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d925f3d9afd05a8c0fb3a1031463a8d59ebe5e2afad297e29c78be19e13b4e62", size = 2265935, upload-time = "2026-08-28T09:58:30.625Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/a4/eb9409ec0736e50aa70a412f16c204ed149516846912f7e6724d4c73ee53/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fc5be0abd4a407e200d844b404e33639a554e7bd0d448e7b9ae181be4789ac2", size = 2066284, upload-time = "2026-08-28T09:58:32.289Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/02/7f6156ffc926857f1c37c07d9a388682865a81830ab6a1b637082c25e399/pydantic_core-2.46.5-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:816ff0a6550ffc06c098ccd2e0698600f9aa7da192a79eaa6f9af504a35db869", size = 2105889, upload-time = "2026-08-28T09:58:33.986Z" },
-    { url = "https://files.pythonhosted.org/packages/92/b1/e781d357ebe09fc929f995700f1b3503e8897f1cece183ecb1300d4d67e9/pydantic_core-2.46.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c7ea57fc63aa7da93a1bd2d644e6577befae10c52c4e36377635eea1056a74f5", size = 2158006, upload-time = "2026-08-28T09:58:35.647Z" },
-    { url = "https://files.pythonhosted.org/packages/70/0a/644597d84ab400e50609c192120b85c9681c22d3a20461b9060a79be0a7a/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:efd62a42486f1bda5d24cb4f63d15a3c7768375fe83d36f9417b4ad7a2fb20b3", size = 2158408, upload-time = "2026-08-28T09:58:37.38Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/ee/ca3b7b3a4b3769ffe9ce9432a7c9be755de9593a46d3b0d54d0409323e44/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:2bc9419666990c06d7397831f2126a1ecc3594aaa3ff7de5bf2d066802f4e07b", size = 2309609, upload-time = "2026-08-28T09:58:39.22Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/52/39fa1f451486019524ca685020390e7ca351832fd874530ba30c8628e6dc/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:18a09e1e1011b462f2e32774f25859ef1223d5c2b0546a633cf56654710721e0", size = 2342618, upload-time = "2026-08-28T09:58:40.89Z" },
-    { url = "https://files.pythonhosted.org/packages/81/5e/468fc630568c61dcef3cd47ad32ffbeed9af643f49208d1ea86ab4f890c4/pydantic_core-2.46.5-cp312-cp312-win32.whl", hash = "sha256:5cb482e9e84c851f4e623fe4acc1ced89168cf1fe18f7089db4548c8f5bbb65b", size = 1939475, upload-time = "2026-08-28T09:58:42.591Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/c9/4c19f41b84cf6b622a72fbeed7665b25d47a187d68d47d0d430c07f23268/pydantic_core-2.46.5-cp312-cp312-win_amd64.whl", hash = "sha256:5e81740c09e310f5aa5cbd3e434a01c154d4bef93241c7877b39f211d2b78ba8", size = 2043140, upload-time = "2026-08-28T09:58:44.272Z" },
-    { url = "https://files.pythonhosted.org/packages/af/dd/0c1a050299147c746e5256db16d645ab5efd4f78c59937d581a0524e74a2/pydantic_core-2.46.5-cp312-cp312-win_arm64.whl", hash = "sha256:f7b0ec93a2893de856652154d73b7ba622f26fa97726487dcac373de5f4c6084", size = 1997729, upload-time = "2026-08-28T09:58:46.13Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/37/5abe39a8372a61d3dc3c1338fc504281c01b32fdb3169cd7187153b56d3e/pydantic_core-2.46.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:b7ca9034437b6022f941f4857459562ee00a560b97e7cce8a0ec5a74fc6766e0", size = 2075885, upload-time = "2026-08-28T09:58:47.856Z" },
-    { url = "https://files.pythonhosted.org/packages/21/43/6323b1f8b217780454c61304bcd2b38ae4762f50754414124603ccc90bb2/pydantic_core-2.46.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f332f0e72a5a0400141f830744e141bf9f97917878dbe968669e8a7fefea78ff", size = 1922768, upload-time = "2026-08-28T09:58:49.58Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/a3/c05ca796e1197618a774b01e596aeedfefc2f7d8c01ae3054e910b120e8a/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:193375f3548919d3f0b60936ca113ada3e38f264f91b9b8e0508efaad57be931", size = 1951241, upload-time = "2026-08-28T09:58:51.511Z" },
-    { url = "https://files.pythonhosted.org/packages/68/32/33bc39ac705c52cffc908e8389f9754fdb208aea5c69cceddf4eb3ce99af/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:79bdfa52f843137045b2d081cc05c120ba6665d29b7559c2c47690906f39279f", size = 2031975, upload-time = "2026-08-28T09:58:53.166Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/70/2333e885c0f6a67bc105c5916965dac9b57f2718ee20d81d1a06a4ebdc13/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:24922243639cbdac66c75fcb6fd6495a9cb52b213d62f9a0d16f0310b1ff8038", size = 2208542, upload-time = "2026-08-28T09:58:55.017Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/ea/296debfb4264207bbda5936133892e027c0a58875ad53ebd512fba8ec3a2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c76fe65e607be28c7fd4d56fc3c42b1583aa058ce3408b7ad0fd540171d31f9f", size = 2264692, upload-time = "2026-08-28T09:58:56.767Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/f2/9e4de77a6271e07a76d2d58b11c091a979c191ed2939bf80067568b369d2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f7b393a8b3da82f5c1fc0751e6d01ac6c55b93c18226a60bdfba4a724efafd1", size = 2066633, upload-time = "2026-08-28T09:58:58.531Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/db/f9e9d0c97445987b2084823d5c240de88087338f04fc2cfaa2df186b8049/pydantic_core-2.46.5-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:7ac031912d54f3d83ef3b3eb98dfabc1608802e2202263d25957eeed40b94761", size = 2105235, upload-time = "2026-08-28T09:59:00.421Z" },
-    { url = "https://files.pythonhosted.org/packages/07/c5/79169b047b3b2c3e99e04bc76372af9637e0bf6db638274fa927df96369e/pydantic_core-2.46.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:837b396ca3d7b74091ca623f6cbd8351bd42d670a79c2683e79fb089f06a2de5", size = 2157367, upload-time = "2026-08-28T09:59:02.442Z" },
-    { url = "https://files.pythonhosted.org/packages/26/b5/ba6057afb7c291bd449f51b867f95aef2072941c4ce4e5c31d6ffd132d3b/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:5ee239d575f80b08eca11f6e20f90c4c695de7825c67eefe6091fbf20dda648e", size = 2158420, upload-time = "2026-08-28T09:59:04.2Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/28/2057abecaafdc22912afa819603a51f0a62d40643b7c4871c51721fea9be/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:e80675d75ae2cd14372cb65cad5400d9347a3d3f6c13000183f22dfd027283ed", size = 2309588, upload-time = "2026-08-28T09:59:06.048Z" },
-    { url = "https://files.pythonhosted.org/packages/71/9d/881156dc404e27479c4246128d73538464cab4a239bec61995e227644c30/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:9c4b71f10dd532fb7a5cbc8f58707779e64f03a258c2bf8bfbaecfcd9970b519", size = 2341866, upload-time = "2026-08-28T09:59:08.539Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/38/d66f443a259f84d13babdceae568e572b0ed26da17ca5d0a649ebb110a67/pydantic_core-2.46.5-cp313-cp313-win32.whl", hash = "sha256:97bf8de4d541598c94a59344eeb988a94c08ff76b5723c41f6567ec18c7892ea", size = 1938580, upload-time = "2026-08-28T09:59:10.402Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/1e/1d5371213f4cc9a7ed70c0bfcc7911de22311ee99a662a56077d7292d2ac/pydantic_core-2.46.5-cp313-cp313-win_amd64.whl", hash = "sha256:15f4a94963c95accac15b7b657bb177d3ad82bb90b0d0526d9a9b85079925db5", size = 2041980, upload-time = "2026-08-28T09:59:12.396Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/48/4222d90b1c67568bace4dec6dca6271449c66de3595d72b6d098f5fde597/pydantic_core-2.46.5-cp313-cp313-win_arm64.whl", hash = "sha256:d22a945598fb91236b4dd793a6e42e4f3dd7740bb5aace5ebd7d4c08d13bb575", size = 1997213, upload-time = "2026-08-28T09:59:14.245Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/8a/14596f2a8367da50cf7cbac48169ee5d9c8e11d486a3b527082384630c72/pydantic_core-2.46.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c1c43ad4339643d70ebb8124e1305a7dab423001eff58bb41a0f731adbc98355", size = 2074081, upload-time = "2026-08-28T09:59:16.141Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/d5/d8a4eb6d6c7f66b91dd37c576d76e9e60fba900caf5372c17bcf949febc2/pydantic_core-2.46.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1a353f84de772f423b5ffb11d7ae352fbbef0f446f3c0b0af0f8236d7233606e", size = 1920497, upload-time = "2026-08-28T09:59:18.065Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/26/092079428f86e927e030b2c0ced87df69dbb1c875cdeaa67bf42ea2be746/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5086029a57366b8cf81b130a43908738095c270c21a8d7f0e8bdfdb89718e2f3", size = 1952130, upload-time = "2026-08-28T09:59:20.476Z" },
-    { url = "https://files.pythonhosted.org/packages/08/c3/8ec0e290a9ebaebd64047bf5fda94be835c6b1551b02437e4b76778fbcd7/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:46c25dda9d092a06c08db76ffe0a197107904d0dfac653f7d5306bbcd6d6119c", size = 2026371, upload-time = "2026-08-28T09:59:22.227Z" },
-    { url = "https://files.pythonhosted.org/packages/01/72/4fd20ad520fb8da0157f95b27a7eb05a72790ef08138e7701ac972c342ea/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:37ea7b83c935e5b0d68c9449b82651accf78a10828b2c02b2f2d9e9496446c21", size = 2202822, upload-time = "2026-08-28T09:59:24.277Z" },
-    { url = "https://files.pythonhosted.org/packages/31/b0/d16e0771206b29314f0d52198b720be21e8a99ab2bf11e3bc0d7c9cebdff/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e64e88d5585bea9ce95861079de72006c7fa6d3df4e3a3b65ba31eb979c15c9f", size = 2262756, upload-time = "2026-08-28T09:59:26.608Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/9b/59634b7ac631c63b2a37760eb6943af3e29573d6b59a4abc5e7f019d4cee/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54d510bac3ee52247af28ed4bb18a1e799f040ac60fd2bf5ccd4c92f1fbe786f", size = 2068352, upload-time = "2026-08-28T09:59:29.044Z" },
-    { url = "https://files.pythonhosted.org/packages/08/7c/570abb1ad2155348dc754ea91be22e5aaa18eb6d69a6068f7c6f2679a6ed/pydantic_core-2.46.5-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:a2a5e1d0ff29adddc9f6d6821a66302e4493f8ca898b715b6b1182c2c201ea0a", size = 2104777, upload-time = "2026-08-28T09:59:30.95Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/25/5bf74adc65a1ac5b7be3f6cb0bcb5433615c1598a801c19d830d84c98ded/pydantic_core-2.46.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:03b9666e41e35d8909852ba191a0607520f81b74eaf12ccf8737005dbb313821", size = 2156312, upload-time = "2026-08-28T09:59:32.604Z" },
-    { url = "https://files.pythonhosted.org/packages/90/6a/2ef38830675e050121040618135564ed56b860b45433b02d9b4ebece46f3/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:a91c17edf6eea2402cb5457b4c89e99bc5ed1004aa34c4adf1d4258c1a5c22c2", size = 2150067, upload-time = "2026-08-28T09:59:34.453Z" },
-    { url = "https://files.pythonhosted.org/packages/90/ef/a7dbb03a14a64c2a4621f989c615ed9a892535a6cad938fc27079f919d80/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b49924c73a235e969511bf2aabdff3beebf9820931f646c80274d5d780010c47", size = 2304516, upload-time = "2026-08-28T09:59:36.194Z" },
-    { url = "https://files.pythonhosted.org/packages/68/f8/6bb4c4b80e8a6fde1904c64a51c62a1d04fcdfa3ea521a66b2ddefa1d885/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:2cbd9a5eff05e51c447c34dfa4632145b26b09120cf04bd0c871e44c1a5e1c9a", size = 2335223, upload-time = "2026-08-28T09:59:37.931Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/80/f46b8c681195190b2c1f1c7c0a81abce60663e987613e09ef64d433dd96b/pydantic_core-2.46.5-cp314-cp314-win32.whl", hash = "sha256:2d5d76654becf5efd62c9e51c3756c67b49498b0c9a40884934c40807adbd074", size = 1934827, upload-time = "2026-08-28T09:59:39.836Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/3c/60674207246bc0a4009d2391b7c7251c7159f279c8d2ab8aae8ef46f3dee/pydantic_core-2.46.5-cp314-cp314-win_amd64.whl", hash = "sha256:fa10ef4112775900e7a0661068635eb67b2ab824fbde764de6e0e21982a93db0", size = 2042648, upload-time = "2026-08-28T09:59:41.792Z" },
-    { url = "https://files.pythonhosted.org/packages/69/0c/117c562c7c1babdf44576b72a5e496906506c93690387ecfbca7c729ae2e/pydantic_core-2.46.5-cp314-cp314-win_arm64.whl", hash = "sha256:045ab3b6d308439e32b81cc173bba5b9018bc6ed896afd0c65b3b009b1699af5", size = 1989652, upload-time = "2026-08-28T09:59:43.702Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/66/9336ae58f9eb68c41d121894e52c4c89eccb07eb8f602a04ee9c3f37736a/pydantic_core-2.46.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8816f3d218beb4b787de5c9759c259b8fa61f9dec42dc7811f320a33771778b7", size = 2065829, upload-time = "2026-08-28T09:59:45.364Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/02/bc19b47a96c2d3109760711acf22369e56bd7e405ca52f7ade164d2ead57/pydantic_core-2.46.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:bce57638e08ac148e5778cce7feb968307a727d66f8e2274a543d0cf0c9ad6a3", size = 1905716, upload-time = "2026-08-28T09:59:47.18Z" },
-    { url = "https://files.pythonhosted.org/packages/52/a4/70b47c0509923dd98ccfed04fb3e32ea3849c82a0ff2205bb41009b43c00/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:976e1128455aa595ea04c79ccfedff1aaeab96ee013fcc916bed120c4f0ad94f", size = 1934216, upload-time = "2026-08-28T09:59:49.241Z" },
-    { url = "https://files.pythonhosted.org/packages/52/ab/aa03b65f7bb198585edf806b906c3223ecf1795543e39e23aec4cce27ad2/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b891faeedeafba41b2983e5001a81b6a915b69544c7e7570d1989ce1c36ac7", size = 2010635, upload-time = "2026-08-28T09:59:51.692Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/8b/0da06343f30b84ec549aafd309c6456223d5dc8bd36af504c573faad561d/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f194189415698233dd1114a093a9b56e61e2c57e11b469be3b0506f46f0771c", size = 2209369, upload-time = "2026-08-28T09:59:53.582Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/5b/844c4defaa34a3df66eb9257087d121d70c201298b96abdf9f492fc2f1bf/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82a36973cf8a2ef5406f4fe2edbf8ed0c99629535d959e0b100c76a32535a111", size = 2253238, upload-time = "2026-08-28T09:59:55.484Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/64/a4e536cb16d7f61a7fd3120b46c577fc7fa7325992f69c4f52bc786d77d8/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdbb78909f52b981d3b2d56b97328d71eb0b974c36bd77c920123a7ebb192829", size = 2065740, upload-time = "2026-08-28T09:59:58.038Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/75/aaa38c6bc2d085f6605b34eabdc6a8a4e0b2e61fc9c8e6e52b28e97b3125/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:52e24eacdb536cade636aa90fb851835222becff8484b7001fdc78cb0290f2aa", size = 2087425, upload-time = "2026-08-28T09:59:59.898Z" },
-    { url = "https://files.pythonhosted.org/packages/55/ae/fcab4cfc39aba3689e1d20c8b5250ad280957022c09af2ed9cd585602a5e/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:37ae34309d7bd8c0d61ab839668058f2a7962ea1fc51d105d2db228fe0618034", size = 2139306, upload-time = "2026-08-28T10:00:03.057Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/f4/f1d03a4bc9d9acbc62f4d742b8a319af52f71885079868b2ff8e48a651ee/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:0cdbada856a1c69a7624a64d3d9aefe79300bd6ef827b43a4f265010b9b55184", size = 2144589, upload-time = "2026-08-28T10:00:05.645Z" },
-    { url = "https://files.pythonhosted.org/packages/83/f3/7a53bb1356de514a4cd295f25b6ac39237895620c0462d2592b76c16e114/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:545f26c504b27c3758439a5e6d9349931f0a04f855668d5fe323c89e82300a38", size = 2288882, upload-time = "2026-08-28T10:00:07.931Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/94/5a81583660c175c59d49ffb09f4b3a44debeaf86a19fca664ae1cdd9ee32/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:ff218293c9c806138dca139765e3b067621be52bcd93cdc14c7711be7ddc90a9", size = 2335210, upload-time = "2026-08-28T10:00:10.177Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/9f/5d685c2693b972d1a59c998586e8823712b66603aeff47ee60a4bdaafd37/pydantic_core-2.46.5-cp314-cp314t-win32.whl", hash = "sha256:97cf3eb53a8cccacf9d46686a0926186c9bfb5574f2ed66d3639d5fe117cd3a9", size = 1921180, upload-time = "2026-08-28T10:00:12.35Z" },
-    { url = "https://files.pythonhosted.org/packages/70/12/5c94ee16d65a37a15f9e869f5e6256df111154491173801a4c5e800ab548/pydantic_core-2.46.5-cp314-cp314t-win_amd64.whl", hash = "sha256:d2f9fc07a8042a8f95925b35c4f04f469707c981fc33245b6ca187cf5d2dd290", size = 2020515, upload-time = "2026-08-28T10:00:14.774Z" },
-    { url = "https://files.pythonhosted.org/packages/63/19/67830dda664e6bdf9285ee2e40f355d0d7d6b92aa0c42e8d217bb8d33d36/pydantic_core-2.46.5-cp314-cp314t-win_arm64.whl", hash = "sha256:acf8a67ba51f4ca9ddbd0e6b3000a65ac51ab734661778b3e7ba64d99a710f2f", size = 1989276, upload-time = "2026-08-28T10:00:16.984Z" },
-    { url = "https://files.pythonhosted.org/packages/af/1e/ecca01fce348f7e8afa9572441ff6f7d1cc70d21e4859f33944d10877e1e/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:c14ad3bdc85ee7f318742c457ca3968a92126d144b15721c759033bfb06296c2", size = 2075342, upload-time = "2026-08-28T10:00:51.353Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/4c/af80c7a8032dfc897040ad5cb772bebde529a381186499e6e29987f23f8c/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0bddb4020d8f04175865ccd17eff3040874fc11fb593f424edb452653b4b947c", size = 1907219, upload-time = "2026-08-28T10:00:53.438Z" },
-    { url = "https://files.pythonhosted.org/packages/be/3e/54d89e2b092e778716bf6153634ef479e955f48c261090be23aa1e0fb0b5/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2471fd51c61c610e1dcf7de44d7299283661654d11264ab4802b303368d69c47", size = 1953393, upload-time = "2026-08-28T10:00:55.58Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/89/828ee90cda28ce17bdefaa3a6eaf74fe430e113295a10e6126beca559d6c/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b10ec717381bdbfafef34607824db4c91de69ff085e4fca3b2af91b4fa17e68a", size = 2099024, upload-time = "2026-08-28T10:00:57.794Z" },
-    { url = "https://files.pythonhosted.org/packages/df/dd/053c2e4303f791f3b8f8a14ab0b22008e8eb21d868c0c90b4f9be705b76a/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:013d6f3483d81e02e7c328831808f336c8596ee33b4bd4026b9ffb1e960b8942", size = 2062540, upload-time = "2026-08-28T10:01:00.318Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/dd/a18df751a5e37dd51bfad7f68e766999125bebe68c9e1d10a493ad01bd63/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:e9c134bb666dd54b778b9fc0d2b50cbb7f979b9e3716f26a88c9ab3b6fc1dd0f", size = 1902040, upload-time = "2026-08-28T10:01:02.529Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/13/01d40f9d07ce8a779fd6e0bd8ad4fba91309500dd67b869e2e219d261a6d/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:347ec774390c87326a2e4929d58d3f7e8763a104d5d35f4cd595a4c952366433", size = 1967479, upload-time = "2026-08-28T10:01:05.004Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/04/c81d4841331c2178b6fb09ae225425e110ed72d990c9fe556c4ec03d1013/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e24d8f05fa2d28513d94e877e9c75ad66175376209b3977f916e240e623193c", size = 2111034, upload-time = "2026-08-28T10:01:07.345Z" },
-    { url = "https://files.pythonhosted.org/packages/20/21/22102e9950b3049526d20e811b95396508377d87651edd2b80d2b3d28659/pydantic_core-2.46.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ab4b66edffb32d9e951efb3814bd104b8367a7501b81b955cacb5726d897389f", size = 2071333, upload-time = "2026-08-28T10:01:09.636Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/18/87aefa427d191e6d3ab1447f1efc1cdcac86af1069239b133e8a0fd7f7c9/pydantic_core-2.46.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:337639ba62a11acde6ef3aeb08c8ea755f8ef1fe5e513356c0f36a2b0d7568b0", size = 1912713, upload-time = "2026-08-28T10:01:12.285Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/93/fd89e9ad49b1805ca94d24ce1088b7d305f05c35ffafcedb9819d03588a0/pydantic_core-2.46.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:413a717a410d0c817ef5b786a059415550b3794e1d0c2abffd9efb93a3d9f7b4", size = 2090926, upload-time = "2026-08-28T10:01:15.19Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/45/8e59dab6acf8d35f02f0a958980074f31038968bdb2c983fcae9d1efee03/pydantic_core-2.46.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1e449def1945a462c464331254e5a44fca7c3b4f9aedf59ec2f50f8066dd8e25", size = 2131303, upload-time = "2026-08-28T10:01:17.937Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/a5/e1d4dc5180dd887a9522efc1f8716b8692b7606b1d3273d7862eaf66be44/pydantic_core-2.46.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:a445486499897b88a7d6c310c88ed64dd37b1b59bfd7ae9107490bbb362f47d6", size = 2145128, upload-time = "2026-08-28T10:01:20.694Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/d7/ad493864a7fb21c0c4df98f965e2db430cb25a9d7369b5778d5016c09fd9/pydantic_core-2.46.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:2d330aaba8621b1edcec8ae2c4050f63b84ccf6d98723a8f212e9684713abf0e", size = 2294560, upload-time = "2026-08-28T10:01:23.495Z" },
-    { url = "https://files.pythonhosted.org/packages/02/8e/b41c84c913f29973a268e6c2b5bbf13c95adb9956c126d10da11ba3b2bef/pydantic_core-2.46.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b6acfb46a814762367fb7ba0828b0a17d441b92ce249a0e007474c9072662dda", size = 2317531, upload-time = "2026-08-28T10:01:26.334Z" },
-    { url = "https://files.pythonhosted.org/packages/db/1d/068464f23075f66a8f1b806935e9cd9363ee446636ea70d2c22ee8659dbf/pydantic_core-2.46.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:d0a24b40877af2de4950252be9d21eaf7fb07660f3c2cae1f56c6b599ada5266", size = 2140686, upload-time = "2026-08-28T10:01:28.947Z" },
-]
-
 [[package]]
 name = "pygments"
 version = "2.21.0"
@@ -476,19 +242,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
-[[package]]
-name = "starlette"
-version = "1.6.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b5/b4/205b0d5241d934e8add0c38aa924c4f9fb7330834ff11e5444db964ec3f9/starlette-1.6.0.tar.gz", hash = "sha256:d4e3ac5e546444960c710297a3c9fc3f7ebae1b7e963f3d36173b49da535be9b", size = 2716969, upload-time = "2026-08-08T18:27:57.512Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/cb/6a6a47d5b464bd08695d254f3da6e7986cc70c9fa5d778eda57538edfe56/starlette-1.6.0-py3-none-any.whl", hash = "sha256:a86dd39d14bb45f85a3d18525215a9ef0cfd1f192ac793220e72598c90335f0c", size = 75969, upload-time = "2026-08-08T18:27:56.196Z" },
-]
-
 [[package]]
 name = "typing-extensions"
 version = "4.16.0"
@@ -498,31 +251,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
 ]
 
-[[package]]
-name = "typing-inspection"
-version = "0.4.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147", size = 14750, upload-time = "2026-08-12T12:37:24.648Z" },
-]
-
-[[package]]
-name = "uvicorn"
-version = "0.53.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click" },
-    { name = "h11" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5d/ad/04bbb797c84fc1f26cb171f7394716f4865ffb8d8c5e1eef42565c2dfa6b/uvicorn-0.53.0.tar.gz", hash = "sha256:a9356f0cb89b3b8621529c5d5eebd69bfe154f4c3f68b4cf2de47e45fa855c2e", size = 110881, upload-time = "2026-09-14T07:44:23.815Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/18/0eea75741ee812e9f598b687619ce2454f6c3a1c5cd21ea990ec6bd26f45/uvicorn-0.53.0-py3-none-any.whl", hash = "sha256:e8dca71ec86dce5f04e333f0d56cdedf942446e6643b9cea1af0d6d3a02cb03e", size = 87081, upload-time = "2026-09-14T07:44:22.179Z" },
-]
-
 [[package]]
 name = "voluptuous"
 version = "0.16.0"