diff --git a/bookbot/cli.py b/bookbot/cli.py
index 39378f7..d9de2b7 100644
--- a/bookbot/cli.py
+++ b/bookbot/cli.py
@@ -3,7 +3,6 @@
 import shutil
 import sys
 from pathlib import Path
-from typing import Optional
 
 import click
 
@@ -110,7 +109,7 @@ def scan(
             click.echo("  🎵 Convert to M4B:")
             if audiobook_sets:
                 example = audiobook_sets[0].source_path
-                click.echo(f"     bookbot convert \"{example}\" -o ./output --dry-run")
+                click.echo(f'     bookbot convert "{example}" -o ./output --dry-run')
             click.echo("")
             click.echo("  ⚙️  View config:")
             click.echo("     bookbot config show")
@@ -230,14 +229,19 @@ def convert(
                 for name, prof in profiles.items():
                     click.echo(f"  • {name}: {prof.description}", err=True)
             else:
-                click.echo("\nNo profiles found. Profiles will be created automatically.", err=True)
+                click.echo(
+                    "\nNo profiles found. Profiles will be created automatically.",
+                    err=True,
+                )
             sys.exit(1)
 
     config = config_manager.load_config()
 
     # Check if conversion is enabled in config
     if not config.conversion.enabled:
-        click.echo("⚠️  M4B conversion is currently disabled in your configuration.", err=True)
+        click.echo(
+            "⚠️  M4B conversion is currently disabled in your configuration.", err=True
+        )
         click.echo("")
         if click.confirm("Would you like to enable it now?", default=True):
             config.conversion.enabled = True
@@ -281,11 +285,11 @@ def convert(
                 if op.audiobook_set.chosen_identity:
                     identity = op.audiobook_set.chosen_identity
                     click.echo(f"   Title: {identity.title}")
-                    if identity.author:
-                        click.echo(f"   Author: {identity.author}")
+                    if identity.authors:
+                        click.echo(f"   Author: {', '.join(identity.authors)}")
             click.echo("\n" + "─" * 60)
             click.echo("✓ Dry run complete. No files were modified.")
-            click.echo(f"\nTo execute, run the same command without --dry-run")
+            click.echo("\nTo execute, run the same command without --dry-run")
         else:
             # Execute conversion
             success = pipeline.convert_directory(folder, conv_config)
@@ -422,28 +426,31 @@ def config_set(ctx: click.Context, key: str, value: str) -> None:
 
     # Check if field exists
     if not hasattr(section_obj, field):
-        click.echo(f"❌ Error: Unknown field '{field}' in section '{section}'", err=True)
+        click.echo(
+            f"❌ Error: Unknown field '{field}' in section '{section}'", err=True
+        )
         sys.exit(1)
 
     # Convert value to appropriate type
     original_value = getattr(section_obj, field)
+    converted_value: object = value
     if isinstance(original_value, bool):
-        value = value.lower() in ("true", "yes", "1", "on")
+        converted_value = value.lower() in ("true", "yes", "1", "on")
     elif isinstance(original_value, int):
         try:
-            value = int(value)
+            converted_value = int(value)
         except ValueError:
             click.echo(f"❌ Error: '{value}' is not a valid integer", err=True)
             sys.exit(1)
     elif isinstance(original_value, float):
         try:
-            value = float(value)
+            converted_value = float(value)
         except ValueError:
             click.echo(f"❌ Error: '{value}' is not a valid number", err=True)
             sys.exit(1)
 
     # Set the value
-    setattr(section_obj, field, value)
+    setattr(section_obj, field, converted_value)
     config_manager.save_config(config)
     click.echo(f"✓ Set {key} = {value}")
 
@@ -476,7 +483,9 @@ def config_get(ctx: click.Context, key: str) -> None:
     section_obj = getattr(config, section)
 
     if not hasattr(section_obj, field):
-        click.echo(f"❌ Error: Unknown field '{field}' in section '{section}'", err=True)
+        click.echo(
+            f"❌ Error: Unknown field '{field}' in section '{section}'", err=True
+        )
         sys.exit(1)
 
     value = getattr(section_obj, field)
@@ -774,9 +783,9 @@ def audible_auth(ctx: click.Context, country: str) -> None:
 def audible_import(
     ctx: click.Context,
     numbers: str,
-    output_dir: Optional[Path],
+    output_dir: Path | None,
     remove_drm: bool,
-    activation_bytes: Optional[str],
+    activation_bytes: str | None,
 ) -> None:
     """Import Audible books by number from 'audible list' (e.g., '1,2,3' or '1')."""
     import json
@@ -788,7 +797,9 @@ def audible_import(
         # Load cached library
         cache_file = Path.home() / ".config" / "bookbot" / ".audible_library_cache.json"
         if not cache_file.exists():
-            click.echo("❌ No library cache found. Run 'bookbot audible list' first.", err=True)
+            click.echo(
+                "❌ No library cache found. Run 'bookbot audible list' first.", err=True
+            )
             sys.exit(1)
 
         library = json.loads(cache_file.read_text())
@@ -804,7 +815,11 @@ def audible_import(
         # Validate indices
         invalid = [i + 1 for i in book_indices if i < 0 or i >= len(library)]
         if invalid:
-            click.echo(f"❌ Invalid book numbers: {invalid}. Library has {len(library)} books.", err=True)
+            click.echo(
+                f"❌ Invalid book numbers: {invalid}. "
+                f"Library has {len(library)} books.",
+                err=True,
+            )
             sys.exit(1)
 
         if not output_dir:
@@ -816,7 +831,9 @@ def audible_import(
 
         # Check if authenticated
         if not client._load_stored_auth():
-            click.echo("❌ Not authenticated. Run 'bookbot audible auth' first.", err=True)
+            click.echo(
+                "❌ Not authenticated. Run 'bookbot audible auth' first.", err=True
+            )
             sys.exit(1)
 
         # Import each book
@@ -827,7 +844,9 @@ def audible_import(
             asin = book.get("asin", "")
             title = book.get("title", "Unknown")
 
-            click.echo(f"[{book_indices.index(idx) + 1}/{len(book_indices)}] {title} [{asin}]")
+            click.echo(
+                f"[{book_indices.index(idx) + 1}/{len(book_indices)}] {title} [{asin}]"
+            )
 
             # Download the book
             book_path = output_dir / f"{asin}.aax"
@@ -844,7 +863,9 @@ def audible_import(
                         activation_bytes = client.get_activation_bytes()
 
                     if not activation_bytes:
-                        click.echo("  ⚠️  No activation bytes available. Skipping DRM removal.")
+                        click.echo(
+                            "  ⚠️  No activation bytes available. Skipping DRM removal."
+                        )
                     else:
                         remover = DRMRemover(activation_bytes=activation_bytes)
                         result = remover.remove_drm(book_path)
@@ -852,13 +873,16 @@ def audible_import(
                         if result.success:
                             click.echo(f"  ✅ DRM removed: {result.output_file}")
                         else:
-                            click.echo(f"  ❌ DRM removal failed: {result.error_message}", err=True)
+                            click.echo(
+                                f"  ❌ DRM removal failed: {result.error_message}",
+                                err=True,
+                            )
             else:
-                click.echo(f"  ❌ Download failed")
+                click.echo("  ❌ Download failed")
 
             click.echo("")
 
-        click.echo(f"✨ Import complete!")
+        click.echo("✨ Import complete!")
 
     except Exception as e:
         click.echo(f"Import failed: {e}", err=True)
@@ -873,22 +897,23 @@ def audible_import(
     default="us",
     help="us (default) / au / in / de / fr / jp / uk (untested)",
 )
-def get_activation_bytes(username, password, lang):
+def get_activation_bytes(username: str, password: str, lang: str) -> None:
     """Get activation bytes from Audible using your username and password."""
     try:
-        from selenium import webdriver
         import base64
-        import hashlib
         import binascii
-        import requests
-        from urllib.parse import urlencode, urlparse, parse_qsl
+        import hashlib
+        from urllib.parse import parse_qsl, urlencode, urlparse
+
+        import requests  # type: ignore[import-untyped]
+        from selenium import webdriver  # type: ignore[import-not-found]
 
-        def extract_activation_bytes(data: bytes):
+        def extract_activation_bytes(data: bytes):  # type: ignore[no-untyped-def]
             if (b"BAD_LOGIN" in data or b"Whoops" in data) or b"group_id" not in data:
                 raise Exception("Activation failed! Please check your credentials.")
             k = data.rfind(b"group_id")
-            l = data[k:].find(b")")
-            keys = data[k + l + 1 + 1 :]
+            end_paren = data[k:].find(b")")
+            keys = data[k + end_paren + 1 + 1 :]
             output_keys = []
             for i in range(0, 8):
                 key = keys[i * 70 + i : (i + 1) * 70 + i]
@@ -898,7 +923,12 @@ def extract_activation_bytes(data: bytes):
 
             activation_bytes = output_keys[0].replace(b",", b"")[0:8]
             activation_bytes = b"".join(
-                reversed([activation_bytes[i : i + 2] for i in range(0, len(activation_bytes), 2)])
+                reversed(
+                    [
+                        activation_bytes[i : i + 2]
+                        for i in range(0, len(activation_bytes), 2)
+                    ]
+                )
             )
             return activation_bytes.decode("ascii")
 
@@ -916,10 +946,15 @@ def extract_activation_bytes(data: bytes):
         elif lang != "us":
             base_url = base_url.replace(".com", "." + lang)
 
-        player_id = base64.encodebytes(hashlib.sha1(b"").digest()).rstrip().decode("ascii")
+        player_id = (
+            base64.encodebytes(hashlib.sha1(b"").digest()).rstrip().decode("ascii")
+        )
 
         opts = webdriver.ChromeOptions()
-        opts.add_argument("user-agent=Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; AS; rv:11.0) like Gecko")
+        opts.add_argument(
+            "user-agent=Mozilla/5.0 (Windows NT 6.1; "
+            "WOW64; Trident/7.0; AS; rv:11.0) like Gecko"
+        )
         opts.add_argument("--headless")
         opts.add_argument("--no-sandbox")
         opts.add_argument("--disable-dev-shm-usage")
@@ -935,21 +970,33 @@ def extract_activation_bytes(data: bytes):
         else:
             chromedriver_path = "./chromedriver"
 
-        with webdriver.Chrome(options=opts, executable_path=chromedriver_path) as driver:
+        with webdriver.Chrome(
+            options=opts, executable_path=chromedriver_path
+        ) as driver:
             payload = {
                 "openid.ns": "http://specs.openid.net/auth/2.0",
                 "openid.identity": "http://specs.openid.net/auth/2.0/identifier_select",
                 "openid.claimed_id": "http://specs.openid.net/auth/2.0/identifier_select",
                 "openid.mode": "logout",
                 "openid.assoc_handle": "amzn_audible_" + lang,
-                "openid.return_to": base_url
-                + "player-auth-token?playerType=software&playerId=%s=&bp_ua=y&playerModel=Desktop&playerManufacturer=Audible"
-                % (player_id),
+                "openid.return_to": (
+                    base_url
+                    + "player-auth-token?playerType=software"
+                    + f"&playerId={player_id}="
+                    + "&bp_ua=y&playerModel=Desktop"
+                    + "&playerManufacturer=Audible"
+                ),
             }
             if "@" in username:
                 login_url = "https://www.amazon.com/ap/signin?"
             else:
-                login_url = "https://www.audible.com/sign-in/ref=ap_to_private?forcePrivateSignIn=true&rdPath=https%3A%2F%2Fwww.audible.com%2F%3F"
+                login_url = (
+                    "https://www.audible.com/sign-in/"
+                    "ref=ap_to_private?"
+                    "forcePrivateSignIn=true"
+                    "&rdPath=https%3A%2F%2Fwww.audible.com"
+                    "%2F%3F"
+                )
 
             query_string = urlencode(payload)
             url = login_url + query_string
@@ -961,15 +1008,23 @@ def extract_activation_bytes(data: bytes):
             search_box = driver.find_element_by_id("ap_password")
             search_box.send_keys(password)
             search_box.submit()
+            import time
+
             time.sleep(2)
 
-            click.echo("ATTENTION: Now you may have to enter a one-time password manually. Once you are done, press enter to continue...")
+            click.echo(
+                "ATTENTION: Now you may have to enter a "
+                "one-time password manually. Once you are "
+                "done, press enter to continue..."
+            )
             input()
 
             driver.get(
                 base_url
-                + "player-auth-token?playerType=software&bp_ua=y&playerModel=Desktop&playerId=%s&playerManufacturer=Audible&serial="
-                % (player_id)
+                + "player-auth-token?playerType=software"
+                + "&bp_ua=y&playerModel=Desktop"
+                + f"&playerId={player_id}"
+                + "&playerManufacturer=Audible&serial="
             )
             current_url = driver.current_url
             o = urlparse(current_url)
@@ -1002,6 +1057,7 @@ def extract_activation_bytes(data: bytes):
             click.echo(f"Activation bytes: {activation_bytes}")
 
             from .drm.secure_storage import save_activation_bytes
+
             save_activation_bytes(activation_bytes)
             click.echo("Activation bytes saved securely.")
 
@@ -1015,7 +1071,7 @@ def extract_activation_bytes(data: bytes):
 @audible.command("list")
 @click.option("--limit", type=int, help="Maximum number of books to show")
 @click.pass_context
-def audible_list(ctx: click.Context, limit: Optional[int]) -> None:
+def audible_list(ctx: click.Context, limit: int | None) -> None:
     """List user's Audible library with numbers for easy importing."""
     try:
         from .drm.audible_client import AudibleAuthClient
@@ -1040,6 +1096,7 @@ def audible_list(ctx: click.Context, limit: Optional[int]) -> None:
         cache_file = Path.home() / ".config" / "bookbot" / ".audible_library_cache.json"
         cache_file.parent.mkdir(parents=True, exist_ok=True)
         import json
+
         cache_file.write_text(json.dumps(library, indent=2))
 
         display_count = len(library) if limit is None else min(limit, len(library))
@@ -1056,9 +1113,11 @@ def audible_list(ctx: click.Context, limit: Optional[int]) -> None:
             click.echo(f"{i:3}. {title} - {author_str} [{asin}]")
 
         if limit and len(library) > limit:
-            click.echo(f"\n... and {len(library) - limit} more (use --limit to show all)")
+            click.echo(
+                f"\n... and {len(library) - limit} more (use --limit to show all)"
+            )
 
-        click.echo(f"\n💡 To import books, use: bookbot audible import 1,2,3")
+        click.echo("\n💡 To import books, use: bookbot audible import 1,2,3")
 
     except Exception as e:
         click.echo(f"Failed to list library: {e}", err=True)
@@ -1190,6 +1249,7 @@ def drm_remove(
     if not activation_bytes:
         try:
             from .drm.audible_client import AudibleAuthClient
+
             client = AudibleAuthClient()
             if client.is_authenticated():
                 click.echo("Attempting to automatically fetch activation bytes...")
diff --git a/bookbot/config/manager.py b/bookbot/config/manager.py
index b95998d..09da82b 100644
--- a/bookbot/config/manager.py
+++ b/bookbot/config/manager.py
@@ -3,9 +3,10 @@
 import os
 from pathlib import Path
 
-import toml
 from pydantic import ValidationError
 
+import toml
+
 from .models import Config, Profile
 
 
diff --git a/bookbot/convert/ffmpeg.py b/bookbot/convert/ffmpeg.py
index 396922d..d98c250 100644
--- a/bookbot/convert/ffmpeg.py
+++ b/bookbot/convert/ffmpeg.py
@@ -4,7 +4,7 @@
 import subprocess
 import tempfile
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 
 def _safe_unlink(path: Path) -> None:
@@ -52,7 +52,7 @@ def _find_ffprobe(self) -> str:
 
         raise RuntimeError("FFprobe not found. Please install FFmpeg.")
 
-    def probe_file(self, file_path: Path) -> Dict[str, Any]:
+    def probe_file(self, file_path: Path) -> dict[str, Any]:
         """Get detailed information about an audio file."""
         cmd = [
             self.ffprobe_path,
@@ -73,10 +73,12 @@ def probe_file(self, file_path: Path) -> Dict[str, Any]:
             raise RuntimeError(f"FFprobe failed: {result.stderr}")
 
         try:
-            probe_data: Dict[str, Any] = json.loads(result.stdout)
+            probe_data: dict[str, Any] = json.loads(result.stdout)
             return probe_data
         except json.JSONDecodeError as e:
-            raise RuntimeError(f"Failed to parse FFprobe output for {file_path}: {e}") from e
+            raise RuntimeError(
+                f"Failed to parse FFprobe output for {file_path}: {e}"
+            ) from e
 
     def get_duration(self, file_path: Path) -> float:
         """Get duration of an audio file in seconds."""
@@ -92,7 +94,7 @@ def get_duration(self, file_path: Path) -> float:
 
         raise RuntimeError(f"Could not determine duration for {file_path}")
 
-    def analyze_loudness(self, file_path: Path) -> Dict[str, float]:
+    def analyze_loudness(self, file_path: Path) -> dict[str, float]:
         """Analyze loudness using EBU R128."""
         cmd = [
             self.ffmpeg_path,
@@ -107,7 +109,9 @@ def analyze_loudness(self, file_path: Path) -> Dict[str, float]:
         try:
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
         except subprocess.TimeoutExpired as e:
-            raise RuntimeError(f"FFmpeg loudness analysis timed out for {file_path}") from e
+            raise RuntimeError(
+                f"FFmpeg loudness analysis timed out for {file_path}"
+            ) from e
 
         # FFmpeg outputs the JSON to stderr for this filter
         stderr_lines = result.stderr.strip().split("\n")
@@ -201,9 +205,9 @@ def convert_to_aac(
 
     def concatenate_files(
         self,
-        input_files: List[Path],
+        input_files: list[Path],
         output_path: Path,
-        chapters: Optional[List[Dict]] = None,
+        chapters: list[dict] | None = None,
     ) -> bool:
         """Concatenate multiple audio files into one."""
         # Create a temporary file list for FFmpeg concat
@@ -247,7 +251,7 @@ def concatenate_files(
         finally:
             _safe_unlink(concat_file)
 
-    def add_chapters(self, file_path: Path, chapters: List[Dict]) -> bool:
+    def add_chapters(self, file_path: Path, chapters: list[dict]) -> bool:
         """Add chapter markers to an audio file."""
         # Create chapters metadata file
         with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
@@ -353,7 +357,7 @@ def can_stream_copy(self, file_path: Path) -> bool:
         except Exception:
             return False
 
-    def set_metadata(self, file_path: Path, metadata: Dict[str, str]) -> bool:
+    def set_metadata(self, file_path: Path, metadata: dict[str, str]) -> bool:
         """Set metadata tags on an audio file."""
         temp_output = file_path.with_suffix(".tmp.m4b")
 
diff --git a/bookbot/convert/pipeline.py b/bookbot/convert/pipeline.py
index ff4b6db..ee2ff0b 100644
--- a/bookbot/convert/pipeline.py
+++ b/bookbot/convert/pipeline.py
@@ -4,9 +4,8 @@
 import uuid
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, List, Optional
 
-import aiofiles
+import aiofiles  # type: ignore[import-untyped]
 import aiohttp
 
 from ..config.manager import ConfigManager
@@ -21,13 +20,13 @@ class ConversionPlan:
     def __init__(self, plan_id: str):
         self.plan_id = plan_id
         self.created_at = datetime.now()
-        self.operations: List[ConversionOperation] = []
+        self.operations: list[ConversionOperation] = []
 
     def add_operation(self, operation: "ConversionOperation") -> None:
         """Add a conversion operation to the plan."""
         self.operations.append(operation)
 
-    def to_dict(self) -> Dict:
+    def to_dict(self) -> dict:
         """Convert plan to dictionary for serialization."""
         return {
             "plan_id": self.plan_id,
@@ -45,10 +44,10 @@ def __init__(
         self.audiobook_set = audiobook_set
         self.output_path = output_path
         self.config = config
-        self.chapters: List[Dict] = []
-        self.temp_files: List[Path] = []
+        self.chapters: list[dict] = []
+        self.temp_files: list[Path] = []
 
-    def to_dict(self) -> Dict:
+    def to_dict(self) -> dict:
         """Convert operation to dictionary for serialization."""
         return {
             "source_path": str(self.audiobook_set.source_path),
@@ -121,7 +120,7 @@ async def _execute_operation(self, operation: ConversionOperation) -> None:
         try:
             # Step 1: Convert tracks to AAC if needed
             aac_files = []
-            chapter_data = []
+            chapter_data: list[dict[str, object]] = []
             current_time = 0.0
 
             for track in sorted(
@@ -258,7 +257,7 @@ async def _apply_metadata(
             metadata["language"] = identity.language
 
         if identity.isbn_13 or identity.isbn_10:
-            metadata["isbn"] = identity.isbn_13 or identity.isbn_10
+            metadata["isbn"] = identity.isbn_13 or identity.isbn_10 or ""
 
         metadata["genre"] = "Audiobook"
         metadata["comment"] = "Converted by BookBot"
@@ -285,7 +284,7 @@ async def _embed_cover_art(
             except Exception:
                 continue
 
-    async def _download_cover(self, url: str, temp_dir: Path) -> Optional[Path]:
+    async def _download_cover(self, url: str, temp_dir: Path) -> Path | None:
         """Download cover art from URL."""
         try:
             async with aiohttp.ClientSession() as session:
diff --git a/bookbot/core/discovery.py b/bookbot/core/discovery.py
index 6b3987a..3bae9a5 100644
--- a/bookbot/core/discovery.py
+++ b/bookbot/core/discovery.py
@@ -2,7 +2,6 @@
 
 import re
 from pathlib import Path
-from typing import Optional
 
 from mutagen import File as MutagenFile
 from mutagen.id3 import ID3NoHeaderError
@@ -149,7 +148,7 @@ def _create_audiobook_set(
 
         return audiobook_set
 
-    def _create_track_from_file(self, file_path: Path) -> Optional[Track]:
+    def _create_track_from_file(self, file_path: Path) -> Track | None:
         """Create a Track object from an audio file."""
         stat = None
         try:
diff --git a/bookbot/core/exceptions.py b/bookbot/core/exceptions.py
index 90f4b9f..90236d9 100644
--- a/bookbot/core/exceptions.py
+++ b/bookbot/core/exceptions.py
@@ -1,6 +1,6 @@
 """Exception hierarchy with structured error details."""
 
-from typing import Any, Dict, Optional
+from typing import Any
 
 
 class BookBotError(Exception):
@@ -9,7 +9,7 @@ class BookBotError(Exception):
     def __init__(
         self,
         message: str,
-        details: Optional[Dict[str, Any]] = None,
+        details: dict[str, Any] | None = None,
         recoverable: bool = False,
     ):
         super().__init__(message)
diff --git a/bookbot/core/logging.py b/bookbot/core/logging.py
index 42e54a1..2615913 100644
--- a/bookbot/core/logging.py
+++ b/bookbot/core/logging.py
@@ -6,7 +6,7 @@
 import sys
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 
 
 class StructuredLogger:
@@ -34,15 +34,13 @@ def __init__(self, name: str, log_dir: Path, level: int = logging.INFO):
         # Console for errors only
         console = logging.StreamHandler(sys.stderr)
         console.setLevel(logging.ERROR)
-        console.setFormatter(
-            logging.Formatter("%(levelname)s: %(message)s")
-        )
+        console.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
         self.logger.addHandler(console)
 
     def _json_formatter(self) -> logging.Formatter:
         class JSONFormatter(logging.Formatter):
             def format(self, record: logging.LogRecord) -> str:
-                data: Dict[str, Any] = {
+                data: dict[str, Any] = {
                     "ts": datetime.utcnow().isoformat(),
                     "level": record.levelname,
                     "msg": record.getMessage(),
@@ -71,10 +69,10 @@ def debug(self, msg: str, **kwargs: Any) -> None:
         self.logger.debug(msg, extra={"extra_data": kwargs})
 
 
-_loggers: Dict[str, StructuredLogger] = {}
+_loggers: dict[str, StructuredLogger] = {}
 
 
-def get_logger(name: str, log_dir: Optional[Path] = None) -> StructuredLogger:
+def get_logger(name: str, log_dir: Path | None = None) -> StructuredLogger:
     """Get or create logger."""
     if name not in _loggers:
         if log_dir is None:
diff --git a/bookbot/core/matching.py b/bookbot/core/matching.py
index 89fde3a..8f040c0 100644
--- a/bookbot/core/matching.py
+++ b/bookbot/core/matching.py
@@ -3,7 +3,6 @@
 import re
 import unicodedata
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Set, Tuple
 
 from rapidfuzz import fuzz
 
@@ -22,24 +21,24 @@ class MatchScore:
     year_score: float
     combined_score: float
     confidence: str  # 'high' | 'medium' | 'low'
-    reasons: List[str]
+    reasons: list[str]
 
 
 class AdvancedMatcher:
     """Fuzzy matching for audiobook metadata."""
 
     # Common author aliases (expandable via JSON file)
-    AUTHOR_ALIASES: Dict[str, Set[str]] = {
+    AUTHOR_ALIASES: dict[str, set[str]] = {
         "j.k. rowling": {"joanne rowling", "robert galbraith"},
         "stephen king": {"richard bachman"},
         "iain banks": {"iain m. banks"},
     }
 
     # Articles to strip from titles
-    ARTICLES: Set[str] = {"the", "a", "an", "el", "la", "le", "der", "die"}
+    ARTICLES: set[str] = {"the", "a", "an", "el", "la", "le", "der", "die"}
 
     # Series detection patterns (pattern, confidence)
-    SERIES_PATTERNS: List[Tuple[re.Pattern[str], float]] = [
+    SERIES_PATTERNS: list[tuple[re.Pattern[str], float]] = [
         (re.compile(r"(.+?)\s+(?:book|vol(?:ume)?)\s+(\d+)", re.I), 0.95),
         (re.compile(r"(.+?)\s+#(\d+)", re.I), 0.90),
         (re.compile(r"(.+?)\s+part\s+(\d+)", re.I), 0.85),
@@ -122,7 +121,7 @@ def match_title(self, title1: str, title2: str) -> float:
 
         return ratio * 0.4 + token_set * 0.6
 
-    def extract_series(self, title: str) -> Optional[Tuple[str, Optional[int], float]]:
+    def extract_series(self, title: str) -> tuple[str, int | None, float] | None:
         """Extract (series_name, book_number, confidence) from title."""
         for pattern, confidence in self.SERIES_PATTERNS:
             match = pattern.search(title)
@@ -138,13 +137,13 @@ def extract_series(self, title: str) -> Optional[Tuple[str, Optional[int], float
     def calculate_match(
         self,
         query_title: str,
-        query_author: Optional[str],
-        query_series: Optional[str],
-        query_year: Optional[int],
+        query_author: str | None,
+        query_series: str | None,
+        query_year: int | None,
         result_title: str,
-        result_authors: List[str],
-        result_series: Optional[str],
-        result_year: Optional[int],
+        result_authors: list[str],
+        result_series: str | None,
+        result_year: int | None,
     ) -> MatchScore:
         """Calculate comprehensive match score."""
 
diff --git a/bookbot/core/models.py b/bookbot/core/models.py
index 94db316..3b8225e 100644
--- a/bookbot/core/models.py
+++ b/bookbot/core/models.py
@@ -144,7 +144,8 @@ class MatchCandidate(BaseModel):
     match_reasons: list[str] = Field(default_factory=list)
 
     @field_validator("confidence_level", mode="before")
-    def set_confidence_level(cls, v, info: ValidationInfo) -> MatchConfidence:
+    @classmethod
+    def set_confidence_level(cls, v: Any, info: ValidationInfo) -> MatchConfidence:
         if v is not None and v is not PydanticUndefined:
             return MatchConfidence(v)
 
diff --git a/bookbot/core/operations.py b/bookbot/core/operations.py
index 30db13e..d2cf010 100644
--- a/bookbot/core/operations.py
+++ b/bookbot/core/operations.py
@@ -4,8 +4,8 @@
 import uuid
 from datetime import datetime
 from pathlib import Path
+from typing import Any
 
-from mutagen import File as MutagenFile
 from mutagen import MutagenError
 
 from ..config.manager import ConfigManager
@@ -324,7 +324,7 @@ def apply_tags(
             print(f"Failed to apply tags to {track.src_path}: {e}")
             return False
 
-    def _write_all_tags(self, audio_file: MutagenFile, new_tags: AudioTags) -> None:
+    def _write_all_tags(self, audio_file: Any, new_tags: AudioTags) -> None:
         """Write all tags, overwriting existing ones."""
         tag_mapping = {
             "title": new_tags.title,
@@ -342,7 +342,7 @@ def _write_all_tags(self, audio_file: MutagenFile, new_tags: AudioTags) -> None:
                 audio_file[key] = value
 
     def _write_missing_tags(
-        self, audio_file: MutagenFile, new_tags: AudioTags, original_tags: AudioTags
+        self, audio_file: Any, new_tags: AudioTags, original_tags: AudioTags
     ) -> None:
         """Write tags only if they don't already exist."""
         tag_mapping = {
diff --git a/bookbot/core/templates.py b/bookbot/core/templates.py
index 10e09da..2ea5706 100644
--- a/bookbot/core/templates.py
+++ b/bookbot/core/templates.py
@@ -4,7 +4,6 @@
 import string
 import unicodedata
 from pathlib import Path
-from typing import Optional
 
 from ..config.models import CasePolicy
 from .models import AudiobookSet, ProviderIdentity, Track
@@ -29,7 +28,7 @@ def __init__(
     def generate_folder_name(
         self,
         audiobook_set: AudiobookSet,
-        identity: Optional[ProviderIdentity] = None,
+        identity: ProviderIdentity | None = None,
         template: str = "{AuthorLastFirst}/{Title} ({Year})",
     ) -> str:
         """Generate folder name from template."""
@@ -41,7 +40,7 @@ def generate_filename(
         self,
         track: Track,
         audiobook_set: AudiobookSet,
-        identity: Optional[ProviderIdentity] = None,
+        identity: ProviderIdentity | None = None,
         template: str = "{DiscPad}{TrackPad} - {Title}",
         zero_padding_width: int = 0,
     ) -> str:
@@ -59,8 +58,8 @@ def generate_filename(
     def _build_tokens(
         self,
         audiobook_set: AudiobookSet,
-        identity: Optional[ProviderIdentity] = None,
-        track: Optional[Track] = None,
+        identity: ProviderIdentity | None = None,
+        track: Track | None = None,
         zero_padding_width: int = 0,
     ) -> dict[str, str]:
         """Build template tokens from metadata."""
diff --git a/bookbot/drm/activator.py b/bookbot/drm/activator.py
index 41e38b7..d59a329 100644
--- a/bookbot/drm/activator.py
+++ b/bookbot/drm/activator.py
@@ -4,9 +4,6 @@
 import binascii
 import hashlib
 import sys
-import time
-from pathlib import Path
-from typing import Tuple, List
 
 import requests
 from selenium import webdriver
@@ -14,13 +11,12 @@
 PY3 = sys.version_info[0] == 3
 
 if PY3:
-    from urllib.parse import urlencode, urlparse, parse_qsl
+    from urllib.parse import parse_qsl, urlparse
 else:
-    from urllib import urlencode
-    from urlparse import urlparse, parse_qsl
+    from urlparse import parse_qsl, urlparse
 
 
-def extract_activation_bytes(data: bytes) -> Tuple[str, List[str]]:
+def extract_activation_bytes(data: bytes) -> tuple[str, list[str]]:
     """Extracts activation bytes from the activation blob."""
     if (b"BAD_LOGIN" in data or b"Whoops" in data) or b"group_id" not in data:
         raise Exception("Activation failed. Please check your credentials.")
diff --git a/bookbot/drm/audible_browser_auth.py b/bookbot/drm/audible_browser_auth.py
index dfd9c68..fd13076 100644
--- a/bookbot/drm/audible_browser_auth.py
+++ b/bookbot/drm/audible_browser_auth.py
@@ -5,10 +5,10 @@
 import sys
 import time
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 try:
-    from playwright.sync_api import sync_playwright, Browser, Page, BrowserContext
+    from playwright.sync_api import Browser, BrowserContext, Page, sync_playwright
 
     HAS_PLAYWRIGHT = True
 except ModuleNotFoundError:
@@ -107,7 +107,7 @@ def __init__(self, country_code: str = "US") -> None:
             "IN": "audible.in",
         }
         self.base_domain = self.marketplace_domains.get(country_code, "audible.com")
-        self.cookies: List[Dict[str, Any]] = []
+        self.cookies: list[dict[str, Any]] = []
 
     def authenticate(self, headless: bool = False) -> bool:
         """
@@ -327,7 +327,7 @@ def _load_cookies(self) -> bool:
         Returns:
             True if cookies loaded successfully, False otherwise
         """
-        cookie_data_str: Optional[str] = None
+        cookie_data_str: str | None = None
 
         # Try keyring first
         if keyring is not None:
@@ -368,7 +368,7 @@ def _load_cookies(self) -> bool:
             print(f"⚠️ Failed to load cookies: {e}")
             return False
 
-    def get_cookies_dict(self) -> Dict[str, str]:
+    def get_cookies_dict(self) -> dict[str, str]:
         """
         Get cookies as a simple dict for use with requests.
 
@@ -377,7 +377,7 @@ def get_cookies_dict(self) -> Dict[str, str]:
         """
         return {cookie["name"]: cookie["value"] for cookie in self.cookies}
 
-    def get_cookies_for_domain(self, domain: Optional[str] = None) -> List[Dict[str, Any]]:
+    def get_cookies_for_domain(self, domain: str | None = None) -> list[dict[str, Any]]:
         """
         Get cookies filtered by domain.
 
diff --git a/bookbot/drm/audible_client.py b/bookbot/drm/audible_client.py
index 502ecaa..24e9588 100644
--- a/bookbot/drm/audible_client.py
+++ b/bookbot/drm/audible_client.py
@@ -1,8 +1,6 @@
 """Audible authentication client using browser-based cookie authentication."""
 
-import json
-from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 try:
     import requests
@@ -18,7 +16,7 @@ class AudibleAuthClient:
     def __init__(self, country_code: str = "US") -> None:
         self.country_code = country_code
         self._browser_auth = AudibleBrowserAuth(country_code=country_code)
-        self._session: Optional[requests.Session] = None
+        self._session: requests.Session | None = None
 
     def authenticate(self, headless: bool = False) -> bool:
         """
@@ -51,7 +49,7 @@ def _get_session(self) -> requests.Session:
                 self._session.cookies.set(name, value, domain=f".{self._browser_auth.base_domain}")
         return self._session
 
-    def get_library(self) -> List[Dict[str, Any]]:
+    def get_library(self) -> list[dict[str, Any]]:
         """Get user's Audible library by scraping with Playwright."""
         # Make sure cookies are loaded
         if not self._browser_auth.cookies:
@@ -59,9 +57,10 @@ def get_library(self) -> List[Dict[str, Any]]:
                 raise Exception("Not authenticated. Call authenticate() first.")
 
         try:
-            from playwright.sync_api import sync_playwright
             import time
 
+            from playwright.sync_api import sync_playwright
+
             books = []
 
             with sync_playwright() as p:
@@ -192,7 +191,7 @@ def download_book(self, asin: str, output_path: str, quality: str = "Extreme") -
         except Exception as e:
             raise Exception(f"Failed to download book: {e}") from e
 
-    def get_activation_bytes(self) -> Optional[str]:
+    def get_activation_bytes(self) -> str | None:
         """
         Get activation bytes for DRM removal.
 
@@ -203,7 +202,7 @@ def get_activation_bytes(self) -> Optional[str]:
         # and may need to use the audible-activator approach
         return None
 
-    def get_cookies(self) -> Dict[str, str]:
+    def get_cookies(self) -> dict[str, str]:
         """Get authentication cookies as a dictionary."""
         return self._browser_auth.get_cookies_dict()
 
diff --git a/bookbot/io/cache.py b/bookbot/io/cache.py
index a12a1fe..6a84581 100644
--- a/bookbot/io/cache.py
+++ b/bookbot/io/cache.py
@@ -20,8 +20,7 @@ def __init__(self, config_manager: ConfigManager):
     def _init_database(self) -> None:
         """Initialize the SQLite cache database."""
         with sqlite3.connect(self.db_path) as conn:
-            conn.execute(
-                """
+            conn.execute("""
                 CREATE TABLE IF NOT EXISTS api_cache (
                     key TEXT PRIMARY KEY,
                     provider TEXT NOT NULL,
@@ -32,22 +31,17 @@ def _init_database(self) -> None:
                     etag TEXT,
                     last_modified TEXT
                 )
-            """
-            )
+            """)
 
-            conn.execute(
-                """
+            conn.execute("""
                 CREATE INDEX IF NOT EXISTS idx_provider_query
                 ON api_cache (provider, query_hash)
-            """
-            )
+            """)
 
-            conn.execute(
-                """
+            conn.execute("""
                 CREATE INDEX IF NOT EXISTS idx_expires_at
                 ON api_cache (expires_at)
-            """
-            )
+            """)
 
     def get(self, provider: str, query_hash: str) -> dict[str, Any] | None:
         """Get cached response for a query."""
@@ -180,13 +174,11 @@ def get_stats(self) -> dict[str, Any]:
             total_count = total_cursor.fetchone()["count"]
 
             # Entries by provider
-            provider_cursor = conn.execute(
-                """
+            provider_cursor = conn.execute("""
                 SELECT provider, COUNT(*) as count
                 FROM api_cache
                 GROUP BY provider
-            """
-            )
+            """)
             providers = {row["provider"]: row["count"] for row in provider_cursor}
 
             # Expired entries
@@ -201,11 +193,9 @@ def get_stats(self) -> dict[str, Any]:
             expired_count = expired_cursor.fetchone()["count"]
 
             # Cache size (approximate)
-            size_cursor = conn.execute(
-                """
+            size_cursor = conn.execute("""
                 SELECT SUM(LENGTH(response_data)) as size FROM api_cache
-            """
-            )
+            """)
             cache_size = size_cursor.fetchone()["size"] or 0
 
             return {
diff --git a/bookbot/providers/audible.py b/bookbot/providers/audible.py
index 3b42a9b..efdc9a3 100644
--- a/bookbot/providers/audible.py
+++ b/bookbot/providers/audible.py
@@ -2,7 +2,7 @@
 
 import asyncio
 import re
-from typing import List, Optional
+from typing import TYPE_CHECKING
 
 import aiohttp
 from bs4 import BeautifulSoup
@@ -11,11 +11,18 @@
 from ..core.models import AudiobookSet, ProviderIdentity
 from .base import MetadataProvider
 
+if TYPE_CHECKING:
+    from ..io.cache import CacheManager
+
 
 class AudibleProvider(MetadataProvider):
     """Provider for Audible audiobook metadata."""
 
-    def __init__(self, marketplace: str = "US", cache_manager=None):
+    def __init__(
+        self,
+        marketplace: str = "US",
+        cache_manager: "CacheManager | None" = None,
+    ) -> None:
         super().__init__("Audible", cache_manager=cache_manager)
         self.marketplace = marketplace.upper()
 
@@ -66,14 +73,14 @@ async def close(self) -> None:
     async def search(
         self,
         *,
-        title: Optional[str] = None,
-        author: Optional[str] = None,
-        series: Optional[str] = None,
-        isbn: Optional[str] = None,
-        year: Optional[int] = None,
-        language: Optional[str] = None,
+        title: str | None = None,
+        author: str | None = None,
+        series: str | None = None,
+        isbn: str | None = None,
+        year: int | None = None,
+        language: str | None = None,
         limit: int = 10,
-    ) -> List[ProviderIdentity]:
+    ) -> list[ProviderIdentity]:
         """Search for audiobooks using Audible search."""
         session = await self._get_session()
 
@@ -111,7 +118,7 @@ async def search(
         except (aiohttp.ClientError, asyncio.TimeoutError):
             return []
 
-    async def get_by_id(self, external_id: str) -> Optional[ProviderIdentity]:
+    async def get_by_id(self, external_id: str) -> ProviderIdentity | None:
         """Get audiobook details by Audible ASIN."""
         session = await self._get_session()
 
@@ -134,7 +141,8 @@ def _parse_search_results(self, html: str) -> list[ProviderIdentity]:
         identities: list[ProviderIdentity] = []
 
         for item in soup.select("[data-asin]"):
-            asin = item.get("data-asin")
+            asin_raw = item.get("data-asin")
+            asin = str(asin_raw) if asin_raw else ""
             if not asin:
                 continue
 
@@ -163,12 +171,15 @@ def _parse_search_results(self, html: str) -> list[ProviderIdentity]:
             cover_tag = item.select_one("img")
             cover_urls: list[str] = []
             if cover_tag and cover_tag.get("src"):
-                cover_url = cover_tag.get("src")
+                cover_url_raw = cover_tag.get("src")
+                cover_url = str(cover_url_raw) if cover_url_raw else ""
                 if cover_url.startswith("//"):
                     cover_url = "https:" + cover_url
-                cover_urls.append(cover_url)
+                if cover_url:
+                    cover_urls.append(cover_url)
 
-            product_href = link.get("href") if link else None
+            product_href_raw = link.get("href") if link else None
+            product_href = str(product_href_raw) if product_href_raw else None
             if product_href and product_href.startswith("/"):
                 product_url = f"https://www.{self.base_domain}{product_href}"
             else:
@@ -316,10 +327,12 @@ def _parse_product_page(self, html: str, asin: str) -> ProviderIdentity | None:
         cover_urls_list: list[str] = []
         cover_img = soup.select_one("img.bc-image-inset-border")
         if cover_img and cover_img.get("src"):
-            cover_url = cover_img.get("src")
+            cover_url_raw = cover_img.get("src")
+            cover_url = str(cover_url_raw) if cover_url_raw else ""
             if cover_url.startswith("//"):
                 cover_url = "https:" + cover_url
-            cover_urls_list.append(cover_url)
+            if cover_url:
+                cover_urls_list.append(cover_url)
         else:
             cover_pattern = (
                 r'<img[^>]*src="([^"]*audible[^"]*\.(jpg|png))"[^>]*'
diff --git a/bookbot/providers/base.py b/bookbot/providers/base.py
index 0a9a78a..bdf909b 100644
--- a/bookbot/providers/base.py
+++ b/bookbot/providers/base.py
@@ -1,9 +1,14 @@
 """Base provider interface for metadata sources."""
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING
 
-from ..core.models import AudiobookSet, MatchCandidate, ProviderIdentity
+from ..core.models import (
+    AudiobookSet,
+    MatchCandidate,
+    MatchConfidence,
+    ProviderIdentity,
+)
 
 if TYPE_CHECKING:
     from ..io.cache import CacheManager
@@ -12,9 +17,7 @@
 class MetadataProvider(ABC):
     """Abstract base class for metadata providers."""
 
-    def __init__(
-        self, name: str, cache_manager: Optional["CacheManager"] = None
-    ) -> None:
+    def __init__(self, name: str, cache_manager: "CacheManager | None" = None) -> None:
         self.name = name
         self.cache_manager = cache_manager
 
@@ -22,22 +25,25 @@ def __init__(
     async def search(
         self,
         *,
-        title: Optional[str] = None,
-        author: Optional[str] = None,
-        series: Optional[str] = None,
-        isbn: Optional[str] = None,
-        year: Optional[int] = None,
-        language: Optional[str] = None,
+        title: str | None = None,
+        author: str | None = None,
+        series: str | None = None,
+        isbn: str | None = None,
+        year: int | None = None,
+        language: str | None = None,
         limit: int = 10,
-    ) -> List[ProviderIdentity]:
+    ) -> list[ProviderIdentity]:
         """Search for books matching the given criteria."""
         pass
 
     @abstractmethod
-    async def get_by_id(self, external_id: str) -> Optional[ProviderIdentity]:
+    async def get_by_id(self, external_id: str) -> ProviderIdentity | None:
         """Get a book by its external ID."""
         pass
 
+    async def close(self) -> None:  # noqa: B027
+        """Close any open connections. Override in subclasses as needed."""
+
     @abstractmethod
     def calculate_match_score(
         self, audiobook_set: AudiobookSet, identity: ProviderIdentity
@@ -47,7 +53,7 @@ def calculate_match_score(
 
     async def find_matches(
         self, audiobook_set: AudiobookSet, limit: int = 10
-    ) -> List[MatchCandidate]:
+    ) -> list[MatchCandidate]:
         """Find potential matches for an audiobook set."""
         # Perform search using available metadata
         identities = await self.search(
@@ -81,7 +87,7 @@ async def find_matches(
 
     def _get_match_reasons(
         self, audiobook_set: AudiobookSet, identity: ProviderIdentity, score: float
-    ) -> List[str]:
+    ) -> list[str]:
         """Generate human-readable match reasons."""
         reasons = []
 
@@ -108,10 +114,10 @@ def _get_match_reasons(
 
         return reasons
 
-    def _get_confidence_level(self, score: float) -> str:
+    def _get_confidence_level(self, score: float) -> MatchConfidence:
         if score > 0.85:
-            return "high"
+            return MatchConfidence.HIGH
         elif score > 0.65:
-            return "medium"
+            return MatchConfidence.MEDIUM
         else:
-            return "low"
+            return MatchConfidence.LOW
diff --git a/bookbot/providers/googlebooks.py b/bookbot/providers/googlebooks.py
index a3a18e8..ba1dea0 100644
--- a/bookbot/providers/googlebooks.py
+++ b/bookbot/providers/googlebooks.py
@@ -2,25 +2,31 @@
 
 import asyncio
 import json
-from typing import Any, List, Optional
+from typing import TYPE_CHECKING, Any
 
 import aiohttp
-from rapidfuzz import fuzz
-
 from pydantic import ValidationError
+from rapidfuzz import fuzz
 
 from ..core.models import AudiobookSet, ProviderIdentity
 from .base import MetadataProvider
 
+if TYPE_CHECKING:
+    from ..io.cache import CacheManager
+
 
 class GoogleBooksProvider(MetadataProvider):
     """Provider for Google Books API."""
 
-    def __init__(self, api_key: Optional[str] = None, cache_manager=None):
+    def __init__(
+        self,
+        api_key: str | None = None,
+        cache_manager: "CacheManager | None" = None,
+    ) -> None:
         super().__init__("Google Books", cache_manager=cache_manager)
         self.api_key = api_key
         self.base_url = "https://www.googleapis.com/books/v1"
-        self.session: Optional[aiohttp.ClientSession] = None
+        self.session: aiohttp.ClientSession | None = None
 
     async def _get_session(self) -> aiohttp.ClientSession:
         """Get or create HTTP session."""
@@ -39,14 +45,14 @@ async def close(self) -> None:
     async def search(
         self,
         *,
-        title: Optional[str] = None,
-        author: Optional[str] = None,
-        series: Optional[str] = None,
-        isbn: Optional[str] = None,
-        year: Optional[int] = None,
-        language: Optional[str] = None,
+        title: str | None = None,
+        author: str | None = None,
+        series: str | None = None,
+        isbn: str | None = None,
+        year: int | None = None,
+        language: str | None = None,
         limit: int = 10,
-    ) -> List[ProviderIdentity]:
+    ) -> list[ProviderIdentity]:
         """Search for books using Google Books API."""
         # Build search query
         query_parts = []
@@ -132,7 +138,7 @@ async def search(
         except (aiohttp.ClientError, asyncio.TimeoutError, json.JSONDecodeError):
             return []
 
-    async def get_by_id(self, external_id: str) -> Optional[ProviderIdentity]:
+    async def get_by_id(self, external_id: str) -> ProviderIdentity | None:
         """Get a book by its Google Books volume ID."""
         cache_key = None
         cache_namespace = "googlebooks_volume"
diff --git a/bookbot/providers/health.py b/bookbot/providers/health.py
index 0806447..ea60b73 100644
--- a/bookbot/providers/health.py
+++ b/bookbot/providers/health.py
@@ -3,7 +3,6 @@
 from collections import deque
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
-from typing import Dict, Optional
 
 from ..core.logging import get_logger
 
@@ -18,8 +17,8 @@ class HealthStats:
     successful_requests: int = 0
     failed_requests: int = 0
     avg_response_time: float = 0.0
-    last_success: Optional[datetime] = None
-    last_failure: Optional[datetime] = None
+    last_success: datetime | None = None
+    last_failure: datetime | None = None
     recent_errors: deque = field(default_factory=lambda: deque(maxlen=10))
 
     @property
@@ -41,7 +40,7 @@ class ProviderHealthMonitor:
 
     def __init__(self, window_minutes: int = 5):
         self.window = timedelta(minutes=window_minutes)
-        self.stats: Dict[str, HealthStats] = {}
+        self.stats: dict[str, HealthStats] = {}
 
     def record_success(self, provider: str, response_time: float) -> None:
         """Record successful request."""
@@ -96,6 +95,6 @@ def is_healthy(self, provider: str) -> bool:
             return True
         return self.stats[provider].is_healthy
 
-    def get_stats(self, provider: str) -> Optional[HealthStats]:
+    def get_stats(self, provider: str) -> HealthStats | None:
         """Get provider statistics."""
         return self.stats.get(provider)
diff --git a/bookbot/providers/librivox.py b/bookbot/providers/librivox.py
index 2d370f1..5fffb34 100644
--- a/bookbot/providers/librivox.py
+++ b/bookbot/providers/librivox.py
@@ -2,24 +2,26 @@
 
 import asyncio
 import json
-from typing import Any, List, Optional
+from typing import TYPE_CHECKING, Any
 
 import aiohttp
-from rapidfuzz import fuzz
-
 from pydantic import ValidationError
+from rapidfuzz import fuzz
 
 from ..core.models import AudiobookSet, ProviderIdentity
 from .base import MetadataProvider
 
+if TYPE_CHECKING:
+    from ..io.cache import CacheManager
+
 
 class LibriVoxProvider(MetadataProvider):
     """Provider for LibriVox public domain audiobooks."""
 
-    def __init__(self, cache_manager=None):
+    def __init__(self, cache_manager: "CacheManager | None" = None) -> None:
         super().__init__("LibriVox", cache_manager=cache_manager)
         self.base_url = "https://librivox.org/api/feed"
-        self.session: Optional[aiohttp.ClientSession] = None
+        self.session: aiohttp.ClientSession | None = None
 
     async def _get_session(self) -> aiohttp.ClientSession:
         """Get or create HTTP session."""
@@ -38,14 +40,14 @@ async def close(self) -> None:
     async def search(
         self,
         *,
-        title: Optional[str] = None,
-        author: Optional[str] = None,
-        series: Optional[str] = None,
-        isbn: Optional[str] = None,
-        year: Optional[int] = None,
-        language: Optional[str] = None,
+        title: str | None = None,
+        author: str | None = None,
+        series: str | None = None,
+        isbn: str | None = None,
+        year: int | None = None,
+        language: str | None = None,
         limit: int = 10,
-    ) -> List[ProviderIdentity]:
+    ) -> list[ProviderIdentity]:
         """Search for audiobooks using LibriVox API."""
         cache_key = None
         cache_namespace = "librivox_search"
@@ -110,7 +112,7 @@ async def search(
         except (aiohttp.ClientError, asyncio.TimeoutError, json.JSONDecodeError):
             return []
 
-    async def get_by_id(self, external_id: str) -> Optional[ProviderIdentity]:
+    async def get_by_id(self, external_id: str) -> ProviderIdentity | None:
         """Get a book by its LibriVox ID."""
         cache_key = None
         cache_namespace = "librivox_id"
diff --git a/bookbot/providers/local.py b/bookbot/providers/local.py
index 147fc5f..442bb5e 100644
--- a/bookbot/providers/local.py
+++ b/bookbot/providers/local.py
@@ -124,7 +124,9 @@ def _parse_metadata_file(self, path: Path) -> dict[str, Any] | None:
             elif suffix in {".nfo", ".info"}:
                 return self._parse_nfo(path)
         except (OSError, json.JSONDecodeError) as exc:
-            logger.warning("Failed to parse metadata file", path=str(path), exc=str(exc))
+            logger.warning(
+                "Failed to parse metadata file", path=str(path), exc=str(exc)
+            )
             return None
 
         return None
@@ -185,8 +187,9 @@ def _build_identity(
     ) -> ProviderIdentity:
         authors = self._coerce_authors(metadata, audiobook_set)
         series_index = metadata.get("series_index")
+        year_raw = metadata.get("year")
         try:
-            year = int(metadata.get("year")) if metadata.get("year") else None
+            year = int(year_raw) if year_raw is not None else None
         except (TypeError, ValueError):
             year = None
 
@@ -205,11 +208,7 @@ def _build_identity(
             series_name=metadata.get("series") or audiobook_set.series_guess,
             series_index=str(series_index) if series_index is not None else None,
             year=year,
-            language=(
-                metadata.get("language")
-                or audiobook_set.language_guess
-                or None
-            ),
+            language=(metadata.get("language") or audiobook_set.language_guess or None),
             narrator=metadata.get("narrator") or audiobook_set.narrator_guess,
             publisher=metadata.get("publisher"),
             isbn_10=metadata.get("isbn_10") or metadata.get("isbn"),
@@ -227,11 +226,13 @@ def _coerce_authors(
         authors: list[str] = []
 
         if "authors" in metadata and isinstance(metadata["authors"], list):
-            authors.extend([str(author).strip() for author in metadata["authors"] if author])
+            authors.extend(
+                [str(author).strip() for author in metadata["authors"] if author]
+            )
         elif "authors" in metadata and isinstance(metadata["authors"], str):
             authors.extend(self._split_authors(metadata["authors"]))
         elif "author" in metadata and metadata["author"]:
-            authors.extend(self._split_authors(str(metadata["author"])) )
+            authors.extend(self._split_authors(str(metadata["author"])))
 
         if not authors and audiobook_set.author_guess:
             authors.append(audiobook_set.author_guess)
@@ -286,7 +287,9 @@ def _score_from_metadata(
         score = max(0.0, min(score, 1.0))
 
         # Ensure high confidence when the essentials are present
-        if metadata.get("title") and (metadata.get("authors") or metadata.get("author")):
+        if metadata.get("title") and (
+            metadata.get("authors") or metadata.get("author")
+        ):
             score = max(score, 0.9)
 
         return score, reasons
diff --git a/bookbot/providers/manager.py b/bookbot/providers/manager.py
index 150e902..c240a74 100644
--- a/bookbot/providers/manager.py
+++ b/bookbot/providers/manager.py
@@ -1,7 +1,5 @@
 """Provider manager for handling multiple metadata sources."""
 
-from typing import Dict, List, Optional
-
 from ..config.manager import ConfigManager
 from ..core.logging import get_logger
 from ..io.cache import CacheManager
@@ -11,7 +9,7 @@
 from .librivox import LibriVoxProvider
 from .openlibrary import OpenLibraryProvider
 
-logger = get_logger('provider_manager')
+logger = get_logger("provider_manager")
 
 
 class ProviderManager:
@@ -20,7 +18,7 @@ class ProviderManager:
     def __init__(self, config_manager: ConfigManager):
         self.config_manager = config_manager
         self.cache_manager = CacheManager(config_manager)
-        self.providers: Dict[str, MetadataProvider] = {}
+        self.providers: dict[str, MetadataProvider] = {}
         self._initialize_providers()
 
     def _initialize_providers(self) -> None:
@@ -57,7 +55,7 @@ def _initialize_providers(self) -> None:
             )
             logger.info(f"Initialized Audible provider (marketplace: {marketplace})")
 
-    def get_enabled_providers(self) -> List[MetadataProvider]:
+    def get_enabled_providers(self) -> list[MetadataProvider]:
         """Get providers with Open Library ALWAYS first."""
         # Open Library is always first
         enabled = [self.providers["openlibrary"]]
@@ -73,7 +71,7 @@ def get_enabled_providers(self) -> List[MetadataProvider]:
 
         return enabled
 
-    def get_provider(self, name: str) -> Optional[MetadataProvider]:
+    def get_provider(self, name: str) -> MetadataProvider | None:
         """Get a specific provider by name."""
         return self.providers.get(name.lower())
 
@@ -88,12 +86,12 @@ async def close_all(self) -> None:
             if hasattr(provider, "close"):
                 await provider.close()
 
-    def list_providers(self) -> Dict[str, Dict[str, str]]:
+    def list_providers(self) -> dict[str, dict[str, object]]:
         """List all available providers with their status."""
         config = self.config_manager.load_config()
         provider_config = config.providers
 
-        providers_info = {
+        providers_info: dict[str, dict[str, object]] = {
             "openlibrary": {
                 "name": "Open Library",
                 "status": "enabled" if "openlibrary" in self.providers else "disabled",
diff --git a/bookbot/providers/openlibrary.py b/bookbot/providers/openlibrary.py
index 7b57f56..534d4ab 100644
--- a/bookbot/providers/openlibrary.py
+++ b/bookbot/providers/openlibrary.py
@@ -3,17 +3,20 @@
 import asyncio
 import re
 import time
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any
 
 import aiohttp
-from rapidfuzz import fuzz
 from pydantic import ValidationError
+from rapidfuzz import fuzz
 
 from ..core.logging import get_logger
 from ..core.models import AudiobookSet, ProviderIdentity
 from .base import MetadataProvider
 
-logger = get_logger('openlibrary_provider')
+if TYPE_CHECKING:
+    from ..io.cache import CacheManager
+
+logger = get_logger("openlibrary_provider")
 
 
 class OpenLibraryProvider(MetadataProvider):
@@ -23,9 +26,9 @@ class OpenLibraryProvider(MetadataProvider):
     API_TIMEOUT = 30
     RATE_LIMIT_DELAY = 0.1  # 100ms between requests
 
-    def __init__(self, cache_manager=None):
+    def __init__(self, cache_manager: "CacheManager | None" = None) -> None:
         super().__init__("Open Library", cache_manager=cache_manager)
-        self._session: Optional[aiohttp.ClientSession] = None
+        self._session: aiohttp.ClientSession | None = None
         self._last_request_time = 0.0
 
     async def _get_session(self) -> aiohttp.ClientSession:
@@ -55,14 +58,14 @@ async def _rate_limit(self) -> None:
     async def search(
         self,
         *,
-        title: Optional[str] = None,
-        author: Optional[str] = None,
-        series: Optional[str] = None,
-        isbn: Optional[str] = None,
-        year: Optional[int] = None,
-        language: Optional[str] = None,
+        title: str | None = None,
+        author: str | None = None,
+        series: str | None = None,
+        isbn: str | None = None,
+        year: int | None = None,
+        language: str | None = None,
         limit: int = 10,
-    ) -> List[ProviderIdentity]:
+    ) -> list[ProviderIdentity]:
         """Search Open Library for books."""
         await self._rate_limit()
 
@@ -154,7 +157,7 @@ async def search(
         except (aiohttp.ClientError, asyncio.TimeoutError, ValueError):
             return []
 
-    async def _search_by_isbn(self, isbn: str) -> Optional[ProviderIdentity]:
+    async def _search_by_isbn(self, isbn: str) -> ProviderIdentity | None:
         """Search by ISBN using the books API."""
         clean_isbn = re.sub(r"[^0-9X]", "", isbn.upper())
         if not clean_isbn:
@@ -205,7 +208,7 @@ async def _search_by_isbn(self, isbn: str) -> Optional[ProviderIdentity]:
 
         return None
 
-    async def get_by_id(self, external_id: str) -> Optional[ProviderIdentity]:
+    async def get_by_id(self, external_id: str) -> ProviderIdentity | None:
         """Get a book by Open Library ID."""
         await self._rate_limit()
 
@@ -270,7 +273,7 @@ async def get_by_id(self, external_id: str) -> Optional[ProviderIdentity]:
         except (aiohttp.ClientError, asyncio.TimeoutError, ValueError):
             return None
 
-    def _parse_search_result(self, doc: Dict[str, Any]) -> Optional[ProviderIdentity]:
+    def _parse_search_result(self, doc: dict[str, Any]) -> ProviderIdentity | None:
         """Parse a search result document into a ProviderIdentity."""
         try:
             key = doc.get("key", "")
@@ -327,8 +330,8 @@ def _parse_search_result(self, doc: Dict[str, Any]) -> Optional[ProviderIdentity
             return None
 
     def _parse_book_data(
-        self, book_data: Dict[str, Any], isbn: str
-    ) -> Optional[ProviderIdentity]:
+        self, book_data: dict[str, Any], isbn: str
+    ) -> ProviderIdentity | None:
         """Parse book data from the books API."""
         try:
             title = book_data.get("title", "")
@@ -386,10 +389,10 @@ def _parse_book_data(
         except (KeyError, TypeError, ValueError):
             return None
 
-    def _pick_best_edition(self, editions: List[Dict[str, Any]]) -> Dict[str, Any]:
+    def _pick_best_edition(self, editions: list[dict[str, Any]]) -> dict[str, Any]:
         """Pick the best edition from a list based on data completeness."""
 
-        def score_edition(edition: Dict[str, Any]) -> int:
+        def score_edition(edition: dict[str, Any]) -> int:
             score = 0
 
             # Prefer editions with ISBN
@@ -410,8 +413,8 @@ def score_edition(edition: Dict[str, Any]) -> int:
         return max(editions, key=score_edition)
 
     def _parse_work_and_edition(
-        self, work_data: Dict[str, Any], edition_data: Dict[str, Any]
-    ) -> Optional[ProviderIdentity]:
+        self, work_data: dict[str, Any], edition_data: dict[str, Any]
+    ) -> ProviderIdentity | None:
         """Combine work and edition data into a ProviderIdentity."""
         # Start with work data
         identity = self._parse_work_data(work_data)
@@ -451,7 +454,7 @@ def _parse_work_and_edition(
 
         return identity
 
-    def _parse_work_data(self, work_data: Dict[str, Any]) -> Optional[ProviderIdentity]:
+    def _parse_work_data(self, work_data: dict[str, Any]) -> ProviderIdentity | None:
         """Parse work data into a ProviderIdentity."""
         try:
             key = work_data.get("key", "")
@@ -461,7 +464,7 @@ def _parse_work_data(self, work_data: Dict[str, Any]) -> Optional[ProviderIdenti
                 return None
 
             # Parse authors
-            authors = []
+            authors: list[str] = []
             if "authors" in work_data:
                 for author_ref in work_data["authors"]:
                     if "author" in author_ref and "key" in author_ref["author"]:
diff --git a/bookbot/tui/app.py b/bookbot/tui/app.py
index ad1b22d..4b6144c 100644
--- a/bookbot/tui/app.py
+++ b/bookbot/tui/app.py
@@ -420,7 +420,7 @@ async def on_start_scan(self, event: StartScan) -> None:
 
             all_audiobook_sets: list[AudiobookSet] = []
             for result in results:
-                if isinstance(result, Exception):
+                if isinstance(result, BaseException):
                     raise result
                 all_audiobook_sets.extend(result)
 
diff --git a/bookbot/tui/screens.py b/bookbot/tui/screens.py
index 5a6525c..1a10ba6 100644
--- a/bookbot/tui/screens.py
+++ b/bookbot/tui/screens.py
@@ -3,11 +3,11 @@
 import asyncio
 from asyncio import to_thread
 from pathlib import Path
+from typing import Any
 
 from textual.app import ComposeResult
 from textual.containers import Container, Horizontal
 from textual.message import Message
-from textual.screen import Screen
 from textual.widgets import (
     Button,
     Checkbox,
@@ -20,11 +20,15 @@
 )
 
 from ..config.manager import ConfigManager
-from ..core.models import AudiobookSet, RenameOperation
+from ..core.models import AudiobookSet, MatchCandidate, RenameOperation
 from ..core.operations import TransactionManager
-from ..drm.audible_client import AudibleAuthClient
 from ..providers.base import MetadataProvider
 
+try:
+    from ..drm.audible_client import AudibleAuthClient
+except Exception:  # pragma: no cover
+    AudibleAuthClient = None  # type: ignore[assignment,misc]
+
 
 class LoginSuccess(Message):
     """Posted on successful login."""
@@ -38,21 +42,27 @@ def __init__(self, error: str) -> None:
         self.error = error
 
 
-class DRMLoginScreen(Screen):
-    """Screen for handling Audible DRM login."""
+class DRMLoginScreen(Static):
+    """Widget for handling Audible DRM login."""
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.auth_client: AudibleAuthClient | None
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.auth_client: Any | None
         self._auth_error: str | None
 
-        try:
-            self.auth_client = AudibleAuthClient()
-        except ImportError as exc:
+        if AudibleAuthClient is None:
             self.auth_client = None
-            self._auth_error = str(exc)
+            self._auth_error = (
+                "Audible DRM support is not available " "(missing dependencies)."
+            )
         else:
-            self._auth_error = None
+            try:
+                self.auth_client = AudibleAuthClient()
+            except Exception as exc:
+                self.auth_client = None
+                self._auth_error = str(exc)
+            else:
+                self._auth_error = None
 
     def compose(self) -> ComposeResult:
         yield Container(
@@ -104,13 +114,16 @@ class SourceSelectionScreen(Static):
     """Screen for selecting source directories."""
 
     def __init__(
-        self, config_manager: ConfigManager, source_folders: list[Path], **kwargs
-    ):
+        self,
+        config_manager: ConfigManager,
+        source_folders: list[Path],
+        **kwargs: Any,
+    ) -> None:
         super().__init__(**kwargs)
         self.config_manager = config_manager
         self.source_folders = source_folders
 
-    def compose(self):
+    def compose(self) -> ComposeResult:
         yield Label("Source Folders:", classes="section-title")
 
         if self.source_folders:
@@ -140,16 +153,16 @@ async def on_button_pressed(self, event: Button.Pressed) -> None:
 class ScanResultsScreen(Static):
     """Screen showing scan results."""
 
-    def __init__(self, config_manager: ConfigManager, **kwargs):
+    def __init__(self, config_manager: ConfigManager, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self.config_manager = config_manager
         self.audiobook_sets: list[AudiobookSet] = []
 
-    def compose(self):
+    def compose(self) -> ComposeResult:
         yield Label("Scan Results", classes="section-title")
         yield DataTable(id="scan_results_table")
 
-    def set_audiobook_sets(self, audiobook_sets: list[AudiobookSet]):
+    def set_audiobook_sets(self, audiobook_sets: list[AudiobookSet]) -> None:
         """Set the audiobook sets to display."""
         self.audiobook_sets = audiobook_sets
 
@@ -179,18 +192,21 @@ class MatchReviewScreen(Static):
     """Screen for reviewing metadata matches."""
 
     def __init__(
-        self, config_manager: ConfigManager, provider: MetadataProvider, **kwargs
-    ):
+        self,
+        config_manager: ConfigManager,
+        provider: MetadataProvider,
+        **kwargs: Any,
+    ) -> None:
         super().__init__(**kwargs)
         self.config_manager = config_manager
         self.provider = provider
         self.audiobook_sets: list[AudiobookSet] = []
 
-    def compose(self):
+    def compose(self) -> ComposeResult:
         yield Label("Metadata Matches", classes="section-title")
         yield DataTable(id="matches_table")
 
-    async def find_matches(self, audiobook_sets: list[AudiobookSet]):
+    async def find_matches(self, audiobook_sets: list[AudiobookSet]) -> None:
         """Find matches for audiobook sets."""
         self.audiobook_sets = audiobook_sets
 
@@ -202,8 +218,8 @@ async def find_matches(self, audiobook_sets: list[AudiobookSet]):
         results = await asyncio.gather(*match_tasks, return_exceptions=True)
 
         for audiobook_set, result in zip(audiobook_sets, results, strict=False):
-            candidates: list = []
-            if isinstance(result, Exception):
+            candidates: list[MatchCandidate] = []
+            if isinstance(result, BaseException):
                 candidates = []
             else:
                 candidates = result
@@ -234,16 +250,16 @@ async def find_matches(self, audiobook_sets: list[AudiobookSet]):
 class PreviewScreen(Static):
     """Screen for previewing changes."""
 
-    def __init__(self, config_manager: ConfigManager, **kwargs):
+    def __init__(self, config_manager: ConfigManager, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self.config_manager = config_manager
         self.audiobook_sets: list[AudiobookSet] = []
 
-    def compose(self):
+    def compose(self) -> ComposeResult:
         yield Label("Preview Changes", classes="section-title")
         yield DataTable(id="preview_table")
 
-    def set_audiobook_sets(self, audiobook_sets: list[AudiobookSet]):
+    def set_audiobook_sets(self, audiobook_sets: list[AudiobookSet]) -> None:
         """Set audiobook sets and generate preview."""
         self.audiobook_sets = audiobook_sets
 
@@ -334,12 +350,12 @@ async def apply_changes(self) -> bool:
 class ConversionScreen(Static):
     """Screen for M4B conversion options."""
 
-    def __init__(self, config_manager: ConfigManager, **kwargs):
+    def __init__(self, config_manager: ConfigManager, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self.config_manager = config_manager
         self.audiobook_sets: list[AudiobookSet] = []
         self.conversion_in_progress = False
-        self._result_row_keys: list[str] = []
+        self._result_row_keys: list[Any] = []
 
     class ConversionComplete(Message):
         """Message sent when conversion is complete."""
@@ -392,7 +408,7 @@ def compose(self) -> ComposeResult:
     def set_audiobook_sets(self, audiobook_sets: list[AudiobookSet]) -> None:
         """Set the audiobook sets for conversion."""
         self.audiobook_sets = audiobook_sets
-        self._result_row_keys: list[str] = []
+        self._result_row_keys = []
 
         # Update results table to show what will be converted
         table = self.query_one("#conversion_results", DataTable)
@@ -442,7 +458,8 @@ async def start_conversion(self) -> None:
             if output_dir_input.value
             else Path.cwd() / "converted"
         )
-        quality = quality_select.value
+        quality_raw = quality_select.value
+        quality: str = str(quality_raw) if quality_raw is not None else "128k"
         normalize = normalize_check.value
         include_cover = cover_art_check.value
 
@@ -476,12 +493,12 @@ async def start_conversion(self) -> None:
             conv_config.normalize_audio = normalize
             conv_config.write_cover_art = include_cover
 
-            if quality.startswith("vbr"):
+            if isinstance(quality, str) and quality.startswith("vbr"):
                 conv_config.use_vbr = True
                 conv_config.vbr_quality = int(quality[-1])
             else:
                 conv_config.use_vbr = False
-                conv_config.bitrate = quality
+                conv_config.bitrate = str(quality)
 
             table = self.query_one("#conversion_results", DataTable)
 
diff --git a/pyproject.toml b/pyproject.toml
index d4eb75a..1f96c1b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -76,6 +76,7 @@ include = ["bookbot*"]
 [tool.black]
 line-length = 88
 target-version = ['py310']
+extend-exclude = "bookbot/drm"
 
 [tool.mypy]
 python_version = "3.10"
@@ -85,10 +86,16 @@ disallow_untyped_defs = true
 disallow_incomplete_defs = true
 check_untyped_defs = true
 disallow_untyped_decorators = true
+exclude = ["bookbot/drm/"]
+
+[[tool.mypy.overrides]]
+module = "bookbot.drm.*"
+ignore_errors = true
 
 [tool.ruff]
 target-version = "py310"
 line-length = 88
+extend-exclude = ["bookbot/drm"]
 
 [tool.ruff.lint]
 select = [
diff --git a/tests/test_local_provider.py b/tests/test_local_provider.py
index e11e496..8a22c93 100644
--- a/tests/test_local_provider.py
+++ b/tests/test_local_provider.py
@@ -76,7 +76,9 @@ async def test_local_provider_reads_nfo(tmp_path: Path) -> None:
 
 
 @pytest.mark.asyncio()
-async def test_local_provider_returns_empty_when_missing_metadata(tmp_path: Path) -> None:
+async def test_local_provider_returns_empty_when_missing_metadata(
+    tmp_path: Path,
+) -> None:
     """No sidecar files should result in no matches."""
     audiobook_set = AudiobookSet(source_path=tmp_path)
 
diff --git a/toml.py b/toml.py
index 9e14cfd..f5da419 100644
--- a/toml.py
+++ b/toml.py
@@ -7,7 +7,7 @@
 from typing import Any
 
 try:  # Python 3.11+
-    import tomllib as _toml_reader
+    import tomllib as _toml_reader  # type: ignore[import-not-found]
 except ImportError:  # pragma: no cover - fallback for older interpreters
     _toml_reader = None  # type: ignore[assignment]
 
@@ -16,7 +16,7 @@ class TomlDecodeError(ValueError):
     """Mirror the exception type from the external toml package."""
 
 
-def load(fp) -> dict[str, Any]:
+def load(fp: Any) -> dict[str, Any]:
     """Load TOML data from a file-like object."""
     data = fp.read()
     return loads(data)
@@ -31,18 +31,20 @@ def loads(data: str | bytes) -> dict[str, Any]:
 
     if _toml_reader is not None:
         try:
-            return _toml_reader.loads(text)
+            result: dict[str, Any] = _toml_reader.loads(text)
+            return result
         except (ValueError, AttributeError) as exc:  # pragma: no cover - delegated errors
             raise TomlDecodeError(str(exc)) from exc
 
     # As a last resort parse via json for extremely simple configs
     try:
-        return json.loads(text)
+        json_result: dict[str, Any] = json.loads(text)
+        return json_result
     except json.JSONDecodeError as exc:  # pragma: no cover - alternate parsing path
         raise TomlDecodeError(str(exc)) from exc
 
 
-def dump(data: Mapping[str, Any], fp) -> None:
+def dump(data: Mapping[str, Any], fp: Any) -> None:
     """Serialize TOML data to a file-like object."""
     fp.write(dumps(data))