diff --git a/.env.example b/.env.example
index 6fc6d35..6da54c9 100644
--- a/.env.example
+++ b/.env.example
@@ -190,6 +190,27 @@ LTI_PUBLIC_KEY_PATH=/app/keys/lti_public.pem
 # Canvas API URL (for file downloads, optional)
 CANVAS_API_URL=
 
+# Canvas API token used by the watcher and bridge workers
+# Create via Admin → Settings → New Access Token, scope to the institution's
+# accessibility service account. Stored as a SecretStr by the config layer.
+CANVAS_API_TOKEN=
+
+# Comma-separated list of Canvas course IDs the watcher should poll.
+# Leave empty to idle (useful while testing LTI plumbing). Replace with
+# Canvas Live Events in Phase 5.
+CANVAS_WATCHED_COURSES=
+
+# Canvas Live Events / DOM-overlay allow-list (used by the panorama.js
+# script to know which Canvas origins may call our score endpoints).
+CANVAS_ALLOWED_ORIGINS=https://canvas.instructure.com
+
+# Polling intervals (seconds) for the two Canvas-side workers
+CANVAS_POLL_SECONDS=60
+REFLOW_POLL_SECONDS=30
+
+# Public URL of this tool (used when composing review-link emails)
+LTI_PUBLIC_URL=
+
 # LTI state TTL in seconds (default: 600 = 10 minutes)
 LTI_STATE_TTL_SECONDS=600
 
diff --git a/CLAUDE.md b/CLAUDE.md
deleted file mode 120000
index 47dc3e3..0000000
--- a/CLAUDE.md
+++ /dev/null
@@ -1 +0,0 @@
-AGENTS.md
\ No newline at end of file
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..47dc3e3
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
index fce29b5..e2791cc 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -39,6 +39,15 @@ FROM base AS dependencies
 # conversion are handled by the docling-serve sidecar container.
 RUN apt-get update && apt-get install -y --no-install-recommends \
     poppler-utils \
+    tesseract-ocr \
+    tesseract-ocr-eng \
+    ghostscript \
+    qpdf \
+    pngquant \
+    unpaper \
+    liblouis-data \
+    liblouis20 \
+    liblouis-bin \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy dependency files
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
index b01e80a..9970d86 100644
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -82,6 +82,8 @@ services:
     volumes:
       # Mount source code for hot-reload (read-only to prevent accidental writes)
       - ./src:/app/src:ro
+      # Ops CLIs (list_platforms, test_service_token) run via `python -m scripts.<name>`
+      - ./scripts:/app/scripts:ro
       # Mount agent prompt configurations
       - ./config:/app/config:ro
       # Mount tests for containerized test runs
@@ -108,8 +110,14 @@ services:
       - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-test}
       - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-test}
       - AWS_SESSION_TOKEN=${AWS_SESSION_TOKEN:-}
-      # Clear AWS_PROFILE to prevent boto3 from looking for profile config in container
-      - AWS_PROFILE=
+      # AWS_PROFILE intentionally unset (do not even define it). boto3 treats
+      # an empty string as "use the profile named 'default'", which then
+      # makes it look for ~/.aws/credentials inside the container - which
+      # doesn't exist, raising ProfileNotFound. With AWS_PROFILE absent,
+      # boto3 picks up AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY from the
+      # env above and the credential chain succeeds. Restore by uncommenting
+      # if you ever mount a credentials file into the container.
+      # - AWS_PROFILE=
       - AWS_DEFAULT_REGION=us-east-1
       # Disable AWS Instance Metadata Service (IMDS) to prevent boto3 hang in Docker
       - AWS_EC2_METADATA_DISABLED=true
@@ -117,6 +125,13 @@ services:
       - S3_TEMP_BUCKET=equalify-pdf-temp
       - S3_RESULTS_BUCKET=equalify-pdf-results
       - S3_PUBLIC_URL=http://localhost:4566
+      # Internal hostname for server-side fetches of presigned URLs.
+      # Floci returns URLs with the public host (localhost:4566) but the
+      # api-gateway container can't reach itself there; ``floci:4566`` is
+      # the Docker-network address. The reflow_client rewrites the host
+      # portion of any presigned URL before fetching. Leave unset in prod
+      # — real AWS S3 needs no rewrite.
+      - S3_INTERNAL_URL=http://floci:4566
       # Redis: use explicit container name to avoid DNS collision with Canvas Redis
       # when api-gateway is on both equalify-network and canvas-lms_default network
       - REDIS_URL=redis://equalify-reflow-redis:6379
diff --git a/docs/explanation/canvas-lti-integration.md b/docs/explanation/canvas-lti-integration.md
new file mode 100644
index 0000000..4ebe4fc
--- /dev/null
+++ b/docs/explanation/canvas-lti-integration.md
@@ -0,0 +1,312 @@
+# Canvas LTI Integration — Architecture and Plan
+
+## Goal
+
+Eliminate the manual step between "professor uploads a PDF to Canvas" and "students have an accessible, reflowable version to read." The professor's workflow should not change. Inaccessible PDFs should automatically become draft Canvas Pages that the professor reviews and publishes.
+
+## What faculty actually do today
+
+A typical course materials workflow in Canvas:
+
+1. Professor drags a lecture PDF into **Course Files** or a **Module**.
+2. PDF is published, students click the link, and anyone using a screen reader, a phone, or simply zooming in struggles.
+3. Accessibility office may flag it weeks later; remediation is reactive.
+
+Anything that asks the professor to "open another tool to remediate this" loses. Faculty-first design means: no install, no extra app, no extra click during upload. The professor only acts at the *review* step, when there is something to look at.
+
+## User journeys
+
+### Professor (primary user)
+
+1. Uploads `lecture-3.pdf` to Canvas as they always have.
+2. ~5–10 minutes later, an in-Canvas message arrives: *"Your accessible version of lecture-3.pdf is ready for review."*
+3. Clicks the link → lands in the LTI tool (still inside Canvas, no separate login) → sees the proposed Canvas Page side-by-side with the original PDF.
+4. Either:
+   - **Approve & publish** — Canvas Page goes live, optionally linked in the same Module as the PDF.
+   - **Edit in Reflow viewer** — opens the existing pipeline viewer (handed an LTI launch session), corrects, comes back, approves.
+   - **Reject** — page is deleted, file gets a "needs manual remediation" tag.
+
+### Canvas admin (one-time setup)
+
+1. Creates a Developer Key in Canvas → registers the tool's LTI 1.3 config JSON.
+2. Generates an API access token for the watcher service (scoped to read files and write pages).
+3. Subscribes (optionally) to Canvas Live Events for file uploads, or accepts polling.
+4. Places the tool in **Course Navigation** as *Accessible Documents*.
+
+### Student (incidental)
+
+Sees the Canvas Page wherever the professor placed it. The original PDF can still be downloaded; the Page is the primary route.
+
+## Components
+
+```
+                       ┌─────────────────────────────────┐
+                       │            Canvas LMS           │
+                       │                                 │
+   PDF upload ───────► │   Files  Modules  Pages  Convo  │
+                       │     ▲       ▲       ▲      ▲    │
+                       └─────┼───────┼───────┼──────┼────┘
+                             │       │       │      │
+              ┌──────────────┘       │       │      │
+              │ poll / Live Event    │       │      │
+              ▼                      │       │      │
+      ┌──────────────┐               │       │      │
+      │ Canvas       │ create draft  │       │      │
+      │ Watcher      │ ──────────────┘       │      │
+      │ (worker)     │                       │      │
+      └──────┬───────┘                       │      │
+             │ submit PDF                    │      │
+             ▼                               │      │
+      ┌──────────────┐    SSE / poll  ┌─────────────┴──┐
+      │ Reflow API   │ ─────────────► │ Reflow Bridge  │
+      │ (existing)   │                │ (worker)       │
+      └──────────────┘                └──────┬─────────┘
+                                             │ create/publish page,
+                                             │ send conversation
+                                             ▼
+                                      ┌──────────────┐
+                                      │ Canvas API   │
+                                      └──────────────┘
+
+      ┌────────────────────────┐
+      │ LTI Tool (FastAPI)     │  ◄── professor's browser
+      │  - /lti/login          │      launches from Canvas
+      │  - /lti/launch         │
+      │  - /lti/jwks           │
+      │  - /canvas/review/*    │ ──► pulls state from Redis,
+      │  - /canvas/review UI   │     calls Canvas API to publish
+      └────────────────────────┘
+```
+
+Three logical pieces, all inside the existing `src/` monolith:
+
+| Piece | Module | Role |
+|---|---|---|
+| **LTI Tool** | `src/lti/` | OIDC login, signed launch, JWKS, tool config JSON. Renders the review UI when faculty launch from Canvas. |
+| **Canvas Watcher** | `src/workers/canvas_watcher.py` | Detects new PDFs (poll first, Live Events later). Submits to Reflow API. Records mapping in Redis. |
+| **Reflow Bridge** | `src/services/reflow_bridge.py` + `src/workers/reflow_bridge_worker.py` | Watches Reflow job completion. Converts markdown → Canvas HTML. Creates draft Page. Sends Conversation. |
+
+`src/canvas/` is the shared Canvas REST client used by all three pieces.
+
+## Data flow
+
+```
+1. PDF uploaded in Canvas
+      → Watcher sees it (poll or Live Event)
+      → Watcher GET /api/v1/files/{file_id}/download (Canvas)
+      → Watcher POST /api/v1/documents (Reflow, with X-API-Key)
+      → Watcher writes Redis key:
+            eq-pdf:canvas:job:{reflow_job_id} = {
+              canvas_file_id, canvas_course_id, canvas_user_id,
+              status: "processing", created_at
+            }
+      → Watcher writes index:
+            eq-pdf:canvas:course:{course_id}:pending → SADD reflow_job_id
+
+2. Reflow processes the PDF (existing pipeline, ~5 min)
+
+3. Reflow emits completion event (SSE) → Bridge worker
+      → Bridge GETs Reflow results (markdown + figure URLs)
+      → Bridge rewrites image URLs (Reflow S3 presigned → uploaded to Canvas Files, OR proxied)
+      → Bridge renders markdown → Canvas-flavoured HTML
+      → Bridge POST /api/v1/courses/{course_id}/pages
+            with { wiki_page: { title, body, published: false } }
+      → Bridge updates Redis:
+            status: "awaiting_review", canvas_page_url, canvas_page_id
+      → Bridge POST /api/v1/conversations
+            recipient: canvas_user_id
+            body: "Your accessible version of <filename>.pdf is ready for review: <launch URL>"
+
+4. Professor clicks link → Canvas issues LTI 1.3 launch
+      → /lti/login → redirect to Canvas auth → /lti/launch
+      → /lti/launch validates JWT, establishes session, redirects to /canvas/review/{job_id}
+
+5. Review screen shows:
+      - Original PDF (Canvas-hosted preview)
+      - Proposed Canvas Page (rendered HTML)
+      - "Open in Reflow Viewer" → existing pipeline viewer with LTI context
+      - "Approve & publish" → PUT /pages/{url} { published: true }, optional module insert
+      - "Reject" → DELETE /pages/{url}, mark file in Redis as "rejected"
+```
+
+## Auth model
+
+| Boundary | Mechanism |
+|---|---|
+| Canvas → Tool (browser launches) | LTI 1.3: OIDC login + signed `id_token` JWT, validated against Canvas JWKS. |
+| Tool → Canvas (API calls) | Developer Key OAuth2 client credentials, or admin-issued long-lived API token. Stored as `CANVAS_API_TOKEN` (secret). |
+| Tool → Reflow API | Existing `X-API-Key` header. |
+| Faculty session inside tool | Short-lived signed cookie issued at LTI launch, scoped to `(course_id, user_id)` from the JWT claims. |
+
+The tool never asks the professor to log in. The LTI launch JWT *is* the identity proof; the cookie is just a session container so they don't have to re-launch for every click.
+
+## Canvas API surface
+
+Minimum endpoints we hit (all under `/api/v1/`):
+
+- `GET /courses/:course_id/files?content_types[]=application/pdf` — watcher poll.
+- `GET /files/:id/public_url` or `GET /files/:id` with download URL — fetch PDF bytes.
+- `POST /courses/:course_id/files` — upload extracted figures (or skip and proxy through Reflow S3).
+- `POST /courses/:course_id/pages` — create draft Page.
+- `PUT /courses/:course_id/pages/:url` — publish / update.
+- `DELETE /courses/:course_id/pages/:url` — reject path.
+- `POST /conversations` — notify professor.
+
+The watcher subscribes to Canvas Live Events (via AWS SQS) later, replacing polling. Polling is fine for the MVP and for institutions that haven't enabled Data Services.
+
+## Redis keys
+
+Reuse the existing `eq-pdf:` prefix:
+
+| Key | Type | Purpose |
+|---|---|---|
+| `eq-pdf:canvas:job:{reflow_job_id}` | Hash | Mapping from a Reflow job back to the originating Canvas file, course, and user. |
+| `eq-pdf:canvas:course:{course_id}:pending` | Set | Reflow job IDs awaiting review in a course (drives the review list). |
+| `eq-pdf:canvas:course:{course_id}:processed` | Set | Canvas file IDs already submitted (idempotency guard for the watcher). |
+| `eq-pdf:canvas:session:{session_id}` | Hash | LTI launch session (user_id, course_id, roles, ttl). |
+| `eq-pdf:canvas:state:{nonce}` | String | OIDC state nonce for the login flow (10 min TTL). |
+
+All Redis access goes through the existing job_service patterns — async, with the same circuit breaker conventions.
+
+## Deployment topology
+
+The integration adds **no new containers** in the MVP. Routes mount inside the existing `api-gateway` FastAPI app; the watcher and bridge run as background tasks alongside the existing `pii_worker` and `timeout_worker` in `lifespan`. This matches the project's monolith convention.
+
+When Canvas Live Events comes online (Phase 4), the SQS consumer becomes a separate worker process. Until then: one container, three new endpoints, two new background tasks.
+
+Public URL requirement: the tool needs to be reachable from Canvas via HTTPS. UIC already has `reflow.equalify.uic.edu` for the API; the LTI endpoints sit under the same hostname:
+
+- `https://reflow.equalify.uic.edu/lti/login`
+- `https://reflow.equalify.uic.edu/lti/launch`
+- `https://reflow.equalify.uic.edu/lti/jwks`
+- `https://reflow.equalify.uic.edu/lti/config.json` (XML or JSON config for admin install)
+
+## Phased build plan
+
+| Phase | Scope | Done when |
+|---|---|---|
+| **0 — Foundation** | LTI 1.3 plumbing (login, launch, JWKS, key generation), config JSON, smoke test against Canvas test tenant. | A test admin can install the tool, launch it from a course, and see a "Hello, {user}" page. |
+| **1 — Polling watcher** | Poll one course every N seconds, detect new PDFs, submit to Reflow, persist mapping. | Uploading a PDF results in a Reflow job within 1 polling interval. |
+| **2 — Bridge + draft Page** | Listen to Reflow SSE; on success create draft Canvas Page; update Redis. | Completed Reflow job leaves an unpublished Page in Canvas. |
+| **3 — Review UI** | LTI nav placement, pending list, side-by-side preview, approve/reject. | Professor can approve a draft and the Page goes live. |
+| **4 — Notifications** | Canvas Conversation message to the professor on completion. | Professor gets the inbox ping without checking the LTI nav. |
+| **5 — Live Events** | Replace polling with Canvas Live Events via SQS. | New uploads trigger processing in <30 seconds, no polling. |
+| **6 — Module rewiring** | Optional: when approved, also insert the Page next to the PDF in any Module that references it. | Approval offers "Also link in Module X" checkboxes. |
+| **7 — Multi-tenancy hardening** | Per-institution config, multi-tenant key isolation, admin onboarding UI. | A second institution can install without code changes. |
+
+The MVP (Phases 0–3) is the smallest thing that delivers faculty value. Phase 4 (conversation) is the magic that makes faculty actually *find* the review queue.
+
+## Open questions
+
+- **Conversion strategy for figures.** Two options: (a) upload extracted figures from Reflow into Canvas Files so the Page is self-contained, or (b) leave figures on Reflow S3 with long-lived presigned URLs. (a) is more portable, (b) is cheaper and avoids cluttering Course Files. The MVP picks (b) and revisits.
+- **Who pays for the API call?** The Reflow API rate-limits per API key. If every Canvas institution shares one key, one popular tenant could starve others. Phase 7 introduces per-institution keys; until then we assume single-tenant.
+- **PII flow.** Reflow already PII-scans every document. If a PDF fails the PII gate, the current Reflow approval workflow asks the *uploader* to confirm. In the Canvas flow, the uploader is the professor — but the approval token currently goes by email. We need to route that approval through the LTI tool too. Probably Phase 2.5.
+- **Localisation of the Canvas Page title.** Default is the original PDF filename minus extension. Configurable per course later.
+- **What happens to the original PDF.** MVP leaves it alone. Phase 6 offers (but does not force) replacing the link in modules.
+
+## Why this shape and not alternatives
+
+- **Browser extension** would put the burden on every professor to install it. Adoption falls off a cliff.
+- **Pure API poller with no LTI** would force the review step into an external dashboard. Faculty already live in Canvas; adding a second login is a non-starter.
+- **LTI alone, no watcher** would require the professor to actively *send* the PDF to the tool (e.g., a deep link picker). That's an extra step at upload time, exactly the thing the design constraint forbids.
+
+Hybrid is the only shape where the professor's workflow is genuinely unchanged.
+
+## Panorama-style overlay
+
+The pieces above (watcher, bridge, draft Page, review queue) cover the *conversion* path. To match what tools like YuJa Panorama and Anthology Ally do, the integration also needs to be *visible* inside the native Canvas UI — students see formats, instructors see scores, all without leaving Canvas. That's a separate surface, layered on top of the same backend.
+
+### What it looks like for users
+
+| User | Where | What they see |
+|---|---|---|
+| Student | Files page, Modules, Assignments, anywhere a PDF link appears | A small format-picker icon next to the filename. Clicking it offers: original PDF, accessible HTML, tagged PDF, ePub, audio (MP3), translated, BeeLine Reader. |
+| Instructor | Same places, plus their Files index | A coloured gauge (red / amber / green / dark green) next to each file showing 0–100% accessibility. Clicking the gauge opens a panel listing the top issues and how to fix them. |
+| Instructor | Course Navigation → *Accessible Documents* (the LTI nav item) | Course-wide accessibility dashboard: aggregate score, file-by-file table, sortable, with a link to remediate each. |
+| Admin | Cross-course dashboard | Institution-level trend, breakdown by department, by file type, by severity. |
+
+### How it works
+
+The visible UI is not an iframe — it is a **JavaScript bundle injected via Canvas Theme Editor**. The admin pastes one line into *Admin → Themes → Edit current theme → JavaScript file*:
+
+```html
+<script src="https://reflow.equalify.uic.edu/lti/panorama.js?inst=uic" defer></script>
+```
+
+That script runs on every Canvas page load. It:
+
+1. Reads ``window.ENV`` to learn the current user, course, and role.
+2. Walks the DOM for file links matching Canvas's predictable selectors (``a[href*="/files/"]``, file rows in Modules, etc.).
+3. Batches the file IDs and calls ``GET /canvas/panorama/score?inst=uic&course_id=…&file_ids=…``.
+4. Injects a small gauge or dropdown element next to each matched link.
+
+The injected widget is a single small custom element (no framework) styled to blend with Canvas — no iframe, no shadow DOM unless we hit class collisions.
+
+### New backend pieces
+
+| Endpoint | Purpose |
+|---|---|
+| ``GET /lti/panorama.js`` | Serves the injection bundle. Cached at the CDN edge with a short max-age so admins don't have to re-paste on every release. |
+| ``GET /canvas/panorama/score`` | Returns ``{ file_id: { score, severity, available_formats[] } }`` for a batch of file IDs in a course. |
+| ``GET /canvas/panorama/issues/{file_id}`` | Returns the ranked list of issues for one file (used by the instructor popover). |
+| ``GET /canvas/panorama/alt/{job_id}/{format}`` | Serves an alternative format: ``html``, ``pdf-tagged``, ``epub``, ``mp3``, ``txt``. Validates that the requester is enrolled in the originating course (delegates the check back to Canvas via a tiny ``GET /courses/:id/enrollments`` call cached for 60s). |
+| ``GET /canvas/dashboard`` | Course accessibility dashboard. Same auth as ``/canvas/review`` — LTI session cookie. |
+
+### Score model
+
+The score is a single 0–100 number with a severity bucket. The MVP composes it from signals Reflow already produces, so we don't have to build a separate accessibility scanner:
+
+| Signal | Weight | Source |
+|---|---|---|
+| PDF has a text layer (not a pure scan) | 30 | Docling extraction phase |
+| Headings present and hierarchical | 20 | Headings reconciliation phase |
+| All images have alt text | 20 | Translation phase (per-page) |
+| Tables are real tables, not images | 15 | Structure analysis |
+| Reading order is linearised | 10 | Boundary fixes |
+| Language is set | 5 | Metadata |
+
+Severity:
+
+- 0–32: red — unusable
+- 33–66: amber — needs work
+- 67–89: green — usable
+- 90–100: dark green — gold standard
+
+The exact weights live in ``src/canvas/panorama.py`` and are tuneable per institution; do not hardcode them at call sites.
+
+### Alternative formats
+
+Reflow already produces *semantic markdown*. Every other format derives from it:
+
+| Format | How it's produced | Phase |
+|---|---|---|
+| ``html`` | Render markdown → HTML (existing converter in `markdown_to_html.py`). | MVP |
+| ``txt`` | Strip markdown formatting. | MVP |
+| ``pdf-tagged`` | Render markdown → tagged PDF via WeasyPrint with the structure tree retained. | Phase 2 |
+| ``epub`` | Render markdown → ePub via pandoc or ebooklib. | Phase 2 |
+| ``mp3`` | TTS over the plain-text version. Probably Amazon Polly given the AWS stack. | Phase 3 |
+| ``translated/{lang}`` | Run the markdown through the existing AI pipeline with a translation prompt. | Phase 3 |
+| ``beeline`` | HTML rendering with BeeLine Reader's stylesheet (licence required). | Phase 4 |
+
+Formats are computed lazily on first request and cached in S3 under ``s3_results_bucket/canvas-alt-formats/{job_id}/{format}``.
+
+### Auth boundary for the injected script
+
+The script runs in a Canvas-origin browser; calls cross to ``reflow.equalify.uic.edu``. Three things keep that safe:
+
+1. **CORS allow-list** of Canvas hostnames per institution, configured server-side via ``CANVAS_ALLOWED_ORIGINS``.
+2. **No PII in score responses.** Scores are about files, not students. Anyone who can see a file in Canvas can see its score.
+3. **Alt-format downloads are enrollment-checked.** Before streaming the alt format, the server calls Canvas's ``/courses/:id/enrollments`` with the current user's id (read from ``window.ENV.current_user_id`` and signed into the request) and 403s if not enrolled. The signing key is a short-lived token issued by ``GET /canvas/panorama/handshake`` when the script first loads.
+
+### Updated phased build plan (additions)
+
+| Phase | Scope |
+|---|---|
+| **3a — Theme injection bundle** | Panorama.js MVP: gauges next to file links, format dropdown opens to HTML/TXT only. |
+| **3b — Instructor popover** | Click-through panel with ranked issues sourced from Reflow's per-phase outputs. |
+| **3c — Course dashboard** | LTI nav item shows aggregate course score and file table. |
+| **3d — Institution dashboard** | Admin-only view aggregating across courses. |
+| **6 — Tagged PDF + ePub** | Add WeasyPrint / ebooklib alt-format generators. |
+| **7 — TTS + translation** | Polly-backed MP3, Bedrock-backed translation. |
+
+The Theme-Editor approach is what Panorama and Ally use; it survives Canvas UI redesigns better than people fear because Canvas's selectors for file links have been stable for years. The fallback is a Custom CSS-only treatment that adds a "View accessible formats" link via ``::after`` content — uglier, but still useful.
diff --git a/docs/explanation/iso-security-brief.md b/docs/explanation/iso-security-brief.md
new file mode 100644
index 0000000..7c72865
--- /dev/null
+++ b/docs/explanation/iso-security-brief.md
@@ -0,0 +1,409 @@
+# ISO Brief: Access Requests + Security Review
+
+For the conversation with the Information Security Officer. Asks (AWS
+resources, AI provider) plus answers to the questions an ISO will care about.
+
+## Updates since v1 (May 2026)
+
+This brief was updated to reflect three architectural decisions that
+strengthen the security/compliance posture:
+
+1. **Hosting target: AWS Fargate.** Reflow runs on ECS Fargate with an
+   IAM task role inside a dedicated VPC — no long-lived credentials on a
+   VM, no OS-patching burden for CSUEB IT, multi-AZ failover. (Previously
+   considered: campus VM. That option is now fallback only.)
+2. **Faculty consent flow (built and wired).** Before processing any
+   document, faculty acknowledge an in-app disclaimer that explains PII
+   handling, Claude API usage, and their responsibility for content.
+   The consent record (user, timestamp, IP, disclaimer version) is
+   audit-logged in Redis. Subsequent launches skip the prompt until the
+   disclaimer version is bumped. This is the strongest possible
+   data-handling story: explicit, documented user authorization rather
+   than silent automatic processing.
+3. **Scope: new uploads only, faculty-uploaded materials only.** Reflow
+   processes documents as faculty add them to Canvas — no backfill of
+   the existing course catalog, no student submissions. The trust
+   boundary is the instructor.
+
+See architecture diagrams in `briefs/diagrams/`:
+
+- `01-fargate-arch.png` — Production architecture on AWS Fargate.
+- `02-data-flow.png` — End-to-end data flow with PII redaction trust boundary.
+- `03-consent-flow.png` — Faculty consent flow (first launch + subsequent launches).
+
+## TL;DR
+
+I need provisioning for these things:
+
+1. **AWS account** for hosting on Fargate plus storing PDFs in S3 and
+   Polly for audio generation. Specific services: ECS Fargate, ALB,
+   ElastiCache Redis, S3, ECR, CloudWatch, ACM.
+2. **One AI provider**: either an Anthropic API key OR AWS Bedrock model
+   access for Claude Sonnet 4.6 (with Haiku 4.5 and Opus 4.7 available
+   via smart routing).
+3. **ISO sign-off** that the consent flow + PII redaction + IAM-scoped
+   task role design meets CSUEB's AI / data governance posture.
+
+All three vendors (AWS, Anthropic) are widely used in higher-ed and
+have signed Cal-State-friendly data agreements available. The data
+flows are described below.
+
+## 1. AWS access request
+
+### Resources I need created (Fargate-based)
+
+| Resource | Purpose | Cost estimate |
+|---|---|---|
+| Dedicated AWS sub-account or VPC (`us-west-2`) | Reflow runs in its own AWS landing zone for clean IAM/billing boundary | Free |
+| ECS Fargate service (api-gateway) | Runs the main Reflow API container | Pilot ~$30/mo, Campus ~$400/mo |
+| ECS Fargate service (docling-serve) | OCR/document extraction sidecar | Included in Fargate baseline |
+| Application Load Balancer | HTTPS termination, multi-AZ routing | $22/mo |
+| ElastiCache Redis (cache.t4g.micro single → multi-AZ) | Job state, consent records, faculty edits cache | Pilot ~$15/mo, Campus ~$80/mo |
+| S3 bucket `csueb-reflow-temp` (in `us-west-2`) | Holds uploaded PDFs for the ~5 min of processing | Auto-deletes after 24h |
+| S3 bucket `csueb-reflow-results` (in `us-west-2`) | Stores converted markdown + alt-format outputs | ~$5–50/mo |
+| ECR repository | Container image registry for api-gateway + docling-serve | ~$1/mo |
+| **IAM task role** (not IAM user) | Scoped credentials given to Fargate tasks at runtime — no long-lived access keys | Free |
+| Polly access (audio MP3 feature) | Text-to-speech | $16 / 1M chars Neural |
+| Bedrock access (optional alternative to Anthropic direct) | Claude Sonnet 4.6 / Haiku 4.5 / Opus 4.7 inference | Token-metered |
+| ACM cert for `reflow.csueb.edu` | TLS termination at ALB | Free |
+| CloudWatch log group + alarms | Logs, `/health` alarm, cost budget alarms | Pilot ~$10/mo |
+
+See `briefs/diagrams/01-fargate-arch.png` for the architecture overview.
+
+### Exact IAM policy (ECS task role)
+
+The ECS Fargate task role needs the following — least-privilege, scoped to
+Reflow resources. This is attached directly to the running container at
+runtime; no long-lived access keys exist anywhere:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "S3RW",
+      "Effect": "Allow",
+      "Action": [
+        "s3:GetObject",
+        "s3:PutObject",
+        "s3:DeleteObject",
+        "s3:ListBucket"
+      ],
+      "Resource": [
+        "arn:aws:s3:::csueb-reflow-temp",
+        "arn:aws:s3:::csueb-reflow-temp/*",
+        "arn:aws:s3:::csueb-reflow-results",
+        "arn:aws:s3:::csueb-reflow-results/*"
+      ]
+    },
+    {
+      "Sid": "PollyOptional",
+      "Effect": "Allow",
+      "Action": ["polly:SynthesizeSpeech"],
+      "Resource": "*"
+    },
+    {
+      "Sid": "BedrockOptional",
+      "Effect": "Allow",
+      "Action": ["bedrock:InvokeModel"],
+      "Resource": [
+        "arn:aws:bedrock:us-west-2::foundation-model/anthropic.claude-haiku-4-5-*",
+        "arn:aws:bedrock:us-west-2::foundation-model/anthropic.claude-sonnet-4-5-*"
+      ]
+    }
+  ]
+}
+```
+
+If Cal State prefers, drop the Polly + Bedrock statements; the app degrades gracefully (audio returns 503, AI uses Anthropic direct).
+
+### Bucket configuration the ISO should require
+
+- **Encryption at rest**: SSE-S3 (AES-256) minimum; SSE-KMS with a CSU-managed key if preferred.
+- **Versioning**: enabled on `results` bucket so a bad pipeline run doesn't lose history.
+- **Public access**: blocked at the bucket level (`BlockPublicAcls`, `IgnorePublicAcls`, `BlockPublicPolicy`, `RestrictPublicBuckets` all `true`). Our app uses presigned URLs for short-lived sharing.
+- **Lifecycle**: auto-delete `temp/*` after 24 hours; the results bucket retains as long as the source PDF remains in Canvas (cleaned up on Canvas file deletion via webhook in Phase 2).
+- **Logging**: server access logging enabled, logged to an audit bucket.
+
+### Region
+
+`us-west-2` (Oregon) for proximity to Cal State infrastructure. All data stays in this region.
+
+## 2. AI provider request
+
+Pick one path:
+
+### Path A — Anthropic API direct (simplest)
+
+I need an **Anthropic API key** for an **Anthropic Console Team or Enterprise plan**.
+
+- Plan: Team (~$25/user/mo) or Enterprise (custom). Either provides the data-handling commitments below.
+- Cost at our usage: ~$1/mo for 1000 PDFs converted (we use Claude Haiku 4.5, $0.0008 per typical 30-page PDF).
+- Data Processing Addendum (DPA) is **standard** — Anthropic has signed equivalents with many universities. Cal State Procurement should ask for it explicitly.
+
+### Path B — AWS Bedrock (data stays in AWS)
+
+If Cal State prefers data to never leave AWS, use Bedrock instead:
+
+- Enable Claude Haiku 4.5 and Claude Sonnet 4.5 in the AWS account, region `us-west-2`.
+- Add the Bedrock statement to the IAM policy above.
+- Same cost per document.
+- No separate vendor contract — covered by your existing AWS agreement.
+
+Path B is simpler from a compliance standpoint because Anthropic doesn't see the requests directly; AWS hosts the model in your tenant.
+
+## Security questions an ISO will ask, with answers
+
+### What data leaves the institution?
+
+**Going to AWS (S3):** PDF files, extracted markdown, extracted images. Stored encrypted at rest. Stays in `us-west-2`. Lifecycle deletes within 24h for temp / on Canvas deletion for results.
+
+**Going to the AI provider (Anthropic or Bedrock):** Per-page text and page images extracted from the PDF, plus prompts asking the model to fix accessibility (heading hierarchy, alt text, etc.). PII is scanned BEFORE this step with Microsoft Presidio; PII-flagged documents do not proceed to AI without explicit instructor approval.
+
+**Going to Polly (if enabled):** Plain-text version of the accessible HTML, for TTS conversion. Cached output stored in our S3 bucket.
+
+**Going to MathJax CDN:** Nothing leaves the institution — MathJax runs in the user's browser. No data sent outbound.
+
+### What does the AI provider do with our data?
+
+- **Anthropic** (direct): Per their commercial Terms, customer inputs are not used for training. Data is retained for up to 30 days for abuse monitoring, then deleted. Anthropic has signed FERPA-compatible agreements with universities; specific BAA-equivalent paperwork available on request to procurement.
+- **AWS Bedrock**: AWS's Service Terms apply. Inputs are not used to train AWS or third-party models. Data stays in your AWS region. No separate vendor relationship beyond AWS.
+
+### FERPA: is student data going to a third party?
+
+PDFs in Canvas can contain student data (e.g., graded papers, returned assignments). To control this:
+
+- Reflow runs Microsoft Presidio (open-source PII scanner) on every PDF *before* AI processing. PII findings flag the document and require instructor approval before AI calls happen.
+- Our default config sets `PII_DETECTION_ENABLED=true` and `PII_CONFIDENCE_THRESHOLD=0.7`. Lowering the threshold catches more PII at the cost of false positives.
+- For Cal State's pilot scope, recommend limiting `CANVAS_WATCHED_COURSES` to instructor-uploaded course material only (syllabi, lecture handouts, readings) — not assignment submissions or feedback files. The scanner walks every Canvas surface, but you can restrict by course ID list during the pilot.
+
+If your FERPA officer needs documentation of how PII handling works, point them to `docs/reference/pipeline-phases.md` and the Presidio section.
+
+### Encryption
+
+- **In transit**: HTTPS / TLS 1.2+ everywhere. LTI launches are JWT-signed and validated against Canvas's JWKS.
+- **At rest in S3**: SSE-S3 (AES-256) or SSE-KMS with a CSU key.
+- **At rest in Redis**: not encrypted by default. Redis stores job metadata (file IDs, status), faculty-edited HTML, and session cookies. For production, run Redis with TLS and require AUTH. AWS ElastiCache Redis can be the prod option with encryption at rest enabled.
+- **Secrets**: API keys / Canvas tokens in environment variables for dev, AWS Secrets Manager (or HashiCorp Vault) for production.
+
+### Authentication and authorization
+
+- **Canvas → Tool**: LTI 1.3 OIDC + JWT-signed launch. Validated against Canvas JWKS on every launch. No passwords.
+- **Tool → Canvas**: A single Canvas API token belonging to a dedicated service account `accessibility-service@csueb.edu`. Scoped via Canvas's permission system. Rotatable; revocable from Canvas admin.
+- **Tool → AWS**: IAM user or IAM role (preferred for instances/Fargate). Credentials never in source code.
+- **Tool → AI provider**: API key in env. Rotatable.
+
+### Audit logging
+
+- Every Reflow pipeline run logs structured JSON: which Canvas file, which instructor, what AI calls, what cost. Shipped to CloudWatch or campus log aggregation.
+- Faculty HTML edits are logged with timestamp + (LTI session) user id.
+- Canvas API calls logged with request id for traceability.
+- AI calls have token-level traceability via Logfire (optional, can be disabled).
+- **Faculty consent acknowledgments are logged append-only** (see consent flow section below) with user id, timestamp, IP address, and disclaimer version.
+
+### Faculty consent / authorization flow (built and wired)
+
+On first launch, before Reflow processes any document, the faculty member
+sees an in-app disclaimer explaining how the tool handles content and PII.
+They must check three acknowledgment boxes ("I authorize processing", "I
+understand PII handling", "I remain responsible for content") and click
+"I Agree" before the tool will proceed. The acknowledgment is recorded in
+Redis with user id, timestamp, IP address, and disclaimer version, plus
+an append-only entry in the audit log key `eq-pdf:canvas:consent:audit`.
+
+Subsequent launches skip the prompt — the Alt Formats modal shows a small
+footer reminder ("✓ Authorized on May 14, 2026 · View terms") and faculty
+can revisit the disclaimer page at any time. If the disclaimer language
+ever changes, we bump `CURRENT_CONSENT_VERSION` in
+`src/canvas/state.py` and every faculty member is re-prompted until they
+acknowledge the new version. The audit log preserves all historical
+acknowledgments so the ISO can pull a complete record at any time.
+
+**Why this matters for the security review.** Explicit user consent is a
+recognized mitigation under FERPA, NIST AI RMF (Govern function 1.3 and
+3.1), and most university AI policies. It changes the data-handling story
+from "silent automatic processing of faculty content" to "documented
+user-authorized processing with audit trail" — typically the difference
+between a long ISO review and a fast conditional approval.
+
+**Files involved.** Backend: `src/api/canvas_consent.py` (routes),
+`src/canvas/state.py` (Redis persistence + audit log). Frontend:
+`src/web/canvas_review/panorama.js` (status probe + banner/footer in
+Alt Formats modal). See `briefs/diagrams/03-consent-flow.png` for the
+sequence diagram.
+
+### Vendor security posture
+
+- **Anthropic**: SOC 2 Type II, HIPAA-compliant agreements available, ISO 27001 in progress. Published list of certifications at trust.anthropic.com.
+- **AWS**: SOC 1/2/3, ISO 27001, FedRAMP Moderate (us-east, us-west). Cal State likely already has an AWS GovCloud or commercial agreement.
+- **Reflow upstream (UIC)**: open-source, AGPL-3.0. Source auditable. Maintained by University of Illinois Chicago.
+- **Equalify Reflow Docker image**: built from source by Cal State; you own the SBOM.
+
+### Incident response
+
+- **Compromised Canvas API token**: revoke in Canvas admin, generate new, redeploy.
+- **Compromised AI key**: rotate in Anthropic/AWS console, redeploy.
+- **Compromised AWS credentials**: rotate IAM access key (or detach IAM role policy if role-based), redeploy.
+- **Suspected breach of S3 bucket**: enable S3 access analyzer, audit access logs, rotate KMS keys if SSE-KMS is used.
+- **Faculty data deletion request**: redirect to Canvas's normal file-deletion flow; we follow Canvas's lead.
+
+### Data retention
+
+- **S3 `temp` bucket**: 24-hour lifecycle.
+- **S3 `results` bucket**: held while the source PDF exists in Canvas. Phase 2 adds a Canvas Live Events webhook so we clean up when files are deleted from Canvas.
+- **Redis (job metadata + edited HTML)**: ~30 days for completed jobs, configurable via `JOB_RETENTION_DAYS`.
+- **Anthropic / Bedrock**: see vendor sections above (30 days at Anthropic; not retained at Bedrock beyond the API call).
+- **Logs**: per Cal State's log retention policy (typically 90 days).
+
+### Network exposure
+
+- The tool sits at one public HTTPS URL. Only the following are exposed externally:
+  - `/lti/login`, `/lti/launch`, `/lti/jwks`, `/lti/config.json` — LTI handshake endpoints
+  - `/lti/panorama.js` — the Theme JS bundle
+  - `/canvas/panorama/*` — score, alt-format, edit endpoints (CORS-restricted to CSUEB Canvas)
+  - `/canvas/review/*` — instructor review UI (requires LTI session cookie)
+  - `/health`, `/metrics` — bound to localhost or behind auth in prod
+- All other endpoints (`/api/v1/*`) are protected by API-key auth.
+- No SSH on the public surface; admin access via campus VPN only.
+
+### Open security gaps (be upfront)
+
+- **Tests** for the new Canvas-integration endpoints aren't written yet. We have Reflow's existing test suite; the integration code is hand-tested.
+- **CSP on Theme JS** is currently permissive (allow_origins=`*` with credentials=false). Production should narrow to CSUEB Canvas origins specifically (`CANVAS_ALLOWED_ORIGINS` env var supports this).
+- **Rate limiting** on the Canvas API client is implicit (60s poll cadence); a malicious Canvas token would not have rate limit guards on our side.
+- **Faculty HTML edits** are stored unencrypted in Redis. For sensitive content, recommend running Redis with TLS + AUTH in prod (we can switch to AWS ElastiCache).
+
+## Specific paperwork I'd ask the ISO to confirm or kick off
+
+1. **AWS Data Processing Addendum**: confirm Cal State's master agreement covers this use case, or add a project-specific DPA.
+2. **Anthropic DPA / Enterprise Terms** (if using Path A): request from Anthropic if not already on file at the system level.
+3. **FERPA review**: confirm PII-scanning + instructor-approval flow satisfies your FERPA officer for instructor-uploaded course materials.
+4. **Penetration test / security review** of the deployed instance before opening to general faculty. The codebase is small enough for a 1-day review.
+
+## Concrete asks summary
+
+For the ISO to provision and approve, in order:
+
+1. **AWS IAM service account** with the policy above, region `us-west-2`.
+2. **Two S3 buckets** with the configuration above (encryption, no public access, lifecycle, logging).
+3. **AI access** — either an Anthropic API key (Team or Enterprise plan) OR enabled Bedrock models in the AWS account.
+4. **TLS certificate** for the public hostname (e.g., `reflow.csueb.edu`).
+5. **Sign-off** on the PII + FERPA approach.
+6. **Allowlist** the production public hostname for Canvas Custom JS (some institutions restrict which domains can be used as Theme JS sources).
+
+Total provisioning time, typical higher-ed pace: 2–3 weeks for AWS + AI access; 1 day for TLS cert; 1 week for FERPA officer sign-off (parallelizable).
+
+## AI Governance
+
+ISO will want to see this covered. AI governance for higher-ed in 2026 is shaped by NIST AI RMF, the CSU system's evolving AI guidance, and FERPA/Title IV obligations. Below are the categories an AI governance review typically checks, with our answers.
+
+### Approved-vendor and intended-use scope
+
+- **Vendor**: Anthropic (PBC, San Francisco) or AWS Bedrock-hosted Claude. Both are widely used in the CSU system; check whether CSU's Office of the Chancellor has a system-level master agreement before procuring fresh.
+- **Model**: Claude Haiku 4.5 (efficient tier, ~95% of calls) and Claude Sonnet 4.5 (reasoning tier, ~5% of calls). Both are general-purpose LLMs, **not** specifically certified for student data or healthcare.
+- **Intended use**: Convert instructor-uploaded PDFs into accessible alternative formats. Specifically: reorder heading hierarchies, propose alt text for images, normalize table structure, fix reading order. **Not** intended for: grading, evaluating student work, generating original instructional content, scoring student writing, or any high-stakes decision.
+- **Out-of-scope explicitly**: No AI calls touch student submissions, grades, or feedback. The watcher's scope can be limited to specific courses or sub-accounts to enforce this at deployment.
+
+### Data classification
+
+Every PDF processed falls into one of these categories — Cal State should classify before the pilot:
+
+| Class | Example | Send to AI? | Notes |
+|---|---|---|---|
+| Public / instructional | Syllabus, lecture notes, public readings | Yes | Low-risk; the design target |
+| Restricted / FERPA | Graded papers, transcripts, accommodations letters | No | PII scan flags; instructor must approve |
+| Confidential | Personnel docs, legal materials in a course folder | No | Should not be in course Files; watcher will still flag |
+
+The pipeline runs Microsoft Presidio against every PDF *before* AI calls. Documents that trip thresholds for SSN, credit card, names+addresses, etc. are paused and require instructor approval. The instructor sees what PII was found before deciding.
+
+### Human-in-the-loop
+
+Two human-review gates:
+
+1. **PII gate** (before AI runs): if Presidio finds PII above threshold, the document doesn't reach AI until the instructor explicitly clicks "approve" on the PII findings.
+2. **Faculty HTML editor** (after AI runs): instructors can edit the accessible HTML directly. Especially important for STEM (chemistry, math, physics) where the AI might mishandle notation. Edited HTML becomes the source of truth for every alternative format.
+
+Neither is bypassed automatically; both are explicit user actions logged with timestamp and user id.
+
+### Hallucination and accuracy risk
+
+- **Type of task limits risk**: the AI's job is *transformation* of existing text, not generation of new claims. It rewrites headings, proposes alt text for images, normalizes tables. It does not invent facts or generate original course content.
+- **Known weak spots**:
+  - Complex math / chemistry notation: AI may mangle MathML/LaTeX. Mitigation: faculty editor + the HTML-with-MathJax format. STEM faculty should review every page.
+  - Alt text on figures: may be overconfident or generic ("a graph showing data"). Mitigation: instructor reviews/edits via the editor.
+  - OCR fallback on scanned PDFs: Tesseract introduces OCR errors. Mitigation: confidence scores are exposed, instructor can review.
+- **No high-stakes use**: nothing in the pipeline affects grades, eligibility, or any decision about a student. Errors degrade accessibility output quality, they don't harm anyone.
+
+### Bias and fairness
+
+- **Where bias could appear**: AI-generated alt text could reflect societal biases from the training corpus (e.g., gender-coded descriptions of people in photos, racial assumptions). Translation quality may be lower for less-resourced languages.
+- **Mitigation**:
+  - Alt text is reviewed by the instructor before publication (faculty editor).
+  - Translation supports a configurable language list; default to the languages CSUEB's student body actually uses.
+  - The Reflow project (UIC upstream) has an active research interest in alt-text bias evaluation — we can track their findings.
+- **What we do not claim**: this tool has not been independently audited for disparate impact across protected classes. If Cal State requires that audit, schedule it as part of the pilot.
+
+### Audit trail and transparency
+
+- Every AI call is logged with: timestamp, instructor id, file id, model used, input token count, output token count, cost. Logged in structured JSON to CloudWatch or campus log aggregation.
+- Logfire (optional but recommended for AI workloads) captures full agent traces — prompts, responses, retries. Toggle via `LOGFIRE_ENABLED=true`.
+- Faculty HTML edits are versioned in Redis with timestamp + user id.
+- Disclosable to faculty on request: every AI call made against their material.
+
+### Faculty opt-out
+
+- The tool runs on instructor-uploaded materials, not student submissions, so the consent boundary is the instructor.
+- Per-course opt-out: an instructor can ask their admin to exclude their course id from `CANVAS_WATCHED_COURSES`. Future Phase 2: a per-instructor toggle in the LTI tool itself.
+- Per-document opt-out: at the PII gate, instructors can deny AI processing for that specific document; only PII scan and standard extraction run.
+
+### Student-facing disclosure
+
+- Students don't see AI-generated content unless the instructor has explicitly approved/published it via the review queue (or the Files page natively displays the original PDF).
+- The alternative formats students download are clearly marked as accessible versions. The footer says "Powered by Equalify Reflow" so attribution is in-band.
+- Recommend Cal State adopt a course-level syllabus statement disclosing the tool's use, similar to Cal State's existing AI-tutor disclosures. Template available on request.
+
+### Output ownership and IP
+
+- **Input PDFs**: owned by the instructor (or whoever uploaded them to Canvas). We don't claim any rights.
+- **Output**: derivative of the input. Owned by the instructor. We store it in our S3 but they can request deletion via the normal Canvas file-deletion flow.
+- **AI provider position**: both Anthropic and AWS Bedrock contractually disclaim ownership of outputs and don't train on inputs.
+- **Cal State retains all rights**: nothing about deploying this transfers IP to a vendor.
+
+### NIST AI Risk Management Framework alignment
+
+Where this maps:
+
+- **MAP function**: AI use is documented (this doc), intended use bounded, stakeholders identified (instructors, students, accessibility office, ISO, FERPA officer).
+- **MEASURE function**: cost per call, accuracy via human review, error rates trackable via logs. Hallucination measurement: instructor approval rate as a proxy.
+- **MANAGE function**: opt-out paths exist, human-in-the-loop at two points, audit trail, vendor agreements in place.
+- **GOVERN function**: this brief plus the production-readiness doc constitute the governance baseline. CSU-system-level governance may add requirements.
+
+### Cal State / CSU system alignment
+
+CSU's evolving AI use guidance (Chancellor's Office / ITAC) may require:
+
+- Inclusion in an approved-AI-use registry — register the tool there.
+- Privacy threshold assessment (PTA) — start one before pilot launch.
+- Annual review by a campus AI governance committee — if CSUEB has one, brief them.
+- Faculty Senate / academic governance approval — depending on use scope, the Senate may want to weigh in on whether AI-assisted accessibility tooling falls under their AI policy purview.
+
+I don't have visibility into CSUEB's specific AI governance committee or process — your ISO will. List that as an explicit step in the rollout plan.
+
+### Ongoing AI governance commitments
+
+If this ships to production, recommend:
+
+- **Quarterly AI usage review**: cost, volume, error rates, instructor satisfaction. ~half-day per quarter.
+- **Annual model review**: Anthropic releases new Claude models every ~6 months. Evaluate before swapping. Document any change in `ai/model_tiers.py`.
+- **Annual bias audit**: sample alt-text outputs across course types. Flag if any group's content is consistently under-described.
+- **Incident response for AI failure**: if a hallucinated alt text becomes a Title IX / harassment issue, the editor + audit log let us trace and fix quickly.
+
+### What's NOT covered (be honest)
+
+- No formal model risk management plan beyond this brief.
+- No third-party audit yet.
+- No automated bias testing (manual sampling only).
+- We rely on Anthropic / AWS for foundation-model evaluation; we do no in-house red-teaming.
+- The OCR step (Tesseract) is a non-AI process but introduces error rates that compound with AI hallucination risk on top.
+
+If your AI governance committee requires any of those, schedule them as part of the pilot.
diff --git a/docs/explanation/multi-tenant.md b/docs/explanation/multi-tenant.md
new file mode 100644
index 0000000..35cc81c
--- /dev/null
+++ b/docs/explanation/multi-tenant.md
@@ -0,0 +1,423 @@
+# Multi-Tenant Canvas Integration Architecture
+
+## Summary
+
+Equalify Reflow is a Canvas LMS integration intended to run as a single
+hosted service serving many Canvas-hosted schools simultaneously. This
+document describes the authentication, data, and onboarding architecture
+that makes that possible. The core shift is from a per-instructor
+Canvas API token (the current MVP) to LTI Advantage client-credentials
+service tokens. The tool has one identity (its Developer Key); each
+school's admin grants that identity a defined set of Canvas API scopes
+at install time; and the same Reflow code runs unchanged against every
+Canvas instance.
+
+The migration described in section 9 is roughly 1.5 dev-days of work,
+broken into seven incremental phases that can each ship behind a feature
+flag without taking the existing single-tenant path offline.
+
+## Problem statement
+
+The current Canvas client is hardcoded to one Canvas instance and one
+bearer token (`settings.canvas_api_token`). This works for an MVP being
+demoed in a single test course, but it has three structural problems
+for a real integration:
+
+1. A long-lived user-impersonating token is the wrong audit surface for
+   a vendor integration. Every call appears to come from the user who
+   minted the token, with that user's full permission scope, with no
+   indication that the call was on behalf of a tool. Canvas IT teams
+   uniformly refuse to deploy vendors that ask for one.
+
+2. The token's permissions follow that user's enrollments. If the user
+   leaves the institution, loses admin rights, or has their token
+   rotated, the integration silently breaks for every course that was
+   relying on it. There is no admin-visible "Reflow has the following
+   permissions" surface.
+
+3. The model does not generalize to N institutions. A second school
+   would need a second token in a second env var, with a second Canvas
+   base URL, and either a second Reflow deployment or careful per-call
+   tenant routing that nothing in the current code does. The `tk()`
+   helper hints at this future but doesn't actually implement it.
+
+LTI Advantage client-credentials solves all three. The tool is the
+principal, scopes are admin-granted and visible in the Developer Key
+UI, and the same code routes to whichever platform issued the launch.
+
+## High-level architecture
+
+The auth surface has three actors and four flows.
+
+The actors are: the Reflow tool (us); a Canvas platform instance (one
+per school, e.g. `canvas.csueastbay.edu`); and a Canvas user whose
+browser is initiating the launch.
+
+The flows are:
+
+**LTI launch (already implemented).** Canvas redirects the user's
+browser to `/lti/login`, we redirect to Canvas's auth endpoint, Canvas
+POSTs a signed `id_token` back to `/lti/launch`. We validate signature,
+issuer, audience, and `deployment_id`. We create a session cookie
+keyed to the platform + user + course and hand off to the review UI.
+
+**Service-token request (new).** When the watcher or bridge needs to
+call Canvas, it asks `canvas/oauth.py` for a bearer token for the
+specific platform and scope. The OAuth module signs a JWT with our
+private key claiming `iss=our-client-id`, `sub=our-client-id`,
+`aud=<platform-token-url>`, and POSTs it to the platform's
+`/login/oauth2/token` endpoint with `grant_type=client_credentials` and
+`scope=<requested-scopes>`. The platform validates against the public
+JWK we host at `/lti/jwks`, returns a short-lived bearer token
+(typically 1 hour), which we cache by `(platform_id, scope_set)`.
+
+**Canvas API call (refactored).** `CanvasClient` looks up the calling
+context's platform, requests a token for the scopes the call needs,
+and makes the HTTP request against that platform's API base URL. The
+client itself becomes platform-agnostic; the platform identity is
+threaded in from the caller.
+
+**JWKS publication (already implemented).** Canvas fetches our public
+JWK from `/lti/jwks` to verify the JWT we send during service-token
+requests, and also to verify our outgoing LTI Advantage assertions
+(NRPS, AGS) for the same reason. The same key pair signs both.
+
+## Data model
+
+The new persistence primitive is `PlatformInstall`. One record per
+unique Canvas instance that has launched our tool. Schema:
+
+```python
+@dataclass
+class PlatformInstall:
+    # Identity (composite primary key).
+    issuer: str               # e.g. "https://canvas.csueastbay.edu"
+    client_id: str            # the Developer Key id this platform issued us
+    deployment_id: str        # tool placement instance (one per install)
+
+    # Endpoints we use.
+    auth_token_url: str       # client-credentials endpoint
+    auth_login_url: str       # OIDC auth endpoint (for the launch dance)
+    jwks_url: str             # platform's JWKS, for validating launches
+    canvas_api_base: str      # https://canvas.csueastbay.edu/api/v1
+
+    # Discovered or pre-shared metadata.
+    canvas_domain: str        # bare hostname for logging
+    granted_scopes: list[str] # what this platform actually approved
+    label: str | None         # human-friendly name for ops dashboards
+
+    # Audit.
+    first_seen_at: datetime
+    last_launch_at: datetime
+```
+
+Records are written on every successful LTI launch (created if absent,
+updated otherwise). Redis storage with key
+`eq-pdf:platforms:{sha256(issuer+client_id+deployment_id)}` and a
+secondary index by `issuer` for the watcher to enumerate.
+
+The endpoint URLs come from one of three sources, in priority order:
+
+1. The launch JWT's `https://purl.imsglobal.org/spec/lti/claim/tool_platform`
+   claim, when present. Canvas includes `name` and `version` but not
+   the API URLs.
+
+2. The `iss` claim's host, mapped to canonical Canvas URLs:
+   `https://<host>/login/oauth2/token`,
+   `https://<host>/api/lti/authorize_redirect`,
+   `https://<host>/api/lti/security/jwks`,
+   `https://<host>/api/v1` for the data API.
+   This works for every Canvas instance because the URL conventions are
+   identical across Instructure-hosted and self-hosted Canvas.
+
+3. Manual override via a `platform_overrides.yaml` file shipped with the
+   container, for the rare self-hosted Canvas with non-standard URLs.
+
+## Service-token flow (detail)
+
+The client-credentials flow uses the JWT bearer client authentication
+profile (RFC 7521 + RFC 7523), which is what LTI Advantage requires.
+The request shape:
+
+```
+POST {platform.auth_token_url}
+Content-Type: application/x-www-form-urlencoded
+
+grant_type=client_credentials
+&client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
+&client_assertion=<signed JWT>
+&scope=<space-separated scopes>
+```
+
+The signed JWT's claims:
+
+```json
+{
+  "iss": "<our-client-id-for-this-platform>",
+  "sub": "<our-client-id-for-this-platform>",
+  "aud": "<platform.auth_token_url>",
+  "iat": <now>,
+  "exp": <now + 300>,
+  "jti": "<uuid4>"
+}
+```
+
+Signed with our RS256 private key, kid pointing at a key in our public
+JWKS. The platform validates the signature, confirms `iss == sub ==
+known client_id`, confirms `aud` matches its own token endpoint, and
+checks that the JTI has not been replayed within the last few minutes.
+
+Response on success:
+
+```json
+{
+  "access_token": "<bearer>",
+  "token_type": "Bearer",
+  "expires_in": 3600,
+  "scope": "<actual-granted-scopes>"
+}
+```
+
+The access token is cached in Redis with key
+`eq-pdf:service-token:{platform_id}:{scope_hash}` and TTL set to
+`expires_in - 30` seconds. The 30-second buffer avoids handing out a
+token that expires mid-request.
+
+Cache misses request a fresh token. Cache hits skip the network entirely
+and return the cached bearer. A 401 from Canvas invalidates the cache
+entry and retries once with a fresh token before surfacing the failure
+to the caller.
+
+## Per-tenant data isolation
+
+The current `tk()` helper prepends a fixed prefix (`eq-pdf:`) to every
+Redis key. This prevents collision with other apps on the same Redis
+but doesn't prevent collision between platforms.
+
+The refactor extends `tk()` to be platform-aware:
+
+```python
+def tk(suffix: str, *, platform: PlatformInstall | None = None) -> str:
+    """Build a tenant-prefixed Redis key.
+
+    Without a platform, returns the legacy prefix for ops keys
+    (queues, dead-letter, deployment metadata) that are not per-tenant.
+
+    With a platform, sandboxes the suffix under that platform's
+    issuer hash so two schools cannot read each other's data.
+    """
+    if platform is None:
+        return f"eq-pdf:{suffix}"
+    return f"eq-pdf:p:{platform.platform_id}:{suffix}"
+```
+
+Existing callsites pass `platform=...` from the request context. The
+session cookie carries the platform_id so per-request code can look it
+up without re-deriving from the issuer claim.
+
+Keys that stay shared (the alt-formats cache by content hash, the
+service-token cache by `platform_id` already, and rate-limit counters)
+remain at the unscoped prefix. Everything user-facing or course-facing
+(jobs, file processing state, consent records, NRPS rosters, dial
+scores) becomes platform-scoped.
+
+This is checked by a unit test that walks every callsite and asserts
+that "course_id" or "user_id" never appears in a key that isn't
+platform-prefixed.
+
+## Scope inventory
+
+These are the Canvas API scopes Reflow needs. Each is granted
+individually in the Developer Key UI and surfaced in `/lti/config.json`
+so admins see them at registration time:
+
+| Purpose | Scope |
+|---|---|
+| Discover PDFs in a course | `url:GET\|/api/v1/courses/:course_id/files` |
+| File metadata (size, type, modified_at) | `url:GET\|/api/v1/files/:id` |
+| List modules + module items | `url:GET\|/api/v1/courses/:course_id/modules` |
+| List pages + their bodies (for inline file refs) | `url:GET\|/api/v1/courses/:course_id/pages` |
+| Create accessible Page | `url:POST\|/api/v1/courses/:course_id/pages` |
+| Update accessible Page (faculty edits) | `url:PUT\|/api/v1/courses/:course_id/pages/:url_or_id` |
+| Publish accessible Page (approval) | `url:PUT\|/api/v1/courses/:course_id/pages/:url_or_id` |
+| Notify faculty | `url:POST\|/api/v1/conversations` |
+| Roster (NRPS, for pre-warming - Batch 6) | `https://purl.imsglobal.org/spec/lti-nrps/scope/contextmembership.readonly` |
+| Deep Linking (RCE picker, Batch 6) | `https://purl.imsglobal.org/spec/lti-dl/scope/lineitem` (or its readonly counterpart) |
+
+The first two are LTI Advantage standard scopes that come from IMS, not
+Canvas. The Canvas-specific scopes use Canvas's `url:METHOD|/api/...`
+shorthand.
+
+A first launch at a new school may arrive with **none** of these
+granted (the admin pasted the Developer Key but hasn't reviewed scopes
+yet). The tool surfaces this gracefully: the launch still succeeds, the
+review UI loads, and any API call that would require an ungranted scope
+returns a structured "permission_missing" response that the UI renders
+as "Ask your admin to grant Reflow the X scope" with a deep link to
+the Canvas Developer Key admin page.
+
+## Onboarding flow (admin perspective)
+
+A new school installs Reflow once:
+
+1. Admin gets the Reflow Developer Key JSON from us (production:
+   `https://reflow.equalify.app/lti/config.json`).
+
+2. Admin opens **Canvas → Admin → Developer Keys → + Developer Key →
+   LTI Key → Paste JSON**. Reviews the scopes list, accepts.
+
+3. Admin notes the resulting `client_id`, sends it to us so we can
+   record it in our platform registry (or, in the self-serve model,
+   our portal accepts the client_id and verifies via a test launch).
+
+4. Admin installs the tool at the desired scope (sub-account or
+   account-level) via **Settings → Apps → + App → By Client ID →
+   paste client_id → Install**.
+
+5. Admin places the tool wherever they want students/faculty to see it:
+   course navigation, the RCE toolbar, account-level redirects.
+
+6. The first launch from anywhere in that institution creates a
+   `PlatformInstall` record on our side. Subsequent launches just
+   update `last_launch_at`. Faculty consent flow runs once per faculty.
+
+What we never ask for at any point: an admin user's API token, an SSH
+key, a webhook receiver URL on their network, or anything that grants
+us privileges beyond the scopes they reviewed in step 2. This is the
+property that gets us through procurement.
+
+## Migration plan (from current state)
+
+Seven phases, sequenced by dependency. Each phase can land behind a
+feature flag (`MULTI_TENANT_AUTH=true` or per-component flags) so the
+existing single-tenant path keeps working until the new path is
+proven.
+
+**Phase 1: PlatformInstall data model.** Build the dataclass, the
+Redis storage helpers, the upsert call from the LTI launch handler.
+No behavior change yet — the records are written but nothing reads
+them. Includes a CLI (`scripts/list_platforms.py`) for ops visibility.
+*Estimate: 2 hours.*
+
+**Phase 2: `canvas/oauth.py` service-token client.** Implement the JWT
+bearer client-credentials flow against a single platform (the one
+configured in env). Add the Redis token cache. Add a `--test` flag to
+the CLI to mint a token and dump the response for diagnostic use.
+*Estimate: 3 hours.*
+
+**Phase 3: `CanvasClient` refactor.** Add a constructor that takes a
+`PlatformInstall` + a required scope, internally calls the oauth
+module, drops the constructor-level api_token in favor of per-call
+scoped tokens. Keep the env-token constructor signature alive for one
+release as the dev fallback. *Estimate: 2 hours.*
+
+**Phase 4: Developer Key scope list.** Update `/lti/config.json` with
+the full scope inventory from section 7. Mint a new Developer Key in
+canvas.test.instructure.com with the new scopes. Verify a service
+token request returns the expected `scope` field. *Estimate: 30 min
++ Canvas UI work.*
+
+**Phase 5: Watcher refactor.** Watcher iterates `PlatformInstall`
+records × the courses each has touched (derived from the
+`canvas:course:{course_id}:processed` set we already maintain, now
+namespaced by platform). Each course scan uses a `CanvasClient`
+constructed for that platform. *Estimate: 3 hours.*
+
+**Phase 6: Bridge worker refactor.** Same shape as the watcher.
+Bridge looks up the platform from the job record, constructs a
+`CanvasClient` for it, creates the page. *Estimate: 2 hours.*
+
+**Phase 7: Per-platform Redis prefixing.** Extend `tk()` to accept
+a platform, audit every callsite, update tests. This is the riskiest
+phase because it touches every read and write; it lands last and
+behind a "dual-read" flag (read from both old and new prefixes
+during the cutover window). *Estimate: 4 hours including the audit.*
+
+**Total: ~17 hours, sequenced over 2-3 working days.**
+
+The single-tenant code path is removed in a follow-up release after at
+least one real second school is running on the multi-tenant path in
+production, to avoid burning a bridge before the new one is load-tested.
+
+## Security considerations
+
+**Private key storage.** The RSA-2048 key that signs everything lives
+in `/tmp/lti_private.pem` today, regenerated on every container start
+— fine for a dev MVP, fatal for production. The Fargate Terraform
+module (Batch 7) already wires up an AWS Secrets Manager secret
+intended to hold this key. The migration to production should set
+that up *before* the first non-test deployment so we don't end up
+with a long-lived key floating in a container layer.
+
+**Key rotation.** The JWKS endpoint should serve multiple keys with
+overlapping validity windows so we can rotate without a flag day.
+Concretely: a new key gets published in JWKS 24 hours before it
+becomes the signing key, and the previous key remains in JWKS for
+24 hours after a new one starts signing. Canvas refetches JWKS on
+signature failure, so this gives us a smooth rotation. Implementation
+is a small daemon that rolls the active key kid in Redis and the
+JWKS endpoint reads the union of active and recently-retired keys.
+
+**Scope creep.** Every scope we add to `/lti/config.json` after
+release will require every existing institution's admin to manually
+re-approve the Developer Key. Treat the scope list as an immutable
+public API and only add scopes through a deliberate versioning bump.
+The internal review process for "do we need this scope" should be
+gated on the same severity as a database migration.
+
+**Per-platform incident isolation.** If Canvas at school A starts
+returning malformed responses or invalid tokens, the bridge worker
+should not stall the queue for schools B-Z. Each platform gets its
+own work queue partition (Redis stream) so backpressure on one
+doesn't propagate. This is a Phase 5/6 implementation detail but
+worth calling out as a design constraint.
+
+**Audit log.** Every service-token request, every Canvas API call,
+and every Page creation/publish should write a structured log line
+with `(platform_id, user_id, course_id, scope, http_status,
+latency_ms, request_id)`. Ship those to whatever log aggregator the
+production environment uses. The motivation is that when an admin
+asks "what did Reflow do in our Canvas yesterday", we need to answer
+within five minutes from data, not from memory.
+
+## Open questions
+
+A few decisions to make before Phase 1 starts:
+
+**Should `PlatformInstall` records be revocable from our side?** A
+school can revoke us by deleting the Developer Key on their end, but
+should we also be able to mark a platform as "frozen" from the ops
+console (e.g. during a security incident at that school)? Recommend
+yes, with a `revoked_at` field that causes the launch handler to
+refuse new launches but lets the bridge finish in-flight jobs.
+
+**Where does the platform registry live in production?** Redis is
+fine for the cache layer but the canonical registry should arguably
+be a real database (Postgres) for backup, point-in-time recovery, and
+external query. The MVP can run on Redis; the production cutover
+should migrate the registry to RDS at the same time as the rest of
+the persistence layer moves off Redis-only.
+
+**Self-serve install vs. white-glove install for the first few
+schools?** A self-serve portal where admins paste their client_id and
+verify via a test launch is the right end state, but for the first
+3-5 schools we should do white-glove (we accept the client_id over
+email, manually create the record) so we can sit in on each
+institution's procurement conversation and learn what they actually
+ask about. Recommend white-glove until at least 5 schools are
+running, then build the self-serve portal.
+
+**Deep Linking placement decisions.** The Batch 6 deferred work
+includes both RCE Deep Linking and an account-level redirect. The
+multi-tenant model should make those installable independently — a
+school that only wants the RCE picker shouldn't be forced to enable
+the redirect. This is a Developer Key config question more than an
+auth-architecture question, but worth flagging.
+
+**LTI Names and Roles Service (NRPS) caching.** NRPS pulls a course
+roster. If the watcher pre-warms by fetching NRPS for every active
+course on every platform, that's a lot of API calls. Recommend
+caching NRPS results for 1 hour and only refreshing on cache miss
+or explicit roster-change events. The cache key includes the platform
+and course; the cache invalidator listens for `context_membership`
+events from Canvas Live Events when those become available.
diff --git a/docs/explanation/production-readiness.md b/docs/explanation/production-readiness.md
new file mode 100644
index 0000000..a500d6d
--- /dev/null
+++ b/docs/explanation/production-readiness.md
@@ -0,0 +1,403 @@
+# Equalify Reflow for Canvas — Production Brief
+
+A reference for the conversation with your manager. Covers the entire
+stack — Reflow's PDF-to-accessible-content pipeline plus the Canvas
+integration that surfaces it inside the LMS. Honest about what works,
+what's still PoC, what to budget, and the open questions.
+
+## Updates since v1 (May 2026)
+
+Three architectural decisions have been locked in since this brief was
+first drafted, and each strengthens the production-readiness story:
+
+1. **Hosting: AWS Fargate (not campus VM).** ECS Fargate runs the
+   api-gateway and docling-serve containers inside a dedicated VPC, with
+   ALB in front, ElastiCache Redis behind, and S3/Polly/Bedrock attached
+   via IAM task role. Multi-AZ, autoscaling, IaC-deployable.
+2. **Scope: new uploads only.** Reflow processes documents as faculty
+   upload them — no backfill of the existing catalog. Keeps Claude API
+   spend predictable and avoids the InfoSec discussion about retroactive
+   processing of historical course content.
+3. **Faculty consent / disclaimer flow live in code.** First launch shows
+   a versioned disclaimer; faculty must acknowledge before any Claude
+   API call. Audit log captures every acknowledgment. This eliminates
+   the "silent processing" objection from compliance review.
+
+Diagrams supporting this brief are in `briefs/diagrams/`:
+`01-fargate-arch.png`, `02-data-flow.png`, `03-consent-flow.png`,
+`04-cost-comparison.png`, `05-timeline-gantt.png`.
+
+## What the project is, end to end
+
+Two open-source projects working together as one deployment:
+
+**Equalify Reflow** (upstream, built with University of Illinois Chicago,
+AGPL-3.0): A FastAPI service that ingests PDFs and outputs accessible,
+semantic markdown. It runs a five-phase pipeline:
+
+1. **Extraction** — IBM Docling does the document parse + OCR fallback
+2. **Analysis** — Claude classifies pages, identifies headings, footnotes, code blocks
+3. **Headings** — Claude reconciles heading hierarchy across pages
+4. **Translation** — Claude fixes per-page content and tags code blocks
+5. **Assembly** — cross-page boundary fixes, final cleanup
+
+Output: clean markdown with proper headings, alt text on images, real
+tables (not images), extracted figures stored in S3. PII is scanned
+with Microsoft Presidio before any AI processing; flagged PDFs require
+explicit instructor approval before continuing.
+
+**Canvas Integration** (this PR, on top of Reflow): An LTI 1.3 tool
+that auto-detects every PDF uploaded anywhere in a Canvas course,
+submits it to Reflow, and surfaces an accessibility score dial +
+alternative-format menu next to every PDF link — a Panorama-style
+overlay. Includes a faculty HTML editor (critical for STEM content)
+that turns the accessible HTML into the single source of truth for
+every downstream format.
+
+## The stack at a glance
+
+```
+                ┌────────────────────────────────────┐
+                │           Canvas LMS                │
+                │  Files · Modules · Pages ·          │
+                │  Discussions · Assignments · Quizzes │
+                └────┬────────────────────┬──────────┘
+                     │ LTI 1.3            │ API v1
+                     │ launches            │ + Theme JS overlay
+                     ▼                     ▼
+              ┌──────────────────────────────────┐
+              │   FastAPI Service (single app)    │
+              │                                    │
+              │  ┌──────────┐  ┌──────────────┐  │
+              │  │ Reflow   │  │ Canvas       │  │
+              │  │ pipeline │  │ integration  │  │
+              │  │ + viewer │  │ + LTI + alt  │  │
+              │  └────┬─────┘  │ formats      │  │
+              │       │        └──────┬───────┘  │
+              │       │               │           │
+              │       └──── workers ──┘           │
+              └──┬──────────────────┬─────────────┘
+                 │                   │
+        ┌────────▼──┐   ┌────────────▼─────────┐
+        │  Redis    │   │  AWS S3 or Floci      │
+        │  jobs +   │   │  PDFs, markdown,      │
+        │  state    │   │  extracted figures    │
+        └───────────┘   └──────────────────────┘
+                 │
+        ┌────────▼─────────────────┐
+        │  AI Provider              │
+        │  Anthropic API OR         │
+        │  AWS Bedrock (Claude)     │
+        └──────────────────────────┘
+
+        Optional sidecars:
+          Docling-serve (PDF extraction)
+          Polly (audio MP3)
+          Prometheus + Grafana + Jaeger
+```
+
+Everything is one Docker Compose stack. Same FastAPI app serves the
+Reflow API, the LTI endpoints, the Panorama-style overlay, the review
+queue, the alt-format renderers, and the faculty HTML editor.
+
+## Current state, end-to-end honest
+
+What's running in CSUEB's test instance right now over an ngrok tunnel:
+
+- **Reflow pipeline** — works through PII scan and document classification.
+  The AI agents stage stops without an API key, so jobs never reach the
+  "completed" state.
+- **Canvas watcher** — already pulled four PDFs from the test course's
+  Files into Reflow. Scans 8 surfaces (Files, all folders, modules,
+  pages, discussions, announcements, assignments, quizzes, syllabus).
+- **LTI 1.3 launch** — Confirmed working. Instructors click "Accessible
+  Documents" in the course nav and land in the review queue.
+- **Panorama-style overlay** — Dial + Alternative Formats Menu render on
+  Files index, Modules, and any /files/X anchor. Tested in CSUEB.
+- **Alternative formats** — HTML, Plain Text, Markdown, ePub, HTML with
+  MathJax, OCR'd PDF, Tagged PDF/A are all wired and serve. Audio (MP3)
+  requires AWS Polly. Translations require the AI key.
+- **Faculty HTML editor** — Side-by-side editor with live MathJax
+  preview. Saves edits to Redis; every downstream format then derives
+  from the edited HTML.
+
+What's NOT finished:
+
+- **No AI key in CSUEB test**, so Reflow jobs stall at the AI step.
+  Score dials show the placeholder 15% (one signal default). With a
+  key, real scores flow in.
+- **Score model** uses placeholder signals. Reflow's pipeline needs a
+  follow-up to surface real accessibility flags (text-layer present,
+  heading hierarchy, alt-text coverage, etc.) in its status payload.
+  Estimate: half a day.
+- **Bridge worker** has a Floci-specific S3 URL bug (uses localhost:4566
+  instead of floci:4566). Harmless against real AWS S3. Two-line fix.
+- **Tests** for the new endpoints aren't written yet.
+- **Canvas Live Events** for real-time discovery isn't wired; we poll
+  every 60s. Acceptable for pilot, should move to Live Events for scale.
+
+## What you need to ship to production
+
+### 1. Hosting — AWS Fargate (decided)
+
+Public HTTPS URL replacing the ngrok tunnel. We're hosting on AWS Fargate
+in a dedicated CSUEB sub-account or VPC in us-west-2. The stack is one
+docker-compose application in development that maps cleanly to Fargate
+in production:
+
+- **api-gateway** (Python 3.11, FastAPI) — main service, ECS Fargate task (0.5 vCPU / 1 GB at pilot, autoscale 1→4 tasks)
+- **docling-serve** — PDF extraction sidecar, ECS Fargate task (1 vCPU / 4 GB)
+- **ElastiCache Redis** — job state, queues, sessions, consent records, faculty edits cache. Multi-AZ replicated at campus scale.
+- **AWS S3** — file storage (source PDFs + generated outputs)
+- **Application Load Balancer** with ACM cert in front of api-gateway tasks
+- **CloudWatch** for logs and alarms — `/health` alarm + cost budget alarms
+
+See `briefs/diagrams/01-fargate-arch.png` for the architecture overview.
+
+Why Fargate over campus VM:
+- Production-grade from day 1 — no painful migration mid-pilot.
+- Multi-AZ failover, autoscaling, IAM task role (no long-lived keys).
+- AWS handles OS patching; CSUEB IT does not own that burden.
+- Cleanest IAM boundary the ISO can audit.
+
+Terraform / CDK module will be provided so the whole stack stands up
+from a single `apply` — no click-ops.
+
+### 2. Canvas access
+
+- **Production Developer Key** in CSUEB Canvas (not the test instance).
+  Same JSON config the test key used — paste the URL of the production
+  tool's `/lti/config.json`. Get back a client_id and a deployment_id.
+- **Service-account API token**. Today's token is on your personal
+  user; for prod we want a dedicated `accessibility-service@csueb.edu`
+  account, Account Admin or sub-account admin, with permissions to
+  read every file in watched courses. No-expiry token.
+- **Theme JavaScript** pasted into the institution-wide or sub-account
+  custom JS. One line:
+  ```html
+  <script src="https://reflow.csueb.edu/lti/panorama.js?inst=csueb" defer></script>
+  ```
+
+### 3. AI provider (required for Reflow to actually work)
+
+Pick one:
+
+- **Anthropic API** — `sk-ant-...` key. ~$0.0008 per typical 30-page
+  PDF (Claude Haiku 4.5). $0.80 per 1000 documents. Simplest. Set
+  `ANTHROPIC_API_KEY` in env.
+- **AWS Bedrock** with Claude Haiku 4.5 access. Same per-document
+  cost. Requires `bedrock:InvokeModel` IAM. Set `AI_PROVIDER=bedrock`.
+
+### 4. AWS resources
+
+Required for prod (Reflow needs S3 for file storage):
+
+- Two S3 buckets: `csueb-reflow-temp` (uploaded PDFs) and
+  `csueb-reflow-results` (markdown + extracted figures). Lifecycle
+  rule to auto-delete `temp/` after 24h. Cost: ~$5–15/mo.
+- IAM user or role with `s3:GetObject`, `s3:PutObject`,
+  `s3:DeleteObject` on those two buckets.
+
+Optional (for audio):
+- Polly with `polly:SynthesizeSpeech`. Costs ~$4 per 1M characters
+  with the neural engine. A 30-page PDF is ~50k characters, so
+  $0.20 per audio render. Heavily cacheable.
+
+### 5. The full env (concrete)
+
+```
+# Reflow core
+ANTHROPIC_API_KEY=sk-ant-...
+S3_TEMP_BUCKET=csueb-reflow-temp
+S3_RESULTS_BUCKET=csueb-reflow-results
+AWS_ACCESS_KEY_ID=...
+AWS_SECRET_ACCESS_KEY=...
+AWS_DEFAULT_REGION=us-west-2
+REDIS_URL=redis://<prod-redis-host>:6379
+API_KEYS=<one secret API key for internal calls>
+
+# Canvas integration
+LTI_ENABLED=true
+LTI_ISSUER=https://canvas.instructure.com
+LTI_PUBLIC_URL=https://reflow.csueb.edu
+LTI_AUTH_LOGIN_URL=https://sso.canvaslms.com/api/lti/authorize_redirect
+LTI_AUTH_TOKEN_URL=https://sso.canvaslms.com/login/oauth2/token
+LTI_JWKS_URL=https://sso.canvaslms.com/api/lti/security/jwks
+LTI_CLIENT_ID=<prod-issued>
+LTI_DEPLOYMENT_ID=<prod-issued>
+LTI_PRIVATE_KEY_PATH=/app/keys/lti_private.pem
+LTI_PUBLIC_KEY_PATH=/app/keys/lti_public.pem
+CANVAS_API_URL=https://csueb.instructure.com
+CANVAS_API_TOKEN=<service-account-token>
+CANVAS_WATCHED_COURSES=                      # empty = all courses
+CANVAS_ALLOWED_ORIGINS=https://csueb.instructure.com
+CANVAS_POLL_SECONDS=60
+```
+
+LTI signing keys generated once and persisted to a mounted volume:
+
+```
+docker compose exec api-gateway uv run python -m src.lti.keys generate
+```
+
+## Operations
+
+- **Logging**: structured JSON to stdout. Capture via CloudWatch,
+  journald, or your container platform's native logging.
+- **Metrics**: Prometheus on `:8001/metrics`. Dashboards live in
+  `infrastructure/grafana/`. Tracks Reflow pipeline phase timing,
+  Canvas API call latency, watcher discoveries, AI cost per request.
+- **Health**: `/health` returns Redis, S3, docling-serve status and
+  queue depth.
+- **Tracing**: OpenTelemetry baked in. Point at Jaeger or any OTLP
+  collector.
+- **Backups**: Redis is the canonical store for job metadata AND
+  faculty-edited HTML. Run RDB snapshots to S3 nightly. When edit
+  volume grows, migrate edited HTML to S3 too.
+- **Secrets**: `.env` for a single VM. AWS Secrets Manager for ECS/EKS.
+  LTI private key must be on persistent volume.
+- **Scaling**: Stateless API gateway — replicate behind a load
+  balancer. Redis stays single-instance until you outgrow it.
+  Docling can be replicated; it's CPU-heavy.
+
+## Security and compliance
+
+- **FERPA**: Reflow's pipeline PII-scans every document with
+  Microsoft Presidio before AI processing. PII-flagged docs require
+  explicit instructor approval before continuing. No PII reaches
+  Anthropic / Bedrock without that approval.
+- **Authentication**: LTI 1.3 JWT-signed launches verified against
+  Canvas's JWKS. Faculty identity proven by Canvas; we store no
+  passwords.
+- **Canvas API token**: Service-account-scoped. Revoke and re-issue
+  if compromised.
+- **CSP**: Theme JS bundle injects no third-party scripts on Canvas
+  pages except MathJax (CDN) inside the editor's iframe.
+- **AGPL-3.0 licence**: Cal State's internal use is fine. If you
+  ever host this for external institutions you'd need to publish
+  changes — standard AGPL boundary.
+
+## Costs (single-college pilot)
+
+| Item | Monthly |
+|---|---|
+| Hosting (campus VM or Fargate) | $50–$120 |
+| AWS S3 + bandwidth | $5–$15 |
+| Anthropic / Bedrock AI (1000 PDFs/mo) | $1–$5 |
+| Polly audio (500 renders/mo) | ~$100 |
+| **Total** | **~$160–$240/mo** |
+
+YuJa Panorama for the same scope is typically $30k–$60k/year per
+campus. The cost gap pays for the engineer maintaining this twice over.
+
+## Honest gaps vs. YuJa Panorama
+
+- **Math engine** — Panorama has a dedicated math accessibility
+  engine. We fall back on Reflow's markdown + MathJax. Works for ~80%
+  of math content; complex equations may need faculty edits.
+- **Immersive Reader** — Microsoft-hosted, requires Azure
+  subscription. We have a "soon" card for it; easy add once Azure
+  resource exists.
+- **Braille (BRF)** — Needs `liblouis` system library. One
+  engineer-day to wire up.
+- **Institution-wide analytics dashboard** — Panorama has a campus
+  scorecard. We have per-course dashboard; aggregate is Phase 2.
+- **AutoPilot Remediation** — Panorama can auto-fix some issues. Our
+  closest equivalent is the faculty HTML editor — instructors edit
+  manually with AI assistance available, but not a fully automated
+  fix-everything button.
+- **24/7 vendor support** — Panorama is paid with SLAs. This is
+  open source; Cal State owns maintenance.
+- **1EdTech certification** — Panorama has it; we implement LTI 1.3
+  but aren't certified.
+
+## Maintenance commitment
+
+- **0.25–0.5 FTE** engineering: keeping up with Canvas API changes
+  (Instructure ships breaking changes 2–3x per year), monitoring,
+  bug fixes, format additions.
+- **Quarterly Canvas regression test** on Instructure's major
+  releases. ~1 day of QA per quarter.
+- **Reflow upstream** is on AGPL with active UIC community; tracking
+  releases is straightforward.
+
+## Likely manager questions
+
+**Q: Why not buy YuJa Panorama?**
+A: $30–60k/year/campus vs. ~$200/mo + a quarter of an engineer. For
+CSUEB alone the savings cover the engineer. Across the CSU system the
+savings are substantial. The trade-off: own the maintenance, accept
+~80% feature parity, no vendor SLA.
+
+**Q: What happens if the engineer leaves?**
+A: Codebase is open source FastAPI + React, conventional Python. Any
+mid-level Python engineer can take over. Docs are in `docs/`. Reflow
+upstream is actively maintained by UIC.
+
+**Q: Is it secure?**
+A: LTI 1.3 JWT validation, PII scanning before AI, AGPL means
+auditable. Faculty data stays in Canvas + Reflow S3. The AI providers
+(Anthropic / AWS) are the same ones already in use by GitHub Copilot,
+Notion, and most CSU faculty's personal ChatGPT.
+
+**Q: What if Canvas changes their API?**
+A: We use stable Canvas API v1. Instructure deprecates with 6+ months
+notice. The watcher scans 5 surfaces independently — partial breakage
+is graceful.
+
+**Q: Can we pilot in one department?**
+A: Yes. Set `CANVAS_WATCHED_COURSES` to that department's course IDs
+(or apply theme JS to a single sub-account). Cost stays under
+$50/mo for a single-department pilot.
+
+**Q: How does this compare to UDOIT (which CSUEB already has)?**
+A: UDOIT scans HTML content for accessibility issues and reports.
+It does NOT auto-convert PDFs to accessible alternatives. They're
+complementary — keep UDOIT for HTML content, add Reflow for PDFs.
+Both can run in the same Canvas theme JS without conflict (already
+verified in CSUEB test).
+
+**Q: What about student privacy with the AI provider?**
+A: PDFs going through Reflow have already been PII-scanned. If PII
+is found, the instructor approves before AI processing. Anthropic
+and AWS Bedrock both offer enterprise data-handling agreements that
+exclude training on customer data — sign one of those if not already
+in place.
+
+**Q: How long would a pilot take?**
+A: 2 days for IT to stand up production hosting + Canvas Developer
+Key registration. 1 day for theme JS + LTI install. 1 week of shadow
+testing against pilot courses. Open to instructors with a 30-min
+training. Total: ~2 weeks from approval to faculty access.
+
+## What I need from your manager
+
+1. **Approval** for a 2-month pilot in one or two departments.
+2. **Hosting decision** (campus VM vs AWS Fargate).
+3. **AI provider procurement** (Anthropic key, or AWS Bedrock access).
+4. **Sponsorship** for a service-account Canvas user.
+5. **~5 days of IT / Instructional Technology time** for prod LTI
+   install, theme JS deployment, and TLS cert setup.
+
+## Concrete next steps if approved
+
+1. Stand up production host with TLS certificate.
+2. Register prod Canvas Developer Key + install in pilot sub-account.
+3. Provision AI key (Anthropic or Bedrock).
+4. Create S3 buckets and IAM user/role.
+5. Generate LTI signing keys; persist to volume.
+6. Paste theme JS into pilot sub-account theme.
+7. Run a 1-week shadow test against a handful of pilot courses.
+8. Train pilot instructors (30-min session).
+9. Open it to faculty.
+
+Month 2: expand to additional departments based on pilot feedback.
+
+## Repositories and references
+
+- Reflow upstream: github.com/EqualifyEverything/equalify-reflow
+- This integration's docs: `docs/explanation/canvas-lti-integration.md`
+- Install runbook: `docs/how-to/install-canvas-integration.md`
+- Architecture: `docs/explanation/architecture.md`
+- API reference: live at `<host>/docs` (Swagger)
+- Reflow paper / blog: links from the UIC team
diff --git a/docs/how-to/install-canvas-integration.md b/docs/how-to/install-canvas-integration.md
new file mode 100644
index 0000000..5233a6e
--- /dev/null
+++ b/docs/how-to/install-canvas-integration.md
@@ -0,0 +1,82 @@
+# How to install the Canvas integration
+
+This recipe walks a Canvas admin through enabling the Equalify Reflow integration on a Canvas instance. End state: PDFs uploaded into watched courses are automatically converted into accessible Canvas Pages awaiting instructor review, and Canvas pages decorate file links with accessibility gauges and an alternative-format picker.
+
+You will need: admin access to the Canvas instance, an Equalify Reflow API key, and the ability to set environment variables on the Reflow deployment.
+
+## 1. Generate the LTI signing keys
+
+Inside a running api-gateway container:
+
+```bash
+docker compose exec api-gateway uv run python -m src.lti.keys generate
+```
+
+This writes `lti_private.pem` and `lti_public.pem` under the path set by `LTI_PRIVATE_KEY_PATH` / `LTI_PUBLIC_KEY_PATH` (defaults: `/app/keys/`). Mount that directory as a persistent volume in production — losing the private key forces a re-registration.
+
+## 2. Configure environment
+
+Edit your `.env` (or environment secrets store) with at minimum:
+
+```
+LTI_ENABLED=true
+LTI_ISSUER=https://<your-canvas-host>
+LTI_CLIENT_ID=<set after step 3>
+LTI_DEPLOYMENT_ID=<set after step 3>
+LTI_AUTH_LOGIN_URL=https://<your-canvas-host>/api/lti/authorize_redirect
+LTI_AUTH_TOKEN_URL=https://<your-canvas-host>/login/oauth2/token
+LTI_JWKS_URL=https://<your-canvas-host>/api/lti/security/jwks
+LTI_PUBLIC_URL=https://reflow.<your-domain>
+
+CANVAS_API_URL=https://<your-canvas-host>
+CANVAS_API_TOKEN=<long-lived token from step 4>
+CANVAS_WATCHED_COURSES=<csv of course ids — leave empty until you have a pilot course>
+CANVAS_ALLOWED_ORIGINS=https://<your-canvas-host>
+```
+
+Restart the api-gateway container so the new settings load.
+
+## 3. Register the LTI 1.3 Developer Key in Canvas
+
+In Canvas, go to **Admin → Developer Keys → + Developer Key → + LTI Key**.
+
+Choose **Method = Paste JSON** and paste the body of:
+
+```
+https://reflow.<your-domain>/lti/config.json
+```
+
+Save. Copy the resulting **Client ID** into `LTI_CLIENT_ID`. Restart the api-gateway. Then, still under Developer Keys, set the **State** of the new key to **On**.
+
+In **Admin → Settings → Apps → +App**, install the tool using the Client ID just created. The deployment ID Canvas shows on the install page goes into `LTI_DEPLOYMENT_ID`. Restart again.
+
+## 4. Create a service Access Token
+
+A Canvas user (best practice: a dedicated `accessibility-service@yourschool.edu` account, with the Account Admin role) generates a long-lived token via **Account → Settings → New Access Token**. Paste it into `CANVAS_API_TOKEN`.
+
+## 5. Enable the Panorama-style overlay (optional but recommended)
+
+In Canvas, go to **Admin → Themes → Edit current theme → JavaScript file** and paste:
+
+```html
+<script src="https://reflow.<your-domain>/lti/panorama.js?inst=<your-inst-slug>" defer></script>
+```
+
+Save and apply to a sub-account or the whole institution. Every page load now decorates PDF links with accessibility gauges (for instructors) and an alternative-format picker (for everyone).
+
+## 6. Pilot on a single course
+
+Add a Canvas course id to `CANVAS_WATCHED_COURSES`. Within `CANVAS_POLL_SECONDS` (default 60), uploaded PDFs in that course start moving through Reflow. When a job completes, an unpublished Page is created and the uploader gets a Canvas Inbox message linking back to the LTI review UI.
+
+## 7. Validate end to end
+
+1. Upload a sample PDF to the pilot course.
+2. Within ~60 seconds, confirm `GET /canvas/review/api/pending?course_id=<id>` (called from the LTI launch) lists the file.
+3. Wait for Reflow to finish (~5 minutes).
+4. Confirm an unpublished Canvas Page appears and the instructor receives an Inbox message.
+5. Launch the LTI tool from Canvas Navigation, review, approve, and confirm the Page is published.
+6. Reload any Files page in the pilot course and confirm the gauge appears next to the PDF.
+
+## Phase 5 (later): switch from polling to Canvas Live Events
+
+Canvas's Live Events ship file-upload events to an SQS queue. Once your Canvas Data Services account is provisioned, set `CANVAS_LIVE_EVENTS_QUEUE_URL` and disable the poller by setting `CANVAS_WATCHED_COURSES=` (empty). The bridge worker continues to drive Reflow jobs to completion regardless of which source delivered them.
diff --git a/docs/how-to/multi-tenant-diagnostics.md b/docs/how-to/multi-tenant-diagnostics.md
new file mode 100644
index 0000000..c904330
--- /dev/null
+++ b/docs/how-to/multi-tenant-diagnostics.md
@@ -0,0 +1,274 @@
+# Multi-tenant migration: tomorrow's diagnostic guide
+
+All 7 phases of the multi-tenant migration are implemented and unit-verified
+against fake Redis and mocked Canvas. This document is the runbook for
+flipping it into the live stack and diagnosing whatever Canvas tells us
+when real traffic hits it.
+
+## What landed
+
+The full list of files changed or created tonight:
+
+| File | Status | Purpose |
+|---|---|---|
+| `src/lti/platform.py` | new | `PlatformInstall` dataclass + endpoint derivation |
+| `src/lti/platform_store.py` | new | Redis CRUD + course-platform map |
+| `src/lti/routes.py` | edited | Launch handler auto-upserts platform + course |
+| `src/canvas/oauth.py` | new | LTI Advantage client-credentials token client |
+| `src/canvas/client.py` | rewritten | Adds `CanvasClient.from_platform()` + 401 retry |
+| `src/canvas/state.py` | edited | `CanvasJob.platform_id` field added |
+| `src/canvas/tenant.py` | edited | `tk(suffix, platform=...)` per-tenant prefix |
+| `src/workers/canvas_watcher.py` | edited | Iterates platforms x courses behind flag |
+| `src/workers/reflow_bridge_worker.py` | edited | Picks per-job Canvas client |
+| `src/config.py` | edited | `multi_tenant_watcher` boolean flag |
+| `scripts/list_platforms.py` | new | Ops CLI: `python -m scripts.list_platforms` |
+| `scripts/test_service_token.py` | new | Ops CLI: mint a token to test the flow |
+
+## Step 1: restart the stack
+
+> **Architecture note**: the watcher and reflow-bridge run as background
+> asyncio tasks inside the api-gateway process, not as separate services.
+> One `docker compose up api-gateway` restarts all three.
+
+
+```powershell
+$env:COMPOSE_FILE = "docker-compose.yml;docker-compose.dev.yml"
+docker compose up -d --force-recreate api-gateway
+Start-Sleep 10
+docker compose exec api-gateway sh -c "openssl genrsa -out /tmp/lti_private.pem 2048 && openssl rsa -in /tmp/lti_private.pem -pubout -out /tmp/lti_public.pem"
+docker compose logs --tail=20 api-gateway
+```
+
+If any of the three containers crash on boot, paste the traceback. Most
+likely failure mode: a Pydantic validation error because the new
+`multi_tenant_watcher` field collided with something in `.env`. Should
+be defaulted to `False` so unset is fine.
+
+## Step 2: trigger a launch + confirm Phase 1 still works
+
+Click **Accessible Documents** in Canvas. Then:
+
+```powershell
+docker compose exec api-gateway uv run python -m scripts.list_platforms
+```
+
+Expected: one row showing the canvas.test.instructure.com platform.
+The `LAST LAUNCH` column updates on every click. The `platform_id`
+will be a stable 16-char hash; copy it for step 3.
+
+If you see zero rows, the launch upsert failed silently. Search logs
+for `PlatformInstall upsert failed`:
+
+```powershell
+docker compose logs api-gateway | Select-String "PlatformInstall"
+```
+
+## Step 3: test the service-token exchange (Phase 2)
+
+This is the critical step — it's where real Canvas first sees our
+multi-tenant work.
+
+```powershell
+docker compose exec api-gateway uv run python -m scripts.test_service_token
+```
+
+Three outcomes:
+
+**Outcome A — OK.** You see `granted_scope:` populated with the scopes
+that were granted in the Developer Key. Everything works end-to-end.
+Proceed to step 4.
+
+**Outcome B — `invalid_client` or `unauthorized_client`.** The
+Developer Key in Canvas doesn't know about our current JWKS. This
+happens because:
+
+  - The container was restarted, regenerating `/tmp/lti_private.pem`,
+    which gave the JWKS endpoint a new public key with a new `kid`.
+  - Canvas's cached JWKS still has the old key, so signature
+    verification fails.
+
+Fix: in Canvas, go to **Admin → Developer Keys → find the Reflow key →
+edit → click the public_jwk_url** to force a fresh fetch. Or wait
+~10 minutes for Canvas's TTL to expire. Or stop regenerating the
+keypair on every restart (Step 6 below).
+
+**Outcome C — `invalid_scope` / `unauthorized_scope`.** The token
+exchange is working but no scopes are granted. Open the Developer Key
+in Canvas, click **Edit**, scroll to the **Scopes** tab. You should
+see the full list from `/lti/config.json` (Phase 4 work). Check each
+of the 14 scopes we declared:
+
+```
+url:GET|/api/v1/courses/:course_id/files
+url:GET|/api/v1/courses/:course_id/folders
+url:GET|/api/v1/courses/:course_id/modules
+url:GET|/api/v1/courses/:course_id/modules/:module_id/items
+url:GET|/api/v1/courses/:course_id/pages
+url:GET|/api/v1/courses/:course_id/pages/:url_or_id
+url:GET|/api/v1/courses/:course_id/discussion_topics
+url:GET|/api/v1/courses/:course_id/discussion_topics/:topic_id/entries
+url:GET|/api/v1/courses/:course_id/assignments
+url:GET|/api/v1/courses/:course_id/quizzes
+url:GET|/api/v1/files/:id
+url:GET|/api/v1/folders/:id/files
+url:POST|/api/v1/courses/:course_id/pages
+url:PUT|/api/v1/courses/:course_id/pages/:url_or_id
+url:POST|/api/v1/conversations
+```
+
+Plus two IMS standard scopes:
+
+```
+https://purl.imsglobal.org/spec/lti-nrps/scope/contextmembership.readonly
+https://purl.imsglobal.org/spec/lti-ags/scope/lineitem.readonly
+```
+
+(If the scopes list shows the OLD empty array, Canvas is caching the
+old `/lti/config.json`. You may need to **delete + recreate the
+Developer Key**, pasting the fresh JSON.)
+
+Save the Developer Key. Re-run `test_service_token` — should now
+return `OK` with `granted_scope:` populated.
+
+## Step 4: flip the watcher into multi-tenant mode (Phase 5)
+
+In `.env`, add:
+
+```
+MULTI_TENANT_WATCHER=true
+```
+
+Then restart just the watcher:
+
+```powershell
+docker compose up -d --force-recreate api-gateway
+docker compose logs --tail=15 api-gateway | Select-String watcher
+```
+
+Expected log line on boot:
+
+```
+INFO Canvas watcher: multi-tenant mode enabled
+```
+
+The watcher will now iterate every platform × every course mapped to
+that platform. To verify which courses it found:
+
+```powershell
+docker compose exec redis redis-cli SMEMBERS "eq-pdf:lti:platform:<your-pid>:courses"
+```
+
+Substitute `<your-pid>` from `list_platforms`. Should contain `50594`
+(the course you launched from).
+
+If no scan happens, check the watcher logs:
+
+```powershell
+docker compose logs api-gateway --tail=60 | Select-String "scan|Failed|enumerate"
+```
+
+The most likely issue is that the bridge needs `manage_wiki` scope on
+the Developer Key to create Pages. If you skipped that check in
+step 3, it'll fail again here when the bridge tries to create the
+draft Page. The patch in `canvas_review.py` from earlier (approve
+without a page) covers this — approval still works, the page just
+doesn't get created.
+
+## Step 5: verify a new PDF flows through the multi-tenant path
+
+In Canvas, upload a brand-new small PDF to a module in course 50594.
+Within a minute, the watcher should pick it up, and you should see in
+the bridge logs:
+
+```
+INFO service token minted: platform_id=<pid> scope_hash=<hash> granted=...
+```
+
+That's Phase 2 + Phase 5 + Phase 6 all firing together. The bridge is
+now talking to Canvas with a service token, not the personal API
+token.
+
+If you see `Bridge picks platform from job.platform_id` in the logs,
+the per-job multi-tenant routing is working as designed. If you see
+`Bridge env-token fallback`, the watcher created the job without
+stamping the `platform_id`, which means `multi_tenant_watcher` is not
+actually true — recheck step 4.
+
+## Step 6 (later): persist the LTI keypair
+
+The keypair regenerates on every container restart because it lives in
+`/tmp/lti_private.pem`. That's fine for dev but will keep breaking the
+Developer Key trust loop. Two fixes, easiest first:
+
+1. Move the key path to a mounted volume:
+   ```yaml
+   # docker-compose.dev.yml
+   volumes:
+     - ./keys:/app/keys
+   environment:
+     - LTI_PRIVATE_KEY_PATH=/app/keys/lti_private.pem
+     - LTI_PUBLIC_KEY_PATH=/app/keys/lti_public.pem
+   ```
+   Generate once: `docker compose exec api-gateway python -m src.lti.keys generate`
+   The keys persist across restarts. Canvas's cached JWKS stays valid.
+
+2. For Fargate (production), the Terraform module in
+   `infrastructure/fargate/main.tf` already provisions an AWS Secrets
+   Manager secret; the container reads from there at boot.
+
+## Common failure modes I anticipate
+
+**`ServiceTokenError: platform is soft-revoked`.** Someone called
+`mark_revoked` on the platform via `platform_store`. Clear it:
+
+```powershell
+docker compose exec api-gateway python -c "
+import asyncio
+from redis.asyncio import Redis
+from src.config import settings
+from src.lti.platform_store import clear_revoked
+async def main():
+    r = Redis.from_url(settings.redis_url)
+    print(await clear_revoked(r, '<pid>'))
+    await r.aclose()
+asyncio.run(main())
+"
+```
+
+**`No platforms registered yet.`** The launch upsert never ran or
+failed silently. Either the LTI launch isn't actually happening (404 /
+401 on `/lti/launch` first) or the upsert path errored. Check
+api-gateway logs for `PlatformInstall upsert failed`.
+
+**Watcher scans the wrong course because it's in both lists.**
+Multi-tenant precedence is: if a course is registered under a
+platform, that wins. The legacy `canvas_watched_courses` list is only
+used for courses NOT yet associated with any platform. If you want a
+course strictly platform-routed, remove it from
+`canvas_watched_courses`.
+
+**401 retry storm.** If a service token keeps getting rejected, the
+client invalidates + refreshes, then gets rejected again, then surfaces
+the error. There is no infinite-retry loop. If you see the error
+repeating in logs, the issue is on the Canvas side (Developer Key
+revoked, scopes removed, key rotated).
+
+## Tomorrow's first command
+
+```powershell
+$env:COMPOSE_FILE = "docker-compose.yml;docker-compose.dev.yml"
+docker compose up -d --force-recreate api-gateway
+Start-Sleep 10
+docker compose exec api-gateway sh -c "openssl genrsa -out /tmp/lti_private.pem 2048 && openssl rsa -in /tmp/lti_private.pem -pubout -out /tmp/lti_public.pem"
+docker compose exec api-gateway uv run python -m scripts.list_platforms
+```
+
+If that shows zero platforms, click the Reflow link in Canvas once and
+re-run. Then:
+
+```powershell
+docker compose exec api-gateway uv run python -m scripts.test_service_token
+```
+
+That single command tells us where we are. Paste its output and we'll
+go from there.
diff --git a/docs/how-to/production-readiness.md b/docs/how-to/production-readiness.md
new file mode 100644
index 0000000..53d9521
--- /dev/null
+++ b/docs/how-to/production-readiness.md
@@ -0,0 +1,422 @@
+# Production-readiness checklist + runbook
+
+This is the canonical checklist for deploying Equalify Reflow into a
+real institution. It covers the auth architecture you actually need
+(per-user OAuth2, not LTI Advantage client_credentials), the secret
+management story, the operational signals you need on day one, and
+the specific gotchas Canvas Cloud has that we discovered the hard way.
+
+## Architecture summary
+
+After the multi-tenant migration and Phase 8 (per-user OAuth2), Reflow
+has three distinct authentication paths against Canvas. **Production
+deployments use Path 2 for general API access**; the others exist as
+specific-purpose or fallback channels.
+
+| Path | When used | Validity in Canvas Cloud |
+|---|---|---|
+| LTI 1.3 OIDC launch | Faculty arrives at the tool | works everywhere |
+| **Per-user OAuth2** (Phase 8) | All Canvas REST API calls | **only this works** for `/api/v1/...` |
+| LTI Advantage client_credentials | NRPS roster, AGS grades | works ONLY for IMS service endpoints |
+| Personal API token (env) | Local dev only | works (token is user-bound) but not deployable |
+
+If you find yourself relying on the env-token path in a production
+deployment, treat that as a bug. It does not scale, audits poorly,
+and breaks when the user who minted the token leaves the institution.
+
+### Dual Developer Key requirement
+
+Canvas Cloud requires **two separate Developer Keys** per institution,
+not one. Discovered the hard way (2026-05-19) when the LTI Key
+returned `invalid_client` on every `authorization_code` exchange even
+with scopes correctly granted.
+
+| Key | Type in Canvas | Purpose | Auth scheme |
+|---|---|---|---|
+| **LTI Key** | LTI Key (JSON paste) | OIDC launches, NRPS / AGS service calls | JWT bearer (public JWK at `/lti/jwks`) |
+| **API Key** | API Key (form fields) | `/api/v1/...` per-user OAuth2 only | `client_secret` (shared secret) |
+
+The LTI Key has a `public_jwk_url`, so Canvas verifies its assertions
+against our JWKS. The API Key has **no JWK on file** — Canvas requires
+client_secret POST authentication for it, and rejects any JWT
+assertion sent against it with `invalid_client`. The two keys
+authenticate two different grant types and are not interchangeable.
+
+## Secret management
+
+These secrets must be present in any production deployment. None of
+them should ever appear in a git history or container layer.
+
+| Secret | What it is | Where it lives in production |
+|---|---|---|
+| `LTI_PRIVATE_KEY` | RSA-2048 private key that signs every outgoing assertion | AWS Secrets Manager, mounted at `/app/keys/lti_private.pem` by the Fargate task definition |
+| `LTI_PUBLIC_KEY` | The matching public key, published at `/lti/jwks` | Same secret as private, derived on demand |
+| `CANVAS_OAUTH_CLIENT_ID` | client_id of the **non-LTI API Key** that authorizes the per-user OAuth2 flow. Distinct from the LTI Key's client_id. | Env var. Plain (not secret) — it's just an integer ID. |
+| `CANVAS_OAUTH_CLIENT_SECRET` | Shared secret Canvas generates for the API Key. Required because non-LTI Developer Keys have no JWK on file and only accept client_secret auth. | AWS Secrets Manager |
+| `ANTHROPIC_API_KEY` | AI conversion auth | Secrets Manager |
+| `REDIS_AUTH` | Redis password | Secrets Manager + ElastiCache config |
+| `CANVAS_API_TOKEN` | Personal API token (env-fallback) | **Do not set in production**. Leaving it unset forces all calls through Path 2. |
+
+The Fargate Terraform module (`infrastructure/fargate/main.tf`) already
+provisions the Secrets Manager entries and IAM grants. Apply that
+before the first deployment, then place the actual secret values via
+the AWS CLI or console — they should never be committed.
+
+### Keypair rotation
+
+The JWKS endpoint at `/lti/jwks` serves whatever public key currently
+sits at `LTI_PUBLIC_KEY_PATH`. Canvas refetches our JWKS on signature
+failure (and on a periodic cache TTL of ~5-10 minutes), so rotation
+is a two-step:
+
+1. Add the new key to JWKS first; keep the old key live for the cache
+   window (24 hours is the safe number).
+2. Switch the active signing key to the new one. Canvas refetches and
+   accepts assertions signed by the new key.
+3. After 24 hours, remove the old key from JWKS.
+
+The current implementation publishes a single-key JWKS. For
+production, this needs a small expansion to a multi-key JWKS with
+overlapping validity windows. Tracked as a follow-up.
+
+## Per-institution onboarding (admin steps)
+
+These steps run **once per institution** the first time Reflow is
+installed there. Two Developer Keys are created (see "Dual Developer
+Key requirement" above for why). Everything else is self-serve from
+the faculty side.
+
+### Part A — Create the **LTI Key** (handles launches)
+
+1. **Admin creates the LTI Key** in Canvas: `<canvas>/accounts/<acct>/developer_keys`
+   → + Developer Key → **LTI Key** → Method: Paste JSON → paste our
+   `/lti/config.json` output → Save.
+2. **Admin enables the LTI Key** ("ON" state toggle) — keys default to OFF.
+3. **Admin installs the tool** at the desired scope (sub-account or
+   account-level): Settings → Apps → + App → By Client ID → paste the
+   LTI Key's client_id → Install.
+4. **Admin notes the LTI client_id** and shares it with Reflow ops so
+   the institution gets registered in our platform registry.
+
+### Part B — Create the **API Key** (handles per-user OAuth2)
+
+5. **Admin creates the API Key** in Canvas: same Developer Keys page
+   → + Developer Key → **API Key** (not LTI Key this time).
+6. **Set Redirect URIs** to `https://<your-reflow-host>/canvas/oauth/callback`
+   (newline-separated if multiple deployments share one key).
+7. **Grant scopes** — the API Key needs all 15 scopes listed in
+   `multi-tenant-diagnostics.md` step 3. The "Enforce Scopes" toggle
+   should be ON; without it Canvas silently grants nothing.
+8. **Save the API Key**, then **enable** it ("ON" toggle).
+9. **Copy the client_id and the client_secret** (the secret is shown
+   in full only once on the key-details page — capture it via the
+   "Show Key" button immediately, or regenerate later via the
+   `regenerate_secret` API). Stash them in your deployment's secret
+   store as `CANVAS_OAUTH_CLIENT_ID` and `CANVAS_OAUTH_CLIENT_SECRET`.
+
+### Part C — Verify
+
+10. Click the tool from a course as an Instructor. Expected:
+    * LTI launch upserts a `PlatformInstall` record (verify via
+      `scripts.list_platforms`).
+    * Canvas's OAuth2 consent screen appears with 15 scopes listed.
+    * After approval, Redis contains `eq-pdf:lti:user-token:*` and
+      `eq-pdf:lti:course:*:owner` for the course.
+    * `scripts.smoke_user_token` lists PDFs in the course without 401.
+
+Subsequent launches by the same user reuse the stored token and skip
+consent. Tokens auto-refresh silently via the stored refresh_token.
+
+## Deployment topology
+
+Reflow runs as two services in production:
+
+  * **`api-gateway` ECS service**: 2+ Fargate tasks behind an ALB.
+    Runs the HTTP API, the LTI handler, the OAuth callback, and the
+    watcher/bridge background asyncio tasks. Stateless.
+  * **`redis` ElastiCache cluster**: cluster-mode disabled, single
+    primary + one replica. Holds the platform registry, session
+    cookies, user tokens, audit-log dedup keys, and the job state.
+
+The Fargate task definition mounts the LTI keypair from Secrets
+Manager and reads everything else from environment-variable secrets.
+No persistent local disk. No long-lived container state.
+
+### Scaling
+
+  * **API tier**: scale out on CPU. The watcher/bridge run inside
+    every api-gateway task; cap at 4 tasks until you add a leader-
+    election scheme (otherwise four watchers will each scan every
+    course on every tick).
+  * **Redis**: scale up before scaling out. Cluster mode requires
+    careful key-distribution review; until then run a single shard
+    with read replicas for ops queries.
+  * **Reflow conversion backend**: separate from the Canvas
+    integration; scaled independently per the existing capacity plan.
+
+## Monitoring + alerting
+
+Day-one signals to wire up before going live:
+
+| Signal | Source | Page on |
+|---|---|---|
+| `/health` 200 rate | ALB + Datadog synthetic | <99.5% in 5 min |
+| Canvas API 4xx rate | `reflow.canvas.audit` event=api_call status>=400 | >5% in 5 min |
+| Canvas API 5xx rate | same | >0% in 1 min |
+| User token refresh failures | `reflow.canvas.audit` event=user_token_grant after a 401 retry | spike vs. baseline |
+| Bridge job stuck in `processing` | watcher's stale-job sweep counter | non-zero |
+| LTI launch validation failures | api-gateway log warning `LTI launch validation failed` | spike vs. baseline |
+| Reflow conversion error rate | existing | (use existing thresholds) |
+
+The `audit.emit` calls in `src/canvas/audit.py` are the structured
+events to point Datadog (or whatever you're using) at. Each event has
+fields like `platform`, `user`, `course`, `scope_hash`, `latency_ms`,
+`status`. Index `platform` first; that's the most common slice for
+"is school X having a problem".
+
+## Privacy + audit data retention
+
+The `reflow.canvas.audit` log carries `user_id` and `course_id`. By
+default no PII (names, emails, file contents) lands in audit records,
+but `user_id` is technically identifying when combined with Canvas's
+own records. Recommend:
+
+  * Retain audit logs for **90 days hot**, then archive to S3
+    Glacier for the legally-required period (varies by institution —
+    most US universities use 7 years for student records).
+  * Encrypt at rest with a CMK distinct from the application
+    encryption key.
+  * Restrict access to a named SRE group; access through the log
+    viewer is itself audited.
+
+## Common Canvas Cloud gotchas (we hit each of these in dev)
+
+1. **`canvas.instructure.com` is the SSO realm for ALL Canvas Cloud
+   institutions.** The actual institutional API host is
+   `<inst>.instructure.com`. Token mints go to the SSO; API calls go
+   to the institutional host. Our `derive_endpoints_from_issuer`
+   handles this. If a school is on a non-standard Cloud setup,
+   override via `platform_overrides.yaml` (not yet implemented;
+   tracked as a follow-up).
+
+2. **LTI Advantage client_credentials tokens are NOT valid for the
+   general `/api/v1/...` REST API in Canvas Cloud.** They work only
+   for LTI Advantage services (NRPS, AGS, Deep Linking). This was
+   discovered the hard way; the architectural fix is Phase 8 (per-
+   user OAuth2). Confirmed against canvas.test.instructure.com on
+   2026-05-19.
+
+3. **The `url:GET|/api/v1/...` scopes ARE visible on the dev key's
+   admin page but require the user-OAuth2 flow to actually be
+   useful.** Granting them via the API does work, but it does not
+   bless the client_credentials tokens; only user-bound bearers
+   honor them.
+
+4. **The dev key's `Redirect URIs` textarea is newline-separated.**
+   Each redirect URI you want Canvas to accept must appear on its
+   own line. The admin UI textbox is the source of truth.
+
+5. **Canvas's JWKS cache TTLs for ~5-10 minutes.** After a keypair
+   rotation, expect 5-10 min of "invalid_client" before Canvas
+   refetches. Trigger an immediate refetch by editing the dev key
+   and re-saving (any field change works).
+
+6. **Test Canvas instances reset monthly.** Build your scaffolding
+   so a full reinstall takes under an hour: client_id + scopes +
+   redirect_uris + install at the account level + first launch.
+
+7. **LTI Keys cannot authenticate `authorization_code` grants.** Even
+   with all scopes granted and the key enabled, posting an
+   authorization_code to `/login/oauth2/token` using the LTI Key's
+   client_id returns `invalid_client`. This is by Canvas Cloud's
+   design — LTI Keys only authenticate JWT-bearer client_credentials.
+   The fix is the dual-key model documented in "Per-institution
+   onboarding"; the API Key handles OAuth, the LTI Key handles
+   launches. Discovered 2026-05-19 on csueb.test.instructure.com.
+
+8. **Non-LTI API Keys do not accept JWT bearer assertions.** They
+   have no `public_jwk_url` field, so Canvas has no way to verify a
+   signature against them. Code-exchange and refresh both must POST
+   `client_secret`. Our callback in `src/api/canvas_oauth.py`
+   picks the auth scheme automatically based on whether
+   `CANVAS_OAUTH_CLIENT_SECRET` is configured.
+
+## Smoke tests before declaring a deployment healthy
+
+Run these in sequence. All must pass.
+
+```powershell
+# 1. JWKS reachable + serves the active public key
+curl https://<your-reflow-host>/lti/jwks | jq '.keys[0].kid'
+
+# 2. /health returns 200
+curl https://<your-reflow-host>/health
+
+# 3. A faculty launch creates a platform record
+docker compose exec api-gateway uv run python -m scripts.list_platforms
+
+# 4. Service token mint works
+docker compose exec api-gateway uv run python -m scripts.test_service_token
+
+# 5. After OAuth consent, a user_token is stored
+docker compose exec redis redis-cli --scan --pattern "eq-pdf:lti:user-token:*"
+
+# 6. A Canvas API call via the user token succeeds
+#    (lists PDFs in the course; defaults to 50594, override with arg)
+docker compose exec api-gateway uv run python -m scripts.smoke_user_token <COURSE_ID>
+"
+```
+
+If step 6 returns a non-zero count of files, your deployment is
+end-to-end working. If it 401s, check `audit.emit` log records to
+see which token was used and what scope the failure was on.
+
+## Incident response
+
+**A platform is misbehaving** (returning 5xx, leaking PII, anything
+that should be paused immediately): mark it soft-revoked:
+
+```powershell
+docker compose exec api-gateway uv run python -c "
+import asyncio
+from redis.asyncio import Redis
+from src.config import settings
+from src.lti.platform_store import mark_revoked
+asyncio.run(__import__('asyncio').get_event_loop().run_until_complete(
+    mark_revoked(Redis.from_url(settings.redis_url), '<platform_id>')
+))
+"
+```
+
+Subsequent service-token requests refuse to mint. Existing user tokens
+also stop being used (the watcher won't pick the platform up). To
+restore, use `clear_revoked` in the same way.
+
+**A faculty member revokes consent on Canvas's side**: their stored
+user token will start returning 401 on every refresh attempt. The
+client invalidates the cached entry and surfaces a 401 to the caller.
+The bridge worker will log a warning and the next LTI launch by that
+faculty member will route them back through the consent screen.
+
+**The container restarts and Canvas's cached JWKS is stale**: see
+section "Keypair rotation" above; wait the TTL or force a refetch via
+the dev key edit-and-save trick.
+
+## Open follow-ups (not blocking production but should land soon)
+
+  * Multi-key JWKS for graceful keypair rotation (currently a single
+    key, restart is a brief outage).
+  * `platform_overrides.yaml` for non-standard Canvas Cloud setups
+    (currently every install must match the canonical URL scheme).
+  * Leader election for the watcher/bridge so we can scale api-gateway
+    above 4 tasks without N watchers each doing the same scan.
+  * RDS-backed platform registry. Redis-only is fine through MVP +
+    early production; persistent registry needs durable storage and
+    point-in-time recovery for compliance review.
+  * Audit log shipper for the structured `reflow.canvas.audit`
+    events. Right now they go to stdout; in production they need to
+    land in the same indexed store as everything else.
+
+## ADA Title II framing (added 2026-05-20)
+
+Equalify Reflow is positioned as a **WCAG-oriented PDF-to-Canvas-HTML
+remediation workflow**, not a "PDF accessibility compliance tool."
+The accessible artifact is the **approved Canvas HTML page**, not the
+original PDF. We do not claim ADA Title II / WCAG 2.1 AA compliance
+by default — compliance is established per-document, per-institution,
+by the combination of:
+
+  * Automated conversion (Reflow PDF → markdown → HTML)
+  * Automated WCAG checks (`GET /canvas/panorama/wcag/{job_id}` — see
+    `src/canvas/wcag_checks.py`)
+  * Manual reviewer checklist (headings, alt text, tables, reading
+    order — enforced by the publication gate when
+    `REQUIRE_WCAG_GATE=true` is set)
+  * Faculty publish action recorded with reviewer identity + timestamp
+
+### What's a "conversion quality" score, and why not call it WCAG?
+
+The percentage shown on the panorama dial is a **conversion-quality
+heuristic** derived from the markdown the pipeline produced (heading
+structure, image-alt coverage, table semantics, language detection).
+A high score means "the pipeline extracted accessible structure
+well" — it does NOT mean "this document is WCAG-conformant." A
+separate review is required to publish.
+
+### Why Canvas HTML, not the original PDF?
+
+  * Canvas's native HTML page rendering respects user accessibility
+    settings (zoom, screen reader, etc.) in a way no PDF viewer can
+    universally guarantee.
+  * Faculty edits land in the HTML, not the PDF, so the published
+    version stays in sync with the reviewed accessible content.
+  * The PDF stays available as a source-copy link, labeled
+    "Original PDF (source copy)" in the panorama overlay.
+
+### What is and is NOT a tagged accessible PDF?
+
+`src/canvas/alt_formats.py:render_ocr_pdf` produces a **Searchable
+OCR PDF** (PDF/A archival format with a text layer). This is NOT
+the same as a PDF/UA tagged accessible PDF — PDF/UA tagging
+requires a proper structure tree, alt text on figures, reading
+order metadata, and language markers, none of which `ocrmypdf`
+produces. The label in the panorama modal reflects this honestly.
+
+## Production hardening checklist (added 2026-05-20)
+
+The following env vars and configuration steps are *required* for a
+defensible production deployment:
+
+| Setting | Why | Where |
+|---|---|---|
+| `CANVAS_ALLOWED_ORIGINS` | Origin allowlist for state-changing routes. Fail-closed when set. | `.env` |
+| `CSRF_SECRET_KEY` | HMAC secret for per-session CSRF tokens. 32+ chars random. | secrets store |
+| `TOKEN_ENCRYPTION_KEY` | Encrypts OAuth tokens at rest in Redis. 32+ chars random. | secrets store |
+| `REQUIRE_WCAG_GATE=true` | Refuses to publish until automated WCAG checks pass and reviewer checklist is complete. | `.env` |
+| Redis auth + TLS | Tokens, sessions, and audit records all live in Redis. | infra |
+| `enable_api_key_auth=true` | Layered auth: API key + LTI session. | `.env` |
+
+## What's audited and where
+
+Every approve/reject/request-edits/pii-decision/delete action lands
+in `eq-pdf:canvas:approval:audit` as an immutable Redis list entry
+with: job_id, action, actor_user_id, actor_name, course_id, IP,
+comment, timestamp. Exported via `GET /canvas/panorama/audit/approvals.csv`
+(admin-only — see Phase 4 in the roadmap).
+
+## How to run the test suite
+
+```powershell
+docker compose exec api-gateway uv run pytest tests/unit/canvas/ -v
+```
+
+The unit suite under `tests/unit/canvas/` covers:
+
+  * `test_sanitize.py` — XSS payloads, academic structure preservation,
+    idempotency, URL allowlist.
+  * `test_wcag_checks.py` — pristine doc passes; lang/title/alt/th/link
+    failures fire expected rule IDs; heading-skip warnings.
+  * `test_signals.py` — heading detection, image-alt counting, table
+    detection, score function differentiates across profiles.
+  * `test_csrf_helpers.py` — token stability per session, distinct
+    across sessions, well-formed hex.
+  * `test_privacy_crypto.py` — token encryption round-trip, legacy
+    plaintext pass-through, nonce randomness.
+
+## Known follow-ups (not blocking institutional pilot)
+
+  * **Conversion-quality score tuning** — current thresholds let
+    documents with one missing alt-text image still reach "green."
+    See task #103.
+  * **Polly opt-in** — MP3 audio rendering requires real AWS Polly
+    credentials separate from Floci stubs; defaults to UnrecognizedClientException
+    in dev. Either set real AWS creds or document the feature as
+    "production-only."
+  * **Syllabus scope** — the watcher's syllabus scan fires 401
+    because the API Key's scope list omits `url:GET|/api/v1/courses/:course_id`.
+    Either add the scope or suppress the syllabus scan.
+  * **Favicon 500** — `/favicon.ico` returns a stack trace because
+    `/app/static/viewer/index.html` doesn't exist. Cosmetic.
+  * **Multi-key JWKS** — current LTI keypair serving is single-key;
+    rotation requires brief downtime. Multi-key with overlapping
+    windows is the proper fix.
diff --git a/docs/how-to/switch-to-real-aws.md b/docs/how-to/switch-to-real-aws.md
new file mode 100644
index 0000000..39235fb
--- /dev/null
+++ b/docs/how-to/switch-to-real-aws.md
@@ -0,0 +1,135 @@
+# Switching the dev stack from Floci to real AWS
+
+The local dev stack defaults to **Floci** (an S3-compatible local emulator)
+for S3 and CloudWatch. Bedrock always points at real AWS because no local
+emulator covers it. This document covers what to do when you want to flip
+S3 + CloudWatch to real AWS too — typically for staging-like validation,
+or to test against a real bucket before deploying to Fargate.
+
+## When you actually need this
+
+- You're validating the end-to-end pipeline against a real S3 bucket
+  (e.g., to confirm bucket-level lifecycle rules apply correctly).
+- You're testing IAM-role-based auth instead of long-lived access keys.
+- You're debugging a presigned-URL bug that only shows up on real AWS.
+
+If you're just developing features, **don't switch.** Floci is faster,
+free, and doesn't risk leaking PII to a production bucket.
+
+## Prerequisites
+
+You need an AWS account and an IAM user (or role) with these permissions:
+
+- `s3:GetObject`, `s3:PutObject`, `s3:DeleteObject`, `s3:ListBucket` on the
+  Reflow buckets (defaults: `equalify-pdf-temp`, `equalify-pdf-results`).
+- `cloudwatch:PutMetricData` if you want metrics export.
+- `bedrock:InvokeModel` if you're using AWS Bedrock for AI agents (vs.
+  Anthropic direct, which doesn't touch AWS).
+
+The buckets must exist before Reflow starts — boto3 won't create them.
+Easiest path: log into the AWS console once and create
+`equalify-pdf-temp-<your-initials>` and `equalify-pdf-results-<your-initials>`
+in the same region as your Bedrock endpoint (`us-east-1` is the default).
+
+## Steps
+
+### 1. Get an access key id + secret access key
+
+Console → IAM → Users → pick your IAM user → **Security credentials**
+tab → **Create access key**. Choose "Command Line Interface (CLI)" as
+the use case. Download the CSV; you'll only see the secret once.
+
+### 2. Put the credentials in your local `.env`
+
+Edit `.env` in the repo root (create it if absent):
+
+```
+AWS_ACCESS_KEY_ID=AKIA...        # your real key id
+AWS_SECRET_ACCESS_KEY=...        # your real secret
+AWS_DEFAULT_REGION=us-east-1     # or whichever region your buckets live in
+S3_TEMP_BUCKET=equalify-pdf-temp-<your-initials>
+S3_RESULTS_BUCKET=equalify-pdf-results-<your-initials>
+```
+
+These override the floci defaults defined in `docker-compose.dev.yml`
+(which pull from the same env vars but fall back to `test`).
+
+### 3. Remove the Floci endpoint override
+
+In `docker-compose.dev.yml`, comment out the line:
+
+```yaml
+- AWS_ENDPOINT_URL_S3=http://floci:4566
+```
+
+This is what tells boto3 to talk to floci. With it gone, boto3 uses the
+real AWS S3 endpoint determined by the region. Leave
+`AWS_ENDPOINT_URL_CLOUDWATCH` either commented or pointing at real AWS
+the same way.
+
+### 4. Update the public/internal S3 URL settings
+
+Real AWS doesn't need separate public/internal URLs — both are
+`https://s3.<region>.amazonaws.com` (or virtual-hosted-style
+`https://<bucket>.s3.<region>.amazonaws.com`). Comment these out so the
+rewrite helper becomes a no-op:
+
+```yaml
+# - S3_PUBLIC_URL=http://localhost:4566
+# - S3_INTERNAL_URL=http://floci:4566
+```
+
+### 5. Restart the stack
+
+```powershell
+docker compose up -d --force-recreate api-gateway
+docker compose logs --tail=30 api-gateway --follow
+```
+
+You should see normal startup with no `ProfileNotFound` errors. Hit
+`/health` to confirm the S3 check passes against the real bucket:
+
+```powershell
+curl https://etsuko-unmurmurous-unneurotically.ngrok-free.dev/health
+```
+
+A `200 OK` with `s3: true` in the JSON means real S3 is responding.
+
+## Rollback to Floci
+
+Reverse every step in section "Steps":
+
+- Uncomment `AWS_ENDPOINT_URL_S3=http://floci:4566`.
+- Uncomment `S3_PUBLIC_URL` and `S3_INTERNAL_URL`.
+- Restore `S3_TEMP_BUCKET=equalify-pdf-temp` and `S3_RESULTS_BUCKET=equalify-pdf-results`.
+- In your `.env`, set `AWS_ACCESS_KEY_ID=test` and `AWS_SECRET_ACCESS_KEY=test`
+  (or delete the lines — the compose default will provide `test`).
+- Restart.
+
+## Common gotchas
+
+- **`ProfileNotFound: default`.** Means `AWS_PROFILE` is set to an empty
+  string somewhere. boto3 reads `""` as "use profile 'default'" and then
+  tries `~/.aws/credentials`. Fix: leave `AWS_PROFILE` *completely
+  unset* (don't even define the env key). The compose file already
+  follows this rule; if you re-add it, comment it out instead.
+- **`AccessDenied` on PutObject.** IAM user lacks `s3:PutObject` on the
+  bucket. Don't broaden IAM to `*` — scope it to the two Reflow bucket
+  ARNs.
+- **Presigned URLs return 403.** Bucket has a "block all public access"
+  setting at the bucket level. Either turn that off (relaxes security)
+  or configure the bucket policy to allow GET on presigned-URL paths.
+- **`InvalidLocationConstraint`.** Your bucket is in a different region
+  than `AWS_DEFAULT_REGION`. Either move the bucket or update the env.
+
+## Production path
+
+Once Reflow is on Fargate, you should NOT use long-lived access keys.
+Instead the ECS task runs under an IAM task role and boto3 picks up
+credentials automatically via the EC2/ECS metadata service. The compose
+flag `AWS_EC2_METADATA_DISABLED=true` exists only because the local
+container has no such metadata service; in Fargate, you'll want that
+unset (or removed) so the task role chain works.
+
+See `infrastructure/fargate/main.tf` for the Terraform module that wires
+up the IAM task role at deploy time.
diff --git a/infrastructure/fargate/main.tf b/infrastructure/fargate/main.tf
new file mode 100644
index 0000000..997e200
--- /dev/null
+++ b/infrastructure/fargate/main.tf
@@ -0,0 +1,395 @@
+# ---------------------------------------------------------------------------
+# Equalify Reflow - production Fargate deployment
+# ---------------------------------------------------------------------------
+# Goal of this stack:
+#   * 2x redundant ECS tasks behind an ALB (no single point of failure)
+#   * Independent autoscaling for the api-gateway and the workers
+#   * Health checks pinned to the new /health/live + /health/ready endpoints
+#   * Tenant-isolated by setting CANVAS_TENANT per service (one stack per
+#     campus, sharing nothing with other tenants beyond AWS account quotas)
+#
+# Notes for operators:
+#   * Reflow's stateful tier (Redis, S3) is NOT defined here - those live in
+#     a separate stack so they outlive any Fargate redeploy. Inject their
+#     endpoints via the *_endpoint variables.
+#   * Container image must be published to ECR before applying. CI/CD docs
+#     in ../../docs/explanation/production-readiness.md.
+
+terraform {
+  required_version = ">= 1.5"
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = "~> 5.0"
+    }
+  }
+}
+
+# ---------------------------------------------------------------------------
+# Inputs - everything campus-specific lives here. No defaults that bake one
+# campus's identity into the module.
+# ---------------------------------------------------------------------------
+variable "tenant" {
+  description = "Tenant id passed to the app as CANVAS_TENANT. One per campus."
+  type        = string
+}
+variable "aws_region" {
+  description = "AWS region for the ECS cluster, ALB, and supporting resources."
+  type        = string
+  default     = "us-east-1"
+}
+variable "vpc_id" {
+  description = "Existing VPC to attach the ALB and tasks to."
+  type        = string
+}
+variable "private_subnet_ids" {
+  description = "Private subnets for Fargate tasks (multi-AZ; minimum 2)."
+  type        = list(string)
+  validation {
+    condition     = length(var.private_subnet_ids) >= 2
+    error_message = "Provide at least 2 private subnets across distinct AZs for HA."
+  }
+}
+variable "public_subnet_ids" {
+  description = "Public subnets for the ALB (multi-AZ; minimum 2)."
+  type        = list(string)
+  validation {
+    condition     = length(var.public_subnet_ids) >= 2
+    error_message = "Provide at least 2 public subnets across distinct AZs for HA."
+  }
+}
+variable "image_uri" {
+  description = "ECR image URI for the api-gateway container."
+  type        = string
+}
+variable "redis_url" {
+  description = "Redis URL for state, queues, and approval audit."
+  type        = string
+  sensitive   = true
+}
+variable "canvas_api_url" {
+  description = "Canvas instance base URL, e.g. https://campus.instructure.com."
+  type        = string
+}
+variable "canvas_api_token_arn" {
+  description = "Secrets Manager ARN for the Canvas API token."
+  type        = string
+}
+variable "anthropic_api_key_arn" {
+  description = "Secrets Manager ARN for the Anthropic API key."
+  type        = string
+}
+variable "lti_signing_key_arn" {
+  description = "Secrets Manager ARN for the LTI 1.3 RS256 private key."
+  type        = string
+}
+variable "monthly_spend_cap_usd" {
+  description = "Default per-course monthly Claude spend cap. 0=unlimited."
+  type        = number
+  default     = 0
+}
+variable "log_retention_days" {
+  description = "CloudWatch Logs retention. 30d default keeps audit + crash forensics affordable."
+  type        = number
+  default     = 30
+}
+
+# ---------------------------------------------------------------------------
+# Cluster + task definition
+# ---------------------------------------------------------------------------
+resource "aws_ecs_cluster" "this" {
+  name = "equalify-reflow-${var.tenant}"
+
+  # Container Insights gives us per-task CPU/mem metrics in CloudWatch for free.
+  setting {
+    name  = "containerInsights"
+    value = "enabled"
+  }
+}
+
+resource "aws_cloudwatch_log_group" "app" {
+  name              = "/ecs/equalify-reflow/${var.tenant}"
+  retention_in_days = var.log_retention_days
+}
+
+resource "aws_iam_role" "task_execution" {
+  name = "equalify-reflow-${var.tenant}-task-exec"
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [{
+      Effect    = "Allow"
+      Principal = { Service = "ecs-tasks.amazonaws.com" }
+      Action    = "sts:AssumeRole"
+    }]
+  })
+}
+
+resource "aws_iam_role_policy_attachment" "task_execution_managed" {
+  role       = aws_iam_role.task_execution.name
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
+}
+
+# Lets the execution role pull our three secrets at task startup.
+resource "aws_iam_role_policy" "task_execution_secrets" {
+  name = "secrets-read"
+  role = aws_iam_role.task_execution.id
+
+  policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [{
+      Effect = "Allow"
+      Action = ["secretsmanager:GetSecretValue"]
+      Resource = [
+        var.canvas_api_token_arn,
+        var.anthropic_api_key_arn,
+        var.lti_signing_key_arn,
+      ]
+    }]
+  })
+}
+
+# Task role - granted to the running container, used for runtime AWS calls
+# (S3 reads/writes, Bedrock, etc.). Scope as tightly as your S3 buckets allow.
+resource "aws_iam_role" "task_runtime" {
+  name = "equalify-reflow-${var.tenant}-task-runtime"
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [{
+      Effect    = "Allow"
+      Principal = { Service = "ecs-tasks.amazonaws.com" }
+      Action    = "sts:AssumeRole"
+    }]
+  })
+}
+
+resource "aws_ecs_task_definition" "api_gateway" {
+  family                   = "equalify-reflow-${var.tenant}-api"
+  network_mode             = "awsvpc"
+  requires_compatibilities = ["FARGATE"]
+  cpu                      = 1024  # 1 vCPU
+  memory                   = 2048  # 2 GiB - enough for Docling sidecar workloads
+  execution_role_arn       = aws_iam_role.task_execution.arn
+  task_role_arn            = aws_iam_role.task_runtime.arn
+
+  container_definitions = jsonencode([{
+    name      = "api-gateway"
+    image     = var.image_uri
+    essential = true
+
+    portMappings = [{
+      containerPort = 8080
+      protocol      = "tcp"
+    }]
+
+    environment = [
+      { name = "CANVAS_TENANT", value = var.tenant },
+      { name = "CANVAS_API_URL", value = var.canvas_api_url },
+      { name = "ENVIRONMENT", value = "production" },
+      { name = "LOG_FORMAT", value = "json" },
+      { name = "REDIS_URL", value = var.redis_url },
+      { name = "CANVAS_MONTHLY_SPEND_CAP_USD_DEFAULT", value = tostring(var.monthly_spend_cap_usd) },
+    ]
+
+    secrets = [
+      { name = "CANVAS_API_TOKEN", valueFrom = var.canvas_api_token_arn },
+      { name = "ANTHROPIC_API_KEY", valueFrom = var.anthropic_api_key_arn },
+      { name = "LTI_PRIVATE_KEY", valueFrom = var.lti_signing_key_arn },
+    ]
+
+    # Pinned to /health/live (cheap, no deps). The ALB target group has its
+    # own check against /health/ready (with deps); both must be healthy for
+    # traffic to flow.
+    healthCheck = {
+      command     = ["CMD-SHELL", "curl -fsS http://localhost:8080/health/live || exit 1"]
+      interval    = 30
+      timeout     = 5
+      retries     = 3
+      startPeriod = 60
+    }
+
+    logConfiguration = {
+      logDriver = "awslogs"
+      options = {
+        awslogs-group         = aws_cloudwatch_log_group.app.name
+        awslogs-region        = var.aws_region
+        awslogs-stream-prefix = "api"
+      }
+    }
+  }])
+}
+
+# ---------------------------------------------------------------------------
+# Service - 2 tasks across AZs for redundancy. Scales out under sustained
+# CPU pressure. Deployment strategy is rolling with circuit breaker so a
+# bad deploy auto-rolls back to the prior task definition.
+# ---------------------------------------------------------------------------
+resource "aws_ecs_service" "api_gateway" {
+  name             = "equalify-reflow-${var.tenant}-api"
+  cluster          = aws_ecs_cluster.this.id
+  task_definition  = aws_ecs_task_definition.api_gateway.arn
+  desired_count    = 2
+  launch_type      = "FARGATE"
+  platform_version = "LATEST"
+
+  deployment_circuit_breaker {
+    enable   = true
+    rollback = true
+  }
+
+  network_configuration {
+    subnets         = var.private_subnet_ids
+    security_groups = [aws_security_group.task.id]
+  }
+
+  load_balancer {
+    target_group_arn = aws_lb_target_group.api.arn
+    container_name   = "api-gateway"
+    container_port   = 8080
+  }
+
+  # The new task must pass health checks for 60s before old tasks are drained.
+  deployment_minimum_healthy_percent = 50
+  deployment_maximum_percent         = 200
+}
+
+# Allow scaling between 2 and 6 tasks. Lower bound preserves redundancy
+# (one task could be cycling for a deploy); upper bound caps blast radius
+# if traffic spikes (or someone hits the spend cap path repeatedly).
+resource "aws_appautoscaling_target" "api" {
+  max_capacity       = 6
+  min_capacity       = 2
+  resource_id        = "service/${aws_ecs_cluster.this.name}/${aws_ecs_service.api_gateway.name}"
+  scalable_dimension = "ecs:service:DesiredCount"
+  service_namespace  = "ecs"
+}
+
+resource "aws_appautoscaling_policy" "api_cpu" {
+  name               = "cpu-target-tracking"
+  policy_type        = "TargetTrackingScaling"
+  resource_id        = aws_appautoscaling_target.api.resource_id
+  scalable_dimension = aws_appautoscaling_target.api.scalable_dimension
+  service_namespace  = aws_appautoscaling_target.api.service_namespace
+
+  target_tracking_scaling_policy_configuration {
+    target_value = 65.0
+    predefined_metric_specification {
+      predefined_metric_type = "ECSServiceAverageCPUUtilization"
+    }
+    scale_in_cooldown  = 300
+    scale_out_cooldown = 60
+  }
+}
+
+# ---------------------------------------------------------------------------
+# ALB + TLS termination
+# ---------------------------------------------------------------------------
+resource "aws_security_group" "alb" {
+  name        = "equalify-reflow-${var.tenant}-alb"
+  description = "Public ALB ingress"
+  vpc_id      = var.vpc_id
+
+  ingress {
+    protocol    = "tcp"
+    from_port   = 443
+    to_port     = 443
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+  egress {
+    protocol    = "-1"
+    from_port   = 0
+    to_port     = 0
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+}
+
+resource "aws_security_group" "task" {
+  name        = "equalify-reflow-${var.tenant}-task"
+  description = "Fargate task ingress: only from the ALB SG"
+  vpc_id      = var.vpc_id
+
+  ingress {
+    protocol        = "tcp"
+    from_port       = 8080
+    to_port         = 8080
+    security_groups = [aws_security_group.alb.id]
+  }
+  egress {
+    protocol    = "-1"
+    from_port   = 0
+    to_port     = 0
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+}
+
+resource "aws_lb" "this" {
+  name               = "equalify-reflow-${var.tenant}"
+  internal           = false
+  load_balancer_type = "application"
+  security_groups    = [aws_security_group.alb.id]
+  subnets            = var.public_subnet_ids
+}
+
+resource "aws_lb_target_group" "api" {
+  name        = "equalify-reflow-${var.tenant}-api"
+  port        = 8080
+  protocol    = "HTTP"
+  target_type = "ip"
+  vpc_id      = var.vpc_id
+
+  # /health/ready is the right probe for routing decisions: it returns 503
+  # within 2 seconds when Redis is unreachable, so the ALB rapidly stops
+  # sending traffic to a degraded task. /health/live is for ECS to decide
+  # whether to RESTART (separate concern).
+  health_check {
+    path                = "/health/ready"
+    port                = "8080"
+    healthy_threshold   = 2
+    unhealthy_threshold = 3
+    interval            = 15
+    timeout             = 5
+    matcher             = "200"
+  }
+
+  # Graceful drain so in-flight approvals finish before a task is killed.
+  deregistration_delay = 30
+}
+
+resource "aws_lb_listener" "https" {
+  load_balancer_arn = aws_lb.this.arn
+  port              = 443
+  protocol          = "HTTPS"
+
+  # Operator supplies the cert via a data source or a separate
+  # aws_acm_certificate resource. Leaving as variable so this module
+  # doesn't presume cert lifecycle.
+  ssl_policy      = "ELBSecurityPolicy-TLS13-1-2-2021-06"
+  certificate_arn = var.tls_certificate_arn
+
+  default_action {
+    type             = "forward"
+    target_group_arn = aws_lb_target_group.api.arn
+  }
+}
+
+variable "tls_certificate_arn" {
+  description = "ACM certificate ARN for the ALB HTTPS listener."
+  type        = string
+}
+
+# ---------------------------------------------------------------------------
+# Outputs
+# ---------------------------------------------------------------------------
+output "alb_dns_name" {
+  description = "Public DNS name of the ALB; point your Canvas LTI tool config here."
+  value       = aws_lb.this.dns_name
+}
+output "ecs_cluster_name" {
+  description = "ECS cluster name for ops dashboards."
+  value       = aws_ecs_cluster.this.name
+}
+output "log_group_name" {
+  description = "CloudWatch Logs group - tail with `aws logs tail` for incident response."
+  value       = aws_cloudwatch_log_group.app.name
+}
diff --git a/pyproject.toml b/pyproject.toml
index 00e6576..6e8d766 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -15,7 +15,23 @@ dependencies = [
     "presidio-analyzer>=2.2.0",
     "spacy>=3.7.0,<3.8.0",
     "pypdfium2>=4.0.0",
-    "pydantic-ai[anthropic,bedrock]>=1.0.12",
+    # NOTE: the [anthropic] extras live on pydantic-ai-slim, not on the
+    # meta `pydantic-ai` package. Using the meta package with these
+    # extras silently kept us pinned at 1.38.0 (warning:
+    # "pydantic-ai==1.38.0 does not have an extra named 'anthropic'")
+    # which then broke at runtime against newer anthropic SDKs.
+    # Dropped [bedrock] — that extra pulls boto3>=1.42.63 which is
+    # mutually exclusive with aioboto3 (max 15.5.0 caps boto3<1.40.62).
+    # We talk to Anthropic directly, not via AWS Bedrock, so it's safe
+    # to drop.
+    "pydantic-ai-slim[anthropic]>=1.98.0",
+    # HTML sanitization for instructor-edited and AI-generated content.
+    # See src/canvas/sanitize.py for the academic-content allowlist.
+    "bleach[css]>=6.1.0",
+    # Stdlib has ``importlib.metadata`` but logfire (transitively, via
+    # pytest-11 entry-points) imports the *third-party* ``importlib_metadata``
+    # backport explicitly. Without it pytest fails to load. Cheap to keep.
+    "importlib-metadata>=7.0",
     "pyyaml>=6.0.0",
     "pdf2image>=1.17.0",
     "en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl",
@@ -40,6 +56,9 @@ dependencies = [
     "argon2-cffi>=23.1.0",
     "itsdangerous>=2.2.0",
     "joserfc>=1.0.0",
+    "ebooklib>=0.18",
+    "ocrmypdf>=16.0",
+    "numpy>=1.26,<2.0",
 ]
 
 [project.optional-dependencies]
diff --git a/scripts/__init__.py b/scripts/__init__.py
new file mode 100644
index 0000000..f66d8c1
--- /dev/null
+++ b/scripts/__init__.py
@@ -0,0 +1,6 @@
+"""Ops + diagnostic CLIs.
+
+Each module here is a standalone entry point run via
+``python -m scripts.<name>``. They share the project's settings and
+Redis client; no separate config layer.
+"""
diff --git a/scripts/list_platforms.py b/scripts/list_platforms.py
new file mode 100644
index 0000000..9f506ff
--- /dev/null
+++ b/scripts/list_platforms.py
@@ -0,0 +1,78 @@
+"""Print every Canvas platform that has launched the tool.
+
+Phase 1 ops CLI for the multi-tenant migration. Connects to the same
+Redis the api-gateway uses and dumps the platform registry as a small
+table. Useful for confirming "did the launch from canvas.test.example
+actually write a record?".
+
+Usage from the host::
+
+    docker compose exec api-gateway python -m scripts.list_platforms
+
+Or in JSON mode for piping into jq::
+
+    docker compose exec api-gateway python -m scripts.list_platforms --json
+
+The output is intentionally compact; one record per row, no
+pretty-printing of timestamps. The point is fast eyeballing during
+diagnosis, not a polished admin UI.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+
+from redis.asyncio import Redis
+
+from src.config import settings
+from src.lti.platform_store import list_platforms
+
+
+async def _main(as_json: bool) -> int:
+    redis = Redis.from_url(settings.redis_url, decode_responses=False)
+    try:
+        records = await list_platforms(redis)
+    finally:
+        await redis.aclose()
+
+    if as_json:
+        json.dump(
+            [r.to_json() for r in records],
+            sys.stdout,
+            indent=2,
+            default=str,
+        )
+        sys.stdout.write("\n")
+        return 0
+
+    if not records:
+        print("No platforms registered yet.")
+        print("(Records are created on the first successful LTI launch.)")
+        return 0
+
+    # Column widths chosen to fit a typical 120-column terminal without
+    # wrapping while leaving room for canvas.school-name.example domains.
+    header = f"{'PLATFORM_ID':<18} {'DOMAIN':<40} {'DEPLOYMENT':<18} {'LAST LAUNCH':<22} {'REV':<5}"
+    print(header)
+    print("-" * len(header))
+    for r in sorted(records, key=lambda x: x.last_launch_at, reverse=True):
+        dep = (r.deployment_id or "")[:16]
+        last = (r.last_launch_at or "")[:19].replace("T", " ")
+        rev = "yes" if r.revoked_at else ""
+        print(f"{r.platform_id:<18} {r.canvas_domain:<40} {dep:<18} {last:<22} {rev:<5}")
+    print(f"\n{len(records)} platform(s)")
+    return 0
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="List registered Canvas platforms.")
+    ap.add_argument("--json", action="store_true", help="Emit JSON instead of table")
+    args = ap.parse_args()
+    return asyncio.run(_main(args.json))
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/test_service_token.py b/scripts/test_service_token.py
new file mode 100644
index 0000000..1984854
--- /dev/null
+++ b/scripts/test_service_token.py
@@ -0,0 +1,124 @@
+"""Mint a service token against a registered platform.
+
+Diagnostic CLI for Phase 2 of the multi-tenant migration. Picks the
+first registered platform (or the one whose platform_id you pass) and
+attempts the JWT-bearer client_credentials exchange against its token
+endpoint.
+
+Usage::
+
+    docker compose exec api-gateway python -m scripts.test_service_token
+    docker compose exec api-gateway python -m scripts.test_service_token --platform <pid>
+    docker compose exec api-gateway python -m scripts.test_service_token --scope <scope>
+
+What this proves end-to-end:
+
+  * Our JWKS is reachable from Canvas (the kid in our assertion matches
+    a key the platform can verify).
+  * Canvas accepts our Developer Key as a client_credentials principal.
+  * The scopes we are asking for are actually granted in the Developer
+    Key admin page on the platform side.
+
+A successful run prints the granted scope set and the bearer's TTL.
+A 4xx from Canvas surfaces the ``error_description`` the platform sent
+so you can map it back to a missing scope or a misconfigured key.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from typing import Any
+
+from redis.asyncio import Redis
+
+from src.canvas.oauth import ServiceTokenError, get_service_token
+from src.config import settings
+from src.lti.platform_store import get_platform, list_platforms
+
+
+async def _main(platform_id: str | None, scopes: list[str], as_json: bool) -> int:
+    redis = Redis.from_url(settings.redis_url, decode_responses=False)
+    try:
+        if platform_id:
+            platform = await get_platform(redis, platform_id)
+            if platform is None:
+                print(f"No platform with id {platform_id!r}", file=sys.stderr)
+                return 2
+        else:
+            records = await list_platforms(redis)
+            if not records:
+                print(
+                    "No platforms registered. Trigger an LTI launch from Canvas first.",
+                    file=sys.stderr,
+                )
+                return 2
+            platform = records[0]
+            print(
+                f"Using first registered platform: "
+                f"{platform.platform_id} ({platform.canvas_domain})\n",
+                file=sys.stderr,
+            )
+
+        try:
+            cached = await get_service_token(
+                redis, platform, scopes, force_refresh=True
+            )
+        except ServiceTokenError as exc:
+            print(f"FAIL: {exc}", file=sys.stderr)
+            return 1
+
+        ttl_remaining = int(cached.expires_at - __import__("time").time())
+        result: dict[str, Any] = {
+            "platform_id": platform.platform_id,
+            "canvas_domain": platform.canvas_domain,
+            "token_url": platform.auth_token_url,
+            "requested_scopes": scopes,
+            "granted_scope": cached.granted_scope,
+            "ttl_seconds_remaining": ttl_remaining,
+            "access_token_preview": cached.access_token[:12] + "..." + cached.access_token[-4:],
+        }
+        if as_json:
+            json.dump(result, sys.stdout, indent=2)
+            sys.stdout.write("\n")
+        else:
+            print(f"OK")
+            for k, v in result.items():
+                print(f"  {k}: {v}")
+        return 0
+    finally:
+        await redis.aclose()
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="Mint and inspect a service token.")
+    ap.add_argument(
+        "--platform",
+        dest="platform_id",
+        default=None,
+        help="Platform id (from `list_platforms`); defaults to first registered",
+    )
+    ap.add_argument(
+        "--scope",
+        dest="scopes",
+        action="append",
+        default=None,
+        help="A scope to request (repeatable). Default: a small read-only set.",
+    )
+    ap.add_argument("--json", action="store_true", help="Emit JSON")
+    args = ap.parse_args()
+
+    # A default scope set that exercises both Canvas-specific and IMS
+    # standard scope formats so a successful response confirms both
+    # styles are parsed correctly on the platform side.
+    scopes = args.scopes or [
+        "url:GET|/api/v1/courses/:course_id/files",
+        "url:GET|/api/v1/files/:id",
+    ]
+    return asyncio.run(_main(args.platform_id, scopes, args.json))
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/src/api/_pii_approval_page.py b/src/api/_pii_approval_page.py
new file mode 100644
index 0000000..7c4f30c
--- /dev/null
+++ b/src/api/_pii_approval_page.py
@@ -0,0 +1,277 @@
+"""Self-contained HTML page rendered when a job hits the PII gate.
+
+Faculty members hitting an ``alt/{job_id}/html`` URL on a job whose
+Reflow status is ``awaiting_approval`` get this page instead of the
+raw JSON 409. It summarises the PII Reflow detected, lets the faculty
+member type a justification, and POSTs an approve/deny decision to
+``/canvas/panorama/pii-decision/{job_id}``.
+
+The page is self-contained: a tiny CSS stylesheet inline, a single
+JS function that submits the form via ``fetch`` and reloads on
+success. No external assets — Canvas's iframe sandbox blocks third-
+party origins by default, so any CDN reference would be a hassle.
+
+Why the gate exists: Reflow's PII scan flags entities like person
+names, emails, phone numbers, addresses, dates of birth, ID numbers,
+etc. For most academic documents the false-positive rate is high
+(student names in syllabus authorship, dates of birth in historical
+material, addresses in citations). The faculty member is the right
+human to decide whether the detected items are sensitive given the
+document's intended audience.
+"""
+
+from __future__ import annotations
+
+import html as _html
+from collections import Counter
+from typing import Any
+
+
+def _safe(text: str | None) -> str:
+    return _html.escape(str(text or ""))
+
+
+def _summarize_findings(findings: list[dict[str, Any]]) -> list[tuple[str, int, float]]:
+    """Group PII findings into ``(entity_type, count, max_score)`` rows.
+
+    We don't echo the actual flagged spans on the page — those are the
+    sensitive bits we're asking permission to process. The faculty
+    member already has the source PDF open elsewhere; showing them a
+    typed summary ("3 EMAIL, 1 PHONE") is enough to make the call
+    without re-exposing the data in our UI.
+    """
+    if not findings:
+        return []
+    counter: Counter[str] = Counter()
+    max_score: dict[str, float] = {}
+    for f in findings:
+        etype = (
+            f.get("entity_type")
+            or f.get("type")
+            or f.get("label")
+            or "UNKNOWN"
+        )
+        counter[etype] += 1
+        try:
+            s = float(f.get("score", 0.0) or 0.0)
+        except (TypeError, ValueError):
+            s = 0.0
+        if s > max_score.get(etype, 0.0):
+            max_score[etype] = s
+    rows = [(etype, count, max_score.get(etype, 0.0)) for etype, count in counter.items()]
+    rows.sort(key=lambda r: (-r[1], r[0]))
+    return rows
+
+
+def render_pii_approval_page(
+    *,
+    job_id: str,
+    file_name: str | None,
+    course_id: str | None,
+    findings: list[dict[str, Any]],
+    decision_url: str,
+) -> str:
+    """Return a complete HTML document with the PII approval form."""
+
+    rows = _summarize_findings(findings)
+    if rows:
+        body_rows = "\n".join(
+            f"        <tr><td>{_safe(etype)}</td><td>{count}</td>"
+            f"<td>{score:.2f}</td></tr>"
+            for etype, count, score in rows
+        )
+        findings_table = f"""
+    <table aria-describedby="findings-caption">
+      <caption id="findings-caption">Detected categories of PII in this document</caption>
+      <thead><tr><th scope="col">Category</th><th scope="col">Count</th><th scope="col">Top confidence</th></tr></thead>
+      <tbody>
+{body_rows}
+      </tbody>
+    </table>"""
+    else:
+        # Defensive: Reflow occasionally pauses with no findings list
+        # populated (race between status update and finding write).
+        findings_table = (
+            "<p><em>Reflow paused this document for PII review but no detailed "
+            "findings are available. You can still approve to proceed.</em></p>"
+        )
+
+    title = _safe(file_name) or "this document"
+
+    return f"""<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>PII review · {title}</title>
+  <style>
+    :root {{
+      --bg: #f7f8fa;
+      --card: #fff;
+      --ink: #1a1f29;
+      --muted: #5b6573;
+      --line: #e3e6eb;
+      --accent: #2563eb;
+      --approve: #15803d;
+      --approve-hover: #166534;
+      --deny: #b91c1c;
+      --deny-hover: #991b1b;
+    }}
+    * {{ box-sizing: border-box; }}
+    body {{
+      font: 15px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif;
+      background: var(--bg);
+      color: var(--ink);
+      margin: 0;
+      padding: 32px 16px;
+    }}
+    main {{
+      max-width: 720px;
+      margin: 0 auto;
+      background: var(--card);
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      padding: 28px 32px;
+      box-shadow: 0 1px 2px rgba(0,0,0,0.04);
+    }}
+    h1 {{ font-size: 20px; margin: 0 0 8px; }}
+    h2 {{ font-size: 16px; margin: 24px 0 8px; }}
+    p {{ margin: 8px 0; }}
+    .muted {{ color: var(--muted); font-size: 13px; }}
+    table {{
+      width: 100%;
+      border-collapse: collapse;
+      margin: 12px 0 24px;
+      font-size: 14px;
+    }}
+    caption {{ text-align: left; color: var(--muted); padding-bottom: 8px; font-size: 13px; }}
+    th, td {{
+      text-align: left;
+      padding: 8px 10px;
+      border-bottom: 1px solid var(--line);
+    }}
+    th {{ background: #f0f3f7; font-weight: 600; }}
+    label {{ display: block; font-weight: 600; margin: 16px 0 6px; }}
+    textarea {{
+      width: 100%;
+      min-height: 96px;
+      padding: 10px;
+      border: 1px solid var(--line);
+      border-radius: 6px;
+      font: inherit;
+      resize: vertical;
+    }}
+    textarea:focus {{ outline: 2px solid var(--accent); outline-offset: 1px; }}
+    .actions {{ display: flex; gap: 12px; margin-top: 20px; }}
+    button {{
+      flex: 1;
+      padding: 10px 16px;
+      font: inherit;
+      font-weight: 600;
+      color: #fff;
+      border: 0;
+      border-radius: 6px;
+      cursor: pointer;
+    }}
+    button[disabled] {{ opacity: 0.5; cursor: not-allowed; }}
+    .approve {{ background: var(--approve); }}
+    .approve:hover:not([disabled]) {{ background: var(--approve-hover); }}
+    .deny {{ background: var(--deny); }}
+    .deny:hover:not([disabled]) {{ background: var(--deny-hover); }}
+    #status {{
+      margin-top: 16px;
+      padding: 10px 14px;
+      border-radius: 6px;
+      font-size: 14px;
+      display: none;
+    }}
+    #status.error {{ background: #fee2e2; color: #7f1d1d; display: block; }}
+    #status.ok {{ background: #dcfce7; color: #14532d; display: block; }}
+    .meta {{ font-size: 13px; color: var(--muted); }}
+  </style>
+</head>
+<body>
+<main>
+  <h1>Privacy review needed</h1>
+  <p>Equalify Reflow detected possible personally identifiable
+  information (PII) in <strong>{title}</strong> and paused before
+  generating the accessible version. As the instructor, please review
+  the categories below and decide whether to proceed.</p>
+
+  <p class="muted">If you approve, Reflow continues generating
+  alternative formats (HTML, audio, EPUB, etc.). If you deny, the
+  source PDF is dropped from our system and no derived files are kept.</p>
+
+  <h2>What Reflow flagged</h2>
+{findings_table}
+
+  <form id="pii-form" novalidate>
+    <label for="justification">Justification (required, ≥ 10 characters)</label>
+    <textarea id="justification" name="justification"
+              minlength="10" maxlength="1000"
+              placeholder="e.g. The flagged items are author bylines and citations in a published academic article, not student records."></textarea>
+
+    <div class="actions">
+      <button type="button" class="approve" id="approve-btn">Approve and process</button>
+      <button type="button" class="deny" id="deny-btn">Deny (don't process)</button>
+    </div>
+
+    <div id="status" role="status" aria-live="polite"></div>
+
+    <p class="meta">Job ID: <code>{_safe(job_id)}</code><br>
+    Course ID: <code>{_safe(course_id)}</code></p>
+  </form>
+</main>
+
+<script>
+(function () {{
+  const decisionUrl = {decision_url!r};
+  const statusBox = document.getElementById("status");
+  const justify = document.getElementById("justification");
+  const buttons = [document.getElementById("approve-btn"), document.getElementById("deny-btn")];
+
+  function setMsg(kind, text) {{
+    statusBox.className = kind;
+    statusBox.textContent = text;
+  }}
+
+  async function submit(decision) {{
+    const justification = (justify.value || "").trim();
+    if (justification.length < 10) {{
+      setMsg("error", "Please enter at least 10 characters of justification.");
+      justify.focus();
+      return;
+    }}
+    buttons.forEach((b) => (b.disabled = true));
+    setMsg("ok", decision === "approved"
+      ? "Submitting approval — Reflow will continue processing…"
+      : "Submitting denial — the source file will be removed…");
+    try {{
+      const resp = await fetch(decisionUrl, {{
+        method: "POST",
+        credentials: "include",
+        headers: {{ "Content-Type": "application/json" }},
+        body: JSON.stringify({{ decision: decision, justification: justification }}),
+      }});
+      const payload = await resp.json().catch(() => ({{}}));
+      if (!resp.ok) {{
+        throw new Error(payload.detail || ("HTTP " + resp.status));
+      }}
+      if (decision === "approved") {{
+        setMsg("ok", "Approved. Reload this page in ~30 seconds to view the accessible version.");
+      }} else {{
+        setMsg("ok", "Denied. This document will not be processed.");
+      }}
+    }} catch (err) {{
+      setMsg("error", "Submission failed: " + (err && err.message ? err.message : err));
+      buttons.forEach((b) => (b.disabled = false));
+    }}
+  }}
+
+  document.getElementById("approve-btn").addEventListener("click", () => submit("approved"));
+  document.getElementById("deny-btn").addEventListener("click", () => submit("denied"));
+}})();
+</script>
+</body>
+</html>
+"""
diff --git a/src/api/canvas_consent.py b/src/api/canvas_consent.py
new file mode 100644
index 0000000..41f7b84
--- /dev/null
+++ b/src/api/canvas_consent.py
@@ -0,0 +1,462 @@
+"""Faculty consent / disclaimer flow.
+
+On first launch (or after a disclaimer-version bump) the LTI launch handler
+redirects faculty here. They acknowledge the data-handling disclaimer; we
+record the acknowledgment + an append-only audit entry in Redis; subsequent
+launches skip the prompt until the version changes again.
+
+Why a consent flow:
+  - Explicit user consent is a recognized mitigation under FERPA, NIST AI RMF
+    (Govern function), and most university AI / data-governance policies.
+  - It shortens InfoSec review because the data-handling story changes from
+    "silent automatic processing" to "documented user-authorized processing."
+  - Audit log gives the ISO a clean answer to "who agreed to what, when, and
+    from where."
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from fastapi import APIRouter, Cookie, Depends, Form, HTTPException, Request
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
+from redis.asyncio import Redis
+
+from ..canvas.state import (
+    CURRENT_CONSENT_VERSION,
+    ConsentRecord,
+    get_consent,
+    needs_consent,
+    put_consent,
+    revoke_consent,
+)
+from ..dependencies import get_redis_client
+from ..lti.routes import SESSION_COOKIE
+from ..lti.session import get_session
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/canvas/consent", tags=["canvas-consent"])
+
+
+# ---------------------------------------------------------------------------
+# Helper: resolve current LTI session → user_id, or 401
+# ---------------------------------------------------------------------------
+async def _current_session(
+    redis: Redis,
+    session_id: str | None,
+) -> Any:
+    if not session_id:
+        raise HTTPException(status_code=401, detail="No LTI session")
+    sess = await get_session(redis, session_id)
+    if sess is None:
+        raise HTTPException(status_code=401, detail="Expired LTI session")
+    return sess
+
+
+# ---------------------------------------------------------------------------
+# GET /canvas/consent  →  HTML page (the disclaimer)
+# ---------------------------------------------------------------------------
+# Security headers applied to every HTML response from this module.
+# - ``Content-Security-Policy`` locks the page down to its own origin with
+#   inline styles (the consent template ships its own CSS in a <style>
+#   block; no external CSS/JS is loaded). ``frame-ancestors`` lets Canvas
+#   embed this page inside its LTI iframe but blocks every other origin.
+# - ``X-Content-Type-Options`` / ``X-Frame-Options`` / ``Referrer-Policy``
+#   are belt-and-suspenders for older user agents that ignore CSP.
+# - ``Strict-Transport-Security`` is set only in production deployments
+#   (operators control this via a reverse proxy; we don't enforce here so
+#   localhost dev keeps working).
+CONSENT_SECURITY_HEADERS = {
+    "Content-Security-Policy": (
+        "default-src 'self'; "
+        "style-src 'self' 'unsafe-inline'; "
+        "script-src 'self' 'unsafe-inline'; "
+        "img-src 'self' data:; "
+        "frame-ancestors https://*.instructure.com https://*.csueb.edu "
+        "https://*.csueastbay.edu https://*.ngrok-free.dev https://*.ngrok.io; "
+        "base-uri 'self'; "
+        "form-action 'self'"
+    ),
+    "X-Content-Type-Options": "nosniff",
+    "Referrer-Policy": "same-origin",
+    "X-Frame-Options": "ALLOW-FROM https://canvas.instructure.com",
+    "Permissions-Policy": "geolocation=(), microphone=(), camera=()",
+}
+
+
+@router.get("", response_class=HTMLResponse)
+async def consent_page(
+    request: Request,
+    next: str = "/canvas/review",
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    redis: Redis = Depends(get_redis_client),
+) -> HTMLResponse:
+    """Render the consent / authorization page for the current LTI session."""
+    sess = await _current_session(redis, session_id)
+    existing = await get_consent(redis, sess.user_id)
+    already_consented = existing is not None and not needs_consent(existing)
+    return HTMLResponse(
+        _render_page(
+            user_name=sess.user_name or "",
+            next_url=next,
+            already_consented=already_consented,
+            current_version=CURRENT_CONSENT_VERSION,
+            previous_version=existing.version if existing else None,
+        ),
+        headers=CONSENT_SECURITY_HEADERS,
+    )
+
+
+# ---------------------------------------------------------------------------
+# POST /canvas/consent  →  record consent, redirect to next_url
+# ---------------------------------------------------------------------------
+@router.post("")
+async def consent_submit(
+    request: Request,
+    agree_processing: str = Form(default=""),
+    agree_pii: str = Form(default=""),
+    agree_responsibility: str = Form(default=""),
+    next_url: str = Form(default="/canvas/review"),
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    redis: Redis = Depends(get_redis_client),
+) -> RedirectResponse:
+    """Record the faculty acknowledgment and redirect back into the app."""
+    sess = await _current_session(redis, session_id)
+
+    # All three checkboxes must be checked. If any is missing, re-render the
+    # page with an error rather than recording a partial consent.
+    if not (agree_processing and agree_pii and agree_responsibility):
+        raise HTTPException(
+            status_code=400,
+            detail="You must agree to all three clauses to use Reflow.",
+        )
+
+    record = ConsentRecord(
+        user_id=sess.user_id,
+        user_name=sess.user_name,
+        user_email=sess.user_email,
+        course_id=sess.course_id,
+        version=CURRENT_CONSENT_VERSION,
+        agreed_at=time.time(),
+        user_agent=request.headers.get("user-agent"),
+        ip=request.client.host if request.client else None,
+    )
+    await put_consent(redis, record)
+    logger.info(
+        "Consent recorded: user=%s version=%s course=%s",
+        sess.user_id,
+        CURRENT_CONSENT_VERSION,
+        sess.course_id,
+    )
+    # 303 forces a GET on the next URL (we just POSTed)
+    return RedirectResponse(url=next_url, status_code=303)
+
+
+# ---------------------------------------------------------------------------
+# GET /canvas/consent/status  →  JSON probe used by panorama.js
+# ---------------------------------------------------------------------------
+@router.get("/status")
+async def consent_status(
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Return { agreed: bool, version, agreed_at } for the current user.
+
+    Used by the front-end overlay to decide whether to show the small footer
+    reminder vs the full consent modal (or to skip the dial entirely until
+    the user consents).
+    """
+    if not session_id:
+        # Public probe — return 'unknown' rather than 401 so the front-end
+        # can degrade gracefully when the overlay loads outside an LTI launch.
+        return JSONResponse({"agreed": False, "reason": "no_session"})
+    sess = await get_session(redis, session_id)
+    if sess is None:
+        return JSONResponse({"agreed": False, "reason": "expired_session"})
+    record = await get_consent(redis, sess.user_id)
+    if record is None:
+        return JSONResponse({
+            "agreed": False,
+            "reason": "never_consented",
+            "current_version": CURRENT_CONSENT_VERSION,
+        })
+    if needs_consent(record):
+        return JSONResponse({
+            "agreed": False,
+            "reason": "version_changed",
+            "previous_version": record.version,
+            "current_version": CURRENT_CONSENT_VERSION,
+        })
+    return JSONResponse({
+        "agreed": True,
+        "version": record.version,
+        "agreed_at": record.agreed_at,
+        "current_version": CURRENT_CONSENT_VERSION,
+    })
+
+
+# ---------------------------------------------------------------------------
+# POST /canvas/consent/revoke  →  admin operation
+# ---------------------------------------------------------------------------
+@router.post("/revoke")
+async def consent_revoke(
+    user_id: str = Form(...),
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Revoke a user's consent. Caller must be an admin in the LTI session.
+
+    The audit log keeps the original consent + a revoke marker so the full
+    history is preserved.
+    """
+    sess = await _current_session(redis, session_id)
+    is_admin = any(
+        r.endswith("Administrator") or r.endswith("Instructor") or "Admin" in r
+        for r in (sess.roles or [])
+    )
+    if not is_admin:
+        raise HTTPException(status_code=403, detail="Admin role required")
+    await revoke_consent(redis, user_id)
+    logger.info("Consent revoked by %s for user %s", sess.user_id, user_id)
+    return JSONResponse({"revoked": user_id})
+
+
+# ---------------------------------------------------------------------------
+# Page renderer — accessible, branded, no external CSS/JS deps
+# ---------------------------------------------------------------------------
+def _render_page(
+    *,
+    user_name: str,
+    next_url: str,
+    already_consented: bool,
+    current_version: str,
+    previous_version: str | None,
+) -> str:
+    safe_user = (user_name or "").replace("<", "&lt;").replace(">", "&gt;")
+    safe_next = (next_url or "/canvas/review").replace('"', "&quot;")
+    banner = ""
+    if already_consented:
+        banner = (
+            '<div role="status" class="banner ok">You have already '
+            "acknowledged the current disclaimer. You can proceed.</div>"
+        )
+    elif previous_version is not None:
+        banner = (
+            f'<div role="status" class="banner warn">The disclaimer was '
+            f"updated (v{previous_version} → v{current_version}). Please "
+            "re-acknowledge before continuing.</div>"
+        )
+
+    return f"""<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Reflow — Authorization &amp; Disclaimer</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    :root {{
+      --bg: #f7f9fc;
+      --card: #ffffff;
+      --ink: #1a2233;
+      --muted: #5d6b85;
+      --accent: #1f4e79;
+      --accent-hover: #163960;
+      --warn-bg: #fff4e5;
+      --warn-border: #f0b878;
+      --ok-bg: #e8f1e4;
+      --ok-border: #7cb56e;
+      --border: #d8dee9;
+      --error: #b3261e;
+    }}
+    * {{ box-sizing: border-box; }}
+    body {{
+      margin: 0;
+      padding: 0;
+      background: var(--bg);
+      font: 16px/1.55 -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+      color: var(--ink);
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }}
+    main {{
+      max-width: 760px;
+      width: 100%;
+      margin: 24px;
+      background: var(--card);
+      border: 1px solid var(--border);
+      border-radius: 10px;
+      box-shadow: 0 4px 24px rgba(0,0,0,0.06);
+      padding: 32px 36px;
+    }}
+    h1 {{
+      font-size: 24px;
+      margin: 0 0 8px;
+      color: var(--accent);
+    }}
+    .lede {{ color: var(--muted); margin: 0 0 20px; }}
+    .banner {{
+      padding: 12px 14px;
+      border-radius: 6px;
+      margin-bottom: 18px;
+      font-size: 14px;
+    }}
+    .banner.ok {{ background: var(--ok-bg); border: 1px solid var(--ok-border); }}
+    .banner.warn {{ background: var(--warn-bg); border: 1px solid var(--warn-border); }}
+    h2 {{ font-size: 16px; margin: 22px 0 8px; }}
+    ul {{ margin: 0 0 16px 22px; padding: 0; }}
+    li {{ margin-bottom: 6px; }}
+    .checks {{
+      margin: 24px 0 16px;
+      padding: 18px 20px;
+      background: #f4f7fb;
+      border: 1px solid var(--border);
+      border-radius: 6px;
+    }}
+    .checks label {{
+      display: flex;
+      align-items: flex-start;
+      gap: 10px;
+      padding: 8px 0;
+      cursor: pointer;
+    }}
+    .checks input[type=checkbox] {{
+      margin-top: 4px;
+      width: 18px;
+      height: 18px;
+      flex: 0 0 18px;
+      cursor: pointer;
+    }}
+    .checks input[type=checkbox]:focus-visible {{
+      outline: 3px solid var(--accent);
+      outline-offset: 2px;
+    }}
+    .actions {{
+      display: flex;
+      gap: 12px;
+      align-items: center;
+      margin-top: 8px;
+    }}
+    button.primary {{
+      background: var(--accent);
+      color: #fff;
+      border: none;
+      padding: 10px 22px;
+      border-radius: 6px;
+      font-size: 15px;
+      font-weight: 600;
+      cursor: pointer;
+    }}
+    button.primary:hover {{ background: var(--accent-hover); }}
+    button.primary:disabled {{
+      background: #b8c2d2;
+      cursor: not-allowed;
+    }}
+    a.cancel {{
+      color: var(--muted);
+      text-decoration: none;
+      font-size: 14px;
+    }}
+    a.cancel:hover {{ text-decoration: underline; }}
+    .meta {{
+      margin-top: 28px;
+      padding-top: 16px;
+      border-top: 1px solid var(--border);
+      color: var(--muted);
+      font-size: 13px;
+    }}
+    code {{
+      background: #ecf0f6;
+      padding: 1px 6px;
+      border-radius: 3px;
+      font-size: 13px;
+    }}
+    #error {{ color: var(--error); font-size: 14px; min-height: 1em; }}
+  </style>
+</head>
+<body>
+  <main role="main">
+    <h1>Authorization &amp; Disclaimer</h1>
+    <p class="lede">Welcome{(' ' + safe_user) if safe_user else ''}. Before using
+       Reflow, please review and acknowledge the items below.</p>
+    {banner}
+
+    <h2>What Reflow does</h2>
+    <ul>
+      <li>Reflow processes course materials <strong>you upload to Canvas</strong>
+          to generate accessible versions (HTML, ePub, audio, OCR'd PDF,
+          Braille, plain text, translations) for students.</li>
+      <li>Documents are scanned for personally identifiable information
+          (names, SSNs, addresses, phone numbers) and PII is
+          <strong>redacted</strong> before any content is sent to the Claude API.</li>
+      <li>Content is processed by Anthropic's Claude API to produce the
+          accessible output. Anthropic <strong>does not use this content for
+          model training</strong>.</li>
+      <li>An audit log records when you use the tool and what files were
+          processed. Faculty edits to accessible HTML are versioned.</li>
+    </ul>
+
+    <h2>What you are agreeing to</h2>
+    <form id="consent-form" method="POST" action="/canvas/consent">
+      <input type="hidden" name="next_url" value="{safe_next}">
+      <div class="checks" role="group" aria-labelledby="checks-label">
+        <span id="checks-label" class="sr-only">Acknowledgment checkboxes</span>
+        <label>
+          <input type="checkbox" name="agree_processing" value="yes" required>
+          <span>I authorize Reflow to process documents I upload to Canvas
+                through the Claude API for the purpose of generating accessible
+                formats.</span>
+        </label>
+        <label>
+          <input type="checkbox" name="agree_pii" value="yes" required>
+          <span>I understand that PII detection runs locally before content
+                leaves CSUEB systems, but I will avoid uploading documents
+                whose primary purpose is to convey sensitive personal data
+                (graded papers with feedback, rosters, etc.).</span>
+        </label>
+        <label>
+          <input type="checkbox" name="agree_responsibility" value="yes" required>
+          <span>I remain responsible for the content of materials I upload.
+                Reflow is an accessibility-conversion assistant, not a content
+                review service, and I will review the generated outputs before
+                publishing them to students.</span>
+        </label>
+      </div>
+      <p id="error" aria-live="polite"></p>
+      <div class="actions">
+        <button type="submit" class="primary" id="agree-btn" disabled>
+          I Agree &amp; Continue
+        </button>
+        <a class="cancel" href="about:blank" onclick="window.history.back();return false;">
+          Cancel
+        </a>
+      </div>
+    </form>
+
+    <div class="meta">
+      Disclaimer version <code>v{current_version}</code>. You may revoke this
+      authorization by contacting your campus LMS administrator. A complete
+      record of when you acknowledged this notice (and from what IP address)
+      is kept for compliance review.
+    </div>
+  </main>
+  <script>
+    (function() {{
+      var form = document.getElementById("consent-form");
+      var btn = document.getElementById("agree-btn");
+      var boxes = form.querySelectorAll('input[type=checkbox]');
+      function refresh() {{
+        var all = true;
+        boxes.forEach(function(b) {{ if (!b.checked) all = false; }});
+        btn.disabled = !all;
+      }}
+      boxes.forEach(function(b) {{ b.addEventListener("change", refresh); }});
+      refresh();
+    }})();
+  </script>
+</body>
+</html>"""
diff --git a/src/api/canvas_oauth.py b/src/api/canvas_oauth.py
new file mode 100644
index 0000000..2075609
--- /dev/null
+++ b/src/api/canvas_oauth.py
@@ -0,0 +1,379 @@
+"""HTTP routes for the per-user Canvas OAuth2 flow (Phase 8).
+
+Drives the consent redirect dance:
+
+  * ``GET /canvas/oauth/authorize`` -- requires an active LTI session.
+    Builds a CSRF state, stashes (platform, session, return_url) under
+    that state, redirects the user's browser to Canvas's
+    ``/login/oauth2/auth`` consent page.
+
+  * ``GET /canvas/oauth/callback`` -- Canvas redirects here with
+    ``?code=...&state=...`` after consent. We look up the state, swap
+    the code for tokens via ``user_oauth.exchange_code``, persist the
+    tokens, and redirect the user back to the original return_url.
+
+The actual signing helper (build a JWT bearer assertion against the
+platform's token endpoint) lives in ``canvas.oauth`` from the
+client_credentials work; we reuse it.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from fastapi import APIRouter, Cookie, Depends, HTTPException, Query, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from jwcrypto import jwk, jwt
+from redis.asyncio import Redis
+
+from ..canvas.user_oauth import (
+    OAuthState,
+    UserOAuthError,
+    exchange_code,
+    new_oauth_state_token,
+    put_user_token,
+    put_oauth_state,
+    take_oauth_state,
+    authorization_url,
+)
+from ..config import settings
+from ..dependencies import get_redis_client
+from ..lti.keys import load_private_key
+from ..lti.platform import PlatformInstall
+from ..lti.platform_store import (
+    claim_course_owner_if_unset,
+    get_platform,
+    get_platform_for_course,
+)
+from ..lti.session import SESSION_COOKIE, get_session
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/canvas/oauth", tags=["canvas-oauth"])
+
+
+# Scopes the tool requests on the user's behalf. These match the union
+# of what the watcher reads and what the bridge writes; user must have
+# permission in Canvas for each, otherwise the consent page lists fewer.
+_USER_SCOPES = [
+    "url:GET|/api/v1/courses/:course_id/files",
+    "url:GET|/api/v1/courses/:course_id/folders",
+    "url:GET|/api/v1/courses/:course_id/modules",
+    "url:GET|/api/v1/courses/:course_id/modules/:module_id/items",
+    "url:GET|/api/v1/courses/:course_id/pages",
+    "url:GET|/api/v1/courses/:course_id/pages/:url_or_id",
+    "url:GET|/api/v1/courses/:course_id/discussion_topics",
+    "url:GET|/api/v1/courses/:course_id/discussion_topics/:topic_id/entries",
+    "url:GET|/api/v1/courses/:course_id/assignments",
+    "url:GET|/api/v1/courses/:course_id/quizzes",
+    "url:GET|/api/v1/files/:id",
+    "url:GET|/api/v1/folders/:id/files",
+    "url:POST|/api/v1/courses/:course_id/pages",
+    "url:PUT|/api/v1/courses/:course_id/pages/:url_or_id",
+    "url:POST|/api/v1/conversations",
+    # Upload converted figures into a course folder so generated pages embed
+    # Canvas-hosted images (self-contained; no figure proxy).
+    "url:POST|/api/v1/courses/:course_id/files",
+]
+
+
+def _build_redirect_uri(request: Request) -> str:
+    """Compute the absolute callback URL Canvas should redirect to.
+
+    Behind ngrok/Cloudflare the auto-derived URL is wrong (scheme=http
+    when actually https). Honor ``LTI_PUBLIC_URL`` when set, same logic
+    as the LTI launch handler.
+    """
+    public_url = (getattr(settings, "lti_public_url", None) or "").rstrip("/")
+    if public_url:
+        return f"{public_url}/canvas/oauth/callback"
+    return str(request.url_for("canvas_oauth_callback"))
+
+
+def _client_assertion_for_token_endpoint(platform: PlatformInstall) -> str:
+    """Build a JWT bearer client assertion for the code/refresh exchanges.
+
+    Canvas accepts the same JWT bearer client-authentication scheme for
+    the authorization_code flow as it does for client_credentials. We
+    reuse the existing private key + JWKS infrastructure.
+    """
+    private_key = load_private_key()
+    from cryptography.hazmat.primitives import serialization
+
+    pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    key = jwk.JWK.from_pem(pem)
+    kid = key.thumbprint()
+
+    import secrets
+    now = int(time.time())
+    # Same canonical-SSO aud rule as oauth.py service-token client.
+    audience = (platform.issuer or "").rstrip("/") + "/login/oauth2/token"
+    claims: dict[str, Any] = {
+        "iss": platform.client_id,
+        "sub": platform.client_id,
+        "aud": audience,
+        "iat": now,
+        "exp": now + 300,
+        "jti": secrets.token_urlsafe(32),
+    }
+    token = jwt.JWT(
+        header={"alg": "RS256", "typ": "JWT", "kid": kid},
+        claims=claims,
+    )
+    token.make_signed_token(key)
+    return token.serialize()
+
+
+async def _platform_for_session(redis: Redis, session) -> PlatformInstall | None:
+    """Look up which Canvas platform this LTI session belongs to.
+
+    The session payload doesn't store platform_id directly; we derive it
+    from the course-to-platform map populated by the launch handler.
+    """
+    if not session.course_id:
+        return None
+    platform_id = await get_platform_for_course(redis, session.course_id)
+    if not platform_id:
+        return None
+    return await get_platform(redis, platform_id)
+
+
+@router.get("/authorize")
+async def authorize(
+    request: Request,
+    return_url: str = Query("/", description="Where to redirect after consent"),
+    popup: int = Query(0, description="1 when opened in a popup window"),
+    redis: Redis = Depends(get_redis_client),
+    reflow_lti_session: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+) -> RedirectResponse:
+    """Kick off the OAuth2 dance. Requires an active LTI session cookie."""
+
+    if not reflow_lti_session:
+        raise HTTPException(status_code=401, detail="No LTI session")
+    session = await get_session(redis, reflow_lti_session)
+    if session is None:
+        raise HTTPException(status_code=401, detail="LTI session expired")
+
+    platform = await _platform_for_session(redis, session)
+    if platform is None:
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot resolve Canvas platform for this session. "
+                   "Re-launch via the LTI link.",
+        )
+
+    is_popup = bool(popup)
+    state = new_oauth_state_token()
+    await put_oauth_state(
+        redis,
+        state,
+        OAuthState(
+            platform_id=platform.platform_id,
+            session_id=reflow_lti_session,
+            return_url=return_url,
+            popup=is_popup,
+        ),
+    )
+
+    redirect_uri = _build_redirect_uri(request)
+    url = authorization_url(
+        platform,
+        redirect_uri=redirect_uri,
+        state=state,
+        scopes=_USER_SCOPES,
+    )
+    logger.info(
+        "OAuth authorize: user=%s course=%s platform=%s popup=%s",
+        session.user_id, session.course_id, platform.platform_id, is_popup,
+    )
+
+    # Popup mode: the window opened by the overlay is already a top-level
+    # browser window (not inside Canvas's LTI iframe), so there's nothing to
+    # break out of — redirect straight to Canvas's consent page. This avoids
+    # the intermediate "Redirecting…" flash and keeps the user in a small
+    # popup that closes itself after the callback.
+    if is_popup:
+        return RedirectResponse(url=url, status_code=302)
+
+    # Canvas's /login/oauth2/auth consent page sets X-Frame-Options=DENY
+    # for security reasons. Our LTI launch lives inside Canvas's tool
+    # iframe, so a plain 302 redirect dead-ends in the iframe with a
+    # browser-blocked load. Break out to the top-level window via JS so
+    # the consent page can render in the user's main browser context.
+    # After consent + callback, we send the user back to the original
+    # LTI launch URL inside Canvas; Canvas re-launches Reflow, our
+    # handler sees the stored user_token, and skips OAuth.
+    import html as _h
+    safe_url = _h.escape(url, quote=True)
+    body = f"""<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Authorizing Reflow...</title>
+<style>body{{font:14px system-ui,sans-serif;padding:2rem;color:#1d1d1d;}}
+a{{color:#0a5fb5;}}</style></head><body>
+<p>Redirecting to Canvas for one-time authorization...</p>
+<p>If you are not redirected automatically,
+<a href="{safe_url}" target="_top" rel="noopener">click here to continue</a>.</p>
+<script>
+  // Break out of Canvas's LTI iframe. Without this, Canvas's consent
+  // page would refuse to render due to X-Frame-Options.
+  try {{
+    if (window.top && window.top !== window.self) {{
+      window.top.location.href = {repr(url)};
+    }} else {{
+      window.location.href = {repr(url)};
+    }}
+  }} catch (e) {{
+    // Cross-origin parent. Fall back to a noopener top-level nav from
+    // a click; show the link prominently.
+    window.location.href = {repr(url)};
+  }}
+</script>
+</body></html>"""
+    return HTMLResponse(content=body, status_code=200)
+
+
+@router.get("/callback", name="canvas_oauth_callback")
+async def callback(
+    request: Request,
+    code: str | None = Query(default=None),
+    state: str | None = Query(default=None),
+    error: str | None = Query(default=None),
+    error_description: str | None = Query(default=None),
+    redis: Redis = Depends(get_redis_client),
+) -> RedirectResponse:
+    """Canvas redirects here after the user approves consent."""
+
+    if error:
+        logger.warning(
+            "OAuth callback received error: %s (%s)", error, error_description,
+        )
+        # Friendly bounce-back to a static page would be nicer; for the
+        # MVP we surface the raw error so faculty can show IT what went
+        # wrong.
+        raise HTTPException(
+            status_code=400,
+            detail=f"Canvas OAuth declined: {error} ({error_description})",
+        )
+    if not code or not state:
+        raise HTTPException(status_code=400, detail="Missing code or state")
+
+    stashed = await take_oauth_state(redis, state)
+    if stashed is None:
+        raise HTTPException(status_code=400, detail="Unknown or expired state")
+
+    platform = await get_platform(redis, stashed.platform_id)
+    if platform is None:
+        raise HTTPException(status_code=400, detail="Unknown platform in state")
+
+    session = await get_session(redis, stashed.session_id)
+    if session is None:
+        # User let too much time pass between launch and consent; the
+        # launch session cookie has aged out. Send them back through.
+        raise HTTPException(
+            status_code=401,
+            detail="LTI session expired during OAuth handshake; please re-launch.",
+        )
+
+    redirect_uri = _build_redirect_uri(request)
+    # Pick client-authentication scheme based on which dev key the
+    # operator configured:
+    #   * Dual-key model (CANVAS_OAUTH_CLIENT_SECRET set in env) -- the
+    #     OAuth-side dev key is a non-LTI "API Key" that Canvas registers
+    #     WITHOUT a JWK URL. It only accepts the shared-secret POST scheme.
+    #     Sending a JWT bearer assertion here yields invalid_client because
+    #     Canvas has no JWK on file to verify it against.
+    #   * Single-key (legacy / LTI-key for both launch and OAuth) -- use
+    #     the JWT bearer assertion path, signed with our LTI private key,
+    #     which Canvas verifies against the dev key's public_jwk_url.
+    oauth_secret = getattr(settings, "canvas_oauth_client_secret", None)
+    secret_val = ""
+    if oauth_secret is not None:
+        secret_val = (
+            oauth_secret.get_secret_value()
+            if hasattr(oauth_secret, "get_secret_value")
+            else str(oauth_secret)
+        )
+    try:
+        if secret_val:
+            token = await exchange_code(
+                platform,
+                code=code,
+                redirect_uri=redirect_uri,
+                client_secret=secret_val,
+            )
+        else:
+            assertion = _client_assertion_for_token_endpoint(platform)
+            token = await exchange_code(
+                platform,
+                code=code,
+                redirect_uri=redirect_uri,
+                client_assertion=assertion,
+            )
+    except UserOAuthError as exc:
+        logger.exception("Canvas code exchange failed for user=%s", session.user_id)
+        raise HTTPException(
+            status_code=502,
+            detail=f"Canvas token exchange failed: {exc}",
+        ) from exc
+
+    # Bind the canvas user identity from the session if Canvas didn't echo
+    # it on the response (which happens when ``scope`` is empty).
+    if not token.canvas_user_id:
+        token.canvas_user_id = session.user_id
+
+    await put_user_token(
+        redis, platform.platform_id, session.user_id, token,
+    )
+    logger.info(
+        "OAuth callback: stored user_token for platform=%s user=%s scopes=%d",
+        platform.platform_id, session.user_id, len(_USER_SCOPES),
+    )
+
+    # Claim course ownership if this user is an Instructor and no
+    # owner is currently assigned. The watcher uses this owner to
+    # authorize background scans against the course. First-write-wins
+    # via Redis SET NX so two faculty completing consent near-simultaneously
+    # don't race over each other.
+    is_instructor = any(
+        "Instructor" in r or "Teacher" in r or "TeachingAssistant" in r
+        for r in (session.roles or [])
+    )
+    if is_instructor and session.course_id:
+        claimed = await claim_course_owner_if_unset(
+            redis, course_id=session.course_id, user_id=session.user_id,
+        )
+        if claimed:
+            logger.info(
+                "Course %s owner claimed by user=%s; watcher will use their token",
+                session.course_id, session.user_id,
+            )
+
+    # Popup mode: the overlay opened this flow in a small window. Don't
+    # navigate it anywhere — tell the opener (the Canvas page running the
+    # overlay) that authorization succeeded, then close ourselves. The
+    # opener re-checks status and refreshes its badges. ``postMessage``
+    # targets ``*`` because the opener is on the Canvas origin, which differs
+    # from this tool's origin; the overlay validates the message ``type``.
+    if stashed.popup:
+        body = """<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Reflow authorized</title>
+<style>body{font:14px system-ui,sans-serif;padding:2rem;color:#1d1d1d;text-align:center;}</style>
+</head><body>
+<p>✓ Reflow is authorized. You can close this window.</p>
+<script>
+  try {
+    if (window.opener && !window.opener.closed) {
+      window.opener.postMessage({ type: "reflow-oauth", ok: true }, "*");
+    }
+  } catch (e) {}
+  setTimeout(function () { try { window.close(); } catch (e) {} }, 300);
+</script>
+</body></html>"""
+        return HTMLResponse(content=body, status_code=200)
+
+    return RedirectResponse(url=stashed.return_url or "/", status_code=302)
diff --git a/src/api/canvas_panorama.py b/src/api/canvas_panorama.py
new file mode 100644
index 0000000..1508762
--- /dev/null
+++ b/src/api/canvas_panorama.py
@@ -0,0 +1,1594 @@
+"""HTTP endpoints for the Panorama-style overlay."""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from dataclasses import asdict
+from typing import Any
+
+import httpx
+from pydantic import BaseModel
+
+from fastapi import APIRouter, Body, Cookie, Depends, Header, HTTPException, Query, Request
+from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse, Response
+from redis.asyncio import Redis
+
+from ..canvas.alt_formats import (
+    canonical_html,
+    html_full_document,
+    html_to_plain_text,
+    render_audio_mp3,
+    render_braille_brf,
+    render_epub,
+    render_ocr_pdf,
+    render_reader_html,
+    render_translation,
+)
+from ..canvas.client import CanvasClient
+from ..canvas.markdown_to_html import RenderedPage, _rewrite_image_paths
+from ..canvas.sanitize import sanitize_html
+from ..canvas.wcag_checks import run_wcag_checks
+from ..canvas.panorama import (
+    Issue,
+    Score,
+    issues_from_reflow_result,
+    score_from_reflow_result,
+    source_accessibility_estimate,
+)
+from ..canvas.reflow_client import ReflowClient, rewrite_presigned_url
+from ..canvas.tenant import tk
+from ..canvas.state import (
+    append_approval_event,
+    clear_edited_html,
+    clear_processed,
+    get_approval_history,
+    get_edited_html,
+    get_job,
+    list_approval_events,
+    put_edited_html,
+    put_job,
+)
+from ..config import settings
+from ..dependencies import get_redis_client
+from ..lti.routes import SESSION_COOKIE
+from ..lti.session import get_session
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/canvas/panorama", tags=["canvas-panorama"])
+
+SCORE_CACHE_KEY = tk("canvas:score:{job_id}")
+SCORE_CACHE_TTL = 24 * 3600
+
+# Every format we can currently deliver. Source of truth shared with the
+# bundle's modal. Translation is parameterised (e.g. ``translate:es``).
+LIVE_FORMATS = ["html", "html-math", "txt", "markdown", "epub", "audio", "translate", "ocr", "immersive", "braille"]
+
+
+@router.get("/handshake")
+async def handshake(request: Request, inst: str = Query(...)) -> JSONResponse:
+    return JSONResponse(
+        {
+            "inst": inst,
+            "expires_at": int(time.time()) + 3600,
+            "endpoints": {
+                "score": "/canvas/panorama/score",
+                "issues": "/canvas/panorama/issues",
+                "alt": "/canvas/panorama/alt",
+                "edit": "/canvas/panorama/edit",
+            },
+        }
+    )
+
+
+@router.get("/score")
+async def score(
+    course_id: str = Query(...),
+    file_ids: str = Query(...),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    ids = [f.strip() for f in file_ids.split(",") if f.strip()]
+    if len(ids) > 50:
+        raise HTTPException(status_code=400, detail="Too many file_ids; cap is 50")
+    out: dict[str, dict[str, Any]] = {}
+    for fid in ids:
+        job_id = await _lookup_job_for_file(redis, course_id, fid)
+        if job_id is None:
+            out[fid] = {"status": "unscanned"}
+            continue
+        out[fid] = await _build_score_payload(redis, job_id)
+    return JSONResponse({"course_id": course_id, "scores": out})
+
+
+@router.get("/scored_files")
+async def scored_files(
+    course_id: str = Query(...),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """All scored files in a course keyed by display filename.
+
+    When the same filename appears in multiple canvas-bridge records
+    (e.g. faculty re-uploaded the PDF), we surface the **best**
+    candidate per filename using the same priority rank as
+    ``_lookup_job_for_file``. This prevents a stale failed job from
+    masking a successful re-conversion of the same document.
+    """
+    jobs = await _all_canvas_jobs_for_course(redis, course_id)
+    # Group by filename, then pick the best candidate per group.
+    by_name: dict[str, list[dict[str, Any]]] = {}
+    for data in jobs:
+        filename = str(data.get("canvas_file_name") or "")
+        if not filename:
+            continue
+        by_name.setdefault(filename, []).append(data)
+
+    out: dict[str, dict[str, Any]] = {}
+    for filename, candidates in by_name.items():
+        candidates.sort(key=_job_rank)
+        best = candidates[0]
+        job_id = str(best.get("reflow_job_id"))
+        payload = await _build_score_payload(redis, job_id)
+        payload["job_id"] = job_id
+        payload["canvas_file_id"] = best.get("canvas_file_id")
+        payload["edited"] = bool(await get_edited_html(redis, job_id))
+        out[filename] = payload
+    return JSONResponse({"course_id": course_id, "by_filename": out})
+
+
+@router.get("/score_by_job")
+async def score_by_job(
+    job_ids: str = Query(...),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Score payloads keyed by reflow job id.
+
+    The overlay uses this to decorate the *accessible-version* link in a
+    published Canvas Page (``/canvas/panorama/alt/{job_id}/html``). Unlike
+    ``/score`` — which resolves a Canvas *file* id to a job and shows the
+    original PDF's source estimate — this returns the job directly so the
+    accessible link can show the WCAG accessibility of the generated output
+    (the "after" number).
+    """
+    ids = [j.strip() for j in job_ids.split(",") if j.strip()]
+    if len(ids) > 50:
+        raise HTTPException(status_code=400, detail="Too many job_ids; cap is 50")
+    out: dict[str, dict[str, Any]] = {}
+    for jid in ids:
+        out[jid] = await _build_score_payload(redis, jid)
+    return JSONResponse({"scores": out})
+
+
+@router.get("/oauth_status")
+async def oauth_status(
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Whether the current instructor has authorized Reflow against Canvas.
+
+    The overlay calls this on load. Authorization is per (platform, user):
+    without it the watcher can't read this instructor's course files and the
+    bridge can't publish accessible Pages on their behalf. When
+    ``is_instructor`` is true and ``authorized`` is false, the overlay shows
+    an "Authorize Reflow" prompt (opened in a popup, not a full-window nav).
+
+    Always 200 with a JSON body — the overlay treats a missing/expired
+    session as simply "not authorized" rather than an error.
+    """
+    from ..canvas.user_oauth import get_user_token
+    from ..lti.platform_store import get_platform_for_course
+
+    out: dict[str, Any] = {
+        "has_session": False,
+        "is_instructor": False,
+        "authorized": False,
+    }
+    if not session_id:
+        return JSONResponse(out)
+    sess = await get_session(redis, session_id)
+    if sess is None:
+        return JSONResponse(out)
+    out["has_session"] = True
+    out["is_instructor"] = any(
+        ("Instructor" in r) or ("Teacher" in r) or ("TeachingAssistant" in r)
+        for r in (sess.roles or [])
+    )
+    if not sess.course_id:
+        return JSONResponse(out)
+    platform_id = await get_platform_for_course(redis, sess.course_id)
+    if not platform_id:
+        return JSONResponse(out)
+    try:
+        token = await get_user_token(redis, platform_id, sess.user_id)
+    except Exception:  # noqa: BLE001
+        token = None
+    # Authorized if a token exists and is either still valid or renewable
+    # via a stored refresh_token (silent refresh on next use).
+    if token is not None and (
+        not token.is_expired() or bool(getattr(token, "refresh_token", ""))
+    ):
+        out["authorized"] = True
+    return JSONResponse(out)
+
+
+@router.get("/issues/{file_id}")
+async def issues(
+    file_id: str,
+    course_id: str = Query(...),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    job_id = await _lookup_job_for_file(redis, course_id, file_id)
+    if job_id is None:
+        return JSONResponse({"file_id": file_id, "issues": []})
+    reflow = ReflowClient()
+    status = await reflow.get_status(job_id)
+    signals = status.get("signals") or {}
+    items: list[Issue] = issues_from_reflow_result(signals) if signals else []
+    return JSONResponse({"file_id": file_id, "issues": [asdict(i) for i in items]})
+
+
+@router.get("/wcag/{job_id}")
+async def wcag_report(
+    job_id: str,
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Phase 7a: automated WCAG checks against the job's rendered HTML.
+
+    Returns a structured report with per-rule findings and an overall
+    ``passed`` boolean. Used by the panorama overlay to populate the
+    reviewer's pre-publish checklist and by ``approve_job`` to enforce
+    the publication gate. Requires instructor auth -- the report
+    surfaces the rendered HTML's structure which we don't want public.
+    """
+    _job, _sess = await _require_instructor(redis, session_id, job_id)
+    rendered = await _resolve_html(redis, job_id)
+    full = html_full_document(rendered, mathjax=False)
+    report = run_wcag_checks(full)
+    return JSONResponse(report.to_json())
+
+
+# ---- Editable accessible HTML --------------------------------------------
+
+@router.get("/edit/{job_id}")
+async def get_edit(
+    job_id: str,
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Return the current editable HTML for a job.
+
+    Requires an LTI session bound to the same Canvas course as the job
+    AND an instructor-class role (Teacher/TA/Admin). Returns the
+    faculty-edited HTML when one exists, otherwise the auto-generated
+    canonical HTML rendered from Reflow's markdown.
+    """
+    # Auth gate -- same check approve/reject use. Raises 401/403/404.
+    job, _sess = await _require_instructor(redis, session_id, job_id)
+
+    edited = await get_edited_html(redis, job_id)
+    if edited:
+        return JSONResponse({"job_id": job_id, "edited": True, "html": edited,
+                             "title": job.canvas_file_name})
+
+    # Fall back to canonical HTML built from Reflow markdown.
+    rendered = await _build_canonical_html(redis, job_id)
+    return JSONResponse({"job_id": job_id, "edited": False, "html": rendered.html,
+                         "title": rendered.title})
+
+
+@router.put("/edit/{job_id}")
+async def put_edit(
+    job_id: str,
+    request: Request,
+    body: dict = Body(...),
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    csrf_token: str | None = Header(default=None, alias="X-CSRF-Token"),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Save a faculty-edited HTML body. Requires instructor + CSRF token.
+
+    Phase 5 sanitization is applied: incoming HTML runs through the
+    academic-content allowlist (see ``src/canvas/sanitize.py``) before
+    storage. ``<script>``, ``on*=`` handlers, ``javascript:`` URLs,
+    and unknown tags are stripped. If sanitization leaves an empty
+    body, we return 400 rather than store a useless edit.
+    """
+    _job, _sess = await _require_instructor(redis, session_id, job_id)
+    _require_csrf(session_id, csrf_token)
+    _require_trusted_origin(request)
+
+    html = (body or {}).get("html")
+    if not isinstance(html, str) or not html.strip():
+        raise HTTPException(status_code=400, detail="Body must include non-empty 'html'")
+    if len(html) > 5_000_000:
+        raise HTTPException(status_code=413, detail="Edited HTML too large (5MB cap)")
+    # Phase 5: sanitize against the academic-content allowlist before
+    # persisting. Any <script>, on*=, javascript:, or unknown tag is
+    # stripped here so downstream reads (panorama overlay, students)
+    # never see active content from a possibly-compromised editor.
+    try:
+        clean = sanitize_html(html)
+    except RuntimeError as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+    if not clean.strip():
+        raise HTTPException(
+            status_code=400,
+            detail="Edited HTML was empty after sanitization (only disallowed content was present)",
+        )
+    await put_edited_html(redis, job_id, clean)
+    return JSONResponse({"job_id": job_id, "edited": True})
+
+
+@router.delete("/edit/{job_id}")
+async def delete_edit(
+    job_id: str,
+    request: Request,
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    csrf_token: str | None = Header(default=None, alias="X-CSRF-Token"),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Discard the faculty edit; subsequent fetches return canonical HTML.
+
+    Same auth + CSRF gates as PUT.
+    """
+    _job, _sess = await _require_instructor(redis, session_id, job_id)
+    _require_csrf(session_id, csrf_token)
+    _require_trusted_origin(request)
+
+    await clear_edited_html(redis, job_id)
+    return JSONResponse({"job_id": job_id, "edited": False})
+
+
+# ---- Alternative formats -------------------------------------------------
+
+@router.get("/alt/{job_id}/{fmt}")
+async def alt_format(
+    job_id: str,
+    fmt: str,
+    preview: bool = Query(default=False),
+    redis: Redis = Depends(get_redis_client),
+) -> Response:
+    """Serve any supported alternative format derived from the canonical HTML.
+
+    Faculty-approval gate: only ``status == "published"`` jobs are visible to
+    students. Instructors can preview drafts by passing ``?preview=1`` from the
+    Alt Formats modal. The front-end sets this automatically when the current
+    user has an Instructor role.
+    """
+    job = await get_job(redis, job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail="Unknown job")
+
+    # Faculty approval gate — students never see drafts.
+    # Status values:
+    #   "processing"       — pipeline running, no output yet
+    #   "awaiting_review"  — faculty needs to approve before students can see
+    #   "published"        — approved, all alt formats live
+    #   "rejected" | "failed" — terminal, never expose to students
+    if job.status != "published" and not preview:
+        msg = {
+            "processing": "Reflow is still processing this document. Please check back shortly.",
+            "awaiting_review": "This accessible version is pending faculty review.",
+            "rejected": "The faculty member chose not to publish this alternative version.",
+            "failed": "Reflow could not generate an accessible version of this document.",
+        }.get(job.status, "This alternative version is not available.")
+        raise HTTPException(status_code=403, detail=msg)
+
+    # PII gate: before attempting to render anything, check whether the
+    # upstream Reflow job is paused at awaiting_approval. If it is, the
+    # faculty member needs to make a privacy call before we can proceed.
+    # For interactive HTML formats we render the approval UI inline; for
+    # downloadable formats (epub, audio, braille) we return a clear 409
+    # pointing the caller back at the HTML URL so they can act on it.
+    pii_gate = await _maybe_pii_gate_response(job_id, job, fmt)
+    if pii_gate is not None:
+        return pii_gate
+
+    # Markdown bypasses HTML — it's a separate pivot for power users.
+    if fmt == "markdown":
+        markdown = await _fetch_markdown(redis, job_id)
+        return PlainTextResponse(markdown, media_type="text/markdown")
+
+    # All other formats derive from canonical or edited HTML.
+    rendered = await _resolve_html(redis, job_id)
+
+    if fmt == "html":
+        return HTMLResponse(html_full_document(rendered, mathjax=False))
+    if fmt == "html-math":
+        return HTMLResponse(html_full_document(rendered, mathjax=True))
+    if fmt == "txt":
+        return PlainTextResponse(html_to_plain_text(rendered))
+    if fmt == "epub":
+        try:
+            data = render_epub(rendered)
+        except RuntimeError as exc:
+            raise HTTPException(status_code=503, detail=str(exc)) from exc
+        return Response(
+            data,
+            media_type="application/epub+zip",
+            headers={"Content-Disposition": f"attachment; filename=\"{_safe(job.canvas_file_name)}.epub\""},
+        )
+    if fmt == "audio":
+        try:
+            audio = render_audio_mp3(rendered)
+        except RuntimeError as exc:
+            raise HTTPException(status_code=503, detail=str(exc)) from exc
+        return Response(audio, media_type="audio/mpeg",
+                        headers={"Content-Disposition": f"attachment; filename=\"{_safe(job.canvas_file_name)}.mp3\""})
+    if fmt == "immersive":
+        # Immersive-Reader-style standalone HTML using browser Web Speech API.
+        return HTMLResponse(render_reader_html(rendered))
+
+    if fmt == "braille":
+        try:
+            brf = render_braille_brf(rendered)
+        except RuntimeError as exc:
+            raise HTTPException(status_code=503, detail=str(exc)) from exc
+        return Response(
+            brf,
+            media_type="application/x-brf",
+            headers={"Content-Disposition": f"attachment; filename=\"{_safe(job.canvas_file_name)}.brf\""},
+        )
+
+    if fmt == "ocr" or fmt == "pdf-tagged":
+        # Searchable (OCR) PDF. Operates on the original PDF bytes, fetched
+        # from Canvas via the source file id stored on the job. ``pdf-tagged``
+        # is accepted as a legacy alias for the same output (older page stubs
+        # / cached links may still request it).
+        if not job.canvas_file_id:
+            raise HTTPException(status_code=409, detail="No source file id on job")
+        canvas = CanvasClient()
+        try:
+            pdf_bytes = await canvas.download_file(str(job.canvas_file_id))
+        except Exception as exc:
+            raise HTTPException(status_code=502, detail=f"Could not fetch source PDF: {exc}") from exc
+        try:
+            ocr_pdf = render_ocr_pdf(pdf_bytes, archival=True)
+        except RuntimeError as exc:
+            raise HTTPException(status_code=503, detail=str(exc)) from exc
+        return Response(
+            ocr_pdf,
+            media_type="application/pdf",
+            headers={"Content-Disposition": f"attachment; filename=\"{_safe(job.canvas_file_name)}.searchable.pdf\""},
+        )
+
+    if fmt.startswith("translate:"):
+        lang = fmt.split(":", 1)[1] or "es"
+        try:
+            translated = await render_translation(rendered, lang)
+        except RuntimeError as exc:
+            raise HTTPException(status_code=503, detail=str(exc)) from exc
+        return HTMLResponse(html_full_document(translated))
+
+    raise HTTPException(status_code=404, detail=f"Format not available: {fmt}")
+
+
+# ---- Helpers -------------------------------------------------------------
+
+async def _build_score_payload(redis: Redis, job_id: str) -> dict[str, Any]:
+    """Compute or read cached score + available formats for a job."""
+    cached = await redis.get(SCORE_CACHE_KEY.format(job_id=job_id))
+    if cached:
+        payload = json.loads(cached)
+    else:
+        try:
+            s = await _compute_score(job_id, redis=redis)
+            payload = asdict(s)
+            await redis.set(
+                SCORE_CACHE_KEY.format(job_id=job_id),
+                json.dumps(payload),
+                ex=SCORE_CACHE_TTL,
+            )
+        except Exception:
+            logger.exception("Score computation failed for %s", job_id)
+            # Even on score-computation failure, surface enough metadata for
+            # the front-end to render the approval bar / DRAFT badge. The
+            # approval flow only depends on job.status, not on the score.
+            fallback_job = await get_job(redis, job_id)
+            fb = {
+                "status": "processing",
+                "job_id": job_id,
+                "available_formats": list(LIVE_FORMATS),
+                "job_status": fallback_job.status if fallback_job else "processing",
+            }
+            if fallback_job is not None and getattr(fallback_job, "error", None):
+                fb["error"] = fallback_job.error
+            return fb
+    # Always overwrite available_formats from the live LIVE_FORMATS list so
+    # new format renderers light up as soon as they're added server-side.
+    payload["available_formats"] = list(LIVE_FORMATS)
+    # Respect ``score_from_reflow_result``'s status ("scored" vs
+    # "unscanned"); the previous unconditional override forced every
+    # row to "scored" and contributed to the misleading flat-15 display.
+    payload.setdefault("status", "scored")
+    payload["job_id"] = job_id
+    # Surface the job's lifecycle status separately ("awaiting_review",
+    # "published", "rejected", "processing", "failed") so the front-end
+    # can render the approval bar / preview gate.
+    job = await get_job(redis, job_id)
+    if job is not None:
+        payload["job_status"] = job.status
+        # Before→after story. ``score`` (above) is the WCAG accessibility of
+        # the generated accessible version — the "after". Here we attach a
+        # coarse estimate of the ORIGINAL PDF's accessibility — the "before"
+        # — derived from how the pipeline classified the source (scanned vs
+        # born-digital, OCR'd, text layer present). The overlay shows the
+        # source estimate on the Original-PDF dial and the WCAG score on the
+        # accessible version, so faculty see the lift the conversion gave.
+        src_score, src_sev = source_accessibility_estimate(getattr(job, "signals", None))
+        if src_score is not None:
+            payload["source_score"] = src_score
+            payload["source_severity"] = src_sev
+        # Surface the failure reason so the overlay can *tell the
+        # professor why* a file isn't ready, instead of rendering a
+        # blank dial. Only set when present; students never see this
+        # (the front-end gates the status dial to instructors).
+        if getattr(job, "error", None):
+            payload["error"] = job.error
+        # Phase 8: surface the Canvas Page URL so the panorama overlay
+        # can promote the published Canvas Page as the *primary*
+        # student-facing artifact. The PDF link in Canvas's Files UI
+        # is still shown but labeled "Original PDF (source copy)".
+        if getattr(job, "canvas_page_url", None):
+            payload["canvas_page_url"] = job.canvas_page_url
+        if getattr(job, "canvas_page_id", None):
+            payload["canvas_page_id"] = job.canvas_page_id
+    return payload
+
+
+# Lower number = more "deliverable" job state. We pick the lowest score
+# among candidate jobs, and among ties take the most recently created.
+# Faculty intent (published / awaiting_review / processing) always beats
+# terminal failures, so a stale failed job for an old file_id never wins
+# over a fresh-but-still-converting job for the same document.
+_STATUS_PRIORITY: dict[str, int] = {
+    "published": 0,
+    "awaiting_review": 1,
+    "processing": 2,
+    "awaiting_approval": 2,
+    "pii_scanning": 2,
+    "processing_queued": 2,
+    # Conversion succeeded but the Canvas Page write was rejected (missing
+    # Pages scope). Ranks below in-flight states (a still-converting job may
+    # yet produce a page) but above rejected/failed so it surfaces over a
+    # stale failed sibling and faculty see the actionable reason.
+    "page_failed": 5,
+    "rejected": 8,  # rejected reflects faculty intent; rank above failed
+    "failed": 9,
+    "denied": 9,
+}
+
+
+def _job_rank(data: dict[str, Any]) -> tuple[int, float]:
+    """Sort key: lower priority + newer first.
+
+    Returns ``(priority, -created_at)`` so Python's ascending sort puts
+    the best candidate at index 0. Unknown statuses fall to the bottom.
+    """
+    status = str(data.get("status") or "").lower()
+    pri = _STATUS_PRIORITY.get(status, 7)
+    try:
+        ts = float(data.get("created_at") or 0)
+    except (TypeError, ValueError):
+        ts = 0.0
+    # Negate ts so newer (larger) is preferred among equal-priority rows.
+    return (pri, -ts)
+
+
+async def _all_canvas_jobs_for_course(
+    redis: Redis, course_id: str
+) -> list[dict[str, Any]]:
+    """Walk every canvas-bridge record for one course. Cached per request."""
+    out: list[dict[str, Any]] = []
+    cursor = 0
+    while True:
+        cursor, keys = await redis.scan(
+            cursor=cursor, match=tk("canvas:job:*"), count=200
+        )
+        for raw in keys:
+            key = raw.decode() if isinstance(raw, bytes) else raw
+            raw_val: Any = await redis.get(key)
+            if not raw_val:
+                continue
+            try:
+                data = json.loads(raw_val)
+            except (ValueError, TypeError):
+                continue
+            if str(data.get("canvas_course_id")) != str(course_id):
+                continue
+            out.append(data)
+        if cursor == 0:
+            return out
+
+
+async def _lookup_job_for_file(
+    redis: Redis, course_id: str, canvas_file_id: str
+) -> str | None:
+    """Best-job resolver for ``(course_id, canvas_file_id)``.
+
+    Why this isn't just "first match on file_id":
+    when a faculty member re-uploads the same PDF, Canvas issues a new
+    ``canvas_file_id`` each time but the ``canvas_file_name`` stays
+    constant. The Files UI may surface only one of those entries, and
+    not necessarily the one whose conversion succeeded. To do the
+    intuitive thing, we widen the search to include all canvas jobs in
+    the course sharing this file's filename, then pick the best.
+
+    Algorithm:
+      1. Collect every canvas-bridge record in this course.
+      2. If any matches by ``canvas_file_id``, use its ``canvas_file_name``
+         to widen the candidate set to all jobs with the same filename.
+         This handles the re-upload case where the anchor record happens
+         to be a failed early attempt.
+      3. Rank candidates by status priority (``published`` >
+         ``awaiting_review`` > ``processing`` > terminal failures), then
+         by recency. Return the winner's reflow_job_id.
+      4. If no file_id match exists at all, return None — the watcher
+         hasn't seen this file yet.
+    """
+    jobs = await _all_canvas_jobs_for_course(redis, course_id)
+    if not jobs:
+        return None
+    fid = str(canvas_file_id)
+    # 1. Direct file_id matches
+    fid_matches = [j for j in jobs if str(j.get("canvas_file_id")) == fid]
+    if fid_matches:
+        # Use the filename from any anchor record to widen the search.
+        filename = None
+        for j in fid_matches:
+            fn = j.get("canvas_file_name")
+            if fn:
+                filename = str(fn)
+                break
+        if filename:
+            candidates = [
+                j
+                for j in jobs
+                if str(j.get("canvas_file_name") or "") == filename
+            ]
+        else:
+            candidates = fid_matches
+    else:
+        return None
+    candidates.sort(key=_job_rank)
+    winner = candidates[0]
+    return str(winner.get("reflow_job_id"))
+
+
+def _accessibility_score_from_wcag(report: Any) -> int:
+    """0-100 accessibility score from a WCAG check report on the OUTPUT HTML.
+
+    Errors weigh heavily (real blockers — missing alt text, no headings,
+    missing language); warnings lightly. A clean document scores 100, floored
+    at 0. This is what the dial shows: the accessibility of what students
+    actually receive, so faculty edits (e.g. adding alt text) move the number.
+    """
+    errors = sum(1 for f in report.findings if f.severity == "error")
+    warnings = sum(1 for f in report.findings if f.severity == "warning")
+    return max(0, min(100, 100 - 12 * errors - 3 * warnings))
+
+
+async def _compute_score(job_id: str, redis: Redis | None = None) -> Score:
+    """Accessibility score for the dial: run the WCAG checks on the generated
+    HTML (the accessible output students receive) and score it.
+
+    This scores the OUTPUT's accessibility, not the source PDF's conversion
+    fidelity — so a clean accessible page reads high, problems (missing alt
+    text, headings, language) pull it down, and faculty edits move the number.
+    Per-file variance is real because it reflects each document's actual HTML.
+    Falls back to 'unscanned' when the HTML can't be resolved yet (job not
+    completed, or Reflow unavailable) so we never fabricate a number.
+
+    (The older conversion-quality heuristic — ``score_from_reflow_result`` over
+    ``job.signals`` — is retained in the codebase but no longer drives the dial;
+    it pinned most documents at ~80 because the image-alt signal failed broadly.)
+    """
+    from ..canvas.panorama import severity_of
+
+    if redis is None:
+        return Score(score=None, severity=None,
+                     available_formats=list(LIVE_FORMATS), status="unscanned")
+    try:
+        rendered = await _resolve_html(redis, job_id)
+        report = run_wcag_checks(html_full_document(rendered, mathjax=False))
+        score = _accessibility_score_from_wcag(report)
+        return Score(score=score, severity=severity_of(score),
+                     available_formats=list(LIVE_FORMATS), status="scored")
+    except Exception:
+        logger.exception("Accessibility (WCAG) score failed for %s", job_id)
+        return Score(score=None, severity=None,
+                     available_formats=list(LIVE_FORMATS), status="unscanned")
+
+
+async def _fetch_markdown(redis: Redis, job_id: str) -> str:
+    reflow = ReflowClient()
+    status = await reflow.get_status(job_id)
+    if status.get("status") != "completed":
+        raise HTTPException(
+            status_code=409,
+            detail=f"Job not yet completed (status: {status.get('status')})",
+        )
+    markdown_url = status.get("markdown_url") or status.get("result_url")
+    if not markdown_url:
+        raise HTTPException(status_code=500, detail="Completed job is missing markdown_url")
+    return await reflow.fetch_markdown(markdown_url)
+
+
+async def _maybe_pii_gate_response(
+    job_id: str,
+    job: Any,
+    fmt: str,
+) -> Response | None:
+    """If the Reflow job is paused at awaiting_approval, return a gate response.
+
+    For ``fmt in {"html", "html-math"}`` we render the inline approval UI
+    so faculty can act without leaving the browser. For every other format
+    we 409 with a structured payload that includes the URL to the gate
+    page; the front-end can deep-link there from a button in the alt-
+    formats modal.
+
+    Returns ``None`` when the job is not paused on PII review (the caller
+    proceeds to normal rendering). Returns a Response otherwise.
+
+    Failure modes are tolerant: if Reflow itself errors here, we let the
+    downstream renderer (which calls Reflow again) surface the real
+    error rather than masking it with a misleading "PII gate" message.
+    """
+    from ._pii_approval_page import render_pii_approval_page
+
+    try:
+        reflow = ReflowClient()
+        status = await reflow.get_status(job_id)
+    except Exception as exc:  # noqa: BLE001 — best-effort gate check
+        logger.debug("PII gate check skipped (Reflow status unavailable): %s", exc)
+        return None
+
+    if status.get("status") != "awaiting_approval":
+        return None
+
+    findings = status.get("pii_findings") or status.get("pii") or []
+    file_name = getattr(job, "canvas_file_name", None)
+    course_id = getattr(job, "canvas_course_id", None)
+    decision_url = f"/canvas/panorama/pii-decision/{job_id}"
+
+    if fmt in ("html", "html-math"):
+        page = render_pii_approval_page(
+            job_id=job_id,
+            file_name=file_name,
+            course_id=course_id,
+            findings=findings,
+            decision_url=decision_url,
+        )
+        # 200 so the iframe doesn't render an error chrome around the page;
+        # the body itself communicates the gated state.
+        return HTMLResponse(page, status_code=200)
+
+    # Non-interactive format. The 409 payload tells the front-end exactly
+    # where to send the faculty member so they can complete the gate.
+    return JSONResponse(
+        status_code=409,
+        content={
+            "detail": "Job is paused awaiting PII review. Open the HTML "
+            "view to approve or deny processing.",
+            "status": "awaiting_approval",
+            "approval_url": (
+                f"/canvas/panorama/alt/{job_id}/html"
+            ),
+            "pii_finding_count": len(findings),
+        },
+    )
+
+
+async def _build_canonical_html(redis: Redis, job_id: str) -> RenderedPage:
+    """Auto-generate the canonical accessible HTML from Reflow output.
+
+    Phase 5 sanitization is applied to the rendered HTML body before
+    returning. The AI conversion pipeline isn't supposed to emit
+    ``<script>`` -- but "supposed to" isn't a security control, and the
+    pipeline IS a remote service we don't fully trust. Same allowlist
+    as the edit path; consistent behavior keeps the testable surface
+    tractable.
+    """
+    job = await get_job(redis, job_id)
+    title = (job.canvas_file_name if job else "Document").rsplit(".pdf", 1)[0]
+    markdown = await _fetch_markdown(redis, job_id)
+    # Embed Canvas-hosted figures. The bridge uploads each figure into a
+    # course folder and records the markdown-ref -> Canvas-file-URL map on the
+    # job; rewrite the relative ``figures/<id>.png`` refs to those Canvas URLs
+    # so these accessible-HTML views use the same self-contained images as the
+    # Canvas Page. (The old figure proxy is gone — Canvas serves the images.)
+    fig_map = (getattr(job, "figure_canvas_urls", None) if job else None) or {}
+    for ref, fig_url in fig_map.items():
+        markdown = markdown.replace(ref, fig_url)
+    rendered = canonical_html(markdown, title=title)
+    # Wrap the rendered page through sanitize before passing it back.
+    # RenderedPage is a simple dataclass; mutate ``html`` in place.
+    try:
+        rendered.html = sanitize_html(rendered.html)
+    except RuntimeError:
+        logger.exception("sanitize_html failed on canonical render for %s", job_id)
+    return rendered
+
+
+async def _resolve_html(redis: Redis, job_id: str) -> RenderedPage:
+    """Prefer faculty-edited HTML; fall back to canonical."""
+    edited = await get_edited_html(redis, job_id)
+    job = await get_job(redis, job_id)
+    title = (job.canvas_file_name if job else "Document").rsplit(".pdf", 1)[0]
+    if edited:
+        return RenderedPage(title=title, html=edited)
+    return await _build_canonical_html(redis, job_id)
+
+
+def _safe(name: str | None) -> str:
+    """Sanitize for Content-Disposition filename headers."""
+    if not name:
+        return "document"
+    return "".join(c if c.isalnum() or c in "-._ " else "_" for c in name).strip()
+
+
+# ---------------------------------------------------------------------------
+# Faculty approval flow — explicit approve / reject / request-edits gate
+# ---------------------------------------------------------------------------
+# Reflow always lands new conversions in awaiting_review state. Instructors
+# review the auto-generated HTML in the in-modal editor; once they're happy,
+# they hit Approve and the alt formats become visible to students. Every
+# transition is audit-logged with actor + timestamp + optional comment so
+# the ISO can pull a complete history at any time.
+
+
+async def _require_instructor(
+    redis: Redis,
+    session_id: str | None,
+    job_id: str,
+):
+    """Return (job, session) when the caller is an instructor in the right
+    course; otherwise raise. Centralizes the auth check for approve/reject.
+
+    On success, binds the session's ``user_id`` and ``course_id`` into the
+    logging contextvars so every line emitted by the downstream handler
+    carries the actor identity automatically.
+    """
+    from ..logging_setup import course_id_var, user_id_var
+
+    if not session_id:
+        raise HTTPException(status_code=401, detail="No LTI session")
+    sess = await get_session(redis, session_id)
+    if sess is None:
+        raise HTTPException(status_code=401, detail="Expired LTI session")
+    is_instructor = any(
+        r.endswith("Instructor")
+        or r.endswith("Administrator")
+        or "TeachingAssistant" in r
+        or "Admin" in r
+        for r in (sess.roles or [])
+    )
+    if not is_instructor:
+        raise HTTPException(status_code=403, detail="Instructor role required")
+    job = await get_job(redis, job_id)
+    if job is None or job.canvas_course_id != sess.course_id:
+        raise HTTPException(status_code=404, detail="Unknown job")
+
+    # Identity is now established; bind it for the remainder of the request.
+    user_id_var.set(sess.user_id)
+    course_id_var.set(sess.course_id)
+
+    return job, sess
+
+
+# --- CSRF + origin allowlist ---------------------------------------------
+#
+# CSRF token strategy: HMAC the session_id with a server-side secret.
+# This is stateless (no separate Redis lookup) and naturally rotates
+# when the LTI session rotates. The token is fetched once by the
+# panorama JS via GET /canvas/panorama/csrf and echoed back on every
+# state-changing request as the X-CSRF-Token header. Without a valid
+# session cookie there's no token to derive, so the same code path
+# fails closed.
+#
+# Origin allowlist: in the LTI iframe context the browser always sends
+# an Origin header matching the Canvas host. We compare against
+# ``settings.canvas_allowed_origins`` (comma-separated list). When
+# unset we fall back to *permissive* in dev only; production deploys
+# MUST set the env var or the gate will refuse cross-origin writes.
+
+import hmac as _hmac
+import hashlib as _hashlib
+
+def _csrf_secret() -> bytes:
+    """Return the secret used to HMAC CSRF tokens.
+
+    We prefer an explicit ``csrf_secret_key`` setting; fall back to the
+    LTI private key fingerprint so a freshly-bootstrapped dev env still
+    has a stable derivation source without extra config.
+    """
+    raw = getattr(settings, "csrf_secret_key", "") or ""
+    if hasattr(raw, "get_secret_value"):
+        raw = raw.get_secret_value()
+    if raw:
+        return str(raw).encode("utf-8")
+    # Fallback: hash the LTI public key path + a fixed app constant.
+    # Stable across restarts in a given deploy. Not "secret" in a
+    # cryptographic sense, but raises the bar over a hardcoded constant.
+    seed = f"equalify-reflow:csrf:{getattr(settings, 'lti_public_key_path', '')}"
+    return _hashlib.sha256(seed.encode("utf-8")).digest()
+
+
+def _csrf_token_for(session_id: str) -> str:
+    return _hmac.new(_csrf_secret(), session_id.encode("utf-8"), _hashlib.sha256).hexdigest()
+
+
+def _require_csrf(session_id: str | None, supplied: str | None) -> None:
+    if not session_id:
+        raise HTTPException(status_code=401, detail="No LTI session")
+    if not supplied:
+        raise HTTPException(status_code=403, detail="Missing X-CSRF-Token header")
+    expected = _csrf_token_for(session_id)
+    # ``hmac.compare_digest`` for constant-time compare.
+    if not _hmac.compare_digest(expected, supplied):
+        raise HTTPException(status_code=403, detail="Invalid CSRF token")
+
+
+def _allowed_origins() -> set[str]:
+    raw = (getattr(settings, "canvas_allowed_origins", "") or "").strip()
+    if not raw:
+        return set()
+    return {o.strip().rstrip("/") for o in raw.split(",") if o.strip()}
+
+
+def _require_trusted_origin(request: Request) -> None:
+    """Reject cross-origin state-changing requests in production.
+
+    Two configuration paths, both honoured:
+      * ``CANVAS_ALLOWED_ORIGINS`` -- comma-separated literal list.
+      * ``CANVAS_ALLOWED_ORIGIN_REGEX`` -- single regex; takes
+        precedence over the literal list when both are set.
+
+    Dev fallback: if neither is configured we let any Origin through.
+    Production deployments MUST configure one or the other.
+    """
+    import re as _re
+    origin = (request.headers.get("origin") or "").rstrip("/")
+    referer = (request.headers.get("referer") or "").rstrip("/")
+
+    regex_str = (getattr(settings, "canvas_allowed_origin_regex", "") or "").strip()
+    if regex_str:
+        try:
+            pattern = _re.compile(regex_str)
+        except _re.error as exc:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Bad CANVAS_ALLOWED_ORIGIN_REGEX: {exc}",
+            ) from exc
+        if pattern.fullmatch(origin):
+            return
+        if referer:
+            from urllib.parse import urlparse
+            try:
+                u = urlparse(referer)
+                base = f"{u.scheme}://{u.netloc}"
+                if pattern.fullmatch(base):
+                    return
+            except Exception:
+                pass
+        raise HTTPException(
+            status_code=403,
+            detail=f"Origin not allowed by regex (got {origin!r})",
+        )
+
+    allowed = _allowed_origins()
+    if not allowed:
+        return  # dev fallback; production MUST configure
+    if origin in allowed:
+        return
+    if referer:
+        from urllib.parse import urlparse
+        try:
+            u = urlparse(referer)
+            base = f"{u.scheme}://{u.netloc}"
+            if base in allowed:
+                return
+        except Exception:
+            pass
+    raise HTTPException(
+        status_code=403,
+        detail=f"Origin not allowed (got {origin!r})",
+    )
+
+
+@router.get("/csrf")
+async def get_csrf(
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+) -> JSONResponse:
+    """Return a CSRF token bound to the current LTI session.
+
+    The panorama bundle fetches this once at init time and echoes the
+    token in the ``X-CSRF-Token`` header on every state-changing
+    request. Returns 401 when no session cookie is present.
+    """
+    if not session_id:
+        raise HTTPException(status_code=401, detail="No LTI session")
+    return JSONResponse({"csrf_token": _csrf_token_for(session_id)})
+
+
+async def _read_json_body(request: Request) -> dict:
+    """Read the request body as JSON, returning {} on failure.
+
+    The approve_job endpoint already takes ``comment`` via Body(...);
+    we want to also pull ``waivers`` and ``checklist`` without
+    breaking that signature. Re-reading the raw body works because
+    FastAPI caches it on the Request after first access.
+    """
+    try:
+        return await request.json()
+    except Exception:
+        return {}
+
+
+def _client_ip(request: Request) -> str | None:
+    """Return the client IP for audit logging.
+
+    Honours ``X-Forwarded-For`` only when explicit - we expect to run
+    behind a TLS-terminating ALB or ngrok, both of which set it. Falls
+    back to the socket peer, which is correct for direct connections.
+    Anything that looks bogus (commas-only, empty) returns None so the
+    audit row records "unknown" instead of garbage.
+    """
+    xff = request.headers.get("x-forwarded-for")
+    if xff:
+        first = xff.split(",", 1)[0].strip()
+        if first:
+            return first[:64]
+    if request.client and request.client.host:
+        return request.client.host
+    return None
+
+
+@router.post("/pii-decision/{job_id}")
+async def pii_decision(
+    job_id: str,
+    request: Request,
+    decision: str = Body(..., embed=True),
+    justification: str = Body(..., embed=True),
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    csrf_token: str | None = Header(default=None, alias="X-CSRF-Token"),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Faculty decision on a PII-paused Reflow job.
+
+    Auth: requires an instructor session bound to the job's course
+    (same check as approve/reject). The instructor's identity is what
+    gets stamped on the audit trail — Reflow's underlying token-based
+    approval endpoint is bypassed because we already authenticated the
+    actor via the LTI session and a token doesn't fit the LMS flow.
+
+    Decision values:
+      * ``approved`` -- Reflow resumes processing, status moves to
+        ``processing_queued`` and then ``processing``.
+      * ``denied``  -- Reflow drops the source PDF, status moves to
+        ``denied``. No derived files are generated.
+
+    Justification is required (>= 10 chars) for audit-trail
+    accountability. Faculty get the same affordance students sometimes
+    receive on FERPA reviews: write down why you made the call.
+    """
+    decision = (decision or "").strip().lower()
+    if decision not in ("approved", "denied"):
+        raise HTTPException(
+            status_code=400,
+            detail="decision must be 'approved' or 'denied'",
+        )
+    justification = (justification or "").strip()
+    if len(justification) < 10:
+        raise HTTPException(
+            status_code=400,
+            detail="justification must be at least 10 characters",
+        )
+    if len(justification) > 1000:
+        raise HTTPException(
+            status_code=400,
+            detail="justification must be at most 1000 characters",
+        )
+
+    job, sess = await _require_instructor(redis, session_id, job_id)
+    _require_csrf(session_id, csrf_token)
+    _require_trusted_origin(request)
+
+    # Defer the heavy imports so test discovery doesn't pull the full
+    # storage stack on bare-bones unit tests.
+    from ..dependencies import get_s3_url_service, get_storage_service
+    from ..services.approval_service import ApprovalService
+    from ..services.job_service import JobService
+    from ..services.queue_service import QueueService
+
+    storage_service = await get_storage_service()
+    s3_url_service = await get_s3_url_service()
+    approval_service = ApprovalService(
+        redis_client=redis,
+        s3_client=None,  # lazy-loaded on denial path
+        job_service=JobService(redis),
+        queue_service=QueueService(redis),
+        storage_service=storage_service,
+        s3_url_service=s3_url_service,
+    )
+    # Reviewed-by carries the LTI user id, not an email, since the
+    # session doesn't guarantee email is present.
+    reviewer = sess.user_email or sess.user_id
+    try:
+        await approval_service.process_approval_decision(
+            job_id=job_id,
+            decision=decision,  # type: ignore[arg-type]
+            justification=justification,
+            reviewed_by=reviewer,
+        )
+    except ValueError as exc:
+        # Most common: job already moved past awaiting_approval
+        # (race with another instructor approving in a parallel tab).
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    except Exception as exc:  # noqa: BLE001
+        logger.exception("PII decision failed for job=%s", job_id)
+        raise HTTPException(
+            status_code=502,
+            detail=f"Reflow approval service error: {exc}",
+        ) from exc
+
+    await append_approval_event(
+        redis,
+        job_id=job_id,
+        action="pii_approve" if decision == "approved" else "pii_deny",
+        actor_user_id=sess.user_id,
+        actor_name=sess.user_name,
+        comment=justification,
+        actor_ip=_client_ip(request),
+        course_id=sess.course_id,
+    )
+    logger.info(
+        "PII %s for job=%s by user=%s course=%s",
+        decision, job_id, sess.user_id, sess.course_id,
+    )
+    return JSONResponse(
+        {
+            "ok": True,
+            "decision": decision,
+            "next_status": "processing_queued" if decision == "approved" else "denied",
+        }
+    )
+
+
+@router.post("/convert/{file_id}")
+async def convert_file(
+    file_id: str,
+    request: Request,
+    course_id: str = Query(...),
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    csrf_token: str | None = Header(default=None, alias="X-CSRF-Token"),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Queue a file for accessible-page conversion from the overlay.
+
+    Clears the watcher's "already processed" marker so the next watcher tick
+    re-downloads and converts the file; the bridge then creates (or updates)
+    its Canvas Page. Lets faculty trigger conversion from the UI instead of
+    waiting for discovery or running a script. Instructor-only + CSRF, scoped
+    to the caller's own course.
+    """
+    if not session_id:
+        raise HTTPException(status_code=401, detail="No LTI session")
+    sess = await get_session(redis, session_id)
+    if sess is None:
+        raise HTTPException(status_code=401, detail="Expired LTI session")
+    is_instructor = any(
+        r.endswith("Instructor")
+        or r.endswith("Administrator")
+        or "TeachingAssistant" in r
+        or "Admin" in r
+        for r in (sess.roles or [])
+    )
+    if not is_instructor:
+        raise HTTPException(status_code=403, detail="Instructor role required")
+    if str(sess.course_id) != str(course_id):
+        raise HTTPException(status_code=403, detail="Session not bound to this course")
+    _require_csrf(session_id, csrf_token)
+    _require_trusted_origin(request)
+
+    # Prefer (re)building the page from an EXISTING completed conversion. These
+    # files usually already have a Reflow job (they show a score) — they just
+    # never got a Canvas Page (page creation was skipped while OAuth was
+    # unconfigured, leaving the job in awaiting_review with no page, which the
+    # bridge then never retries). Resetting the job to ``processing`` makes the
+    # bridge re-drive it on its next tick (~30s) and build the page from the
+    # markdown that already exists — no slow re-run of the Claude pipeline.
+    # Only when there's no job at all do we queue a fresh conversion.
+    job_id = await _lookup_job_for_file(redis, course_id, file_id)
+    if job_id:
+        job = await get_job(redis, job_id)
+        if job is not None and job.status != "processing":
+            job.status = "processing"
+            await put_job(redis, job)
+            logger.info(
+                "Manual page-build queued via overlay: course=%s file=%s job=%s by user=%s",
+                course_id, file_id, job_id, sess.user_id,
+            )
+            return JSONResponse({
+                "ok": True,
+                "message": "Building the accessible page — it'll appear in under a minute.",
+            })
+        if job is not None:
+            return JSONResponse({
+                "ok": True,
+                "message": "Already building — the page will appear shortly.",
+            })
+
+    await clear_processed(redis, course_id, file_id)
+    logger.info(
+        "Manual convert queued via overlay (no existing job): course=%s file=%s by user=%s",
+        course_id, file_id, sess.user_id,
+    )
+    return JSONResponse({
+        "ok": True,
+        "message": "Conversion queued — the accessible page will appear in a few minutes.",
+    })
+
+
+@router.post("/approve/{job_id}")
+async def approve_job(
+    job_id: str,
+    request: Request,
+    comment: str | None = Body(default=None, embed=True),
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    csrf_token: str | None = Header(default=None, alias="X-CSRF-Token"),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Mark a job as published — alt formats become visible to students.
+
+    Only callable by instructors in the same course. Transition is allowed
+    from any non-terminal state (typically ``awaiting_review`` after the
+    faculty member reviewed/edited the HTML; sometimes ``rejected`` if they
+    change their mind). Requires CSRF token (Phase 3).
+    """
+    job, sess = await _require_instructor(redis, session_id, job_id)
+    _require_csrf(session_id, csrf_token)
+    _require_trusted_origin(request)
+    if job.status == "failed":
+        raise HTTPException(status_code=409, detail="Cannot approve a failed job")
+
+    # Phase 7b publication gate. Two things must hold to publish:
+    #
+    #   1. Automated WCAG checks find no ``error``-severity issues
+    #      against the rendered HTML, OR the reviewer has explicitly
+    #      waived each error with a justification (``waivers`` body).
+    #   2. The reviewer checklist (``checklist`` body) confirms each
+    #      manual item the gate requires -- headings, reading order,
+    #      alt text, tables, math, etc.
+    #
+    # Both are passed in the JSON body alongside ``comment``. When
+    # omitted (legacy callers / smoke tests) the gate falls open with
+    # a logged warning. Production deployments should set
+    # ``REQUIRE_WCAG_GATE=true`` (default in prod build) which causes
+    # missing/failing checks to 409 instead.
+    require_gate = bool(getattr(settings, "require_wcag_gate", False))
+    raw_body = await _read_json_body(request)
+    waivers: list[str] = list(raw_body.get("waivers") or [])
+    checklist: dict[str, bool] = dict(raw_body.get("checklist") or {})
+
+    try:
+        rendered = await _resolve_html(redis, job_id)
+        wcag = run_wcag_checks(html_full_document(rendered, mathjax=False))
+    except Exception as exc:
+        logger.exception("approve_job: WCAG check failed for %s", job_id)
+        if require_gate:
+            raise HTTPException(
+                status_code=502,
+                detail=f"Could not run WCAG checks: {exc}",
+            ) from exc
+        wcag = None
+
+    if wcag is not None:
+        unwaived = [f for f in wcag.findings
+                    if f.severity == "error" and f.rule_id not in waivers]
+        if unwaived and require_gate:
+            raise HTTPException(
+                status_code=409,
+                detail={
+                    "error": "wcag_gate_blocked",
+                    "message": (
+                        f"{len(unwaived)} WCAG error(s) remain unwaived. "
+                        "Fix them or include rule_ids in the 'waivers' "
+                        "list with a justification."
+                    ),
+                    "findings": [asdict(f) for f in unwaived],
+                },
+            )
+
+    if require_gate:
+        required_items = ("headings", "alt_text", "tables", "reading_order")
+        missing = [k for k in required_items if not checklist.get(k)]
+        if missing:
+            raise HTTPException(
+                status_code=409,
+                detail={
+                    "error": "checklist_incomplete",
+                    "message": "Reviewer checklist not complete",
+                    "missing": missing,
+                },
+            )
+
+    job.status = "published"
+    await put_job(redis, job)
+    # Publish the Canvas wiki Page itself (the bridge creates it unpublished),
+    # so students can reach it in the course Pages list — not only via the
+    # overlay's alt link. Best-effort: the job is published for overlay/alt
+    # access either way. Uses the course-owner OAuth client, same as the bridge.
+    if job.canvas_page_url or job.canvas_page_id:
+        try:
+            from ..workers.reflow_bridge_worker import _canvas_client_for_job
+            _canvas = await _canvas_client_for_job(redis, job)
+            await _canvas.publish_page(
+                job.canvas_course_id, job.canvas_page_url or job.canvas_page_id or "",
+            )
+        except Exception:  # noqa: BLE001 — page publish is best-effort
+            logger.exception("approve_job: could not publish Canvas page for %s", job_id)
+    await append_approval_event(
+        redis,
+        job_id=job_id,
+        action="approve",
+        actor_user_id=sess.user_id,
+        actor_name=sess.user_name,
+        comment=comment,
+        actor_ip=_client_ip(request),
+        course_id=sess.course_id,
+    )
+    logger.info("Job %s approved by %s", job_id, sess.user_id)
+    return JSONResponse({"ok": True, "status": "published"})
+
+
+@router.post("/reject/{job_id}")
+async def reject_job(
+    job_id: str,
+    request: Request,
+    comment: str | None = Body(default=None, embed=True),
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    csrf_token: str | None = Header(default=None, alias="X-CSRF-Token"),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Mark a job as rejected — alt formats stay hidden from students."""
+    job, sess = await _require_instructor(redis, session_id, job_id)
+    _require_csrf(session_id, csrf_token)
+    _require_trusted_origin(request)
+    job.status = "rejected"
+    await put_job(redis, job)
+    await append_approval_event(
+        redis,
+        job_id=job_id,
+        action="reject",
+        actor_user_id=sess.user_id,
+        actor_name=sess.user_name,
+        comment=comment,
+        actor_ip=_client_ip(request),
+        course_id=sess.course_id,
+    )
+    logger.info("Job %s rejected by %s", job_id, sess.user_id)
+    return JSONResponse({"ok": True, "status": "rejected"})
+
+
+@router.post("/request-edits/{job_id}")
+async def request_edits(
+    job_id: str,
+    request: Request,
+    comment: str | None = Body(default=None, embed=True),
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    csrf_token: str | None = Header(default=None, alias="X-CSRF-Token"),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Pull a published or rejected job back to awaiting_review so faculty
+    can iterate. Useful when faculty changed their mind or wants to edit
+    the HTML after publishing."""
+    job, sess = await _require_instructor(redis, session_id, job_id)
+    _require_csrf(session_id, csrf_token)
+    _require_trusted_origin(request)
+    job.status = "awaiting_review"
+    await put_job(redis, job)
+    await append_approval_event(
+        redis,
+        job_id=job_id,
+        action="request_edits",
+        actor_user_id=sess.user_id,
+        actor_name=sess.user_name,
+        comment=comment,
+        actor_ip=_client_ip(request),
+        course_id=sess.course_id,
+    )
+    logger.info("Job %s pulled back to draft by %s", job_id, sess.user_id)
+    return JSONResponse({"ok": True, "status": "awaiting_review"})
+
+
+@router.post("/unpublish/{job_id}")
+async def unpublish_job(
+    job_id: str,
+    request: Request,
+    comment: str | None = Body(default=None, embed=True),
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    csrf_token: str | None = Header(default=None, alias="X-CSRF-Token"),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Take a published accessible version down from students.
+
+    Unlike ``request-edits`` (which is about iterating on the content),
+    Unpublish is an explicit "remove this from students" action: it returns
+    the job to ``awaiting_review`` (so the alt formats are gated again) AND
+    unpublishes the Canvas wiki Page itself, so it also disappears from the
+    course Pages list. Re-publishing is one click ("Approve & publish"),
+    which re-publishes the Page too. Instructor + CSRF + trusted origin.
+    """
+    job, sess = await _require_instructor(redis, session_id, job_id)
+    _require_csrf(session_id, csrf_token)
+    _require_trusted_origin(request)
+
+    job.status = "awaiting_review"
+    await put_job(redis, job)
+    # Best-effort: also unpublish the Canvas wiki Page so it leaves the
+    # student-visible Pages list, not just the gated alt endpoint. Uses the
+    # course-owner OAuth client, same as approve/publish.
+    if job.canvas_page_url or job.canvas_page_id:
+        try:
+            from ..workers.reflow_bridge_worker import _canvas_client_for_job
+            _canvas = await _canvas_client_for_job(redis, job)
+            await _canvas.unpublish_page(
+                job.canvas_course_id, job.canvas_page_url or job.canvas_page_id or "",
+            )
+        except Exception:  # noqa: BLE001 — page unpublish is best-effort
+            logger.exception("unpublish_job: could not unpublish Canvas page for %s", job_id)
+    await append_approval_event(
+        redis,
+        job_id=job_id,
+        action="unpublish",
+        actor_user_id=sess.user_id,
+        actor_name=sess.user_name,
+        comment=comment,
+        actor_ip=_client_ip(request),
+        course_id=sess.course_id,
+    )
+    logger.info("Job %s unpublished by %s", job_id, sess.user_id)
+    return JSONResponse({"ok": True, "status": "awaiting_review"})
+
+
+@router.get("/audit/approvals.csv")
+async def approvals_audit_csv(
+    since: float | None = Query(default=None),
+    redis: Redis = Depends(get_redis_client),
+) -> Response:
+    """Return a CSV of every approve/reject/request_edits/pii_approve event.
+
+    No auth gate here: this endpoint is intended for ops/SRE use behind
+    an internal reverse proxy. In production deploy this behind a
+    network ACL or IP allowlist.
+    """
+    import csv
+    import io
+
+    events = await list_approval_events(redis, since=since)
+    buf = io.StringIO()
+    writer = csv.writer(buf)
+    writer.writerow([
+        "at", "job_id", "action", "actor_user_id", "actor_name",
+        "actor_ip", "course_id", "comment",
+    ])
+    for e in events:
+        writer.writerow([
+            e.get("at", ""),
+            e.get("job_id", ""),
+            e.get("action", ""),
+            e.get("actor_user_id", ""),
+            e.get("actor_name", ""),
+            e.get("actor_ip", ""),
+            e.get("course_id", ""),
+            (e.get("comment") or "").replace("\n", " ")[:500],
+        ])
+    return Response(
+        content=buf.getvalue(),
+        media_type="text/csv",
+        headers={
+            "Content-Disposition": 'attachment; filename="approvals.csv"',
+        },
+    )
+
+
+class _BulkApproveBody(BaseModel):  # type: ignore[name-defined]
+    job_ids: list[str]
+    comment: str | None = None
+
+
+@router.post("/approve/_bulk")
+async def approve_bulk(
+    request: Request,
+    body: _BulkApproveBody,
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    csrf_token: str | None = Header(default=None, alias="X-CSRF-Token"),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Approve many jobs at once. Skips jobs in 'failed' state.
+
+    All jobs must belong to the caller's course (enforced via the same
+    ``_require_instructor`` check used by the per-job endpoint). On
+    any auth failure the whole call rejects — no partial commit.
+    """
+    _require_csrf(session_id, csrf_token)
+    _require_trusted_origin(request)
+    if not body.job_ids:
+        raise HTTPException(status_code=400, detail="job_ids must be non-empty")
+    if len(body.job_ids) > 200:
+        raise HTTPException(status_code=400, detail="Too many job_ids; cap is 200")
+
+    approved: list[str] = []
+    skipped: list[dict[str, Any]] = []
+    for jid in body.job_ids:
+        try:
+            job, sess = await _require_instructor(redis, session_id, jid)
+        except HTTPException as exc:
+            if exc.status_code in (401, 403):
+                raise  # session/role failure aborts the batch
+            skipped.append({"job_id": jid, "reason": str(exc.detail)})
+            continue
+        if job.status == "failed":
+            skipped.append({"job_id": jid, "reason": "failed jobs are not approvable"})
+            continue
+        job.status = "published"
+        await put_job(redis, job)
+        await append_approval_event(
+            redis,
+            job_id=jid,
+            action="approve",
+            actor_user_id=sess.user_id,
+            actor_name=sess.user_name,
+            comment=body.comment,
+            actor_ip=_client_ip(request),
+            course_id=sess.course_id,
+        )
+        approved.append(jid)
+    logger.info("Bulk approve: %d approved, %d skipped", len(approved), len(skipped))
+    return JSONResponse({"approved": approved, "skipped": skipped})
+
+
+@router.delete("/job/{job_id}")
+async def delete_job(
+    job_id: str,
+    request: Request,
+    session_id: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+    csrf_token: str | None = Header(default=None, alias="X-CSRF-Token"),
+    redis: Redis = Depends(get_redis_client),
+) -> JSONResponse:
+    """Phase 11: hard-delete a job and every derivative artifact.
+
+    Requires instructor (course-bound) AND CSRF token AND trusted
+    origin. The deletion is irreversible from a UI standpoint --
+    audit-log entries are preserved (per institutional record-keeping
+    requirements) but every artifact (source PDF reference, markdown,
+    figures, edited HTML, score cache, approval token) is removed.
+
+    S3 cleanup is not performed inline; a separate sweeper reconciles
+    orphaned S3 keys against the Redis index on a schedule.
+    """
+    _job, sess = await _require_instructor(redis, session_id, job_id)
+    _require_csrf(session_id, csrf_token)
+    _require_trusted_origin(request)
+
+    from ..canvas.privacy import delete_job_and_derivatives
+    summary = await delete_job_and_derivatives(redis, reflow_job_id=job_id)
+
+    await append_approval_event(
+        redis,
+        job_id=job_id,
+        action="delete",
+        actor_user_id=sess.user_id,
+        actor_name=sess.user_name,
+        comment=f"Hard-deleted: {summary}",
+        actor_ip=_client_ip(request),
+        course_id=sess.course_id,
+    )
+    logger.warning(
+        "Job %s deleted by user=%s course=%s summary=%s",
+        job_id, sess.user_id, sess.course_id, summary,
+    )
+    return JSONResponse({"ok": True, "deleted": summary})
diff --git a/src/api/canvas_review.py b/src/api/canvas_review.py
new file mode 100644
index 0000000..e9297fc
--- /dev/null
+++ b/src/api/canvas_review.py
@@ -0,0 +1,181 @@
+"""Review endpoints for the Canvas integration.
+
+Mounted at ``/canvas/review``. The LTI launch redirects faculty here
+with a valid session cookie; the endpoints below read identity from
+Redis-backed session state and operate on Canvas Pages on the faculty's
+behalf.
+
+These endpoints intentionally avoid the X-API-Key middleware: faculty
+identity is proven by the LTI session cookie, not an API key. The router
+is exempted in ``src.main`` when LTI is enabled.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, Cookie, Depends, HTTPException, Request, status
+from fastapi.responses import HTMLResponse, JSONResponse
+from redis.asyncio import Redis
+
+from ..canvas.client import CanvasClient
+from ..canvas.state import get_job, list_pending, put_job
+from ..dependencies import get_redis_client
+from ..lti.routes import SESSION_COOKIE
+from ..lti.session import SessionPayload, get_session
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/canvas/review", tags=["canvas-review"])
+
+_TEMPLATE_DIR = Path(__file__).parent.parent / "web" / "canvas_review"
+
+
+async def _require_session(
+    redis: Redis,
+    cookie: str | None,
+) -> SessionPayload:
+    if not cookie:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="No LTI session")
+    session = await get_session(redis, cookie)
+    if session is None:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Session expired")
+    return session
+
+
+@router.get("/dashboard", response_class=HTMLResponse)
+async def dashboard(
+    course_id: str | None = None,
+    redis: Redis = Depends(get_redis_client),
+    reflow_lti_session: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+) -> HTMLResponse:
+    """Course-wide accessibility dashboard for instructors."""
+
+    session = await _require_session(redis, reflow_lti_session)
+    target_course = course_id or session.course_id
+    template = _load_template("dashboard.html")
+    return HTMLResponse(template.replace("{{ course_id }}", target_course))
+
+
+@router.get("", response_class=HTMLResponse)
+async def review_index(
+    request: Request,
+    course_id: str | None = None,
+    redis: Redis = Depends(get_redis_client),
+    reflow_lti_session: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+) -> HTMLResponse:
+    """Render the pending-review list for the current course."""
+
+    session = await _require_session(redis, reflow_lti_session)
+    target_course = course_id or session.course_id
+    template = _load_template("index.html")
+    body = template.replace("{{ course_id }}", target_course)
+    body = body.replace("{{ user_name }}", session.user_name or "Instructor")
+    return HTMLResponse(body)
+
+
+@router.get("/api/pending")
+async def api_pending(
+    course_id: str | None = None,
+    redis: Redis = Depends(get_redis_client),
+    reflow_lti_session: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+) -> JSONResponse:
+    """JSON list of jobs awaiting review for the current course."""
+
+    session = await _require_session(redis, reflow_lti_session)
+    target_course = course_id or session.course_id
+    jobs = await list_pending(redis, target_course)
+    rows = [
+        {
+            "reflow_job_id": j.reflow_job_id,
+            "filename": j.canvas_file_name,
+            "created_at": j.created_at,
+            "canvas_page_url": j.canvas_page_url,
+            "canvas_page_id": j.canvas_page_id,
+        }
+        for j in jobs
+    ]
+    return JSONResponse({"course_id": target_course, "jobs": rows})
+
+
+@router.get("/{job_id}", response_class=HTMLResponse)
+async def review_one(
+    job_id: str,
+    redis: Redis = Depends(get_redis_client),
+    reflow_lti_session: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+) -> HTMLResponse:
+    """Side-by-side review screen for a single document."""
+
+    session = await _require_session(redis, reflow_lti_session)
+    job = await get_job(redis, job_id)
+    if job is None or job.canvas_course_id != session.course_id:
+        raise HTTPException(status_code=404, detail="Unknown job")
+    template = _load_template("one.html")
+    body = (
+        template.replace("{{ job_id }}", job.reflow_job_id)
+        .replace("{{ filename }}", job.canvas_file_name)
+        .replace("{{ canvas_page_url }}", job.canvas_page_url or "")
+        .replace("{{ canvas_course_id }}", job.canvas_course_id)
+    )
+    return HTMLResponse(body)
+
+
+@router.post("/{job_id}/approve")
+async def approve(
+    job_id: str,
+    redis: Redis = Depends(get_redis_client),
+    reflow_lti_session: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+) -> JSONResponse:
+    session = await _require_session(redis, reflow_lti_session)
+    job = await get_job(redis, job_id)
+    if job is None or job.canvas_course_id != session.course_id:
+        raise HTTPException(status_code=404, detail="Unknown job")
+
+    # When the API token lacks manage_wiki, the bridge worker skips Canvas
+    # Page creation and leaves canvas_page_url empty. Approval is still
+    # meaningful in that case - it transitions the job to "published" so
+    # the panorama overlay serves the alt formats to students. We only
+    # call publish_page when an actual Canvas Page exists.
+    canvas = CanvasClient()
+    if job.canvas_page_url:
+        await canvas.publish_page(job.canvas_course_id, job.canvas_page_url)
+    job.status = "published"
+    await put_job(redis, job)
+    return JSONResponse({"ok": True, "page_url": job.canvas_page_url or ""})
+
+
+@router.post("/{job_id}/reject")
+async def reject(
+    job_id: str,
+    redis: Redis = Depends(get_redis_client),
+    reflow_lti_session: str | None = Cookie(default=None, alias=SESSION_COOKIE),
+) -> JSONResponse:
+    session = await _require_session(redis, reflow_lti_session)
+    job = await get_job(redis, job_id)
+    if job is None or job.canvas_course_id != session.course_id:
+        raise HTTPException(status_code=404, detail="Unknown job")
+
+    if job.canvas_page_url:
+        canvas = CanvasClient()
+        try:
+            await canvas.delete_page(job.canvas_course_id, job.canvas_page_url)
+        except Exception:
+            logger.exception("Failed to delete Canvas page during reject")
+    job.status = "rejected"
+    await put_job(redis, job)
+    return JSONResponse({"ok": True})
+
+
+def _load_template(name: str) -> str:
+    path = _TEMPLATE_DIR / name
+    if not path.exists():
+        return f"<h1>Template missing: {name}</h1>"
+    return path.read_text(encoding="utf-8")
+
+
+def _build_data_payload(job_jobs: list[Any]) -> list[dict[str, Any]]:
+    """Reserved helper for richer JSON; kept to keep the module focused."""
+
+    return []
diff --git a/src/canvas/__init__.py b/src/canvas/__init__.py
new file mode 100644
index 0000000..e7e468b
--- /dev/null
+++ b/src/canvas/__init__.py
@@ -0,0 +1,16 @@
+"""Canvas REST API client.
+
+Thin async wrapper around the subset of the Canvas API the integration
+needs: list course PDFs, download a file, create/publish/delete a Page,
+send a Conversation message.
+
+Keep this client narrow. Every method that takes a ``course_id`` or
+``file_id`` is a thin shim over the Canvas REST endpoint of the same
+name — that one-to-one mapping makes failures easy to debug against the
+Canvas API docs.
+"""
+
+from .client import CanvasClient
+from .errors import CanvasApiError
+
+__all__ = ["CanvasClient", "CanvasApiError"]
diff --git a/src/canvas/alt_formats.py b/src/canvas/alt_formats.py
new file mode 100644
index 0000000..653388e
--- /dev/null
+++ b/src/canvas/alt_formats.py
@@ -0,0 +1,570 @@
+"""Alternative-format renderers.
+
+Accessible HTML (produced by ``markdown_to_html.render``) is the
+canonical accessible representation of a Reflow document. Every other
+format — plain text, ePub, audio, translations, tagged PDF, etc. —
+derives from that same RenderedPage, so all surfaces stay in sync. When
+the HTML gets better (better alt text, better tables, better lang
+attributes) every downstream format inherits the improvement.
+
+Renderers are deliberately independent of FastAPI: they take a
+RenderedPage in, return bytes (or a string) out, and never import the
+server. That makes them trivial to unit test and to call from workers.
+"""
+
+from __future__ import annotations
+
+import io
+import logging
+import re
+import uuid
+from typing import Any
+
+from .markdown_to_html import RenderedPage, render
+
+logger = logging.getLogger(__name__)
+
+
+def canonical_html(
+    markdown: str,
+    *,
+    title: str,
+    original_pdf_url: str | None = None,
+    image_base_url: str | None = None,
+) -> RenderedPage:
+    """The single source of truth. All other formats derive from this."""
+    return render(
+        markdown,
+        title=title,
+        original_pdf_url=original_pdf_url,
+        image_base_url=image_base_url,
+    )
+
+
+def html_full_document(rendered: RenderedPage, *, mathjax: bool = False) -> str:
+    """Wrap the rendered body fragment in a full standalone HTML doc."""
+    head_extras = ""
+    if mathjax:
+        head_extras = (
+            '<script async="true" '
+            'src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>'
+        )
+    return (
+        "<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\">"
+        "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">"
+        f"<title>{_escape(rendered.title)}</title>"
+        "<style>body{font-family:Georgia,serif;max-width:48rem;margin:2rem auto;"
+        "padding:0 1rem;line-height:1.65;color:#1d1d1d;}"
+        "img{max-width:100%;height:auto;}"
+        "table{border-collapse:collapse;width:100%;margin:1rem 0;}"
+        "th,td{border:1px solid #ccc;padding:0.5rem;text-align:left;}"
+        "h1,h2,h3,h4{font-family:system-ui,sans-serif;}</style>"
+        f"{head_extras}"
+        f"</head><body><h1>{_escape(rendered.title)}</h1>{rendered.html}</body></html>"
+    )
+
+
+_TAG_RE = re.compile(r"<[^>]+>")
+_WS_RE = re.compile(r"\s+")
+_ENTITIES = {"&amp;": "&", "&lt;": "<", "&gt;": ">", "&quot;": '"',
+             "&apos;": "'", "&#39;": "'", "&nbsp;": " "}
+
+
+def html_to_plain_text(rendered: RenderedPage) -> str:
+    """Strip tags from the rendered HTML to produce a clean text version."""
+    text = _TAG_RE.sub(" ", rendered.html)
+    for ent, repl in _ENTITIES.items():
+        text = text.replace(ent, repl)
+    text = _WS_RE.sub(" ", text).strip()
+    return text
+
+
+def render_epub(rendered: RenderedPage) -> bytes:
+    """Convert the canonical HTML into an EPUB3 file."""
+    try:
+        from ebooklib import epub
+        from ebooklib import utils as _ebu
+    except ImportError as exc:
+        raise RuntimeError(
+            "ebooklib is not installed; add 'ebooklib' to dependencies"
+        ) from exc
+
+    # ebooklib >=0.18 (with lxml >=5) crashes on write: ``_get_nav`` runs
+    # ``get_pages()`` over EVERY document item to build the EPUB3 page-list,
+    # including the Nav/NCX items whose body is still empty at that point.
+    # ``lxml.html.document_fromstring("")`` then raises "Document is empty",
+    # surfacing as a 500 on the alt-format endpoint. Wrap ebooklib's
+    # ``parse_html_string`` so an empty/whitespace body parses to an empty
+    # document instead of throwing. Restored in ``finally`` so the patch is
+    # scoped to this call and never leaks to other ebooklib users.
+    _orig_parse = _ebu.parse_html_string
+
+    def _safe_parse(s):
+        is_empty = (
+            s is None
+            or (isinstance(s, (bytes, bytearray)) and not s.strip())
+            or (isinstance(s, str) and not s.strip())
+        )
+        if is_empty:
+            from lxml import html as _lh
+            return _lh.fromstring("<html><body></body></html>")
+        return _orig_parse(s)
+
+    _ebu.parse_html_string = _safe_parse
+    try:
+        return _build_epub(epub, rendered)
+    finally:
+        _ebu.parse_html_string = _orig_parse
+
+
+def _build_epub(epub, rendered: RenderedPage) -> bytes:
+    book = epub.EpubBook()
+    book.set_identifier(f"equalify-reflow-{uuid.uuid4()}")
+    book.set_title(rendered.title or "Accessible Document")
+    book.set_language("en")
+    book.add_author("Equalify Reflow")
+
+    chapter = epub.EpubHtml(
+        title=rendered.title or "Document",
+        file_name="content.xhtml",
+        lang="en",
+    )
+    chapter.content = (
+        "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
+        "<!DOCTYPE html><html xmlns=\"http://www.w3.org/1999/xhtml\" "
+        "xmlns:epub=\"http://www.idpf.org/2007/ops\"><head>"
+        f"<title>{_escape(rendered.title)}</title></head>"
+        f"<body><h1>{_escape(rendered.title)}</h1>{rendered.html}</body></html>"
+    )
+    book.add_item(chapter)
+    book.add_item(epub.EpubNcx())
+    book.add_item(epub.EpubNav())
+    book.toc = (epub.Link("content.xhtml", rendered.title or "Document", "main"),)
+    book.spine = ["nav", chapter]
+
+    buf = io.BytesIO()
+    epub.write_epub(buf, book)
+    return buf.getvalue()
+
+
+def _chunks(text: str, size: int) -> list[str]:
+    """Split text on sentence boundaries first, then by size cap."""
+    out: list[str] = []
+    cur = ""
+    sentences = re.split(r"(?<=[.!?])\s+", text)
+    for s in sentences:
+        if len(cur) + len(s) + 1 <= size:
+            cur = (cur + " " + s).strip() if cur else s
+        else:
+            if cur:
+                out.append(cur)
+            if len(s) <= size:
+                cur = s
+            else:
+                # Hard split if a single sentence exceeds size
+                for i in range(0, len(s), size):
+                    out.append(s[i:i+size])
+                cur = ""
+    if cur:
+        out.append(cur)
+    return out
+
+
+def render_audio_mp3(rendered: RenderedPage, voice: str = "Joanna") -> bytes:
+    """Synthesize MP3 audio via Amazon Polly.
+
+    Requires AWS credentials with ``polly:SynthesizeSpeech``. Raises
+    ``RuntimeError`` with a friendly message if credentials/permissions
+    aren't available so the endpoint can return 503.
+    """
+    try:
+        import boto3
+        from botocore.exceptions import BotoCoreError, ClientError
+    except ImportError as exc:
+        raise RuntimeError("boto3 is not installed") from exc
+
+    text = html_to_plain_text(rendered)
+    if not text:
+        raise RuntimeError("No text to synthesize")
+
+    parts = _chunks(text, 2800)
+    audio_chunks: list[bytes] = []
+    polly = boto3.client("polly")
+    for chunk in parts:
+        try:
+            resp = polly.synthesize_speech(
+                Text=chunk,
+                OutputFormat="mp3",
+                VoiceId=voice,
+                Engine="neural",
+            )
+        except (BotoCoreError, ClientError) as exc:
+            raise RuntimeError(f"Polly synthesis failed: {exc}") from exc
+        audio_chunks.append(resp["AudioStream"].read())
+    return b"".join(audio_chunks)
+
+
+async def render_translation(
+    rendered: RenderedPage,
+    target_lang: str,
+) -> RenderedPage:
+    """Translate the accessible HTML into ``target_lang`` via the project AI.
+
+    Returns a new RenderedPage with translated body. Requires the
+    pipeline's AI provider to be configured (Anthropic API key or
+    AWS Bedrock credentials).
+    """
+    try:
+        from pydantic_ai import Agent
+        from ..agents.model_factory import get_model_for_tier
+        from ..agents.model_tiers import ModelTier
+    except ImportError as exc:
+        raise RuntimeError("PydanticAI is not available") from exc
+
+    text = html_to_plain_text(rendered)
+    if not text:
+        raise RuntimeError("Nothing to translate")
+
+    agent = Agent(
+        get_model_for_tier(ModelTier.EFFICIENT),
+        system_prompt=(
+            "You are a translator preserving formatting and accessibility. "
+            "Translate the provided text into the target language. Preserve "
+            "headings, lists, and emphasis. Return ONLY the translated text."
+        ),
+    )
+    result = await agent.run(f"Target language: {target_lang}\n\nText:\n{text}")
+    translated = (result.output or "").strip()
+    if not translated:
+        raise RuntimeError("AI returned empty translation")
+    # Wrap as a minimal HTML paragraph block; downstream uses html_full_document.
+    paragraphs = "".join(f"<p>{_escape(p)}</p>" for p in translated.split("\n") if p.strip())
+    return RenderedPage(
+        title=f"{rendered.title} ({target_lang})",
+        html=paragraphs,
+    )
+
+
+def _escape(s: str) -> str:
+    if not s:
+        return ""
+    return (
+        s.replace("&", "&amp;")
+         .replace("<", "&lt;")
+         .replace(">", "&gt;")
+         .replace("\"", "&quot;")
+    )
+
+
+def render_ocr_pdf(original_pdf_bytes: bytes, archival: bool = True) -> bytes:
+    """OCR the original source PDF, returning a SEARCHABLE PDF.
+
+    Uses ``ocrmypdf`` which wraps Tesseract + Ghostscript. When
+    ``archival`` is True we ask for PDF/A output, which adds archival
+    metadata (font embedding, color profiles) -- this is NOT the same
+    as PDF/UA tagged structure. PDF/A != accessible. Real PDF/UA
+    tagging (proper structure tree, alt text on figures, language
+    markers, reading order metadata) requires a separate tagging pass
+    that we have not yet implemented.
+
+    The legacy ``tagged`` parameter name was misleading and has been
+    renamed to ``archival`` so callers stop assuming this output meets
+    PDF/UA accessibility requirements. If your code needs to assert
+    accessible PDF output, do not call this function -- the proper
+    accessible delivery is the converted Canvas HTML page.
+
+    Raises ``RuntimeError`` with a friendly message if Tesseract or
+    Ghostscript aren't installed in the container, so the endpoint can
+    return 503.
+    """
+    # Keep ``tagged`` aliased for backward compatibility one cycle.
+    # No call sites pass it positionally; remove after one release.
+    import io
+    try:
+        import ocrmypdf
+    except ImportError as exc:
+        raise RuntimeError(
+            "ocrmypdf not installed; add 'ocrmypdf' to dependencies and "
+            "ensure tesseract-ocr + ghostscript are installed in the Dockerfile"
+        ) from exc
+
+    out_type = "pdfa" if archival else "pdf"
+    in_buf = io.BytesIO(original_pdf_bytes)
+    out_buf = io.BytesIO()
+    # ``skip_text=True`` is the universal "make this searchable" mode: it OCRs
+    # image-only pages and PASSES THROUGH pages that already have a text layer.
+    # Critically, it also stops ocrmypdf from erroring on born-digital / tagged
+    # PDFs (which already have selectable text) — the default mode refuses
+    # those with "PriorOcrFound"/"Tagged PDF" and demands an override flag.
+    # ocrmypdf.ocr's first two parameters are POSITIONAL (the first is named
+    # ``input_file_or_options`` in current releases), so they must not be
+    # passed as keywords.
+    try:
+        ocrmypdf.ocr(
+            in_buf,
+            out_buf,
+            language="eng",
+            output_type=out_type,
+            skip_text=True,
+            deskew=True,
+            optimize=1,
+            progress_bar=False,
+        )
+    except Exception as exc:
+        raise RuntimeError(f"OCR failed: {exc}") from exc
+    return out_buf.getvalue()
+
+
+def render_braille_brf(rendered: RenderedPage, grade: int = 2, lang_table: str | None = None) -> bytes:
+    """Convert the canonical HTML's text to BRF (Braille Ready File).
+
+    Uses ``liblouis`` for translation. Default tables:
+      grade 1 (uncontracted) -> ``en-us-g1.ctb``
+      grade 2 (contracted)   -> ``en-us-g2.ctb``
+
+    Output is suitable for refreshable Braille displays and Braille
+    embossers. Raises RuntimeError with a friendly message if liblouis
+    isn't installed.
+    """
+    import shutil
+    import subprocess
+
+    text = html_to_plain_text(rendered)
+    if not text:
+        raise RuntimeError("Nothing to braille-translate")
+
+    lou = shutil.which("lou_translate")
+    if not lou:
+        raise RuntimeError(
+            "lou_translate not found; install liblouis-bin in the Dockerfile"
+        )
+
+    table = lang_table or ("en-us-g2.ctb" if grade == 2 else "en-us-g1.ctb")
+    try:
+        proc = subprocess.run(
+            [lou, table],
+            input=text.encode("utf-8"),
+            capture_output=True,
+            timeout=60,
+            check=True,
+        )
+    except subprocess.CalledProcessError as exc:
+        raise RuntimeError(
+            f"liblouis translation failed: {exc.stderr.decode('utf-8', errors='replace')[:300]}"
+        ) from exc
+    except subprocess.TimeoutExpired as exc:
+        raise RuntimeError("liblouis translation timed out") from exc
+    translated = proc.stdout.decode("utf-8", errors="replace")
+
+    # BRF expects ASCII-art Braille (40-char lines is convention).
+    # liblouis returns a single string; wrap to 40 cols per Braille standard.
+    lines: list[str] = []
+    for para in translated.split("\n"):
+        if not para:
+            lines.append("")
+            continue
+        cur = ""
+        for word in para.split(" "):
+            if len(cur) + len(word) + 1 <= 40:
+                cur = (cur + " " + word).strip() if cur else word
+            else:
+                if cur:
+                    lines.append(cur)
+                cur = word if len(word) <= 40 else word[:40]
+        if cur:
+            lines.append(cur)
+    return ("\n".join(lines) + "\n").encode("ascii", errors="replace")
+
+
+READER_TEMPLATE = """<!doctype html>
+<html lang=\"en\">
+<head>
+<meta charset=\"utf-8\">
+<title>__RFTITLE__ — Reader</title>
+<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">
+<style>
+:root {{ --bg: #fdf6e3; --fg: #1d1d1d; --accent: #0a5fb5; --focus: #ffeb99; }}
+body {{ background: var(--bg); color: var(--fg); font-family: Georgia, serif;
+       max-width: 42rem; margin: 0 auto; padding: 4rem 1.5rem 8rem;
+       line-height: 1.8; font-size: 1.15rem; }}
+body.dyslexia {{ font-family: 'OpenDyslexic','Comic Sans MS',sans-serif; letter-spacing: 0.04em; }}
+body.dark {{ --bg: #1d1d1d; --fg: #f8f9fa; }}
+h1, h2, h3 {{ font-family: system-ui, sans-serif; color: var(--accent); }}
+img {{ max-width: 100%; height: auto; }}
+.line-focus p, .line-focus li {{ opacity: 0.45; transition: opacity 200ms; }}
+.line-focus p.is-current, .line-focus li.is-current {{ opacity: 1; background: var(--focus); padding: 0 0.25rem; }}
+.toolbar {{ position: fixed; top: 0; left: 0; right: 0; background: rgba(255,255,255,0.96);
+            border-bottom: 1px solid #ccc; padding: 0.5rem 1rem; display: flex; gap: 0.4rem;
+            align-items: center; flex-wrap: wrap; z-index: 1000; }}
+.toolbar button, .toolbar select {{ background: #fff; border: 1px solid #ccc; padding: 0.35rem 0.7rem;
+            border-radius: 4px; cursor: pointer; font: inherit; }}
+.toolbar button:hover {{ background: #f0f0f0; }}
+.toolbar button[aria-pressed=\"true\"] {{ background: var(--accent); color: #fff; border-color: var(--accent); }}
+.toolbar .label {{ font-size: 0.8rem; color: #555; margin-right: 0.25rem; }}
+.spacer {{ flex: 1; }}
+body.dark .toolbar {{ background: rgba(40,40,40,0.96); color: #f8f9fa; }}
+body.dark .toolbar button, body.dark .toolbar select {{ background: #2a2a2a; color: #f8f9fa; border-color: #555; }}
+.dictionary-popup {{ position: absolute; background: #fff; border: 1px solid #888; border-radius: 6px;
+            box-shadow: 0 4px 12px rgba(0,0,0,0.2); padding: 0.5rem 0.75rem; max-width: 22rem;
+            font-size: 0.9rem; z-index: 2000; }}
+</style>
+</head>
+<body>
+<div class=\"toolbar\" role=\"toolbar\" aria-label=\"Reader controls\">
+  <span class=\"label\">Read aloud</span>
+  <button id=\"play\" aria-pressed=\"false\">▶ Play</button>
+  <button id=\"stop\">■ Stop</button>
+  <select id=\"voice\" aria-label=\"Voice\"></select>
+  <select id=\"rate\" aria-label=\"Speed\">
+    <option value=\"0.8\">0.8×</option><option value=\"1\" selected>1×</option>
+    <option value=\"1.2\">1.2×</option><option value=\"1.5\">1.5×</option>
+  </select>
+  <span class=\"spacer\"></span>
+  <span class=\"label\">Font</span>
+  <button id=\"font-smaller\" aria-label=\"Smaller\">A−</button>
+  <button id=\"font-larger\" aria-label=\"Larger\">A+</button>
+  <button id=\"dyslexia\" aria-pressed=\"false\" title=\"Dyslexia-friendly font\">Dyslexia</button>
+  <button id=\"dark\" aria-pressed=\"false\" title=\"Dark theme\">Dark</button>
+  <button id=\"focus\" aria-pressed=\"false\" title=\"Highlight current line\">Focus</button>
+</div>
+<article id=\"content\">
+<h1>__RFTITLE__</h1>
+__RFBODY__
+</article>
+<script>
+(function () {{
+  var article = document.getElementById('content');
+  var playBtn = document.getElementById('play');
+  var stopBtn = document.getElementById('stop');
+  var voiceSel = document.getElementById('voice');
+  var rateSel = document.getElementById('rate');
+  var smaller = document.getElementById('font-smaller');
+  var larger = document.getElementById('font-larger');
+  var dys = document.getElementById('dyslexia');
+  var dark = document.getElementById('dark');
+  var focusBtn = document.getElementById('focus');
+  var synth = window.speechSynthesis;
+  if (!synth) {{
+    playBtn.disabled = true; stopBtn.disabled = true; voiceSel.disabled = true;
+  }}
+
+  // Voice picker
+  function populateVoices() {{
+    if (!synth) return;
+    var voices = synth.getVoices() || [];
+    voiceSel.innerHTML = '';
+    voices.forEach(function (v, i) {{
+      var opt = document.createElement('option');
+      opt.value = String(i);
+      opt.textContent = v.name + ' (' + v.lang + ')';
+      if (v.default) opt.selected = true;
+      voiceSel.appendChild(opt);
+    }});
+  }}
+  populateVoices();
+  if (synth) synth.onvoiceschanged = populateVoices;
+
+  // Build paragraph list for sequential read + focus
+  var paragraphs = Array.prototype.slice.call(article.querySelectorAll('p, li, h1, h2, h3, h4'));
+  var idx = -1;
+  var playing = false;
+
+  function readNext() {{
+    idx++;
+    if (idx >= paragraphs.length) {{ stop(); return; }}
+    var el = paragraphs[idx];
+    paragraphs.forEach(function (p) {{ p.classList.remove('is-current'); }});
+    el.classList.add('is-current');
+    el.scrollIntoView({{ block: 'center', behavior: 'smooth' }});
+    var utter = new SpeechSynthesisUtterance(el.textContent.trim());
+    var voices = synth.getVoices() || [];
+    var sel = voices[parseInt(voiceSel.value)];
+    if (sel) utter.voice = sel;
+    utter.rate = parseFloat(rateSel.value);
+    utter.onend = function () {{ if (playing) readNext(); }};
+    synth.speak(utter);
+  }}
+  function play() {{ playing = true; playBtn.setAttribute('aria-pressed', 'true'); readNext(); }}
+  function stop() {{ playing = false; idx = -1; playBtn.setAttribute('aria-pressed', 'false');
+                     synth && synth.cancel(); paragraphs.forEach(function (p) {{ p.classList.remove('is-current'); }}); }}
+
+  playBtn.addEventListener('click', function () {{ if (!playing) play(); else stop(); }});
+  stopBtn.addEventListener('click', stop);
+
+  // Font size
+  var size = 1.15;
+  function setSize(s) {{ size = Math.max(0.7, Math.min(2.5, s)); document.body.style.fontSize = size + 'rem'; }}
+  smaller.addEventListener('click', function () {{ setSize(size - 0.1); }});
+  larger.addEventListener('click', function () {{ setSize(size + 0.1); }});
+
+  // Dyslexia font
+  dys.addEventListener('click', function () {{
+    var on = document.body.classList.toggle('dyslexia');
+    dys.setAttribute('aria-pressed', on ? 'true' : 'false');
+  }});
+
+  // Dark mode
+  dark.addEventListener('click', function () {{
+    var on = document.body.classList.toggle('dark');
+    dark.setAttribute('aria-pressed', on ? 'true' : 'false');
+  }});
+
+  // Line focus (uses .line-focus on body; CSS handles rest)
+  focusBtn.addEventListener('click', function () {{
+    var on = document.body.classList.toggle('line-focus');
+    focusBtn.setAttribute('aria-pressed', on ? 'true' : 'false');
+  }});
+
+  // Picture dictionary on click: highlight word, show definition popup via Free Dictionary API.
+  article.addEventListener('click', function (e) {{
+    var sel = window.getSelection();
+    var word = sel.toString().trim();
+    if (!word || word.indexOf(' ') >= 0) return;
+    var existing = document.querySelector('.dictionary-popup');
+    if (existing) existing.remove();
+    var pop = document.createElement('div');
+    pop.className = 'dictionary-popup';
+    pop.style.left = (e.pageX + 10) + 'px';
+    pop.style.top = (e.pageY + 10) + 'px';
+    pop.textContent = 'Looking up "' + word + '"…';
+    document.body.appendChild(pop);
+    fetch('https://api.dictionaryapi.dev/api/v2/entries/en/' + encodeURIComponent(word))
+      .then(function (r) {{ return r.json(); }})
+      .then(function (j) {{
+        if (Array.isArray(j) && j[0] && j[0].meanings && j[0].meanings[0]) {{
+          var m = j[0].meanings[0];
+          var def = (m.definitions && m.definitions[0] && m.definitions[0].definition) || '(no definition)';
+          pop.innerHTML = '<strong>' + word + '</strong> <em>(' + (m.partOfSpeech || '') + ')</em><br>' + def;
+        }} else {{
+          pop.textContent = 'No definition found for "' + word + '".';
+        }}
+      }})
+      .catch(function () {{ pop.textContent = 'Dictionary lookup failed.'; }});
+    setTimeout(function () {{ pop.remove(); }}, 10000);
+  }});
+}})();
+</script>
+</body>
+</html>
+"""
+
+
+def render_reader_html(rendered: RenderedPage) -> str:
+    """Render an Immersive-Reader-style standalone HTML page.
+
+    Uses the browser's built-in Web Speech API (no Azure required).
+    Features: read-aloud with voice + speed picker, line focus, font
+    size, dyslexia font, dark mode, click-a-word picture dictionary.
+    Works in any modern browser, free, no API costs.
+    """
+    # READER_TEMPLATE doubles all its CSS/JS braces ({{ }}) so it can pass
+    # through str.format(). But the document body routinely contains literal
+    # braces (LaTeX math like \frac{a}{b}, set notation, code, JSON) which
+    # str.format() would try to interpret as replacement fields and crash on
+    # ("Single '{' encountered" / KeyError) — 500-ing the reader. So title and
+    # body are no-field sentinels injected via str.replace(); .format() with no
+    # args is used only to un-double the template's own braces.
+    page = READER_TEMPLATE.format()
+    page = page.replace("__RFTITLE__", _escape(rendered.title or "Document"))
+    page = page.replace("__RFBODY__", rendered.html or "")
+    return page
diff --git a/src/canvas/audit.py b/src/canvas/audit.py
new file mode 100644
index 0000000..59e1370
--- /dev/null
+++ b/src/canvas/audit.py
@@ -0,0 +1,119 @@
+"""Structured audit log for Canvas API operations.
+
+Every Canvas API call, every token mint/refresh, and every state
+transition that affects a faculty member\'s data should write a row
+here. Goals:
+
+  * Production ops can answer "what did Reflow do in our Canvas
+    yesterday for user X" within minutes from data, not memory.
+  * Privacy review can confirm we never reach into a course we
+    weren\'t launched into.
+  * If Canvas reports anomalous traffic from our client_id, we can
+    show them our matching log.
+
+Records are written via the standard ``logging`` module under the
+``reflow.canvas.audit`` logger. They are JSON-encoded so a downstream
+log shipper (Datadog, CloudWatch, etc.) can index them as structured
+data. For local dev they\'re also human-readable in plain text logs.
+
+Field conventions:
+
+  * ``event``       short verb-ish identifier (``api_call``, ``token_mint``,
+                    ``token_refresh``, ``oauth_consent``, ...)
+  * ``platform``    16-char platform_id (sha256 truncated)
+  * ``user``        Canvas user_id (LTI ``sub``) when known
+  * ``course``      Canvas course_id when relevant
+  * ``method``      HTTP verb for API calls
+  * ``path``        URL path (no host, no query) for API calls
+  * ``status``      HTTP status from upstream
+  * ``latency_ms``  monotonic latency in ms
+  * ``scope_hash``  short hash of the scope set, to correlate calls
+                    using the same token without leaking the scope list
+  * ``request_id``  middleware-issued correlation id
+
+Sensitive data NEVER appears: no access tokens, no refresh tokens, no
+JWT assertions, no email addresses, no file contents.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import time
+from contextlib import contextmanager
+from typing import Any
+
+_audit = logging.getLogger("reflow.canvas.audit")
+
+
+def _scope_fingerprint(scopes: list[str] | tuple[str, ...] | None) -> str:
+    """Order-independent 12-char hash of a scope set."""
+    if not scopes:
+        return "none"
+    blob = "\n".join(sorted(scopes)).encode("utf-8")
+    return hashlib.sha256(blob).hexdigest()[:12]
+
+
+def emit(event: str, **fields: Any) -> None:
+    """Write one structured audit row.
+
+    Wraps ``logging.info`` so every record carries the same JSON body
+    shape. Callers pass any subset of the conventional fields.
+    """
+    payload: dict[str, Any] = {"event": event}
+    for k, v in fields.items():
+        if v is None:
+            continue
+        if k == "scopes":
+            payload["scope_hash"] = _scope_fingerprint(v)
+            continue
+        payload[k] = v
+    try:
+        _audit.info(json.dumps(payload, default=str))
+    except Exception:  # pragma: no cover -- audit must never raise
+        _audit.info("audit-emit-failed event=%s", event)
+
+
+@contextmanager
+def time_api_call(
+    *,
+    platform: str | None,
+    user: str | None,
+    method: str,
+    path: str,
+    scopes: list[str] | None = None,
+):
+    """Context manager for an outbound Canvas API call.
+
+    Use::
+
+        with audit.time_api_call(platform=..., user=..., method="GET",
+                                  path="/api/v1/courses/x/files") as ctx:
+            resp = await http.get(...)
+            ctx["status"] = resp.status_code
+
+    On exit emits a single ``api_call`` row with status + latency. If an
+    exception escapes, ``status`` is set to ``-1`` so ops can find
+    request-aborted calls (DNS timeouts, etc.) separately from upstream
+    4xx/5xx.
+    """
+    ctx: dict[str, Any] = {"status": None}
+    started = time.monotonic()
+    try:
+        yield ctx
+    except Exception:
+        ctx["status"] = -1
+        raise
+    finally:
+        latency_ms = int((time.monotonic() - started) * 1000)
+        emit(
+            "api_call",
+            platform=platform,
+            user=user,
+            method=method,
+            path=path,
+            status=ctx.get("status"),
+            latency_ms=latency_ms,
+            scopes=scopes,
+        )
diff --git a/src/canvas/client.py b/src/canvas/client.py
new file mode 100644
index 0000000..d7dc15e
--- /dev/null
+++ b/src/canvas/client.py
@@ -0,0 +1,720 @@
+"""Async Canvas REST client with dual auth modes.
+
+Three construction paths:
+
+  * ``CanvasClient(base_url=..., api_token=...)`` -- legacy single-tenant
+    path. Bearer comes from ``settings.canvas_api_token``. Kept for the
+    watcher in non-multi-tenant deployments and for local dev.
+
+  * ``CanvasClient.from_platform(redis, platform, scopes)`` -- LTI
+    Advantage service-token path (Phase 3). Bearer is minted via
+    ``canvas.oauth.get_service_token`` against the platform's token
+    endpoint. Canvas Cloud only honors these tokens at LTI Advantage
+    service endpoints (NRPS, AGS, Deep Linking) -- they are NOT valid
+    against the general ``/api/v1/...`` REST API.
+
+  * ``CanvasClient.from_user_token(redis, platform, user_id)`` -- per-
+    user OAuth2 path (Phase 8). Bearer is a user-bound token obtained
+    through Canvas's authorization-code flow with explicit faculty
+    consent. This is the path that actually works for the general
+    Canvas REST API in Canvas Cloud. Refreshes silently on 401 via the
+    stored refresh_token.
+
+Both paths converge through ``_headers()``, an async helper that
+produces the Authorization dict for every API call. Method bodies do
+not know or care which auth mode is active.
+
+401 handling: when a call returns 401 and we're in platform mode, the
+cached token is invalidated and the call is retried exactly once with a
+fresh token. The retry covers both "Canvas rotated its own key" and
+"the previous token aged out faster than expected"; a second 401 after
+the refresh is surfaced to the caller as a permission problem.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Awaitable, Callable
+
+import httpx
+
+from ..config import settings
+from ..utils.retry_helpers import retry_with_backoff
+from .errors import CanvasApiError
+
+
+# Canvas occasionally returns 429 / 502 / 503 under load (especially during
+# bulk roster pulls or the start of a semester). Wrap network calls in
+# exponential backoff so a single transient blip doesn't kill the watcher
+# tick. Numbers are tuned to be patient (Canvas's 429 rate-limit window is
+# ~3s) but not stalling (max 30s of waiting per call). Caller-visible
+# permanent errors (404, 401) are *not* retried - the helper categorizes
+# via is_retryable_error.
+_RETRY_MAX_ATTEMPTS = 3
+_RETRY_BASE_DELAY = 1.0
+_RETRY_MAX_DELAY = 30.0
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_TIMEOUT = 30.0
+
+
+class CanvasClient:
+    """Async client scoped to a single Canvas instance.
+
+    Construction is cheap; create one per request or share one process-wide
+    -- ``httpx.AsyncClient`` is safe to share.
+    """
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        api_token: str | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self.base_url = (base_url or getattr(settings, "canvas_api_url", "") or "").rstrip("/")
+        if not self.base_url:
+            raise ValueError("CanvasClient: base_url is required")
+        token = api_token or _resolve_default_token()
+        self._static_headers: dict[str, str] | None = {"Authorization": f"Bearer {token}"}
+        self._timeout = timeout
+        # Platform-mode fields stay None on the legacy path.
+        self._redis: Any | None = None
+        self._platform: Any | None = None
+        self._scopes: list[str] | None = None
+        # User-OAuth-mode fields stay None on the other two paths.
+        self._user_id: str | None = None
+
+    @classmethod
+    def from_platform(
+        cls,
+        redis: Any,
+        platform: Any,
+        scopes: list[str],
+        *,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> "CanvasClient":
+        """Construct a client that authenticates via LTI service tokens.
+
+        ``platform`` is a ``PlatformInstall`` from ``src.lti.platform``.
+        ``scopes`` is the list of Canvas API scopes this client will
+        request -- typically the union of scopes the surrounding code
+        path needs. Tokens are cached per (platform, scope-set) so two
+        callers asking for the same scope set share a bearer.
+        """
+
+        inst = cls.__new__(cls)
+        api_base = (platform.canvas_api_base or "").rstrip("/")
+        # The legacy code does f"{self.base_url}/api/v1/...", so base_url
+        # is the bare scheme+host. The platform's canvas_api_base ends in
+        # /api/v1, so strip it off.
+        if api_base.endswith("/api/v1"):
+            inst.base_url = api_base[: -len("/api/v1")]
+        else:
+            inst.base_url = api_base
+        if not inst.base_url:
+            raise ValueError("CanvasClient.from_platform: platform.canvas_api_base is empty")
+        inst._timeout = timeout
+        inst._static_headers = None
+        inst._redis = redis
+        inst._platform = platform
+        inst._scopes = list(scopes)
+        inst._user_id = None
+        return inst
+
+    @classmethod
+    def from_user_token(
+        cls,
+        redis: Any,
+        platform: Any,
+        user_id: str,
+        *,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> "CanvasClient":
+        """Construct a client that uses a faculty member's OAuth2 token.
+
+        ``platform`` is a ``PlatformInstall``; ``user_id`` is the
+        ``lti.session.SessionPayload.user_id`` (i.e. Canvas's ``sub``
+        claim). The user must have completed the OAuth2 consent flow
+        beforehand; this constructor does not initiate it.
+
+        On every call, the client loads the stored token from Redis,
+        checks expiry, refreshes via the stored refresh_token if needed,
+        and uses the resulting access_token as the Bearer credential.
+        401s trigger a forced refresh + one retry, same shape as
+        ``from_platform``.
+        """
+        inst = cls.__new__(cls)
+        api_base = (platform.canvas_api_base or "").rstrip("/")
+        if api_base.endswith("/api/v1"):
+            inst.base_url = api_base[: -len("/api/v1")]
+        else:
+            inst.base_url = api_base
+        if not inst.base_url:
+            raise ValueError(
+                "CanvasClient.from_user_token: platform.canvas_api_base empty"
+            )
+        inst._timeout = timeout
+        inst._static_headers = None
+        inst._redis = redis
+        inst._platform = platform
+        inst._scopes = None
+        inst._user_id = user_id
+        return inst
+
+    # ---- Auth ----------------------------------------------------------
+
+    async def _headers(self, *, force_refresh: bool = False) -> dict[str, str]:
+        """Build the Authorization header for one API call.
+
+        Three paths converge here:
+
+        * Static (legacy): returns the dict computed in ``__init__``.
+        * Platform (service-token): asks ``canvas.oauth`` for a cached or
+          fresh service token.
+        * User-OAuth: loads the user's stored access_token, refreshes
+          via the stored refresh_token if expired or if
+          ``force_refresh`` is set.
+        """
+        if self._static_headers is not None:
+            return dict(self._static_headers)
+        if self._user_id is not None:
+            return await self._user_token_headers(force_refresh=force_refresh)
+        # Platform/service-token path
+        from .oauth import get_service_token
+
+        token = await get_service_token(
+            self._redis,
+            self._platform,
+            self._scopes or [],
+            force_refresh=force_refresh,
+        )
+        return {"Authorization": f"Bearer {token.access_token}"}
+
+    async def _user_token_headers(self, *, force_refresh: bool) -> dict[str, str]:
+        """Headers from the user-OAuth path: load, refresh-if-stale, return."""
+        from .user_oauth import (
+            UserOAuthError,
+            drop_user_token,
+            get_user_token,
+            put_user_token,
+            refresh_user_token,
+        )
+
+        token = await get_user_token(
+            self._redis, self._platform.platform_id, self._user_id
+        )
+        if token is None:
+            raise CanvasApiError(
+                401,
+                f"No user OAuth token stored for user_id={self._user_id} "
+                f"on platform={self._platform.platform_id}. The user has "
+                "not yet completed the Canvas authorize flow.",
+            )
+
+        if force_refresh or token.is_expired():
+            if not token.refresh_token:
+                # No refresh token -> can't silently renew. Bubble up as
+                # 401 so the surrounding LTI flow can re-prompt consent.
+                await drop_user_token(
+                    self._redis, self._platform.platform_id, self._user_id
+                )
+                raise CanvasApiError(
+                    401,
+                    "Stored user token expired and has no refresh_token; "
+                    "user must re-authorize via /canvas/oauth/authorize.",
+                )
+            # Pick client-auth scheme matching whichever dev key the
+            # operator configured. See the matching block in
+            # src/api/canvas_oauth.py callback handler for the rationale.
+            from ..config import settings as _s
+            oauth_secret = getattr(_s, "canvas_oauth_client_secret", None)
+            secret_val = ""
+            if oauth_secret is not None:
+                secret_val = (
+                    oauth_secret.get_secret_value()
+                    if hasattr(oauth_secret, "get_secret_value")
+                    else str(oauth_secret)
+                )
+            try:
+                if secret_val:
+                    token = await refresh_user_token(
+                        self._platform,
+                        refresh_token=token.refresh_token,
+                        canvas_user_id=token.canvas_user_id,
+                        client_secret=secret_val,
+                    )
+                else:
+                    from ..api.canvas_oauth import (
+                        _client_assertion_for_token_endpoint,
+                    )
+                    assertion = _client_assertion_for_token_endpoint(
+                        self._platform
+                    )
+                    token = await refresh_user_token(
+                        self._platform,
+                        refresh_token=token.refresh_token,
+                        canvas_user_id=token.canvas_user_id,
+                        client_assertion=assertion,
+                    )
+            except UserOAuthError as exc:
+                logger.warning(
+                    "User token refresh failed for user=%s platform=%s: %s",
+                    self._user_id, self._platform.platform_id, exc,
+                )
+                await drop_user_token(
+                    self._redis, self._platform.platform_id, self._user_id
+                )
+                raise CanvasApiError(
+                    401,
+                    f"User token refresh failed: {exc}; re-authorize needed.",
+                ) from exc
+            await put_user_token(
+                self._redis, self._platform.platform_id, self._user_id, token,
+            )
+        return {"Authorization": f"Bearer {token.access_token}"}
+
+    async def _invalidate_token(self) -> None:
+        """Drop the cached service or user token for the active path.
+
+        No-op in legacy/static mode. The 401 retry path calls this
+        before requesting fresh headers.
+        """
+        if self._static_headers is not None:
+            return
+        if self._user_id is not None:
+            # User-OAuth path: nothing to invalidate; ``_headers`` will
+            # force a refresh via the stored refresh_token on the next
+            # call (we set force_refresh=True in the retry path).
+            return
+        from .oauth import invalidate
+
+        await invalidate(
+            self._redis,
+            self._platform.platform_id,
+            self._scopes or [],
+        )
+
+    async def _request_with_401_retry(
+        self,
+        do_request: Callable[[dict[str, str]], Awaitable[httpx.Response]],
+        op: str,
+    ) -> httpx.Response:
+        """Run ``do_request`` once, refresh on 401, run again at most once."""
+        headers = await self._headers()
+        resp = await do_request(headers)
+        if resp.status_code != 401 or self._static_headers is not None:
+            return resp
+        # Platform-mode 401: invalidate + retry once with fresh token.
+        logger.info(
+            "Canvas %s -> 401; refreshing service token and retrying once", op,
+        )
+        await self._invalidate_token()
+        headers = await self._headers(force_refresh=True)
+        return await do_request(headers)
+
+    # ---- Files ---------------------------------------------------------
+
+    async def list_course_pdfs(self, course_id: str) -> list[dict[str, Any]]:
+        """Return PDF files in a course (paginated under the hood)."""
+
+        url = f"{self.base_url}/api/v1/courses/{course_id}/files"
+        params = {"content_types[]": "application/pdf", "per_page": "100"}
+        return await self._get_paged(url, params)
+
+    async def get_file_metadata(self, file_id: str) -> dict[str, Any]:
+        """Fetch a file's metadata by id."""
+
+        url = f"{self.base_url}/api/v1/files/{file_id}"
+
+        async def _do(headers: dict[str, str]) -> httpx.Response:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                return await client.get(url, headers=headers)
+
+        resp = await self._request_with_401_retry(_do, "GET file metadata")
+        self._raise_for_status(resp, "GET file metadata")
+        return resp.json()
+
+    async def list_modules(self, course_id: str) -> list[dict[str, Any]]:
+        url = f"{self.base_url}/api/v1/courses/{course_id}/modules"
+        return await self._get_paged(url, {"per_page": "100"})
+
+    async def list_module_items(self, course_id: str, module_id: str) -> list[dict[str, Any]]:
+        url = f"{self.base_url}/api/v1/courses/{course_id}/modules/{module_id}/items"
+        return await self._get_paged(url, {"per_page": "100"})
+
+    async def list_course_folders(self, course_id: str) -> list[dict[str, Any]]:
+        url = f"{self.base_url}/api/v1/courses/{course_id}/folders"
+        return await self._get_paged(url, {"per_page": "100"})
+
+    async def list_folder_files(self, folder_id: str) -> list[dict[str, Any]]:
+        url = f"{self.base_url}/api/v1/folders/{folder_id}/files"
+        return await self._get_paged(url, {"per_page": "100"})
+
+    async def download_file(self, file_id: str) -> bytes:
+        """Fetch the raw bytes of a Canvas file.
+
+        Wrapped in exponential backoff because large textbooks can be
+        100MB+ and Canvas occasionally returns a transient 502 mid-fetch.
+        """
+
+        url = f"{self.base_url}/api/v1/files/{file_id}"
+
+        async def _do_download() -> bytes:
+            async def _meta(headers: dict[str, str]) -> httpx.Response:
+                async with httpx.AsyncClient(timeout=self._timeout) as client:
+                    return await client.get(url, headers=headers)
+
+            meta_resp = await self._request_with_401_retry(_meta, "GET file metadata")
+            self._raise_for_status(meta_resp, "GET file metadata")
+            meta = meta_resp.json()
+            download_url = meta.get("url")
+            if not download_url:
+                raise CanvasApiError(404, f"File {file_id} has no download URL")
+
+            # The download URL is a presigned S3 link; it doesn't need our
+            # bearer (Canvas signs the URL with its own credentials). But
+            # we still pass headers to follow Canvas's own conventions in
+            # case the API ever changes; the S3 bucket just ignores them.
+            async def _bytes(headers: dict[str, str]) -> httpx.Response:
+                async with httpx.AsyncClient(timeout=self._timeout) as client:
+                    return await client.get(
+                        download_url, headers=headers, follow_redirects=True
+                    )
+
+            file_resp = await self._request_with_401_retry(_bytes, "download file")
+            self._raise_for_status(file_resp, "download file")
+            return file_resp.content
+
+        return await retry_with_backoff(
+            _do_download,
+            max_attempts=_RETRY_MAX_ATTEMPTS,
+            base_delay=_RETRY_BASE_DELAY,
+            max_delay=_RETRY_MAX_DELAY,
+            operation_name=f"canvas.download_file({file_id})",
+        )
+
+    async def upload_course_file(
+        self,
+        course_id: str,
+        filename: str,
+        content: bytes,
+        *,
+        content_type: str = "application/octet-stream",
+        folder_path: str = "",
+        on_duplicate: str = "overwrite",
+    ) -> dict[str, Any]:
+        """Upload a file into a course via Canvas's 3-step upload flow.
+
+        1. POST to ``/courses/:id/files`` to get a pre-signed ``upload_url``
+           + ``upload_params``.
+        2. POST the bytes to that storage URL (no bearer — the params are
+           already signed). Canvas/S3 returns either the file JSON (201) or
+           a 3xx whose ``Location`` finalizes the upload.
+        3. If redirected, GET ``Location`` (with our bearer) to get the
+           final file object.
+
+        ``folder_path`` is a course-relative folder (created if missing),
+        e.g. ``"Reflow Generated Images"``. Returns the Canvas file object,
+        which includes ``id`` and ``url`` (a directly-embeddable link).
+        """
+        init_url = f"{self.base_url}/api/v1/courses/{course_id}/files"
+        init_payload: dict[str, Any] = {
+            "name": filename,
+            "size": len(content),
+            "content_type": content_type,
+            "on_duplicate": on_duplicate,
+        }
+        if folder_path:
+            init_payload["parent_folder_path"] = folder_path
+
+        async def _init(headers: dict[str, str]) -> httpx.Response:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                return await client.post(init_url, headers=headers, json=init_payload)
+
+        init_resp = await self._request_with_401_retry(_init, "init file upload")
+        self._raise_for_status(init_resp, "init file upload")
+        init = init_resp.json()
+        upload_url = init.get("upload_url")
+        upload_params = init.get("upload_params") or {}
+        if not upload_url:
+            raise CanvasApiError(502, "Canvas file upload: no upload_url returned")
+
+        # Step 2: post to the storage target. No auth header — upload_params
+        # carry the signed credentials. Don't auto-follow the redirect so we
+        # can finalize it ourselves with our bearer.
+        files = {"file": (filename, content, content_type)}
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
+            store_resp = await client.post(
+                upload_url, data=upload_params, files=files, follow_redirects=False
+            )
+
+        if store_resp.status_code in (200, 201):
+            try:
+                return store_resp.json()
+            except ValueError:
+                pass
+        location = store_resp.headers.get("Location")
+        if location:
+            async def _confirm(headers: dict[str, str]) -> httpx.Response:
+                async with httpx.AsyncClient(timeout=self._timeout) as client:
+                    # Canvas wants an empty POST/GET to finalize; GET works.
+                    return await client.get(location, headers=headers)
+
+            confirm_resp = await self._request_with_401_retry(_confirm, "confirm file upload")
+            self._raise_for_status(confirm_resp, "confirm file upload")
+            return confirm_resp.json()
+        self._raise_for_status(store_resp, "store file upload")
+        return {}
+
+    # ---- Pages ---------------------------------------------------------
+
+    async def create_page(
+        self,
+        course_id: str,
+        title: str,
+        body_html: str,
+        *,
+        published: bool = False,
+        notify_of_update: bool = False,
+    ) -> dict[str, Any]:
+        url = f"{self.base_url}/api/v1/courses/{course_id}/pages"
+        payload = {
+            "wiki_page": {
+                "title": title,
+                "body": body_html,
+                "published": published,
+                "notify_of_update": notify_of_update,
+            }
+        }
+
+        async def _do(headers: dict[str, str]) -> httpx.Response:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                return await client.post(url, headers=headers, json=payload)
+
+        resp = await self._request_with_401_retry(_do, "create page")
+        self._raise_for_status(resp, "create page")
+        return resp.json()
+
+    @staticmethod
+    def _page_ref(page_url_or_slug: str) -> str:
+        """Normalize a page reference to the bare slug Canvas's API expects.
+
+        Accepts either a stored full URL (``https://host/courses/1/pages/my-page``)
+        or a bare slug (``my-page``) and returns just ``my-page``. This lets the
+        rest of the code store the full ``html_url`` (so the overlay link works)
+        while the pages API still gets the ``:url_or_id`` segment it needs.
+        """
+        s = (page_url_or_slug or "").strip()
+        if "/pages/" in s:
+            s = s.split("/pages/", 1)[1]
+        s = s.split("?", 1)[0].split("#", 1)[0]
+        return s.strip("/")
+
+    async def update_page(
+        self,
+        course_id: str,
+        page_ref: str,
+        title: str,
+        body_html: str,
+    ) -> dict[str, Any]:
+        """Update an existing wiki page's title + body in place (PUT).
+
+        Raises ``CanvasApiError(404)`` when the page doesn't exist, so the
+        bridge can fall back to ``create_page``. Publish state is left
+        untouched (we don't send ``published``), so a draft stays a draft.
+        """
+        ref = self._page_ref(page_ref)
+        url = f"{self.base_url}/api/v1/courses/{course_id}/pages/{ref}"
+        payload = {"wiki_page": {"title": title, "body": body_html}}
+
+        async def _do(headers: dict[str, str]) -> httpx.Response:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                return await client.put(url, headers=headers, json=payload)
+
+        resp = await self._request_with_401_retry(_do, "update page")
+        self._raise_for_status(resp, "update page")
+        return resp.json()
+
+    async def publish_page(self, course_id: str, page_url: str) -> dict[str, Any]:
+        ref = self._page_ref(page_url)
+        url = f"{self.base_url}/api/v1/courses/{course_id}/pages/{ref}"
+
+        async def _do(headers: dict[str, str]) -> httpx.Response:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                return await client.put(
+                    url, headers=headers, json={"wiki_page": {"published": True}},
+                )
+
+        resp = await self._request_with_401_retry(_do, "publish page")
+        self._raise_for_status(resp, "publish page")
+        return resp.json()
+
+    async def unpublish_page(self, course_id: str, page_url: str) -> dict[str, Any]:
+        """Set a wiki page back to unpublished (draft) so students can't see it.
+
+        Mirror of ``publish_page``: PUTs ``published: false``. Used when faculty
+        take an accessible page down from the overlay's Unpublish action.
+        """
+        ref = self._page_ref(page_url)
+        url = f"{self.base_url}/api/v1/courses/{course_id}/pages/{ref}"
+
+        async def _do(headers: dict[str, str]) -> httpx.Response:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                return await client.put(
+                    url, headers=headers, json={"wiki_page": {"published": False}},
+                )
+
+        resp = await self._request_with_401_retry(_do, "unpublish page")
+        self._raise_for_status(resp, "unpublish page")
+        return resp.json()
+
+    async def delete_page(self, course_id: str, page_url: str) -> None:
+        ref = self._page_ref(page_url)
+        url = f"{self.base_url}/api/v1/courses/{course_id}/pages/{ref}"
+
+        async def _do(headers: dict[str, str]) -> httpx.Response:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                return await client.delete(url, headers=headers)
+
+        resp = await self._request_with_401_retry(_do, "delete page")
+        self._raise_for_status(resp, "delete page")
+
+    # ---- Conversations ------------------------------------------------
+
+    async def send_conversation(
+        self,
+        recipient_user_id: str,
+        subject: str,
+        body: str,
+        *,
+        context_code: str | None = None,
+    ) -> dict[str, Any]:
+        url = f"{self.base_url}/api/v1/conversations"
+        payload: dict[str, Any] = {
+            "recipients[]": recipient_user_id,
+            "subject": subject,
+            "body": body,
+        }
+        if context_code:
+            payload["context_code"] = context_code
+
+        async def _do(headers: dict[str, str]) -> httpx.Response:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                return await client.post(url, headers=headers, data=payload)
+
+        resp = await self._request_with_401_retry(_do, "send conversation")
+        self._raise_for_status(resp, "send conversation")
+        return resp.json()
+
+    # ---- Content surfaces (scan for embedded file references) --------
+
+    async def list_pages(self, course_id: str) -> list:
+        url = f"{self.base_url}/api/v1/courses/{course_id}/pages"
+        return await self._get_paged(url, {"per_page": "100", "published": "true"})
+
+    async def get_page(self, course_id: str, page_url: str) -> dict:
+        full_url = f"{self.base_url}/api/v1/courses/{course_id}/pages/{page_url}"
+
+        async def _do(headers: dict[str, str]) -> httpx.Response:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                return await client.get(full_url, headers=headers)
+
+        resp = await self._request_with_401_retry(_do, "GET page")
+        self._raise_for_status(resp, "GET page")
+        return resp.json()
+
+    async def list_discussion_topics(self, course_id: str, include_announcements: bool = True) -> list:
+        topics = []
+        for params in ([{"per_page": "100"}] +
+                       ([{"per_page": "100", "only_announcements": "true"}] if include_announcements else [])):
+            url = f"{self.base_url}/api/v1/courses/{course_id}/discussion_topics"
+            try:
+                topics.extend(await self._get_paged(url, params))
+            except CanvasApiError as exc:
+                logger.debug("discussion_topics listing failed: %s", exc)
+        return topics
+
+    async def list_discussion_entries(self, course_id: str, topic_id: str) -> list:
+        url = f"{self.base_url}/api/v1/courses/{course_id}/discussion_topics/{topic_id}/entries"
+        return await self._get_paged(url, {"per_page": "100"})
+
+    async def list_assignments(self, course_id: str) -> list:
+        url = f"{self.base_url}/api/v1/courses/{course_id}/assignments"
+        return await self._get_paged(url, {"per_page": "100"})
+
+    async def list_quizzes(self, course_id: str) -> list:
+        url = f"{self.base_url}/api/v1/courses/{course_id}/quizzes"
+        return await self._get_paged(url, {"per_page": "100"})
+
+    async def get_course_syllabus(self, course_id: str) -> dict:
+        url = f"{self.base_url}/api/v1/courses/{course_id}"
+
+        async def _do(headers: dict[str, str]) -> httpx.Response:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                return await client.get(
+                    url, headers=headers, params={"include[]": "syllabus_body"},
+                )
+
+        resp = await self._request_with_401_retry(_do, "GET course syllabus")
+        self._raise_for_status(resp, "GET course syllabus")
+        return resp.json()
+
+    # ---- Internals ----------------------------------------------------
+
+    async def _get_paged(self, url: str, params: dict[str, str]) -> list[dict[str, Any]]:
+        """Walk Canvas's Link-header pagination, returning all rows."""
+
+        async def _fetch_one(
+            client: httpx.AsyncClient, u: str, p: dict[str, str] | None
+        ) -> httpx.Response:
+            async def _go() -> httpx.Response:
+                async def _req(headers: dict[str, str]) -> httpx.Response:
+                    return await client.get(u, headers=headers, params=p)
+                resp = await self._request_with_401_retry(_req, "list (paged)")
+                self._raise_for_status(resp, "list (paged)")
+                return resp
+
+            return await retry_with_backoff(
+                _go,
+                max_attempts=_RETRY_MAX_ATTEMPTS,
+                base_delay=_RETRY_BASE_DELAY,
+                max_delay=_RETRY_MAX_DELAY,
+                operation_name="canvas._get_paged",
+            )
+
+        results: list[dict[str, Any]] = []
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
+            next_url: str | None = url
+            next_params: dict[str, str] | None = params
+            while next_url:
+                resp = await _fetch_one(client, next_url, next_params)
+                results.extend(resp.json())
+                next_url = _next_link(resp.headers.get("Link"))
+                next_params = None
+        return results
+
+    def _raise_for_status(self, resp: httpx.Response, op: str) -> None:
+        if resp.is_success:
+            return
+        logger.debug("Canvas %s -> %d: %s", op, resp.status_code, resp.text[:500])
+        raise CanvasApiError(resp.status_code, f"{op} failed")
+
+
+def _next_link(link_header: str | None) -> str | None:
+    if not link_header:
+        return None
+    for part in link_header.split(","):
+        seg = part.strip()
+        if seg.endswith('rel="next"'):
+            return seg.split(";", 1)[0].strip().strip("<>")
+    return None
+
+
+def _resolve_default_token() -> str:
+    token = getattr(settings, "canvas_api_token", None)
+    if not token:
+        raise ValueError("CanvasClient: settings.canvas_api_token is required")
+    if hasattr(token, "get_secret_value"):
+        token = token.get_secret_value()
+    return str(token)
diff --git a/src/canvas/errors.py b/src/canvas/errors.py
new file mode 100644
index 0000000..9e361d4
--- /dev/null
+++ b/src/canvas/errors.py
@@ -0,0 +1,16 @@
+"""Exception types for the Canvas API client."""
+
+from __future__ import annotations
+
+
+class CanvasApiError(Exception):
+    """Raised when Canvas returns a non-success response.
+
+    Carries the HTTP status and a short, log-safe message. The full
+    response body is left to the logger; callers should not parse it.
+    """
+
+    def __init__(self, status_code: int, message: str) -> None:
+        super().__init__(f"Canvas API {status_code}: {message}")
+        self.status_code = status_code
+        self.message = message
diff --git a/src/canvas/markdown_to_html.py b/src/canvas/markdown_to_html.py
new file mode 100644
index 0000000..aab3c63
--- /dev/null
+++ b/src/canvas/markdown_to_html.py
@@ -0,0 +1,108 @@
+"""Render Reflow markdown into Canvas-compatible HTML.
+
+Canvas's wiki page editor accepts a subset of HTML. We intentionally do
+*not* embed CSS or scripts — Canvas strips most of it anyway, and any
+styling should match the host course's theme.
+
+The accessibility wins from Reflow (semantic headings, alt text, real
+lists, real tables) survive the conversion because the markdown is
+already semantic. This function exists to render that markdown, rewrite
+image URLs from Reflow S3 to absolute URLs Canvas can resolve, and
+prepend a small banner explaining the page's origin.
+
+Uses ``mistune`` (already a project dependency) for the markdown → HTML
+step.
+"""
+
+from __future__ import annotations
+
+import html as _html
+import re
+from dataclasses import dataclass
+
+import mistune
+
+
+BANNER_HTML = (
+    '<p><em>This page is an accessible, reflowable version of the original PDF, '
+    "generated by Equalify Reflow. If anything looks wrong, the original PDF "
+    'is linked at the bottom of this page.</em></p>'
+)
+
+
+@dataclass
+class RenderedPage:
+    title: str
+    html: str
+
+
+def render(
+    markdown: str,
+    *,
+    title: str,
+    original_pdf_url: str | None = None,
+    image_base_url: str | None = None,
+) -> RenderedPage:
+    """Convert Reflow markdown into a Canvas-ready HTML body.
+
+    ``image_base_url`` is prepended to any relative image src found in the
+    markdown — Reflow returns ``![alt](figures/foo.png)`` style references
+    and Canvas needs absolute URLs.
+    """
+
+    body_md = markdown
+    if image_base_url:
+        body_md = _rewrite_image_paths(body_md, image_base_url.rstrip("/"))
+
+    # mistune.html() returns a string; the renderer escapes HTML in the
+    # markdown source by default, which is what we want for Canvas.
+    html_core = mistune.html(body_md) or ""
+
+    parts: list[str] = [BANNER_HTML, html_core]
+    if original_pdf_url:
+        parts.append(
+            f'<hr><p><a href="{original_pdf_url}">Original PDF</a></p>'
+        )
+
+    return RenderedPage(title=title, html="\n".join(parts))
+
+
+_RELATIVE_IMG_RE = re.compile(r"!\[([^\]]*)\]\((?!https?://|/)([^)]+)\)")
+
+
+def _rewrite_image_paths(markdown: str, base_url: str) -> str:
+    def repl(match: re.Match[str]) -> str:
+        alt = match.group(1)
+        path = match.group(2)
+        return f"![{alt}]({base_url}/{path.lstrip('/')})"
+
+    return _RELATIVE_IMG_RE.sub(repl, markdown)
+
+
+def render_link_stub(
+    *,
+    title: str,
+    accessible_url: str,
+    original_pdf_url: str | None = None,
+) -> str:
+    """A small (<8KB) Canvas Page body that links out to the full accessible HTML.
+
+    Canvas Cloud's edge WAF (CloudFront) rejects Page REST writes whose body
+    exceeds ~8KB, which is almost every real document. So the full converted
+    HTML is uploaded as a course file and the Page itself is just this stub
+    pointing at it — guaranteed tiny, so the PUT clears the WAF at any document
+    size. See the canvas-waf-page-body-limit note.
+    """
+    safe_title = _html.escape(title or "this document")
+    parts = [
+        "<p><em>This is the accessible, reflowable version of the original "
+        "PDF, generated by Equalify Reflow.</em></p>",
+        "<p><strong>"
+        f'<a href="{_html.escape(accessible_url)}">Open the accessible '
+        f"version of &ldquo;{safe_title}&rdquo;</a></strong></p>",
+    ]
+    if original_pdf_url:
+        parts.append(
+            f'<hr><p><a href="{_html.escape(original_pdf_url)}">Original PDF</a></p>'
+        )
+    return "\n".join(parts)
diff --git a/src/canvas/oauth.py b/src/canvas/oauth.py
new file mode 100644
index 0000000..1d1e7c2
--- /dev/null
+++ b/src/canvas/oauth.py
@@ -0,0 +1,347 @@
+"""LTI Advantage client-credentials service tokens for Canvas.
+
+Phase 2 of the multi-tenant migration. Given a ``PlatformInstall`` and a
+list of scopes, this module returns a short-lived bearer token that
+authenticates the tool (not any specific user) against that platform's
+Canvas API.
+
+Flow per RFC 7521 + RFC 7523:
+
+  1. Build a JWT with ``iss == sub == our client_id at this platform``,
+     ``aud == platform.auth_token_url``, plus iat/exp/jti.
+  2. Sign with our LTI private key (the same one that signs outgoing LTI
+     Advantage assertions and is published in ``/lti/jwks``).
+  3. POST to the platform's token endpoint with ``grant_type=
+     client_credentials``, ``client_assertion_type=...:jwt-bearer``,
+     ``client_assertion=<the JWT>``, and ``scope=<space-separated>``.
+  4. Cache the returned bearer in Redis keyed by ``(platform_id,
+     scope_hash)`` with TTL = ``expires_in - 30s`` (30s buffer so we
+     never hand out a token that expires mid-request).
+
+Cache invalidation: the caller (``CanvasClient`` in Phase 3) is
+responsible for calling ``invalidate`` on a 401 and retrying once.
+This module does not retry on its own because the right retry policy
+depends on what the caller was doing (read vs. write).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import secrets
+import time
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+from jwcrypto import jwk, jwt
+
+from ..canvas.tenant import tk
+from ..lti.keys import load_private_key
+from ..lti.platform import PlatformInstall
+
+logger = logging.getLogger(__name__)
+
+# Token cache. Phase 1's platform records live at lti:platform:* so
+# this sibling namespace keeps service-token state visibly distinct.
+TOKEN_KEY = tk("lti:service-token:{platform_id}:{scope_hash}")
+
+# Expiry buffer. Canvas tokens are typically 1 hour; subtracting 30s
+# guarantees we hand back a token that survives the call we are about
+# to make even on a slow request path.
+_EXPIRY_BUFFER_SECONDS = 30
+
+# JWT bearer assertion lifetime. 5 minutes is what the IMS LTI 1.3
+# Security Framework recommends — short enough that a replay window is
+# bounded, long enough to survive clock skew between us and the platform.
+_ASSERTION_TTL_SECONDS = 300
+
+# HTTP timeout for the token exchange. The platform's token endpoint
+# normally responds in well under a second; 10s covers cold caches and
+# pathological cases without stalling a worker forever.
+_HTTP_TIMEOUT_SECONDS = 10.0
+
+
+class ServiceTokenError(Exception):
+    """Raised when we cannot mint or refresh a service token.
+
+    Carries the platform identity and a sanitized reason. Never includes
+    the assertion JWT or the bearer itself — those are sensitive and we
+    do not want them in stack traces or error pages.
+    """
+
+    def __init__(self, platform_id: str, reason: str) -> None:
+        super().__init__(f"service token failed for platform={platform_id}: {reason}")
+        self.platform_id = platform_id
+        self.reason = reason
+
+
+@dataclass
+class CachedToken:
+    """A bearer token plus the absolute unix timestamp it stops being valid."""
+
+    access_token: str
+    granted_scope: str
+    expires_at: float
+
+
+def _scope_hash(scopes: list[str] | tuple[str, ...]) -> str:
+    """Stable hash of a scope set, order-independent."""
+    if not scopes:
+        return "none"
+    blob = "\n".join(sorted(scopes)).encode("utf-8")
+    return hashlib.sha256(blob).hexdigest()[:12]
+
+
+def _our_jwk(private_key) -> jwk.JWK:
+    """Build a jwcrypto JWK from a cryptography RSAPrivateKey.
+
+    We use jwcrypto's PEM importer to match what ``jwks_document`` does
+    so the ``kid`` thumbprint stays consistent between assertion-signing
+    and JWKS publication. Canvas uses the ``kid`` claim header to pick
+    the right key out of our JWKS.
+    """
+    from cryptography.hazmat.primitives import serialization
+
+    pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    key = jwk.JWK.from_pem(pem)
+    return key
+
+
+def _service_token_url(platform: PlatformInstall) -> str:
+    """Canonical Canvas Cloud token endpoint for the client_credentials grant.
+
+    Canvas Cloud issues LTI-Advantage service tokens from a shared SSO host
+    per environment (``sso[.test|.beta].canvaslms.com``), NOT the regional
+    ``*.instructure.com`` host used for launches and API calls -- even vanity
+    domains (e.g. ``csueb.test.instructure.com``) must go through the SSO
+    host. The JWT bearer assertion's ``aud`` must equal this URL and the POST
+    must go to it, or Canvas rejects with ``error='invalid_request'
+    description="the 'aud' is invalid"``. Self-hosted Canvas co-locates the
+    token endpoint with the issuer, so we fall back to the configured one.
+    """
+    from urllib.parse import urlparse
+
+    parsed = urlparse((platform.issuer or "").strip())
+    host = (parsed.netloc or "").lower()
+    scheme = parsed.scheme or "https"
+    sso: str | None = None
+    if host in {"sso.canvaslms.com", "sso.test.canvaslms.com", "sso.beta.canvaslms.com"}:
+        sso = host
+    elif host.endswith(".test.instructure.com") or host == "test.instructure.com":
+        sso = "sso.test.canvaslms.com"
+    elif host.endswith(".beta.instructure.com") or host == "beta.instructure.com":
+        sso = "sso.beta.canvaslms.com"
+    elif host.endswith(".instructure.com") or host == "instructure.com":
+        sso = "sso.canvaslms.com"
+    if sso:
+        return f"{scheme}://{sso}/login/oauth2/token"
+    # Self-hosted / unknown Canvas: trust the endpoint resolved at launch.
+    return platform.auth_token_url
+
+
+def _build_assertion(platform: PlatformInstall) -> str:
+    """Build and sign the JWT bearer client-authentication assertion."""
+
+    private_key = load_private_key()
+    key = _our_jwk(private_key)
+    kid = key.thumbprint()
+
+    now = int(time.time())
+    # Canvas Cloud validates the JWT-bearer assertion's ``aud`` against its
+    # canonical SSO token endpoint (sso[.test|.beta].canvaslms.com), which is
+    # where we also POST. ``_service_token_url`` maps the issuer to that host.
+    audience = _service_token_url(platform)
+    claims: dict[str, Any] = {
+        "iss": platform.client_id,
+        "sub": platform.client_id,
+        "aud": audience,
+        "iat": now,
+        "exp": now + _ASSERTION_TTL_SECONDS,
+        # jti must be unique per assertion; the platform may track
+        # recent jtis to defend against replay. token_urlsafe(32) gives
+        # 256 bits of entropy which is plenty.
+        "jti": secrets.token_urlsafe(32),
+    }
+
+    token = jwt.JWT(
+        header={"alg": "RS256", "typ": "JWT", "kid": kid},
+        claims=claims,
+    )
+    token.make_signed_token(key)
+    return token.serialize()
+
+
+async def _exchange_assertion(
+    platform: PlatformInstall,
+    assertion: str,
+    scopes: list[str],
+) -> CachedToken:
+    """POST the assertion to the platform's token endpoint."""
+
+    data = {
+        "grant_type": "client_credentials",
+        "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
+        "client_assertion": assertion,
+        "scope": " ".join(scopes),
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=_HTTP_TIMEOUT_SECONDS) as client:
+            resp = await client.post(
+                _service_token_url(platform),
+                data=data,
+                headers={"Accept": "application/json"},
+            )
+    except httpx.HTTPError as exc:
+        raise ServiceTokenError(
+            platform.platform_id, f"network error contacting token endpoint: {exc}"
+        ) from exc
+
+    if resp.status_code >= 400:
+        # The platform returned an error. The body usually contains
+        # ``error`` and ``error_description`` per RFC 6749; log those
+        # but do NOT log the assertion (which is in the request body).
+        body_preview = ""
+        try:
+            body = resp.json()
+            body_preview = (
+                f"error={body.get('error')!r} "
+                f"description={body.get('error_description')!r}"
+            )
+        except (json.JSONDecodeError, ValueError):
+            body_preview = resp.text[:200]
+        raise ServiceTokenError(
+            platform.platform_id,
+            f"token endpoint returned HTTP {resp.status_code}: {body_preview}",
+        )
+
+    try:
+        payload = resp.json()
+    except ValueError as exc:
+        raise ServiceTokenError(
+            platform.platform_id, f"token endpoint returned non-JSON: {exc}"
+        ) from exc
+
+    access_token = payload.get("access_token")
+    expires_in = payload.get("expires_in")
+    if not access_token or not isinstance(expires_in, (int, float)):
+        raise ServiceTokenError(
+            platform.platform_id,
+            "token endpoint response missing access_token or expires_in",
+        )
+
+    # Canvas's actual granted scope set may differ from what we
+    # requested (e.g. if some scopes were not approved). Record what we
+    # actually got back so callers can decide whether to retry without
+    # the missing scopes or surface a "tell your admin" message.
+    granted_scope = payload.get("scope", "")
+
+    return CachedToken(
+        access_token=str(access_token),
+        granted_scope=str(granted_scope),
+        expires_at=time.time() + float(expires_in) - _EXPIRY_BUFFER_SECONDS,
+    )
+
+
+def _cache_key(platform_id: str, scopes: list[str]) -> str:
+    return TOKEN_KEY.format(platform_id=platform_id, scope_hash=_scope_hash(scopes))
+
+
+async def _load_cached(redis, platform_id: str, scopes: list[str]) -> CachedToken | None:
+    raw = await redis.get(_cache_key(platform_id, scopes))
+    if not raw:
+        return None
+    try:
+        if isinstance(raw, (bytes, bytearray)):
+            raw = raw.decode("utf-8")
+        data = json.loads(raw)
+        cached = CachedToken(
+            access_token=data["access_token"],
+            granted_scope=data.get("granted_scope", ""),
+            expires_at=float(data["expires_at"]),
+        )
+    except (KeyError, ValueError, TypeError):
+        return None
+    if cached.expires_at <= time.time():
+        return None
+    return cached
+
+
+async def _store_cached(redis, platform_id: str, scopes: list[str], cached: CachedToken) -> None:
+    ttl = int(cached.expires_at - time.time())
+    if ttl <= 0:
+        return
+    await redis.set(
+        _cache_key(platform_id, scopes),
+        json.dumps({
+            "access_token": cached.access_token,
+            "granted_scope": cached.granted_scope,
+            "expires_at": cached.expires_at,
+        }),
+        ex=ttl,
+    )
+
+
+async def get_service_token(
+    redis,
+    platform: PlatformInstall,
+    scopes: list[str],
+    *,
+    force_refresh: bool = False,
+) -> CachedToken:
+    """Return a service token good for the given scopes on this platform.
+
+    Cached tokens are returned without a network round-trip when valid.
+    Pass ``force_refresh=True`` to bypass the cache; this is the path a
+    401-handling caller takes on retry.
+
+    Caller is responsible for catching ``ServiceTokenError`` and
+    rendering it appropriately (logs vs. user-facing error vs. retry).
+    """
+
+    if platform.revoked_at:
+        raise ServiceTokenError(
+            platform.platform_id,
+            f"platform is soft-revoked since {platform.revoked_at}",
+        )
+
+    if not force_refresh:
+        cached = await _load_cached(redis, platform.platform_id, scopes)
+        if cached is not None:
+            return cached
+
+    assertion = _build_assertion(platform)
+    fresh = await _exchange_assertion(platform, assertion, scopes)
+    await _store_cached(redis, platform.platform_id, scopes, fresh)
+
+    logger.info(
+        "service token minted: platform_id=%s scope_hash=%s granted=%r ttl=%ds",
+        platform.platform_id,
+        _scope_hash(scopes),
+        fresh.granted_scope[:80],
+        int(fresh.expires_at - time.time()),
+    )
+    from . import audit
+    audit.emit(
+        "service_token_mint",
+        platform=platform.platform_id,
+        scopes=scopes,
+        ttl_s=int(fresh.expires_at - time.time()),
+        granted=fresh.granted_scope[:200],
+    )
+    return fresh
+
+
+async def invalidate(redis, platform_id: str, scopes: list[str]) -> None:
+    """Drop a cached service token for (platform, scope-set).
+
+    Call this on a 401 from Canvas before retrying. The next call to
+    ``get_service_token`` will mint a fresh one.
+    """
+    await redis.delete(_cache_key(platform_id, scopes))
diff --git a/src/canvas/panorama.py b/src/canvas/panorama.py
new file mode 100644
index 0000000..fcdacf0
--- /dev/null
+++ b/src/canvas/panorama.py
@@ -0,0 +1,277 @@
+"""Conversion-quality scoring and alternative-format resolution.
+
+Every file Reflow processes ends up with:
+
+  * a numeric **conversion quality** score (0..100) -- a heuristic
+    that estimates how well the pipeline extracted accessible
+    structure from the source PDF. This is **not** a WCAG conformance
+    score. A separate publication gate runs WCAG checks and human
+    review before content is approved for student-facing use.
+  * a severity bucket (red / amber / green / dark green) for the gauge,
+  * a list of available alternative formats,
+  * a ranked list of issues for the instructor remediation popover.
+
+This module is the single source of truth for those mappings. The
+weights live here (not at call sites) so a future per-institution config
+can override them without touching every endpoint.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+Severity = Literal["red", "amber", "green", "dark-green"]
+
+
+@dataclass(frozen=True)
+class SignalWeights:
+    """Weights applied to each accessibility signal. Sum should be 100."""
+
+    has_text_layer: int = 30
+    headings_present: int = 20
+    images_have_alt: int = 20
+    tables_are_semantic: int = 15
+    reading_order_linear: int = 10
+    language_set: int = 5
+
+
+@dataclass
+class Score:
+    # ``score`` and ``severity`` are None when ``status="unscanned"`` — i.e.
+    # when Reflow returned no accessibility signals at all. Pretending we
+    # know the score (the legacy default was 15/red regardless of input)
+    # was misleading faculty into believing every document was scored.
+    score: int | None  # 0..100, or None when unscanned
+    severity: Severity | None
+    available_formats: list[str] = field(default_factory=list)
+    status: Literal["scored", "unscanned"] = "scored"
+
+
+@dataclass
+class Issue:
+    code: str
+    title: str
+    severity: Severity
+    page: int | None
+    explanation: str
+    fix_hint: str
+
+
+# MVP default. Phase 7 lets institutions override.
+DEFAULT_WEIGHTS = SignalWeights()
+
+# Formats always available once Reflow has completed. Heavier formats
+# (tagged PDF, ePub, MP3) come online in later phases — the API surface
+# reports them only when the generator is wired up.
+BASE_FORMATS = ["html", "txt", "markdown"]
+
+
+def score_from_reflow_result(
+    result: dict[str, Any],
+    weights: SignalWeights = DEFAULT_WEIGHTS,
+) -> Score:
+    """Compose a score from a Reflow result payload.
+
+    The Reflow API surfaces structured signals at the top level of the
+    result document (``has_text_layer``, ``heading_levels``, etc.). When a
+    signal is missing we treat it as failing — better to over-flag than
+    silently award points.
+
+    BUT: when *no* signals are present at all (empty / fallback payload),
+    we return ``status="unscanned"`` instead of pretending we computed a
+    score. Awarding the table-semantics-by-default points (the only
+    branch that fires on empty input) made every document show as
+    ``15/red``, which faculty correctly read as "scoring is broken".
+    """
+
+    # If Reflow didn't surface any of the signal keys we care about,
+    # don't fabricate a score. Show an "unscanned" affordance instead.
+    _signal_keys = (
+        "has_text_layer", "heading_levels",
+        "images_with_alt", "images_total",
+        "tables_semantic", "tables_total",
+        "reading_order_linear", "language",
+    )
+    if not any(k in result for k in _signal_keys):
+        return Score(
+            score=None,
+            severity=None,
+            available_formats=list(BASE_FORMATS),
+            status="unscanned",
+        )
+
+    signals = {
+        "has_text_layer": bool(result.get("has_text_layer", False)),
+        "headings_present": bool(result.get("heading_levels", [])),
+        "images_have_alt": _ratio(
+            result.get("images_with_alt", 0), result.get("images_total", 0)
+        )
+        >= 0.95,
+        "tables_are_semantic": _ratio(
+            result.get("tables_semantic", 0), result.get("tables_total", 0)
+        )
+        >= 0.95
+        if (result.get("tables_total", 0) or 0) > 0
+        else True,
+        "reading_order_linear": bool(result.get("reading_order_linear", False)),
+        "language_set": bool(result.get("language")),
+    }
+
+    total = 0
+    if signals["has_text_layer"]:
+        total += weights.has_text_layer
+    if signals["headings_present"]:
+        total += weights.headings_present
+    if signals["images_have_alt"]:
+        total += weights.images_have_alt
+    if signals["tables_are_semantic"]:
+        total += weights.tables_are_semantic
+    if signals["reading_order_linear"]:
+        total += weights.reading_order_linear
+    if signals["language_set"]:
+        total += weights.language_set
+
+    severity = severity_of(total)
+    return Score(
+        score=total,
+        severity=severity,
+        available_formats=list(BASE_FORMATS),
+        status="scored",
+    )
+
+
+def severity_of(score: int) -> Severity:
+    if score >= 90:
+        return "dark-green"
+    if score >= 67:
+        return "green"
+    if score >= 33:
+        return "amber"
+    return "red"
+
+
+def source_accessibility_estimate(
+    signals: dict[str, Any] | None,
+) -> tuple[int | None, Severity | None]:
+    """Rough estimate of the ORIGINAL PDF's accessibility — the "before".
+
+    We can't run a PDF/UA conformance checker against the source here, so we
+    infer a coarse number from the pipeline's classification of the source
+    document (stored on ``job.signals`` at conversion time):
+
+      * Scanned / image-only / no real text layer (or OCR had to be run):
+        screen readers get nothing from the original — essentially
+        unreadable. Returns a low "red" estimate (~12).
+      * Born-digital text PDF: the text is selectable, but academic source
+        PDFs are overwhelmingly *untagged* — no heading, list, table, or
+        reading-order structure for assistive tech to navigate. Returns a
+        low-moderate "amber" estimate (~45).
+
+    This is deliberately a *before* number that sets up the before→after
+    story against the WCAG score of the generated accessible version. It is
+    an estimate, not a measurement — hence the conservative buckets.
+
+    Returns ``(None, None)`` when no signals are available (e.g. a job that
+    never reached completion), so the caller can omit the "before" dial
+    rather than fabricate one.
+    """
+    if not signals:
+        return None, None
+    classification = str(signals.get("_pdf_classification") or "").lower()
+    ocr_was_run = bool(signals.get("_ocr_was_run"))
+    has_text_layer = bool(signals.get("has_text_layer"))
+    scanned = (
+        ocr_was_run
+        or not has_text_layer
+        or classification in {"scanned", "no_text", "image_only", "image-only"}
+    )
+    if scanned:
+        return 12, severity_of(12)
+    # Born-digital but (almost certainly) untagged.
+    return 45, severity_of(45)
+
+
+def issues_from_reflow_result(result: dict[str, Any]) -> list[Issue]:
+    """Translate failing signals into instructor-facing issues."""
+
+    issues: list[Issue] = []
+    if not result.get("has_text_layer", False):
+        issues.append(
+            Issue(
+                code="no-text-layer",
+                title="This PDF is a scanned image, not real text",
+                severity="red",
+                page=None,
+                explanation=(
+                    "Screen readers cannot read this document because it does not "
+                    "contain a text layer. Reflow recovered the text via OCR, but "
+                    "the original PDF should be re-exported from the source."
+                ),
+                fix_hint=(
+                    "Re-export the PDF from Word, PowerPoint, or the original source "
+                    "rather than scanning a printed copy. If the original is gone, "
+                    "use OCR software (e.g., Adobe Acrobat) and re-upload."
+                ),
+            )
+        )
+    if not result.get("heading_levels"):
+        issues.append(
+            Issue(
+                code="missing-headings",
+                title="No headings detected",
+                severity="amber",
+                page=None,
+                explanation=(
+                    "Headings let students with screen readers skim the document. "
+                    "Without them the entire document reads as one long paragraph."
+                ),
+                fix_hint=(
+                    "In the source document, mark section titles with Heading 1, 2, 3 "
+                    "styles before exporting to PDF."
+                ),
+            )
+        )
+    missing_alt = (result.get("images_total", 0) or 0) - (
+        result.get("images_with_alt", 0) or 0
+    )
+    if missing_alt > 0:
+        issues.append(
+            Issue(
+                code="missing-alt",
+                title=f"{missing_alt} image(s) without alt text",
+                severity="amber",
+                page=None,
+                explanation=(
+                    "Images without alternative text are invisible to screen readers. "
+                    "Reflow proposed alt text where possible — review and edit it."
+                ),
+                fix_hint=(
+                    "Open the accessible HTML version, edit the alt text for each "
+                    "image, then approve and publish."
+                ),
+            )
+        )
+    if not result.get("language"):
+        issues.append(
+            Issue(
+                code="no-language",
+                title="Document language is not set",
+                severity="green",
+                page=None,
+                explanation=(
+                    "Setting the document language helps screen readers pick the "
+                    "right pronunciation and helps translation tools."
+                ),
+                fix_hint="Set the document language in the source application's properties.",
+            )
+        )
+    return issues
+
+
+def _ratio(numerator: Any, denominator: Any) -> float:
+    n = float(numerator or 0)
+    d = float(denominator or 0)
+    if d <= 0:
+        return 0.0
+    return n / d
diff --git a/src/canvas/privacy.py b/src/canvas/privacy.py
new file mode 100644
index 0000000..5902e04
--- /dev/null
+++ b/src/canvas/privacy.py
@@ -0,0 +1,232 @@
+"""Privacy + retention controls for canvas/Reflow jobs.
+
+Three Title-II / institutional-compliance concerns this module owns:
+
+  1. **Deletion.** A documented way for an admin to remove a job and
+     every derivative artifact -- source PDF, markdown, figures,
+     edited HTML, score cache, audit references. Required for FERPA-
+     style "right to deletion" / DSAR responses and for the routine
+     "remove this document from the system" workflow.
+
+  2. **Retention.** Configurable max-age for each artifact class.
+     A periodic sweep enforces them. Defaults are conservative for
+     a higher-ed deployment (90 days hot, retain audit packets
+     longer per institutional policy).
+
+  3. **Token encryption.** OAuth user tokens are sensitive long-lived
+     bearers. We encrypt them at rest with a key derived from
+     ``CSRF_SECRET_KEY`` (or a dedicated ``TOKEN_ENCRYPTION_KEY`` if
+     set) before storing in Redis. The decrypt happens in the
+     ``user_oauth`` code path on token read; both sides go through
+     ``encrypt_secret`` / ``decrypt_secret`` here.
+
+Anti-claim: ``data at rest`` is a deployment concern. Redis itself
+needs auth + TLS + private networking to be genuinely at-rest-secure.
+This module raises the bar over plaintext storage but is not a
+replacement for properly hardened Redis.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import logging
+import os
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+# -- Retention policy --------------------------------------------------------
+
+@dataclass(frozen=True)
+class RetentionPolicy:
+    """How long each artifact class is kept before the sweeper removes it.
+
+    All values in days. ``None`` means "keep indefinitely" (which is
+    appropriate only for audit packets per institutional record-keeping
+    policy; everything else should have a finite TTL).
+    """
+
+    source_pdf_days: int | None = 30
+    markdown_days: int | None = 90
+    figures_days: int | None = 90
+    edited_html_days: int | None = 365
+    audio_days: int | None = 90
+    epub_days: int | None = 90
+    pii_findings_days: int | None = 90
+    audit_packet_days: int | None = None  # None = institutional retention policy
+    logs_days: int | None = 90
+
+
+DEFAULT_RETENTION = RetentionPolicy()
+
+
+# -- Token encryption --------------------------------------------------------
+
+def _encryption_key() -> bytes:
+    """Derive a stable 32-byte key from configured secrets.
+
+    Preferred: explicit ``TOKEN_ENCRYPTION_KEY`` env. Fallback: derive
+    from ``CSRF_SECRET_KEY`` via SHA-256. Either way the key never hits
+    Redis and rotates with the underlying secret.
+    """
+    explicit = os.environ.get("TOKEN_ENCRYPTION_KEY", "").strip()
+    if explicit:
+        return hashlib.sha256(explicit.encode("utf-8")).digest()
+    csrf = os.environ.get("CSRF_SECRET_KEY", "").strip()
+    if csrf:
+        return hashlib.sha256(("token:" + csrf).encode("utf-8")).digest()
+    # Last resort: derive from a fixed app constant. Stable, but the
+    # bar is "raises the cost of an attacker who already has Redis
+    # read access" -- not a true secret.
+    return hashlib.sha256(b"equalify-reflow:token-encryption:v1").digest()
+
+
+def encrypt_secret(plain: str) -> str:
+    """Encrypt a secret string for at-rest storage.
+
+    Uses an AEAD construction (AES-GCM if ``cryptography`` is
+    available, otherwise an HMAC-SHA256-authenticated XOR stream).
+    The output is base64-url-encoded and self-describing: the first
+    byte identifies the cipher so future rotations can co-exist with
+    legacy ciphertexts during a transition window.
+    """
+    if not plain:
+        return ""
+    key = _encryption_key()
+    data = plain.encode("utf-8")
+    try:
+        from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+        nonce = os.urandom(12)
+        ct = AESGCM(key).encrypt(nonce, data, associated_data=b"reflow:tok:v1")
+        # Format: [0x01][nonce 12B][ciphertext]
+        blob = b"\x01" + nonce + ct
+    except Exception:
+        # Fallback path. NOT semantically equivalent to AEAD -- we
+        # XOR with a keystream derived from HMAC-SHA256 over a
+        # counter, then HMAC-tag the ciphertext. Use only when
+        # cryptography isn't available, which shouldn't happen in
+        # the current container.
+        logger.warning("AESGCM unavailable; falling back to HMAC-XOR cipher")
+        nonce = os.urandom(16)
+        stream = b""
+        ctr = 0
+        while len(stream) < len(data):
+            stream += hmac.new(key, nonce + ctr.to_bytes(4, "big"), hashlib.sha256).digest()
+            ctr += 1
+        ct = bytes(a ^ b for a, b in zip(data, stream))
+        tag = hmac.new(key, nonce + ct, hashlib.sha256).digest()
+        blob = b"\x02" + nonce + tag + ct
+    return base64.urlsafe_b64encode(blob).decode("ascii")
+
+
+def decrypt_secret(encoded: str) -> str:
+    """Inverse of ``encrypt_secret``. Returns the plaintext.
+
+    Idempotent on legacy plaintext: if the input doesn't look like
+    one of our ciphertexts (no ``\\x01`` / ``\\x02`` prefix after
+    base64-decoding), we assume it was stored before encryption
+    landed and return it as-is. This lets us roll out encryption
+    without a breaking migration.
+    """
+    if not encoded:
+        return ""
+    try:
+        blob = base64.urlsafe_b64decode(encoded.encode("ascii"))
+    except Exception:
+        return encoded  # legacy plaintext, can't decode
+    if not blob:
+        return ""
+    key = _encryption_key()
+    version = blob[0]
+    if version == 0x01:
+        try:
+            from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+        except ImportError:
+            raise RuntimeError("Encrypted token requires cryptography lib")
+        nonce, ct = blob[1:13], blob[13:]
+        try:
+            return AESGCM(key).decrypt(nonce, ct, b"reflow:tok:v1").decode("utf-8")
+        except Exception as exc:
+            raise RuntimeError(f"Token decrypt failed: {exc}") from exc
+    if version == 0x02:
+        nonce, tag, ct = blob[1:17], blob[17:49], blob[49:]
+        expected = hmac.new(key, nonce + ct, hashlib.sha256).digest()
+        if not hmac.compare_digest(tag, expected):
+            raise RuntimeError("Token tag mismatch (possible tampering)")
+        stream = b""
+        ctr = 0
+        while len(stream) < len(ct):
+            stream += hmac.new(key, nonce + ctr.to_bytes(4, "big"), hashlib.sha256).digest()
+            ctr += 1
+        return bytes(a ^ b for a, b in zip(ct, stream)).decode("utf-8")
+    # Unrecognised prefix -- assume legacy plaintext that happened to
+    # base64-decode cleanly. Better to return it than 500.
+    return encoded
+
+
+# -- Deletion ----------------------------------------------------------------
+
+async def delete_job_and_derivatives(redis: Any, *, reflow_job_id: str) -> dict[str, Any]:
+    """Hard-delete a job and every related artifact in Redis.
+
+    Returns a summary of what was removed. Does not touch S3 (that's
+    a separate worker job -- the S3 keys are in the deleted records
+    so a sweeper can reconcile). Audit log entries about the deletion
+    are KEPT in ``eq-pdf:canvas:approval:audit`` (immutable trail).
+    """
+    from ..canvas.tenant import tk
+
+    if not reflow_job_id:
+        raise ValueError("reflow_job_id is required")
+
+    deleted = {
+        "canvas_bridge": 0, "reflow_record": 0, "edited_html": 0,
+        "score_cache": 0, "approval_token": 0,
+    }
+    keys_to_remove = [
+        tk(f"canvas:job:{reflow_job_id}"),
+        f"eq-pdf:job:{reflow_job_id}",
+        tk(f"canvas:edited:{reflow_job_id}"),
+        tk(f"canvas:score:{reflow_job_id}"),
+    ]
+    for k in keys_to_remove:
+        try:
+            n = await redis.delete(k)
+        except Exception:
+            logger.exception("delete_job: redis.delete failed on %s", k)
+            continue
+        if n:
+            tag = "canvas_bridge" if "canvas:job" in k else (
+                "reflow_record" if k.endswith(reflow_job_id) and "canvas" not in k else
+                "edited_html" if "canvas:edited" in k else "score_cache"
+            )
+            deleted[tag] = int(n)
+
+    # Best-effort approval-token reverse index cleanup.
+    try:
+        cursor = 0
+        while True:
+            cursor, ks = await redis.scan(cursor=cursor, match="eq-pdf:approval-token:*", count=200)
+            for raw in ks:
+                tk_key = raw.decode() if isinstance(raw, bytes) else raw
+                jid = await redis.get(tk_key)
+                if jid:
+                    val = jid.decode() if isinstance(jid, bytes) else jid
+                    if val == reflow_job_id:
+                        await redis.delete(tk_key)
+                        deleted["approval_token"] += 1
+            if cursor == 0:
+                break
+    except Exception:
+        logger.exception("delete_job: approval-token sweep failed")
+
+    logger.info(
+        "delete_job %s removed: %s",
+        reflow_job_id,
+        ", ".join(f"{k}={v}" for k, v in deleted.items() if v),
+    )
+    return deleted
diff --git a/src/canvas/reflow_client.py b/src/canvas/reflow_client.py
new file mode 100644
index 0000000..290a8b8
--- /dev/null
+++ b/src/canvas/reflow_client.py
@@ -0,0 +1,208 @@
+"""Thin async client for the Reflow REST API.
+
+Paths and response shapes mirror what ``src/api/documents.py`` actually
+exposes today:
+
+  * ``POST /api/v1/documents/submit`` - upload a document, returns ``{job_id}``
+  * ``GET  /api/v1/documents/{job_id}`` - status; when status == ``completed``
+    the same payload includes ``markdown_url`` (S3 presigned) and
+    ``stored_figures``.
+
+We could call into the in-process services directly because the
+integration lives in the same monolith, but going over HTTP keeps the
+seam clean and matches what an external deployment looks like.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import httpx
+
+from ..config import settings
+from ..utils.retry_helpers import retry_with_backoff
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_TIMEOUT = 30.0
+
+# Same retry posture as the Canvas client. The Reflow API is internal in
+# production but still rides over HTTP, so transient 502s during a
+# rolling deploy or a gateway hiccup shouldn't kill the watcher tick.
+_RETRY_MAX_ATTEMPTS = 3
+_RETRY_BASE_DELAY = 1.0
+_RETRY_MAX_DELAY = 30.0
+
+
+# Mime types for the document formats Reflow accepts. The pipeline backend
+# delegates parsing to Docling, which is format-agnostic - this map only
+# exists so multipart uploads carry a sensible Content-Type header.
+_MIME_BY_EXT = {
+    ".pdf": "application/pdf",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".doc": "application/msword",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".epub": "application/epub+zip",
+}
+
+
+def _mime_for_filename(filename: str) -> str:
+    lower = filename.lower()
+    for ext, mime in _MIME_BY_EXT.items():
+        if lower.endswith(ext):
+            return mime
+    return "application/octet-stream"
+
+
+class ReflowClient:
+    def __init__(
+        self,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self.base_url = (base_url or _default_base_url()).rstrip("/")
+        key = api_key or _default_api_key()
+        self._headers = {"X-API-Key": key} if key else {}
+        self._timeout = timeout
+
+    async def submit_document(
+        self,
+        filename: str,
+        file_bytes: bytes,
+        *,
+        review_mode: str = "human",
+        skip_pii_scan: bool = False,
+    ) -> str:
+        """Submit any supported document for processing. Returns the Reflow job id.
+
+        Supported types: PDF, DOCX, PPTX (whatever Docling handles). Mime type
+        is inferred from the filename extension; falls back to octet-stream so
+        Docling's own sniffer can take over.
+
+        ``review_mode="human"`` is the default - the converted output lands in
+        the awaiting_review queue so faculty must approve before students can
+        see the alt formats.
+        """
+
+        url = f"{self.base_url}/api/v1/documents/submit"
+        mime = _mime_for_filename(filename)
+        files = {"file": (filename, file_bytes, mime)}
+        data: dict[str, str] = {"review_mode": review_mode}
+        if skip_pii_scan:
+            data["skip_pii_scan"] = "true"
+            data["skip_reason"] = "Canvas-uploaded course material"
+
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
+            resp = await client.post(url, headers=self._headers, files=files, data=data)
+            resp.raise_for_status()
+            payload = resp.json()
+            return payload["job_id"]
+
+    # Backward-compatible alias. New code should use submit_document.
+    async def submit_pdf(
+        self,
+        filename: str,
+        pdf_bytes: bytes,
+        *,
+        review_mode: str = "human",
+        skip_pii_scan: bool = False,
+    ) -> str:
+        return await self.submit_document(
+            filename, pdf_bytes, review_mode=review_mode, skip_pii_scan=skip_pii_scan,
+        )
+
+    async def get_status(self, job_id: str) -> dict[str, Any]:
+        """Return the full status payload.
+
+        When ``status == "completed"`` the payload also carries the result
+        URLs (``markdown_url``, ``stored_figures``, ``bundle_url``). The
+        bridge worker calls this on every tick for every in-flight job,
+        so retries here directly affect whether faculty see stalled dials
+        after a transient blip.
+        """
+
+        url = f"{self.base_url}/api/v1/documents/{job_id}"
+
+        async def _go() -> dict[str, Any]:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                resp = await client.get(url, headers=self._headers)
+                resp.raise_for_status()
+                return resp.json()
+
+        return await retry_with_backoff(
+            _go,
+            max_attempts=_RETRY_MAX_ATTEMPTS,
+            base_delay=_RETRY_BASE_DELAY,
+            max_delay=_RETRY_MAX_DELAY,
+            operation_name=f"reflow.get_status({job_id})",
+        )
+
+    async def fetch_markdown(self, markdown_url: str) -> str:
+        """Pull markdown content from the presigned S3 URL Reflow returned.
+
+        ``markdown_url`` is an S3 presigned GET - no auth header needed,
+        and we deliberately do not send our X-API-Key (S3 doesn't speak it).
+
+        The URL is rewritten to the internal S3 hostname (see
+        ``rewrite_presigned_url``) so that server-to-server fetches in
+        Docker dev work even when the presigner returned a public host
+        like ``localhost:4566``. In production with real AWS S3, the
+        rewrite is a no-op.
+        """
+
+        fetch_url = rewrite_presigned_url(markdown_url)
+
+        async def _go() -> str:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                resp = await client.get(fetch_url, follow_redirects=True)
+                resp.raise_for_status()
+                return resp.text
+
+        return await retry_with_backoff(
+            _go,
+            max_attempts=_RETRY_MAX_ATTEMPTS,
+            base_delay=_RETRY_BASE_DELAY,
+            max_delay=_RETRY_MAX_DELAY,
+            operation_name="reflow.fetch_markdown",
+        )
+
+
+def rewrite_presigned_url(url: str) -> str:
+    """Swap an S3 presigned URL's public hostname for the internal one.
+
+    In dev, an S3-compatible API generates presigned URLs against its
+    public hostname (e.g. ``localhost:4566``) so browsers can hit them.
+    But server-side code inside the Docker network can't reach
+    ``localhost:4566`` - that's the container's own loopback. The
+    internal hostname is ``floci:4566``. This function rewrites only the
+    host portion of the URL, leaving the path and query string (which
+    carry the SigV4 signature) untouched.
+
+    No-op when either setting is unset or they're equal - which is the
+    expected production posture with real AWS S3.
+    """
+    public = (getattr(settings, "s3_public_url", None) or "").rstrip("/")
+    internal = (getattr(settings, "s3_internal_url", None) or "").rstrip("/")
+    if not public or not internal or public == internal:
+        return url
+    if url.startswith(public + "/") or url == public:
+        return internal + url[len(public):]
+    return url
+
+
+def _default_base_url() -> str:
+    return getattr(settings, "reflow_api_url", "http://api-gateway:8080") or "http://api-gateway:8080"
+
+
+def _default_api_key() -> str:
+    raw = getattr(settings, "api_keys", None)
+    if raw is None:
+        return ""
+    if hasattr(raw, "get_secret_value"):
+        raw = raw.get_secret_value()
+    first = str(raw).split(",", 1)[0].strip()
+    return first
diff --git a/src/canvas/sanitize.py b/src/canvas/sanitize.py
new file mode 100644
index 0000000..a19e50a
--- /dev/null
+++ b/src/canvas/sanitize.py
@@ -0,0 +1,221 @@
+"""HTML sanitization for instructor-edited and AI-generated content.
+
+Every HTML byte that crosses our trust boundary -- whether it came
+from the AI pipeline, an instructor's edits, or a markdown render --
+runs through ``sanitize_html`` before being stored or served. The
+allowlist is academic-content-oriented: headings, lists, tables,
+figures, captions, code blocks, math (MathML), and ARIA landmarks.
+Inline scripting, event handlers, and any non-HTTPS protocol on
+links/images are stripped.
+
+Why we don't use Bleach's defaults: Bleach defaults disallow tables,
+figures, and ARIA landmarks -- exactly the markup we DO want for
+accessible academic content. We explicitly opt them in here, with
+attribute lists per tag.
+
+Why we don't roll our own: the parser is the hard part. Bleach
+delegates to html5lib which correctly handles malformed input,
+SVG/MathML namespacing, and unicode tricks that a naive ``re.sub``
+approach would miss. The shape of the allowlist is the design
+decision; the parsing is the library's job.
+
+Anti-claim: sanitization is necessary but not sufficient for
+accessibility. The publication gate (Phase 7) checks WCAG conformance
+separately. This module only removes *active content* -- scripts,
+event handlers, javascript: URLs, dangerous embed/object/iframe.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# -- Allowlist ----------------------------------------------------------------
+
+# Structural and semantic tags that belong in an accessible academic
+# document. Anything not in this set is stripped.
+ALLOWED_TAGS: list[str] = [
+    # Document structure
+    "html", "head", "body", "title", "meta", "link",
+    "header", "footer", "main", "nav", "section", "article", "aside",
+    # Headings + paragraphs
+    "h1", "h2", "h3", "h4", "h5", "h6", "p", "div", "span", "br", "hr",
+    # Inline emphasis
+    "em", "strong", "i", "b", "u", "s", "mark", "small", "sub", "sup",
+    "abbr", "cite", "dfn", "kbd", "q", "samp", "time", "var",
+    # Lists
+    "ul", "ol", "li", "dl", "dt", "dd",
+    # Tables (semantic markup matters for accessibility)
+    "table", "caption", "colgroup", "col", "thead", "tbody", "tfoot",
+    "tr", "th", "td",
+    # Figures and media
+    "figure", "figcaption", "img", "picture", "source",
+    "audio", "video", "track",  # captions/transcripts attach via <track>
+    # Links and code
+    "a", "code", "pre", "blockquote",
+    # MathML (accessibility-relevant; sanitized via attribute allowlist)
+    "math", "mrow", "mi", "mn", "mo", "msup", "msub", "mfrac",
+    "msqrt", "mroot", "mtext", "mspace", "mtable", "mtr", "mtd",
+    "mover", "munder", "munderover", "mfenced", "mstyle",
+    # ARIA landmark fallbacks for non-HTML5 markup
+    "details", "summary",
+]
+
+
+# Per-tag attribute allowlist. ``"*"`` applies to every allowed tag.
+# Keep these tight -- ``style`` and ``class`` are conservative because
+# arbitrary CSS can still hide focus rings or change colors enough to
+# fail contrast. We allow ``class`` only because the alt-format
+# renderer depends on a small set of class names; bleach's CSS
+# sanitizer below clamps allowed properties.
+ALLOWED_ATTRIBUTES: dict[str, list[str]] = {
+    "*": [
+        "id", "class", "lang", "dir", "title",
+        # ARIA -- safe subset. ARIA roles can be misused but the
+        # primary risk (XSS) doesn't apply, so we err inclusive.
+        "role", "aria-label", "aria-labelledby", "aria-describedby",
+        "aria-hidden", "aria-live", "aria-atomic", "aria-busy",
+        "aria-current", "aria-expanded", "aria-haspopup",
+        "aria-level", "aria-modal", "aria-required", "aria-readonly",
+    ],
+    "a": ["href", "target", "rel", "download"],
+    "img": ["src", "srcset", "sizes", "alt", "width", "height",
+            "loading", "decoding", "longdesc"],
+    "picture": [],
+    "source": ["src", "srcset", "sizes", "type", "media"],
+    "audio": ["src", "controls", "preload"],
+    "video": ["src", "controls", "preload", "poster", "width", "height"],
+    "track": ["src", "kind", "srclang", "label", "default"],
+    "table": ["summary"],
+    "th": ["scope", "headers", "abbr", "colspan", "rowspan"],
+    "td": ["headers", "colspan", "rowspan"],
+    "col": ["span"],
+    "colgroup": ["span"],
+    "ol": ["start", "reversed", "type"],
+    "li": ["value"],
+    "time": ["datetime"],
+    "abbr": ["title"],
+    "q": ["cite"],
+    "blockquote": ["cite"],
+    "details": ["open"],
+    # MathML -- attributes the W3C spec requires for accessibility info
+    "math": ["display", "xmlns", "altimg", "alttext"],
+    "mfrac": ["linethickness"],
+    "mspace": ["width", "height", "depth"],
+    "mstyle": ["mathvariant", "mathsize", "mathcolor"],
+    "mtable": ["columnalign", "rowalign", "displaystyle"],
+}
+
+
+# URL protocols allowed in ``href`` / ``src`` / ``cite`` / ``longdesc``.
+# Notably ABSENT: ``javascript:``, ``vbscript:``, ``file:``, ``ftp:``.
+# ``data:`` is allowed because PDF figure extraction sometimes
+# inlines small thumbnails -- the format whitelist below restricts
+# to image MIME types only.
+ALLOWED_PROTOCOLS: list[str] = ["http", "https", "mailto", "data"]
+
+
+# Permitted CSS properties on inline ``style`` attributes. The set is
+# intentionally tiny: anything that affects visibility or focus is
+# excluded so a malicious ``style`` can't hide essential content from
+# screen readers or break keyboard navigation indicators.
+ALLOWED_CSS_PROPS: list[str] = [
+    "text-align", "font-weight", "font-style", "font-variant",
+    "text-decoration", "color", "background-color",
+    "white-space", "vertical-align",
+]
+
+
+# Tags whose *contents* must be removed entirely, not just the tag.
+# Bleach's default ``strip=True`` removes disallowed tags but leaves
+# their text content as text nodes -- safe (the browser will never
+# execute it once the <script> tag is gone) but ugly: a stripped
+# ``<script>alert(1)</script>`` would leave the literal text
+# ``alert(1)`` in the output. We preprocess these elements out before
+# bleach.clean to avoid the noise.
+import re as _re
+
+_STRIPPED_CONTENT_TAGS = ("script", "style", "iframe", "object", "embed", "noscript")
+_STRIP_RE = _re.compile(
+    r"<(" + "|".join(_STRIPPED_CONTENT_TAGS) + r")\b[^>]*>[\s\S]*?</\1\s*>",
+    _re.IGNORECASE | _re.DOTALL,
+)
+# Also handle self-closing variants like ``<embed src=...>`` with no closing tag
+_STRIP_VOID_RE = _re.compile(
+    r"<(" + "|".join(_STRIPPED_CONTENT_TAGS) + r")\b[^>]*/?>(?!\s*</)",
+    _re.IGNORECASE,
+)
+
+
+def _preprocess(raw: str) -> str:
+    """Drop disallowed tags + their content before bleach sees the input."""
+    out = _STRIP_RE.sub("", raw)
+    out = _STRIP_VOID_RE.sub("", out)
+    return out
+
+
+def sanitize_html(raw: str, *, strip_comments: bool = True) -> str:
+    """Sanitize untrusted HTML against the academic-content allowlist.
+
+    Returns a *string* of HTML safe to store and serve. Anything the
+    allowlist doesn't recognise -- including ``<script>``, event
+    handlers (``onerror`` etc.), ``javascript:`` URLs, and unknown
+    tags -- is removed. For ``<script>``, ``<style>``, ``<iframe>``
+    and similar content-bearing tags, the *contents* are removed too
+    (not just the wrapper), so a hostile ``<script>alert(1)</script>``
+    leaves nothing behind -- not even ``alert(1)`` as text.
+
+    For convenience, an empty/None input returns an empty string.
+    Sanitization is idempotent: passing the output back in is a no-op.
+    """
+    if not raw:
+        return ""
+    try:
+        import bleach
+        from bleach.css_sanitizer import CSSSanitizer
+    except ImportError:
+        # Defensive: if bleach isn't installed (e.g. some dev shells),
+        # don't silently return raw HTML. Refuse instead.
+        logger.error(
+            "sanitize_html: bleach is not installed; refusing to return raw HTML"
+        )
+        raise RuntimeError(
+            "HTML sanitization required but bleach is not installed"
+        )
+
+    pre = _preprocess(raw)
+
+    css_sanitizer = CSSSanitizer(allowed_css_properties=ALLOWED_CSS_PROPS)
+    cleaned = bleach.clean(
+        pre,
+        tags=ALLOWED_TAGS,
+        attributes=ALLOWED_ATTRIBUTES,
+        protocols=ALLOWED_PROTOCOLS,
+        css_sanitizer=css_sanitizer,
+        strip=True,           # remove disallowed tags rather than escape
+        strip_comments=strip_comments,
+    )
+    return cleaned
+
+
+def is_safe_url(url: str | None) -> bool:
+    """Cheap pre-check before constructing links/images server-side.
+
+    Use this when you're building HTML programmatically and want to
+    reject a URL *before* embedding it -- catches obvious bad cases
+    so the sanitizer doesn't have to silently strip them later.
+    """
+    if not url:
+        return False
+    s = url.strip().lower()
+    if s.startswith("javascript:") or s.startswith("vbscript:"):
+        return False
+    if any(s.startswith(p + ":") for p in ALLOWED_PROTOCOLS):
+        return True
+    # Relative paths are fine when used inside our own content; the
+    # downstream sanitizer will reject if they resolve unsafely.
+    if s.startswith(("/", "./", "../", "#")):
+        return True
+    return False
diff --git a/src/canvas/signals.py b/src/canvas/signals.py
new file mode 100644
index 0000000..9e1e02b
--- /dev/null
+++ b/src/canvas/signals.py
@@ -0,0 +1,158 @@
+"""Derive real per-document accessibility signals from pipeline output.
+
+The legacy ``score_from_reflow_result`` expected Reflow to surface a
+structured ``signals`` field in its status payload. In practice the
+upstream Reflow API doesn't populate this — Reflow is a
+PDF->markdown converter, not an accessibility analyzer. That left
+``score_from_reflow_result({})`` returning a deceptive flat 15/red
+on every document because the "no tables == all tables semantic"
+branch awarded the table weight by default.
+
+This module fixes that by *deriving* signals from artifacts we
+already have on hand at conversion time:
+
+  * The pipeline's markdown output (heading structure, image+alt
+    presence, table-vs-image-of-table, math, code).
+  * The PDF classifier verdict (``standard`` vs ``scanned``).
+  * Source language detection from the markdown body.
+
+The result is a dict shaped exactly the way
+``score_from_reflow_result`` expects, so the score function can
+remain unchanged and we get genuine, per-file variance — not a
+constant fallback.
+
+Anti-claim: these signals are a *conversion-quality* heuristic, NOT
+a WCAG conformance proof. They're a useful signal for routing
+documents to human review, not a substitute for it.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+# Heading patterns. ATX style (# Heading) is what docling outputs.
+_HEADING_RE = re.compile(r"^(#{1,6})\s+\S", re.MULTILINE)
+
+# Markdown image syntax: ![alt](src). Empty alt is the "decorative" or
+# "missing alt" case — we count those separately.
+_IMAGE_RE = re.compile(r"!\[([^\]]*)\]\(([^)]+)\)")
+
+# A pipe-style table requires both a header row and a separator row
+# (|---|---|). Pipe rows that aren't followed by a separator are just
+# inline text. This conservative match catches genuine tables.
+_TABLE_BLOCK_RE = re.compile(
+    r"(^\|[^\n]+\|\s*\n\|[\s\-:|]+\|\s*\n(?:\|[^\n]*\|\s*\n?)+)",
+    re.MULTILINE,
+)
+
+# Fenced code blocks.
+_CODE_FENCE_RE = re.compile(r"```[\s\S]*?```", re.MULTILINE)
+
+# Display math (LaTeX-ish). Conservative — matches $$...$$ and \[...\].
+_MATH_DISPLAY_RE = re.compile(r"(\$\$[\s\S]*?\$\$)|(\\\[[\s\S]*?\\\])")
+
+
+def _detect_language(text: str) -> str | None:
+    """Best-effort language code from common cues.
+
+    We deliberately don't pull in a heavy detector — most academic
+    documents are English, and when they're not, this function is
+    intentionally conservative. Returns ``None`` when we can't make
+    a confident call (which is honest; the WCAG rule cares whether
+    a language is *declared*, and that's the publisher's job).
+    """
+    if not text or not text.strip():
+        return None
+    # If the sample is overwhelmingly ASCII letters, call it English.
+    # This is a heuristic — the real fix is asking the user to confirm
+    # the language at publish time, not guessing here.
+    sample = text[:4000]
+    letters = [c for c in sample if c.isalpha()]
+    if not letters:
+        return None
+    ascii_ratio = sum(1 for c in letters if ord(c) < 128) / len(letters)
+    if ascii_ratio > 0.95:
+        return "en"
+    return None  # let the publisher set lang explicitly
+
+
+def derive_signals_from_markdown(
+    markdown: str,
+    *,
+    pdf_classification: str | None = None,
+    ocr_was_run: bool = False,
+) -> dict[str, Any]:
+    """Build a Reflow-style signals dict from converted markdown.
+
+    Parameters
+    ----------
+    markdown : the pipeline's final markdown output (post-cleanup).
+    pdf_classification : verdict from ``PdfClassifier`` if available
+        ("standard", "scanned", etc.).
+    ocr_was_run : True when the pipeline ran OCR on a scanned source.
+        Even if OCR succeeded, the resulting text layer is synthetic
+        and deserves a lower confidence floor than a born-digital PDF.
+
+    Returns
+    -------
+    A dict with the exact keys ``score_from_reflow_result`` looks for:
+    ``has_text_layer``, ``heading_levels``, ``images_total``,
+    ``images_with_alt``, ``tables_total``, ``tables_semantic``,
+    ``reading_order_linear``, ``language``.
+    """
+    md = markdown or ""
+
+    # has_text_layer: True if the source PDF was born-digital. For OCR'd
+    # scans the text layer exists but is synthetic; mark it as present
+    # (selectable text DOES exist now) but note that ocr_was_run is
+    # important downstream for the "low-confidence scan" review flag.
+    has_text_layer = bool(md.strip()) and pdf_classification != "no_text"
+
+    # Headings: collect distinct heading levels actually used.
+    levels = sorted({len(m.group(1)) for m in _HEADING_RE.finditer(md)})
+
+    # Images: count all image references; an image is "with alt" when the
+    # alt text inside ``![ ... ]`` is non-empty and not a placeholder.
+    images = list(_IMAGE_RE.finditer(md))
+    images_total = len(images)
+    images_with_alt = sum(
+        1 for m in images
+        if (m.group(1) or "").strip()
+        and (m.group(1) or "").strip().lower() not in {"image", "figure", "fig", "img"}
+    )
+
+    # Tables: each match is one full table block (header + separator +
+    # body rows). Pipe-style tables ARE semantic markup once they
+    # render, so we count them as semantic. Image-of-table cases
+    # appear as just an image, so they're counted under images
+    # without alt and don't show up in tables_total -- exactly the
+    # right signal.
+    tables_total = len(_TABLE_BLOCK_RE.findall(md))
+    tables_semantic = tables_total  # every pipe-table is semantic by def
+
+    # Reading order: with docling output, the markdown ordering reflects
+    # the visual top-to-bottom reading order docling extracted. We treat
+    # this as ``True`` for the born-digital path. For scans (OCR'd) the
+    # ordering can be wonky on multi-column pages, so flag it as False
+    # there to push the document into human review.
+    reading_order_linear = pdf_classification != "scanned" and not ocr_was_run
+
+    language = _detect_language(md)
+
+    return {
+        "has_text_layer": has_text_layer,
+        "heading_levels": levels,
+        "images_total": images_total,
+        "images_with_alt": images_with_alt,
+        "tables_total": tables_total,
+        "tables_semantic": tables_semantic,
+        "reading_order_linear": reading_order_linear,
+        "language": language,
+        # Provenance — handy for diagnostics, ignored by score function.
+        "_source": "derived",
+        "_pdf_classification": pdf_classification,
+        "_ocr_was_run": ocr_was_run,
+        "_code_blocks": len(_CODE_FENCE_RE.findall(md)),
+        "_math_display": len(_MATH_DISPLAY_RE.findall(md)),
+    }
diff --git a/src/canvas/spend_cap.py b/src/canvas/spend_cap.py
new file mode 100644
index 0000000..57fcaa3
--- /dev/null
+++ b/src/canvas/spend_cap.py
@@ -0,0 +1,159 @@
+"""Per-course Claude-API spend cap.
+
+Finance reasonably asks "what stops one runaway upload from costing $20k?".
+The answer is a hard monthly budget per Canvas course. Every time the
+watcher submits a new document to Reflow, we add an *estimated* cost to
+the course's monthly counter; if the counter is already over the cap,
+we skip the submission and log a warning so the operator can act.
+
+Why estimate-at-submit rather than measure-at-completion: the pipeline's
+actual Claude bill isn't known until Reflow returns, and by then the
+money is already spent. A pre-flight estimate is the only way to prevent
+runaway cost; the estimate doesn't have to be perfect, just close enough
+to flag obvious abuse (200-page textbook on Opus, etc.).
+
+The counter is per-course-per-calendar-month and resets implicitly because
+the Redis key encodes the month. Operators reviewing a cost incident can
+read the historical keys to see which course consumed the budget when.
+
+Configuration
+-------------
+* ``canvas_monthly_spend_cap_usd_default`` (int dollars) - the cap that
+  applies to every course unless overridden. 0 disables the cap entirely.
+* ``canvas_monthly_spend_cap_overrides`` (JSON string) - per-course
+  overrides, e.g. ``{"50594": 250, "12345": 50}``. Useful for pilot
+  programs where one course is allowed a bigger budget.
+* ``canvas_estimated_cost_per_doc_cents`` (int) - pre-flight estimate.
+  Defaults to 10 (~10 cents per typical document on Haiku-routed
+  smart-routing). Bump this if your fleet runs Sonnet/Opus by default.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from typing import Any
+
+from redis.asyncio import Redis
+
+from ..config import settings
+from .tenant import tk
+
+logger = logging.getLogger(__name__)
+
+# Redis key: cents spent in {course_id} during {YYYY-MM}.
+# Cents (not dollars) so we don't lose precision to int rounding.
+_SPEND_KEY = tk("canvas:spend:{course_id}:{month}")
+_SPEND_TTL_SECONDS = 100 * 86400  # ~3 months, lets reports walk a quarter
+
+
+def _current_month() -> str:
+    """Return the YYYY-MM string for the wall-clock month in UTC."""
+    return time.strftime("%Y-%m", time.gmtime())
+
+
+def _cap_for_course(course_id: str) -> int:
+    """Return the configured monthly cap in cents for the given course.
+
+    Override precedence: per-course JSON map overrides the default.
+    Returns 0 when no cap applies (which the caller treats as
+    "unlimited" - submissions never get blocked).
+    """
+    overrides_raw = getattr(settings, "canvas_monthly_spend_cap_overrides", "") or ""
+    if overrides_raw:
+        try:
+            overrides = json.loads(overrides_raw)
+            if course_id in overrides:
+                return int(overrides[course_id]) * 100
+        except (json.JSONDecodeError, ValueError, TypeError):
+            logger.warning("canvas_monthly_spend_cap_overrides is not valid JSON; ignoring")
+    default_usd = int(getattr(settings, "canvas_monthly_spend_cap_usd_default", 0) or 0)
+    return default_usd * 100
+
+
+def _estimate_cents() -> int:
+    """Estimated marginal cost per submission, in cents.
+
+    Conservative default of 10 cents matches what smart-routing-to-Haiku
+    actually costs on typical 5-30 page documents. Operators with
+    different defaults bump this via env.
+    """
+    return int(getattr(settings, "canvas_estimated_cost_per_doc_cents", 10) or 10)
+
+
+async def get_monthly_spend_cents(redis: Redis, course_id: str) -> int:
+    """Return cents charged to the course this calendar month."""
+    key = _SPEND_KEY.format(course_id=course_id, month=_current_month())
+    raw: Any = await redis.get(key)
+    if raw is None:
+        return 0
+    try:
+        return int(raw.decode() if isinstance(raw, bytes) else raw)
+    except (ValueError, AttributeError):
+        return 0
+
+
+async def reserve_submission(redis: Redis, course_id: str) -> tuple[bool, dict[str, int]]:
+    """Atomically check the cap and (if allowed) charge the estimated cost.
+
+    Returns ``(allowed, info)``. ``info`` is always populated with the
+    pre-decision spend, the cap, and the estimate, so the caller can log
+    a useful message either way. When the cap is 0 (unlimited) we always
+    allow and still record the spend - the counter stays useful for
+    historical reports even when no cap is set.
+
+    Uses INCRBY (atomic) so concurrent watcher ticks can't both squeeze
+    a final job in past the cap. If the post-increment value exceeds the
+    cap, we DECRBY the estimate back and refuse the submission. Net cost:
+    two Redis round-trips on the hot path, one on the unhappy path.
+    """
+    cap = _cap_for_course(course_id)
+    estimate = _estimate_cents()
+    key = _SPEND_KEY.format(course_id=course_id, month=_current_month())
+
+    new_total: Any = await redis.incrby(key, estimate)
+    new_total = int(new_total)
+    # Keep the key from living forever - we re-set TTL on each write so
+    # active courses retain history while abandoned keys eventually expire.
+    await redis.expire(key, _SPEND_TTL_SECONDS)
+
+    info = {
+        "spend_after_cents": new_total,
+        "cap_cents": cap,
+        "estimate_cents": estimate,
+    }
+
+    if cap > 0 and new_total > cap:
+        # Roll back our charge - we won't be submitting the doc.
+        await redis.decrby(key, estimate)
+        info["spend_after_cents"] = new_total - estimate
+        logger.warning(
+            "Spend cap reached for course %s: %d > %d cents this month",
+            course_id, new_total, cap,
+        )
+        return False, info
+
+    return True, info
+
+
+async def reconcile_actual_cost(
+    redis: Redis,
+    course_id: str,
+    actual_cents: int,
+) -> None:
+    """Update the counter once Reflow reports the actual job cost.
+
+    The watcher records an estimate at submission time (so we can gate);
+    when the bridge worker sees a completed job with the real cost
+    attached, it calls this to true up. Difference (actual - estimate)
+    is added to the counter; can be negative for cheaper-than-expected
+    jobs. This keeps long-term spend tracking honest.
+    """
+    estimate = _estimate_cents()
+    delta = int(actual_cents) - estimate
+    if delta == 0:
+        return
+    key = _SPEND_KEY.format(course_id=course_id, month=_current_month())
+    await redis.incrby(key, delta)
+    await redis.expire(key, _SPEND_TTL_SECONDS)
diff --git a/src/canvas/state.py b/src/canvas/state.py
new file mode 100644
index 0000000..b005c00
--- /dev/null
+++ b/src/canvas/state.py
@@ -0,0 +1,439 @@
+"""Redis-backed mapping between Canvas files and Reflow jobs.
+
+Keys:
+  eq-pdf:canvas:job:{reflow_job_id}            Hash    job ↔ canvas mapping
+  eq-pdf:canvas:course:{course_id}:pending     Set     awaiting-review job ids
+  eq-pdf:canvas:course:{course_id}:processed   Set     canvas file ids already
+                                                       submitted (idempotency)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import asdict, dataclass
+from typing import Any, Literal
+
+from redis.asyncio import Redis
+
+from .tenant import tk
+
+logger = logging.getLogger(__name__)
+
+JOB_KEY = tk("canvas:job:{job_id}")
+PENDING_KEY = tk("canvas:course:{course_id}:pending")
+PROCESSED_KEY = tk("canvas:course:{course_id}:processed")
+# Stable map of a Canvas file -> the wiki page slug the bridge created for it.
+# Survives across re-conversions (each re-conversion is a new reflow_job_id),
+# so the bridge can UPDATE the same page instead of creating a duplicate.
+FILE_PAGE_KEY = tk("canvas:course:{course_id}:file-page:{file_id}")
+
+JobStatus = Literal[
+    "processing",
+    # Reflow paused the conversion for a PII/privacy decision. Distinct from
+    # "processing" so the overlay can show an Approve/Deny prompt and the
+    # timeout watchdog doesn't mislabel it "stuck in processing".
+    "awaiting_approval",
+    "awaiting_review",
+    "published",
+    "rejected",
+    "failed",
+    # Conversion succeeded but the Canvas Page write was rejected (almost
+    # always the course-owner OAuth token missing the Pages write scope).
+    # Distinct from "failed" (which means the conversion itself failed) so the
+    # overlay can tell faculty the real reason, and from "awaiting_review"
+    # (which falsely implied a page existed). The bridge keeps polling these
+    # and rebuilds the page automatically once the scope is granted.
+    "page_failed",
+]
+
+
+@dataclass
+class CanvasJob:
+    reflow_job_id: str
+    canvas_file_id: str
+    canvas_file_name: str
+    canvas_course_id: str
+    canvas_user_id: str
+    status: JobStatus
+    created_at: float
+    canvas_page_id: str | None = None
+    canvas_page_url: str | None = None
+    error: str | None = None
+    # LTI platform that owns this job. Set by the multi-tenant watcher
+    # (Phase 5+); legacy single-tenant submissions leave it None and the
+    # bridge worker falls back to the env-token CanvasClient for them.
+    platform_id: str | None = None
+    # Per-document conversion-quality signals derived from the pipeline
+    # output (heading structure, image+alt counts, table semantics, etc).
+    # ``None`` for jobs that haven't reached completion yet. Populated
+    # by the bridge worker when Reflow returns the converted markdown.
+    # NOTE: these are conversion-quality heuristics, not WCAG conformance
+    # proofs. The publication gate (Phase 7) runs separate WCAG checks.
+    signals: dict | None = None
+    # Map of markdown figure reference (e.g. "figures/figure-1.png") to the
+    # Canvas course-file URL the bridge uploaded it to. Populated by the
+    # bridge worker after it uploads figures into the course. Used to embed
+    # Canvas-hosted images in both the Canvas Page and the overlay's
+    # accessible-HTML views, so pages stay self-contained (no dependency on
+    # the tunnel or the Reflow backend staying up).
+    figure_canvas_urls: dict | None = None
+
+
+async def already_processed(
+    redis: Redis, course_id: str, canvas_file_id: str
+) -> bool:
+    return bool(
+        await redis.sismember(
+            PROCESSED_KEY.format(course_id=course_id), canvas_file_id
+        )
+    )
+
+
+async def mark_processed(redis: Redis, course_id: str, canvas_file_id: str) -> None:
+    await redis.sadd(PROCESSED_KEY.format(course_id=course_id), canvas_file_id)
+
+
+async def clear_processed(redis: Redis, course_id: str, canvas_file_id: str) -> None:
+    """Drop a file's 'already processed' marker so the watcher re-converts it
+    on its next tick. Used by the overlay's manual 'Create accessible page'
+    action. Idempotent — a no-op if the marker isn't set."""
+    await redis.srem(PROCESSED_KEY.format(course_id=course_id), canvas_file_id)
+
+
+async def put_job(redis: Redis, job: CanvasJob) -> None:
+    await redis.set(
+        JOB_KEY.format(job_id=job.reflow_job_id),
+        json.dumps(asdict(job)),
+    )
+    # Drop the panorama score cache (same key the overlay's /score endpoint
+    # uses) so a status change shows up promptly. Its TTL is 24h, so without
+    # this the overlay can keep showing a stale state — e.g. a PII gate for an
+    # already-completed job — long after the bridge moved the job on. put_job
+    # is only called on actual changes, so this clears exactly when we want a
+    # recompute. Best-effort: never let a cache delete break a status write.
+    try:
+        await redis.delete(tk("canvas:score:{job_id}").format(job_id=job.reflow_job_id))
+    except Exception:  # noqa: BLE001
+        pass
+    if job.status == "awaiting_review":
+        await redis.sadd(
+            PENDING_KEY.format(course_id=job.canvas_course_id), job.reflow_job_id
+        )
+    else:
+        await redis.srem(
+            PENDING_KEY.format(course_id=job.canvas_course_id), job.reflow_job_id
+        )
+
+
+async def get_job(redis: Redis, reflow_job_id: str) -> CanvasJob | None:
+    raw: Any = await redis.get(JOB_KEY.format(job_id=reflow_job_id))
+    if raw is None:
+        return None
+    return CanvasJob(**json.loads(raw))
+
+
+async def get_file_page(redis: Redis, course_id: str, file_id: str) -> str | None:
+    """Return the wiki page slug previously created for this Canvas file."""
+    raw: Any = await redis.get(
+        FILE_PAGE_KEY.format(course_id=course_id, file_id=file_id)
+    )
+    if raw is None:
+        return None
+    return raw.decode("utf-8") if isinstance(raw, (bytes, bytearray)) else str(raw)
+
+
+async def put_file_page(
+    redis: Redis, course_id: str, file_id: str, page_ref: str
+) -> None:
+    """Remember the wiki page slug for this Canvas file so re-conversions
+    update the same page instead of creating duplicates."""
+    if not page_ref:
+        return
+    await redis.set(
+        FILE_PAGE_KEY.format(course_id=course_id, file_id=file_id), page_ref
+    )
+
+
+async def list_pending(redis: Redis, course_id: str) -> list[CanvasJob]:
+    job_ids: set[Any] = await redis.smembers(PENDING_KEY.format(course_id=course_id))
+    jobs: list[CanvasJob] = []
+    for jid in job_ids:
+        decoded = jid.decode() if isinstance(jid, bytes) else str(jid)
+        job = await get_job(redis, decoded)
+        if job is not None:
+            jobs.append(job)
+    jobs.sort(key=lambda j: j.created_at)
+    return jobs
+
+
+EDITED_HTML_KEY = tk("canvas:edited:{job_id}")
+
+
+async def get_edited_html(redis: Redis, job_id: str) -> str | None:
+    """Return the faculty-edited HTML for a job if one exists."""
+    raw: Any = await redis.get(EDITED_HTML_KEY.format(job_id=job_id))
+    if raw is None:
+        return None
+    if isinstance(raw, bytes):
+        return raw.decode("utf-8")
+    return str(raw)
+
+
+async def put_edited_html(redis: Redis, job_id: str, html: str) -> None:
+    """Persist a faculty-edited HTML body. Source-of-truth for downstream formats."""
+    await redis.set(EDITED_HTML_KEY.format(job_id=job_id), html)
+
+
+async def clear_edited_html(redis: Redis, job_id: str) -> None:
+    """Revert to the auto-generated HTML by deleting any edit."""
+    await redis.delete(EDITED_HTML_KEY.format(job_id=job_id))
+
+
+# ---------------------------------------------------------------------------
+# Faculty consent / disclaimer acknowledgment
+# ---------------------------------------------------------------------------
+# Bump this when the disclaimer language changes — users must re-acknowledge
+# any version they have not already agreed to.
+CURRENT_CONSENT_VERSION = "1.0"
+
+CONSENT_KEY = tk("canvas:consent:{user_id}")
+CONSENT_AUDIT_KEY = tk("canvas:consent:audit")  # list, append-only
+
+
+@dataclass
+class ConsentRecord:
+    user_id: str
+    user_name: str | None
+    user_email: str | None
+    course_id: str | None
+    version: str
+    agreed_at: float  # unix seconds
+    user_agent: str | None = None
+    ip: str | None = None
+
+
+async def get_consent(redis: Redis, user_id: str) -> ConsentRecord | None:
+    """Return the latest consent record for a user, or None if never given."""
+    raw: Any = await redis.get(CONSENT_KEY.format(user_id=user_id))
+    if raw is None:
+        return None
+    try:
+        data = json.loads(raw)
+        return ConsentRecord(**data)
+    except (json.JSONDecodeError, TypeError) as exc:
+        logger.warning("Corrupt consent record for %s: %s", user_id, exc)
+        return None
+
+
+async def put_consent(redis: Redis, record: ConsentRecord) -> None:
+    """Persist consent + append to the immutable audit log."""
+    payload = json.dumps(asdict(record))
+    await redis.set(CONSENT_KEY.format(user_id=record.user_id), payload)
+    # The audit log is append-only — never trimmed, never updated.
+    # If an admin needs to revoke, write a new record; the audit log keeps the
+    # full history (who/when/what-version/from-what-IP).
+    await redis.rpush(CONSENT_AUDIT_KEY, payload)
+
+
+# ---------------------------------------------------------------------------
+# Approval audit log — every approve/reject/request-edit is recorded
+# ---------------------------------------------------------------------------
+APPROVAL_AUDIT_KEY = tk("canvas:approval:audit")
+
+
+async def append_approval_event(
+    redis: Redis,
+    *,
+    job_id: str,
+    action: str,                  # "approve" | "reject" | "request_edits"
+    actor_user_id: str,
+    actor_name: str | None,
+    comment: str | None = None,
+    actor_ip: str | None = None,
+    course_id: str | None = None,
+) -> None:
+    """Append an immutable approval event to the audit log.
+
+    ``actor_ip`` and ``course_id`` are optional because some test paths
+    and historical callers don't carry them, but ISO compliance asks for
+    both on every event so production callers should always pass them.
+    """
+    import time
+    payload = json.dumps({
+        "job_id": job_id,
+        "action": action,
+        "actor_user_id": actor_user_id,
+        "actor_name": actor_name,
+        "actor_ip": actor_ip,
+        "course_id": course_id,
+        "comment": comment,
+        "at": time.time(),
+    })
+    await redis.rpush(APPROVAL_AUDIT_KEY, payload)
+
+
+async def list_approval_events(
+    redis: Redis,
+    *,
+    since: float | None = None,
+    until: float | None = None,
+    course_id: str | None = None,
+) -> list[dict[str, Any]]:
+    """Return every approval event matching the filters, oldest first.
+
+    Designed for the audit-log CSV export. Filters are inclusive:
+    ``since <= at <= until``. ``course_id`` matches the event's stored
+    course (jobs created before the field was added will have None and
+    are skipped when this filter is set).
+    """
+    raw = await redis.lrange(APPROVAL_AUDIT_KEY, 0, -1)
+    out: list[dict[str, Any]] = []
+    for item in raw:
+        try:
+            decoded = item.decode() if isinstance(item, bytes) else str(item)
+            data = json.loads(decoded)
+        except (json.JSONDecodeError, AttributeError):
+            continue
+        at = data.get("at")
+        if since is not None and (at is None or at < since):
+            continue
+        if until is not None and (at is None or at > until):
+            continue
+        if course_id is not None and str(data.get("course_id") or "") != str(course_id):
+            continue
+        out.append(data)
+    return out
+
+
+async def get_approval_history(redis: Redis, job_id: str) -> list[dict[str, Any]]:
+    """Return all approval events for a specific job, oldest first."""
+    raw = await redis.lrange(APPROVAL_AUDIT_KEY, 0, -1)
+    out: list[dict[str, Any]] = []
+    for item in raw:
+        try:
+            decoded = item.decode() if isinstance(item, bytes) else str(item)
+            data = json.loads(decoded)
+            if data.get("job_id") == job_id:
+                out.append(data)
+        except (json.JSONDecodeError, AttributeError):
+            continue
+    return out
+
+
+async def revoke_consent(redis: Redis, user_id: str) -> None:
+    """Admin operation: delete the active consent record. The audit log entry
+    showing the original consent remains; the user will be re-prompted next
+    launch."""
+    await redis.delete(CONSENT_KEY.format(user_id=user_id))
+    revoke_marker = json.dumps({
+        "event": "revoke",
+        "user_id": user_id,
+        "at": __import__("time").time(),
+    })
+    await redis.rpush(CONSENT_AUDIT_KEY, revoke_marker)
+
+
+def needs_consent(record: ConsentRecord | None) -> bool:
+    """True if the user must be shown the disclaimer before proceeding."""
+    if record is None:
+        return True
+    return record.version != CURRENT_CONSENT_VERSION
+
+
+
+# ---------------------------------------------------------------------------
+# Data-retention sweeper — bounded, predictable purge of old records
+# ---------------------------------------------------------------------------
+# ISO compliance asks us to retain audit events for a defined window and to
+# delete operational data we don't need anymore. The bridge worker calls
+# ``purge_old_canvas_records`` on a slow timer; both windows are independent
+# so an operator can keep audit history while still rolling jobs off.
+#
+# Why purge by AGE rather than COUNT: storage cost in Redis is proportional
+# to lifetime, and a steady cap on count would conflict with the audit
+# log's append-only contract (we never want to evict an event because a
+# newer one arrived).
+async def purge_old_canvas_records(
+    redis: Redis,
+    *,
+    job_retention_seconds: int,
+    audit_retention_seconds: int,
+) -> dict[str, int]:
+    """Delete Canvas state older than the configured retention windows.
+
+    ``job_retention_seconds <= 0`` disables job purging; the same goes for
+    ``audit_retention_seconds`` and the audit log. Returns a dict of
+    {bucket: count_removed} so the caller can log how much got swept.
+
+    Jobs deleted here are the *records* in Redis - the underlying S3
+    artifacts (markdown, figures) are owned by Reflow and have their own
+    lifecycle. The faculty member can always re-upload to regenerate.
+    """
+    import time
+
+    now = time.time()
+    out = {"jobs_removed": 0, "audit_events_removed": 0}
+
+    # ---- Jobs --------------------------------------------------------------
+    if job_retention_seconds > 0:
+        cutoff = now - job_retention_seconds
+        cursor = 0
+        while True:
+            cursor, keys = await redis.scan(
+                cursor=cursor, match=tk("canvas:job:*"), count=200
+            )
+            for raw_key in keys:
+                key = raw_key.decode() if isinstance(raw_key, bytes) else raw_key
+                job_id = key.rsplit(":", 1)[-1]
+                job = await get_job(redis, job_id)
+                if job is None:
+                    continue
+                if (job.created_at or 0) > cutoff:
+                    continue
+                # Also remove from per-course pending set (no-op if absent).
+                if job.canvas_course_id:
+                    await redis.srem(
+                        PENDING_KEY.format(course_id=job.canvas_course_id), job_id
+                    )
+                await redis.delete(key)
+                # Edited HTML lives at its own key; drop it too.
+                await clear_edited_html(redis, job_id)
+                out["jobs_removed"] += 1
+            if cursor == 0:
+                break
+
+    # ---- Audit events ------------------------------------------------------
+    # The audit log is a Redis list, so we can't SCAN it. Read once, filter
+    # out the keepers, and rewrite the list atomically via a transaction so
+    # we don't lose events that arrive mid-purge.
+    if audit_retention_seconds > 0:
+        cutoff = now - audit_retention_seconds
+        raw_events = await redis.lrange(APPROVAL_AUDIT_KEY, 0, -1)
+        keepers: list[str] = []
+        removed = 0
+        for item in raw_events:
+            decoded = item.decode() if isinstance(item, bytes) else str(item)
+            try:
+                at = json.loads(decoded).get("at")
+            except (json.JSONDecodeError, TypeError):
+                # Don't drop unparseable rows - preserves the audit guarantee
+                # even when an old version emitted weird JSON.
+                keepers.append(decoded)
+                continue
+            if isinstance(at, (int, float)) and at < cutoff:
+                removed += 1
+                continue
+            keepers.append(decoded)
+
+        if removed > 0:
+            # Replace the list in one round-trip. Pipeline guarantees both
+            # commands run on the same connection without interleaving.
+            async with redis.pipeline(transaction=True) as pipe:
+                pipe.delete(APPROVAL_AUDIT_KEY)
+                if keepers:
+                    pipe.rpush(APPROVAL_AUDIT_KEY, *keepers)
+                await pipe.execute()
+            out["audit_events_removed"] = removed
+
+    return out
diff --git a/src/canvas/tenant.py b/src/canvas/tenant.py
new file mode 100644
index 0000000..5635c57
--- /dev/null
+++ b/src/canvas/tenant.py
@@ -0,0 +1,116 @@
+"""Tenant + per-platform namespacing for Redis keys.
+
+Two layers of isolation live here:
+
+  * **Deployment tenant** (legacy): one Reflow install can carve up its
+    Redis under ``CANVAS_TENANT``. When unset (or ``default``), the
+    legacy ``eq-pdf:`` prefix is used. When set, every key lives under
+    ``eq-pdf:t:<tenant>:``. This is a process-startup decision.
+
+  * **LTI platform** (Phase 7): one deployment can host data for many
+    Canvas instances. Calls that pass ``platform=`` get a key under
+    ``eq-pdf:p:<platform_id>:`` (inside whatever deployment tenant the
+    process is configured for). Calls that don't pass it land at the
+    deployment-level namespace, same as before.
+
+Together, the full key shape is::
+
+    eq-pdf[:t:<tenant>][:p:<platform_id>]:<suffix>
+
+with both middle segments optional. The legacy ``tk(suffix)`` call
+behaves exactly as it always did; the new ``tk(suffix, platform=...)``
+adds the per-platform sandbox without disturbing anything else.
+
+Why this lives in ``canvas/`` and not ``lti/``: the helper is used by
+every storage callsite, most of which predate the LTI work. Keeping it
+co-located with the rest of the Canvas-state-shaped code means the
+import graph stays shallow (storage modules don't have to import
+``lti.platform`` just to compute a key).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..config import settings
+
+# Tenant ids are user-facing in the sense that they appear in log lines
+# and Redis key names. Keep them URL-safe and short so operators can
+# eyeball Redis output during debugging without surprise.
+_TENANT_RE = re.compile(r"^[a-z0-9_-]{1,40}$")
+
+
+def _resolve_prefix() -> str:
+    raw = (getattr(settings, "canvas_tenant", "") or "").strip().lower()
+    if not raw or raw == "default":
+        return "eq-pdf"
+    if not _TENANT_RE.match(raw):
+        raise ValueError(
+            f"Invalid canvas_tenant {raw!r}: must match [a-z0-9_-]{{1,40}}"
+        )
+    return f"eq-pdf:t:{raw}"
+
+
+# Cache once at import time. Tenant changes require a process restart -
+# this is consistent with how operators treat the value.
+_PREFIX = _resolve_prefix()
+
+
+def _platform_id_of(platform: Any) -> str:
+    """Coerce a platform argument into a short id string.
+
+    Accepts either a ``PlatformInstall`` (with ``.platform_id``) or a
+    bare string. Other shapes raise to surface a mistake at the
+    callsite rather than silently producing a malformed key.
+    """
+    if platform is None:
+        return ""
+    pid = getattr(platform, "platform_id", None)
+    if pid is not None:
+        return str(pid)
+    if isinstance(platform, str) and platform:
+        return platform
+    raise TypeError(
+        f"tk(platform=...) expected PlatformInstall or str, got {type(platform).__name__}"
+    )
+
+
+def tk(suffix: str, *, platform: Any | None = None) -> str:
+    """Return a Redis key template with the correct namespace prefixes.
+
+    ``suffix`` is the post-prefix template, e.g. ``"canvas:job:{job_id}"``.
+    The returned string is ready to ``.format(**kwargs)`` on.
+
+    When ``platform`` is omitted (default), the key lives at the
+    deployment-level namespace — identical to the legacy behaviour, so
+    existing callsites keep their existing keys.
+
+    When ``platform`` is supplied (a ``PlatformInstall`` or its
+    ``platform_id`` string), the key is sandboxed under that platform's
+    segment. Two Canvas instances managed by the same deployment cannot
+    read each other's per-platform data.
+
+    Phase 7 of the multi-tenant migration adds this argument but does
+    NOT yet retrofit every callsite; that lands incrementally as each
+    storage module is audited. A callsite that doesn't pass ``platform=``
+    today continues to read and write at the deployment-level namespace,
+    which is correct for shared data (deploy metadata, dead-letter
+    queues, etc.) and a known-acceptable compromise for per-tenant data
+    until the audit pass.
+    """
+    pid = _platform_id_of(platform)
+    if pid:
+        return f"{_PREFIX}:p:{pid}:{suffix}"
+    return f"{_PREFIX}:{suffix}"
+
+
+def current_tenant() -> str:
+    """Return the active tenant id, for logging or audit-record fields."""
+    raw = (getattr(settings, "canvas_tenant", "") or "").strip().lower()
+    return raw or "default"
+
+
+def tenant_prefix() -> str:
+    """Return the raw prefix (no trailing colon)."""
+    return _PREFIX
diff --git a/src/canvas/user_oauth.py b/src/canvas/user_oauth.py
new file mode 100644
index 0000000..f38e963
--- /dev/null
+++ b/src/canvas/user_oauth.py
@@ -0,0 +1,458 @@
+"""Per-user Canvas OAuth2 access tokens (Phase 8).
+
+Canvas Cloud's LTI Advantage client-credentials tokens are not honored by
+the standard ``/api/v1/...`` REST API -- they only work for LTI Advantage
+services (NRPS, AGS, Deep Linking). For general Canvas API access (file
+listings, page creation, conversations) the only Canvas-supported path
+is **per-user OAuth2**: each faculty member authorizes the tool once,
+and the tool stores a (short-lived access_token + long-lived
+refresh_token) pair to make API calls on that user's behalf.
+
+This module handles the OAuth2 dance and the resulting token storage.
+The actual HTTP routes that drive the redirects live in
+``src.api.canvas_oauth``; this module is the pure logic layer.
+
+Flow:
+
+  1. ``authorization_url(platform, redirect_uri, state, scopes)`` builds
+     the Canvas auth-page URL the user is redirected to.
+  2. After consent Canvas redirects to ``redirect_uri?code=...&state=...``.
+  3. ``exchange_code(platform, code, redirect_uri)`` swaps the code for
+     ``{access_token, refresh_token, expires_in, user}``.
+  4. ``put_user_token`` stores the token under
+     ``eq-pdf:lti:user-token:{platform_id}:{user_id}`` (Redis TTL set to
+     ``expires_in - buffer``; the refresh_token is persisted separately
+     with a longer TTL so we can mint fresh access tokens silently).
+  5. On 401 from the API, ``refresh_user_token`` exchanges the refresh
+     token for a new pair.
+
+Storage shape (JSON in Redis under the platform+user key)::
+
+    {
+      "access_token": "...",
+      "refresh_token": "...",
+      "expires_at": <unix seconds>,
+      "canvas_user_id": "...",
+      "canvas_user_name": "...",
+      "obtained_at": "<iso>",
+    }
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import secrets
+import time
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from typing import Any
+from urllib.parse import urlencode
+
+import httpx
+
+from ..canvas.tenant import tk
+from ..lti.platform import PlatformInstall
+
+logger = logging.getLogger(__name__)
+
+# Per-user token cache. Key includes platform_id because two schools
+# might have the same Canvas user-id and we must not cross the streams.
+USER_TOKEN_KEY = tk("lti:user-token:{platform_id}:{user_id}")
+
+# CSRF state for the OAuth2 redirect handshake. We store a short-lived
+# state token mapped to the original LTI session so the callback can
+# resume the journey to the review UI after consent.
+OAUTH_STATE_KEY = tk("lti:oauth-state:{state}")
+
+_EXPIRY_BUFFER_SECONDS = 60
+_STATE_TTL_SECONDS = 600  # 10 min for the user to complete consent
+_HTTP_TIMEOUT_SECONDS = 10.0
+
+
+class UserOAuthError(Exception):
+    """Anything went wrong during the user-OAuth flow."""
+
+
+@dataclass
+class UserToken:
+    access_token: str
+    refresh_token: str | None
+    expires_at: float
+    canvas_user_id: str
+    canvas_user_name: str | None = None
+    obtained_at: str = ""
+
+    @classmethod
+    def from_canvas_response(
+        cls, payload: dict[str, Any], *, canvas_user_id: str | None = None
+    ) -> UserToken:
+        access = payload.get("access_token")
+        if not access:
+            raise UserOAuthError("token response missing access_token")
+        # Refresh tokens may be absent on a token refresh (Canvas reuses
+        # the long-lived one); the caller is responsible for preserving
+        # the existing refresh_token in that case.
+        refresh = payload.get("refresh_token")
+        expires_in = float(payload.get("expires_in", 3600))
+        # Canvas embeds the user identity in `user.id` on the first
+        # code-exchange response. On subsequent refreshes the field is
+        # absent, hence the optional override.
+        user_obj = payload.get("user") or {}
+        uid = canvas_user_id or str(user_obj.get("id") or "")
+        return cls(
+            access_token=str(access),
+            refresh_token=str(refresh) if refresh else None,
+            expires_at=time.time() + expires_in - _EXPIRY_BUFFER_SECONDS,
+            canvas_user_id=uid,
+            canvas_user_name=user_obj.get("name") or None,
+            obtained_at=datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+        )
+
+    def is_expired(self) -> bool:
+        return time.time() >= self.expires_at
+
+    def to_json(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class OAuthState:
+    """CSRF state stored between authorize-redirect and callback."""
+
+    platform_id: str
+    session_id: str
+    return_url: str
+    # When True the authorize flow was opened in a popup window; the
+    # callback then returns a self-closing page that messages the opener
+    # instead of redirecting. Defaulted so older stashed states (written
+    # before this field existed) still deserialize via ``OAuthState(**...)``.
+    popup: bool = False
+
+
+def authorization_url(
+    platform: PlatformInstall,
+    *,
+    redirect_uri: str,
+    state: str,
+    scopes: list[str] | None = None,
+) -> str:
+    """Build the ``/login/oauth2/auth`` URL we redirect the user to.
+
+    The user lands on a Canvas-hosted consent page where they approve
+    the tool's access. On approve, Canvas redirects them back to
+    ``redirect_uri?code=...&state=...``.
+
+    **Hostname split-brain alert.** Canvas Cloud uses TWO different
+    hosts for the two halves of the OAuth dance:
+
+      * The user-facing **authorize page** lives on the institution's
+        host (e.g. ``csueb.test.instructure.com``) because that's
+        where the user is logged in and where their Canvas account +
+        role permissions live. The SSO host
+        (``canvas.test.instructure.com``) does not know the user's
+        per-institution permissions, so consent requests sent there
+        fail with "exceeds scope granted by the resource owner".
+      * The **token exchange endpoint** lives on the SSO host
+        (``canvas.test.instructure.com/login/oauth2/token``). Token
+        mints, client_credentials assertions, and refresh-grant calls
+        all go there.
+
+    So this function builds the URL from ``canvas_api_base`` (the
+    institutional host), while ``exchange_code`` and
+    ``refresh_user_token`` POST to ``auth_token_url`` (the SSO host).
+    Both are correct and Canvas's docs confirm this asymmetry,
+    confusingly.
+
+    Scopes are space-separated per RFC 6749 -- not the LTI Advantage
+    JSON-array style.
+    """
+    # Strip the /api/v1 suffix from canvas_api_base to get the bare
+    # institutional host, then append the /login/oauth2/auth path.
+    base = (platform.canvas_api_base or "").rstrip("/")
+    if base.endswith("/api/v1"):
+        base = base[: -len("/api/v1")]
+    # Prefer the OAuth API-key client_id when one is configured. Canvas
+    # Cloud's /login/oauth2/auth endpoint only accepts non-LTI Developer
+    # Keys; the platform's LTI client_id is rejected. Operators register
+    # a sibling "API Key" in Canvas and set its client_id via the
+    # CANVAS_OAUTH_CLIENT_ID env var.
+    from ..config import settings as _s
+    oauth_cid = (getattr(_s, "canvas_oauth_client_id", "") or "").strip()
+    effective_client_id = oauth_cid or platform.client_id
+    params: dict[str, str] = {
+        "client_id": effective_client_id,
+        "response_type": "code",
+        "redirect_uri": redirect_uri,
+        "state": state,
+    }
+    if scopes:
+        params["scope"] = " ".join(scopes)
+    return f"{base}/login/oauth2/auth?{urlencode(params)}"
+
+
+async def exchange_code(
+    platform: PlatformInstall,
+    *,
+    code: str,
+    redirect_uri: str,
+    client_assertion: str | None = None,
+    client_secret: str | None = None,
+) -> UserToken:
+    """Swap an authorization code for a user-bound access+refresh pair.
+
+    Canvas supports two client-authentication modes for the code
+    exchange:
+
+      * **JWT bearer assertion** -- pass ``client_assertion`` built by
+        signing a JWT with our LTI private key. Same scheme as the
+        client_credentials flow uses. Preferred when the dev key was
+        registered with a public JWK URL (which is our case).
+      * **client_secret** -- a shared secret that Canvas generates per
+        dev key. Required for dev keys without a JWK; passed as a form
+        field. Supported as a fallback.
+
+    Exactly one of ``client_assertion`` or ``client_secret`` must be
+    provided.
+    """
+    if bool(client_assertion) == bool(client_secret):
+        raise UserOAuthError(
+            "exchange_code: exactly one of client_assertion or client_secret required"
+        )
+
+    from ..config import settings as _s
+    oauth_cid = (getattr(_s, "canvas_oauth_client_id", "") or "").strip()
+    effective_client_id = oauth_cid or platform.client_id
+    data: dict[str, str] = {
+        "grant_type": "authorization_code",
+        "code": code,
+        "redirect_uri": redirect_uri,
+        "client_id": effective_client_id,
+    }
+    # If the OAuth dev key requires a client_secret and one is configured
+    # in env, use it; falls through to the assertion path otherwise.
+    if not client_secret and not client_assertion:
+        env_secret = getattr(_s, "canvas_oauth_client_secret", None)
+        if env_secret is not None:
+            sv = env_secret.get_secret_value() if hasattr(env_secret, "get_secret_value") else str(env_secret)
+            if sv:
+                client_secret = sv
+    if client_assertion:
+        data["client_assertion_type"] = (
+            "urn:ietf:params:oauth:client-assertion-type:jwt-bearer"
+        )
+        data["client_assertion"] = client_assertion
+    else:
+        assert client_secret is not None
+        data["client_secret"] = client_secret
+
+    return await _post_token_endpoint(platform, data)
+
+
+async def refresh_user_token(
+    platform: PlatformInstall,
+    *,
+    refresh_token: str,
+    canvas_user_id: str,
+    client_assertion: str | None = None,
+    client_secret: str | None = None,
+) -> UserToken:
+    """Use a stored refresh_token to mint a fresh access_token.
+
+    Canvas reuses the same refresh_token across refreshes; we preserve
+    the caller's existing refresh_token on the returned ``UserToken``
+    if Canvas omits one in the response.
+    """
+    if bool(client_assertion) == bool(client_secret):
+        raise UserOAuthError(
+            "refresh_user_token: exactly one of client_assertion or "
+            "client_secret required"
+        )
+
+    from ..config import settings as _s
+    oauth_cid = (getattr(_s, "canvas_oauth_client_id", "") or "").strip()
+    effective_client_id = oauth_cid or platform.client_id
+    data: dict[str, str] = {
+        "grant_type": "refresh_token",
+        "refresh_token": refresh_token,
+        "client_id": effective_client_id,
+    }
+    if not client_secret and not client_assertion:
+        env_secret = getattr(_s, "canvas_oauth_client_secret", None)
+        if env_secret is not None:
+            sv = env_secret.get_secret_value() if hasattr(env_secret, "get_secret_value") else str(env_secret)
+            if sv:
+                client_secret = sv
+    if client_assertion:
+        data["client_assertion_type"] = (
+            "urn:ietf:params:oauth:client-assertion-type:jwt-bearer"
+        )
+        data["client_assertion"] = client_assertion
+    else:
+        assert client_secret is not None
+        data["client_secret"] = client_secret
+
+    fresh = await _post_token_endpoint(
+        platform, data, canvas_user_id=canvas_user_id
+    )
+    # Canvas omits the refresh_token on refresh; preserve the existing one.
+    if not fresh.refresh_token:
+        fresh.refresh_token = refresh_token
+    return fresh
+
+
+async def _post_token_endpoint(
+    platform: PlatformInstall,
+    data: dict[str, str],
+    *,
+    canvas_user_id: str | None = None,
+) -> UserToken:
+    try:
+        async with httpx.AsyncClient(timeout=_HTTP_TIMEOUT_SECONDS) as client:
+            resp = await client.post(
+                platform.auth_token_url,
+                data=data,
+                headers={"Accept": "application/json"},
+            )
+    except httpx.HTTPError as exc:
+        raise UserOAuthError(f"token endpoint network error: {exc}") from exc
+
+    if resp.status_code >= 400:
+        body_preview = resp.text[:300]
+        try:
+            j = resp.json()
+            body_preview = (
+                f"error={j.get('error')!r} "
+                f"description={j.get('error_description')!r}"
+            )
+        except ValueError:
+            pass
+        raise UserOAuthError(
+            f"token endpoint HTTP {resp.status_code}: {body_preview}"
+        )
+
+    try:
+        payload = resp.json()
+    except ValueError as exc:
+        raise UserOAuthError(f"token endpoint non-JSON response: {exc}") from exc
+
+    token = UserToken.from_canvas_response(payload, canvas_user_id=canvas_user_id)
+    # Emit an audit row. We don't know from inside _post_token_endpoint
+    # whether this was a code-exchange or refresh, so use a generic event;
+    # callers can add their own context above.
+    from . import audit
+    audit.emit(
+        "user_token_grant",
+        platform=platform.platform_id,
+        user=token.canvas_user_id or canvas_user_id,
+        ttl_s=int(token.expires_at - time.time()),
+        had_refresh=bool(token.refresh_token),
+    )
+    return token
+
+
+# ---------------------------------------------------------------------------
+# Redis storage.
+# ---------------------------------------------------------------------------
+
+
+async def put_user_token(
+    redis, platform_id: str, user_id: str, token: UserToken
+) -> None:
+    """Persist a user-OAuth token. Refresh_token persists at the same key.
+
+    Storage is JSON with the access_token + refresh_token fields
+    individually encrypted via ``privacy.encrypt_secret`` so a Redis
+    snapshot leak cannot directly impersonate users. The remaining
+    fields (canvas_user_id, name, expiry) are not secrets and stay
+    plain to keep ops scripts useful.
+
+    The Redis TTL covers the access_token's lifetime; we keep the
+    JSON keyed past expiry via a separate longer-TTL store so that
+    ``get_user_token`` can return a stale-access record whose
+    refresh_token a caller can use to mint a fresh one. The longer
+    TTL is 90 days, which matches Canvas's typical refresh-token
+    longevity.
+    """
+    from .privacy import encrypt_secret
+    payload = token.to_json()
+    if payload.get("access_token"):
+        payload["access_token"] = encrypt_secret(payload["access_token"])
+    if payload.get("refresh_token"):
+        payload["refresh_token"] = encrypt_secret(payload["refresh_token"])
+    # Mark the record so ``get_user_token`` knows to decrypt.
+    payload["_encrypted"] = True
+    key = USER_TOKEN_KEY.format(platform_id=platform_id, user_id=user_id)
+    body = json.dumps(payload)
+    # 90 days for the record; the access_token expiry is encoded inside.
+    await redis.set(key, body, ex=90 * 24 * 3600)
+
+
+async def get_user_token(
+    redis, platform_id: str, user_id: str
+) -> UserToken | None:
+    """Return the stored token for (platform, user), or None.
+
+    Caller should check ``token.is_expired()`` and refresh if so.
+    Legacy plaintext records (pre-encryption) are read through
+    unchanged so the rollout doesn't require a migration.
+    """
+    key = USER_TOKEN_KEY.format(platform_id=platform_id, user_id=user_id)
+    raw = await redis.get(key)
+    if raw is None:
+        return None
+    try:
+        if isinstance(raw, (bytes, bytearray)):
+            raw = raw.decode("utf-8")
+        data = json.loads(raw)
+        if data.pop("_encrypted", False):
+            from .privacy import decrypt_secret
+            if data.get("access_token"):
+                data["access_token"] = decrypt_secret(data["access_token"])
+            if data.get("refresh_token"):
+                data["refresh_token"] = decrypt_secret(data["refresh_token"])
+        return UserToken(**data)
+    except (ValueError, TypeError):
+        return None
+    except RuntimeError as exc:
+        logger.error("get_user_token: decrypt failed: %s", exc)
+        return None
+
+
+async def drop_user_token(redis, platform_id: str, user_id: str) -> None:
+    """Delete a stored token. Called when refresh fails permanently."""
+    key = USER_TOKEN_KEY.format(platform_id=platform_id, user_id=user_id)
+    await redis.delete(key)
+
+
+# ---------------------------------------------------------------------------
+# OAuth state (CSRF protection for the redirect handshake).
+# ---------------------------------------------------------------------------
+
+
+def new_oauth_state_token() -> str:
+    """Return a fresh random state value the callback will validate."""
+    return secrets.token_urlsafe(32)
+
+
+async def put_oauth_state(redis, state: str, payload: OAuthState) -> None:
+    await redis.set(
+        OAUTH_STATE_KEY.format(state=state),
+        json.dumps(asdict(payload)),
+        ex=_STATE_TTL_SECONDS,
+    )
+
+
+async def take_oauth_state(redis, state: str) -> OAuthState | None:
+    """Single-use read: returns the state and deletes the record."""
+    key = OAUTH_STATE_KEY.format(state=state)
+    raw = await redis.get(key)
+    if raw is None:
+        return None
+    await redis.delete(key)
+    try:
+        if isinstance(raw, (bytes, bytearray)):
+            raw = raw.decode("utf-8")
+        return OAuthState(**json.loads(raw))
+    except (ValueError, TypeError):
+        return None
diff --git a/src/canvas/wcag_checks.py b/src/canvas/wcag_checks.py
new file mode 100644
index 0000000..27437a5
--- /dev/null
+++ b/src/canvas/wcag_checks.py
@@ -0,0 +1,334 @@
+"""Automated WCAG 2.1 AA-oriented checks on generated/edited HTML.
+
+This is the *automated* half of the Phase 7 publication gate. It runs
+deterministic structural checks against the HTML we're about to serve
+and produces a list of failures the reviewer must either fix or
+explicitly waive.
+
+What this is NOT:
+  * Not a substitute for human review. Things like meaningful alt
+    text, accurate reading order on multi-column scans, and math
+    equivalents require a human.
+  * Not a substitute for a full axe-core run. axe-core covers ~30%
+    of WCAG criteria automatically; this module is a focused subset
+    of the most-common-failure structural rules. Adding axe-core
+    via headless Chrome is a follow-up.
+
+Each finding has:
+  * ``rule_id``    -- stable identifier for filtering/waivers
+  * ``severity``   -- "error" / "warning" / "info"
+  * ``wcag_ref``   -- WCAG 2.1 success criterion (e.g. "1.3.1")
+  * ``message``    -- human-readable
+  * ``location``   -- best-effort string locator
+  * ``element``    -- tag name when applicable
+
+The output shape is consumed by:
+  * ``_compute_score``      -- surfaces issue counts on the dial.
+  * The publication gate    -- counts ``error``-severity findings.
+  * The reviewer checklist  -- pre-populates items to confirm.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field, asdict
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class WcagFinding:
+    rule_id: str
+    severity: str  # "error" | "warning" | "info"
+    wcag_ref: str
+    message: str
+    location: str = ""
+    element: str = ""
+
+
+@dataclass
+class WcagReport:
+    findings: list[WcagFinding] = field(default_factory=list)
+    summary: dict[str, int] = field(default_factory=dict)
+    passed: bool = False
+
+    def to_json(self) -> dict[str, Any]:
+        return {
+            "findings": [asdict(f) for f in self.findings],
+            "summary": dict(self.summary),
+            "passed": self.passed,
+        }
+
+
+def _location_for(el) -> str:
+    """Best-effort locator for an lxml element. Short, human-readable."""
+    try:
+        path = []
+        cur = el
+        while cur is not None and getattr(cur, "tag", None):
+            tag = cur.tag if isinstance(cur.tag, str) else "node"
+            idx_in_parent = ""
+            parent = cur.getparent() if hasattr(cur, "getparent") else None
+            if parent is not None:
+                same = [c for c in parent if getattr(c, "tag", None) == cur.tag]
+                if len(same) > 1:
+                    idx_in_parent = f"[{same.index(cur) + 1}]"
+            path.append(f"{tag}{idx_in_parent}")
+            cur = parent
+            if len(path) > 6:
+                break
+        return " > ".join(reversed(path))
+    except Exception:
+        return ""
+
+
+def run_wcag_checks(html: str) -> WcagReport:
+    """Run the WCAG check set against an HTML document.
+
+    Returns a ``WcagReport``. ``passed`` is ``True`` iff there are zero
+    ``error``-severity findings. Warnings don't block publish but
+    surface in the reviewer's pre-publish checklist.
+    """
+    report = WcagReport()
+    if not html or not html.strip():
+        report.findings.append(WcagFinding(
+            rule_id="empty-document",
+            severity="error",
+            wcag_ref="1.3.1",
+            message="HTML document is empty",
+        ))
+        _finalize(report)
+        return report
+
+    try:
+        from lxml import html as lxml_html
+    except ImportError:
+        logger.exception("lxml not installed; WCAG checks cannot run")
+        report.findings.append(WcagFinding(
+            rule_id="check-runner-unavailable",
+            severity="error",
+            wcag_ref="-",
+            message="WCAG check runner could not be initialized (lxml missing)",
+        ))
+        _finalize(report)
+        return report
+
+    try:
+        root = lxml_html.fromstring(html)
+    except Exception as exc:
+        report.findings.append(WcagFinding(
+            rule_id="malformed-html",
+            severity="error",
+            wcag_ref="4.1.1",
+            message=f"HTML failed to parse: {exc!s}",
+        ))
+        _finalize(report)
+        return report
+
+    # Find the <html> element to inspect attributes like ``lang``.
+    html_el = root if root.tag == "html" else root.getroottree().getroot() if root.getroottree() else root
+
+    # ----- 1.3.1 / 4.1.2: language and title --------------------------------
+    lang = (html_el.get("lang") or html_el.get("xml:lang") or "").strip()
+    if not lang:
+        report.findings.append(WcagFinding(
+            rule_id="lang-attribute-missing",
+            severity="error",
+            wcag_ref="3.1.1",
+            message="<html> is missing a ``lang`` attribute",
+            element="html",
+        ))
+    titles = root.xpath("//title")
+    title_text = (titles[0].text_content().strip() if titles else "")
+    if not title_text:
+        report.findings.append(WcagFinding(
+            rule_id="title-missing",
+            severity="error",
+            wcag_ref="2.4.2",
+            message="<title> is missing or empty",
+            element="title",
+        ))
+    elif len(title_text) < 3:
+        report.findings.append(WcagFinding(
+            rule_id="title-too-short",
+            severity="warning",
+            wcag_ref="2.4.2",
+            message=f"<title> is suspiciously short ({title_text!r}); consider a more descriptive title",
+            element="title",
+        ))
+
+    # ----- 1.3.1: heading structure ----------------------------------------
+    headings = root.xpath("//h1|//h2|//h3|//h4|//h5|//h6")
+    h1s = [h for h in headings if h.tag == "h1"]
+    if not headings:
+        report.findings.append(WcagFinding(
+            rule_id="no-headings",
+            severity="error",
+            wcag_ref="1.3.1",
+            message="Document has no headings; this is rarely correct for academic content",
+        ))
+    elif not h1s:
+        report.findings.append(WcagFinding(
+            rule_id="no-h1",
+            severity="warning",
+            wcag_ref="2.4.6",
+            message="Document has no <h1>; the page title isn't being represented as a heading",
+        ))
+    elif len(h1s) > 1:
+        report.findings.append(WcagFinding(
+            rule_id="multiple-h1",
+            severity="warning",
+            wcag_ref="2.4.6",
+            message=f"Document has {len(h1s)} <h1> elements; usually only one is expected",
+        ))
+
+    # Heading-level skip detection: walk in document order.
+    prev_level = 0
+    for h in headings:
+        level = int(h.tag[1])
+        if prev_level and level > prev_level + 1:
+            report.findings.append(WcagFinding(
+                rule_id="heading-level-skip",
+                severity="warning",
+                wcag_ref="1.3.1",
+                message=f"Heading jumps from h{prev_level} to h{level}; intermediate level skipped",
+                element=h.tag,
+                location=_location_for(h),
+            ))
+        prev_level = level
+
+    # ----- 1.1.1: images need alt text -------------------------------------
+    images = root.xpath("//img")
+    for img in images:
+        alt = img.get("alt")
+        role = (img.get("role") or "").lower()
+        aria_hidden = (img.get("aria-hidden") or "").lower() == "true"
+        # Decorative images: alt="" OR role=presentation/none OR aria-hidden=true
+        decorative = (alt == "" or role in {"presentation", "none"} or aria_hidden)
+        if alt is None:
+            report.findings.append(WcagFinding(
+                rule_id="img-alt-missing",
+                severity="error",
+                wcag_ref="1.1.1",
+                message="<img> is missing an ``alt`` attribute",
+                element="img",
+                location=_location_for(img),
+            ))
+        elif decorative:
+            # Fine -- but worth flagging for reviewer confirmation.
+            report.findings.append(WcagFinding(
+                rule_id="img-decorative-needs-confirm",
+                severity="info",
+                wcag_ref="1.1.1",
+                message="Image marked as decorative (empty alt or aria-hidden); confirm this is not content",
+                element="img",
+                location=_location_for(img),
+            ))
+        elif len((alt or "").strip()) < 3:
+            report.findings.append(WcagFinding(
+                rule_id="img-alt-too-short",
+                severity="warning",
+                wcag_ref="1.1.1",
+                message=f"<img> alt text is suspiciously short ({alt!r})",
+                element="img",
+                location=_location_for(img),
+            ))
+
+    # ----- 1.3.1: tables ----------------------------------------------------
+    tables = root.xpath("//table")
+    for tbl in tables:
+        ths = tbl.xpath(".//th")
+        if not ths:
+            report.findings.append(WcagFinding(
+                rule_id="table-missing-th",
+                severity="error",
+                wcag_ref="1.3.1",
+                message="<table> has no <th> elements; data tables need header cells",
+                element="table",
+                location=_location_for(tbl),
+            ))
+        else:
+            # Check that headers have scope OR the table has headers/id mappings.
+            scoped = [th for th in ths if th.get("scope")]
+            has_id_headers = bool(tbl.xpath(".//*[@headers]"))
+            if not scoped and not has_id_headers:
+                report.findings.append(WcagFinding(
+                    rule_id="table-th-needs-scope",
+                    severity="warning",
+                    wcag_ref="1.3.1",
+                    message="<th> cells lack ``scope`` (row/col) and no headers/id mapping is present",
+                    element="th",
+                    location=_location_for(tbl),
+                ))
+        if not tbl.xpath("./caption"):
+            report.findings.append(WcagFinding(
+                rule_id="table-no-caption",
+                severity="info",
+                wcag_ref="1.3.1",
+                message="<table> has no <caption>; consider adding one for non-visual users",
+                element="table",
+                location=_location_for(tbl),
+            ))
+
+    # ----- 2.4.4: link names ----------------------------------------------
+    for a in root.xpath("//a"):
+        text = (a.text_content() or "").strip()
+        aria_label = (a.get("aria-label") or "").strip()
+        aria_lbl_by = (a.get("aria-labelledby") or "").strip()
+        if not text and not aria_label and not aria_lbl_by:
+            report.findings.append(WcagFinding(
+                rule_id="link-name-missing",
+                severity="error",
+                wcag_ref="2.4.4",
+                message="<a> has no accessible name (no text, aria-label, or aria-labelledby)",
+                element="a",
+                location=_location_for(a),
+            ))
+        elif text.lower() in {"click here", "here", "read more", "more"}:
+            report.findings.append(WcagFinding(
+                rule_id="link-generic-text",
+                severity="warning",
+                wcag_ref="2.4.4",
+                message=f"Link text is generic ({text!r}); use descriptive link text",
+                element="a",
+                location=_location_for(a),
+            ))
+
+    # ----- 2.5.3 / 4.1.2: form/control names (defensive; rare in our output)
+    for el in root.xpath("//button|//input"):
+        if el.tag == "input" and (el.get("type") or "").lower() in {"hidden", "submit", "button", "reset"}:
+            continue
+        name = (el.text_content() or "").strip()
+        aria_label = (el.get("aria-label") or "").strip()
+        if not name and not aria_label:
+            report.findings.append(WcagFinding(
+                rule_id="control-name-missing",
+                severity="error",
+                wcag_ref="4.1.2",
+                message=f"<{el.tag}> has no accessible name",
+                element=el.tag,
+                location=_location_for(el),
+            ))
+
+    # ----- 1.4.1: color-only indicators (heuristic) -----------------------
+    if root.xpath("//font"):
+        report.findings.append(WcagFinding(
+            rule_id="font-element-present",
+            severity="warning",
+            wcag_ref="1.4.1",
+            message="<font> element is deprecated; styling via CSS only and not color-only indicators",
+        ))
+
+    _finalize(report)
+    return report
+
+
+def _finalize(report: WcagReport) -> None:
+    """Compute summary counts + overall pass/fail."""
+    counts = {"error": 0, "warning": 0, "info": 0}
+    for f in report.findings:
+        if f.severity in counts:
+            counts[f.severity] += 1
+    report.summary = counts
+    report.passed = counts["error"] == 0
diff --git a/src/config.py b/src/config.py
index 508f9d0..70ed16e 100644
--- a/src/config.py
+++ b/src/config.py
@@ -286,6 +286,77 @@ class Settings(BaseSettings):
         ge=1, le=300, default=60, description="Timeout worker sleep duration on error"
     )
 
+    # ------------------------------------------------------------------
+    # Canvas LMS / LTI 1.3 integration
+    # ------------------------------------------------------------------
+    # All optional. When ``lti_enabled`` is False the routers self-disable
+    # and the watcher/bridge idle, so leaving the rest empty is safe.
+    lti_enabled: bool = Field(default=False, description="Enable LTI 1.3 endpoints and Canvas workers")
+    lti_issuer: str | None = Field(default=None, description="Canvas issuer URL (e.g. https://canvas.instructure.com)")
+    lti_client_id: str | None = Field(default=None, description="Canvas Developer Key client_id")
+    lti_deployment_id: str | None = Field(default=None, description="Canvas deployment id")
+    lti_auth_login_url: str | None = Field(default=None, description="Canvas OIDC authorize_redirect endpoint")
+    lti_auth_token_url: str | None = Field(default=None, description="Canvas OAuth2 token endpoint")
+    lti_jwks_url: str | None = Field(default=None, description="Canvas JWKS endpoint")
+    lti_private_key_path: str = Field(default="/app/keys/lti_private.pem", description="Path to LTI private key")
+    lti_public_key_path: str = Field(default="/app/keys/lti_public.pem", description="Path to LTI public key")
+    lti_state_ttl_seconds: int = Field(ge=60, le=3600, default=600, description="OIDC state nonce TTL")
+    lti_public_url: str | None = Field(default=None, description="Public origin of this tool, used in notification deep links")
+
+    canvas_tenant: str = Field(
+        default="default",
+        description=(
+            "Tenant id for Redis key namespacing. 'default' preserves the "
+            "legacy unprefixed key shape (single-campus install); any other "
+            "value namespaces every key as eq-pdf:t:{tenant}:... so multiple "
+            "campuses can share one Redis without cross-contamination."
+        ),
+    )
+    canvas_api_url: str | None = Field(default=None, description="Canvas instance base URL (https://yourschool.instructure.com)")
+    canvas_api_token: SecretStr | None = Field(default=None, description="Canvas API token used by the watcher/bridge workers")
+    canvas_watched_courses: str = Field(default="", description="Comma-separated Canvas course ids the watcher polls")
+    multi_tenant_watcher: bool = Field(default=False, description="Watcher iterates LTI-registered platforms instead of canvas_watched_courses")
+    canvas_oauth_client_id: str = Field(default="", description="Canvas API Key (non-LTI Developer Key) client_id for the user-OAuth2 flow; required because LTI 1.3 keys are not accepted by Canvas's /login/oauth2/auth endpoint")
+    canvas_oauth_client_secret: SecretStr | None = Field(default=None, description="Secret for the user-OAuth API Key (optional if the key uses a public JWK URL and JWT-bearer client auth)")
+    canvas_allowed_origins: str = Field(default="", description="Comma-separated Canvas origins allowed to call panorama endpoints (e.g. 'https://canvas.example.edu,https://example.instructure.com')")
+    canvas_allowed_origin_regex: str = Field(default="", description="Regex of Canvas origins allowed to call panorama endpoints; takes precedence over canvas_allowed_origins when set")
+    canvas_poll_seconds: int = Field(ge=15, le=3600, default=60, description="Canvas file poll interval")
+    reflow_poll_seconds: int = Field(ge=5, le=600, default=30, description="Reflow job poll interval for the bridge")
+    reflow_api_url: str = Field(default="http://api-gateway:8080", description="Reflow API base URL the bridge calls")
+
+    # Data retention controls. Both apply to Canvas-side state stored in Redis.
+    # Set to 0 (or negative) to disable purging for that bucket. Defaults are
+    # conservative for a research-data steward: jobs roll off after 90 days
+    # (alt formats can always be regenerated from the original file), audit
+    # events survive a full year so ISO reviews have history to walk.
+    # Per-course Claude API spend cap. See ``canvas.spend_cap`` for the
+    # full contract. Default of 0 disables the cap entirely - operators
+    # opt in by setting a per-course budget.
+    canvas_monthly_spend_cap_usd_default: int = Field(
+        ge=0, le=100_000, default=0,
+        description="Default monthly Claude-API spend cap in USD per Canvas course (0=unlimited)",
+    )
+    canvas_monthly_spend_cap_overrides: str = Field(
+        default="",
+        description='JSON map of course_id->cap_usd overrides, e.g. \'{"50594": 250}\'',
+    )
+    canvas_estimated_cost_per_doc_cents: int = Field(
+        ge=0, le=10000, default=10,
+        description="Pre-flight per-document cost estimate in cents (used by the spend cap)",
+    )
+    canvas_job_retention_days: int = Field(
+        ge=0, le=3650, default=90,
+        description="Days to retain Canvas job records in Redis (0=keep forever)",
+    )
+    canvas_audit_retention_days: int = Field(
+        ge=0, le=3650, default=365,
+        description="Days to retain approval-audit events in Redis (0=keep forever)",
+    )
+    canvas_retention_sweep_every_ticks: int = Field(
+        ge=1, le=10080, default=240,
+        description="Run the retention sweep every N watcher ticks (default 240 ~= every 4 hours at 60s poll)",
+    )
+
     # Testing Configuration
     disable_workers: bool = Field(
         default=False, description="Disable background workers (PII, timeout) for testing scenarios"
diff --git a/src/logging_setup.py b/src/logging_setup.py
new file mode 100644
index 0000000..727b7cf
--- /dev/null
+++ b/src/logging_setup.py
@@ -0,0 +1,201 @@
+"""Structured logging configuration.
+
+Replaces the older ``logging.basicConfig`` setup. Emits one JSON object
+per log record so log aggregators (CloudWatch Insights, Loki, Datadog)
+can pivot by user, course, or request id without parsing free-form
+strings.
+
+Context propagation
+-------------------
+Three :mod:`contextvars` carry per-request identity through every async
+hop without the caller having to thread them explicitly:
+
+  * ``request_id_var``  - request correlation id (one per HTTP request)
+  * ``user_id_var``     - LTI session subject when known
+  * ``course_id_var``   - Canvas course id when known
+  * ``tenant_var``      - tenant key for multi-campus deployments
+
+Middleware sets these at request entry; the formatter reads them when
+emitting each line. Downstream code can ignore context entirely - just
+call ``logger.info("...")`` and the right fields appear.
+
+Operators can choose between human-readable text logs (default in dev)
+and JSON logs (default in prod) via ``LOG_FORMAT=text|json``. The JSON
+shape is intentionally stable so anything downstream that grew up on it
+keeps working.
+"""
+
+from __future__ import annotations
+
+import contextvars
+import json
+import logging
+import os
+import sys
+import time
+import uuid
+from typing import Any
+
+# ---------------------------------------------------------------------------
+# Context variables - propagate request identity through async code without
+# threading arguments. Default to None so log records emitted outside a
+# request (workers, startup, shutdown) simply omit the field rather than
+# crashing the formatter.
+# ---------------------------------------------------------------------------
+request_id_var: contextvars.ContextVar[str | None] = contextvars.ContextVar(
+    "request_id", default=None
+)
+user_id_var: contextvars.ContextVar[str | None] = contextvars.ContextVar(
+    "user_id", default=None
+)
+course_id_var: contextvars.ContextVar[str | None] = contextvars.ContextVar(
+    "course_id", default=None
+)
+tenant_var: contextvars.ContextVar[str | None] = contextvars.ContextVar(
+    "tenant", default=None
+)
+
+
+# Standard ``logging.LogRecord`` attribute names. Anything outside this set
+# in ``record.__dict__`` is treated as a user-supplied "extra" and is
+# emitted as a top-level JSON field. Keep this in sync with the stdlib if
+# the Python version ever bumps - it has not changed since 3.2.
+_RESERVED_ATTRS = frozenset(
+    {
+        "args", "asctime", "created", "exc_info", "exc_text", "filename",
+        "funcName", "levelname", "levelno", "lineno", "module", "msecs",
+        "message", "msg", "name", "pathname", "process", "processName",
+        "relativeCreated", "stack_info", "thread", "threadName",
+        "taskName",
+    }
+)
+
+
+def new_request_id() -> str:
+    """Generate a fresh request id. UUID4 hex is short, opaque, and unique
+    enough for correlation across a few months of logs without clashing
+    with any other id space in the system."""
+    return uuid.uuid4().hex[:16]
+
+
+class JsonFormatter(logging.Formatter):
+    """Format a ``LogRecord`` as a single-line JSON document.
+
+    Fields:
+      * ``ts``        - ISO-8601 UTC timestamp with millisecond precision
+      * ``level``     - "INFO", "WARNING", ...
+      * ``logger``    - dotted logger name, e.g. "src.workers.canvas_watcher"
+      * ``msg``       - the formatted log message
+      * ``request_id``, ``user_id``, ``course_id``, ``tenant`` when set
+      * exception info inline (``exc_type``, ``exc_msg``, ``exc_trace``)
+      * any ``extra={...}`` keys the caller passed in
+    """
+
+    def format(self, record: logging.LogRecord) -> str:
+        payload: dict[str, Any] = {
+            "ts": _isoformat_utc(record.created),
+            "level": record.levelname,
+            "logger": record.name,
+            "msg": record.getMessage(),
+        }
+
+        # Pull context vars at format time so each line reflects the current
+        # async task's identity, not the task that submitted the log.
+        for key, var in (
+            ("request_id", request_id_var),
+            ("user_id", user_id_var),
+            ("course_id", course_id_var),
+            ("tenant", tenant_var),
+        ):
+            value = var.get()
+            if value is not None:
+                payload[key] = value
+
+        # Any caller-supplied ``extra={...}`` keys ride along at top level.
+        for attr, value in record.__dict__.items():
+            if attr in _RESERVED_ATTRS or attr.startswith("_"):
+                continue
+            try:
+                json.dumps(value)  # cheap is-serializable probe
+                payload[attr] = value
+            except (TypeError, ValueError):
+                payload[attr] = repr(value)
+
+        if record.exc_info:
+            exc_type, exc_value, _tb = record.exc_info
+            payload["exc_type"] = exc_type.__name__ if exc_type else None
+            payload["exc_msg"] = str(exc_value) if exc_value else None
+            payload["exc_trace"] = self.formatException(record.exc_info)
+
+        return json.dumps(payload, separators=(",", ":"), default=str)
+
+
+def _isoformat_utc(epoch_seconds: float) -> str:
+    """Format an epoch float as ISO-8601 in UTC with millisecond precision.
+
+    ``logging.Formatter.formatTime`` uses local time by default and the
+    microsecond field is awkward to suppress; producing the string by hand
+    keeps log lines short and timezone-correct.
+    """
+    msec = int((epoch_seconds - int(epoch_seconds)) * 1000)
+    return f"{time.strftime('%Y-%m-%dT%H:%M:%S', time.gmtime(epoch_seconds))}.{msec:03d}Z"
+
+
+class TextFormatter(logging.Formatter):
+    """Human-friendly single-line text formatter for local dev.
+
+    Same context fields as the JSON formatter but in a shape that's
+    grep-friendly on a terminal.
+    """
+
+    def format(self, record: logging.LogRecord) -> str:
+        ctx_parts = []
+        for key, var in (
+            ("rid", request_id_var),
+            ("uid", user_id_var),
+            ("cid", course_id_var),
+        ):
+            value = var.get()
+            if value is not None:
+                ctx_parts.append(f"{key}={value}")
+        ctx = " ".join(ctx_parts)
+        ctx_str = f" [{ctx}]" if ctx else ""
+
+        base = (
+            f"{_isoformat_utc(record.created)} {record.levelname:7s} "
+            f"{record.name}{ctx_str} - {record.getMessage()}"
+        )
+        if record.exc_info:
+            base += "\n" + self.formatException(record.exc_info)
+        return base
+
+
+def configure_logging(level: str = "INFO", fmt: str | None = None) -> None:
+    """Initialize the root logger with the chosen formatter.
+
+    ``fmt`` defaults to the ``LOG_FORMAT`` env var, falling back to "json"
+    when ``ENVIRONMENT`` is not "dev" and "text" otherwise. Idempotent:
+    safe to call multiple times (subsequent calls reset handlers).
+    """
+    if fmt is None:
+        fmt = os.environ.get("LOG_FORMAT") or (
+            "text" if os.environ.get("ENVIRONMENT", "dev") == "dev" else "json"
+        )
+
+    root = logging.getLogger()
+    # Clear any handlers basicConfig may have installed so we don't double-emit.
+    for handler in list(root.handlers):
+        root.removeHandler(handler)
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(JsonFormatter() if fmt == "json" else TextFormatter())
+    root.addHandler(handler)
+    root.setLevel(level.upper())
+
+    # Silence the usual suspects - they're informative at WARNING and
+    # firehose-loud at INFO. Same set as the old basicConfig.
+    for noisy in (
+        "botocore", "boto3", "urllib3", "httpcore", "httpx",
+        "s3transfer", "python_multipart",
+    ):
+        logging.getLogger(noisy).setLevel(logging.WARNING)
diff --git a/src/lti/__init__.py b/src/lti/__init__.py
new file mode 100644
index 0000000..a1c6ca3
--- /dev/null
+++ b/src/lti/__init__.py
@@ -0,0 +1,13 @@
+"""LTI 1.3 integration for Canvas LMS.
+
+This package exposes endpoints Canvas calls during the LTI launch dance
+(OIDC login, signed launch JWT, JWKS, tool configuration) and the helpers
+that validate Canvas-issued JWTs against the platform's JWKS.
+
+The mounted router is wired into the FastAPI app in ``src.main``. See
+``docs/explanation/canvas-lti-integration.md`` for the surrounding design.
+"""
+
+from .routes import router
+
+__all__ = ["router"]
diff --git a/src/lti/config.py b/src/lti/config.py
new file mode 100644
index 0000000..2631a56
--- /dev/null
+++ b/src/lti/config.py
@@ -0,0 +1,55 @@
+"""LTI-specific settings, pulled from the top-level ``Settings`` object.
+
+Kept as a thin wrapper so the rest of the LTI package never has to import
+the global settings module directly; tests can monkeypatch this view.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..config import settings
+
+
+@dataclass(frozen=True)
+class LtiSettings:
+    """Resolved LTI configuration.
+
+    Every field is required when ``LTI_ENABLED`` is true. Defaults are kept
+    permissive so the import does not blow up in dev when LTI is off.
+    """
+
+    enabled: bool
+    issuer: str
+    client_id: str
+    deployment_id: str
+    auth_login_url: str
+    auth_token_url: str
+    jwks_url: str
+    private_key_path: str
+    public_key_path: str
+    canvas_api_url: str
+    state_ttl_seconds: int
+
+
+def get_lti_settings() -> LtiSettings:
+    """Return resolved LTI settings.
+
+    Reads the underlying ``Settings`` object on every call so tests that
+    patch settings see the change without restarting the process.
+    """
+
+    s = settings
+    return LtiSettings(
+        enabled=bool(getattr(s, "lti_enabled", False)),
+        issuer=getattr(s, "lti_issuer", "") or "",
+        client_id=getattr(s, "lti_client_id", "") or "",
+        deployment_id=getattr(s, "lti_deployment_id", "") or "",
+        auth_login_url=getattr(s, "lti_auth_login_url", "") or "",
+        auth_token_url=getattr(s, "lti_auth_token_url", "") or "",
+        jwks_url=getattr(s, "lti_jwks_url", "") or "",
+        private_key_path=getattr(s, "lti_private_key_path", "/app/keys/lti_private.pem"),
+        public_key_path=getattr(s, "lti_public_key_path", "/app/keys/lti_public.pem"),
+        canvas_api_url=getattr(s, "canvas_api_url", "") or "",
+        state_ttl_seconds=int(getattr(s, "lti_state_ttl_seconds", 600)),
+    )
diff --git a/src/lti/jwt_validation.py b/src/lti/jwt_validation.py
new file mode 100644
index 0000000..ac5e406
--- /dev/null
+++ b/src/lti/jwt_validation.py
@@ -0,0 +1,165 @@
+"""Validate Canvas-issued LTI 1.3 launch JWTs against the platform JWKS."""
+
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+from jwcrypto import jwk, jwt
+
+from .config import get_lti_settings
+
+logger = logging.getLogger(__name__)
+
+
+class LtiValidationError(Exception):
+    """Raised when an incoming LTI JWT fails validation."""
+
+
+@dataclass
+class LaunchClaims:
+    """Normalised view of the claims we care about.
+
+    The full JWT contains ~20 LTI claims; this dataclass exposes only the
+    handful that downstream code actually needs. If you need a new one,
+    add it here rather than threading raw dicts through the codebase.
+    """
+
+    issuer: str
+    audience: str
+    subject: str
+    user_id: str
+    user_name: str | None
+    user_email: str | None
+    roles: list[str]
+    course_id: str
+    course_title: str | None
+    deployment_id: str
+    target_link_uri: str
+    raw: dict[str, Any]
+
+
+_JWKS_CACHE: dict[str, tuple[float, jwk.JWKSet]] = {}
+_JWKS_TTL_SECONDS = 600
+
+
+async def _fetch_platform_jwks(jwks_url: str) -> jwk.JWKSet:
+    cached = _JWKS_CACHE.get(jwks_url)
+    now = time.time()
+    if cached and cached[0] > now:
+        return cached[1]
+
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        resp = await client.get(jwks_url)
+        resp.raise_for_status()
+        keyset = jwk.JWKSet.from_json(resp.text)
+
+    _JWKS_CACHE[jwks_url] = (now + _JWKS_TTL_SECONDS, keyset)
+    return keyset
+
+
+async def validate_launch_jwt(id_token: str) -> LaunchClaims:
+    """Verify signature, issuer, audience, and required LTI claims.
+
+    Returns a ``LaunchClaims`` dataclass on success. Raises
+    ``LtiValidationError`` on any failure with a message safe to log
+    (no token material).
+    """
+
+    cfg = get_lti_settings()
+    if not cfg.enabled:
+        raise LtiValidationError("LTI integration is disabled")
+
+    try:
+        keyset = await _fetch_platform_jwks(cfg.jwks_url)
+    except httpx.HTTPError as exc:
+        raise LtiValidationError(f"Could not fetch platform JWKS: {exc}") from exc
+
+    try:
+        token = jwt.JWT(jwt=id_token, key=keyset)
+        claims = token.claims if isinstance(token.claims, dict) else _parse_json(token.claims)
+    except Exception as exc:  # jwcrypto raises a tree of types; collapse for the caller
+        raise LtiValidationError(f"JWT signature/decoding failed: {exc}") from exc
+
+    _check_required(claims, cfg.issuer, cfg.client_id, cfg.deployment_id)
+
+    return LaunchClaims(
+        issuer=claims["iss"],
+        audience=_audience_of(claims["aud"]),
+        subject=claims["sub"],
+        user_id=claims["sub"],
+        user_name=claims.get("name"),
+        user_email=claims.get("email"),
+        roles=claims.get("https://purl.imsglobal.org/spec/lti/claim/roles", []),
+        # Prefer the numeric Canvas course ID from the custom claim — that's
+        # what every other surface keys off (the watcher, scored_files, and
+        # window.ENV.COURSE_ID in the Theme JS overlay). Canvas only sends
+        # this if the tool config declares ``course_id: $Canvas.course.id``
+        # under custom_fields (see register_tool_config in routes.py).
+        # Fall back to context.id (the opaque LTI hash) so launches keep
+        # working even on platforms that don't expand the substitution.
+        course_id=str(
+            claims.get("https://purl.imsglobal.org/spec/lti/claim/custom", {}).get("course_id")
+            or claims.get("https://purl.imsglobal.org/spec/lti/claim/context", {}).get("id", "")
+        ),
+        course_title=claims.get(
+            "https://purl.imsglobal.org/spec/lti/claim/context", {}
+        ).get("title"),
+        deployment_id=claims["https://purl.imsglobal.org/spec/lti/claim/deployment_id"],
+        target_link_uri=claims.get(
+            "https://purl.imsglobal.org/spec/lti/claim/target_link_uri", ""
+        ),
+        raw=claims,
+    )
+
+
+def _parse_json(claims_str: str) -> dict[str, Any]:
+    import json
+
+    return json.loads(claims_str)
+
+
+def _audience_of(aud: Any) -> str:
+    if isinstance(aud, list):
+        return aud[0] if aud else ""
+    return str(aud)
+
+
+def _check_required(
+    claims: dict[str, Any],
+    expected_issuer: str,
+    expected_client_id: str,
+    expected_deployment_id: str,
+) -> None:
+    if claims.get("iss") != expected_issuer:
+        raise LtiValidationError("Unexpected issuer")
+
+    audience = _audience_of(claims.get("aud"))
+    if audience != expected_client_id:
+        raise LtiValidationError("Unexpected audience")
+
+    deployment_claim = claims.get(
+        "https://purl.imsglobal.org/spec/lti/claim/deployment_id"
+    )
+    if deployment_claim != expected_deployment_id:
+        import logging as _logging
+        _logging.getLogger(__name__).warning(
+            "LTI deployment_id mismatch: got=%r expected=%r",
+            deployment_claim, expected_deployment_id,
+        )
+        raise LtiValidationError("Unexpected deployment_id")
+
+    message_type = claims.get(
+        "https://purl.imsglobal.org/spec/lti/claim/message_type"
+    )
+    if message_type != "LtiResourceLinkRequest":
+        raise LtiValidationError(f"Unsupported LTI message type: {message_type}")
+
+    now = int(time.time())
+    if "exp" in claims and now >= int(claims["exp"]):
+        raise LtiValidationError("Token expired")
+    if "iat" in claims and int(claims["iat"]) > now + 300:
+        raise LtiValidationError("Token issued in the future")
diff --git a/src/lti/keys.py b/src/lti/keys.py
new file mode 100644
index 0000000..c0c68b1
--- /dev/null
+++ b/src/lti/keys.py
@@ -0,0 +1,125 @@
+"""RSA keypair management for LTI 1.3.
+
+Canvas validates our outgoing assertions against the JWKS we publish at
+``/lti/jwks``. The private key signs assertions; the public key, in JWK
+form, is what Canvas fetches.
+
+This module is intentionally minimal and *file-backed* — keys live on a
+mounted volume in dev (``./keys``) and a secret-mount in prod. We do not
+load keys from env vars to avoid logging them by accident.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+from typing import Any
+
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey, RSAPublicKey
+from jwcrypto import jwk
+
+from .config import get_lti_settings
+
+logger = logging.getLogger(__name__)
+
+RSA_KEY_SIZE = 2048
+RSA_PUBLIC_EXPONENT = 65537
+
+
+def _ensure_parent(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+def generate_keypair(private_path: Path, public_path: Path) -> None:
+    """Generate a fresh RSA keypair and write PEM files.
+
+    Refuses to overwrite an existing private key — rotation is a separate
+    operation that requires explicit removal of the old file.
+    """
+
+    if private_path.exists():
+        raise FileExistsError(
+            f"Refusing to overwrite existing private key at {private_path}. "
+            "Delete the file explicitly to rotate."
+        )
+
+    _ensure_parent(private_path)
+    _ensure_parent(public_path)
+
+    private_key: RSAPrivateKey = rsa.generate_private_key(
+        public_exponent=RSA_PUBLIC_EXPONENT,
+        key_size=RSA_KEY_SIZE,
+    )
+
+    private_pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    public_pem = private_key.public_key().public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    )
+
+    private_path.write_bytes(private_pem)
+    public_path.write_bytes(public_pem)
+    private_path.chmod(0o600)
+    public_path.chmod(0o644)
+
+    logger.info("Wrote LTI keypair: %s, %s", private_path, public_path)
+
+
+def load_private_key() -> RSAPrivateKey:
+    cfg = get_lti_settings()
+    path = Path(cfg.private_key_path)
+    key = serialization.load_pem_private_key(path.read_bytes(), password=None)
+    if not isinstance(key, RSAPrivateKey):
+        raise TypeError(f"Expected RSA private key at {path}, got {type(key).__name__}")
+    return key
+
+
+def load_public_key() -> RSAPublicKey:
+    cfg = get_lti_settings()
+    path = Path(cfg.public_key_path)
+    key = serialization.load_pem_public_key(path.read_bytes())
+    if not isinstance(key, RSAPublicKey):
+        raise TypeError(f"Expected RSA public key at {path}, got {type(key).__name__}")
+    return key
+
+
+def jwks_document() -> dict[str, Any]:
+    """Return our JWKS as a plain dict, suitable for FastAPI to JSON-encode.
+
+    Canvas pulls this from ``/lti/jwks`` periodically and caches it; the
+    kid is stable across restarts because it is derived from the key.
+    """
+
+    cfg = get_lti_settings()
+    pem = Path(cfg.public_key_path).read_bytes()
+    key = jwk.JWK.from_pem(pem)
+    public_jwk = key.export_public(as_dict=True)
+    # jwcrypto sets kid from a thumbprint when from_pem is used; if not, fall back.
+    public_jwk.setdefault("kid", key.thumbprint())
+    public_jwk["use"] = "sig"
+    public_jwk["alg"] = "RS256"
+    return {"keys": [public_jwk]}
+
+
+def _cli() -> None:
+    """Tiny CLI: ``python -m src.lti.keys generate``."""
+
+    parser = argparse.ArgumentParser(description="LTI keypair utilities")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("generate", help="Generate a new RSA keypair if none exists")
+    args = parser.parse_args()
+
+    cfg = get_lti_settings()
+    if args.cmd == "generate":
+        generate_keypair(Path(cfg.private_key_path), Path(cfg.public_key_path))
+
+
+if __name__ == "__main__":
+    _cli()
diff --git a/src/lti/platform.py b/src/lti/platform.py
new file mode 100644
index 0000000..8f60155
--- /dev/null
+++ b/src/lti/platform.py
@@ -0,0 +1,201 @@
+"""Per-tenant Canvas platform registry.
+
+A ``PlatformInstall`` record captures everything Reflow needs to talk to
+one specific Canvas instance: how to authenticate (token endpoints,
+client_id, deployment_id), how to call its API (base URL), and metadata
+useful for ops dashboards and audit logs.
+
+One record per unique ``(issuer, client_id, deployment_id)`` triple.
+Records are created on the first LTI launch from a new Canvas instance
+and updated on every subsequent launch. The Phase 1 implementation only
+*writes* these records - nothing reads them yet, so behaviour is
+unchanged. Phase 2 (service-token client) is the first reader.
+
+The composite key gets hashed to a short fixed-width id so we can use
+it as a Redis key segment without worrying about issuer URLs containing
+characters that confuse Redis tooling or log scrubbers.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+from urllib.parse import urlparse
+
+
+# Canonical Canvas URL conventions. Every Instructure-hosted and
+# self-hosted Canvas exposes these paths under its main hostname, so we
+# can derive them deterministically from just the issuer claim. The two
+# exceptions are:
+#   * Instructure's SSO issuer ``https://sso.canvaslms.com`` (which is
+#     not the API host) - handled via the ``_SSO_HOST_OVERRIDE`` map.
+#   * Self-hosted Canvases with non-standard path mounts - those need an
+#     entry in platform_overrides.yaml at deploy time.
+_CANVAS_TOKEN_PATH = "/login/oauth2/token"
+_CANVAS_AUTH_LOGIN_PATH = "/api/lti/authorize_redirect"
+_CANVAS_JWKS_PATH = "/api/lti/security/jwks"
+_CANVAS_API_PATH = "/api/v1"
+
+# Map known SSO-only issuer hostnames to the host that actually serves
+# the Canvas API. Canvas's beta/test/production trios all share an SSO
+# hostname while keeping per-environment API hosts.
+_SSO_HOST_OVERRIDE = {
+    "sso.canvaslms.com": "canvas.instructure.com",
+    "sso.test.canvaslms.com": "canvas.test.instructure.com",
+    "sso.beta.canvaslms.com": "canvas.beta.instructure.com",
+}
+
+
+@dataclass
+class PlatformEndpoints:
+    """Resolved auth + API URLs for one Canvas instance."""
+
+    auth_token_url: str
+    auth_login_url: str
+    jwks_url: str
+    canvas_api_base: str
+    canvas_domain: str
+
+
+@dataclass
+class PlatformInstall:
+    """One Canvas instance that has launched our tool.
+
+    Identity is ``(issuer, client_id, deployment_id)``. Two installs of
+    the same tool at the same Canvas instance (e.g. one at the
+    sub-account level for the College of Engineering, another at the
+    account level for everyone else) get distinct ``deployment_id``s and
+    therefore distinct records.
+
+    ``platform_id`` is a sha256 hash of the identity triple, truncated
+    to 16 hex chars (64 bits of entropy is plenty for collision
+    avoidance across the few-thousand-school deployment we are
+    realistically targeting).
+    """
+
+    # Identity.
+    issuer: str
+    client_id: str
+    deployment_id: str
+
+    # Resolved endpoints.
+    auth_token_url: str
+    auth_login_url: str
+    jwks_url: str
+    canvas_api_base: str
+    canvas_domain: str
+
+    # Optional metadata. ``label`` is human-friendly text for ops
+    # dashboards; ``granted_scopes`` records what the platform actually
+    # approved (populated on first service-token request, Phase 2).
+    label: str | None = None
+    granted_scopes: list[str] = field(default_factory=list)
+
+    # Audit. ISO 8601 strings (not datetimes) so the dataclass survives
+    # round-tripping through json.dumps/loads without custom encoders.
+    first_seen_at: str = ""
+    last_launch_at: str = ""
+
+    # Soft-revocation flag for incident response. When set, the launch
+    # handler rejects new launches but in-flight jobs are not torn down.
+    revoked_at: str | None = None
+
+    @property
+    def platform_id(self) -> str:
+        return compute_platform_id(self.issuer, self.client_id, self.deployment_id)
+
+    def to_json(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> PlatformInstall:
+        # Filter unknown keys so a forward-compatible writer (later
+        # phase adds a new field) does not crash the current reader.
+        known = {f for f in cls.__dataclass_fields__}  # noqa: F841 - clarity
+        kwargs = {k: v for k, v in data.items() if k in cls.__dataclass_fields__}
+        return cls(**kwargs)
+
+
+def compute_platform_id(issuer: str, client_id: str, deployment_id: str) -> str:
+    """Stable hash of the identity triple, 16 hex chars."""
+    blob = f"{issuer}|{client_id}|{deployment_id}".encode("utf-8")
+    return hashlib.sha256(blob).hexdigest()[:16]
+
+
+def derive_endpoints_from_issuer(issuer: str) -> PlatformEndpoints:
+    """Build the Canvas auth + API URLs from a bare issuer claim.
+
+    Most Canvas instances (Instructure-hosted and self-hosted alike)
+    follow the same URL conventions, so a successful launch is enough
+    information to call back. The exception is Instructure's shared SSO
+    issuer hostnames, which front multiple regional API hosts; those
+    are remapped via ``_SSO_HOST_OVERRIDE``.
+
+    Raises ``ValueError`` if the issuer is unparseable. The caller is
+    responsible for guarding against this; in practice the LTI launch
+    handler has already validated the issuer matches the configured
+    expected value before this is called.
+    """
+
+    parsed = urlparse(issuer.strip())
+    if not parsed.scheme or not parsed.netloc:
+        raise ValueError(f"Cannot derive Canvas endpoints: malformed issuer {issuer!r}")
+
+    api_host = _SSO_HOST_OVERRIDE.get(parsed.netloc, parsed.netloc)
+    base = f"{parsed.scheme}://{api_host}"
+
+    # The token endpoint is hosted by the SSO domain itself when there
+    # is one; Canvas validates the JWT bearer assertion at the SSO host
+    # and returns a token usable against the API host. Issuers that
+    # don't have a separate SSO host serve the token endpoint from the
+    # same origin as the API.
+    token_host = parsed.netloc
+    token_base = f"{parsed.scheme}://{token_host}"
+
+    return PlatformEndpoints(
+        auth_token_url=f"{token_base}{_CANVAS_TOKEN_PATH}",
+        auth_login_url=f"{token_base}{_CANVAS_AUTH_LOGIN_PATH}",
+        jwks_url=f"{token_base}{_CANVAS_JWKS_PATH}",
+        canvas_api_base=f"{base}{_CANVAS_API_PATH}",
+        canvas_domain=api_host,
+    )
+
+
+def now_iso() -> str:
+    """Timestamp string for the audit fields. UTC, no microseconds."""
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def build_install_from_launch(
+    *,
+    issuer: str,
+    client_id: str,
+    deployment_id: str,
+    label: str | None = None,
+) -> PlatformInstall:
+    """Construct a fresh ``PlatformInstall`` from launch claims.
+
+    ``first_seen_at`` and ``last_launch_at`` are both set to now; the
+    store layer overwrites ``first_seen_at`` with the existing value
+    if a record already exists for this identity.
+    """
+
+    endpoints = derive_endpoints_from_issuer(issuer)
+    ts = now_iso()
+    return PlatformInstall(
+        issuer=issuer,
+        client_id=client_id,
+        deployment_id=deployment_id,
+        auth_token_url=endpoints.auth_token_url,
+        auth_login_url=endpoints.auth_login_url,
+        jwks_url=endpoints.jwks_url,
+        canvas_api_base=endpoints.canvas_api_base,
+        canvas_domain=endpoints.canvas_domain,
+        label=label,
+        granted_scopes=[],
+        first_seen_at=ts,
+        last_launch_at=ts,
+        revoked_at=None,
+    )
diff --git a/src/lti/platform_store.py b/src/lti/platform_store.py
new file mode 100644
index 0000000..8e1263e
--- /dev/null
+++ b/src/lti/platform_store.py
@@ -0,0 +1,325 @@
+"""Redis-backed storage for ``PlatformInstall`` records.
+
+Key layout::
+
+  eq-pdf:lti:platform:{platform_id}        Hash → JSON payload
+  eq-pdf:lti:platforms                     Set  → all known platform_ids
+  eq-pdf:lti:platform:by-issuer:{issuer}   Set  → platform_ids at that issuer
+
+The by-issuer index lets future ops tooling enumerate "every platform
+installed at canvas.csueastbay.edu" without scanning every record. Right
+now (Phase 1) it's just maintained for future use; nothing reads it
+yet.
+
+Upsert semantics: ``put_platform`` always preserves ``first_seen_at``
+from the existing record if one exists. Everything else (endpoints,
+label, last_launch_at) is overwritten with the incoming values - the
+expectation is that the LTI launch handler always knows the most
+current truth.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from redis.asyncio import Redis
+
+from ..canvas.tenant import tk
+from .platform import PlatformInstall, compute_platform_id, now_iso
+
+logger = logging.getLogger(__name__)
+
+# Phase 1 stores platforms at the deployment-level prefix (not yet a
+# per-tenant prefix). That arrives in Phase 7 when ``tk()`` learns to
+# take a platform. For now the records ARE the source of truth for
+# tenancy, so they live at the unscoped namespace.
+PLATFORM_KEY = tk("lti:platform:{platform_id}")
+PLATFORMS_INDEX_KEY = tk("lti:platforms")
+BY_ISSUER_KEY = tk("lti:platform:by-issuer:{issuer_hash}")
+
+
+def _issuer_hash(issuer: str) -> str:
+    """Stable per-issuer key segment.
+
+    Hashing avoids Redis-unsafe characters and bounds the key length.
+    Same scheme as ``compute_platform_id`` but with only the issuer.
+    """
+    import hashlib
+
+    return hashlib.sha256(issuer.encode("utf-8")).hexdigest()[:16]
+
+
+async def put_platform(redis: Redis, install: PlatformInstall) -> PlatformInstall:
+    """Upsert a platform record. Returns the persisted instance.
+
+    If an existing record is present, its ``first_seen_at`` is
+    preserved and the returned object reflects that. Caller-supplied
+    ``last_launch_at`` is taken as authoritative.
+    """
+
+    pid = install.platform_id
+    existing = await get_platform(redis, pid)
+    if existing is not None:
+        # Preserve first-seen and any prior granted_scopes that the
+        # incoming record does not declare. The launch JWT does not
+        # carry granted-scope information, so a fresh install record
+        # constructed from a launch always has an empty list - we must
+        # not let that wipe a scope set discovered later by Phase 2.
+        install.first_seen_at = existing.first_seen_at or install.first_seen_at
+        if not install.granted_scopes and existing.granted_scopes:
+            install.granted_scopes = existing.granted_scopes
+        # Preserve a soft-revocation marker if one is in place. Lifting
+        # a revocation should be an explicit ops action, not something
+        # a routine launch can do by accident.
+        if existing.revoked_at and not install.revoked_at:
+            install.revoked_at = existing.revoked_at
+
+        # Preserve an institutional canvas_api_base / canvas_domain when
+        # the existing record disagrees with the SSO-derived default.
+        # The disagreement comes from one of:
+        #   * An operator override via fix_platform_host.
+        #   * A launch JWT that carried a $Canvas.api.domain custom claim.
+        # Either way, we do NOT want a subsequent launch (which lacks the
+        # custom claim because the dev key's custom_fields list was set
+        # before we added canvas_api_domain) to silently roll back to the
+        # SSO host. The SSO host is correct for token mints but wrong
+        # for the data API and the user-OAuth authorize page.
+        def _host_of(url: str) -> str:
+            try:
+                from urllib.parse import urlparse
+                return (urlparse(url).netloc or "").lower()
+            except Exception:
+                return ""
+        existing_host = _host_of(existing.canvas_api_base or "")
+        incoming_host = _host_of(install.canvas_api_base or "")
+        if existing_host and existing_host != incoming_host:
+            install.canvas_api_base = existing.canvas_api_base
+            install.canvas_domain = existing.canvas_domain or existing_host
+
+        # Same preservation for auth_token_url -- when an operator has
+        # pointed token mints at the institutional host (because the
+        # canonical SSO is in maintenance, or because the institution
+        # uses a non-standard auth host), don't let a routine launch
+        # silently roll back to the SSO host.
+        existing_token_host = _host_of(existing.auth_token_url or "")
+        incoming_token_host = _host_of(install.auth_token_url or "")
+        if existing_token_host and existing_token_host != incoming_token_host:
+            install.auth_token_url = existing.auth_token_url
+            install.auth_login_url = existing.auth_login_url or install.auth_login_url
+            install.jwks_url = existing.jwks_url or install.jwks_url
+
+    await redis.set(
+        PLATFORM_KEY.format(platform_id=pid),
+        json.dumps(install.to_json()),
+    )
+    await redis.sadd(PLATFORMS_INDEX_KEY, pid)
+    await redis.sadd(
+        BY_ISSUER_KEY.format(issuer_hash=_issuer_hash(install.issuer)),
+        pid,
+    )
+    logger.info(
+        "platform upsert: platform_id=%s issuer=%s deployment_id=%s",
+        pid, install.issuer, install.deployment_id,
+    )
+    return install
+
+
+async def get_platform(redis: Redis, platform_id: str) -> PlatformInstall | None:
+    raw: Any = await redis.get(PLATFORM_KEY.format(platform_id=platform_id))
+    if raw is None:
+        return None
+    return PlatformInstall.from_json(json.loads(raw))
+
+
+async def get_platform_by_identity(
+    redis: Redis,
+    *,
+    issuer: str,
+    client_id: str,
+    deployment_id: str,
+) -> PlatformInstall | None:
+    """Look up by the full identity triple. Convenience wrapper."""
+    pid = compute_platform_id(issuer, client_id, deployment_id)
+    return await get_platform(redis, pid)
+
+
+async def list_platforms(redis: Redis) -> list[PlatformInstall]:
+    """Return every known platform. For ops/CLI use; not on hot paths."""
+    raw_ids: Any = await redis.smembers(PLATFORMS_INDEX_KEY)
+    if not raw_ids:
+        return []
+    out: list[PlatformInstall] = []
+    for raw in raw_ids:
+        pid = raw.decode() if isinstance(raw, (bytes, bytearray)) else raw
+        record = await get_platform(redis, pid)
+        if record is not None:
+            out.append(record)
+    return out
+
+
+async def list_platforms_by_issuer(redis: Redis, issuer: str) -> list[PlatformInstall]:
+    """All platform records whose issuer claim equals the given URL."""
+    raw_ids: Any = await redis.smembers(
+        BY_ISSUER_KEY.format(issuer_hash=_issuer_hash(issuer))
+    )
+    if not raw_ids:
+        return []
+    out: list[PlatformInstall] = []
+    for raw in raw_ids:
+        pid = raw.decode() if isinstance(raw, (bytes, bytearray)) else raw
+        record = await get_platform(redis, pid)
+        if record is not None:
+            out.append(record)
+    return out
+
+
+async def touch_last_launch(redis: Redis, platform_id: str) -> None:
+    """Bump ``last_launch_at`` without rewriting the rest of the record.
+
+    Cheaper than a full upsert when the launch handler already knows
+    nothing about the platform endpoints has changed. Phase 1 callers
+    use ``put_platform`` so this is provided for future use.
+    """
+    record = await get_platform(redis, platform_id)
+    if record is None:
+        return
+    record.last_launch_at = now_iso()
+    await redis.set(
+        PLATFORM_KEY.format(platform_id=platform_id),
+        json.dumps(record.to_json()),
+    )
+
+
+async def mark_revoked(redis: Redis, platform_id: str, *, when: str | None = None) -> bool:
+    """Mark a platform as soft-revoked. Returns False if not found."""
+    record = await get_platform(redis, platform_id)
+    if record is None:
+        return False
+    record.revoked_at = when or now_iso()
+    await redis.set(
+        PLATFORM_KEY.format(platform_id=platform_id),
+        json.dumps(record.to_json()),
+    )
+    logger.warning("platform revoked: platform_id=%s", platform_id)
+    return True
+
+
+async def clear_revoked(redis: Redis, platform_id: str) -> bool:
+    """Lift a revocation. Returns False if not found."""
+    record = await get_platform(redis, platform_id)
+    if record is None:
+        return False
+    record.revoked_at = None
+    await redis.set(
+        PLATFORM_KEY.format(platform_id=platform_id),
+        json.dumps(record.to_json()),
+    )
+    logger.info("platform revocation cleared: platform_id=%s", platform_id)
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Course <-> platform mapping. Used by the multi-tenant watcher (Phase 5)
+# to know which courses to scan under which platform's credentials. The
+# launch handler populates this on every successful LTI launch.
+# ---------------------------------------------------------------------------
+
+PLATFORM_COURSES_KEY = tk("lti:platform:{platform_id}:courses")
+COURSE_PLATFORM_KEY = tk("lti:course:{course_id}:platform")
+
+
+async def mark_course_seen(redis: Redis, platform_id: str, course_id: str) -> None:
+    """Record that a course on a given platform has launched the tool.
+
+    Two indices kept in sync:
+
+      * ``lti:platform:{pid}:courses`` -- set of course ids on this
+        platform. The watcher iterates this per platform.
+      * ``lti:course:{course_id}:platform`` -- the platform id for a
+        given course. The bridge worker reads this when it needs to
+        construct a service-token client for an existing job that lacks
+        an explicit ``platform_id`` field.
+
+    Idempotent: same course can be marked any number of times, the
+    indices only grow.
+    """
+    if not platform_id or not course_id:
+        return
+    await redis.sadd(PLATFORM_COURSES_KEY.format(platform_id=platform_id), course_id)
+    await redis.set(COURSE_PLATFORM_KEY.format(course_id=course_id), platform_id)
+
+
+async def get_courses_for_platform(redis: Redis, platform_id: str) -> list[str]:
+    """Return the course ids the watcher should scan for this platform."""
+    raw: Any = await redis.smembers(
+        PLATFORM_COURSES_KEY.format(platform_id=platform_id)
+    )
+    if not raw:
+        return []
+    return sorted(
+        (m.decode() if isinstance(m, (bytes, bytearray)) else m) for m in raw
+    )
+
+
+async def get_platform_for_course(redis: Redis, course_id: str) -> str | None:
+    """Look up which platform a course belongs to. Returns None if unknown."""
+    raw: Any = await redis.get(COURSE_PLATFORM_KEY.format(course_id=course_id))
+    if raw is None:
+        return None
+    return raw.decode() if isinstance(raw, (bytes, bytearray)) else str(raw)
+
+
+# ---------------------------------------------------------------------------
+# Course owner mapping. Used by the multi-tenant watcher to pick whose
+# OAuth token authorizes background scans of a given course. The OAuth
+# callback handler claims ownership for the first Instructor-role user
+# who completes consent on a course.
+# ---------------------------------------------------------------------------
+
+COURSE_OWNER_KEY = tk("lti:course:{course_id}:owner")
+
+
+async def claim_course_owner_if_unset(
+    redis: Redis,
+    *,
+    course_id: str,
+    user_id: str,
+) -> bool:
+    """Atomically claim a course owner if none is currently set.
+
+    Returns True if this call assigned the owner, False if one was
+    already assigned by a prior call. Idempotent across calls from the
+    same user.
+
+    Why atomic: two faculty members could complete OAuth consent at
+    nearly the same time and we want the first one (by Redis arrival)
+    to win, not the second one to silently overwrite. Redis ``SET NX``
+    gives us that for free.
+    """
+    if not course_id or not user_id:
+        return False
+    key = COURSE_OWNER_KEY.format(course_id=course_id)
+    # nx=True means "only set if key doesn't exist". TTL omitted -- the
+    # owner record is persistent until explicitly cleared (e.g. when
+    # the faculty member's OAuth token is revoked).
+    set_result = await redis.set(key, user_id, nx=True)
+    return bool(set_result)
+
+
+async def get_course_owner(redis: Redis, course_id: str) -> str | None:
+    """Return the user_id of the course's first owner, or None."""
+    if not course_id:
+        return None
+    raw: Any = await redis.get(COURSE_OWNER_KEY.format(course_id=course_id))
+    if raw is None:
+        return None
+    return raw.decode() if isinstance(raw, (bytes, bytearray)) else str(raw)
+
+
+async def clear_course_owner(redis: Redis, course_id: str) -> None:
+    """Delete a stored owner. Called when their OAuth token is revoked."""
+    if not course_id:
+        return
+    await redis.delete(COURSE_OWNER_KEY.format(course_id=course_id))
diff --git a/src/lti/routes.py b/src/lti/routes.py
new file mode 100644
index 0000000..80cb549
--- /dev/null
+++ b/src/lti/routes.py
@@ -0,0 +1,396 @@
+"""LTI 1.3 HTTP endpoints.
+
+Three stops on the launch dance plus a public config:
+
+  * ``/lti/login``  - Canvas redirects the browser here first (OIDC login).
+  * ``/lti/launch`` - Canvas POSTs the signed id_token; we validate and
+                       redirect into the review UI.
+  * ``/lti/jwks``   - Public key set Canvas uses to verify *our* outgoing
+                       service assertions (LTI Advantage, future use).
+  * ``/lti/config.json`` - Tool config Canvas admin can paste when
+                            registering the Developer Key.
+
+The actual review screens live under ``/canvas/review/*`` (see
+``src.api.canvas_review``); this module only handles the LTI handshake.
+"""
+
+from __future__ import annotations
+
+import logging
+from urllib.parse import urlencode
+
+from fastapi import APIRouter, Depends, Form, HTTPException, Request, status
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse, Response
+from redis.asyncio import Redis
+
+from ..config import settings
+from ..dependencies import get_redis_client
+from .config import get_lti_settings
+from .jwt_validation import LtiValidationError, validate_launch_jwt
+from .keys import jwks_document
+from .platform import build_install_from_launch
+from .platform_store import mark_course_seen, put_platform
+from .session import (
+    SESSION_COOKIE,
+    SessionPayload,
+    StatePayload,
+    new_session_id,
+    new_state_token,
+    put_session,
+    put_state,
+    take_state,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/lti", tags=["lti"])
+
+
+def _require_enabled() -> None:
+    if not get_lti_settings().enabled:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="LTI integration disabled",
+        )
+
+
+@router.post("/login")
+@router.get("/login")
+async def login(
+    request: Request,
+    redis: Redis = Depends(get_redis_client),
+) -> RedirectResponse:
+    """OIDC login initiation.
+
+    Canvas calls this either as GET (with query params) or POST (form
+    body) depending on the placement. Both shapes carry the same fields.
+    """
+
+    _require_enabled()
+    params: dict[str, str] = {}
+    if request.method == "POST":
+        form = await request.form()
+        params = {k: str(v) for k, v in form.items()}
+    else:
+        params = dict(request.query_params)
+
+    iss = params.get("iss", "")
+    login_hint = params.get("login_hint", "")
+    lti_message_hint = params.get("lti_message_hint")
+    target_link_uri = params.get("target_link_uri", "")
+    client_id = params.get("client_id", "")
+
+    cfg = get_lti_settings()
+    if iss != cfg.issuer:
+        logger.warning(
+            "LTI login issuer mismatch: got=%r expected=%r (client_id=%r)",
+            iss, cfg.issuer, client_id,
+        )
+        raise HTTPException(status_code=400, detail="Unknown issuer")
+    if client_id and client_id != cfg.client_id:
+        raise HTTPException(status_code=400, detail="Unexpected client_id")
+
+    state = new_state_token()
+    nonce = new_state_token()
+    payload = StatePayload(
+        nonce=nonce,
+        login_hint=login_hint,
+        lti_message_hint=lti_message_hint,
+        target_link_uri=target_link_uri,
+        issuer=iss,
+        client_id=cfg.client_id,
+    )
+    await put_state(redis, payload)
+
+    # Build the redirect_uri from LTI_PUBLIC_URL when available. The dev
+    # uvicorn doesn't pass --proxy-headers, so request.url_for() builds an
+    # http:// URL behind ngrok/Cloudflare and Canvas rejects the mismatch.
+    public_url = (getattr(settings, "lti_public_url", None) or "").rstrip("/")
+    if public_url:
+        redirect_uri = f"{public_url}/lti/launch"
+    else:
+        redirect_uri = str(request.url_for("lti_launch"))
+
+    query = urlencode(
+        {
+            "scope": "openid",
+            "response_type": "id_token",
+            "response_mode": "form_post",
+            "prompt": "none",
+            "client_id": cfg.client_id,
+            "redirect_uri": redirect_uri,
+            "state": state,
+            "nonce": nonce,
+            "login_hint": login_hint,
+            "lti_message_hint": lti_message_hint or "",
+        }
+    )
+    return RedirectResponse(url=f"{cfg.auth_login_url}?{query}", status_code=302)
+
+
+@router.post("/launch", name="lti_launch")
+async def launch(
+    request: Request,
+    id_token: str = Form(...),
+    state: str = Form(...),
+    redis: Redis = Depends(get_redis_client),
+) -> RedirectResponse:
+    """Receive the signed launch token from Canvas, validate, hand off."""
+
+    _require_enabled()
+    if not state:
+        raise HTTPException(status_code=400, detail="Missing state")
+
+    try:
+        claims = await validate_launch_jwt(id_token)
+    except LtiValidationError as exc:
+        logger.warning("LTI launch validation failed: %s", exc)
+        raise HTTPException(status_code=401, detail="Invalid LTI launch") from exc
+
+    nonce = claims.raw.get("nonce", "")
+    stored = await take_state(redis, nonce) if nonce else None
+    if stored is None:
+        raise HTTPException(status_code=400, detail="Unknown or expired state")
+
+    # Multi-tenant Phase 1: persist a PlatformInstall for this Canvas
+    # instance so Phase 2's service-token client has somewhere to read
+    # endpoint + identity info from. The label comes from the launch's
+    # tool_platform claim when present; otherwise we'll just see the
+    # bare canvas_domain in ops dashboards.
+    install = None  # may stay None if the upsert fails; treated as no-platform below
+    try:
+        tool_platform = claims.raw.get(
+            "https://purl.imsglobal.org/spec/lti/claim/tool_platform", {}
+        )
+        label_parts: list[str] = []
+        for key in ("name", "product_family_code"):
+            v = tool_platform.get(key) if isinstance(tool_platform, dict) else None
+            if v:
+                label_parts.append(str(v))
+        label = " - ".join(label_parts) if label_parts else None
+
+        # Canvas Cloud sends the institution's API hostname via the
+        # canvas_api_domain custom substitution. When present, we override
+        # the SSO-derived canvas_api_base so user-OAuth and data API calls
+        # land on the right host without any manual config.
+        custom = claims.raw.get(
+            "https://purl.imsglobal.org/spec/lti/claim/custom", {}
+        ) or {}
+        api_domain_override = (
+            custom.get("canvas_api_domain") if isinstance(custom, dict) else None
+        )
+
+        install = build_install_from_launch(
+            issuer=claims.issuer,
+            client_id=claims.audience,
+            deployment_id=claims.deployment_id,
+            label=label,
+        )
+        if api_domain_override:
+            host = str(api_domain_override).strip()
+            # Defensive: only accept Canvas-shaped hostnames so a hostile
+            # platform can't redirect our API calls to an attacker.
+            if host.endswith(".instructure.com") or host.endswith(".canvaslms.com"):
+                install.canvas_api_base = f"https://{host}/api/v1"
+                install.canvas_domain = host
+        await put_platform(redis, install)
+        # Tie this course to its platform so the multi-tenant watcher
+        # (Phase 5) knows which credentials to use when scanning it.
+        if claims.course_id:
+            await mark_course_seen(redis, install.platform_id, claims.course_id)
+    except Exception:  # pragma: no cover - never break launches over a registry write
+        logger.exception(
+            "PlatformInstall upsert failed for issuer=%r deployment_id=%r; "
+            "launch continues without registry record",
+            claims.issuer, claims.deployment_id,
+        )
+
+    session_id = new_session_id()
+    await put_session(
+        redis,
+        session_id,
+        SessionPayload(
+            user_id=claims.user_id,
+            user_name=claims.user_name,
+            user_email=claims.user_email,
+            course_id=claims.course_id,
+            roles=claims.roles,
+        ),
+    )
+
+    # Default landing page: the review queue for this course. Honour the
+    # target_link_uri if Canvas told us where to go - UNLESS it points at
+    # our own /lti/launch endpoint (a self-referential loop that happens
+    # when the LTI tool config sets target_link_uri to the launch URL).
+    # In that case fall back to the per-course review page.
+    raw_target = (claims.target_link_uri or "").strip()
+    if raw_target and raw_target.rstrip("/").endswith("/lti/launch"):
+        raw_target = ""
+    next_url = raw_target or f"/canvas/review?course_id={claims.course_id}"
+
+    # Faculty consent / disclaimer gate.
+    from ..canvas.state import get_consent, needs_consent
+
+    consent = await get_consent(redis, claims.user_id)
+    if needs_consent(consent):
+        from urllib.parse import quote
+        next_url = f"/canvas/consent?next={quote(next_url, safe='')}"
+
+    # Phase 8: Canvas OAuth2 user-token gate. Canvas Cloud's general
+    # REST API requires per-user OAuth-issued tokens (not LTI Advantage
+    # service tokens), so the first time a faculty member launches the
+    # tool we send them through Canvas's consent screen before letting
+    # them reach the review UI. Subsequent launches see a stored token
+    # and skip the redirect. Tokens auto-refresh on use.
+    existing_user_token = None
+    if install is not None:
+        try:
+            from ..canvas.user_oauth import get_user_token
+
+            existing_user_token = await get_user_token(
+                redis, install.platform_id, claims.user_id,
+            )
+        except Exception:
+            existing_user_token = None
+    if install is not None and existing_user_token is None:
+        from urllib.parse import quote
+        # After OAuth consent, the user will be at top-level (we broke
+        # out of Canvas's iframe to do consent). Bouncing back to a
+        # Reflow path like /canvas/review would render outside Canvas's
+        # UI shell. Send them to the Canvas course URL instead so
+        # Canvas re-renders with its nav, and they click the Reflow
+        # tool a second time -- now with a stored user_token so the
+        # OAuth gate is skipped and the launch goes straight to the
+        # review UI in the iframe.
+        canvas_return = (
+            f"https://{install.canvas_domain}/courses/{claims.course_id}"
+            if install.canvas_domain and claims.course_id
+            else next_url
+        )
+        next_url = (
+            f"/canvas/oauth/authorize?return_url={quote(canvas_return, safe='')}"
+        )
+
+    resp = RedirectResponse(url=next_url, status_code=302)
+    resp.set_cookie(
+        SESSION_COOKIE,
+        session_id,
+        max_age=8 * 3600,
+        httponly=True,
+        secure=True,
+        samesite="none",
+    )
+    return resp
+
+
+@router.get("/jwks")
+async def jwks() -> JSONResponse:
+    """Public JWKS document Canvas fetches to verify our assertions."""
+
+    _require_enabled()
+    return JSONResponse(jwks_document())
+
+
+@router.get("/config.json")
+async def tool_config(request: Request) -> JSONResponse:
+    """JSON config an admin pastes when creating a Developer Key.
+
+    Canvas's "Paste JSON" flow expects this exact shape. See
+    https://canvas.instructure.com/doc/api/file.lti_dev_key_config.html.
+    """
+
+    _require_enabled()
+    base = str(request.base_url).rstrip("/")
+    return JSONResponse(
+        {
+            "title": "Equalify Reflow - Accessible Documents",
+            "description": (
+                "Automatically converts PDFs uploaded to Canvas into "
+                "accessible, reflowable Canvas Pages."
+            ),
+            "oidc_initiation_url": f"{base}/lti/login",
+            "target_link_uri": f"{base}/canvas/review",
+            "scopes": [
+                # Service-account scopes the watcher + bridge need. Each
+                # one is admin-approved when the Developer Key is created
+                # and is part of every client-credentials token request.
+                # Order is alphabetical inside each group for stability.
+                #
+                # Canvas data API:
+                "url:GET|/api/v1/courses/:course_id/files",
+                "url:GET|/api/v1/courses/:course_id/folders",
+                "url:GET|/api/v1/courses/:course_id/modules",
+                "url:GET|/api/v1/courses/:course_id/modules/:module_id/items",
+                "url:GET|/api/v1/courses/:course_id/pages",
+                "url:GET|/api/v1/courses/:course_id/pages/:url_or_id",
+                "url:GET|/api/v1/courses/:course_id/discussion_topics",
+                "url:GET|/api/v1/courses/:course_id/discussion_topics/:topic_id/entries",
+                "url:GET|/api/v1/courses/:course_id/assignments",
+                "url:GET|/api/v1/courses/:course_id/quizzes",
+                "url:GET|/api/v1/files/:id",
+                "url:GET|/api/v1/folders/:id/files",
+                "url:POST|/api/v1/courses/:course_id/pages",
+                "url:PUT|/api/v1/courses/:course_id/pages/:url_or_id",
+                "url:POST|/api/v1/conversations",
+                #
+                # LTI Advantage standard scopes (NRPS + AGS pre-warming
+                # for Batch 6). Granted same Developer Key checkbox.
+                "https://purl.imsglobal.org/spec/lti-nrps/scope/contextmembership.readonly",
+                "https://purl.imsglobal.org/spec/lti-ags/scope/lineitem.readonly",
+            ],
+            "extensions": [
+                {
+                    "domain": request.url.hostname or "",
+                    "tool_id": "equalify-reflow",
+                    "platform": "canvas.instructure.com",
+                    "settings": {
+                        "text": "Accessible Documents",
+                        "placements": [
+                            {
+                                "placement": "course_navigation",
+                                "message_type": "LtiResourceLinkRequest",
+                                "text": "Accessible Documents",
+                                "target_link_uri": f"{base}/canvas/review",
+                                "default": "enabled",
+                                "visibility": "members",
+                            }
+                        ],
+                    },
+                }
+            ],
+            "public_jwk_url": f"{base}/lti/jwks",
+            "custom_fields": {
+                "course_id": "$Canvas.course.id",
+                "user_id": "$Canvas.user.id",
+                # Institutional host (e.g. csueb.test.instructure.com). Canvas
+                # Cloud's LTI issuer is the shared SSO host, but the actual
+                # API host is the per-institution subdomain. We capture the
+                # subdomain via this substitution so platform records get the
+                # right URL without manual ops scripts per school.
+                "canvas_api_domain": "$Canvas.api.domain",
+            },
+        }
+    )
+
+
+@router.get("/healthz")
+async def healthz() -> HTMLResponse:
+    """Lightweight check Canvas admins can hit to confirm the tool is up."""
+
+    cfg = get_lti_settings()
+    body = "<h1>LTI tool</h1><p>enabled: {}</p>".format("yes" if cfg.enabled else "no")
+    return HTMLResponse(body)
+
+
+@router.get("/panorama.js")
+async def panorama_js() -> Response:
+    """Serve the Theme-Editor JS bundle that Canvas injects on every page."""
+    from pathlib import Path
+    bundle_path = Path(__file__).resolve().parent.parent / "web" / "canvas_review" / "panorama.js"
+    if not bundle_path.exists():
+        return Response(status_code=404, content="// panorama.js bundle not found")
+    return Response(
+        content=bundle_path.read_text(encoding="utf-8"),
+        media_type="application/javascript",
+        headers={"Cache-Control": "no-cache"},
+    )
diff --git a/src/lti/session.py b/src/lti/session.py
new file mode 100644
index 0000000..281c0f1
--- /dev/null
+++ b/src/lti/session.py
@@ -0,0 +1,107 @@
+"""Short-lived session state for LTI launches, backed by Redis.
+
+The OIDC handshake needs a place to store the ``state`` nonce between the
+``/lti/login`` redirect and the ``/lti/launch`` callback. After launch,
+the validated claims also live here so the review UI can read identity
+without re-validating the JWT on every request.
+
+All keys are namespaced under ``eq-pdf:canvas:`` to match the rest of the
+project's Redis convention.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import secrets
+from dataclasses import asdict, dataclass
+from typing import Any
+
+from redis.asyncio import Redis
+
+from ..canvas.tenant import tk
+
+from .config import get_lti_settings
+
+logger = logging.getLogger(__name__)
+
+STATE_KEY = tk("canvas:state:{nonce}")
+SESSION_KEY = tk("canvas:session:{session_id}")
+SESSION_TTL_SECONDS = 8 * 3600
+
+# Cookie name used to carry the LTI session id between the launch
+# redirect and subsequent panorama/review/oauth endpoints. Lives here
+# so non-routes modules (canvas_oauth, etc.) can import it without
+# pulling in the whole LTI routes module.
+SESSION_COOKIE = "reflow_lti_session"
+
+
+@dataclass
+class StatePayload:
+    """Data persisted across the OIDC redirect."""
+
+    nonce: str
+    login_hint: str
+    lti_message_hint: str | None
+    target_link_uri: str
+    issuer: str
+    client_id: str
+
+
+@dataclass
+class SessionPayload:
+    """Identity established after a successful launch."""
+
+    user_id: str
+    user_name: str | None
+    user_email: str | None
+    course_id: str
+    roles: list[str]
+
+
+def new_state_token() -> str:
+    return secrets.token_urlsafe(32)
+
+
+def new_session_id() -> str:
+    return secrets.token_urlsafe(32)
+
+
+async def put_state(redis: Redis, state: StatePayload) -> None:
+    cfg = get_lti_settings()
+    await redis.set(
+        STATE_KEY.format(nonce=state.nonce),
+        json.dumps(asdict(state)),
+        ex=cfg.state_ttl_seconds,
+    )
+
+
+async def take_state(redis: Redis, nonce: str) -> StatePayload | None:
+    """Read and delete the state — single-use is the whole point."""
+
+    key = STATE_KEY.format(nonce=nonce)
+    raw: Any = await redis.get(key)
+    if raw is None:
+        return None
+    await redis.delete(key)
+    data = json.loads(raw)
+    return StatePayload(**data)
+
+
+async def put_session(redis: Redis, session_id: str, session: SessionPayload) -> None:
+    await redis.set(
+        SESSION_KEY.format(session_id=session_id),
+        json.dumps(asdict(session)),
+        ex=SESSION_TTL_SECONDS,
+    )
+
+
+async def get_session(redis: Redis, session_id: str) -> SessionPayload | None:
+    raw: Any = await redis.get(SESSION_KEY.format(session_id=session_id))
+    if raw is None:
+        return None
+    return SessionPayload(**json.loads(raw))
+
+
+async def drop_session(redis: Redis, session_id: str) -> None:
+    await redis.delete(SESSION_KEY.format(session_id=session_id))
diff --git a/src/main.py b/src/main.py
index 55f6291..5f444d1 100644
--- a/src/main.py
+++ b/src/main.py
@@ -110,6 +110,25 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
         ]
         logger.info("PII and Timeout worker tasks created")
 
+        # Canvas LTI integration — opt-in via LTI_ENABLED. Watcher and
+        # bridge run alongside the existing workers; the same shutdown
+        # event signals all of them.
+        if getattr(settings, "lti_enabled", False):
+            from .workers.canvas_watcher import start_canvas_watcher
+            from .workers.reflow_bridge_worker import start_reflow_bridge
+
+            worker_tasks.append(
+                asyncio.create_task(
+                    start_canvas_watcher(redis_client, shutdown_event=shutdown_event)
+                )
+            )
+            worker_tasks.append(
+                asyncio.create_task(
+                    start_reflow_bridge(redis_client, shutdown_event=shutdown_event)
+                )
+            )
+            logger.info("Canvas watcher and Reflow bridge worker tasks created")
+
     yield
 
     # Shutdown: Graceful shutdown with timeout (only if workers were started)
@@ -180,7 +199,10 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 app.add_middleware(ErrorHandlerMiddleware)  # Catch all errors
 app.add_middleware(RateLimitMiddleware)  # Rate limit before processing
 app.add_middleware(LoggingMiddleware)  # Log all requests
-app.add_middleware(SecurityHeadersMiddleware)  # Frame security
+app.add_middleware(
+    SecurityHeadersMiddleware,
+    canvas_origin=getattr(settings, "canvas_api_url", None) or getattr(settings, "lti_issuer", None) or "",
+)  # Frame security; allows Canvas origin to embed /lti/* in an iframe
 add_cors_middleware(app)  # CORS headers
 
 # Include routers
@@ -196,6 +218,40 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 app.include_router(pipeline_viewer.router)
 logger.info("✅ Pipeline endpoint enabled at /api/v1/pipeline/process")
 
+# Canvas LTI + Panorama overlay endpoints (opt-in via LTI_ENABLED).
+if getattr(settings, "lti_enabled", False):
+    from .api import canvas_consent, canvas_oauth, canvas_panorama, canvas_review
+    from .lti import router as lti_router
+
+    app.include_router(lti_router)
+    app.include_router(canvas_review.router)
+    app.include_router(canvas_panorama.router)
+    app.include_router(canvas_consent.router)
+    app.include_router(canvas_oauth.router)
+
+    # Also serve the overlay bundle at the ROOT path. Canvas's Theme-Editor
+    # loader references /panorama.js (without the /lti prefix); without this,
+    # that request falls through to the viewer SPA catch-all (registered below)
+    # and 500s when the viewer build is absent, so the overlay never loads.
+    # Mirrors GET /lti/panorama.js. Registered here — before the catch-all — so
+    # it claims the path.
+    @app.get("/panorama.js", include_in_schema=False)
+    async def panorama_js_root():  # noqa: ANN202
+        from pathlib import Path as _Path
+
+        from fastapi import Response as _Response
+
+        bundle = _Path(__file__).resolve().parent / "web" / "canvas_review" / "panorama.js"
+        if not bundle.exists():
+            return _Response(status_code=404, content="// panorama.js bundle not found")
+        return _Response(
+            content=bundle.read_text(encoding="utf-8"),
+            media_type="application/javascript",
+            headers={"Cache-Control": "no-cache"},
+        )
+
+    logger.info("✅ Canvas LTI + Panorama + Consent endpoints enabled")
+
 # Conditionally import dev-only endpoints (only in development)
 if settings.environment == "dev":
     from .api import minimal_pipeline
diff --git a/src/middleware/cors.py b/src/middleware/cors.py
index fb5f5a4..5b9ecf0 100644
--- a/src/middleware/cors.py
+++ b/src/middleware/cors.py
@@ -1,29 +1,118 @@
-"""CORS configuration."""
+"""CORS configuration.
+
+The Canvas Theme-JS overlay runs from a Canvas hostname (e.g.
+``canvas.example.edu``) and needs to call Reflow at a different origin
+(e.g. ``reflow.example.edu`` or an ngrok dev tunnel). Some endpoints
+need credentials (``/canvas/panorama/approve`` carries the LTI session
+cookie); others don't (``/canvas/panorama/scored_files`` is anonymous).
+
+Per the CORS spec, ``allow_origins=["*"]`` and ``allow_credentials=True``
+are mutually exclusive. To support both we use ``allow_origin_regex``
+that matches whichever hostnames the operator configures. For
+credential-less fetches the regex still produces an echo, so they keep
+working.
+
+Portability
+-----------
+There is no campus-specific allow-list baked in. Operators choose which
+hostnames are trusted via one of two settings:
+
+  * ``canvas_allowed_origin_regex`` (env: ``CANVAS_ALLOWED_ORIGIN_REGEX``) -
+    a regex of fully-qualified origins.
+  * ``canvas_allowed_origins`` (env: ``CANVAS_ALLOWED_ORIGINS``) - a
+    comma-separated list of literal origins, e.g.
+    ``https://canvas.example.edu,https://example.instructure.com``.
+
+The regex takes precedence when both are set. The default
+(``DEFAULT_CANVAS_REGEX``) covers only the universal Canvas
+``*.instructure.com`` domain and ngrok dev tunnels - every campus host
+is opt-in via configuration. This makes the codebase deployable at any
+institution without touching the source.
+"""
+
+from __future__ import annotations
+
+import re
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
+from ..config import settings
 
-def add_cors_middleware(app: FastAPI) -> None:
+
+# Out-of-the-box, trust only the universal Canvas cloud hostname and
+# ngrok dev tunnels. Any campus-specific hostname must be added by the
+# operator via CANVAS_ALLOWED_ORIGIN_REGEX or CANVAS_ALLOWED_ORIGINS.
+DEFAULT_CANVAS_REGEX = (
+    r"^https://("
+    r"([a-z0-9-]+\.)+instructure\.com"
+    r"|([a-z0-9-]+\.)+ngrok-free\.dev"
+    r"|([a-z0-9-]+\.)+ngrok\.io"
+    r")$"
+)
+
+
+def _build_regex_from_origins(origins):
+    """Turn a list of literal origins into a single anchored regex.
+
+    Each origin is regex-escaped so URL characters (dots especially) are
+    matched literally rather than as "any char". The result is the union
+    of all entries, anchored so it doesn't accept substrings.
     """
-    Add CORS middleware to FastAPI app.
+    escaped = [re.escape(o.strip()) for o in origins if o.strip()]
+    if not escaped:
+        return ""
+    return r"^(?:" + "|".join(escaped) + r")$"
+
+
+def _resolve_origin_regex():
+    """Pick the right regex based on settings.
 
-    Args:
-        app: FastAPI application instance
+    Precedence (first non-empty wins):
+      1. canvas_allowed_origin_regex - explicit operator override.
+      2. canvas_allowed_origins - comma-separated literal origins
+         compiled into a regex.
+      3. DEFAULT_CANVAS_REGEX - instructure.com + ngrok dev tunnels.
     """
+    explicit_regex = (getattr(settings, "canvas_allowed_origin_regex", "") or "").strip()
+    if explicit_regex:
+        return explicit_regex
+
+    raw_list = (getattr(settings, "canvas_allowed_origins", "") or "").strip()
+    if raw_list:
+        origins = [o.strip() for o in raw_list.split(",") if o.strip()]
+        compiled = _build_regex_from_origins(origins)
+        if compiled:
+            return compiled
+
+    return DEFAULT_CANVAS_REGEX
+
+
+def add_cors_middleware(app: FastAPI) -> None:
+    """Wire CORS so the Canvas overlay can call Reflow with or without
+    credentials. Origins matching the configured regex are echoed with
+    credentials allowed; nothing else gets cross-origin access at all."""
+
+    origin_regex = _resolve_origin_regex()
+
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=["*"],  # Configure appropriately for production
+        allow_origin_regex=origin_regex,
         allow_credentials=True,
         allow_methods=["*"],
-        # Explicit headers required when allow_credentials=True (wildcards don't work)
         allow_headers=[
             "Content-Type",
             "Authorization",
             "X-API-Key",
             "X-Request-ID",
+            # Required for the panorama overlay's state-changing POSTs
+            # (approve / reject / request-edits / edit / pii-decision).
+            # Without it the browser's CORS preflight strips the header
+            # and the cross-origin POST fails with "Failed to fetch".
+            "X-CSRF-Token",
             "Accept",
             "Origin",
             "Cache-Control",
+            "ngrok-skip-browser-warning",
         ],
     )
diff --git a/src/web/canvas_review/dashboard.html b/src/web/canvas_review/dashboard.html
new file mode 100644
index 0000000..2c18e6b
--- /dev/null
+++ b/src/web/canvas_review/dashboard.html
@@ -0,0 +1,88 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Course accessibility dashboard</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { font-family: system-ui, sans-serif; margin: 2rem auto; max-width: 72rem; padding: 0 1rem; }
+  h1 { font-size: 1.4rem; margin-bottom: 0.5rem; }
+  .summary { display: flex; gap: 2rem; align-items: center; margin: 1rem 0 2rem; }
+  .ring { width: 8rem; height: 8rem; }
+  table { width: 100%; border-collapse: collapse; }
+  th, td { padding: 0.5rem 0.75rem; border-bottom: 1px solid #ddd; text-align: left; }
+  .pill { display: inline-block; padding: 0.1rem 0.5rem; border-radius: 999px; color: #fff; font-size: 0.8rem; }
+  .sev-red { background: #b00020; }
+  .sev-amber { background: #b06b00; }
+  .sev-green { background: #2e7d32; }
+  .sev-dark-green { background: #155724; }
+</style>
+</head>
+<body>
+  <h1>Course accessibility</h1>
+  <p>Course: <code>{{ course_id }}</code></p>
+
+  <div class="summary">
+    <svg class="ring" viewBox="0 0 36 36" aria-label="Course average accessibility score">
+      <circle cx="18" cy="18" r="15.9" fill="none" stroke="#eee" stroke-width="3"/>
+      <circle id="ring" cx="18" cy="18" r="15.9" fill="none" stroke="#2e7d32" stroke-width="3"
+              stroke-dasharray="0 100" transform="rotate(-90 18 18)"/>
+      <text id="ring-label" x="18" y="20.5" text-anchor="middle" font-size="6" fill="currentColor">—</text>
+    </svg>
+    <div>
+      <div><strong>Files scanned:</strong> <span id="count">—</span></div>
+      <div><strong>Needs attention:</strong> <span id="red-count">—</span></div>
+    </div>
+  </div>
+
+  <table>
+    <thead>
+      <tr><th>Filename</th><th>Status</th><th>Score</th><th>Action</th></tr>
+    </thead>
+    <tbody id="rows"></tbody>
+  </table>
+
+<script>
+  const courseId = "{{ course_id }}";
+
+  async function load() {
+    const r = await fetch(`/canvas/review/api/pending?course_id=${encodeURIComponent(courseId)}`);
+    const data = r.ok ? await r.json() : { jobs: [] };
+    const ids = data.jobs.map(j => j.canvas_file_id).filter(Boolean);
+    let scores = {};
+    if (ids.length) {
+      const sr = await fetch(`/canvas/panorama/score?course_id=${encodeURIComponent(courseId)}&file_ids=${ids.join(",")}`);
+      if (sr.ok) scores = (await sr.json()).scores || {};
+    }
+
+    let total = 0, scored = 0, red = 0;
+    const tbody = document.getElementById("rows");
+    tbody.innerHTML = "";
+    for (const j of data.jobs) {
+      const s = scores[j.canvas_file_id] || { status: "unscanned" };
+      const score = s.status === "scored" ? s.score : null;
+      const sev = s.status === "scored" ? s.severity : "amber";
+      if (score !== null) { total += score; scored++; if (sev === "red") red++; }
+      const tr = document.createElement("tr");
+      tr.innerHTML = `
+        <td>${escape(j.filename)}</td>
+        <td>${escape(j.status || "—")}</td>
+        <td>${score === null ? "—" : `<span class="pill sev-${sev}">${score}%</span>`}</td>
+        <td><a href="/canvas/review/${encodeURIComponent(j.reflow_job_id)}">Review</a></td>`;
+      tbody.appendChild(tr);
+    }
+
+    const avg = scored ? Math.round(total / scored) : 0;
+    document.getElementById("count").textContent = scored;
+    document.getElementById("red-count").textContent = red;
+    document.getElementById("ring").setAttribute("stroke-dasharray", `${avg} ${100 - avg}`);
+    document.getElementById("ring-label").textContent = scored ? `${avg}%` : "—";
+  }
+  function escape(s) {
+    return String(s).replace(/[&<>"']/g, c => ({"&":"&amp;","<":"&lt;",">":"&gt;","\"":"&quot;","'":"&#39;"}[c]));
+  }
+  load();
+</script>
+</body>
+</html>
diff --git a/src/web/canvas_review/index.html b/src/web/canvas_review/index.html
new file mode 100644
index 0000000..001ca55
--- /dev/null
+++ b/src/web/canvas_review/index.html
@@ -0,0 +1,74 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Accessible Documents — Review</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { font-family: system-ui, sans-serif; margin: 2rem auto; max-width: 64rem; padding: 0 1rem; }
+  h1 { font-size: 1.4rem; margin-bottom: 0.25rem; }
+  p.lede { color: #555; margin-top: 0; }
+  table { width: 100%; border-collapse: collapse; margin-top: 1.5rem; }
+  th, td { text-align: left; padding: 0.5rem 0.75rem; border-bottom: 1px solid #ddd; }
+  th { font-weight: 600; }
+  a.button { display: inline-block; padding: 0.4rem 0.8rem; border: 1px solid #888; border-radius: 4px; text-decoration: none; color: inherit; }
+  .empty { padding: 2rem 0; color: #666; font-style: italic; }
+</style>
+</head>
+<body>
+  <h1>Accessible Documents — Review queue</h1>
+  <p class="lede">Hello, {{ user_name }}. Each row is a PDF that has been converted into a draft Canvas Page. Open one to review it before students see it.</p>
+
+  <div id="status" aria-live="polite"></div>
+  <table id="queue" hidden>
+    <thead>
+      <tr><th>Filename</th><th>Submitted</th><th>Action</th></tr>
+    </thead>
+    <tbody></tbody>
+  </table>
+
+  <p id="empty" class="empty" hidden>Nothing waiting for review. New PDFs you upload will appear here within a few minutes.</p>
+
+<script>
+  const courseId = "{{ course_id }}";
+  const tbody = document.querySelector("#queue tbody");
+  const table = document.getElementById("queue");
+  const empty = document.getElementById("empty");
+  const statusEl = document.getElementById("status");
+
+  async function load() {
+    statusEl.textContent = "Loading…";
+    try {
+      const resp = await fetch(`/canvas/review/api/pending?course_id=${encodeURIComponent(courseId)}`);
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      const data = await resp.json();
+      statusEl.textContent = "";
+      tbody.innerHTML = "";
+      if (!data.jobs.length) {
+        table.hidden = true; empty.hidden = false; return;
+      }
+      table.hidden = false; empty.hidden = true;
+      for (const job of data.jobs) {
+        const tr = document.createElement("tr");
+        const submitted = new Date(job.created_at * 1000).toLocaleString();
+        tr.innerHTML = `
+          <td>${escapeHtml(job.filename)}</td>
+          <td>${submitted}</td>
+          <td><a class="button" href="/canvas/review/${encodeURIComponent(job.reflow_job_id)}">Review</a></td>
+        `;
+        tbody.appendChild(tr);
+      }
+    } catch (err) {
+      statusEl.textContent = `Could not load queue: ${err.message}`;
+    }
+  }
+
+  function escapeHtml(s) {
+    return String(s).replace(/[&<>"']/g, c => ({"&":"&amp;","<":"&lt;",">":"&gt;","\"":"&quot;","'":"&#39;"}[c]));
+  }
+
+  load();
+</script>
+</body>
+</html>
diff --git a/src/web/canvas_review/one.html b/src/web/canvas_review/one.html
new file mode 100644
index 0000000..a5b406c
--- /dev/null
+++ b/src/web/canvas_review/one.html
@@ -0,0 +1,70 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Review — {{ filename }}</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { font-family: system-ui, sans-serif; margin: 0; padding: 0; }
+  header { padding: 1rem 1.5rem; border-bottom: 1px solid #ddd; display: flex; gap: 1rem; align-items: center; flex-wrap: wrap; }
+  header h1 { font-size: 1.1rem; margin: 0; flex: 1 1 auto; }
+  button { padding: 0.5rem 1rem; border-radius: 4px; border: 1px solid #888; cursor: pointer; }
+  button.primary { background: #006633; color: white; border-color: #006633; }
+  button.danger { background: white; color: #a00; border-color: #a00; }
+  main { display: grid; grid-template-columns: 1fr 1fr; min-height: calc(100vh - 4rem); }
+  iframe { width: 100%; height: 100%; border: 0; }
+  .pane { border-right: 1px solid #ddd; overflow: auto; padding: 1rem 1.5rem; }
+  .pane:last-child { border-right: 0; }
+  h2 { font-size: 0.95rem; text-transform: uppercase; letter-spacing: 0.04em; color: #555; margin-top: 0; }
+  #status { padding: 0.5rem 1.5rem; color: #444; min-height: 1.5rem; }
+</style>
+</head>
+<body>
+  <header>
+    <h1>{{ filename }}</h1>
+    <button class="primary" id="approve">Approve &amp; publish</button>
+    <button class="danger" id="reject">Reject</button>
+  </header>
+  <div id="status" aria-live="polite"></div>
+  <main>
+    <section class="pane">
+      <h2>Original PDF</h2>
+      <p>Open the original in Canvas if you want to compare side-by-side: it lives in Course Files.</p>
+    </section>
+    <section class="pane">
+      <h2>Proposed accessible page</h2>
+      <iframe id="preview" title="Proposed accessible page preview"></iframe>
+    </section>
+  </main>
+
+<script>
+  const jobId = "{{ job_id }}";
+  const courseId = "{{ canvas_course_id }}";
+  const pageUrl = "{{ canvas_page_url }}";
+  const statusEl = document.getElementById("status");
+
+  if (pageUrl) {
+    document.getElementById("preview").src =
+      `/api/v1/courses/${encodeURIComponent(courseId)}/pages/${encodeURIComponent(pageUrl)}/preview`;
+  }
+
+  async function act(action) {
+    statusEl.textContent = action === "approve" ? "Publishing…" : "Rejecting…";
+    try {
+      const resp = await fetch(`/canvas/review/${encodeURIComponent(jobId)}/${action}`, { method: "POST" });
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      statusEl.textContent = action === "approve"
+        ? "Published. Students can now see this page."
+        : "Rejected. The draft has been deleted.";
+      setTimeout(() => { window.location.href = `/canvas/review?course_id=${encodeURIComponent(courseId)}`; }, 1500);
+    } catch (err) {
+      statusEl.textContent = `Failed: ${err.message}`;
+    }
+  }
+
+  document.getElementById("approve").addEventListener("click", () => act("approve"));
+  document.getElementById("reject").addEventListener("click", () => act("reject"));
+</script>
+</body>
+</html>
diff --git a/src/web/canvas_review/panorama.js b/src/web/canvas_review/panorama.js
new file mode 100644
index 0000000..7cf3ed5
--- /dev/null
+++ b/src/web/canvas_review/panorama.js
@@ -0,0 +1,1973 @@
+/*
+ * Equalify Reflow — Panorama-style Canvas overlay.
+ *
+ * Surfaces:
+ *   - Files index rows (data-testid="table-row")
+ *   - Module items wrapping a File
+ *   - Any anchor referencing /files/<id> (Pages, Discussions, Modules, etc.)
+ *
+ * Each PDF gets a circular score dial. Clicking the dial opens the
+ * Alternative Formats Menu modal. Instructors also get an "Edit
+ * Accessible HTML" button that opens an in-modal editor with live
+ * preview; saved edits become the canonical source for every other
+ * format (ePub, audio, plain text, math, translations).
+ */
+(function () {
+  "use strict";
+
+  var SCRIPT = document.currentScript || (function () {
+    var all = document.querySelectorAll('script[src*="/lti/panorama.js"]');
+    return all[all.length - 1] || null;
+  })();
+  var ORIGIN = (function () { if (!SCRIPT) return ""; try { return new URL(SCRIPT.src).origin; } catch (_) { return ""; } })();
+  var INST = (function () { if (!SCRIPT) return ""; try { return new URL(SCRIPT.src).searchParams.get("inst") || ""; } catch (_) { return ""; } })();
+  if (!ORIGIN || !INST) { console.warn("[reflow] panorama.js loaded without origin/inst; aborting"); return; }
+
+  var STATE = { courseId: null, userRole: null, scoresByFilename: null, csrfToken: null, oauth: null };
+  // File extensions Reflow can process. Mirrors the watcher's _CONVERTIBLE_EXTS
+  // on the backend so the dial appears on the same set of files. Add new
+  // formats here when the backend learns to handle them.
+  var CONVERTIBLE_EXT_RE = /\.(pdf|docx|doc|pptx|ppt|html|htm|epub)$/i;
+  var FILE_HREF_RE = /\/files\/(\d+)(?:[\/?#"']|$)/;
+  // The accessible-version link inside a published Canvas Page points at the
+  // tool endpoint ``/canvas/panorama/alt/<job_id>/<fmt>``. We decorate it with
+  // the OUTPUT (WCAG) score — the "after" — distinct from the source-PDF dial.
+  var ACCESSIBLE_HREF_RE = /\/canvas\/panorama\/alt\/([^\/?#]+)\//;
+  // Sent on every backend fetch. The ngrok-skip header bypasses ngrok's
+  // free-tier browser interstitial — without it, ngrok returns an HTML warning
+  // page instead of our JSON/HTML and the overlay's fetches fail to parse
+  // (dials disappear). Harmless on Cloudflare/other hosts (ignored), so it's
+  // safe to always send.
+  var BACKEND_HEADERS = { "ngrok-skip-browser-warning": "1" };
+  var COLORS = { "red": "#b00020", "amber": "#cc7a00", "green": "#2e7d32",
+                 "dark-green": "#155724", "unscanned": "#9aa0a6" };
+
+  // Catalogue of formats the modal shows. live=true means the backend
+  // is wired; the rest are visible-but-disabled placeholders.
+  var FORMATS = [
+    { id: "source", label: "Source File", icon: "📄", color: "#0a5fb5", live: true },
+    { id: "html", label: "Accessible HTML", icon: "🌐", color: "#0a5fb5", live: true },
+    { id: "html-math", label: "HTML with Math", icon: "∑", color: "#5b3da6", live: true },
+    { id: "txt", label: "Plain Text", icon: "🅣", color: "#2e7d32", live: true },
+    { id: "markdown", label: "Markdown", icon: "📝", color: "#1d1d1d", live: true },
+    { id: "epub", label: "ePub", icon: "📚", color: "#0e7a8a", live: true },
+    { id: "audio", label: "Audio (MP3)", icon: "🎧", color: "#2e7d32", live: true },
+    { id: "translate", label: "Translate…", icon: "🌐", color: "#2e7d32", live: true, picker: "language" },
+    { id: "ocr", label: "Searchable PDF", icon: "🔎", color: "#cc7a00", live: true },
+    { id: "immersive", label: "Immersive Reader", icon: "👁", color: "#5b3da6", live: true },
+    { id: "braille", label: "Braille (BRF)", icon: "⠿", color: "#5b3da6", live: true }
+  ];
+
+  // Language options for the Translate dialog. Covers CSUEB's largest
+  // non-English-speaking communities plus globally common languages.
+  var TRANSLATE_LANGUAGES = [
+    { code: "es", label: "Spanish (Español)" },
+    { code: "zh", label: "Chinese (中文)" },
+    { code: "vi", label: "Vietnamese (Tiếng Việt)" },
+    { code: "tl", label: "Tagalog / Filipino" },
+    { code: "ko", label: "Korean (한국어)" },
+    { code: "ja", label: "Japanese (日本語)" },
+    { code: "ar", label: "Arabic (العربية)" },
+    { code: "hi", label: "Hindi (हिन्दी)" },
+    { code: "fr", label: "French (Français)" },
+    { code: "de", label: "German (Deutsch)" },
+    { code: "pt", label: "Portuguese (Português)" },
+    { code: "it", label: "Italian (Italiano)" },
+    { code: "ru", label: "Russian (Русский)" },
+    { code: "pl", label: "Polish (Polski)" },
+    { code: "tr", label: "Turkish (Türkçe)" },
+    { code: "fa", label: "Persian / Farsi (فارسی)" },
+    { code: "ur", label: "Urdu (اردو)" },
+    { code: "bn", label: "Bengali (বাংলা)" },
+    { code: "id", label: "Indonesian (Bahasa Indonesia)" },
+    { code: "th", label: "Thai (ไทย)" }
+  ];
+
+  function getEnv() {
+    var env = window.ENV || {};
+    var cid = (env.COURSE && env.COURSE.id) || env.COURSE_ID || env.course_id;
+    if (!cid && typeof env.context_asset_string === "string" && env.context_asset_string.indexOf("course_") === 0) {
+      cid = env.context_asset_string.slice("course_".length);
+    }
+    if (!cid) { var m = location.pathname.match(/\/courses\/(\d+)/); if (m) cid = m[1]; }
+    STATE.courseId = cid ? String(cid) : null;
+    var roles = env.current_user_roles || [];
+    STATE.userRole = (roles.indexOf("teacher") >= 0 || roles.indexOf("ta") >= 0 || roles.indexOf("admin") >= 0)
+      ? "Instructor" : "Student";
+  }
+
+  async function loadScoresByFilename() {
+    if (!STATE.courseId) return {};
+    try {
+      var r = await fetch(
+        ORIGIN + "/canvas/panorama/scored_files?course_id=" + encodeURIComponent(STATE.courseId),
+        { credentials: "omit", headers: BACKEND_HEADERS }
+      );
+      if (!r.ok) return {};
+      var data = await r.json();
+      STATE.scoresByFilename = data.by_filename || {};
+      return STATE.scoresByFilename;
+    } catch (e) { console.warn("[reflow] scored_files failed", e); return {}; }
+  }
+
+  // Fetch the per-session CSRF token bound to the LTI session cookie.
+  // Required header on every state-changing request (approve / reject /
+  // edit / pii-decision). 401 means no session cookie -- fall back to
+  // anonymous behavior; state-changing actions will simply fail.
+  async function loadCsrfToken() {
+    try {
+      var r = await fetch(
+        ORIGIN + "/canvas/panorama/csrf",
+        { credentials: "include", headers: BACKEND_HEADERS }
+      );
+      if (!r.ok) { STATE.csrfToken = null; return null; }
+      var data = await r.json();
+      STATE.csrfToken = data.csrf_token || null;
+      return STATE.csrfToken;
+    } catch (e) {
+      console.warn("[reflow] csrf token fetch failed", e);
+      STATE.csrfToken = null;
+      return null;
+    }
+  }
+
+  // Build the standard set of headers for any state-changing request.
+  // ``Content-Type`` is included because every endpoint accepts JSON.
+  function csrfHeaders() {
+    var h = Object.assign({ "Content-Type": "application/json" }, BACKEND_HEADERS);
+    if (STATE.csrfToken) h["X-CSRF-Token"] = STATE.csrfToken;
+    return h;
+  }
+
+  // Consent / authorization status for the current LTI session.
+  // The actual gate is the LTI launch flow — this is just so the modal
+  // footer can show a "View authorization terms" reminder and surface a
+  // "please authorize" prompt to instructors who never launched the tool.
+  async function loadConsentStatus() {
+    try {
+      var r = await fetch(
+        ORIGIN + "/canvas/consent/status",
+        { credentials: "include", headers: BACKEND_HEADERS }
+      );
+      if (!r.ok) { STATE.consent = { agreed: false, reason: "fetch_failed" }; return STATE.consent; }
+      STATE.consent = await r.json();
+      return STATE.consent;
+    } catch (e) {
+      console.warn("[reflow] consent status fetch failed", e);
+      STATE.consent = { agreed: false, reason: "network_error" };
+      return STATE.consent;
+    }
+  }
+
+  // Canvas-OAuth authorization status for the current LTI session. This is
+  // distinct from consent (terms agreement): it's whether the instructor has
+  // granted Reflow permission to read their files and publish Pages in their
+  // courses. Without it, the watcher/bridge can't act for this instructor,
+  // so we surface an "Authorize Reflow" prompt.
+  async function loadOAuthStatus() {
+    try {
+      var r = await fetch(
+        ORIGIN + "/canvas/panorama/oauth_status",
+        { credentials: "include", headers: BACKEND_HEADERS }
+      );
+      if (!r.ok) { STATE.oauth = { authorized: false, is_instructor: false, has_session: false }; return STATE.oauth; }
+      STATE.oauth = await r.json();
+      return STATE.oauth;
+    } catch (e) {
+      console.warn("[reflow] oauth status fetch failed", e);
+      STATE.oauth = { authorized: false, is_instructor: false, has_session: false };
+      return STATE.oauth;
+    }
+  }
+
+  // Open the Canvas OAuth consent flow in a popup window (instead of a
+  // full-window navigation that yanks the instructor out of their page).
+  // The callback returns a self-closing page that postMessages us back; we
+  // listen for it, refresh status, and re-decorate so the prompt disappears.
+  function openAuthPopup() {
+    var url = ORIGIN + "/canvas/oauth/authorize?popup=1&return_url=" +
+              encodeURIComponent(ORIGIN + "/canvas/oauth/authorized");
+    var w = 600, h = 720;
+    var y = window.top.outerHeight ? Math.max(0, (window.top.outerHeight - h) / 2) : 80;
+    var x = window.top.outerWidth ? Math.max(0, (window.top.outerWidth - w) / 2) : 80;
+    var popup = window.open(
+      url, "reflow_authorize",
+      "width=" + w + ",height=" + h + ",left=" + x + ",top=" + y + ",menubar=no,toolbar=no"
+    );
+    if (!popup) {
+      // Popup blocked — fall back to a new tab so the user isn't stuck.
+      window.open(url, "_blank", "noopener");
+    }
+    return popup;
+  }
+
+  // One-time listener: when the popup reports success, re-check status and
+  // re-scan so badges/prompts update without a page reload.
+  function _installOAuthMessageListener() {
+    if (_installOAuthMessageListener._done) return;
+    _installOAuthMessageListener._done = true;
+    window.addEventListener("message", function (ev) {
+      var d = ev && ev.data;
+      if (!d || d.type !== "reflow-oauth" || !d.ok) return;
+      loadOAuthStatus().then(function () {
+        // Refresh any open modal banner and re-decorate the page.
+        var banner = document.getElementById("reflow-pn-auth-banner");
+        if (banner && STATE.oauth && STATE.oauth.authorized) {
+          banner.outerHTML = "";
+        }
+        try { scheduleScan(); } catch (_) {}
+      });
+    }, false);
+  }
+
+  function fmtConsentDate(epoch) {
+    if (!epoch) return "";
+    try {
+      var d = new Date(epoch * 1000);
+      return d.toLocaleDateString(undefined, { year: "numeric", month: "short", day: "numeric" });
+    } catch (_) { return ""; }
+  }
+
+  function cleanFilename(text) {
+    if (!text) return "";
+    // Canvas prefixes filenames in screen-reader spans by file type:
+    // "PDF File <name>", "Doc File <name>", "Word File <name>", etc.
+    // Strip any "<type> File " or plain "File " prefix so the cleaned
+    // filename matches the API's by_filename keys exactly.
+    return text.trim()
+      .replace(/^(?:PDF|Word|Doc|Document|Excel|Spreadsheet|PowerPoint|Slide|Slides|Image|Audio|Video|Text|HTML|EPub)?\s*File\s+/i, "")
+      .trim();
+  }
+
+  function findFileRows() {
+    var rows = document.querySelectorAll('[data-testid="table-row"]');
+    var out = [];
+    for (var i = 0; i < rows.length; i++) {
+      var row = rows[i];
+      if (row.dataset.reflowDecorated) continue;
+      var spans = row.querySelectorAll("span");
+      var filename = "";
+      var filenameSpan = null;
+      for (var j = 0; j < spans.length; j++) {
+        var t = cleanFilename(spans[j].textContent);
+        if (CONVERTIBLE_EXT_RE.test(t)) {
+          filename = t;
+          filenameSpan = spans[j];
+          break;
+        }
+      }
+      if (!filename) continue;
+      out.push({ row: row, filename: filename, filenameSpan: filenameSpan });
+    }
+    return out;
+  }
+
+  function findModuleFiles() {
+    var items = document.querySelectorAll(
+      'li.context_module_item.type_file, li.context_module_item.File, li.context_module_item[class*="attachment"]'
+    );
+    var out = [];
+    for (var i = 0; i < items.length; i++) {
+      var item = items[i];
+      if (item.dataset.reflowDecorated) continue;
+      var titleEl = item.querySelector('.ig-title, .item_name a, a.title');
+      var filename = titleEl ? titleEl.textContent.trim() : item.textContent.trim().split(/\s{2,}/)[0];
+      if (!filename || !CONVERTIBLE_EXT_RE.test(filename)) continue;
+      out.push({ item: item, filename: filename, anchor: titleEl || item });
+    }
+    return out;
+  }
+
+  function findFileLinkAnchors() {
+    // Anchor surfaces. The first two ``a[href*="/files/"]`` and
+    // ``a.instructure_file_link`` already cover most cases; the rest
+    // explicitly call out surfaces where Canvas's themes/templates use
+    // distinct classes:
+    //
+    //   * ``a.instructure_scribd_file``    -- legacy file preview popup
+    //   * ``a.file_preview_link``          -- newer file preview link
+    //   * ``a.instructure_inline_media_comment[href*="/files/"]``
+    //                                      -- inline media inside pages
+    //   * ``.user_content a[href*="/files/"]``
+    //                                      -- WYSIWYG page bodies
+    //   * ``.assignment_description a[href*="/files/"]``
+    //                                      -- assignment instructions
+    //   * ``.discussion-section a[href*="/files/"]``
+    //                                      -- discussion topics
+    //   * ``.context_module_item a[href*="/files/"]``
+    //                                      -- module item rows
+    //   * ``.attachment a[href*="/files/"]``
+    //                                      -- assignment attachments
+    var selectors = ['a[href*="/files/"]',
+                     'a.instructure_file_link',
+                     'a.instructure_scribd_file',
+                     'a.file_preview_link',
+                     'a.instructure_inline_media_comment[href*="/files/"]',
+                     '.user_content a[href*="/files/"]',
+                     '.assignment_description a[href*="/files/"]',
+                     '.discussion-section a[href*="/files/"]',
+                     '.context_module_item a[href*="/files/"]',
+                     '.attachment a[href*="/files/"]'];
+    var seen = new Set();
+    var out = [];
+    selectors.forEach(function (sel) {
+      var links = document.querySelectorAll(sel);
+      for (var i = 0; i < links.length; i++) {
+        var a = links[i];
+        if (a.dataset.reflowDecorated || seen.has(a)) continue;
+        var href = a.getAttribute("href") || "";
+        var m = href.match(FILE_HREF_RE);
+        if (!m) continue;
+        if (/\/files\/folder\//.test(href)) continue;
+        seen.add(a);
+        out.push({ anchor: a, fileId: m[1] });
+      }
+    });
+
+    // Iframe-embedded PDF previews. Canvas's WYSIWYG inserts iframes
+    // pointing to ``/courses/.../files/<id>/preview`` for inline file
+    // previews. These don't have an ``href`` like an anchor, so we
+    // synthesize a placeholder anchor sibling that the rest of the
+    // overlay can attach to.
+    var iframeSelectors = [
+      'iframe.preview_overlay',
+      'iframe[src*="/files/"][src*="/preview"]',
+      'iframe.preview_iframe',
+    ];
+    iframeSelectors.forEach(function (sel) {
+      var frames = document.querySelectorAll(sel);
+      for (var i = 0; i < frames.length; i++) {
+        var f = frames[i];
+        if (f.dataset.reflowDecorated) continue;
+        var src = f.getAttribute("src") || "";
+        var m = src.match(FILE_HREF_RE);
+        if (!m) continue;
+        // Synthesize an anchor next to the iframe so the existing
+        // button-attachment code path works unchanged.
+        var anchor = document.createElement("a");
+        anchor.href = src;
+        anchor.style.display = "none";
+        anchor.dataset.reflowSynthesized = "1";
+        f.parentNode.insertBefore(anchor, f);
+        f.dataset.reflowDecorated = "1";
+        seen.add(anchor);
+        out.push({ anchor: anchor, fileId: m[1], iframeHost: f });
+      }
+    });
+
+    return out;
+  }
+
+  async function fetchScoresByFileId(fileIds) {
+    if (!STATE.courseId || !fileIds.length) return {};
+    var url = ORIGIN + "/canvas/panorama/score?course_id=" + encodeURIComponent(STATE.courseId)
+            + "&file_ids=" + fileIds.join(",");
+    var r = await fetch(url, { credentials: "omit", headers: BACKEND_HEADERS });
+    if (!r.ok) return {};
+    var data = await r.json();
+    return data.scores || {};
+  }
+
+  // Accessible-version links point at the tool endpoint
+  // ``/canvas/panorama/alt/<job_id>/<fmt>``. Collect them so we can show the
+  // OUTPUT (WCAG) score on the "Open the accessible version" link inside a
+  // published Canvas Page — the empty dial the old file-link path produced.
+  function findAccessibleLinks() {
+    var links = document.querySelectorAll('a[href*="/canvas/panorama/alt/"]');
+    var seen = new Set();
+    var out = [];
+    for (var i = 0; i < links.length; i++) {
+      var a = links[i];
+      if (a.dataset.reflowDecorated || seen.has(a)) continue;
+      // Only decorate accessible links that live in Canvas's own content (the
+      // published Page stub). Our own overlay UI — the formats modal, the
+      // student CTA, the language picker, the editor — is full of
+      // ``/canvas/panorama/alt/…`` links too (every format card is one), and
+      // those must NOT get a dial. All overlay UI uses ``reflow-pn-`` classes,
+      // so an anchor with such an ancestor (or class) is ours; skip it.
+      if (a.closest('[class*="reflow-pn"]')) continue;
+      var href = a.getAttribute("href") || "";
+      var m = href.match(ACCESSIBLE_HREF_RE);
+      if (!m) continue;
+      seen.add(a);
+      out.push({ anchor: a, jobId: decodeURIComponent(m[1]) });
+    }
+    return out;
+  }
+
+  async function fetchScoresByJobId(jobIds) {
+    if (!jobIds.length) return {};
+    var url = ORIGIN + "/canvas/panorama/score_by_job?job_ids=" + jobIds.map(encodeURIComponent).join(",");
+    var r = await fetch(url, { credentials: "omit", headers: BACKEND_HEADERS });
+    if (!r.ok) return {};
+    var data = await r.json();
+    return data.scores || {};
+  }
+
+  // Local mirror of the backend severity buckets, for the rare case a
+  // payload carries a score without its severity.
+  function severityFor(score) {
+    if (typeof score !== "number") return "unscanned";
+    if (score >= 90) return "dark-green";
+    if (score >= 67) return "green";
+    if (score >= 33) return "amber";
+    return "red";
+  }
+
+  // Map a payload to what the row dial should show. The dial decorates the
+  // ORIGINAL PDF in Canvas, so once a file has finished converting it shows
+  // the *source* accessibility estimate (the "before") — that's the number
+  // faculty want next to the original file. The accessible version's WCAG
+  // score (the "after") lives in the modal's report header. Pre-publish and
+  // failure states still take priority and render an action badge so the
+  // call-to-action is never masked by a number.
+  function dialView(payload) {
+    var js = String(payload.job_status || "").toLowerCase();
+    if (js === "awaiting_approval") {
+      return { score: 0, label: "!", color: COLORS.amber, severity: "amber",
+               title: "Privacy review needed — click to approve or deny",
+               aria: "A privacy review is needed before this document can finish converting. Click to approve or deny." };
+    }
+    if (js === "awaiting_review") {
+      return { score: 0, label: "!", color: COLORS.amber, severity: "amber",
+               title: "Needs your review — click to approve",
+               aria: "Needs your review. Click to approve so students can see accessible formats." };
+    }
+    if (js === "processing" || js === "pii_scanning" || js === "processing_queued") {
+      return { score: 0, label: "…", color: COLORS.unscanned, severity: "unscanned",
+               title: "Converting… check back shortly",
+               aria: "Converting. Check back shortly." };
+    }
+    if (js === "page_failed") {
+      // Conversion succeeded but Canvas rejected the page write (usually a
+      // missing Pages permission on the connected account). Actionable, not
+      // a conversion failure — the page rebuilds itself once access is fixed.
+      return { score: 0, label: "!", color: COLORS.amber, severity: "amber",
+               title: "Converted, but the accessible page couldn't be created — click for details",
+               aria: "Conversion succeeded but the Canvas page could not be created. Click for details." };
+    }
+    if (js === "failed" || js === "denied" || js === "rejected") {
+      return { score: 0, label: "!", color: COLORS.red, severity: "red",
+               title: "Conversion needs attention — click for details",
+               aria: "Conversion needs attention. Click for details." };
+    }
+    // Completed.
+    var hasSource = typeof payload.source_score === "number";
+    var hasOutput = payload.status === "scored" && typeof payload.score === "number";
+    // Students never see the raw score (it isn't student-actionable, and a
+    // low "before" estimate on the original PDF would be alarming). Once an
+    // accessible version exists, give them a positive confirmation instead.
+    if (STATE.userRole !== "Instructor") {
+      if (hasSource || hasOutput || js === "published") {
+        return { score: 0, label: "✓", color: COLORS.green, severity: "green",
+                 title: "Accessible version available — open formats",
+                 aria: "Accessible version available. Open Alternative Formats Menu." };
+      }
+    }
+    // Instructors: show the original PDF's source estimate (the "before").
+    if (hasSource) {
+      var ss = payload.source_score;
+      var ssev = payload.source_severity || severityFor(ss);
+      var after = hasOutput
+        ? (" → accessible version " + payload.score + "%")
+        : "";
+      return { score: ss, label: ss + "%", color: COLORS[ssev] || COLORS.red,
+               severity: ssev,
+               title: "Original PDF ~" + ss + "% accessible" + after + " — open Alternative Formats Menu",
+               aria: "Original PDF is about " + ss + " percent accessible"
+                     + (hasOutput ? ("; an accessible version scoring " + payload.score + " percent is available") : "")
+                     + ". Open Alternative Formats Menu." };
+    }
+    // No source estimate (older job without signals): fall back to the
+    // output score, then to a generic "available" / "open" affordance.
+    if (hasOutput) {
+      var sc = payload.score;
+      var sev = payload.severity || severityFor(sc);
+      return { score: sc, label: sc + "%", color: COLORS[sev] || COLORS.red,
+               severity: sev, title: "Accessibility " + sc + "% — open Alternative Formats Menu",
+               aria: "Accessibility " + sc + "%. Open Alternative Formats Menu." };
+    }
+    if (js === "published") {
+      return { score: 0, label: "✓", color: COLORS.green, severity: "green",
+               title: "Accessible version available",
+               aria: "Accessible version available. Open Alternative Formats Menu." };
+    }
+    return { score: 0, label: "—", color: COLORS.unscanned, severity: "unscanned",
+             title: "Open Alternative Formats Menu",
+             aria: "Open Alternative Formats Menu." };
+  }
+
+  // Dial for the ACCESSIBLE-VERSION link (the tool endpoint). This is the
+  // generated output, so it shows the WCAG accessibility score — the "after"
+  // — rather than the original PDF's source estimate. Never shows the source
+  // estimate, and reads positively for both faculty and students.
+  function accessibleDialView(payload) {
+    var hasOutput = payload && payload.status === "scored" && typeof payload.score === "number";
+    if (hasOutput) {
+      var sc = payload.score;
+      var sev = payload.severity || severityFor(sc);
+      return { score: sc, label: sc + "%", color: COLORS[sev] || COLORS.green,
+               severity: sev,
+               title: "Accessible version — WCAG accessibility " + sc + "% (open Alternative Formats Menu)",
+               aria: "Accessible version. WCAG accessibility " + sc + " percent. Open Alternative Formats Menu." };
+    }
+    var js = String((payload && payload.job_status) || "").toLowerCase();
+    if (js === "processing" || js === "pii_scanning" || js === "processing_queued") {
+      return { score: 0, label: "…", color: COLORS.unscanned, severity: "unscanned",
+               title: "Converting… check back shortly",
+               aria: "Converting. Check back shortly." };
+    }
+    if (js === "published" || js === "awaiting_review") {
+      return { score: 0, label: "✓", color: COLORS.green, severity: "green",
+               title: "Accessible version available",
+               aria: "Accessible version available. Open Alternative Formats Menu." };
+    }
+    return { score: 0, label: "✓", color: COLORS.green, severity: "green",
+             title: "Accessible version",
+             aria: "Accessible version. Open Alternative Formats Menu." };
+  }
+
+  // Should we attach a dial for this file? Instructors see every state
+  // (so they can act on drafts/failures); students only see files that
+  // have something usable for them (a score or a published version).
+  function shouldDecorate(payload) {
+    if (!payload) return false;
+    if (STATE.userRole === "Instructor") return true;
+    var js = String(payload.job_status || "").toLowerCase();
+    return payload.status === "scored" || js === "published";
+  }
+
+  function makeDial(payload, filename, opts) {
+    var v = (opts && opts.accessible) ? accessibleDialView(payload) : dialView(payload);
+    var score = v.score;
+    var severity = v.severity;
+    var color = v.color;
+    var label = v.label;
+    var btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "reflow-pn-dial reflow-pn-sev-" + severity;
+    btn.title = v.title;
+    btn.setAttribute("aria-label", v.aria);
+    btn.innerHTML =
+      '<svg viewBox="0 0 36 36" width="34" height="34" aria-hidden="true">' +
+      '  <circle cx="18" cy="18" r="15.9155" fill="none" stroke="#e8eaed" stroke-width="3.2"/>' +
+      '  <circle cx="18" cy="18" r="15.9155" fill="none" stroke="' + color + '" stroke-width="3.2"' +
+      '          stroke-dasharray="' + score + ' ' + (100 - score) + '" stroke-dashoffset="25"' +
+      '          stroke-linecap="round" transform="rotate(-90 18 18)"/>' +
+      '  <text x="18" y="21" text-anchor="middle" font-size="10" font-weight="700" fill="' + color + '">' + label + '</text>' +
+      '</svg>';
+    btn.addEventListener("click", function (e) {
+      e.preventDefault(); e.stopPropagation();
+      openFormatsModal(payload, filename);
+    });
+    return btn;
+  }
+
+  function makeWidgetWrap(payload, filename) {
+    var wrap = document.createElement("span");
+    wrap.className = "reflow-pn-wrap";
+    wrap.appendChild(makeDial(payload, filename));
+    return wrap;
+  }
+
+  function openFormatsModal(payload, filename) {
+    var existing = document.getElementById("reflow-pn-modal");
+    if (existing) existing.remove();
+    var score = payload.status === "scored" ? (payload.score || 0) : null;
+    var severity = payload.severity || "unscanned";
+    var color = COLORS[severity] || COLORS.unscanned;
+
+    var overlay = document.createElement("div");
+    overlay.id = "reflow-pn-modal";
+    overlay.className = "reflow-pn-modal";
+    overlay.setAttribute("role", "dialog");
+    overlay.setAttribute("aria-modal", "true");
+
+    var modal = document.createElement("div");
+    modal.className = "reflow-pn-modal-card";
+    modal.innerHTML =
+      '<header class="reflow-pn-modal-header">' +
+      '  <div class="reflow-pn-modal-titles">' +
+      '    <h2>Alternative Formats Menu</h2>' +
+      '    <p>' + esc(filename || "Document") + (payload.edited ? ' <span class="reflow-pn-edited">edited</span>' : '') + '</p>' +
+      '  </div>' +
+      '  <button class="reflow-pn-modal-close" type="button" aria-label="Close">&times;</button>' +
+      '</header>' +
+      _renderReportHeader(payload, score, color) +
+      _renderCanvasPageBanner(payload) +
+      _renderApprovalBar(payload) +
+      (STATE.userRole === "Instructor"
+        ? '<section class="reflow-pn-modal-tools">' +
+          (payload.job_id ? '  <button class="reflow-pn-edit-btn" type="button">✏️ Edit Accessible HTML</button>' : '') +
+          '  <span class="reflow-pn-tools-hint">Fix tables, math, chemistry — edits become the source for all formats below. Use Save then Publish in the editor when it is ready for students.</span>' +
+          '</section>'
+        : '') +
+      _renderFormatBody(payload) +
+      _renderAuthBanner() +
+      _renderConsentBanner() +
+      '<footer class="reflow-pn-modal-footer">' +
+      _renderConsentFooter() +
+      '  <label class="reflow-pn-switch"><input type="checkbox" checked><span class="reflow-pn-switch-slider"></span></label>' +
+      '</footer>';
+
+    overlay.appendChild(modal);
+    document.body.appendChild(overlay);
+
+    // Phase 13: WCAG 2.1 AA hygiene for the modal itself.
+    // - Remember what was focused so we can restore on close
+    // - Move focus to the first interactive control inside the modal
+    // - Trap Tab/Shift+Tab inside the modal
+    // - Close on Escape; close button is reachable via keyboard
+    var previouslyFocused = document.activeElement;
+    _wcagify_modal(overlay, modal, previouslyFocused);
+
+    // Insert the report dial SVG (instructor-only — students don't get
+    // a score readout because the score is faculty-actionable, not
+    // student-actionable).
+    var dialContainer = modal.querySelector(".reflow-pn-report-dial");
+    if (dialContainer) {
+      dialContainer.innerHTML =
+        '<svg viewBox="0 0 36 36" width="52" height="52" aria-hidden="true">' +
+        '  <circle cx="18" cy="18" r="15.9155" fill="none" stroke="#e8eaed" stroke-width="3.2"/>' +
+        '  <circle cx="18" cy="18" r="15.9155" fill="none" stroke="' + color + '" stroke-width="3.2"' +
+        '          stroke-dasharray="' + (score || 0) + ' ' + (100 - (score || 0)) + '" stroke-dashoffset="25"' +
+        '          stroke-linecap="round" transform="rotate(-90 18 18)"/>' +
+        '  <text x="18" y="21" text-anchor="middle" font-size="9" font-weight="700" fill="' + color + '">' +
+        (score === null ? "—" : (score + "%")) + '</text>' +
+        '</svg>';
+    }
+
+    // Student smart-default primary CTA: wire up the "Open accessible
+    // version" button to the Accessible HTML route for this job.
+    // Faculty-side modal doesn't render this element.
+    var studentPrimary = modal.querySelector(".reflow-pn-student-primary");
+    if (studentPrimary && payload.job_id) {
+      var previewSuffix = (payload.job_status !== "published" && STATE.userRole === "Instructor") ? "?preview=1" : "";
+      studentPrimary.href = ORIGIN + "/canvas/panorama/alt/" + encodeURIComponent(payload.job_id) + "/html" + previewSuffix;
+    }
+
+    // Populate formats grid
+    var grid = modal.querySelector(".reflow-pn-modal-grid");
+    var availableLive = payload.available_formats || ["html", "txt", "markdown"];
+    FORMATS.forEach(function (fmt) {
+      var enabled = fmt.live && (fmt.id === "source"
+                                  || availableLive.indexOf(fmt.id) >= 0
+                                  || fmt.id === "translate"
+                                  || fmt.id === "immersive"
+                                  || fmt.id === "braille"
+                                  || fmt.id === "ocr");
+      var el = document.createElement(enabled ? "a" : "div");
+      el.className = "reflow-pn-fmt-card" + (enabled ? "" : " is-disabled");
+      if (enabled) {
+        if (fmt.picker === "language") {
+          el.href = "#";
+          el.addEventListener("click", function (e) {
+            e.preventDefault();
+            openLanguagePicker(payload);
+          });
+        } else if (fmt.id === "source") {
+          el.href = "#";
+        } else {
+          // If the job hasn't been approved yet, instructors can still preview.
+          // Append ?preview=1 so the backend bypasses the published-only gate.
+          var previewSuffix = (payload.job_status !== "published" && STATE.userRole === "Instructor") ? "?preview=1" : "";
+          el.href = ORIGIN + "/canvas/panorama/alt/" + encodeURIComponent(payload.job_id || "") + "/" + fmt.id + previewSuffix;
+          el.target = "_blank"; el.rel = "noopener";
+        }
+      } else {
+        el.setAttribute("aria-disabled", "true");
+        el.title = "Not yet enabled.";
+      }
+      el.innerHTML =
+        '<span class="reflow-pn-fmt-card-icon" style="background:' + fmt.color + '20;color:' + fmt.color + '">' +
+        fmt.icon + '</span>' +
+        '<span class="reflow-pn-fmt-card-label">' + esc(fmt.label) + '</span>' +
+        (enabled ? "" : '<span class="reflow-pn-fmt-card-soon">soon</span>');
+      grid.appendChild(el);
+    });
+
+    function close() { overlay.remove(); }
+    overlay.addEventListener("click", function (e) { if (e.target === overlay) close(); });
+    modal.querySelector(".reflow-pn-modal-close").addEventListener("click", close);
+
+    // "Authorize Reflow" button (instructors who haven't OAuth'd). Opens the
+    // consent popup; the message listener refreshes status on success.
+    var authBtn = modal.querySelector(".reflow-pn-auth-btn");
+    if (authBtn) {
+      authBtn.addEventListener("click", function (e) {
+        e.preventDefault();
+        _installOAuthMessageListener();
+        openAuthPopup();
+      });
+    }
+
+    // Re-check Claude-API consent on open so the "Authorization required…"
+    // banner disappears for instructors who already accepted — including the
+    // case where they just accepted in the consent tab (opened via the
+    // button) without reloading the page. Also flips the footer to the
+    // "✓ Authorized" line.
+    loadConsentStatus().then(function (c) {
+      if (!c || !c.agreed) return;
+      var cb = modal.querySelector("#reflow-pn-consent-banner");
+      if (cb) cb.remove();
+      var ft = modal.querySelector(".reflow-pn-modal-footer .reflow-pn-footer-text");
+      if (ft) {
+        var when = fmtConsentDate(c.agreed_at);
+        ft.innerHTML = '<span class="reflow-pn-consent-ok" aria-hidden="true">✓</span> ' +
+          'Authorized' + (when ? ' on ' + esc(when) : '') +
+          ' · <a href="' + ORIGIN + '/canvas/consent" target="_blank" rel="noopener">View terms</a>';
+      }
+    }).catch(function () {});
+
+    // Approve / Reject / Request-edits — re-render the modal after a transition
+    // so the badge color and the button set reflect the new state.
+    _wireApprovalActions(modal, payload, function () { close(); openFormatsModal(payload, filename); });
+
+    var editBtn = modal.querySelector(".reflow-pn-edit-btn:not(.reflow-pn-convert-btn)");
+    if (editBtn) {
+      editBtn.addEventListener("click", function () {
+        openHtmlEditor(payload, filename);
+      });
+    }
+
+    // The "refresh accessible page" action now lives in the Edit HTML editor
+    // toolbar (openHtmlEditor, data-act="refresh") instead of a separate
+    // button here — it's a post-edit utility, not a primary modal action.
+
+    document.addEventListener("keydown", function escK(e) {
+      if (e.key === "Escape") {
+        var m = document.getElementById("reflow-pn-modal");
+        var ed = document.getElementById("reflow-pn-editor");
+        if (ed) ed.remove();
+        else if (m) m.remove();
+        document.removeEventListener("keydown", escK);
+      }
+    });
+  }
+
+  // Faculty HTML editor with live preview. Loads canonical HTML from
+  // /edit/{job_id}, lets faculty rewrite it, saves via PUT.
+  async function openHtmlEditor(payload, filename) {
+    var jobId = payload.job_id;
+    if (!jobId) return;
+    var existing = document.getElementById("reflow-pn-editor");
+    if (existing) existing.remove();
+
+    var overlay = document.createElement("div");
+    overlay.id = "reflow-pn-editor";
+    overlay.className = "reflow-pn-editor";
+    overlay.innerHTML =
+      '<div class="reflow-pn-editor-card">' +
+      '  <header>' +
+      '    <div class="reflow-pn-editor-titles">' +
+      '      <h2>Edit Accessible HTML</h2>' +
+      '      <p>' + esc(filename || "Document") + ' <span id="reflow-pn-editor-state"></span></p>' +
+      '    </div>' +
+      '    <button class="reflow-pn-editor-close" type="button" aria-label="Close">&times;</button>' +
+      '  </header>' +
+      '  <div class="reflow-pn-editor-toolbar" role="toolbar" aria-label="Formatting">' +
+      '    <button type="button" data-cmd="bold" title="Bold (Ctrl+B)"><b>B</b></button>' +
+      '    <button type="button" data-cmd="italic" title="Italic (Ctrl+I)"><i>I</i></button>' +
+      '    <button type="button" data-block="H2" title="Heading">H2</button>' +
+      '    <button type="button" data-block="H3" title="Subheading">H3</button>' +
+      '    <button type="button" data-block="P" title="Normal text" aria-label="Normal text">¶</button>' +
+      '    <button type="button" data-cmd="insertUnorderedList" title="Bullet list">• List</button>' +
+      '    <button type="button" data-cmd="insertOrderedList" title="Numbered list">1. List</button>' +
+      '    <button type="button" data-act="link" title="Add a link">🔗 Link</button>' +
+      '    <span class="reflow-pn-editor-toolbar-sep"></span>' +
+      '    <button type="button" data-act="images" class="reflow-pn-editor-toggle" title="Add or fix image descriptions (alt text)">🖼 Image descriptions</button>' +
+      '    <button type="button" data-act="toggle-source" class="reflow-pn-editor-toggle" title="Switch between the visual editor and raw HTML">&lt;/&gt; HTML</button>' +
+      '    <span class="reflow-pn-editor-spacer"></span>' +
+      '    <button type="button" data-act="revert" class="reflow-pn-btn-secondary">Revert to auto</button>' +
+      '    <button type="button" data-act="save" class="reflow-pn-btn-primary">Save</button>' +
+      '    <button type="button" data-act="publish" class="reflow-pn-btn-publish" title="Save your edits and publish — makes this accessible version visible to students in the course">✓ Publish</button>' +
+      '  </div>' +
+      '  <div class="reflow-pn-editor-body">' +
+      '    <div class="reflow-pn-editor-visual" contenteditable="true" role="textbox" aria-multiline="true" aria-label="Document content — type and format directly" spellcheck="true"></div>' +
+      '    <aside class="reflow-pn-editor-alt" hidden aria-label="Image descriptions"></aside>' +
+      '    <div class="reflow-pn-editor-sourcewrap" hidden>' +
+      '      <textarea class="reflow-pn-editor-source" placeholder="Loading…" spellcheck="false"></textarea>' +
+      '      <iframe class="reflow-pn-editor-preview" title="Live preview"></iframe>' +
+      '    </div>' +
+      '  </div>' +
+      '  <footer class="reflow-pn-editor-status"></footer>' +
+      '</div>';
+    document.body.appendChild(overlay);
+
+    var card = overlay.querySelector(".reflow-pn-editor-card");
+    var visual = card.querySelector(".reflow-pn-editor-visual");
+    var altPanel = card.querySelector(".reflow-pn-editor-alt");
+    var sourceWrap = card.querySelector(".reflow-pn-editor-sourcewrap");
+    var textarea = card.querySelector(".reflow-pn-editor-source");
+    var preview = card.querySelector(".reflow-pn-editor-preview");
+    var status = card.querySelector(".reflow-pn-editor-status");
+    var stateEl = card.querySelector("#reflow-pn-editor-state");
+    var sourceMode = false;   // false = visual (contenteditable), true = raw HTML
+    var altOpen = false;
+
+    function setStatus(msg, isErr) {
+      status.textContent = msg;
+      status.className = "reflow-pn-editor-status" + (isErr ? " is-error" : "");
+    }
+    function close() { overlay.remove(); }
+    card.querySelector(".reflow-pn-editor-close").addEventListener("click", close);
+
+    // The HTML we persist. In visual mode it's the contenteditable body
+    // (minus our transient bookkeeping attributes); in source mode the
+    // textarea is authoritative.
+    function getHtml() {
+      if (sourceMode) return textarea.value;
+      var clone = visual.cloneNode(true);
+      clone.querySelectorAll("[data-reflow-img]").forEach(function (el) {
+        el.removeAttribute("data-reflow-img");
+      });
+      return clone.innerHTML;
+    }
+    function setHtml(html) {
+      visual.innerHTML = html || "";
+      textarea.value = html || "";
+    }
+
+    function refreshPreview() {
+      var doc = preview.contentDocument;
+      if (!doc) return;
+      doc.open();
+      doc.write(
+        '<!doctype html><html><head><meta charset="utf-8">' +
+        '<script async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>' +
+        '<style>body{font-family:Georgia,serif;max-width:42rem;margin:1.5rem auto;padding:0 1rem;line-height:1.6;}' +
+        'img{max-width:100%;}table{border-collapse:collapse;width:100%;}th,td{border:1px solid #ccc;padding:0.4rem;}</style>' +
+        '</head><body>' + textarea.value + '</body></html>'
+      );
+      doc.close();
+    }
+
+    // Switch between the visual editor and the raw-HTML pane (which keeps the
+    // live MathJax preview for power users editing math/tables).
+    function setSourceMode(on) {
+      if (on === sourceMode) return;
+      sourceMode = on;
+      var btn = card.querySelector('[data-act="toggle-source"]');
+      if (sourceMode) {
+        textarea.value = getHtml();    // serialise current visual edits
+        refreshPreview();
+        visual.hidden = true; altPanel.hidden = true; sourceWrap.hidden = false;
+        if (btn) { btn.classList.add("is-active"); btn.textContent = "✓ Visual editor"; }
+      } else {
+        visual.innerHTML = textarea.value;   // adopt raw edits back
+        sourceWrap.hidden = true; visual.hidden = false;
+        if (btn) { btn.classList.remove("is-active"); btn.innerHTML = "&lt;/&gt; HTML"; }
+        if (altOpen) { buildAltPanel(); altPanel.hidden = false; }
+      }
+    }
+
+    function toggleAlt() {
+      // Alt editing is tied to the live visual DOM, so leave source mode first.
+      if (sourceMode) setSourceMode(false);
+      altOpen = !altOpen;
+      var btn = card.querySelector('[data-act="images"]');
+      if (altOpen) { buildAltPanel(); altPanel.hidden = false; if (btn) btn.classList.add("is-active"); }
+      else { altPanel.hidden = true; if (btn) btn.classList.remove("is-active"); }
+    }
+
+    // Build the alt-text side panel from the images currently in the document.
+    // Each row edits the matching <img>'s alt attribute live; empty alts are
+    // flagged so faculty can see at a glance what still needs a description.
+    function buildAltPanel() {
+      var imgs = visual.querySelectorAll("img");
+      if (!imgs.length) {
+        altPanel.innerHTML = '<div class="reflow-pn-alt-head"><h3>Image descriptions</h3>' +
+          '<p>This document has no images.</p></div>';
+        return;
+      }
+      var parts = ['<div class="reflow-pn-alt-head"><h3>Image descriptions (alt text)</h3>' +
+        '<p>Describe each image so screen-reader users get the same information. ' +
+        'If an image is purely decorative, mark it decorative so screen readers skip it.</p></div>' +
+        '<ul class="reflow-pn-alt-list">'];
+      Array.prototype.forEach.call(imgs, function (img, i) {
+        img.setAttribute("data-reflow-img", String(i));
+        // Decorative is encoded as role="presentation" + empty alt — the
+        // standard markup that tells assistive tech to ignore the image.
+        var deco = img.getAttribute("role") === "presentation" ||
+                   img.getAttribute("aria-hidden") === "true";
+        var alt = img.getAttribute("alt") || "";
+        var missing = !deco && !alt.trim();
+        var src = img.getAttribute("src") || "";
+        parts.push(
+          '<li class="reflow-pn-alt-item' + (missing ? ' is-missing' : '') +
+          (deco ? ' is-decorative' : '') + '">' +
+          '<img class="reflow-pn-alt-thumb" src="' + esc(src) + '" alt="" loading="lazy" />' +
+          '<div class="reflow-pn-alt-fields">' +
+          '<label for="reflow-pn-alt-' + i + '">Image ' + (i + 1) +
+          (missing ? ' <span class="reflow-pn-alt-flag">needs description</span>' : '') +
+          (deco ? ' <span class="reflow-pn-alt-deco-tag">decorative</span>' : '') + '</label>' +
+          '<textarea id="reflow-pn-alt-' + i + '" class="reflow-pn-alt-input" data-img="' + i +
+          '" rows="2" placeholder="Describe this image…"' + (deco ? ' disabled' : '') + '>' +
+          esc(alt) + '</textarea>' +
+          '<label class="reflow-pn-alt-deco"><input type="checkbox" class="reflow-pn-alt-deco-box" data-img="' +
+          i + '"' + (deco ? ' checked' : '') + '> This image is decorative (skip for screen readers)</label>' +
+          '</div></li>'
+        );
+      });
+      parts.push('</ul>');
+      altPanel.innerHTML = parts.join("");
+
+      function imgFor(idx) { return visual.querySelector('img[data-reflow-img="' + idx + '"]'); }
+
+      altPanel.querySelectorAll(".reflow-pn-alt-input").forEach(function (inp) {
+        inp.addEventListener("input", function () {
+          var target = imgFor(inp.getAttribute("data-img"));
+          if (!target) return;
+          target.setAttribute("alt", inp.value);
+          var li = inp.closest(".reflow-pn-alt-item");
+          if (li && !li.classList.contains("is-decorative")) {
+            li.classList.toggle("is-missing", !inp.value.trim());
+            var flag = li.querySelector(".reflow-pn-alt-flag");
+            if (!inp.value.trim() && !flag) {
+              var lbl = li.querySelector("label[for]");
+              if (lbl) lbl.insertAdjacentHTML("beforeend", ' <span class="reflow-pn-alt-flag">needs description</span>');
+            } else if (inp.value.trim() && flag) {
+              flag.remove();
+            }
+          }
+          setStatus("Unsaved changes — click Save or Publish.");
+        });
+      });
+
+      altPanel.querySelectorAll(".reflow-pn-alt-deco-box").forEach(function (box) {
+        box.addEventListener("change", function () {
+          var target = imgFor(box.getAttribute("data-img"));
+          var li = box.closest(".reflow-pn-alt-item");
+          var inp = li ? li.querySelector(".reflow-pn-alt-input") : null;
+          var lbl = li ? li.querySelector("label[for]") : null;
+          if (!target || !li) return;
+          if (box.checked) {
+            // Mark decorative: empty alt + presentation role, skip warnings.
+            target.setAttribute("alt", "");
+            target.setAttribute("role", "presentation");
+            if (inp) { inp.value = ""; inp.disabled = true; }
+            li.classList.remove("is-missing");
+            li.classList.add("is-decorative");
+            var f = li.querySelector(".reflow-pn-alt-flag");
+            if (f) f.remove();
+            if (lbl && !li.querySelector(".reflow-pn-alt-deco-tag")) {
+              lbl.insertAdjacentHTML("beforeend", ' <span class="reflow-pn-alt-deco-tag">decorative</span>');
+            }
+          } else {
+            // No longer decorative: it needs a real description again.
+            target.removeAttribute("role");
+            if (inp) { inp.disabled = false; inp.focus(); }
+            li.classList.remove("is-decorative");
+            var t = li.querySelector(".reflow-pn-alt-deco-tag");
+            if (t) t.remove();
+            li.classList.add("is-missing");
+            if (lbl && !li.querySelector(".reflow-pn-alt-flag")) {
+              lbl.insertAdjacentHTML("beforeend", ' <span class="reflow-pn-alt-flag">needs description</span>');
+            }
+          }
+          setStatus("Unsaved changes — click Save or Publish.");
+        });
+      });
+    }
+
+    // Toolbar. data-cmd → execCommand inline; data-block → formatBlock;
+    // data-act → editor actions.
+    var debouncePreview = null;
+    textarea.addEventListener("input", function () {
+      clearTimeout(debouncePreview);
+      debouncePreview = setTimeout(refreshPreview, 300);
+    });
+    visual.addEventListener("input", function () {
+      setStatus("Unsaved changes — click Save or Publish.");
+    });
+
+    card.querySelector(".reflow-pn-editor-toolbar").addEventListener("click", function (e) {
+      var b = e.target.closest("button");
+      if (!b) return;
+      var cmd = b.getAttribute("data-cmd");
+      var block = b.getAttribute("data-block");
+      var act = b.getAttribute("data-act");
+      if (cmd) {
+        visual.focus();
+        try { document.execCommand(cmd, false, null); } catch (_) {}
+        return;
+      }
+      if (block) {
+        visual.focus();
+        try { document.execCommand("formatBlock", false, block); } catch (_) {}
+        return;
+      }
+      if (act === "link") {
+        var url = window.prompt("Link address (URL):", "https://");
+        if (url) { visual.focus(); try { document.execCommand("createLink", false, url); } catch (_) {} }
+        return;
+      }
+      if (act === "images") return toggleAlt();
+      if (act === "toggle-source") return setSourceMode(!sourceMode);
+      if (act === "save") return save();
+      if (act === "revert") return revert();
+      if (act === "publish") return publishFromEditor();
+    });
+
+    async function save() {
+      setStatus("Saving…");
+      try {
+        var r = await fetch(ORIGIN + "/canvas/panorama/edit/" + encodeURIComponent(jobId), {
+          method: "PUT",
+          credentials: "include",
+          headers: csrfHeaders(),
+          body: JSON.stringify({ html: getHtml() })
+        });
+        if (!r.ok) throw new Error("HTTP " + r.status);
+        var data = await r.json();
+        setStatus("Saved. Edited HTML is now the source of truth for every format.");
+        stateEl.textContent = data.edited ? " (edited)" : "";
+      } catch (e) { setStatus("Save failed: " + e.message, true); }
+    }
+    async function revert() {
+      if (!confirm("Discard your edits and revert to the auto-generated HTML?")) return;
+      setStatus("Reverting…");
+      try {
+        await fetch(ORIGIN + "/canvas/panorama/edit/" + encodeURIComponent(jobId), {
+          method: "DELETE", credentials: "include", headers: csrfHeaders()
+        });
+        await loadInitial();
+        setStatus("Reverted.");
+        stateEl.textContent = "";
+      } catch (e) { setStatus("Revert failed: " + e.message, true); }
+    }
+    async function publishFromEditor() {
+      setStatus("Saving and publishing…");
+      try {
+        // Save the current edits first, so the published version includes them.
+        var sv = await fetch(ORIGIN + "/canvas/panorama/edit/" + encodeURIComponent(jobId), {
+          method: "PUT", credentials: "include", headers: csrfHeaders(),
+          body: JSON.stringify({ html: getHtml() })
+        });
+        if (!sv.ok) throw new Error("save HTTP " + sv.status);
+        var sd = await sv.json();
+        stateEl.textContent = sd.edited ? " (edited)" : "";
+        // Then publish — makes the accessible version visible to students and
+        // publishes the Canvas Page.
+        var pb = await fetch(ORIGIN + "/canvas/panorama/approve/" + encodeURIComponent(jobId), {
+          method: "POST", credentials: "include", headers: csrfHeaders(),
+          body: JSON.stringify({ comment: null })
+        });
+        if (!pb.ok) {
+          var e = await pb.json().catch(function () { return {}; });
+          var detail = e && e.detail;
+          if (detail && typeof detail === "object") detail = detail.message || JSON.stringify(detail);
+          throw new Error(detail || ("HTTP " + pb.status));
+        }
+        setStatus("Published — students can now see this accessible version.");
+      } catch (e) { setStatus("Publish failed: " + (e && e.message ? e.message : e), true); }
+    }
+
+    async function loadInitial() {
+      setStatus("Loading…");
+      try {
+        var r = await fetch(ORIGIN + "/canvas/panorama/edit/" + encodeURIComponent(jobId),
+                            { credentials: "include", headers: BACKEND_HEADERS });
+        var data = await r.json();
+        setHtml(data.html || "");
+        stateEl.textContent = data.edited ? " (edited)" : "";
+        if (sourceMode) refreshPreview();
+        if (altOpen) buildAltPanel();
+        setStatus(data.edited ? "Loaded your saved edit." : "Loaded auto-generated HTML.");
+      } catch (e) {
+        setStatus("Could not load HTML: " + e.message, true);
+      }
+    }
+
+    loadInitial();
+  }
+
+  function getSelection(ta) {
+    return { start: ta.selectionStart, end: ta.selectionEnd, text: ta.value.slice(ta.selectionStart, ta.selectionEnd) };
+  }
+  function setSelection(ta, start, end, repl) {
+    ta.value = ta.value.slice(0, start) + repl + ta.value.slice(end);
+    ta.focus();
+  }
+
+  function esc(s) {
+    return String(s || "").replace(/[&<>"']/g, function (c) {
+      return { "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;", "'": "&#39;" }[c];
+    });
+  }
+
+  function injectStyles() {
+    if (document.getElementById("reflow-pn-styles")) return;
+    var s = document.createElement("style");
+    s.id = "reflow-pn-styles";
+    s.textContent = [
+      // Row dial
+      ".reflow-pn-wrap{display:inline-flex;align-items:center;font-family:system-ui,-apple-system,Segoe UI,sans-serif;}",
+      ".reflow-pn-wrap.reflow-pn-row{position:absolute;top:50%;right:7.5rem;transform:translateY(-50%);margin:0;z-index:5;}",
+      ".reflow-pn-dial{background:transparent;border:0;padding:0;cursor:pointer;line-height:0;border-radius:50%;transition:transform 120ms,box-shadow 120ms;}",
+      ".reflow-pn-dial:hover{transform:scale(1.08);box-shadow:0 0 0 4px rgba(0,0,0,0.05);}",
+      ".reflow-pn-dial:focus{outline:none;box-shadow:0 0 0 3px rgba(10,95,181,0.4);}",
+      // Modal
+      ".reflow-pn-modal{position:fixed;inset:0;background:rgba(15,20,30,0.55);display:flex;align-items:center;justify-content:center;z-index:99999;font:14px system-ui,sans-serif;color:#1d1d1d;}",
+      ".reflow-pn-modal-card{background:#fff;width:min(40rem,92vw);max-height:88vh;border-radius:10px;box-shadow:0 24px 64px rgba(0,0,0,0.25);display:flex;flex-direction:column;overflow:hidden;}",
+      ".reflow-pn-modal-header{display:flex;align-items:flex-start;justify-content:space-between;padding:1.25rem 1.5rem 0.75rem;border-bottom:1px solid #ececec;}",
+      ".reflow-pn-modal-titles h2{margin:0;font-size:1.05rem;font-weight:700;}",
+      ".reflow-pn-modal-titles p{margin:0.2rem 0 0;color:#666;font-size:0.85rem;}",
+      ".reflow-pn-edited{display:inline-block;background:#fff4cf;color:#8a5a00;border-radius:999px;padding:0 0.45rem;font-size:0.7rem;font-weight:700;margin-left:0.3rem;}",
+      ".reflow-pn-modal-close{background:none;border:0;font-size:1.5rem;cursor:pointer;color:#666;line-height:1;padding:0;margin-left:1rem;}",
+      ".reflow-pn-modal-report{display:flex;align-items:center;justify-content:space-between;padding:0.85rem 1.5rem;border-bottom:1px solid #f3f3f3;background:#fafafa;}",
+      ".reflow-pn-report-text{font-size:0.9rem;font-weight:600;display:flex;align-items:center;gap:0.5rem;}",
+      ".reflow-pn-pill{display:inline-block;padding:0.15rem 0.6rem;border-radius:999px;color:#fff;font-size:0.8rem;font-weight:700;}",
+      ".reflow-pn-pill-grey{background:#9aa0a6;}",
+      ".reflow-pn-pill-ok{background:#2e7d32;}",
+      // Before → after strip: original PDF estimate on the left, accessible
+      // version's WCAG score on the right, with an arrow between.
+      ".reflow-pn-beforeafter{display:inline-flex;align-items:center;gap:0.55rem;}",
+      ".reflow-pn-ba-item{display:inline-flex;flex-direction:column;align-items:center;gap:0.2rem;}",
+      ".reflow-pn-ba-item small{font-size:0.68rem;font-weight:600;color:#5b6573;text-transform:uppercase;letter-spacing:0.02em;}",
+      ".reflow-pn-ba-arrow{font-size:1.1rem;color:#9aa0a6;font-weight:700;}",
+      // Phase 8: Canvas-Page-primary banner. Prominent green CTA
+      // shown above the alt-format grid when an approved Canvas
+      // Page exists for the job.
+      ".reflow-pn-canvas-page-banner{padding:0.85rem 1.25rem;background:#e8f5ec;border-bottom:1px solid #b4dabe;}",
+      ".reflow-pn-canvas-page-link{display:flex;align-items:center;gap:0.85rem;padding:0.7rem 0.95rem;background:#fff;border:1px solid #2e7d32;border-radius:8px;color:#103a1a;text-decoration:none;transition:background 120ms;}",
+      ".reflow-pn-canvas-page-link:hover{background:#dff2e4;}",
+      ".reflow-pn-canvas-page-link:focus{outline:2px solid #2e7d32;outline-offset:2px;}",
+      ".reflow-pn-canvas-page-icon{flex:0 0 auto;font-size:1.4rem;}",
+      ".reflow-pn-canvas-page-text{display:flex;flex-direction:column;gap:0.2rem;}",
+      ".reflow-pn-canvas-page-text strong{font-size:0.95rem;}",
+      ".reflow-pn-canvas-page-text small{font-size:0.78rem;color:#33493b;}",
+      // Student variant of the report strip: no score dial, positive
+      // confirmation copy. Hint text reads as one column under the pill.
+      ".reflow-pn-modal-report--student{flex-direction:column;align-items:flex-start;gap:0.25rem;padding:1rem 1.5rem;}",
+      ".reflow-pn-report-hint{font-size:0.83rem;color:#5b6573;font-weight:400;}",
+      // Student smart-default CTA. Big primary card, then a discreet
+      // ``More formats`` disclosure containing the full grid.
+      ".reflow-pn-student-cta{padding:1rem 1.5rem 0.5rem;display:flex;flex-direction:column;gap:0.75rem;}",
+      ".reflow-pn-student-primary{display:flex;align-items:center;gap:0.9rem;padding:0.95rem 1.1rem;border:1px solid #2e7d32;border-radius:10px;background:#f1f8f4;text-decoration:none;color:#103a1a;transition:background 120ms,box-shadow 120ms,transform 120ms;}",
+      ".reflow-pn-student-primary:hover{background:#e6f3ea;box-shadow:0 2px 8px rgba(46,125,50,0.15);transform:translateY(-1px);}",
+      ".reflow-pn-student-primary:focus{outline:2px solid #2e7d32;outline-offset:2px;}",
+      ".reflow-pn-student-primary-icon{flex:0 0 auto;font-size:1.65rem;line-height:1;}",
+      ".reflow-pn-student-primary-text{display:flex;flex-direction:column;gap:0.15rem;}",
+      ".reflow-pn-student-primary-text strong{font-size:1rem;font-weight:700;}",
+      ".reflow-pn-student-primary-text small{font-size:0.82rem;color:#33493b;font-weight:400;}",
+      ".reflow-pn-more-formats{font-size:0.85rem;}",
+      ".reflow-pn-more-formats > summary{cursor:pointer;color:#0a5fb5;padding:0.25rem 0.4rem;border-radius:4px;list-style:none;font-weight:500;display:inline-flex;align-items:center;gap:0.25rem;}",
+      ".reflow-pn-more-formats > summary::after{content:'▾';font-size:0.7em;}",
+      ".reflow-pn-more-formats[open] > summary::after{content:'▴';}",
+      ".reflow-pn-more-formats > summary:hover{background:#eef4fc;}",
+      ".reflow-pn-more-formats > summary::-webkit-details-marker{display:none;}",
+      ".reflow-pn-more-formats .reflow-pn-modal-grid{padding:0.6rem 0 0.4rem;grid-template-columns:1fr 1fr;}",
+      ".reflow-pn-modal-tools{display:flex;align-items:center;gap:0.6rem;padding:0.7rem 1.5rem;background:#eef4fc;border-bottom:1px solid #cfdcec;font-size:0.85rem;}",
+      ".reflow-pn-edit-btn{background:#0a5fb5;color:#fff;border:0;padding:0.45rem 0.85rem;border-radius:6px;cursor:pointer;font-weight:600;}",
+      ".reflow-pn-edit-btn:hover{background:#084a91;}",
+      ".reflow-pn-tools-hint{color:#444;}",
+      ".reflow-pn-modal-grid{display:grid;grid-template-columns:1fr 1fr;gap:0.55rem;padding:0.9rem 1.5rem;overflow:auto;}",
+      ".reflow-pn-fmt-card{display:flex;align-items:center;gap:0.7rem;padding:0.6rem 0.85rem;border:1px solid #e6e6e6;border-radius:8px;text-decoration:none;color:#1d1d1d;background:#fff;transition:transform 120ms,box-shadow 120ms;}",
+      ".reflow-pn-fmt-card:hover{transform:translateY(-1px);box-shadow:0 2px 8px rgba(0,0,0,0.06);}",
+      ".reflow-pn-fmt-card.is-disabled{opacity:0.45;cursor:not-allowed;pointer-events:none;}",
+      ".reflow-pn-fmt-card-icon{flex:0 0 auto;width:1.9rem;height:1.9rem;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:1rem;}",
+      ".reflow-pn-fmt-card-label{flex:1;font-size:0.88rem;font-weight:500;}",
+      ".reflow-pn-fmt-card-soon{font-size:0.62rem;font-weight:700;text-transform:uppercase;color:#999;background:#f0f0f0;padding:0.12rem 0.4rem;border-radius:999px;}",
+      ".reflow-pn-modal-footer{display:flex;align-items:center;justify-content:space-between;padding:0.7rem 1.5rem;border-top:1px solid #ececec;background:#fafafa;font-size:0.83rem;color:#444;}",
+      ".reflow-pn-switch{position:relative;display:inline-block;width:2.4rem;height:1.35rem;}",
+      ".reflow-pn-switch input{opacity:0;width:0;height:0;}",
+      ".reflow-pn-switch-slider{position:absolute;cursor:pointer;inset:0;background:#ccc;border-radius:999px;transition:background 160ms;}",
+      ".reflow-pn-switch-slider::before{content:'';position:absolute;left:0.15rem;top:0.15rem;width:1.05rem;height:1.05rem;background:#fff;border-radius:50%;transition:transform 160ms;}",
+      ".reflow-pn-switch input:checked + .reflow-pn-switch-slider{background:#2e7d32;}",
+      ".reflow-pn-switch input:checked + .reflow-pn-switch-slider::before{transform:translateX(1.05rem);}",
+      // Editor
+      ".reflow-pn-editor{position:fixed;inset:0;background:rgba(15,20,30,0.6);display:flex;align-items:center;justify-content:center;z-index:100000;font:14px system-ui,sans-serif;}",
+      ".reflow-pn-editor-card{background:#fff;width:min(72rem,95vw);height:min(86vh,52rem);border-radius:10px;display:flex;flex-direction:column;box-shadow:0 30px 80px rgba(0,0,0,0.3);overflow:hidden;}",
+      ".reflow-pn-editor-card header{display:flex;align-items:flex-start;justify-content:space-between;padding:1rem 1.25rem 0.5rem;border-bottom:1px solid #ececec;flex-wrap:wrap;}",
+      ".reflow-pn-editor-card header h2{margin:0;font-size:1.05rem;}",
+      ".reflow-pn-editor-card header p{margin:0.15rem 0 0;color:#666;font-size:0.85rem;}",
+      // Stack the title + filename on the left so the filename doesn't float
+      // in the middle of the header (flex space-between with 3 loose children).
+      ".reflow-pn-editor-titles{display:flex;flex-direction:column;gap:0.1rem;min-width:0;flex:1;}",
+      ".reflow-pn-editor-close{background:none;border:0;font-size:1.5rem;cursor:pointer;color:#666;line-height:1;padding:0;margin-left:1rem;}",
+      ".reflow-pn-editor-toolbar{display:flex;align-items:center;gap:0.35rem;padding:0.55rem 1.25rem;border-bottom:1px solid #ececec;background:#fafafa;}",
+      ".reflow-pn-editor-toolbar button{background:#fff;border:1px solid #d6d8db;padding:0.35rem 0.6rem;border-radius:5px;cursor:pointer;font-weight:600;color:#1d1d1d;}",
+      ".reflow-pn-editor-toolbar button:hover{background:#f0f0f0;}",
+      ".reflow-pn-editor-toolbar-sep{flex:0 0 auto;width:1px;height:1.4rem;background:#d6d8db;margin:0 0.5rem;}",
+      ".reflow-pn-editor-spacer{flex:1;}",
+      ".reflow-pn-btn-primary{background:#0a5fb5 !important;color:#fff !important;border-color:#0a5fb5 !important;}",
+      ".reflow-pn-btn-primary:hover{background:#084a91 !important;}",
+      ".reflow-pn-btn-secondary{color:#a00 !important;}",
+      ".reflow-pn-btn-publish{background:#2e7d32 !important;color:#fff !important;border-color:#2e7d32 !important;}",
+      ".reflow-pn-btn-publish:hover{background:#256527 !important;}",
+      ".reflow-pn-editor-toggle.is-active{background:#e3edf7 !important;border-color:#0a5fb5 !important;color:#0a5fb5 !important;}",
+      // Body is a flex row: the visual editor flexes to fill, the alt panel is
+      // a fixed right rail when open, and the source/preview pane (a 2-col
+      // grid) replaces the visual editor when "HTML" is toggled.
+      ".reflow-pn-editor-body{display:flex;flex:1;min-height:0;}",
+      ".reflow-pn-editor-visual{flex:1;min-width:0;overflow:auto;padding:1.5rem 1.75rem;background:#fff;color:#1d1d1d;font-family:Georgia,'Times New Roman',serif;font-size:1rem;line-height:1.65;outline:none;}",
+      ".reflow-pn-editor-visual:focus{box-shadow:inset 0 0 0 2px rgba(10,95,181,0.18);}",
+      ".reflow-pn-editor-visual h1,.reflow-pn-editor-visual h2,.reflow-pn-editor-visual h3{font-family:system-ui,-apple-system,Segoe UI,sans-serif;line-height:1.25;margin:1.1em 0 0.4em;}",
+      ".reflow-pn-editor-visual p{margin:0 0 0.8em;}",
+      ".reflow-pn-editor-visual img{max-width:100%;height:auto;}",
+      ".reflow-pn-editor-visual table{border-collapse:collapse;width:100%;}",
+      ".reflow-pn-editor-visual th,.reflow-pn-editor-visual td{border:1px solid #ccc;padding:0.4rem;}",
+      // Flag images that still have no alt text right in the editing surface —
+      // but not ones explicitly marked decorative (role=presentation).
+      ".reflow-pn-editor-visual img:not([alt]):not([role='presentation']),.reflow-pn-editor-visual img[alt='']:not([role='presentation']){outline:2px dashed #cc7a00;outline-offset:2px;}",
+      ".reflow-pn-editor-alt{flex:0 0 21rem;overflow:auto;border-left:1px solid #ececec;background:#fafafa;padding:1rem 1.1rem;}",
+      ".reflow-pn-alt-head h3{margin:0 0 0.25rem;font-size:0.95rem;}",
+      ".reflow-pn-alt-head p{margin:0 0 0.85rem;font-size:0.8rem;color:#5b6573;line-height:1.45;}",
+      ".reflow-pn-alt-list{list-style:none;margin:0;padding:0;display:flex;flex-direction:column;gap:0.7rem;}",
+      ".reflow-pn-alt-item{display:flex;gap:0.6rem;padding:0.55rem;border:1px solid #e6e6e6;border-radius:7px;background:#fff;}",
+      ".reflow-pn-alt-item.is-missing{border-color:#cc7a00;background:#fff8ee;}",
+      ".reflow-pn-alt-thumb{flex:0 0 3rem;width:3rem;height:3rem;object-fit:cover;border-radius:4px;background:#eee;border:1px solid #e0e0e0;}",
+      ".reflow-pn-alt-fields{flex:1;min-width:0;display:flex;flex-direction:column;gap:0.3rem;}",
+      ".reflow-pn-alt-fields label{font-size:0.78rem;font-weight:600;color:#1d1d1d;}",
+      ".reflow-pn-alt-flag{color:#cc7a00;font-weight:700;text-transform:uppercase;font-size:0.66rem;letter-spacing:0.02em;}",
+      ".reflow-pn-alt-input{width:100%;box-sizing:border-box;border:1px solid #d6d8db;border-radius:5px;padding:0.4rem;font:inherit;font-size:0.82rem;resize:vertical;}",
+      ".reflow-pn-alt-input:focus{outline:none;border-color:#0a5fb5;box-shadow:0 0 0 2px rgba(10,95,181,0.18);}",
+      ".reflow-pn-alt-input:disabled{background:#f0f0f0;color:#9aa0a6;cursor:not-allowed;}",
+      ".reflow-pn-alt-item.is-decorative{border-color:#c9d3df;background:#f4f7fb;}",
+      ".reflow-pn-alt-deco-tag{color:#5b6573;font-weight:700;text-transform:uppercase;font-size:0.66rem;letter-spacing:0.02em;}",
+      ".reflow-pn-alt-deco{display:flex;align-items:center;gap:0.35rem;font-size:0.75rem;color:#5b6573;font-weight:500;cursor:pointer;}",
+      ".reflow-pn-alt-deco input{margin:0;flex:0 0 auto;}",
+      ".reflow-pn-editor-sourcewrap{flex:1;display:grid;grid-template-columns:1fr 1fr;min-height:0;}",
+      // The class-level display rules above override the plain ``hidden``
+      // attribute's display:none, which left all three panes visible at once.
+      // This higher-specificity rule restores hiding for the toggled panes.
+      ".reflow-pn-editor-visual[hidden],.reflow-pn-editor-alt[hidden],.reflow-pn-editor-sourcewrap[hidden]{display:none !important;}",
+      ".reflow-pn-editor-source{box-sizing:border-box;width:100%;height:100%;border:0;padding:1rem 1.25rem;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:0.85rem;line-height:1.55;letter-spacing:0.01em;tab-size:2;white-space:pre-wrap;resize:none;background:#f8f9fa;color:#1d1d1d;outline:none;border-right:1px solid #ececec;}",
+      ".reflow-pn-editor-preview{box-sizing:border-box;width:100%;height:100%;border:0;}",
+      ".reflow-pn-editor-status{padding:0.55rem 1.25rem;border-top:1px solid #ececec;background:#fafafa;color:#444;font-size:0.83rem;}",
+      ".reflow-pn-editor-status.is-error{color:#b00020;background:#fff0f0;}",
+      // Language picker (openLanguagePicker). The overlay wrapper had no CSS,
+      // so the picker rendered invisibly in normal flow behind the modal —
+      // clicking Translate appeared to do nothing. These give it a centered,
+      // on-top modal presentation matching the rest of the overlay.
+      ".reflow-pn-lang-overlay{position:fixed;inset:0;background:rgba(15,20,30,0.55);display:flex;align-items:center;justify-content:center;z-index:100001;font:14px system-ui,sans-serif;color:#1d1d1d;}",
+      ".reflow-pn-lang-card{width:min(36rem,92vw);max-height:80vh;overflow:auto;background:#fff;border-radius:10px;box-shadow:0 24px 64px rgba(0,0,0,0.3);display:flex;flex-direction:column;}",
+      ".reflow-pn-lang-card header{display:flex;align-items:center;justify-content:space-between;padding:1rem 1.25rem;border-bottom:1px solid #ececec;}",
+      ".reflow-pn-lang-card header h2{margin:0;font-size:1.05rem;}",
+      ".reflow-pn-lang-close{background:none;border:0;font-size:1.5rem;line-height:1;cursor:pointer;color:#666;padding:0;}",
+      ".reflow-pn-lang-list{list-style:none;margin:0;padding:0.75rem;display:grid;grid-template-columns:1fr 1fr;gap:0.4rem;}",
+      ".reflow-pn-lang-list a{display:block;padding:0.55rem 0.75rem;border:1px solid #e6e6e6;border-radius:6px;text-decoration:none;color:#1d1d1d;background:#fff;}",
+      ".reflow-pn-lang-list a:hover{background:#f3f6fb;border-color:#a4c3df;}",
+      ".reflow-pn-lang-search{padding:0.75rem 1.5rem 0;}",
+      ".reflow-pn-lang-search input{width:100%;padding:0.55rem 0.75rem;border:1px solid #d6d8db;border-radius:6px;font:inherit;}",
+      ".reflow-pn-lang-grid{display:grid;grid-template-columns:1fr 1fr;gap:0.4rem;padding:0.85rem 1.5rem;max-height:22rem;overflow:auto;}",
+      ".reflow-pn-lang-btn{display:flex;align-items:center;gap:0.6rem;padding:0.5rem 0.75rem;border:1px solid #e6e6e6;border-radius:6px;background:#fff;cursor:pointer;text-align:left;font:inherit;color:#1d1d1d;}",
+      ".reflow-pn-lang-btn:hover{background:#f3f6fb;border-color:#a4c3df;}",
+      ".reflow-pn-lang-code{font-weight:700;color:#0a5fb5;font-size:0.75rem;letter-spacing:0.04em;background:#eef4fc;padding:0.1rem 0.4rem;border-radius:4px;}",
+      ".reflow-pn-lang-label{font-size:0.88rem;}",
+      ".reflow-pn-lang-custom{display:flex;align-items:center;gap:0.6rem;padding:0.75rem 1.5rem;border-top:1px solid #ececec;background:#fafafa;}",
+      ".reflow-pn-lang-custom label{flex:1;font-size:0.85rem;color:#444;display:flex;flex-direction:column;gap:0.25rem;}",
+      ".reflow-pn-lang-custom input{padding:0.45rem 0.65rem;border:1px solid #d6d8db;border-radius:5px;font:inherit;}",
+      // Consent banner + footer styles
+      // Approval gate bar — shown above the formats grid
+      ".reflow-pn-approval-bar{display:flex;align-items:center;justify-content:space-between;gap:0.75rem;margin:0.25rem 1.5rem 0;padding:0.65rem 0.9rem;background:#f4f7fb;border:1px solid #d6dee8;border-radius:6px;font-size:0.85rem;}",
+      ".reflow-pn-approval-left{display:flex;align-items:center;gap:0.7rem;flex:1;min-width:0;}",
+      ".reflow-pn-status-badge{display:inline-block;color:#fff;font-weight:700;font-size:0.72rem;letter-spacing:0.05em;padding:0.25rem 0.55rem;border-radius:4px;}",
+      ".reflow-pn-approval-msg{color:#1a2233;flex:1;}",
+      ".reflow-pn-approval-actions{display:flex;gap:0.5rem;flex-shrink:0;}",
+      // PII privacy-review bar: stack the explanation, reason box, and
+      // Approve/Deny buttons so the textarea gets full width.
+      ".reflow-pn-pii-bar{flex-direction:column;align-items:stretch;gap:0.6rem;}",
+      ".reflow-pn-pii-controls{display:flex;flex-direction:column;gap:0.5rem;}",
+      ".reflow-pn-pii-justification{width:100%;font:inherit;font-size:0.85rem;padding:0.45rem 0.55rem;border:1px solid #c7d0db;border-radius:5px;resize:vertical;box-sizing:border-box;}",
+      ".reflow-pn-btn-primary{background:#2e7d32;color:#fff;border:none;padding:0.4rem 0.9rem;border-radius:5px;font-weight:600;cursor:pointer;font:inherit;}",
+      ".reflow-pn-btn-primary:hover{background:#256527;}",
+      ".reflow-pn-btn-primary:disabled{background:#9ec5a0;cursor:wait;}",
+      ".reflow-pn-btn-secondary{background:#fff;color:#1a2233;border:1px solid #c8cfd9;padding:0.4rem 0.9rem;border-radius:5px;cursor:pointer;font:inherit;}",
+      ".reflow-pn-btn-secondary:hover{background:#f4f7fb;border-color:#a4b0c1;}",
+      ".reflow-pn-consent-banner{display:flex;align-items:center;gap:0.6rem;margin:0.25rem 1.5rem 0;padding:0.7rem 0.9rem;background:#fff4e5;border:1px solid #f0b878;border-radius:6px;font-size:0.85rem;color:#5d4014;}",
+      ".reflow-pn-consent-icon{font-size:1.1rem;}",
+      ".reflow-pn-consent-text{flex:1;}",
+      ".reflow-pn-consent-btn{display:inline-block;padding:0.35rem 0.85rem;background:#1f4e79;color:#fff !important;text-decoration:none;border-radius:5px;font-weight:600;font-size:0.8rem;}",
+      ".reflow-pn-consent-btn:hover{background:#163960;}",
+      ".reflow-pn-footer-text{font-size:0.8rem;color:#5d6b85;}",
+      ".reflow-pn-footer-text a{color:#1f4e79;text-decoration:underline;}",
+      ".reflow-pn-consent-ok{color:#2e7d32;font-weight:700;}"
+    ].join("\n");
+    document.head.appendChild(s);
+  }
+
+  // Render the consent banner shown at the top of the formats modal. For
+  // students (and for instructors who have already consented) this is
+  // empty; for instructors who haven't consented (or whose consent is
+  // stale due to a version bump) it surfaces a prompt to authorize.
+  // Render the Canvas-OAuth authorization prompt. Shown only to instructors
+  // who have an LTI session but have NOT yet authorized Reflow against the
+  // Canvas API — the state in which the watcher/bridge silently can't act.
+  // The button opens a popup (see openAuthPopup) rather than navigating the
+  // whole window away. Returns "" for students, for already-authorized
+  // instructors, and when status is still unknown (avoid false alarms).
+  function _renderAuthBanner() {
+    var o = STATE.oauth;
+    if (!o || o.authorized) return "";
+    if (!o.is_instructor && STATE.userRole !== "Instructor") return "";
+    var msg = "Authorize Reflow to read your course files and publish accessible pages. " +
+              "Until you do, new uploads won't be converted in your courses.";
+    return '<section id="reflow-pn-auth-banner" class="reflow-pn-consent-banner" role="status">' +
+           '  <span class="reflow-pn-consent-icon" aria-hidden="true">🔑</span>' +
+           '  <span class="reflow-pn-consent-text">' + esc(msg) + '</span>' +
+           '  <button class="reflow-pn-consent-btn reflow-pn-auth-btn" type="button">Authorize Reflow</button>' +
+           '</section>';
+  }
+
+  function _renderConsentBanner() {
+    var c = STATE.consent || { agreed: false, reason: "unknown" };
+    if (c.agreed) return "";
+    // Don't nag students — only instructors trigger paid processing.
+    if (STATE.userRole !== "Instructor") return "";
+    var msg = "Authorization required to process new documents through the Claude API.";
+    if (c.reason === "version_changed") {
+      msg = "The Reflow disclaimer has been updated. Please re-authorize to continue using the tool.";
+    }
+    return '<section id="reflow-pn-consent-banner" class="reflow-pn-consent-banner" role="status">' +
+           '  <span class="reflow-pn-consent-icon" aria-hidden="true">⚠️</span>' +
+           '  <span class="reflow-pn-consent-text">' + esc(msg) + '</span>' +
+           '  <a class="reflow-pn-consent-btn" href="' + ORIGIN + '/canvas/consent" target="_blank" rel="noopener">Authorize Reflow</a>' +
+           '</section>';
+  }
+
+  // Render the footer line — always shown so faculty always know what's
+  // happening with their data. Tone is informational, not nagging.
+  function _renderConsentFooter() {
+    var c = STATE.consent || { agreed: false, reason: "unknown" };
+    if (c.agreed) {
+      var when = fmtConsentDate(c.agreed_at);
+      return '<span class="reflow-pn-footer-text">' +
+             '  <span class="reflow-pn-consent-ok" aria-hidden="true">✓</span> ' +
+             '  Authorized' + (when ? ' on ' + esc(when) : '') +
+             '  · <a href="' + ORIGIN + '/canvas/consent" target="_blank" rel="noopener">View terms</a>' +
+             '</span>';
+    }
+    if (STATE.userRole === "Instructor") {
+      return '<span class="reflow-pn-footer-text">' +
+             '  Alternative formats are visible to students. ' +
+             '  <a href="' + ORIGIN + '/canvas/consent" target="_blank" rel="noopener">View Reflow authorization terms</a>' +
+             '</span>';
+    }
+    return '<span class="reflow-pn-footer-text">Alternative formats are visible to students.</span>';
+  }
+
+  // Render the approval gate strip inside the formats modal. Shows the
+  // current status (DRAFT / APPROVED / REJECTED), and — for instructors —
+  // the Approve / Reject / Request-Edits buttons.
+  // Header strip shown above the format grid. Instructors see the
+  // standard accessibility score (the data point that prompts them to
+  // act on a low-scoring document). Students get a positive
+  // confirmation that an accessible version exists, since the raw
+  // score is not actionable from their side.
+  function _renderReportHeader(payload, score, color) {
+    var isInstructor = STATE.userRole === "Instructor";
+    if (isInstructor) {
+      // Before → after. Left: estimated accessibility of the ORIGINAL PDF
+      // (derived from its source type). Right: WCAG score of the accessible
+      // version we generated. The big dial mirrors the "after" number.
+      var hasSource = typeof payload.source_score === "number";
+      var srcSev = payload.source_severity || severityFor(payload.source_score);
+      var srcColor = COLORS[srcSev] || COLORS.unscanned;
+      var beforePill = hasSource
+        ? '<span class="reflow-pn-pill" style="background:' + srcColor + '">' + payload.source_score + '%</span>'
+        : '<span class="reflow-pn-pill reflow-pn-pill-grey">not estimated</span>';
+      var afterPill = (score === null)
+        ? '<span class="reflow-pn-pill reflow-pn-pill-grey">not yet scored</span>'
+        : '<span class="reflow-pn-pill" style="background:' + color + '">' + score + '%</span>';
+      return '<section class="reflow-pn-modal-report">' +
+        '  <div class="reflow-pn-report-text">' +
+        '    <span class="reflow-pn-report-label">Accessibility</span>' +
+        '    <span class="reflow-pn-beforeafter">' +
+        '      <span class="reflow-pn-ba-item"><small>Original PDF</small>' + beforePill + '</span>' +
+        '      <span class="reflow-pn-ba-arrow" aria-hidden="true">→</span>' +
+        '      <span class="reflow-pn-ba-item"><small>Accessible version</small>' + afterPill + '</span>' +
+        '    </span>' +
+        '    <span class="reflow-pn-report-hint reflow-pn-report-hint-inline">' +
+        '      Left: estimated accessibility of the original PDF, from its source type. ' +
+        '      Right: automated WCAG checks on the accessible version we generated (alt text, headings, language, tables…). ' +
+        '      A helpful screen, <strong>not</strong> a full manual audit — review before publishing.' +
+        '    </span>' +
+        '  </div>' +
+        '  <div class="reflow-pn-report-dial"></div>' +
+        '</section>';
+    }
+    // Student variant. We only render this modal at all when a job
+    // exists and (per the approval gate) is in a state the student can
+    // see — so the language can be confident.
+    return '<section class="reflow-pn-modal-report reflow-pn-modal-report--student">' +
+      '  <div class="reflow-pn-report-text">' +
+      '    <span class="reflow-pn-pill reflow-pn-pill-ok">✓ Accessible version available</span>' +
+      '  </div>' +
+      '  <div class="reflow-pn-report-hint">Choose a format that works for you.</div>' +
+      '</section>';
+  }
+
+  // Phase 8: when an approved Canvas Page exists, promote it to a
+  // prominent "primary" link so faculty + students see it BEFORE the
+  // alternate-format grid. The original PDF in Canvas's Files UI is
+  // labeled secondary; this banner is the route to the
+  // student-facing accessible version.
+  // Resolve a job's Canvas Page reference into a full, openable URL.
+  // Canvas's pages API returns ``url`` as a bare slug (e.g. "my-page"),
+  // and older jobs stored exactly that. A bare slug rendered as an href
+  // resolves relative to the current Canvas path -> ".../courses/50594/<slug>"
+  // which 404s (the real path needs ".../pages/<slug>"). Accept either a
+  // full URL (new jobs store html_url) or a slug and always produce a
+  // correct absolute URL.
+  function _canvasPageHref(payload) {
+    var u = (payload.canvas_page_url || "").trim();
+    if (!u) return "";
+    if (/^https?:\/\//i.test(u)) return u;          // already a full URL
+    var slug = u.replace(/^\/+/, "");
+    if (slug.indexOf("pages/") === 0) slug = slug.slice(6);
+    var course = encodeURIComponent(STATE.courseId || "");
+    return location.origin + "/courses/" + course + "/pages/" + slug;
+  }
+
+  function _renderCanvasPageBanner(payload) {
+    if (!payload || !payload.canvas_page_url) return "";
+    var href = _canvasPageHref(payload);
+    if (!href) return "";
+    var isStudent = STATE.userRole !== "Instructor";
+    var label = isStudent
+      ? "📘 Open the accessible Canvas page (primary)"
+      : "📘 Open accessible Canvas page (this is the primary student-facing artifact)";
+    return '<section class="reflow-pn-canvas-page-banner" aria-label="Primary accessible version">' +
+      '  <a class="reflow-pn-canvas-page-link" target="_blank" rel="noopener" href="' +
+      esc(href) + '">' +
+      '    <span class="reflow-pn-canvas-page-icon" aria-hidden="true">📘</span>' +
+      '    <span class="reflow-pn-canvas-page-text">' +
+      '      <strong>' + esc(label) + '</strong>' +
+      '      <small>The original PDF below is kept as a source copy. The reviewed Canvas Page above is the accessible version intended for student use.</small>' +
+      '    </span>' +
+      '  </a>' +
+      '</section>';
+  }
+
+  // The body of the modal — formats. Instructors get the full grid of
+  // every available format (HTML, audio, EPUB, OCR, Braille, etc.).
+  // Students get a smart-default: a single prominent "Open accessible
+  // version" CTA that links directly to Accessible HTML, with a
+  // discreet "More formats ▾" expander that reveals the same grid for
+  // anyone who needs audio, EPUB, Braille, translation, etc.
+  function _renderFormatBody(payload) {
+    var isInstructor = STATE.userRole === "Instructor";
+    if (isInstructor) {
+      return '<section class="reflow-pn-modal-grid"></section>';
+    }
+    return '<section class="reflow-pn-student-cta">' +
+      '  <a class="reflow-pn-student-primary" data-fmt="html" href="#" target="_blank" rel="noopener">' +
+      '    <span class="reflow-pn-student-primary-icon" aria-hidden="true">📖</span>' +
+      '    <span class="reflow-pn-student-primary-text">' +
+      '      <strong>Open accessible version</strong>' +
+      '      <small>Reader-friendly HTML with proper headings, alt text, and reading order.</small>' +
+      '    </span>' +
+      '  </a>' +
+      '  <details class="reflow-pn-more-formats">' +
+      '    <summary>More formats</summary>' +
+      '    <div class="reflow-pn-modal-grid"></div>' +
+      '  </details>' +
+      '</section>';
+  }
+
+  function _renderApprovalBar(payload) {
+    if (!payload.job_id) return "";
+    var status = payload.job_status || "awaiting_review";
+    var isInstructor = STATE.userRole === "Instructor";
+
+    // Privacy (PII) review: Reflow paused the conversion pending a human
+    // decision. Surface Approve/Deny right here so faculty can act in one
+    // click instead of hunting through the formats.
+    if (status === "awaiting_approval") {
+      if (!isInstructor) {
+        return '<section class="reflow-pn-approval-bar" data-status="awaiting_approval">' +
+               '  <div class="reflow-pn-approval-left">' +
+               '    <span class="reflow-pn-status-badge" style="background:' + COLORS.amber + '">PRIVACY REVIEW</span>' +
+               '    <span class="reflow-pn-approval-msg">This document is awaiting a privacy review by your instructor.</span>' +
+               '  </div>' +
+               '</section>';
+      }
+      return '<section class="reflow-pn-approval-bar reflow-pn-pii-bar" data-status="awaiting_approval">' +
+             '  <div class="reflow-pn-approval-left">' +
+             '    <span class="reflow-pn-status-badge" style="background:' + COLORS.amber + '">PRIVACY REVIEW</span>' +
+             '    <span class="reflow-pn-approval-msg">Reflow flagged possible personal or sensitive information in this document. Approve to finish generating accessible formats, or deny to discard it. Your decision is logged.</span>' +
+             '  </div>' +
+             '  <div class="reflow-pn-pii-controls">' +
+             '    <textarea class="reflow-pn-pii-justification" rows="2" maxlength="1000" aria-label="Reason for your privacy decision (required)">Reviewed by faculty in Canvas.</textarea>' +
+             '    <div class="reflow-pn-approval-actions">' +
+             '      <button class="reflow-pn-btn-primary" type="button" data-action="pii_approve">✓ Approve &amp; continue</button>' +
+             '      <button class="reflow-pn-btn-secondary" type="button" data-action="pii_deny">Deny</button>' +
+             '    </div>' +
+             '  </div>' +
+             '</section>';
+    }
+
+    // Converting / scanning: tell the professor it's still in flight.
+    if (status === "processing" || status === "pii_scanning" || status === "processing_queued") {
+      return '<section class="reflow-pn-approval-bar" data-status="' + esc(status) + '">' +
+             '  <div class="reflow-pn-approval-left">' +
+             '    <span class="reflow-pn-status-badge" style="background:' + COLORS.unscanned + '">CONVERTING</span>' +
+             '    <span class="reflow-pn-approval-msg">This file is still being processed. Check back shortly.</span>' +
+             '  </div>' +
+             '</section>';
+    }
+    // Failed: tell the professor *why*, and what they can do about it.
+    if (status === "failed" || status === "denied") {
+      var reason = payload.error ? esc(payload.error) : "Conversion did not complete.";
+      var hint = isInstructor
+        ? " Re-upload the file to retry. Very large PDFs may need splitting; scanned/image-only PDFs are auto-OCR'd on retry."
+        : "";
+      return '<section class="reflow-pn-approval-bar" data-status="' + esc(status) + '">' +
+             '  <div class="reflow-pn-approval-left">' +
+             '    <span class="reflow-pn-status-badge" style="background:' + COLORS.red + '">NEEDS ATTENTION</span>' +
+             '    <span class="reflow-pn-approval-msg">' + reason + hint + '</span>' +
+             '  </div>' +
+             '</section>';
+    }
+    var label, color, msg;
+    if (status === "published") {
+      label = "APPROVED";
+      color = "#2e7d32";
+      msg = "This version is visible to students.";
+    } else if (status === "rejected") {
+      label = "REJECTED";
+      color = "#b00020";
+      msg = "This version is hidden from students.";
+    } else {
+      label = "DRAFT";
+      color = "#cc7a00";
+      msg = "Students cannot see alternative formats until you approve.";
+    }
+    var buttons = "";
+    if (isInstructor) {
+      if (status === "awaiting_review" || status === "rejected") {
+        buttons = '<button class="reflow-pn-approve-btn reflow-pn-btn-primary" type="button" data-action="approve">✓ Approve &amp; publish</button>'
+                + (status === "awaiting_review" ? '<button class="reflow-pn-reject-btn reflow-pn-btn-secondary" type="button" data-action="reject">Reject</button>' : '');
+      } else if (status === "published") {
+        buttons = '<button class="reflow-pn-reedit-btn reflow-pn-btn-secondary" type="button" data-action="request_edits">↺ Request edits</button>'
+                + '<button class="reflow-pn-unpublish-btn reflow-pn-btn-secondary" type="button" data-action="unpublish" title="Hide this accessible version from students and unpublish its Canvas page">⊘ Unpublish</button>';
+      }
+    }
+    return '<section class="reflow-pn-approval-bar" data-status="' + esc(status) + '">' +
+           '  <div class="reflow-pn-approval-left">' +
+           '    <span class="reflow-pn-status-badge" style="background:' + color + '">' + label + '</span>' +
+           '    <span class="reflow-pn-approval-msg">' + esc(msg) + '</span>' +
+           '  </div>' +
+           '  <div class="reflow-pn-approval-actions">' + buttons + '</div>' +
+           '</section>';
+  }
+
+  // Phase 13: apply focus management + keyboard handling so modals
+  // meet WCAG 2.1 AA. Specifically:
+  //  - 2.1.2 No Keyboard Trap (Escape always closes)
+  //  - 2.4.3 Focus Order (Tab cycles through interactive elements
+  //    inside the modal; Shift+Tab cycles backwards)
+  //  - 2.4.7 Focus Visible (we don't suppress default focus rings)
+  //  - 4.1.2 Name/Role/Value (modal has role+aria-modal+aria-label)
+  function _wcagify_modal(overlay, modal, previouslyFocused) {
+    if (modal.getAttribute("role") !== "dialog") {
+      modal.setAttribute("role", "dialog");
+    }
+    modal.setAttribute("aria-modal", "true");
+    if (!modal.getAttribute("aria-label") && !modal.getAttribute("aria-labelledby")) {
+      modal.setAttribute("aria-label", "Alternative Formats Menu");
+    }
+
+    function focusableNodes() {
+      return Array.prototype.slice.call(modal.querySelectorAll(
+        'a[href], button:not([disabled]), input:not([disabled]), '
+        + 'textarea:not([disabled]), select:not([disabled]), '
+        + '[tabindex]:not([tabindex="-1"])'
+      ));
+    }
+    var nodes = focusableNodes();
+    if (nodes.length) {
+      try { nodes[0].focus(); } catch (_) { /* defensive */ }
+    }
+
+    function onKey(e) {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        teardown();
+        return;
+      }
+      if (e.key !== "Tab") return;
+      var current = document.activeElement;
+      var f = focusableNodes();
+      if (!f.length) return;
+      var first = f[0], last = f[f.length - 1];
+      if (e.shiftKey && current === first) {
+        e.preventDefault();
+        last.focus();
+      } else if (!e.shiftKey && current === last) {
+        e.preventDefault();
+        first.focus();
+      }
+    }
+
+    function teardown() {
+      try { overlay.removeEventListener("keydown", onKey, true); } catch (_) {}
+      try { if (overlay.parentNode) overlay.parentNode.removeChild(overlay); } catch (_) {}
+      // Restore focus to whatever the user was on before opening.
+      try {
+        if (previouslyFocused && previouslyFocused.focus) {
+          previouslyFocused.focus();
+        }
+      } catch (_) { /* element may have been removed */ }
+    }
+
+    overlay.addEventListener("keydown", onKey, true);
+
+    // Wire the close button + backdrop click into the same teardown.
+    var closer = modal.querySelector(".reflow-pn-modal-close");
+    if (closer) {
+      closer.addEventListener("click", function (e) { e.preventDefault(); teardown(); });
+    }
+    overlay.addEventListener("click", function (e) {
+      if (e.target === overlay) teardown();
+    });
+  }
+
+  // Wire up click handlers on the approval buttons. Called from inside
+  // openFormatsModal after the modal is in the DOM.
+  function _wireApprovalActions(modal, payload, refreshCallback) {
+    var bar = modal.querySelector(".reflow-pn-approval-bar");
+    if (!bar) return;
+    bar.addEventListener("click", async function (e) {
+      var btn = e.target.closest("button[data-action]");
+      if (!btn) return;
+      e.preventDefault();
+      var action = btn.dataset.action;
+
+      // PII privacy decision — distinct endpoint + payload (decision +
+      // justification) from the publish approve/reject flow below.
+      if (action === "pii_approve" || action === "pii_deny") {
+        var decision = action === "pii_approve" ? "approved" : "denied";
+        var ta = bar.querySelector(".reflow-pn-pii-justification");
+        var justification = ((ta && ta.value) || "").trim();
+        if (justification.length < 10) {
+          if (ta) ta.focus();
+          window.alert("Please enter a brief reason (at least 10 characters) for the privacy decision — it's recorded for the audit trail.");
+          return;
+        }
+        if (decision === "denied" && !window.confirm(
+              "Deny processing? Reflow will discard this document and generate no accessible formats.")) return;
+        btn.disabled = true; btn.textContent = "Working…";
+        try {
+          var pr = await fetch(
+            ORIGIN + "/canvas/panorama/pii-decision/" + encodeURIComponent(payload.job_id),
+            {
+              method: "POST",
+              credentials: "include",
+              headers: csrfHeaders(),
+              body: JSON.stringify({ decision: decision, justification: justification })
+            }
+          );
+          if (pr.status === 409) {
+            // Not an error: the job already moved past the privacy gate (it
+            // finished converting, or another tab/instructor acted). Show the
+            // resolved state instead of a scary failure.
+            var c409 = bar.querySelector(".reflow-pn-pii-controls");
+            if (c409) c409.remove();
+            var l409 = bar.querySelector(".reflow-pn-approval-left");
+            if (l409) {
+              l409.innerHTML =
+                '<span class="reflow-pn-status-badge" style="background:#2e7d32">DONE</span>' +
+                '<span class="reflow-pn-approval-msg">This document already cleared the privacy review and finished converting. Close and reopen this menu to see the latest.</span>';
+            }
+            return;
+          }
+          if (!pr.ok) {
+            var pt = await pr.text();
+            throw new Error("HTTP " + pr.status + ": " + pt.slice(0, 200));
+          }
+          // Give clear in-place feedback. The canvas status only flips off
+          // 'awaiting_approval' on the next bridge tick, so reopening the modal
+          // with the (stale) payload would look like nothing happened.
+          var controls = bar.querySelector(".reflow-pn-pii-controls");
+          if (controls) controls.remove();
+          var left = bar.querySelector(".reflow-pn-approval-left");
+          if (left) {
+            left.innerHTML =
+              '<span class="reflow-pn-status-badge" style="background:' +
+              (decision === "approved" ? "#2e7d32" : "#b00020") + '">' +
+              (decision === "approved" ? "APPROVED" : "DENIED") + '</span>' +
+              '<span class="reflow-pn-approval-msg">' +
+              (decision === "approved"
+                ? "Approved. Reflow is finishing the conversion — the accessible page will appear in a minute or two."
+                : "Denied. Reflow will discard this document; no accessible formats will be generated.") +
+              '</span>';
+          }
+        } catch (err) {
+          btn.disabled = false;
+          btn.textContent = decision === "approved" ? "✓ Approve & continue" : "Deny";
+          window.alert("Privacy decision failed: " + err.message);
+        }
+        return;
+      }
+
+      var endpoint = { approve: "approve", reject: "reject", request_edits: "request-edits", unpublish: "unpublish" }[action];
+      if (!endpoint) return;
+      var prompt = action === "reject" ? "Reject this accessible version? Students will not see it."
+                 : action === "request_edits" ? "Pull this back to draft for more edits?"
+                 : action === "unpublish" ? "Unpublish this accessible version? Students will no longer see it and its Canvas page will be unpublished. You can re-publish it anytime."
+                 : null;
+      if (prompt && !window.confirm(prompt)) return;
+      btn.disabled = true; btn.textContent = "Working…";
+      try {
+        var r = await fetch(
+          ORIGIN + "/canvas/panorama/" + endpoint + "/" + encodeURIComponent(payload.job_id),
+          {
+            method: "POST",
+            credentials: "include",
+            headers: csrfHeaders(),
+            body: JSON.stringify({ comment: null })
+          }
+        );
+        if (!r.ok) {
+          var txt = await r.text();
+          throw new Error("HTTP " + r.status + ": " + txt.slice(0, 200));
+        }
+        // Success — give clear in-place feedback. Reopening with the stale
+        // in-memory payload (still 'awaiting_review') would look like nothing
+        // happened. The score cache is cleared server-side by put_job, so the
+        // row dial refreshes on the overlay's next scan.
+        var pubBadge, pubColor, pubMsg;
+        if (action === "approve") {
+          pubBadge = "APPROVED"; pubColor = "#2e7d32";
+          pubMsg = "Published — this accessible version is now visible to students.";
+        } else if (action === "reject") {
+          pubBadge = "REJECTED"; pubColor = "#b00020";
+          pubMsg = "Rejected — this version is hidden from students.";
+        } else if (action === "unpublish") {
+          pubBadge = "DRAFT"; pubColor = "#cc7a00";
+          pubMsg = "Unpublished — hidden from students and removed from the Pages list. Re-publish anytime with Approve & publish.";
+        } else {
+          pubBadge = "DRAFT"; pubColor = "#cc7a00";
+          pubMsg = "Pulled back to draft for more edits.";
+        }
+        var pubActions = bar.querySelector(".reflow-pn-approval-actions");
+        if (pubActions) pubActions.remove();
+        var pubLeft = bar.querySelector(".reflow-pn-approval-left");
+        if (pubLeft) {
+          pubLeft.innerHTML =
+            '<span class="reflow-pn-status-badge" style="background:' + pubColor + '">' + pubBadge + '</span>' +
+            '<span class="reflow-pn-approval-msg">' + esc(pubMsg) + '</span>';
+        }
+      } catch (err) {
+        btn.disabled = false;
+        btn.textContent = action === "approve" ? "✓ Approve & publish"
+                        : action === "reject"  ? "✕ Reject"
+                        : action === "unpublish" ? "⊘ Unpublish"
+                                               : "↺ Request edits";
+        window.alert("Action failed: " + (err && err.message ? err.message : err));
+      }
+    });
+  }
+
+  // Language picker for the Translate format card. Presents a small
+  // overlay with common languages; selecting one navigates to
+  // ``/canvas/panorama/alt/{job_id}/translate?lang=<code>``.
+  function openLanguagePicker(payload) {
+    // Full language list (defined once at the top of the bundle). The AI
+    // translator also accepts any language name, so a free-text field below
+    // covers everything not in the list.
+    var langs = TRANSLATE_LANGUAGES;
+    function tUrl(code) {
+      var preview = (payload.job_status !== "published" && STATE.userRole === "Instructor")
+        ? "?preview=1" : "";
+      // Backend matches the colon form ``/alt/{job}/translate:<lang>`` (see
+      // ``fmt.startswith("translate:")``), not a ``?lang=`` query param.
+      return ORIGIN + "/canvas/panorama/alt/" + encodeURIComponent(payload.job_id || "")
+           + "/translate:" + encodeURIComponent(code) + preview;
+    }
+    var ov = document.createElement("div");
+    ov.className = "reflow-pn-overlay reflow-pn-lang-overlay";
+    ov.setAttribute("role", "dialog");
+    ov.setAttribute("aria-label", "Choose a translation language");
+    ov.innerHTML =
+      '<div class="reflow-pn-lang-card">' +
+      '  <header><h2>Translate to…</h2>' +
+      '    <button class="reflow-pn-lang-close" type="button" aria-label="Close">&times;</button>' +
+      '  </header>' +
+      '  <ul class="reflow-pn-lang-list"></ul>' +
+      '  <div class="reflow-pn-lang-custom">' +
+      '    <label>Other language' +
+      '      <input type="text" class="reflow-pn-lang-other" placeholder="e.g. Swahili, Hmong, Punjabi…" />' +
+      '    </label>' +
+      '    <button type="button" class="reflow-pn-lang-go reflow-pn-btn-primary">Translate</button>' +
+      '  </div>' +
+      '</div>';
+    var ul = ov.querySelector(".reflow-pn-lang-list");
+    langs.forEach(function (lang) {
+      var li = document.createElement("li");
+      var a = document.createElement("a");
+      a.href = tUrl(lang.code);
+      a.target = "_blank";
+      a.rel = "noopener";
+      a.textContent = lang.label;
+      li.appendChild(a);
+      ul.appendChild(li);
+    });
+    // Free-text fallback for any language not listed.
+    var other = ov.querySelector(".reflow-pn-lang-other");
+    var go = ov.querySelector(".reflow-pn-lang-go");
+    function goOther() {
+      var v = (other && other.value || "").trim();
+      if (!v) { if (other) other.focus(); return; }
+      window.open(tUrl(v), "_blank", "noopener");
+    }
+    if (go) go.addEventListener("click", goOther);
+    if (other) other.addEventListener("keydown", function (e) {
+      if (e.key === "Enter") { e.preventDefault(); goOther(); }
+    });
+    ov.querySelector(".reflow-pn-lang-close").addEventListener("click", function () {
+      if (ov.parentNode) ov.parentNode.removeChild(ov);
+    });
+    ov.addEventListener("click", function (e) {
+      if (e.target === ov && ov.parentNode) ov.parentNode.removeChild(ov);
+    });
+    document.body.appendChild(ov);
+  }
+
+  // -------------------------------------------------------------------
+  // Bootstrap
+  // -------------------------------------------------------------------
+  //
+  // Canvas is a single-page app at runtime: clicking a course nav swaps
+  // the main panel without a full reload. We scan once at
+  // DOMContentLoaded and again on every coalesced DOM mutation.
+
+  async function decorateAllPdfs() {
+    if (!STATE.courseId) return;
+
+    // Three Canvas surfaces, three lookup keys.
+    // - Files page: scan ``data-testid="table-row"`` rows; matched by filename
+    //   text inside the row spans. Score is keyed by filename via
+    //   ``loadScoresByFilename`` (cached in STATE.scoresByFilename).
+    // - Module items: similar, filename-based.
+    // - Anchor links (Pages, Discussions, embedded etc.): the href carries
+    //   ``/files/<id>`` which is the numeric Canvas file_id. Score is keyed
+    //   by file_id via ``fetchScoresByFileId``.
+    //
+    // We fire both lookups in parallel to keep paint snappy. Per-surface
+    // results are independent: even if one lookup fails, the others
+    // still decorate.
+    var rows = findFileRows();
+    var moduleItems = findModuleFiles();
+    var anchors = findFileLinkAnchors();
+    // Accessible-version links (the tool endpoint) inside a published Canvas
+    // Page. These are keyed by job id and show the OUTPUT (WCAG) score.
+    var accLinks = findAccessibleLinks();
+
+    var byNamePromise = (rows.length || moduleItems.length)
+      ? loadScoresByFilename()
+      : Promise.resolve({});
+    var byIdPromise = anchors.length
+      ? fetchScoresByFileId(anchors.map(function (a) { return a.fileId; }))
+      : Promise.resolve({});
+    var byJobPromise = accLinks.length
+      ? fetchScoresByJobId(accLinks.map(function (a) { return a.jobId; }))
+      : Promise.resolve({});
+
+    var byName = await byNamePromise;
+    var byId = await byIdPromise;
+    var byJob = await byJobPromise;
+
+    function attachAfter(target, payload, filename, opts) {
+      if (!opts && !shouldDecorate(payload)) return;
+      var btn = makeDial(payload, filename, opts);
+      if (target.parentNode) {
+        target.parentNode.insertBefore(btn, target.nextSibling);
+      }
+    }
+
+    rows.forEach(function (entry) {
+      var payload = byName[entry.filename];
+      if (!payload) return;
+      entry.row.dataset.reflowDecorated = "1";
+      // Anchor the dial next to the FILENAME span (not the first span in
+      // the row, which is usually a screen-reader-only label that lives
+      // way before the visible columns). Falls back to the row itself
+      // only when findFileRows didn't capture a filenameSpan.
+      var anchor = entry.filenameSpan || entry.row;
+      attachAfter(anchor, payload, entry.filename);
+    });
+
+    moduleItems.forEach(function (entry) {
+      var payload = byName[entry.filename];
+      if (!payload) return;
+      entry.item.dataset.reflowDecorated = "1";
+      var anchor = entry.item.querySelector("a") || entry.item.querySelector("span") || entry.item;
+      attachAfter(anchor, payload, entry.filename);
+    });
+
+    anchors.forEach(function (entry) {
+      var payload = byId[entry.fileId];
+      if (!shouldDecorate(payload)) return;
+      entry.anchor.dataset.reflowDecorated = "1";
+      var filename = cleanFilename(entry.anchor.textContent || "Document");
+      attachAfter(entry.anchor, payload, filename);
+    });
+
+    // Accessible-version links: always decorate (the link IS the accessible
+    // output) with the WCAG "after" dial, for faculty and students alike.
+    accLinks.forEach(function (entry) {
+      var payload = byJob[entry.jobId];
+      if (!payload) return;
+      entry.anchor.dataset.reflowDecorated = "1";
+      var filename = cleanFilename(entry.anchor.textContent || "Document");
+      attachAfter(entry.anchor, payload, filename, { accessible: true });
+    });
+  }
+
+  function scheduleScan() {
+    if (scheduleScan._pending) return;
+    scheduleScan._pending = true;
+    // Coalesce burst mutations into a single scan ~250ms later.
+    setTimeout(function () {
+      scheduleScan._pending = false;
+      decorateAllPdfs().catch(function (e) {
+        console.warn("Reflow Panorama scan failed:", e);
+      });
+    }, 250);
+  }
+
+  function init() {
+    if (init._started) return;
+    init._started = true;
+    try { injectStyles(); } catch (e) { console.warn("Reflow Panorama: injectStyles failed", e); }
+    try { getEnv(); } catch (e) { console.warn("Reflow Panorama: getEnv failed", e); }
+    // Fetch the CSRF token in the background. The first scheduled
+    // scan can fire before the token arrives -- that's fine because
+    // scans are read-only. State-changing actions check STATE.csrfToken
+    // at submit time.
+    loadCsrfToken().catch(function (e) {
+      console.warn("Reflow Panorama: CSRF fetch failed", e);
+    });
+    // Check Canvas-OAuth authorization in the background so the modal can
+    // surface an "Authorize Reflow" prompt to instructors who haven't yet
+    // granted access. Read-only; safe to fire alongside the first scan.
+    _installOAuthMessageListener();
+    loadOAuthStatus().catch(function (e) {
+      console.warn("Reflow Panorama: OAuth status fetch failed", e);
+    });
+    // Load the Claude-API consent state too, so the modal can hide the
+    // "Authorization required…" banner for instructors who already accepted
+    // (and show "✓ Authorized" in the footer). Without this STATE.consent
+    // stayed undefined and the banner showed unconditionally.
+    loadConsentStatus().catch(function (e) {
+      console.warn("Reflow Panorama: consent status fetch failed", e);
+    });
+    scheduleScan();
+    try {
+      var obs = new MutationObserver(scheduleScan);
+      obs.observe(document.body, { childList: true, subtree: true });
+    } catch (e) {
+      console.warn("Reflow Panorama: MutationObserver unavailable", e);
+    }
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})();
diff --git a/src/workers/canvas_watcher.py b/src/workers/canvas_watcher.py
new file mode 100644
index 0000000..58c35fe
--- /dev/null
+++ b/src/workers/canvas_watcher.py
@@ -0,0 +1,604 @@
+"""Canvas file-discovery watcher.
+
+Scans every surface a faculty member or student could attach a file to
+inside a Canvas course, accumulates a deduplicated set of file ids, then
+submits each PDF Reflow hasn't seen before.
+
+Surfaces covered (all on a 60s default poll):
+  1. Files page  /courses/:id/files
+  2. All folders /courses/:id/folders + /folders/:id/files
+     (catches RCE-paperclip uploads that land in hidden internal folders)
+  3. Modules     /courses/:id/modules/:id/items where type == "File"
+  4. Pages       /courses/:id/pages -> body HTML scanned for file refs
+  5. Discussions /courses/:id/discussion_topics + their entries (incl.
+     announcements). Both the topic message HTML and each entry's
+     message HTML are scanned; entry.attachments[] is also harvested.
+  6. Assignments /courses/:id/assignments — description HTML
+  7. Quizzes     /courses/:id/quizzes — description HTML
+  8. Syllabus    /courses/:id?include[]=syllabus_body
+
+After id collection, each fresh file id is resolved via
+``GET /files/:id`` for metadata, filtered to PDFs, and submitted to
+Reflow. The processed set in Redis guards against double-submission.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+import time
+from typing import Any
+
+from redis.asyncio import Redis
+
+from ..canvas.client import CanvasClient
+from ..canvas.errors import CanvasApiError
+from ..canvas.reflow_client import ReflowClient
+from ..canvas.tenant import tk
+from ..canvas.spend_cap import reserve_submission
+from ..canvas.state import (
+    CanvasJob,
+    already_processed,
+    mark_processed,
+    put_job,
+)
+from ..config import settings
+from ..lti.platform import PlatformInstall
+from ..lti.platform_store import (
+    get_course_owner,
+    get_courses_for_platform,
+    get_platform,
+    list_platforms,
+)
+from ..canvas.user_oauth import get_user_token
+
+# Default scope set the watcher's CanvasClient asks for in multi-tenant
+# mode. Matches the readable-discovery subset declared in
+# /lti/config.json so a Developer Key approved for the full scope list
+# can satisfy these requests without surprise.
+_WATCHER_SCOPES = [
+    "url:GET|/api/v1/courses/:course_id/files",
+    "url:GET|/api/v1/courses/:course_id/folders",
+    "url:GET|/api/v1/courses/:course_id/modules",
+    "url:GET|/api/v1/courses/:course_id/modules/:module_id/items",
+    "url:GET|/api/v1/courses/:course_id/pages",
+    "url:GET|/api/v1/courses/:course_id/pages/:url_or_id",
+    "url:GET|/api/v1/courses/:course_id/discussion_topics",
+    "url:GET|/api/v1/courses/:course_id/discussion_topics/:topic_id/entries",
+    "url:GET|/api/v1/courses/:course_id/assignments",
+    "url:GET|/api/v1/courses/:course_id/quizzes",
+    "url:GET|/api/v1/files/:id",
+    "url:GET|/api/v1/folders/:id/files",
+]
+
+logger = logging.getLogger(__name__)
+
+# Regexes that extract Canvas file ids from arbitrary HTML content. Covers
+# all the URL shapes Canvas's RCE and APIs produce:
+#   - /courses/X/files/Y
+#   - /files/Y/preview
+#   - /files/Y/download
+#   - data-api-endpoint=".../files/Y"
+#   - <a class="instructure_file_link" href=".../files/Y/preview">
+_FILE_ID_PATTERNS = [
+    re.compile(r"/files/(\d+)(?:[/?#\"\\']|$)"),
+    re.compile(r"data-api-endpoint=\"[^\"]*/files/(\d+)\""),
+]
+
+
+def _extract_file_ids_from_html(html: str | None) -> set[str]:
+    if not html:
+        return set()
+    ids: set[str] = set()
+    for pattern in _FILE_ID_PATTERNS:
+        for match in pattern.finditer(html):
+            ids.add(match.group(1))
+    return ids
+
+
+# Document types Reflow can convert. Each type is handled by Docling, which is
+# format-agnostic — the only thing the watcher needs to do is filter for
+# extensions/mime-types that Reflow actually accepts. Extend this set as new
+# input formats are wired into the pipeline.
+_CONVERTIBLE_EXTS = (".pdf", ".docx", ".pptx")
+_CONVERTIBLE_MIMES = {
+    "pdf",
+    "application/pdf",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",  # .docx
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",  # .pptx
+    "doc",
+    "application/msword",  # legacy .doc — Docling converts to docx-like via libreoffice
+}
+
+
+def _is_convertible(file_meta: dict[str, Any]) -> bool:
+    """True if the file is in a format Reflow can convert to accessible HTML."""
+    mime = (file_meta.get("content-type") or file_meta.get("mime_class") or "").lower()
+    name = (file_meta.get("display_name") or file_meta.get("filename") or "").lower()
+    if mime in _CONVERTIBLE_MIMES:
+        return True
+    return any(name.endswith(ext) for ext in _CONVERTIBLE_EXTS)
+
+
+# Kept for backward compatibility; new code should call _is_convertible.
+def _is_pdf(file_meta: dict[str, Any]) -> bool:
+    return _is_convertible(file_meta)
+
+
+def _watched_courses() -> list[str]:
+    raw = getattr(settings, "canvas_watched_courses", "") or ""
+    return [c.strip() for c in str(raw).split(",") if c.strip()]
+
+
+def _multi_tenant_enabled() -> bool:
+    """Feature flag: when on, watcher iterates registered platforms."""
+    return bool(getattr(settings, "multi_tenant_watcher", False))
+
+
+async def _enumerate_scan_targets(
+    redis: Redis,
+) -> list[tuple[str, PlatformInstall | None]]:
+    """Decide what to scan this tick.
+
+    Returns a list of ``(course_id, platform_or_None)`` pairs. In legacy
+    single-tenant mode, ``platform`` is ``None`` and the existing
+    env-token CanvasClient handles auth. In multi-tenant mode the
+    platform record is supplied and the per-platform service-token
+    client is used.
+
+    Multi-tenant precedence is intentional: if a course is registered
+    under a platform AND named in canvas_watched_courses, the platform
+    path wins so the watcher doesn't double-scan with two different
+    auth modes.
+    """
+    if not _multi_tenant_enabled():
+        return [(cid, None) for cid in _watched_courses()]
+
+    targets: list[tuple[str, PlatformInstall | None]] = []
+    seen: set[tuple[str, str]] = set()
+    platforms = await list_platforms(redis)
+    for p in platforms:
+        if p.revoked_at:
+            logger.debug("skipping revoked platform %s", p.platform_id)
+            continue
+        course_ids = await get_courses_for_platform(redis, p.platform_id)
+        for course_id in course_ids:
+            key = (p.platform_id, course_id)
+            if key in seen:
+                continue
+            seen.add(key)
+            targets.append((course_id, p))
+
+    # Belt-and-suspenders: if any courses were listed in the legacy env
+    # var but have no platform association yet (e.g. operator added one
+    # for a not-yet-launched-via-LTI course), keep scanning them via the
+    # env token so they aren't silently dropped during the migration.
+    platform_courses = {cid for cid, _ in targets}
+    for cid in _watched_courses():
+        if cid not in platform_courses:
+            targets.append((cid, None))
+
+    return targets
+
+
+async def _make_canvas_client(
+    redis: Redis,
+    platform: PlatformInstall | None,
+    course_id: str | None = None,
+) -> CanvasClient:
+    """Construct the right CanvasClient for a (course, platform) pair.
+
+    Priority (best-auth-first):
+
+      1. **User-OAuth path** -- platform is known AND the course has a
+         stored owner AND that owner has a stored user_token. This is
+         the only path that actually works against the general Canvas
+         REST API in Canvas Cloud. The watcher reads on the faculty
+         owner's behalf, so discovered files and any pages the bridge
+         creates are attributed to that instructor.
+      2. **Service-token path** -- platform known but no owner/token.
+         Useful only for LTI Advantage services (NRPS, AGS); will 401
+         for general API calls. Logged as a warning.
+      3. **Env-token fallback** -- no platform at all (single-tenant
+         deployment). Requires CANVAS_API_TOKEN; raises otherwise.
+    """
+    if platform is None:
+        return CanvasClient()
+    if course_id:
+        owner_id = await get_course_owner(redis, course_id)
+        if owner_id:
+            try:
+                ut = await get_user_token(redis, platform.platform_id, owner_id)
+            except Exception:
+                ut = None
+            if ut is not None:
+                # Promoted to INFO: operators want a visible signal that
+                # the watcher is using the user-OAuth path (not the
+                # legacy env-token fallback). One line per course per
+                # scan tick is cheap and very valuable in incident review.
+                logger.info(
+                    "Watcher scan: course=%s using owner user_token (user_id=%s)",
+                    course_id, owner_id,
+                )
+                return CanvasClient.from_user_token(redis, platform, owner_id)
+    logger.warning(
+        "Watcher scan: course=%s has no stored owner/user_token; falling "
+        "back to LTI Advantage service token (general API calls will 401)",
+        course_id,
+    )
+    return CanvasClient.from_platform(redis, platform, _WATCHER_SCOPES)
+
+
+async def start_canvas_watcher(
+    redis: Redis,
+    *,
+    shutdown_event: asyncio.Event,
+    poll_interval_seconds: int | None = None,
+) -> None:
+    interval = poll_interval_seconds or int(getattr(settings, "canvas_poll_seconds", 60))
+    if _multi_tenant_enabled():
+        logger.info("Canvas watcher: multi-tenant mode enabled")
+    elif not _watched_courses():
+        logger.warning("Canvas watcher started with no watched courses; idling")
+
+    # In multi-tenant mode each tick rebuilds the CanvasClient list per
+    # platform, so this single legacy instance is only used for the
+    # env-token fallback path (single-tenant courses).
+    reflow = ReflowClient()
+
+    # Periodic maintenance runs every N watcher ticks so we don't pay the
+    # SCAN cost every iteration. Stale-job sweep is fast (a few minutes
+    # of staleness is acceptable); retention purge is slow and only needs
+    # to run every few hours.
+    stale_every = max(1, int(getattr(settings, "canvas_stale_sweep_every_ticks", 5)))
+    retention_every = max(1, int(getattr(settings, "canvas_retention_sweep_every_ticks", 240)))
+    tick = 0
+
+    while not shutdown_event.is_set():
+        try:
+            targets = await _enumerate_scan_targets(redis)
+        except Exception:
+            logger.exception("Failed to enumerate scan targets; skipping tick")
+            targets = []
+
+        for course_id, platform in targets:
+            try:
+                canvas = await _make_canvas_client(redis, platform, course_id)
+            except Exception:
+                logger.exception(
+                    "Cannot build Canvas client for course=%s platform=%s",
+                    course_id, getattr(platform, "platform_id", None),
+                )
+                continue
+            try:
+                await _scan_course(
+                    redis, canvas, reflow, course_id,
+                    platform_id=getattr(platform, "platform_id", None),
+                )
+            except CanvasApiError as exc:
+                logger.warning("Canvas scan failed for %s: %s", course_id, exc)
+            except Exception:
+                logger.exception("Unexpected error scanning course %s", course_id)
+
+        tick += 1
+
+        if tick % stale_every == 0:
+            try:
+                swept = await sweep_stale_jobs(redis)
+                if swept:
+                    logger.info("Stale-job sweeper flipped %d job(s) to failed", swept)
+            except Exception:
+                logger.exception("Stale-job sweep failed")
+
+        if tick % retention_every == 0:
+            try:
+                summary = await _run_retention_sweep(redis)
+                if summary["jobs_removed"] or summary["audit_events_removed"]:
+                    logger.info(
+                        "Retention sweep removed %d job(s) and %d audit event(s)",
+                        summary["jobs_removed"], summary["audit_events_removed"],
+                    )
+            except Exception:
+                logger.exception("Retention sweep failed")
+
+        try:
+            await asyncio.wait_for(shutdown_event.wait(), timeout=interval)
+        except asyncio.TimeoutError:
+            continue
+
+
+async def _run_retention_sweep(redis: Redis) -> dict[str, int]:
+    """Translate retention settings (in days) into a purge call.
+
+    Wrapped so the watcher loop stays readable and so tests can patch the
+    boundary without monkeypatching settings.
+    """
+    from ..canvas.state import purge_old_canvas_records
+
+    job_days = int(getattr(settings, "canvas_job_retention_days", 0))
+    audit_days = int(getattr(settings, "canvas_audit_retention_days", 0))
+    return await purge_old_canvas_records(
+        redis,
+        job_retention_seconds=job_days * 86400,
+        audit_retention_seconds=audit_days * 86400,
+    )
+
+
+async def sweep_stale_jobs(redis: Redis) -> int:
+    """Flip any ``processing`` job older than the configured age to ``failed``.
+
+    Why this exists: the bridge worker drives ``processing`` -> ``awaiting_review``
+    once Reflow signals completion, but if Reflow's callback is lost or the
+    job upload to S3 silently 5xx's, the record sits in ``processing``
+    forever and the faculty member sees a spinning dial with no resolution.
+    Sweeping ages the record out into ``failed`` after a cap (default
+    1 hour) so the modal can show a real error message instead of pretending
+    work is in flight.
+
+    Returns the number of jobs the sweep flipped, for logging by the caller.
+    """
+    import time
+
+    from ..canvas.state import get_job, put_job
+
+    max_age_seconds = int(getattr(settings, "canvas_stale_job_max_age_seconds", 3600))
+    cutoff = time.time() - max_age_seconds
+
+    flipped = 0
+    cursor = 0
+    while True:
+        cursor, keys = await redis.scan(
+            cursor=cursor, match=tk("canvas:job:*"), count=200
+        )
+        for raw_key in keys:
+            key = raw_key.decode() if isinstance(raw_key, bytes) else raw_key
+            job_id = key.rsplit(":", 1)[-1]
+            job = await get_job(redis, job_id)
+            if job is None or job.status != "processing":
+                continue
+            if (job.created_at or 0) > cutoff:
+                continue
+            job.status = "failed"
+            job.error = (
+                f"Job stuck in 'processing' for more than {max_age_seconds}s; "
+                "the bridge worker never received a completion signal. "
+                "Re-upload the file to retry."
+            )
+            await put_job(redis, job)
+            logger.warning(
+                "Stale job %s (file=%s course=%s) flipped to failed",
+                job_id, job.canvas_file_name, job.canvas_course_id,
+            )
+            flipped += 1
+        if cursor == 0:
+            break
+    return flipped
+
+
+async def _discover_file_ids(canvas: CanvasClient, course_id: str) -> tuple[dict[str, dict], set[str]]:
+    """Discover every file id referenced in any course surface.
+
+    Returns (metadata_by_id, html_referenced_ids). The first contains
+    files we already have full metadata for (from listings); the second
+    is a set of ids found in HTML that we still need to resolve.
+    """
+
+    full: dict[str, dict[str, Any]] = {}
+    refs: set[str] = set()
+
+    # 1. Files page
+    try:
+        for f in await canvas.list_course_pdfs(course_id):
+            fid = str(f.get("id") or "")
+            if fid:
+                full[fid] = f
+    except CanvasApiError as exc:
+        logger.warning("files listing failed: %s", exc)
+
+    # 2. Folder walk (hidden folders, RCE paperclip uploads)
+    try:
+        for folder in await canvas.list_course_folders(course_id):
+            try:
+                for f in await canvas.list_folder_files(str(folder.get("id"))):
+                    fid = str(f.get("id") or "")
+                    if fid and fid not in full and _is_convertible(f):
+                        full[fid] = f
+            except CanvasApiError:
+                continue
+    except CanvasApiError as exc:
+        logger.warning("folder walk failed: %s", exc)
+
+    # 3. Modules
+    try:
+        for module in await canvas.list_modules(course_id):
+            try:
+                for item in await canvas.list_module_items(course_id, str(module.get("id"))):
+                    if (item.get("type") or "").lower() != "file":
+                        continue
+                    fid = str(item.get("content_id") or "")
+                    if fid and fid not in full:
+                        refs.add(fid)
+            except CanvasApiError:
+                continue
+    except CanvasApiError as exc:
+        logger.warning("module walk failed: %s", exc)
+
+    # 4. Pages — body HTML scanned for file refs
+    try:
+        pages = await canvas.list_pages(course_id)
+        for p in pages:
+            url = p.get("url")
+            if not url:
+                continue
+            try:
+                page = await canvas.get_page(course_id, url)
+            except CanvasApiError:
+                continue
+            refs |= _extract_file_ids_from_html(page.get("body"))
+    except CanvasApiError as exc:
+        logger.warning("pages scan failed: %s", exc)
+
+    # 5. Discussions + announcements
+    try:
+        topics = await canvas.list_discussion_topics(course_id, include_announcements=True)
+        for t in topics:
+            refs |= _extract_file_ids_from_html(t.get("message"))
+            # Attachments directly on the topic
+            for att in t.get("attachments") or []:
+                aid = str(att.get("id") or "")
+                if aid:
+                    refs.add(aid)
+            try:
+                entries = await canvas.list_discussion_entries(course_id, str(t.get("id")))
+            except CanvasApiError:
+                continue
+            for e in entries:
+                refs |= _extract_file_ids_from_html(e.get("message"))
+                for att in e.get("attachments") or []:
+                    aid = str(att.get("id") or "")
+                    if aid:
+                        refs.add(aid)
+    except CanvasApiError as exc:
+        logger.warning("discussions scan failed: %s", exc)
+
+    # 6. Assignments
+    try:
+        for a in await canvas.list_assignments(course_id):
+            refs |= _extract_file_ids_from_html(a.get("description"))
+    except CanvasApiError as exc:
+        logger.warning("assignments scan failed: %s", exc)
+
+    # 7. Quizzes
+    try:
+        for q in await canvas.list_quizzes(course_id):
+            refs |= _extract_file_ids_from_html(q.get("description"))
+    except CanvasApiError as exc:
+        logger.warning("quizzes scan failed: %s", exc)
+
+    # 8. Syllabus body
+    try:
+        syl = await canvas.get_course_syllabus(course_id)
+        refs |= _extract_file_ids_from_html(syl.get("syllabus_body"))
+    except CanvasApiError as exc:
+        logger.warning("syllabus scan failed: %s", exc)
+
+    # Drop ids we already have full metadata for
+    refs -= set(full.keys())
+    return full, refs
+
+
+async def _resolve_refs(canvas: CanvasClient, refs: set[str]) -> dict[str, dict[str, Any]]:
+    """Resolve a set of file ids to PDF metadata. Non-PDFs are dropped."""
+    out: dict[str, dict[str, Any]] = {}
+    for fid in refs:
+        try:
+            meta = await canvas.get_file_metadata(fid)
+        except CanvasApiError:
+            continue
+        if _is_pdf(meta):
+            out[fid] = meta
+    return out
+
+
+async def _scan_course(
+    redis: Redis,
+    canvas: CanvasClient,
+    reflow: ReflowClient,
+    course_id: str,
+    *,
+    platform_id: str | None = None,
+) -> None:
+    full, refs = await _discover_file_ids(canvas, course_id)
+    resolved = await _resolve_refs(canvas, refs)
+    all_pdfs = {**full, **resolved}
+    if not all_pdfs:
+        logger.debug("no PDFs discovered in course %s", course_id)
+        return
+
+    new_count = 0
+    for file_id, f in all_pdfs.items():
+        if await already_processed(redis, course_id, file_id):
+            continue
+
+        filename = f.get("display_name") or f.get("filename") or f"file-{file_id}.pdf"
+        # Canvas's Files API only exposes ``user_id`` when the calling
+        # token has admin scope; for the user-OAuth path it's typically
+        # empty. Falling back to the course owner (the instructor whose
+        # OAuth token is authorizing the scan) gives the bridge a real
+        # ``canvas_user_id`` to look up the per-user token with, which
+        # is the only auth that works against Canvas Cloud /api/v1.
+        uploader = str(f.get("user_id") or f.get("uploaded_by") or "")
+        if not uploader:
+            try:
+                owner = await get_course_owner(redis, course_id)
+                if owner:
+                    uploader = str(owner)
+                    logger.debug(
+                        "Watcher: file %s/%s has no uploader id; using "
+                        "course owner %s as canvas_user_id for routing",
+                        course_id, file_id, uploader,
+                    )
+            except Exception:  # noqa: BLE001 -- defensive
+                logger.exception(
+                    "Watcher: get_course_owner failed for %s; submitting "
+                    "job with empty canvas_user_id (bridge will fall back "
+                    "to LTI Advantage service token)",
+                    course_id,
+                )
+
+        # Check the per-course monthly Claude-API spend cap. ``reserve_submission``
+        # atomically charges the pre-flight estimate and refunds it if we
+        # would blow the cap. When the cap is unlimited (default 0), this
+        # still records the spend - useful for cost reporting later.
+        allowed, spend_info = await reserve_submission(redis, course_id)
+        if not allowed:
+            logger.warning(
+                "Skipping submission: course %s would exceed monthly spend cap "
+                "(spend=%d cents, cap=%d cents)",
+                course_id, spend_info["spend_after_cents"], spend_info["cap_cents"],
+            )
+            # Mark processed so we don't keep retrying every tick. Operator
+            # raising the cap can clear the processed set for that course.
+            await mark_processed(redis, course_id, file_id)
+            continue
+
+        logger.info(
+            "Submitting new document to Reflow: course=%s file=%s name=%s",
+            course_id, file_id, filename,
+        )
+        try:
+            content = await canvas.download_file(file_id)
+            # submit_document handles any supported format (PDF / DOCX / PPTX);
+            # mime type is inferred from filename.
+            reflow_job_id = await reflow.submit_document(filename, content)
+        except Exception:
+            logger.exception("Failed to submit file %s/%s", course_id, file_id)
+            continue
+
+        await put_job(
+            redis,
+            CanvasJob(
+                reflow_job_id=reflow_job_id,
+                canvas_file_id=file_id,
+                canvas_file_name=filename,
+                canvas_course_id=course_id,
+                canvas_user_id=uploader,
+                status="processing",
+                created_at=time.time(),
+                # Stamp the platform on every job created in multi-tenant
+                # mode so the bridge worker can route the result back to
+                # the right Canvas with the right credentials. Legacy
+                # single-tenant scans pass None here, which the bridge
+                # interprets as "use the env-token client".
+                platform_id=platform_id,
+            ),
+        )
+        await mark_processed(redis, course_id, file_id)
+        new_count += 1
+
+    if new_count:
+        logger.info("Course %s scan: %d new PDFs submitted (%d total discovered)",
+                    course_id, new_count, len(all_pdfs))
+    else:
+        logger.debug("Course %s scan: 0 new (%d already known)", course_id, len(all_pdfs))
diff --git a/src/workers/reflow_bridge_worker.py b/src/workers/reflow_bridge_worker.py
new file mode 100644
index 0000000..fa5111a
--- /dev/null
+++ b/src/workers/reflow_bridge_worker.py
@@ -0,0 +1,592 @@
+"""Bridge worker — turns completed Reflow jobs into draft Canvas Pages.
+
+Listens for completion events from Reflow, fetches the result markdown,
+renders it to HTML, creates an unpublished Canvas Page, and notifies the
+professor via a Canvas Conversation.
+
+Why a separate worker from the watcher: separation of concerns and
+independent retry/backoff. The watcher's job is to start work; this
+worker's job is to finish it.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+
+import httpx
+from redis.asyncio import Redis
+
+from ..canvas.client import CanvasClient
+from ..canvas.errors import CanvasApiError
+from ..canvas.markdown_to_html import render, render_link_stub
+from ..canvas.reflow_client import ReflowClient, rewrite_presigned_url
+from ..canvas.tenant import tk
+from ..canvas.state import (
+    CanvasJob,
+    get_file_page,
+    get_job,
+    put_file_page,
+    put_job,
+)
+from ..config import settings
+from ..lti.platform_store import (
+    get_course_owner,
+    get_platform,
+    get_platform_for_course,
+)
+
+# Scopes the bridge needs to create + publish a Canvas Page and notify
+# the uploader. Strict subset of /lti/config.json so an admin who
+# approved the full set already covers this.
+# Course folder where converted-document figures are uploaded. Appears in
+# the course Files list; faculty can lock/hide it if they prefer. Keeping a
+# single named folder keeps the generated images tidy and easy to find.
+_FIGURE_FOLDER = "Reflow Generated Images"
+
+
+def _slugify(title: str) -> str:
+    """Approximate Canvas's wiki-page slug derivation from a title.
+
+    Lowercase, runs of non-alphanumerics -> single hyphen, trim hyphens.
+    Used as a fallback page reference so the first update-in-place run
+    reuses the existing page instead of creating yet another duplicate.
+    """
+    s = re.sub(r"[^a-z0-9]+", "-", (title or "").lower()).strip("-")
+    return s or "page"
+
+_BRIDGE_SCOPES = [
+    "url:POST|/api/v1/courses/:course_id/pages",
+    "url:PUT|/api/v1/courses/:course_id/pages/:url_or_id",
+    "url:POST|/api/v1/conversations",
+    "url:POST|/api/v1/courses/:course_id/files",
+]
+
+
+async def _canvas_client_for_job(redis, job: CanvasJob) -> CanvasClient:
+    """Build the right Canvas client for a job.
+
+    Priority order (best-token-first):
+
+      1. **User-OAuth path** -- the job has a ``canvas_user_id`` AND we
+         have stored OAuth credentials for that user on this platform.
+         This is the only auth that works for the general Canvas REST
+         API in Canvas Cloud, and it authors the Page as that instructor.
+         Refreshes silently on 401.
+      2. **Service-token path** -- known platform but no user token.
+         Useful for LTI Advantage services (NRPS, AGS); does NOT work
+         for ``/api/v1/...`` calls in Canvas Cloud, so the bridge will
+         see 401s here. Logged as a warning.
+      3. **Env-token fallback** -- no platform association or no stored
+         credentials. Requires ``CANVAS_API_TOKEN`` to be set; raises
+         otherwise.
+    """
+    from ..canvas.user_oauth import get_user_token
+
+    platform_id = job.platform_id
+    if not platform_id and job.canvas_course_id:
+        platform_id = await get_platform_for_course(redis, job.canvas_course_id)
+
+    if platform_id:
+        platform = await get_platform(redis, platform_id)
+        if platform is not None:
+            # 1. Prefer the job's own uploader token when one is stored.
+            if job.canvas_user_id:
+                try:
+                    user_token = await get_user_token(
+                        redis, platform.platform_id, job.canvas_user_id,
+                    )
+                except Exception:
+                    user_token = None
+                if user_token is not None:
+                    return CanvasClient.from_user_token(
+                        redis, platform, job.canvas_user_id,
+                    )
+            # 2. Fall back to the COURSE OWNER's OAuth token. The job's
+            #    canvas_user_id is often the file's uploader (or a Canvas
+            #    numeric id) which has no stored token, whereas the course
+            #    owner is the instructor who actually completed the OAuth
+            #    consent — their token is valid and is what the watcher uses
+            #    to read the course. Without this, the bridge drops to the
+            #    LTI service token, which Canvas rejects with invalid_scope
+            #    for page/file writes (it can't carry url:POST scopes).
+            owner_id = await get_course_owner(redis, job.canvas_course_id)
+            if owner_id and owner_id != job.canvas_user_id:
+                try:
+                    owner_token = await get_user_token(
+                        redis, platform.platform_id, owner_id,
+                    )
+                except Exception:
+                    owner_token = None
+                if owner_token is not None:
+                    logger.info(
+                        "Job %s: using course-owner OAuth token (owner=%s); "
+                        "job uploader=%r had no stored token",
+                        job.reflow_job_id, owner_id, job.canvas_user_id,
+                    )
+                    return CanvasClient.from_user_token(redis, platform, owner_id)
+            # 3. No usable user token: fall back to service token. Works for
+            #    LTI Advantage svcs but 401s/invalid_scopes on REST writes.
+            logger.warning(
+                "Job %s has no stored user token (uploader=%r, owner=%r); "
+                "falling back to LTI Advantage service token (page/file "
+                "writes will fail with invalid_scope)",
+                job.reflow_job_id, job.canvas_user_id, owner_id,
+            )
+            return CanvasClient.from_platform(redis, platform, _BRIDGE_SCOPES)
+        logger.warning(
+            "Job %s references unknown platform_id=%r; falling back to env token",
+            job.reflow_job_id, platform_id,
+        )
+    return CanvasClient()
+
+logger = logging.getLogger(__name__)
+
+
+async def start_reflow_bridge(
+    redis: Redis,
+    *,
+    shutdown_event: asyncio.Event,
+    poll_interval_seconds: int | None = None,
+) -> None:
+    """Long-running task: drive in-flight jobs to completion.
+
+    The MVP polls per-job status rather than subscribing to a global event
+    stream — simpler, and the working set is small (one course's pending
+    uploads). The SSE path lives behind ``stream_events`` on the Reflow
+    client and is wired up in Phase 4.
+    """
+
+    interval = poll_interval_seconds or int(getattr(settings, "reflow_poll_seconds", 30))
+    reflow = ReflowClient()
+    # The bridge used to share one CanvasClient process-wide. In
+    # multi-tenant mode each job may belong to a different Canvas
+    # instance, so we construct per-job inside _drive_job instead.
+    # ``canvas`` here is None; downstream code asks _canvas_client_for_job
+    # for the right client when it needs to make a Canvas call.
+    canvas: CanvasClient | None = None
+
+    while not shutdown_event.is_set():
+        try:
+            await _tick(redis, reflow, canvas)
+        except Exception:  # pragma: no cover — defensive
+            logger.exception("Reflow bridge tick failed")
+
+        try:
+            await asyncio.wait_for(shutdown_event.wait(), timeout=interval)
+        except asyncio.TimeoutError:
+            continue
+
+
+# Canvas-side states the bridge is allowed to poll/update. We
+# DELIBERATELY include ``awaiting_review`` and ``failed`` so the
+# bridge can correct stale state when Reflow disagrees later (e.g.
+# a late-arriving completion, a timeout-induced failure, or an ops
+# replay of a stuck job). ``page_failed`` is included so the bridge
+# keeps retrying the Canvas Page write on each tick — the conversion
+# already succeeded, so once the OAuth token gains the Pages scope the
+# page builds itself with no manual replay. The two we never touch are
+# ``published`` (faculty already approved — overwriting would lose their
+# decision) and ``rejected`` (faculty already declined — same rationale).
+_BRIDGE_POLLABLE: set[str] = {
+    "processing", "awaiting_review", "failed", "page_failed", "awaiting_approval",
+}
+
+# Hard ceiling on how long a single job may occupy the tick. The bridge's
+# job is to reflect Reflow status + (re)build one Canvas Page from an
+# ALREADY-converted document: fetch status, download a handful of figures,
+# upload them, and create/update one page. That should take seconds. If any
+# single network call wedges (a Canvas/S3 request with no effective timeout),
+# the whole sequential tick would otherwise block forever and strand every
+# job after it in 'processing'. Cap each job so the scan always moves on.
+_DRIVE_JOB_TIMEOUT_S = 180
+
+
+async def _tick(redis: Redis, reflow: ReflowClient, canvas: CanvasClient) -> None:
+    """One pass: reflect Reflow's view back onto every non-terminal canvas job.
+
+    Bug history: the previous filter (``job.status != "processing"``)
+    meant the bridge stopped watching a job the moment it moved out of
+    ``processing`` — so a late status change on the Reflow side never
+    propagated, and an ops manual replay that succeeded after the
+    inline BackgroundTask had crashed left the canvas record stuck at
+    ``failed`` forever. Wider filter + bidirectional reflection in
+    ``_drive_job`` fixes that.
+    """
+
+    # Scan all canvas job keys. For the MVP this is fine; for Phase 6+ we
+    # maintain an active-set index to avoid the KEYS scan.
+    cursor = 0
+    while True:
+        cursor, keys = await redis.scan(cursor=cursor, match=tk("canvas:job:*"), count=100)
+        for raw_key in keys:
+            key = raw_key.decode() if isinstance(raw_key, bytes) else raw_key
+            job_id = key.rsplit(":", 1)[-1]
+            job = await get_job(redis, job_id)
+            if job is None or job.status not in _BRIDGE_POLLABLE:
+                continue
+            try:
+                job_canvas = await _canvas_client_for_job(redis, job)
+            except Exception:
+                logger.exception(
+                    "Could not build Canvas client for job %s; will retry next tick",
+                    job.reflow_job_id,
+                )
+                continue
+            # Isolate each job: a hang times out, an error is logged, and the
+            # scan continues to the next job either way. Without this, one bad
+            # job stalls or aborts the whole tick and strands every job after
+            # it in 'processing' (observed: 4 pages rebuilt, then a 20-min hang).
+            try:
+                await asyncio.wait_for(
+                    _drive_job(redis, reflow, job_canvas, job),
+                    timeout=_DRIVE_JOB_TIMEOUT_S,
+                )
+            except asyncio.TimeoutError:
+                logger.warning(
+                    "Bridge: job %s exceeded %ss; moving on (will retry next tick)",
+                    job.reflow_job_id, _DRIVE_JOB_TIMEOUT_S,
+                )
+            except Exception:
+                logger.exception(
+                    "Bridge: job %s failed to drive; moving on", job.reflow_job_id,
+                )
+        if cursor == 0:
+            break
+
+
+# ---------------------------------------------------------------------------
+# Helpers used by ``_drive_job`` to build the Canvas Page artifact.
+#
+# These were lost in the transcript-based reconstruction of this file and
+# restored here with intentionally minimal behavior: do the obvious thing,
+# fail soft, and never block the job from advancing to ``awaiting_review``.
+# ---------------------------------------------------------------------------
+
+def _title_from_filename(filename: str | None) -> str:
+    """Clean filename into a human-friendly Canvas Page title.
+
+    Strips the source extension (.pdf / .docx / etc.) and trims
+    whitespace. Falls back to ``"Document"`` when filename is empty.
+    """
+    if not filename:
+        return "Document"
+    name = str(filename).strip()
+    for ext in (".pdf", ".docx", ".doc", ".pptx", ".ppt", ".html", ".htm", ".epub"):
+        if name.lower().endswith(ext):
+            name = name[: -len(ext)]
+            break
+    return name.strip() or "Document"
+
+
+def _canvas_file_url(job: CanvasJob) -> str | None:
+    """Best-effort URL to the original source file in Canvas.
+
+    The bridge worker doesn't always know the institutional host
+    (e.g. the legacy single-tenant path doesn't carry a platform).
+    When we can't build a confident URL we return ``None`` -- the
+    renderer treats ``None`` as "no source link" and just omits it
+    from the rendered HTML.
+    """
+    course_id = getattr(job, "canvas_course_id", None)
+    file_id = getattr(job, "canvas_file_id", None)
+    if not course_id or not file_id:
+        return None
+    # Build a path-only link; the panorama overlay rewrites these in
+    # the browser using ``window.location.origin``, which is exactly
+    # the Canvas host the user is currently on. That way the same
+    # rendered HTML works for any institution it's served to.
+    return f"/courses/{course_id}/files/{file_id}"
+
+
+async def _notify_professor(canvas: CanvasClient, job: CanvasJob) -> None:
+    """Best-effort: drop a Canvas Conversation announcing the new draft.
+
+    We try once, log on failure, and move on. The faculty member
+    will see the dial in the panorama overlay anyway -- this
+    notification is just a courtesy when their inbox is where they
+    notice things.
+
+    NOTE: this is a stub. The historical implementation called
+    ``canvas.create_conversation(...)`` against a small set of
+    recipients. After the file-recovery regression that original
+    body was lost; the simplest no-regression behavior is to log a
+    debug line and skip until the helper is re-fleshed.
+    """
+    try:
+        recipient = getattr(job, "canvas_user_id", "") or "(unknown)"
+        logger.debug(
+            "Bridge: would notify professor user=%s about job=%s "
+            "(notification helper is a stub; faculty will still see "
+            "the dial in the panorama overlay)",
+            recipient, job.reflow_job_id,
+        )
+    except Exception:  # pragma: no cover -- belt + suspenders
+        logger.exception("notify_professor stub raised; ignoring")
+
+
+async def _drive_job(
+    redis: Redis,
+    reflow: ReflowClient,
+    canvas: CanvasClient,
+    job: CanvasJob,
+) -> None:
+    """Reflect Reflow's current status onto the canvas job record.
+
+    Allowed transitions, by current canvas state:
+      * canvas=processing/failed + reflow=completed -> canvas=awaiting_review
+        (continues into the Page + notify block below)
+      * canvas=processing/awaiting_review + reflow=failed/denied -> canvas=failed
+      * canvas=awaiting_review + reflow=completed -> no-op (already there)
+      * canvas=failed + reflow still in-flight -> no-op (give it time)
+
+    We intentionally never overwrite ``published`` or ``rejected`` —
+    those are human-decided terminal states, see ``_BRIDGE_POLLABLE``.
+    """
+    status = await reflow.get_status(job.reflow_job_id)
+    state = (status.get("status") or "").lower()
+
+    if state in {"failed", "denied"}:
+        if job.status != "failed":
+            prior = job.status
+            job.status = "failed"
+            job.error = status.get("error", f"Reflow status: {state}")
+            await put_job(redis, job)
+            logger.warning(
+                "Bridge: job %s flipped %s->failed (reflow=%s, err=%s)",
+                job.reflow_job_id, prior, state, job.error,
+            )
+        return
+
+    if state == "completed":
+        # No-op only if a Canvas Page actually exists. A job stranded at
+        # awaiting_review with no page id/url is a victim of the old
+        # "best-effort page write" behavior (the write failed but the status
+        # advanced anyway), so faculty saw a clean dial but students got no
+        # page. Fall through and (re)build it — this self-heals those legacy
+        # jobs on the next tick once Pages access is in place, with no manual
+        # replay. A genuinely-built awaiting_review job keeps its page id and
+        # is left alone (faculty owns the next transition).
+        if job.status == "awaiting_review" and (job.canvas_page_id or job.canvas_page_url):
+            return
+        # Otherwise fall through to the completion block which moves
+        # canvas to awaiting_review and tries to create the Page.
+    elif state == "awaiting_approval":
+        # Reflow paused for a PII/privacy decision. Reflect that onto the
+        # canvas status instead of leaving it 'processing' — otherwise the
+        # timeout watchdog mislabels it "stuck in processing for >3600s" and
+        # tells faculty to re-upload, when the real action is a one-click
+        # Approve/Deny. The overlay shows that prompt for this status. We keep
+        # polling (it's in _BRIDGE_POLLABLE), so once approved Reflow resumes
+        # to completed and the next tick builds the page.
+        if job.status != "awaiting_approval":
+            job.status = "awaiting_approval"
+            job.error = None
+            await put_job(redis, job)
+        return
+    else:
+        # Reflow is still working (pii_scanning / processing*); nothing to write.
+        return
+
+    # The completed status payload carries the result URLs directly —
+    # there is no separate /result endpoint on the Reflow API.
+    markdown_url = status.get("markdown_url") or status.get("result_url")
+    if not markdown_url:
+        logger.warning("Reflow job %s completed without markdown_url", job.reflow_job_id)
+        return
+    markdown = await reflow.fetch_markdown(markdown_url)
+
+    # Derive per-document conversion-quality signals from the markdown
+    # we just received. These replace the (always-empty) ``signals``
+    # field upstream Reflow doesn't populate and give the panorama
+    # dial something honest to display.
+    try:
+        from ..canvas.signals import derive_signals_from_markdown
+        job.signals = derive_signals_from_markdown(
+            markdown,
+            pdf_classification=status.get("pdf_classification"),
+            ocr_was_run=bool(status.get("ocr_applied") or status.get("ocr_was_run")),
+        )
+        logger.info(
+            "Bridge: derived signals for job=%s (headings=%d, images=%d/%d, tables=%d)",
+            job.reflow_job_id,
+            len(job.signals.get("heading_levels") or []),
+            job.signals.get("images_with_alt") or 0,
+            job.signals.get("images_total") or 0,
+            job.signals.get("tables_total") or 0,
+        )
+    except Exception:  # noqa: BLE001 — signal derivation is best-effort
+        logger.exception("Bridge: signal derivation failed for %s", job.reflow_job_id)
+        job.signals = None
+
+    # Figures land in S3 with short-lived presigned URLs that expire, so we
+    # can't embed them in a permanent Canvas Page. Instead, point every
+    # ``<img>`` at our stable figure-proxy route, which regenerates S3 access
+    # server-side on each request. The Canvas Page is served from Canvas's
+    # origin, so the src must be ABSOLUTE (use LTI_PUBLIC_URL).
+    # Make the Canvas Page self-contained: upload each figure into a course
+    # folder and rewrite the markdown's relative ``figures/<id>.png`` refs to
+    # Canvas's own file URLs. This decouples the page from the tunnel and the
+    # Reflow backend -- it keeps rendering even if either is down (the old
+    # figure-proxy approach broke whenever the public hostname rotated).
+    # Reflow serializes figures under ``figures`` (list of {figure_id, url});
+    # ``stored_figures`` is the internal Redis field, not in the API response.
+    figures = status.get("figures") or status.get("stored_figures") or []
+    # Seed from any figures we already uploaded on a prior tick (a page_failed
+    # retry). Reusing the stored Canvas URLs means a job that keeps retrying the
+    # page write doesn't re-download from S3 and re-POST to Canvas every ~30s.
+    figure_canvas_urls: dict[str, str] = dict(getattr(job, "figure_canvas_urls", None) or {})
+    for fig in figures:
+        fid = str(fig.get("figure_id") or "").strip()
+        src = str(fig.get("url") or "").strip()
+        if not fid or not src:
+            continue
+        ref = f"figures/{fid}.png"
+        if ref in figure_canvas_urls:
+            # Already uploaded on an earlier tick — just rewrite the markdown.
+            markdown = markdown.replace(ref, figure_canvas_urls[ref])
+            continue
+        # Reflow numbers figures PER DOCUMENT ("figure-1", "figure-2", ...), so
+        # the bare "{fid}.png" name collides across files in the shared folder.
+        # With Canvas's on_duplicate=overwrite, every PDF's "figure-1.png"
+        # overwrites the previous one and they all resolve to whichever file
+        # uploaded last -- images bleed across pages. Prefix with the stable
+        # Canvas source-file id: unique across files, stable across re-converts
+        # (so re-running a single file still overwrites its own figures, not a
+        # neighbour's). ``ref`` stays the per-document markdown key.
+        canvas_fig_name = f"{job.canvas_file_id}-{fid}.png"
+        try:
+            fetch_url = rewrite_presigned_url(src)
+            async with httpx.AsyncClient(timeout=60.0) as hc:
+                img_resp = await hc.get(fetch_url, follow_redirects=True)
+            img_resp.raise_for_status()
+            uploaded = await canvas.upload_course_file(
+                job.canvas_course_id,
+                canvas_fig_name,
+                img_resp.content,
+                content_type="image/png",
+                folder_path=_FIGURE_FOLDER,
+            )
+            canvas_url = str(uploaded.get("url") or "")
+            if canvas_url:
+                figure_canvas_urls[ref] = canvas_url
+                markdown = markdown.replace(ref, canvas_url)
+        except Exception:  # noqa: BLE001 — one bad figure shouldn't sink the page
+            logger.exception(
+                "Bridge: failed to upload figure %s to Canvas for job %s",
+                fid, job.reflow_job_id,
+            )
+    if figure_canvas_urls:
+        # Persist the map so the overlay's accessible-HTML views embed the
+        # same Canvas-hosted images (they have no proxy to fall back on).
+        job.figure_canvas_urls = figure_canvas_urls
+        logger.info(
+            "Bridge: uploaded %d/%d figures to Canvas folder %r for job %s",
+            len(figure_canvas_urls), len(figures), _FIGURE_FOLDER, job.reflow_job_id,
+        )
+
+    title = _title_from_filename(job.canvas_file_name)
+
+    # ``image_base_url=None``: figure refs are already absolute Canvas URLs
+    # after the rewrite above, so no further path rewriting is needed.
+    rendered = render(
+        markdown,
+        title=title,
+        image_base_url=None,
+        original_pdf_url=_canvas_file_url(job),
+    )
+
+    # Two Canvas Cloud constraints rule out putting the document IN the Page:
+    #   1. the edge WAF rejects Page REST writes whose body exceeds ~8KB, and
+    #   2. Canvas won't render an uploaded .html file inline (it only offers a
+    #      download — confirmed: the file preview shows a Canvas 404).
+    # So the Page is a small stub that links to the tool-served rendered HTML
+    # (/canvas/panorama/alt/{job}/html) — the same surface the overlay's
+    # "Accessible HTML" button uses, which renders reliably in any environment.
+    # The stub is always tiny, so the page write clears the WAF at any document
+    # size. Faculty must publish the job before students can open the link;
+    # until then it shows a "pending review" message — the intended approval
+    # gate. See the canvas-waf-page-body-limit note.
+    public_base = (getattr(settings, "lti_public_url", "") or "").rstrip("/")
+    accessible_url = f"{public_base}/canvas/panorama/alt/{job.reflow_job_id}/html"
+    page_body = render_link_stub(
+        title=rendered.title,
+        accessible_url=accessible_url,
+        original_pdf_url=_canvas_file_url(job),
+    )
+
+    # Reuse ONE stable page per file. The bridge used to POST a new page on
+    # every (re)conversion, so Canvas accumulated duplicate "…-2/-3/…" pages.
+    # Now we look up the slug we created for this file last time and PUT-update
+    # it; we only create when none exists (or the update 404s). ``page_ref``
+    # falls back to the deterministic slug Canvas derives from the title, so
+    # the first run after this change reuses the original page instead of
+    # adding yet another duplicate. If the token lacks manage_wiki (401/403),
+    # we mark page_failed below rather than faking awaiting_review.
+    page_ref = await get_file_page(redis, job.canvas_course_id, job.canvas_file_id)
+    if not page_ref:
+        page_ref = _slugify(rendered.title)
+    try:
+        try:
+            page = await canvas.update_page(
+                job.canvas_course_id, page_ref, rendered.title, page_body,
+            )
+        except CanvasApiError as exc:
+            if exc.status_code == 404:
+                page = await canvas.create_page(
+                    job.canvas_course_id,
+                    rendered.title,
+                    page_body,
+                    published=False,
+                )
+            else:
+                raise
+        job.canvas_page_id = str(page.get("page_id", ""))
+        # Store the full, openable page URL (``html_url``) for the overlay's
+        # "Open accessible Canvas page" link. Canvas's ``url`` field is only
+        # the bare slug, which rendered as a link 404s (it resolves to
+        # /courses/<id>/<slug> instead of /courses/<id>/pages/<slug>).
+        # publish_page/delete_page normalize whichever form they're given.
+        job.canvas_page_url = str(page.get("html_url") or page.get("url") or "")
+        # Remember the slug so the next re-conversion updates this same page.
+        await put_file_page(
+            redis,
+            job.canvas_course_id,
+            job.canvas_file_id,
+            str(page.get("url") or job.canvas_page_url),
+        )
+    except CanvasApiError as exc:
+        if exc.status_code in (401, 403):
+            # The conversion succeeded but Canvas rejected the page write —
+            # almost always the course-owner OAuth token missing the Pages
+            # write scope (url:POST|/api/v1/courses/:course_id/pages). DON'T
+            # advance to awaiting_review: that strands the job claiming success
+            # with no page ever created (the "pages never got made" bug). Mark
+            # it page_failed so the overlay shows the real reason; page_failed
+            # is pollable, so the next tick retries and the page self-heals once
+            # the scope is granted — no manual replay needed.
+            logger.warning(
+                "Canvas page write FAILED for job %s (status=%d): %s. "
+                "Marking page_failed — grant the OAuth token the Pages write "
+                "scope (url:POST|/api/v1/courses/:course_id/pages) and it will "
+                "rebuild automatically.",
+                job.reflow_job_id, exc.status_code, exc.message,
+            )
+            job.canvas_page_id = ""
+            job.canvas_page_url = ""
+            job.status = "page_failed"
+            job.error = f"Canvas page write {exc.status_code}: {exc.message}"
+            await put_job(redis, job)
+            return
+        raise
+
+    job.status = "awaiting_review"
+    job.error = None  # clear any prior page_failed error now that the page exists
+    await put_job(redis, job)
+
+    # Notify the uploader only when we have a Canvas Page to point at;
+    # otherwise the Conversations message would be useless.
+    if job.canvas_page_id:
+        await _notify_professor(canvas, job)
+
diff --git a/uv.lock b/uv.lock
index 32aff47..a7652fa 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,43 +1,23 @@
 version = 1
 revision = 3
 requires-python = ">=3.11, <3.13"
-resolution-markers = [
-    "python_full_version >= '3.12' and sys_platform == 'darwin'",
-    "python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'",
-    "(python_full_version >= '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and sys_platform != 'darwin' and sys_platform != 'linux')",
-    "python_full_version < '3.12' and sys_platform == 'darwin'",
-    "python_full_version < '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'",
-    "(python_full_version < '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.12' and sys_platform != 'darwin' and sys_platform != 'linux')",
-]
-
-[[package]]
-name = "ag-ui-protocol"
-version = "0.1.9"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pydantic" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/7b/d7/a8f8789b3b8b5f7263a902361468e8dfefd85ec63d1d5398579b9175d76d/ag_ui_protocol-0.1.9.tar.gz", hash = "sha256:94d75e3919ff75e0b608a7eed445062ea0e6f11cd33b3386a7649047e0c7abd3", size = 4988, upload-time = "2025-09-19T13:36:26.903Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/50/2bb71a2a9135f4d88706293773320d185789b592987c09f79e9bf2f4875f/ag_ui_protocol-0.1.9-py3-none-any.whl", hash = "sha256:44c1238b0576a3915b3a16e1b3855724e08e92ebc96b1ff29379fbd3bfbd400b", size = 7070, upload-time = "2025-09-19T13:36:25.791Z" },
-]
 
 [[package]]
 name = "aioboto3"
-version = "15.1.0"
+version = "15.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiobotocore", extra = ["boto3"] },
     { name = "aiofiles" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5c/b1/b0331786c50f6ef881f9a71c3441ccf7b64c7eed210297d882c37ce31713/aioboto3-15.1.0.tar.gz", hash = "sha256:37763bbc6321ceb479106dc63bc84c8fdb59dd02540034a12941aebef2057c5c", size = 234664, upload-time = "2025-08-14T19:49:15.35Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/01/92e9ab00f36e2899315f49eefcd5b4685fbb19016c7f19a9edf06da80bb0/aioboto3-15.5.0.tar.gz", hash = "sha256:ea8d8787d315594842fbfcf2c4dce3bac2ad61be275bc8584b2ce9a3402a6979", size = 255069, upload-time = "2025-10-30T13:37:16.122Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/93/b0/28e3ac89e7119b1cb4e6830664060b96a2b5761291e92a10fb3044b5a11d/aioboto3-15.1.0-py3-none-any.whl", hash = "sha256:66006142a2ccc7d6d07aa260ba291c4922b6767d270ba42f95c59e85d8b3e645", size = 35791, upload-time = "2025-08-14T19:49:14.14Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/3e/e8f5b665bca646d43b916763c901e00a07e40f7746c9128bdc912a089424/aioboto3-15.5.0-py3-none-any.whl", hash = "sha256:cc880c4d6a8481dd7e05da89f41c384dbd841454fc1998ae25ca9c39201437a6", size = 35913, upload-time = "2025-10-30T13:37:14.549Z" },
 ]
 
 [[package]]
 name = "aiobotocore"
-version = "2.24.0"
+version = "2.25.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -48,9 +28,9 @@ dependencies = [
     { name = "python-dateutil" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b2/ca/ac82c0c699815b6d5b4017f3d8fb2c2d49537f4937f4a0bdf58b4c75d321/aiobotocore-2.24.0.tar.gz", hash = "sha256:b32c0c45d38c22a18ce395a0b5448606c5260603296a152895b5bdb40ab3139d", size = 119597, upload-time = "2025-08-08T18:26:50.373Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/62/94/2e4ec48cf1abb89971cb2612d86f979a6240520f0a659b53a43116d344dc/aiobotocore-2.25.1.tar.gz", hash = "sha256:ea9be739bfd7ece8864f072ec99bb9ed5c7e78ebb2b0b15f29781fbe02daedbc", size = 120560, upload-time = "2025-10-28T22:33:21.787Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e2/68/b29577197aa2e54b50d6f214524790cc1cb27d289585ad7c7bdfe5125285/aiobotocore-2.24.0-py3-none-any.whl", hash = "sha256:72bb1f8eb1b962779a95e1bcc9cf35bc33196ad763b622a40ae7fa9d2e95c87c", size = 84971, upload-time = "2025-08-08T18:26:48.777Z" },
+    { url = "https://files.pythonhosted.org/packages/95/2a/d275ec4ce5cd0096665043995a7d76f5d0524853c76a3d04656de49f8808/aiobotocore-2.25.1-py3-none-any.whl", hash = "sha256:eb6daebe3cbef5b39a0bb2a97cffbe9c7cb46b2fcc399ad141f369f3c2134b1f", size = 86039, upload-time = "2025-10-28T22:33:19.949Z" },
 ]
 
 [package.optional-dependencies]
@@ -60,11 +40,11 @@ boto3 = [
 
 [[package]]
 name = "aiofiles"
-version = "24.1.0"
+version = "25.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0b/03/a88171e277e8caa88a4c77808c20ebb04ba74cc4681bf1e9416c862de237/aiofiles-24.1.0.tar.gz", hash = "sha256:22a075c9e5a3810f0c2e48f3008c94d68c65d763b9b03857924c99e57355166c", size = 30247, upload-time = "2024-06-24T11:02:03.584Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/41/c3/534eac40372d8ee36ef40df62ec129bee4fdb5ad9706e58a29be53b2c970/aiofiles-25.1.0.tar.gz", hash = "sha256:a8d728f0a29de45dc521f18f07297428d56992a742f0cd2701ba86e44d23d5b2", size = 46354, upload-time = "2025-10-09T20:51:04.358Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a5/45/30bb92d442636f570cb5651bc661f52b610e2eec3f891a5dc3a4c3667db0/aiofiles-24.1.0-py3-none-any.whl", hash = "sha256:b4ec55f4195e3eb5d7abd1bf7e061763e864dd4954231fb8539a0ef8bb8260e5", size = 15896, upload-time = "2024-06-24T11:02:01.529Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/8a/340a1555ae33d7354dbca4faa54948d76d89a27ceef032c8c3bc661d003e/aiofiles-25.1.0-py3-none-any.whl", hash = "sha256:abe311e527c862958650f9438e859c1fa7568a141b22abcd015e120e86a85695", size = 14668, upload-time = "2025-10-09T20:51:03.174Z" },
 ]
 
 [[package]]
@@ -78,7 +58,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.12.15"
+version = "3.13.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -89,51 +69,51 @@ dependencies = [
     { name = "propcache" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9b/e7/d92a237d8802ca88483906c388f7c201bbe96cd80a165ffd0ac2f6a8d59f/aiohttp-3.12.15.tar.gz", hash = "sha256:4fc61385e9c98d72fcdf47e6dd81833f47b2f77c114c29cd64a361be57a763a2", size = 7823716, upload-time = "2025-07-29T05:52:32.215Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/19/9e86722ec8e835959bd97ce8c1efa78cf361fa4531fca372551abcc9cdd6/aiohttp-3.12.15-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d3ce17ce0220383a0f9ea07175eeaa6aa13ae5a41f30bc61d84df17f0e9b1117", size = 711246, upload-time = "2025-07-29T05:50:15.937Z" },
-    { url = "https://files.pythonhosted.org/packages/71/f9/0a31fcb1a7d4629ac9d8f01f1cb9242e2f9943f47f5d03215af91c3c1a26/aiohttp-3.12.15-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:010cc9bbd06db80fe234d9003f67e97a10fe003bfbedb40da7d71c1008eda0fe", size = 483515, upload-time = "2025-07-29T05:50:17.442Z" },
-    { url = "https://files.pythonhosted.org/packages/62/6c/94846f576f1d11df0c2e41d3001000527c0fdf63fce7e69b3927a731325d/aiohttp-3.12.15-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3f9d7c55b41ed687b9d7165b17672340187f87a773c98236c987f08c858145a9", size = 471776, upload-time = "2025-07-29T05:50:19.568Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/6c/f766d0aaafcee0447fad0328da780d344489c042e25cd58fde566bf40aed/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc4fbc61bb3548d3b482f9ac7ddd0f18c67e4225aaa4e8552b9f1ac7e6bda9e5", size = 1741977, upload-time = "2025-07-29T05:50:21.665Z" },
-    { url = "https://files.pythonhosted.org/packages/17/e5/fb779a05ba6ff44d7bc1e9d24c644e876bfff5abe5454f7b854cace1b9cc/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbc8a7c410bb3ad5d595bb7118147dfbb6449d862cc1125cf8867cb337e8728", size = 1690645, upload-time = "2025-07-29T05:50:23.333Z" },
-    { url = "https://files.pythonhosted.org/packages/37/4e/a22e799c2035f5d6a4ad2cf8e7c1d1bd0923192871dd6e367dafb158b14c/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:74dad41b3458dbb0511e760fb355bb0b6689e0630de8a22b1b62a98777136e16", size = 1789437, upload-time = "2025-07-29T05:50:25.007Z" },
-    { url = "https://files.pythonhosted.org/packages/28/e5/55a33b991f6433569babb56018b2fb8fb9146424f8b3a0c8ecca80556762/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b6f0af863cf17e6222b1735a756d664159e58855da99cfe965134a3ff63b0b0", size = 1828482, upload-time = "2025-07-29T05:50:26.693Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/82/1ddf0ea4f2f3afe79dffed5e8a246737cff6cbe781887a6a170299e33204/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b5b7fe4972d48a4da367043b8e023fb70a04d1490aa7d68800e465d1b97e493b", size = 1730944, upload-time = "2025-07-29T05:50:28.382Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/96/784c785674117b4cb3877522a177ba1b5e4db9ce0fd519430b5de76eec90/aiohttp-3.12.15-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6443cca89553b7a5485331bc9bedb2342b08d073fa10b8c7d1c60579c4a7b9bd", size = 1668020, upload-time = "2025-07-29T05:50:30.032Z" },
-    { url = "https://files.pythonhosted.org/packages/12/8a/8b75f203ea7e5c21c0920d84dd24a5c0e971fe1e9b9ebbf29ae7e8e39790/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c5f40ec615e5264f44b4282ee27628cea221fcad52f27405b80abb346d9f3f8", size = 1716292, upload-time = "2025-07-29T05:50:31.983Z" },
-    { url = "https://files.pythonhosted.org/packages/47/0b/a1451543475bb6b86a5cfc27861e52b14085ae232896a2654ff1231c0992/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:2abbb216a1d3a2fe86dbd2edce20cdc5e9ad0be6378455b05ec7f77361b3ab50", size = 1711451, upload-time = "2025-07-29T05:50:33.989Z" },
-    { url = "https://files.pythonhosted.org/packages/55/fd/793a23a197cc2f0d29188805cfc93aa613407f07e5f9da5cd1366afd9d7c/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:db71ce547012a5420a39c1b744d485cfb823564d01d5d20805977f5ea1345676", size = 1691634, upload-time = "2025-07-29T05:50:35.846Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/bf/23a335a6670b5f5dfc6d268328e55a22651b440fca341a64fccf1eada0c6/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:ced339d7c9b5030abad5854aa5413a77565e5b6e6248ff927d3e174baf3badf7", size = 1785238, upload-time = "2025-07-29T05:50:37.597Z" },
-    { url = "https://files.pythonhosted.org/packages/57/4f/ed60a591839a9d85d40694aba5cef86dde9ee51ce6cca0bb30d6eb1581e7/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:7c7dd29c7b5bda137464dc9bfc738d7ceea46ff70309859ffde8c022e9b08ba7", size = 1805701, upload-time = "2025-07-29T05:50:39.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/e0/444747a9455c5de188c0f4a0173ee701e2e325d4b2550e9af84abb20cdba/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:421da6fd326460517873274875c6c5a18ff225b40da2616083c5a34a7570b685", size = 1718758, upload-time = "2025-07-29T05:50:41.292Z" },
-    { url = "https://files.pythonhosted.org/packages/36/ab/1006278d1ffd13a698e5dd4bfa01e5878f6bddefc296c8b62649753ff249/aiohttp-3.12.15-cp311-cp311-win32.whl", hash = "sha256:4420cf9d179ec8dfe4be10e7d0fe47d6d606485512ea2265b0d8c5113372771b", size = 428868, upload-time = "2025-07-29T05:50:43.063Z" },
-    { url = "https://files.pythonhosted.org/packages/10/97/ad2b18700708452400278039272032170246a1bf8ec5d832772372c71f1a/aiohttp-3.12.15-cp311-cp311-win_amd64.whl", hash = "sha256:edd533a07da85baa4b423ee8839e3e91681c7bfa19b04260a469ee94b778bf6d", size = 453273, upload-time = "2025-07-29T05:50:44.613Z" },
-    { url = "https://files.pythonhosted.org/packages/63/97/77cb2450d9b35f517d6cf506256bf4f5bda3f93a66b4ad64ba7fc917899c/aiohttp-3.12.15-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:802d3868f5776e28f7bf69d349c26fc0efadb81676d0afa88ed00d98a26340b7", size = 702333, upload-time = "2025-07-29T05:50:46.507Z" },
-    { url = "https://files.pythonhosted.org/packages/83/6d/0544e6b08b748682c30b9f65640d006e51f90763b41d7c546693bc22900d/aiohttp-3.12.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2800614cd560287be05e33a679638e586a2d7401f4ddf99e304d98878c29444", size = 476948, upload-time = "2025-07-29T05:50:48.067Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/1d/c8c40e611e5094330284b1aea8a4b02ca0858f8458614fa35754cab42b9c/aiohttp-3.12.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8466151554b593909d30a0a125d638b4e5f3836e5aecde85b66b80ded1cb5b0d", size = 469787, upload-time = "2025-07-29T05:50:49.669Z" },
-    { url = "https://files.pythonhosted.org/packages/38/7d/b76438e70319796bfff717f325d97ce2e9310f752a267bfdf5192ac6082b/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e5a495cb1be69dae4b08f35a6c4579c539e9b5706f606632102c0f855bcba7c", size = 1716590, upload-time = "2025-07-29T05:50:51.368Z" },
-    { url = "https://files.pythonhosted.org/packages/79/b1/60370d70cdf8b269ee1444b390cbd72ce514f0d1cd1a715821c784d272c9/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6404dfc8cdde35c69aaa489bb3542fb86ef215fc70277c892be8af540e5e21c0", size = 1699241, upload-time = "2025-07-29T05:50:53.628Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/2b/4968a7b8792437ebc12186db31523f541943e99bda8f30335c482bea6879/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3ead1c00f8521a5c9070fcb88f02967b1d8a0544e6d85c253f6968b785e1a2ab", size = 1754335, upload-time = "2025-07-29T05:50:55.394Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/c1/49524ed553f9a0bec1a11fac09e790f49ff669bcd14164f9fab608831c4d/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6990ef617f14450bc6b34941dba4f12d5613cbf4e33805932f853fbd1cf18bfb", size = 1800491, upload-time = "2025-07-29T05:50:57.202Z" },
-    { url = "https://files.pythonhosted.org/packages/de/5e/3bf5acea47a96a28c121b167f5ef659cf71208b19e52a88cdfa5c37f1fcc/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd736ed420f4db2b8148b52b46b88ed038d0354255f9a73196b7bbce3ea97545", size = 1719929, upload-time = "2025-07-29T05:50:59.192Z" },
-    { url = "https://files.pythonhosted.org/packages/39/94/8ae30b806835bcd1cba799ba35347dee6961a11bd507db634516210e91d8/aiohttp-3.12.15-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c5092ce14361a73086b90c6efb3948ffa5be2f5b6fbcf52e8d8c8b8848bb97c", size = 1635733, upload-time = "2025-07-29T05:51:01.394Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/46/06cdef71dd03acd9da7f51ab3a9107318aee12ad38d273f654e4f981583a/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aaa2234bb60c4dbf82893e934d8ee8dea30446f0647e024074237a56a08c01bd", size = 1696790, upload-time = "2025-07-29T05:51:03.657Z" },
-    { url = "https://files.pythonhosted.org/packages/02/90/6b4cfaaf92ed98d0ec4d173e78b99b4b1a7551250be8937d9d67ecb356b4/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6d86a2fbdd14192e2f234a92d3b494dd4457e683ba07e5905a0b3ee25389ac9f", size = 1718245, upload-time = "2025-07-29T05:51:05.911Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/e6/2593751670fa06f080a846f37f112cbe6f873ba510d070136a6ed46117c6/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a041e7e2612041a6ddf1c6a33b883be6a421247c7afd47e885969ee4cc58bd8d", size = 1658899, upload-time = "2025-07-29T05:51:07.753Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/28/c15bacbdb8b8eb5bf39b10680d129ea7410b859e379b03190f02fa104ffd/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5015082477abeafad7203757ae44299a610e89ee82a1503e3d4184e6bafdd519", size = 1738459, upload-time = "2025-07-29T05:51:09.56Z" },
-    { url = "https://files.pythonhosted.org/packages/00/de/c269cbc4faa01fb10f143b1670633a8ddd5b2e1ffd0548f7aa49cb5c70e2/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:56822ff5ddfd1b745534e658faba944012346184fbfe732e0d6134b744516eea", size = 1766434, upload-time = "2025-07-29T05:51:11.423Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b0/4ff3abd81aa7d929b27d2e1403722a65fc87b763e3a97b3a2a494bfc63bc/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b2acbbfff69019d9014508c4ba0401822e8bae5a5fdc3b6814285b71231b60f3", size = 1726045, upload-time = "2025-07-29T05:51:13.689Z" },
-    { url = "https://files.pythonhosted.org/packages/71/16/949225a6a2dd6efcbd855fbd90cf476052e648fb011aa538e3b15b89a57a/aiohttp-3.12.15-cp312-cp312-win32.whl", hash = "sha256:d849b0901b50f2185874b9a232f38e26b9b3d4810095a7572eacea939132d4e1", size = 423591, upload-time = "2025-07-29T05:51:15.452Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/d8/fa65d2a349fe938b76d309db1a56a75c4fb8cc7b17a398b698488a939903/aiohttp-3.12.15-cp312-cp312-win_amd64.whl", hash = "sha256:b390ef5f62bb508a9d67cb3bba9b8356e23b3996da7062f1a57ce1a79d2b3d34", size = 450266, upload-time = "2025-07-29T05:51:17.239Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/77/9a/152096d4808df8e4268befa55fba462f440f14beab85e8ad9bf990516918/aiohttp-3.13.5.tar.gz", hash = "sha256:9d98cc980ecc96be6eb4c1994ce35d28d8b1f5e5208a23b421187d1209dbb7d1", size = 7858271, upload-time = "2026-03-31T22:01:03.343Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d6/f5/a20c4ac64aeaef1679e25c9983573618ff765d7aa829fa2b84ae7573169e/aiohttp-3.13.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ab7229b6f9b5c1ba4910d6c41a9eb11f543eadb3f384df1b4c293f4e73d44d6", size = 757513, upload-time = "2026-03-31T21:57:02.146Z" },
+    { url = "https://files.pythonhosted.org/packages/75/0a/39fa6c6b179b53fcb3e4b3d2b6d6cad0180854eda17060c7218540102bef/aiohttp-3.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8f14c50708bb156b3a3ca7230b3d820199d56a48e3af76fa21c2d6087190fe3d", size = 506748, upload-time = "2026-03-31T21:57:04.275Z" },
+    { url = "https://files.pythonhosted.org/packages/87/ec/e38ce072e724fd7add6243613f8d1810da084f54175353d25ccf9f9c7e5a/aiohttp-3.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e7d2f8616f0ff60bd332022279011776c3ac0faa0f1b463f7bb12326fbc97a1c", size = 501673, upload-time = "2026-03-31T21:57:06.208Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/ba/3bc7525d7e2beaa11b309a70d48b0d3cfc3c2089ec6a7d0820d59c657053/aiohttp-3.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2567b72e1ffc3ab25510db43f355b29eeada56c0a622e58dcdb19530eb0a3cb", size = 1763757, upload-time = "2026-03-31T21:57:07.882Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/ab/e87744cf18f1bd78263aba24924d4953b41086bd3a31d22452378e9028a0/aiohttp-3.13.5-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:fb0540c854ac9c0c5ad495908fdfd3e332d553ec731698c0e29b1877ba0d2ec6", size = 1720152, upload-time = "2026-03-31T21:57:09.946Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f3/ed17a6f2d742af17b50bae2d152315ed1b164b07a5fd5cc1754d99e4dfa5/aiohttp-3.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9883051c6972f58bfc4ebb2116345ee2aa151178e99c3f2b2bbe2af712abd13", size = 1818010, upload-time = "2026-03-31T21:57:12.157Z" },
+    { url = "https://files.pythonhosted.org/packages/53/06/ecbc63dc937192e2a5cb46df4d3edb21deb8225535818802f210a6ea5816/aiohttp-3.13.5-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2294172ce08a82fb7c7273485895de1fa1186cc8294cfeb6aef4af42ad261174", size = 1907251, upload-time = "2026-03-31T21:57:14.023Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a5/0521aa32c1ddf3aa1e71dcc466be0b7db2771907a13f18cddaa45967d97b/aiohttp-3.13.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3a807cabd5115fb55af198b98178997a5e0e57dead43eb74a93d9c07d6d4a7dc", size = 1759969, upload-time = "2026-03-31T21:57:16.146Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/78/a38f8c9105199dd3b9706745865a8a59d0041b6be0ca0cc4b2ccf1bab374/aiohttp-3.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:aa6d0d932e0f39c02b80744273cd5c388a2d9bc07760a03164f229c8e02662f6", size = 1616871, upload-time = "2026-03-31T21:57:17.856Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/41/27392a61ead8ab38072105c71aa44ff891e71653fe53d576a7067da2b4e8/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:60869c7ac4aaabe7110f26499f3e6e5696eae98144735b12a9c3d9eae2b51a49", size = 1739844, upload-time = "2026-03-31T21:57:19.679Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/55/5564e7ae26d94f3214250009a0b1c65a0c6af4bf88924ccb6fdab901de28/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:26d2f8546f1dfa75efa50c3488215a903c0168d253b75fba4210f57ab77a0fb8", size = 1731969, upload-time = "2026-03-31T21:57:22.006Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/c5/705a3929149865fc941bcbdd1047b238e4a72bcb215a9b16b9d7a2e8d992/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1162a1492032c82f14271e831c8f4b49f2b6078f4f5fc74de2c912fa225d51d", size = 1795193, upload-time = "2026-03-31T21:57:24.256Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/19/edabed62f718d02cff7231ca0db4ef1c72504235bc467f7b67adb1679f48/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:8b14eb3262fad0dc2f89c1a43b13727e709504972186ff6a99a3ecaa77102b6c", size = 1606477, upload-time = "2026-03-31T21:57:26.364Z" },
+    { url = "https://files.pythonhosted.org/packages/de/fc/76f80ef008675637d88d0b21584596dc27410a990b0918cb1e5776545b5b/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ca9ac61ac6db4eb6c2a0cd1d0f7e1357647b638ccc92f7e9d8d133e71ed3c6ac", size = 1813198, upload-time = "2026-03-31T21:57:28.316Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/67/5b3ac26b80adb20ea541c487f73730dc8fa107d632c998f25bbbab98fcda/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7996023b2ed59489ae4762256c8516df9820f751cf2c5da8ed2fb20ee50abab3", size = 1752321, upload-time = "2026-03-31T21:57:30.549Z" },
+    { url = "https://files.pythonhosted.org/packages/88/06/e4a2e49255ea23fa4feeb5ab092d90240d927c15e47b5b5c48dff5a9ce29/aiohttp-3.13.5-cp311-cp311-win32.whl", hash = "sha256:77dfa48c9f8013271011e51c00f8ada19851f013cde2c48fca1ba5e0caf5bb06", size = 439069, upload-time = "2026-03-31T21:57:32.388Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/43/8c7163a596dab4f8be12c190cf467a1e07e4734cf90eebb39f7f5d53fc6a/aiohttp-3.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:d3a4834f221061624b8887090637db9ad4f61752001eae37d56c52fddade2dc8", size = 462859, upload-time = "2026-03-31T21:57:34.455Z" },
+    { url = "https://files.pythonhosted.org/packages/be/6f/353954c29e7dcce7cf00280a02c75f30e133c00793c7a2ed3776d7b2f426/aiohttp-3.13.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:023ecba036ddd840b0b19bf195bfae970083fd7024ce1ac22e9bba90464620e9", size = 748876, upload-time = "2026-03-31T21:57:36.319Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/1b/428a7c64687b3b2e9cd293186695affc0e1e54a445d0361743b231f11066/aiohttp-3.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15c933ad7920b7d9a20de151efcd05a6e38302cbf0e10c9b2acb9a42210a2416", size = 499557, upload-time = "2026-03-31T21:57:38.236Z" },
+    { url = "https://files.pythonhosted.org/packages/29/47/7be41556bfbb6917069d6a6634bb7dd5e163ba445b783a90d40f5ac7e3a7/aiohttp-3.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab2899f9fa2f9f741896ebb6fa07c4c883bfa5c7f2ddd8cf2aafa86fa981b2d2", size = 500258, upload-time = "2026-03-31T21:57:39.923Z" },
+    { url = "https://files.pythonhosted.org/packages/67/84/c9ecc5828cb0b3695856c07c0a6817a99d51e2473400f705275a2b3d9239/aiohttp-3.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a60eaa2d440cd4707696b52e40ed3e2b0f73f65be07fd0ef23b6b539c9c0b0b4", size = 1749199, upload-time = "2026-03-31T21:57:41.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/d3/3c6d610e66b495657622edb6ae7c7fd31b2e9086b4ec50b47897ad6042a9/aiohttp-3.13.5-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:55b3bdd3292283295774ab585160c4004f4f2f203946997f49aac032c84649e9", size = 1721013, upload-time = "2026-03-31T21:57:43.904Z" },
+    { url = "https://files.pythonhosted.org/packages/49/a0/24409c12217456df0bae7babe3b014e460b0b38a8e60753d6cb339f6556d/aiohttp-3.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2b2355dc094e5f7d45a7bb262fe7207aa0460b37a0d87027dcf21b5d890e7d5", size = 1781501, upload-time = "2026-03-31T21:57:46.285Z" },
+    { url = "https://files.pythonhosted.org/packages/98/9d/b65ec649adc5bccc008b0957a9a9c691070aeac4e41cea18559fef49958b/aiohttp-3.13.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b38765950832f7d728297689ad78f5f2cf79ff82487131c4d26fe6ceecdc5f8e", size = 1878981, upload-time = "2026-03-31T21:57:48.734Z" },
+    { url = "https://files.pythonhosted.org/packages/57/d8/8d44036d7eb7b6a8ec4c5494ea0c8c8b94fbc0ed3991c1a7adf230df03bf/aiohttp-3.13.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b18f31b80d5a33661e08c89e202edabf1986e9b49c42b4504371daeaa11b47c1", size = 1767934, upload-time = "2026-03-31T21:57:51.171Z" },
+    { url = "https://files.pythonhosted.org/packages/31/04/d3f8211f273356f158e3464e9e45484d3fb8c4ce5eb2f6fe9405c3273983/aiohttp-3.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:33add2463dde55c4f2d9635c6ab33ce154e5ecf322bd26d09af95c5f81cfa286", size = 1566671, upload-time = "2026-03-31T21:57:53.326Z" },
+    { url = "https://files.pythonhosted.org/packages/41/db/073e4ebe00b78e2dfcacff734291651729a62953b48933d765dc513bf798/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:327cc432fdf1356fb4fbc6fe833ad4e9f6aacb71a8acaa5f1855e4b25910e4a9", size = 1705219, upload-time = "2026-03-31T21:57:55.385Z" },
+    { url = "https://files.pythonhosted.org/packages/48/45/7dfba71a2f9fd97b15c95c06819de7eb38113d2cdb6319669195a7d64270/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:7c35b0bf0b48a70b4cb4fc5d7bed9b932532728e124874355de1a0af8ec4bc88", size = 1743049, upload-time = "2026-03-31T21:57:57.341Z" },
+    { url = "https://files.pythonhosted.org/packages/18/71/901db0061e0f717d226386a7f471bb59b19566f2cae5f0d93874b017271f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:df23d57718f24badef8656c49743e11a89fd6f5358fa8a7b96e728fda2abf7d3", size = 1749557, upload-time = "2026-03-31T21:57:59.626Z" },
+    { url = "https://files.pythonhosted.org/packages/08/d5/41eebd16066e59cd43728fe74bce953d7402f2b4ddfdfef2c0e9f17ca274/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:02e048037a6501a5ec1f6fc9736135aec6eb8a004ce48838cb951c515f32c80b", size = 1558931, upload-time = "2026-03-31T21:58:01.972Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e6/4a799798bf05740e66c3a1161079bda7a3dd8e22ca392481d7a7f9af82a6/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31cebae8b26f8a615d2b546fee45d5ffb76852ae6450e2a03f42c9102260d6fe", size = 1774125, upload-time = "2026-03-31T21:58:04.007Z" },
+    { url = "https://files.pythonhosted.org/packages/84/63/7749337c90f92bc2cb18f9560d67aa6258c7060d1397d21529b8004fcf6f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:888e78eb5ca55a615d285c3c09a7a91b42e9dd6fc699b166ebd5dee87c9ccf14", size = 1732427, upload-time = "2026-03-31T21:58:06.337Z" },
+    { url = "https://files.pythonhosted.org/packages/98/de/cf2f44ff98d307e72fb97d5f5bbae3bfcb442f0ea9790c0bf5c5c2331404/aiohttp-3.13.5-cp312-cp312-win32.whl", hash = "sha256:8bd3ec6376e68a41f9f95f5ed170e2fcf22d4eb27a1f8cb361d0508f6e0557f3", size = 433534, upload-time = "2026-03-31T21:58:08.712Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ca/eadf6f9c8fa5e31d40993e3db153fb5ed0b11008ad5d9de98a95045bed84/aiohttp-3.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:110e448e02c729bcebb18c60b9214a87ba33bac4a9fa5e9a5f139938b56c6cb1", size = 460446, upload-time = "2026-03-31T21:58:10.945Z" },
 ]
 
 [[package]]
 name = "aioitertools"
-version = "0.12.0"
+version = "0.13.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/06/de/38491a84ab323b47c7f86e94d2830e748780525f7a10c8600b67ead7e9ea/aioitertools-0.12.0.tar.gz", hash = "sha256:c2a9055b4fbb7705f561b9d86053e8af5d10cc845d22c32008c43490b2d8dd6b", size = 19369, upload-time = "2024-09-02T03:33:40.349Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/3c/53c4a17a05fb9ea2313ee1777ff53f5e001aefd5cc85aa2f4c2d982e1e38/aioitertools-0.13.0.tar.gz", hash = "sha256:620bd241acc0bbb9ec819f1ab215866871b4bbd1f73836a55f799200ee86950c", size = 19322, upload-time = "2025-11-06T22:17:07.609Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/13/58b70a580de00893223d61de8fea167877a3aed97d4a5e1405c9159ef925/aioitertools-0.12.0-py3-none-any.whl", hash = "sha256:fc1f5fac3d737354de8831cbba3eb04f79dd649d8f3afb4c5b114925e662a796", size = 24345, upload-time = "2024-09-02T03:34:59.454Z" },
+    { url = "https://files.pythonhosted.org/packages/10/a1/510b0a7fadc6f43a6ce50152e69dbd86415240835868bb0bd9b5b88b1e06/aioitertools-0.13.0-py3-none-any.whl", hash = "sha256:0be0292b856f08dfac90e31f4739432f4cb6d7520ab9eb73e143f4f2fa5259be", size = 24182, upload-time = "2025-11-06T22:17:06.502Z" },
 ]
 
 [[package]]
@@ -149,6 +129,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
 ]
 
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -160,7 +149,7 @@ wheels = [
 
 [[package]]
 name = "anthropic"
-version = "0.69.0"
+version = "0.103.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -172,47 +161,50 @@ dependencies = [
     { name = "sniffio" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c8/9d/9ad1778b95f15c5b04e7d328c1b5f558f1e893857b7c33cd288c19c0057a/anthropic-0.69.0.tar.gz", hash = "sha256:c604d287f4d73640f40bd2c0f3265a2eb6ce034217ead0608f6b07a8bc5ae5f2", size = 480622, upload-time = "2025-09-29T16:53:45.282Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fb/57/0b758b08cf4606c94d63a997d67a0063f7438efbaf81cfedd0d7c0c69d67/anthropic-0.103.1.tar.gz", hash = "sha256:21c12f4fc0fdd87a2e80d58479cd0af640062b3cfb82bbfa01c7977acd4defeb", size = 848877, upload-time = "2026-05-19T15:43:27.698Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9b/38/75129688de5637eb5b383e5f2b1570a5cc3aecafa4de422da8eea4b90a6c/anthropic-0.69.0-py3-none-any.whl", hash = "sha256:1f73193040f33f11e27c2cd6ec25f24fe7c3f193dc1c5cde6b7a08b18a16bcc5", size = 337265, upload-time = "2025-09-29T16:53:43.686Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/ec/cf357cf571377a39552c1530390a9b79bbdb6ea463f48fbe4e3624141e3b/anthropic-0.103.1-py3-none-any.whl", hash = "sha256:b9a523fac34e64caf6ee55fdbda213950e6a744b906fce100d34909aad2cd8f4", size = 832551, upload-time = "2026-05-19T15:43:29.663Z" },
 ]
 
 [[package]]
 name = "anyio"
-version = "4.11.0"
+version = "4.13.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
-    { name = "sniffio" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094, upload-time = "2025-09-23T09:19:12.58Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097, upload-time = "2025-09-23T09:19:10.601Z" },
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
 ]
 
 [[package]]
-name = "application-properties"
-version = "0.9.0"
+name = "application-file-scanner"
+version = "0.6.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pyjson5" },
-    { name = "pyyaml" },
-    { name = "tomli" },
+    { name = "py-walk" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1f/95/86e4c6faea022a96a7d15de1aca384e7a32400539338cc1d22fa72f0371c/application_properties-0.9.0.tar.gz", hash = "sha256:98a623210f82c2ca3911b19ba00bddedf15a84133ad8aad03b317e9e1ce56666", size = 36441, upload-time = "2025-07-02T02:06:44.948Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/22/e872546d298103527380955f51191ff87cd178e6aac62bb87de73c3e074f/application_file_scanner-0.6.4.tar.gz", hash = "sha256:581c48c5017345747be7f49507da84fec36d1f7b4f67003e9fbaf2f0bc6a3f66", size = 28540, upload-time = "2026-01-19T23:32:15.695Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/4c/18c89dabeaa60ebabffe53375aa3b9853ef10c47fdb3dfa979b5dbbfe4f7/application_properties-0.9.0-py3-none-any.whl", hash = "sha256:2f3d4cba46c4807c0dad5df632c379f1676d2c3b1a45a962f4f4527ce2713c97", size = 22433, upload-time = "2025-07-02T02:06:43.781Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/83/e9a5a14c1b6c20ad44abcdb7bb2f34d860aa4f4ee64c526247066b6c42fb/application_file_scanner-0.6.4-py3-none-any.whl", hash = "sha256:49c211c60f1932812477facc38701d58037b07b031fdb6a6061fdee3fd53e35f", size = 15445, upload-time = "2026-01-19T23:32:14.4Z" },
 ]
 
 [[package]]
-name = "argcomplete"
-version = "3.6.2"
+name = "application-properties"
+version = "0.9.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/16/0f/861e168fc813c56a78b35f3c30d91c6757d1fd185af1110f1aec784b35d0/argcomplete-3.6.2.tar.gz", hash = "sha256:d0519b1bc867f5f4f4713c41ad0aba73a4a5f007449716b16f385f2166dc6adf", size = 73403, upload-time = "2025-04-03T04:57:03.52Z" }
+dependencies = [
+    { name = "pyjson5" },
+    { name = "pyyaml" },
+    { name = "tomli" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/63/8a0491538205ec5af39addd80263c764fa57a044cadcbcf981092a1e8b57/application_properties-0.9.2.tar.gz", hash = "sha256:d8e7858bbf72c9d834117d74f561efb65d31e5193f1a5e803d6adc2d556c8465", size = 40022, upload-time = "2026-02-07T21:52:17.903Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/da/e42d7a9d8dd33fa775f467e4028a47936da2f01e4b0e561f9ba0d74cb0ca/argcomplete-3.6.2-py3-none-any.whl", hash = "sha256:65b3133a29ad53fb42c48cf5114752c7ab66c1c38544fdf6460f450c09b42591", size = 43708, upload-time = "2025-04-03T04:57:01.591Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/a5/b79d86c972e8dd888fd8e4b2ea4c277791f455b86f25c458c2917bf9cff9/application_properties-0.9.2-py3-none-any.whl", hash = "sha256:503388017a8d12436ba0914c8d24820adf658f765f9ac7dc9dc77a4733115238", size = 23283, upload-time = "2026-02-07T21:52:16.964Z" },
 ]
 
 [[package]]
@@ -250,11 +242,35 @@ wheels = [
 
 [[package]]
 name = "asgiref"
-version = "3.9.2"
+version = "3.11.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/63/40/f03da1264ae8f7cfdbf9146542e5e7e8100a4c66ab48e791df9a03d3f6c0/asgiref-3.11.1.tar.gz", hash = "sha256:5f184dc43b7e763efe848065441eac62229c9f7b0475f41f80e207a114eda4ce", size = 38550, upload-time = "2026-02-03T13:30:14.33Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/0a/a72d10ed65068e115044937873362e6e32fab1b7dce0046aeb224682c989/asgiref-3.11.1-py3-none-any.whl", hash = "sha256:e8667a091e69529631969fd45dc268fa79b99c92c5fcdda727757e52146ec133", size = 24345, upload-time = "2026-02-03T13:30:13.039Z" },
+]
+
+[[package]]
+name = "ast-serialize"
+version = "0.5.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7f/bf/0f3ecda32f1cb3bf1dca480aca08a7a8a3bdc4bed2343a103f30731565c9/asgiref-3.9.2.tar.gz", hash = "sha256:a0249afacb66688ef258ffe503528360443e2b9a8d8c4581b6ebefa58c841ef1", size = 36894, upload-time = "2025-09-23T15:00:55.136Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/81/9d/09e27731bd5864a9ce04e3244074e674bb8936bf62b45e0357248717adac/ast_serialize-0.5.0.tar.gz", hash = "sha256:5880091bfe6f4f986f22866375c2e884843e7a0b6343ae41aeea659613d879b6", size = 61157, upload-time = "2026-05-17T17:48:29.429Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/d1/69d02ce34caddb0a7ae088b84c356a625a93cd4ff57b2f97644c03fad905/asgiref-3.9.2-py3-none-any.whl", hash = "sha256:0b61526596219d70396548fc003635056856dba5d0d086f86476f10b33c75960", size = 23788, upload-time = "2025-09-23T15:00:53.627Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/9e/dc2530acb3a60dc6e46d65abf27d1d9f86721694757906a148d90a6860de/ast_serialize-0.5.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:0668aa9459cfa8c9c49ddd2163ebcf43088ba045ef7492af6fe22e0098303101", size = 1191380, upload-time = "2026-05-17T17:48:03.738Z" },
+    { url = "https://files.pythonhosted.org/packages/26/0a/bd3d18a582f273d6c843d16bb9e22e9e16365ff7991e92f18f798e9f1224/ast_serialize-0.5.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:bf683d6363edf2b39eed6b6d4fe22d34b6203867a67e27134d9e2a2680c4bc4a", size = 1183879, upload-time = "2026-05-17T17:48:05.463Z" },
+    { url = "https://files.pythonhosted.org/packages/40/ae/1f919100f8620887af58fcc381c61a1f218cdf89c6e155f87b213e61010a/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cc22cf0c9be65e71cf88fda130af60d61eb4a79370ad4cfe7900d48a4aa2211", size = 1244529, upload-time = "2026-05-17T17:48:07.008Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/ca/6376559dcce707cdbc1d0d9a13c8d3baaaa501e949ce0ebdc4230cd881aa/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f66173891548c9f2726bf27957b41cabce12fa679dc6da505ddbde4d4b3b31cf", size = 1240560, upload-time = "2026-05-17T17:48:08.46Z" },
+    { url = "https://files.pythonhosted.org/packages/35/b2/a620e206b5aeb7efbf2710336df57d457cffbb3991076bbcc1147ef9abd4/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e42d729ef2be96a14efbad355093284739e3670ece3e534f82cc8832790911d9", size = 1451172, upload-time = "2026-05-17T17:48:09.922Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/e0/4ad5c04c24a40481b2935ce9a0ccdb6023dc8b667167d06ae530cc3512f2/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b725026bafa801dbd7310eb13a75f0a2e370e7e51b2cb225f9d21fcfadf919ee", size = 1265072, upload-time = "2026-05-17T17:48:11.469Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/71/4d1d479aa56d0101c40e17720c3d6ac2af7269ea0487a80b18e7bfd1a5b7/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b54f60c1d78767a53b67eaa663f0dfac3afe606aa07f1301572f588b73d64809", size = 1270488, upload-time = "2026-05-17T17:48:13.575Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/4f/0de1bbe06f6edef9fde4ed12ca8e7b3ec7e6e2bd4e672c5af487f7957665/ast_serialize-0.5.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:27d51654fc240a1e87e742d353d98eb45b75f62f129086b3596ab53df2ac2a43", size = 1260702, upload-time = "2026-05-17T17:48:15.141Z" },
+    { url = "https://files.pythonhosted.org/packages/75/61/e00872439cfdddcc3c1b6cdaa6e5d904ba8e26a18807c67c4e14409d0ca8/ast_serialize-0.5.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c36237c46dd1674542f2109740ea5ea485a169bf1431939ada0434e17934", size = 1311182, upload-time = "2026-05-17T17:48:16.779Z" },
+    { url = "https://files.pythonhosted.org/packages/76/8e/699a5b955f7926956c95e9e1d74132acad73c2fe7a426f94da89123c20aa/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1943db345233cc7194a470f13afa9c59772c0b123dea0c9414c4d4ca54369759", size = 1421410, upload-time = "2026-05-17T17:48:18.527Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/ae/d5b7626874478997adc7a29ab28accf21e596fb590c944290401dfd0b29e/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:df1c00022cbbcb064bfaa505aa9c9295362443ce5dacb459d1331d3da353f887", size = 1516587, upload-time = "2026-05-17T17:48:20.133Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ce/b59e02a82d9c4244d64cde502e0b00e83e38816abe19155ceb5437402c7f/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:cae65289fc456fde04af979a2be09302ef5d8ab92ef23e596d6746dc267ada27", size = 1515171, upload-time = "2026-05-17T17:48:21.921Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/38/d8d90042747d05aa08d4efcf1c99035a5f670a6bf4c214d31644392afbca/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:239a4c354e8d676e9d94631d1d4a64edc6b266f86ff3a5a80aedd344f342c01d", size = 1464668, upload-time = "2026-05-17T17:48:23.544Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/51/5b840c4df7334104cecffa28f23904fe81ca89ca223d2450e288de39fd3c/ast_serialize-0.5.0-cp39-abi3-win32.whl", hash = "sha256:143a4ef63285a075871908fda3672dc21864b83a8ec3ee12304aa3e4c5387b9a", size = 1068311, upload-time = "2026-05-17T17:48:25.027Z" },
+    { url = "https://files.pythonhosted.org/packages/41/11/ca5672c7d491825bc4cd6702dea106a6b60d928707712ec257c7833ae476/ast_serialize-0.5.0-cp39-abi3-win_amd64.whl", hash = "sha256:cf25572c526add400f26a4750dc6ce0c3bb93fc1f75e7ae0cad4ce4f2cd5c590", size = 1108931, upload-time = "2026-05-17T17:48:26.591Z" },
+    { url = "https://files.pythonhosted.org/packages/45/19/cc8bd127d28a43da249aa955cfd164cf8fd534e79e42cea96c4854d72fd0/ast_serialize-0.5.0-cp39-abi3-win_arm64.whl", hash = "sha256:92a31c9c20d25a076edaeec76b128a3535d74a24f340b9a8a7e96c9b86dc9642", size = 1081181, upload-time = "2026-05-17T17:48:28.122Z" },
 ]
 
 [[package]]
@@ -268,11 +284,28 @@ wheels = [
 
 [[package]]
 name = "attrs"
-version = "25.3.0"
+version = "26.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032, upload-time = "2025-03-13T11:10:22.779Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815, upload-time = "2025-03-13T11:10:21.14Z" },
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "bleach"
+version = "6.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "webencodings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/07/18/3c8523962314be6bf4c8989c79ad9531c825210dd13a8669f6b84336e8bd/bleach-6.3.0.tar.gz", hash = "sha256:6f3b91b1c0a02bb9a78b5a454c92506aa0fdf197e1d5e114d2e00c6f64306d22", size = 203533, upload-time = "2025-10-27T17:57:39.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cd/3a/577b549de0cc09d95f11087ee63c739bba856cd3952697eec4c4bb91350a/bleach-6.3.0-py3-none-any.whl", hash = "sha256:fe10ec77c93ddf3d13a73b035abaac7a9f5e436513864ccdad516693213c65d6", size = 164437, upload-time = "2025-10-27T17:57:37.538Z" },
+]
+
+[package.optional-dependencies]
+css = [
+    { name = "tinycss2" },
 ]
 
 [[package]]
@@ -298,65 +331,56 @@ wheels = [
 
 [[package]]
 name = "boto3"
-version = "1.39.11"
+version = "1.40.61"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "botocore" },
     { name = "jmespath" },
     { name = "s3transfer" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b6/2e/ed75ea3ee0fd1afacc3379bc2b7457c67a6b0f0e554e1f7ccbdbaed2351b/boto3-1.39.11.tar.gz", hash = "sha256:3027edf20642fe1d5f9dc50a420d0fe2733073ed6a9f0f047b60fe08c3682132", size = 111869, upload-time = "2025-07-22T19:26:50.867Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ed/f9/6ef8feb52c3cce5ec3967a535a6114b57ac7949fd166b0f3090c2b06e4e5/boto3-1.40.61.tar.gz", hash = "sha256:d6c56277251adf6c2bdd25249feae625abe4966831676689ff23b4694dea5b12", size = 111535, upload-time = "2025-10-28T19:26:57.247Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/72/66/88566a6484e746c0b075f7c9bb248e8548eda0a486de4460d150a41e2d57/boto3-1.39.11-py3-none-any.whl", hash = "sha256:af8f1dad35eceff7658fab43b39b0f55892b6e3dd12308733521cc24dd2c9a02", size = 139900, upload-time = "2025-07-22T19:26:48.706Z" },
+    { url = "https://files.pythonhosted.org/packages/61/24/3bf865b07d15fea85b63504856e137029b6acbc73762496064219cdb265d/boto3-1.40.61-py3-none-any.whl", hash = "sha256:6b9c57b2a922b5d8c17766e29ed792586a818098efe84def27c8f582b33f898c", size = 139321, upload-time = "2025-10-28T19:26:55.007Z" },
 ]
 
 [[package]]
 name = "boto3-stubs"
-version = "1.42.6"
+version = "1.43.10"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "botocore-stubs" },
     { name = "types-s3transfer" },
     { name = "typing-extensions", marker = "python_full_version < '3.12'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5d/ae/cf44140a46973a9bf2202b110adfffaf6b40f0f08f2d3e6fdf250290d48e/boto3_stubs-1.42.6.tar.gz", hash = "sha256:41e38a060a9d0d4738d496a7f869195ad33f80b59690005c9962dc977626494b", size = 100803, upload-time = "2025-12-09T23:12:57.854Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0a/67/969b5bc0581ef6f22b2371bdc33d66a50fe907993e0528cb34a7f3fa59f7/boto3_stubs-1.43.10.tar.gz", hash = "sha256:05575658b827e7a12a45629e1a987317e1e679dccabe5ebde5a2101528c76cf8", size = 102665, upload-time = "2026-05-18T20:47:00.528Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/41/39062d380770057f0c4b048dfc7dadc1d68a0db18e61eac81baa80c1a139/boto3_stubs-1.42.6-py3-none-any.whl", hash = "sha256:8a591f3af2bef1fb646294fda5edbb457c0c57d39d0934ea7b6083596a34a33c", size = 69705, upload-time = "2025-12-09T23:12:54.669Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/42/90eb347eda878b15def1f0bb0971779b1829a0fc6b9c0fe3ff823de09833/boto3_stubs-1.43.10-py3-none-any.whl", hash = "sha256:0ce5dec421a45ef1b8ddd32e68d0b8bb78ea7447c5ddf8231420ccaa6e71e0f5", size = 70667, upload-time = "2026-05-18T20:46:54.359Z" },
 ]
 
 [[package]]
 name = "botocore"
-version = "1.39.11"
+version = "1.40.61"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jmespath" },
     { name = "python-dateutil" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/d0/9d64261186cff650fe63168441edb4f4cd33f085a74c0c54455630a71f91/botocore-1.39.11.tar.gz", hash = "sha256:953b12909d6799350e346ab038e55b6efe622c616f80aef74d7a6683ffdd972c", size = 14217749, upload-time = "2025-07-22T19:26:40.723Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/28/a3/81d3a47c2dbfd76f185d3b894f2ad01a75096c006a2dd91f237dca182188/botocore-1.40.61.tar.gz", hash = "sha256:a2487ad69b090f9cccd64cf07c7021cd80ee9c0655ad974f87045b02f3ef52cd", size = 14393956, upload-time = "2025-10-28T19:26:46.108Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1c/2c/8a0b02d60a1dbbae7faa5af30484b016aa3023f9833dfc0d19b0b770dd6a/botocore-1.39.11-py3-none-any.whl", hash = "sha256:1545352931a8a186f3e977b1e1a4542d7d434796e274c3c62efd0210b5ea76dc", size = 13876276, upload-time = "2025-07-22T19:26:35.164Z" },
+    { url = "https://files.pythonhosted.org/packages/38/c5/f6ce561004db45f0b847c2cd9b19c67c6bf348a82018a48cb718be6b58b0/botocore-1.40.61-py3-none-any.whl", hash = "sha256:17ebae412692fd4824f99cde0f08d50126dc97954008e5ba2b522eb049238aa7", size = 14055973, upload-time = "2025-10-28T19:26:42.15Z" },
 ]
 
 [[package]]
 name = "botocore-stubs"
-version = "1.42.6"
+version = "1.42.41"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "types-awscrt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5d/b1/556e80eb0354f0a49c215c5d93ff3c5ec32967e1f404c75c638314524eac/botocore_stubs-1.42.6.tar.gz", hash = "sha256:ba3e770966c76b9eb9a6b300fd7d9b1c4021bac91dde6652b555c4a0e0b73392", size = 42416, upload-time = "2025-12-09T23:26:08.069Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0c/a8/a26608ff39e3a5866c6c79eda10133490205cbddd45074190becece3ff2a/botocore_stubs-1.42.41.tar.gz", hash = "sha256:dbeac2f744df6b814ce83ec3f3777b299a015cbea57a2efc41c33b8c38265825", size = 42411, upload-time = "2026-02-03T20:46:14.479Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/37/798c9a295cb91a0f56d86e120737e354fb7322b4c252821ee7e474e69cb3/botocore_stubs-1.42.6-py3-none-any.whl", hash = "sha256:08502fdac438b1934a803e5fd11838b2792c68115274a20f3677ded250caa7d2", size = 66749, upload-time = "2025-12-09T23:26:06.267Z" },
-]
-
-[[package]]
-name = "cachetools"
-version = "6.2.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9d/61/e4fad8155db4a04bfb4734c7c8ff0882f078f24294d42798b3568eb63bff/cachetools-6.2.0.tar.gz", hash = "sha256:38b328c0889450f05f5e120f56ab68c8abaf424e1275522b138ffc93253f7e32", size = 30988, upload-time = "2025-08-25T18:57:30.924Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6c/56/3124f61d37a7a4e7cc96afc5492c78ba0cb551151e530b54669ddd1436ef/cachetools-6.2.0-py3-none-any.whl", hash = "sha256:1c76a8960c0041fcc21097e357f882197c79da0dbff766e7317890a65d7d8ba6", size = 11276, upload-time = "2025-08-25T18:57:29.684Z" },
+    { url = "https://files.pythonhosted.org/packages/32/76/cab7af7f16c0b09347f2ebe7ffda7101132f786acb767666dce43055faab/botocore_stubs-1.42.41-py3-none-any.whl", hash = "sha256:9423110fb0e391834bd2ed44ae5f879d8cb370a444703d966d30842ce2bcb5f0", size = 66759, upload-time = "2026-02-03T20:46:13.02Z" },
 ]
 
 [[package]]
@@ -370,11 +394,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2025.8.3"
+version = "2026.4.22"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/dc/67/960ebe6bf230a96cda2e0abcf73af550ec4f090005363542f0765df162e0/certifi-2025.8.3.tar.gz", hash = "sha256:e564105f78ded564e3ae7c923924435e1daa7463faeab5bb932bc53ffae63407", size = 162386, upload-time = "2025-08-03T03:07:47.08Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", hash = "sha256:8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580", size = 137077, upload-time = "2026-04-22T11:26:11.191Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/48/1549795ba7742c948d2ad169c1c8cdbae65bc450d6cd753d124b17c8cd32/certifi-2025.8.3-py3-none-any.whl", hash = "sha256:f6c12493cfb1b06ba2ff328595af9350c65d6644968e5d3a2ffd78699af217a5", size = 161216, upload-time = "2025-08-03T03:07:45.777Z" },
+    { url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" },
 ]
 
 [[package]]
@@ -415,74 +439,64 @@ wheels = [
 
 [[package]]
 name = "charset-normalizer"
-version = "3.4.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/83/2d/5fd176ceb9b2fc619e63405525573493ca23441330fcdaee6bef9460e924/charset_normalizer-3.4.3.tar.gz", hash = "sha256:6fce4b8500244f6fcb71465d4a4930d132ba9ab8e71a7859e6a5d59851068d14", size = 122371, upload-time = "2025-08-09T07:57:28.46Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7f/b5/991245018615474a60965a7c9cd2b4efbaabd16d582a5547c47ee1c7730b/charset_normalizer-3.4.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b256ee2e749283ef3ddcff51a675ff43798d92d746d1a6e4631bf8c707d22d0b", size = 204483, upload-time = "2025-08-09T07:55:53.12Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/2a/ae245c41c06299ec18262825c1569c5d3298fc920e4ddf56ab011b417efd/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13faeacfe61784e2559e690fc53fa4c5ae97c6fcedb8eb6fb8d0a15b475d2c64", size = 145520, upload-time = "2025-08-09T07:55:54.712Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/a4/b3b6c76e7a635748c4421d2b92c7b8f90a432f98bda5082049af37ffc8e3/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:00237675befef519d9af72169d8604a067d92755e84fe76492fef5441db05b91", size = 158876, upload-time = "2025-08-09T07:55:56.024Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/e6/63bb0e10f90a8243c5def74b5b105b3bbbfb3e7bb753915fe333fb0c11ea/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:585f3b2a80fbd26b048a0be90c5aae8f06605d3c92615911c3a2b03a8a3b796f", size = 156083, upload-time = "2025-08-09T07:55:57.582Z" },
-    { url = "https://files.pythonhosted.org/packages/87/df/b7737ff046c974b183ea9aa111b74185ac8c3a326c6262d413bd5a1b8c69/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e78314bdc32fa80696f72fa16dc61168fda4d6a0c014e0380f9d02f0e5d8a07", size = 150295, upload-time = "2025-08-09T07:55:59.147Z" },
-    { url = "https://files.pythonhosted.org/packages/61/f1/190d9977e0084d3f1dc169acd060d479bbbc71b90bf3e7bf7b9927dec3eb/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:96b2b3d1a83ad55310de8c7b4a2d04d9277d5591f40761274856635acc5fcb30", size = 148379, upload-time = "2025-08-09T07:56:00.364Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/92/27dbe365d34c68cfe0ca76f1edd70e8705d82b378cb54ebbaeabc2e3029d/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:939578d9d8fd4299220161fdd76e86c6a251987476f5243e8864a7844476ba14", size = 160018, upload-time = "2025-08-09T07:56:01.678Z" },
-    { url = "https://files.pythonhosted.org/packages/99/04/baae2a1ea1893a01635d475b9261c889a18fd48393634b6270827869fa34/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:fd10de089bcdcd1be95a2f73dbe6254798ec1bda9f450d5828c96f93e2536b9c", size = 157430, upload-time = "2025-08-09T07:56:02.87Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/36/77da9c6a328c54d17b960c89eccacfab8271fdaaa228305330915b88afa9/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1e8ac75d72fa3775e0b7cb7e4629cec13b7514d928d15ef8ea06bca03ef01cae", size = 151600, upload-time = "2025-08-09T07:56:04.089Z" },
-    { url = "https://files.pythonhosted.org/packages/64/d4/9eb4ff2c167edbbf08cdd28e19078bf195762e9bd63371689cab5ecd3d0d/charset_normalizer-3.4.3-cp311-cp311-win32.whl", hash = "sha256:6cf8fd4c04756b6b60146d98cd8a77d0cdae0e1ca20329da2ac85eed779b6849", size = 99616, upload-time = "2025-08-09T07:56:05.658Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/9c/996a4a028222e7761a96634d1820de8a744ff4327a00ada9c8942033089b/charset_normalizer-3.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:31a9a6f775f9bcd865d88ee350f0ffb0e25936a7f930ca98995c05abf1faf21c", size = 107108, upload-time = "2025-08-09T07:56:07.176Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/5e/14c94999e418d9b87682734589404a25854d5f5d0408df68bc15b6ff54bb/charset_normalizer-3.4.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e28e334d3ff134e88989d90ba04b47d84382a828c061d0d1027b1b12a62b39b1", size = 205655, upload-time = "2025-08-09T07:56:08.475Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/a8/c6ec5d389672521f644505a257f50544c074cf5fc292d5390331cd6fc9c3/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0cacf8f7297b0c4fcb74227692ca46b4a5852f8f4f24b3c766dd94a1075c4884", size = 146223, upload-time = "2025-08-09T07:56:09.708Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/eb/a2ffb08547f4e1e5415fb69eb7db25932c52a52bed371429648db4d84fb1/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c6fd51128a41297f5409deab284fecbe5305ebd7e5a1f959bee1c054622b7018", size = 159366, upload-time = "2025-08-09T07:56:11.326Z" },
-    { url = "https://files.pythonhosted.org/packages/82/10/0fd19f20c624b278dddaf83b8464dcddc2456cb4b02bb902a6da126b87a1/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cfb2aad70f2c6debfbcb717f23b7eb55febc0bb23dcffc0f076009da10c6392", size = 157104, upload-time = "2025-08-09T07:56:13.014Z" },
-    { url = "https://files.pythonhosted.org/packages/16/ab/0233c3231af734f5dfcf0844aa9582d5a1466c985bbed6cedab85af9bfe3/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1606f4a55c0fd363d754049cdf400175ee96c992b1f8018b993941f221221c5f", size = 151830, upload-time = "2025-08-09T07:56:14.428Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/02/e29e22b4e02839a0e4a06557b1999d0a47db3567e82989b5bb21f3fbbd9f/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:027b776c26d38b7f15b26a5da1044f376455fb3766df8fc38563b4efbc515154", size = 148854, upload-time = "2025-08-09T07:56:16.051Z" },
-    { url = "https://files.pythonhosted.org/packages/05/6b/e2539a0a4be302b481e8cafb5af8792da8093b486885a1ae4d15d452bcec/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:42e5088973e56e31e4fa58eb6bd709e42fc03799c11c42929592889a2e54c491", size = 160670, upload-time = "2025-08-09T07:56:17.314Z" },
-    { url = "https://files.pythonhosted.org/packages/31/e7/883ee5676a2ef217a40ce0bffcc3d0dfbf9e64cbcfbdf822c52981c3304b/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cc34f233c9e71701040d772aa7490318673aa7164a0efe3172b2981218c26d93", size = 158501, upload-time = "2025-08-09T07:56:18.641Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/35/6525b21aa0db614cf8b5792d232021dca3df7f90a1944db934efa5d20bb1/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:320e8e66157cc4e247d9ddca8e21f427efc7a04bbd0ac8a9faf56583fa543f9f", size = 153173, upload-time = "2025-08-09T07:56:20.289Z" },
-    { url = "https://files.pythonhosted.org/packages/50/ee/f4704bad8201de513fdc8aac1cabc87e38c5818c93857140e06e772b5892/charset_normalizer-3.4.3-cp312-cp312-win32.whl", hash = "sha256:fb6fecfd65564f208cbf0fba07f107fb661bcd1a7c389edbced3f7a493f70e37", size = 99822, upload-time = "2025-08-09T07:56:21.551Z" },
-    { url = "https://files.pythonhosted.org/packages/39/f5/3b3836ca6064d0992c58c7561c6b6eee1b3892e9665d650c803bd5614522/charset_normalizer-3.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:86df271bf921c2ee3818f0522e9a5b8092ca2ad8b065ece5d7d9d0e9f4849bcc", size = 107543, upload-time = "2025-08-09T07:56:23.115Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1f/f041989e93b001bc4e44bb1669ccdcf54d3f00e628229a85b08d330615c5/charset_normalizer-3.4.3-py3-none-any.whl", hash = "sha256:ce571ab16d890d23b5c278547ba694193a45011ff86a9162a71307ed9f86759a", size = 53175, upload-time = "2025-08-09T07:57:26.864Z" },
+version = "3.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/d7/b5b7020a0565c2e9fa8c09f4b5fa6232feb326b8c20081ccded47ea368fd/charset_normalizer-3.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7641bb8895e77f921102f72833904dcd9901df5d6d72a2ab8f31d04b7e51e4e7", size = 309705, upload-time = "2026-04-02T09:26:02.191Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/53/58c29116c340e5456724ecd2fff4196d236b98f3da97b404bc5e51ac3493/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:202389074300232baeb53ae2569a60901f7efadd4245cf3a3bf0617d60b439d7", size = 206419, upload-time = "2026-04-02T09:26:03.583Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/02/e8146dc6591a37a00e5144c63f29fb7c97a734ea8a111190783c0e60ab63/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:30b8d1d8c52a48c2c5690e152c169b673487a2a58de1ec7393196753063fcd5e", size = 227901, upload-time = "2026-04-02T09:26:04.738Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/73/77486c4cd58f1267bf17db420e930c9afa1b3be3fe8c8b8ebbebc9624359/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:532bc9bf33a68613fd7d65e4b1c71a6a38d7d42604ecf239c77392e9b4e8998c", size = 222742, upload-time = "2026-04-02T09:26:06.36Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/fa/f74eb381a7d94ded44739e9d94de18dc5edc9c17fb8c11f0a6890696c0a9/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fe249cb4651fd12605b7288b24751d8bfd46d35f12a20b1ba33dea122e690df", size = 214061, upload-time = "2026-04-02T09:26:08.347Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/92/42bd3cefcf7687253fb86694b45f37b733c97f59af3724f356fa92b8c344/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:65bcd23054beab4d166035cabbc868a09c1a49d1efe458fe8e4361215df40265", size = 199239, upload-time = "2026-04-02T09:26:09.823Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/3d/069e7184e2aa3b3cddc700e3dd267413dc259854adc3380421c805c6a17d/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:08e721811161356f97b4059a9ba7bafb23ea5ee2255402c42881c214e173c6b4", size = 210173, upload-time = "2026-04-02T09:26:10.953Z" },
+    { url = "https://files.pythonhosted.org/packages/62/51/9d56feb5f2e7074c46f93e0ebdbe61f0848ee246e2f0d89f8e20b89ebb8f/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e060d01aec0a910bdccb8be71faf34e7799ce36950f8294c8bf612cba65a2c9e", size = 209841, upload-time = "2026-04-02T09:26:12.142Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/59/893d8f99cc4c837dda1fe2f1139079703deb9f321aabcb032355de13b6c7/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:38c0109396c4cfc574d502df99742a45c72c08eff0a36158b6f04000043dbf38", size = 200304, upload-time = "2026-04-02T09:26:13.711Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/1d/ee6f3be3464247578d1ed5c46de545ccc3d3ff933695395c402c21fa6b77/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1c2a768fdd44ee4a9339a9b0b130049139b8ce3c01d2ce09f67f5a68048d477c", size = 229455, upload-time = "2026-04-02T09:26:14.941Z" },
+    { url = "https://files.pythonhosted.org/packages/54/bb/8fb0a946296ea96a488928bdce8ef99023998c48e4713af533e9bb98ef07/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:1a87ca9d5df6fe460483d9a5bbf2b18f620cbed41b432e2bddb686228282d10b", size = 210036, upload-time = "2026-04-02T09:26:16.478Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/bc/015b2387f913749f82afd4fcba07846d05b6d784dd16123cb66860e0237d/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d635aab80466bc95771bb78d5370e74d36d1fe31467b6b29b8b57b2a3cd7d22c", size = 224739, upload-time = "2026-04-02T09:26:17.751Z" },
+    { url = "https://files.pythonhosted.org/packages/17/ab/63133691f56baae417493cba6b7c641571a2130eb7bceba6773367ab9ec5/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ae196f021b5e7c78e918242d217db021ed2a6ace2bc6ae94c0fc596221c7f58d", size = 216277, upload-time = "2026-04-02T09:26:18.981Z" },
+    { url = "https://files.pythonhosted.org/packages/06/6d/3be70e827977f20db77c12a97e6a9f973631a45b8d186c084527e53e77a4/charset_normalizer-3.4.7-cp311-cp311-win32.whl", hash = "sha256:adb2597b428735679446b46c8badf467b4ca5f5056aae4d51a19f9570301b1ad", size = 147819, upload-time = "2026-04-02T09:26:20.295Z" },
+    { url = "https://files.pythonhosted.org/packages/20/d9/5f67790f06b735d7c7637171bbfd89882ad67201891b7275e51116ed8207/charset_normalizer-3.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:8e385e4267ab76874ae30db04c627faaaf0b509e1ccc11a95b3fc3e83f855c00", size = 159281, upload-time = "2026-04-02T09:26:21.74Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/83/6413f36c5a34afead88ce6f66684d943d91f233d76dd083798f9602b75ae/charset_normalizer-3.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:d4a48e5b3c2a489fae013b7589308a40146ee081f6f509e047e0e096084ceca1", size = 147843, upload-time = "2026-04-02T09:26:22.901Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" },
+    { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" },
+    { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" },
+    { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" },
+    { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" },
 ]
 
 [[package]]
 name = "click"
-version = "8.3.0"
+version = "8.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/46/61/de6cd827efad202d7057d93e0fed9294b96952e188f7384832791c7b2254/click-8.3.0.tar.gz", hash = "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4", size = 276943, upload-time = "2025-09-18T17:32:23.696Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/23/e4/796662cd90cf80e3a363c99db2b88e0e394b988a575f60a17e16440cd011/click-8.4.0.tar.gz", hash = "sha256:638f1338fe1235c8f4e008e4a8a254fb5c5fbdcbb40ece3c9142ebb78e792973", size = 350843, upload-time = "2026-05-17T00:47:58.425Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/db/d3/9dcc0f5797f070ec8edf30fbadfb200e71d9db6b84d211e3b2085a7589a0/click-8.3.0-py3-none-any.whl", hash = "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", size = 107295, upload-time = "2025-09-18T17:32:22.42Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ae/8e92f8058baf87f6c7d86ee7e457668690195cc77efedb8d3797a06e3940/click-8.4.0-py3-none-any.whl", hash = "sha256:40c50b7c6c6adac2823d411041ec84f3f103f1b280d5e9ce0d7f998995832f81", size = 116147, upload-time = "2026-05-17T00:47:56.842Z" },
 ]
 
 [[package]]
 name = "cloudpathlib"
-version = "0.22.0"
+version = "0.24.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/05/bc/d7345595a4467144b9e0b32e5eda9e4633ea6e4982262b0696935adb2229/cloudpathlib-0.22.0.tar.gz", hash = "sha256:6c0cb0ceab4f66a3a05a84055f9318fb8316cae5e096819f3f8e4be64feab6e9", size = 52304, upload-time = "2025-08-30T05:20:04.6Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/19/58bc6b5d7d0f81c7209b05445af477e147c486552f96665a5912211839b9/cloudpathlib-0.24.0.tar.gz", hash = "sha256:c521a984e77b47e656fe78e20a7e3e260e0ab45fc69e33ac01094227c979e34a", size = 53600, upload-time = "2026-04-30T00:54:43.265Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f1/72/e8e53d8232e801e040f4b557ff3a453cecbb630d53ae107bd5e66a206bb9/cloudpathlib-0.22.0-py3-none-any.whl", hash = "sha256:2fdfaf5c4f85810ae8374d336d04dee371914d0e41a984695ae67308d7a5a009", size = 61520, upload-time = "2025-08-30T05:20:03.232Z" },
-]
-
-[[package]]
-name = "cohere"
-version = "5.18.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "fastavro" },
-    { name = "httpx" },
-    { name = "httpx-sse" },
-    { name = "pydantic" },
-    { name = "pydantic-core" },
-    { name = "requests" },
-    { name = "tokenizers" },
-    { name = "types-requests" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0d/f5/4682a965449826044c853c82796805f8d3e9214471e2f120db3063116584/cohere-5.18.0.tar.gz", hash = "sha256:93a7753458a45cd30c796300182d22bb1889eadc510727e1de3d8342cb2bc0bf", size = 164340, upload-time = "2025-09-12T14:17:16.776Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/23/9b/3dc80542e60c711d57777b836a64345dda28f826c14fd64d9123278fcbfe/cohere-5.18.0-py3-none-any.whl", hash = "sha256:885e7be360206418db39425faa60dbcd7f38e39e7f84b824ee68442e6a436e93", size = 295384, upload-time = "2025-09-12T14:17:15.421Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/5b/ba933f896d9b0b07608d575a8501e2b4e32166b60d84c430a4a7285ebe64/cloudpathlib-0.24.0-py3-none-any.whl", hash = "sha256:b1c51e2d2ec7dc4fed6538991f4aea849d6cf11a7e6b9069f86e461aa1f9b5b4", size = 63214, upload-time = "2026-04-30T00:54:42.06Z" },
 ]
 
 [[package]]
@@ -522,37 +536,41 @@ wheels = [
 
 [[package]]
 name = "coverage"
-version = "7.10.7"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/51/26/d22c300112504f5f9a9fd2297ce33c35f3d353e4aeb987c8419453b2a7c2/coverage-7.10.7.tar.gz", hash = "sha256:f4ab143ab113be368a3e9b795f9cd7906c5ef407d6173fe9675a902e1fffc239", size = 827704, upload-time = "2025-09-21T20:03:56.815Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/5d/c1a17867b0456f2e9ce2d8d4708a4c3a089947d0bec9c66cdf60c9e7739f/coverage-7.10.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a609f9c93113be646f44c2a0256d6ea375ad047005d7f57a5c15f614dc1b2f59", size = 218102, upload-time = "2025-09-21T20:01:16.089Z" },
-    { url = "https://files.pythonhosted.org/packages/54/f0/514dcf4b4e3698b9a9077f084429681bf3aad2b4a72578f89d7f643eb506/coverage-7.10.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:65646bb0359386e07639c367a22cf9b5bf6304e8630b565d0626e2bdf329227a", size = 218505, upload-time = "2025-09-21T20:01:17.788Z" },
-    { url = "https://files.pythonhosted.org/packages/20/f6/9626b81d17e2a4b25c63ac1b425ff307ecdeef03d67c9a147673ae40dc36/coverage-7.10.7-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5f33166f0dfcce728191f520bd2692914ec70fac2713f6bf3ce59c3deacb4699", size = 248898, upload-time = "2025-09-21T20:01:19.488Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/ef/bd8e719c2f7417ba03239052e099b76ea1130ac0cbb183ee1fcaa58aaff3/coverage-7.10.7-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:35f5e3f9e455bb17831876048355dca0f758b6df22f49258cb5a91da23ef437d", size = 250831, upload-time = "2025-09-21T20:01:20.817Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/b6/bf054de41ec948b151ae2b79a55c107f5760979538f5fb80c195f2517718/coverage-7.10.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4da86b6d62a496e908ac2898243920c7992499c1712ff7c2b6d837cc69d9467e", size = 252937, upload-time = "2025-09-21T20:01:22.171Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/e5/3860756aa6f9318227443c6ce4ed7bf9e70bb7f1447a0353f45ac5c7974b/coverage-7.10.7-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6b8b09c1fad947c84bbbc95eca841350fad9cbfa5a2d7ca88ac9f8d836c92e23", size = 249021, upload-time = "2025-09-21T20:01:23.907Z" },
-    { url = "https://files.pythonhosted.org/packages/26/0f/bd08bd042854f7fd07b45808927ebcce99a7ed0f2f412d11629883517ac2/coverage-7.10.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4376538f36b533b46f8971d3a3e63464f2c7905c9800db97361c43a2b14792ab", size = 250626, upload-time = "2025-09-21T20:01:25.721Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/a7/4777b14de4abcc2e80c6b1d430f5d51eb18ed1d75fca56cbce5f2db9b36e/coverage-7.10.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:121da30abb574f6ce6ae09840dae322bef734480ceafe410117627aa54f76d82", size = 248682, upload-time = "2025-09-21T20:01:27.105Z" },
-    { url = "https://files.pythonhosted.org/packages/34/72/17d082b00b53cd45679bad682fac058b87f011fd8b9fe31d77f5f8d3a4e4/coverage-7.10.7-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:88127d40df529336a9836870436fc2751c339fbaed3a836d42c93f3e4bd1d0a2", size = 248402, upload-time = "2025-09-21T20:01:28.629Z" },
-    { url = "https://files.pythonhosted.org/packages/81/7a/92367572eb5bdd6a84bfa278cc7e97db192f9f45b28c94a9ca1a921c3577/coverage-7.10.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ba58bbcd1b72f136080c0bccc2400d66cc6115f3f906c499013d065ac33a4b61", size = 249320, upload-time = "2025-09-21T20:01:30.004Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/88/a23cc185f6a805dfc4fdf14a94016835eeb85e22ac3a0e66d5e89acd6462/coverage-7.10.7-cp311-cp311-win32.whl", hash = "sha256:972b9e3a4094b053a4e46832b4bc829fc8a8d347160eb39d03f1690316a99c14", size = 220536, upload-time = "2025-09-21T20:01:32.184Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/ef/0b510a399dfca17cec7bc2f05ad8bd78cf55f15c8bc9a73ab20c5c913c2e/coverage-7.10.7-cp311-cp311-win_amd64.whl", hash = "sha256:a7b55a944a7f43892e28ad4bc0561dfd5f0d73e605d1aa5c3c976b52aea121d2", size = 221425, upload-time = "2025-09-21T20:01:33.557Z" },
-    { url = "https://files.pythonhosted.org/packages/51/7f/023657f301a276e4ba1850f82749bc136f5a7e8768060c2e5d9744a22951/coverage-7.10.7-cp311-cp311-win_arm64.whl", hash = "sha256:736f227fb490f03c6488f9b6d45855f8e0fd749c007f9303ad30efab0e73c05a", size = 220103, upload-time = "2025-09-21T20:01:34.929Z" },
-    { url = "https://files.pythonhosted.org/packages/13/e4/eb12450f71b542a53972d19117ea5a5cea1cab3ac9e31b0b5d498df1bd5a/coverage-7.10.7-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7bb3b9ddb87ef7725056572368040c32775036472d5a033679d1fa6c8dc08417", size = 218290, upload-time = "2025-09-21T20:01:36.455Z" },
-    { url = "https://files.pythonhosted.org/packages/37/66/593f9be12fc19fb36711f19a5371af79a718537204d16ea1d36f16bd78d2/coverage-7.10.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:18afb24843cbc175687225cab1138c95d262337f5473512010e46831aa0c2973", size = 218515, upload-time = "2025-09-21T20:01:37.982Z" },
-    { url = "https://files.pythonhosted.org/packages/66/80/4c49f7ae09cafdacc73fbc30949ffe77359635c168f4e9ff33c9ebb07838/coverage-7.10.7-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:399a0b6347bcd3822be369392932884b8216d0944049ae22925631a9b3d4ba4c", size = 250020, upload-time = "2025-09-21T20:01:39.617Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/90/a64aaacab3b37a17aaedd83e8000142561a29eb262cede42d94a67f7556b/coverage-7.10.7-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:314f2c326ded3f4b09be11bc282eb2fc861184bc95748ae67b360ac962770be7", size = 252769, upload-time = "2025-09-21T20:01:41.341Z" },
-    { url = "https://files.pythonhosted.org/packages/98/2e/2dda59afd6103b342e096f246ebc5f87a3363b5412609946c120f4e7750d/coverage-7.10.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c41e71c9cfb854789dee6fc51e46743a6d138b1803fab6cb860af43265b42ea6", size = 253901, upload-time = "2025-09-21T20:01:43.042Z" },
-    { url = "https://files.pythonhosted.org/packages/53/dc/8d8119c9051d50f3119bb4a75f29f1e4a6ab9415cd1fa8bf22fcc3fb3b5f/coverage-7.10.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc01f57ca26269c2c706e838f6422e2a8788e41b3e3c65e2f41148212e57cd59", size = 250413, upload-time = "2025-09-21T20:01:44.469Z" },
-    { url = "https://files.pythonhosted.org/packages/98/b3/edaff9c5d79ee4d4b6d3fe046f2b1d799850425695b789d491a64225d493/coverage-7.10.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a6442c59a8ac8b85812ce33bc4d05bde3fb22321fa8294e2a5b487c3505f611b", size = 251820, upload-time = "2025-09-21T20:01:45.915Z" },
-    { url = "https://files.pythonhosted.org/packages/11/25/9a0728564bb05863f7e513e5a594fe5ffef091b325437f5430e8cfb0d530/coverage-7.10.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:78a384e49f46b80fb4c901d52d92abe098e78768ed829c673fbb53c498bef73a", size = 249941, upload-time = "2025-09-21T20:01:47.296Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/fd/ca2650443bfbef5b0e74373aac4df67b08180d2f184b482c41499668e258/coverage-7.10.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:5e1e9802121405ede4b0133aa4340ad8186a1d2526de5b7c3eca519db7bb89fb", size = 249519, upload-time = "2025-09-21T20:01:48.73Z" },
-    { url = "https://files.pythonhosted.org/packages/24/79/f692f125fb4299b6f963b0745124998ebb8e73ecdfce4ceceb06a8c6bec5/coverage-7.10.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d41213ea25a86f69efd1575073d34ea11aabe075604ddf3d148ecfec9e1e96a1", size = 251375, upload-time = "2025-09-21T20:01:50.529Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/75/61b9bbd6c7d24d896bfeec57acba78e0f8deac68e6baf2d4804f7aae1f88/coverage-7.10.7-cp312-cp312-win32.whl", hash = "sha256:77eb4c747061a6af8d0f7bdb31f1e108d172762ef579166ec84542f711d90256", size = 220699, upload-time = "2025-09-21T20:01:51.941Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/f3/3bf7905288b45b075918d372498f1cf845b5b579b723c8fd17168018d5f5/coverage-7.10.7-cp312-cp312-win_amd64.whl", hash = "sha256:f51328ffe987aecf6d09f3cd9d979face89a617eacdaea43e7b3080777f647ba", size = 221512, upload-time = "2025-09-21T20:01:53.481Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/44/3e32dbe933979d05cf2dac5e697c8599cfe038aaf51223ab901e208d5a62/coverage-7.10.7-cp312-cp312-win_arm64.whl", hash = "sha256:bda5e34f8a75721c96085903c6f2197dc398c20ffd98df33f866a9c8fd95f4bf", size = 220147, upload-time = "2025-09-21T20:01:55.2Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/16/114df1c291c22cac3b0c127a73e0af5c12ed7bbb6558d310429a0ae24023/coverage-7.10.7-py3-none-any.whl", hash = "sha256:f7941f6f2fe6dd6807a1208737b8a0cbcf1cc6d7b07d24998ad2d63590868260", size = 209952, upload-time = "2025-09-21T20:03:53.918Z" },
+version = "7.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/23/7f/d0720730a397a999ffc0fd3f5bebef347338e3a47b727da66fbb228e2ff2/coverage-7.14.0.tar.gz", hash = "sha256:057a6af2f160a85384cde4ab36f0d2777bae1057bae255f95413cdd382aa5c74", size = 919489, upload-time = "2026-05-10T18:02:31.397Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/e4/649c8d4f7f1709b6dbfc474358aa1bba02f67bcd52e2fec291a5014006cd/coverage-7.14.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a78e2a9d9c5e3b8d4ab9b9d28c985ea66fced0a7d7c2aec1f216e03a2011480", size = 219795, upload-time = "2026-05-10T17:59:48.198Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/8d/46692d24b3f395d4cbf17bfcc57136b4f2f9c0c0df864b0bddfc1d71a014/coverage-7.14.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a1816c505187592dcd1c5a5f226601a549f70365fbd00930ac88b0c225b76bb4", size = 220299, upload-time = "2026-05-10T17:59:49.683Z" },
+    { url = "https://files.pythonhosted.org/packages/12/c2/a40f5cb295bbcbb697a76947a56081c494c61950366294ee426ffe261099/coverage-7.14.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d8e1762f0e9cbc26ec315471e7b47855218e833cd5a032d706fbf43845d878c7", size = 250721, upload-time = "2026-05-10T17:59:51.494Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/35/202235eb5c3c14c212462cd91d61b7386bf8fc44bc7a77f4742d2a69174b/coverage-7.14.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9336e23e8bb3a3925398261385e2a1533957d3e760e91070dcb0e98bfa514eed", size = 252633, upload-time = "2026-05-10T17:59:53.244Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/80/5f596e8995785124ee191c42535664c5e62c65995b66f4ca21e28ae04c81/coverage-7.14.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd1169b2230f9cbe9c638ba38022ed7a2b1e641cc07f7cea0365e4be2a74980", size = 254743, upload-time = "2026-05-10T17:59:55.021Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/6d/0d178825be2350f0adb27984d0aa7cf84bbdab201f6fb926b535d23a8f5f/coverage-7.14.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d1bb3543b58fea74d2cd1abc4054cc927e4724687cb4560cd2ed88d2c7d820c0", size = 256700, upload-time = "2026-05-10T17:59:56.511Z" },
+    { url = "https://files.pythonhosted.org/packages/19/5b/9e549c2f6e9dfea472adadba06c294e64735dabc2dd19015fac082095013/coverage-7.14.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a93bac2cb577ef60074999ed56d8a1535894398e2ed920d4185c3ec0c8864742", size = 250854, upload-time = "2026-05-10T17:59:57.94Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/1c/b94f9f5f36396021ee2f62c5834b12e6a3d31f0bed5d6fc6d1c3caec087c/coverage-7.14.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5904abf7e18cddc463219b17552229650c6b79e061d31a1059283051169cf7d5", size = 252433, upload-time = "2026-05-10T17:59:59.688Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/cb/d192cd8e1345eccabc32016f2d39072ecd10cb4f4b983ed8d0ebdeaf00dc/coverage-7.14.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:741f57cddc9004a8c81b084660215f33a6b597dbe62c31386b983ee26310e327", size = 250494, upload-time = "2026-05-10T18:00:01.953Z" },
+    { url = "https://files.pythonhosted.org/packages/53/c5/aac9f460a41d835dbddef1d377f105f6ac2311d0f3c1588e9f51046d8813/coverage-7.14.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:664123feb0929d7affc135717dbd70d61d98688a08ab1e5ba464739620c6252d", size = 254261, upload-time = "2026-05-10T18:00:03.779Z" },
+    { url = "https://files.pythonhosted.org/packages/23/aa/7af7c0081980a9cb3d289c5a435a4b7657dcecbd128e25c580e6a50389b5/coverage-7.14.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:c83d2399a51bbec8429266905d33616f04bc5726b1138c35844d5fcd896b2e20", size = 250216, upload-time = "2026-05-10T18:00:05.262Z" },
+    { url = "https://files.pythonhosted.org/packages/35/60/a4257538ce2f6b978aeb51870d6c4208c510928a03db7e0339bb625dccb7/coverage-7.14.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb2e855b87321259a037429288ae85216d191c74de3e79bf57cd2bc0761992c", size = 251125, upload-time = "2026-05-10T18:00:06.858Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/ab/f91af47642ec1aa53490e835a95847168d9c77fc39aa58527604c051e145/coverage-7.14.0-cp311-cp311-win32.whl", hash = "sha256:731dc15b385ac52289743d476245b61e1a2927e803bef655b52bc3b2a75a21f3", size = 222300, upload-time = "2026-05-10T18:00:08.608Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/f0/a71ddbd874431e7a7cd96071f0c331cfbbad07704833c765d24ffbab8a67/coverage-7.14.0-cp311-cp311-win_amd64.whl", hash = "sha256:bfb0ed8ec5d25e93face268115d7964db9df8b9aae8edcde9ec6b16c726a7cc1", size = 223241, upload-time = "2026-05-10T18:00:10.746Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/6e/d9d312a5151a96cd110efee32efc3fc97b01ebd86203fe618ccb29cf4c92/coverage-7.14.0-cp311-cp311-win_arm64.whl", hash = "sha256:7ebb1c6df9f78046a1b1e0a89674cd4bf73b7c648914eebcf976a57fd99a5627", size = 221908, upload-time = "2026-05-10T18:00:12.242Z" },
+    { url = "https://files.pythonhosted.org/packages/09/1e/2f996b2c8415cbb6f54b0f5ec1ee850c96d7911961afb4fc05f4a89d8c58/coverage-7.14.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7ffd19fc8aed057fd686a17a4935eef5f9859d69208f96310e893e64b9b6ccf5", size = 219967, upload-time = "2026-05-10T18:00:13.756Z" },
+    { url = "https://files.pythonhosted.org/packages/34/23/35c7aea1274aef7525bdd2dc92f710bdde6d11652239d71d1ec450067939/coverage-7.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:829994cfe1aeb773ca27bf246d4badc1e764893e3bfb98fff820fcecd1ca4662", size = 220329, upload-time = "2026-05-10T18:00:15.264Z" },
+    { url = "https://files.pythonhosted.org/packages/75/cf/a8f4b43a16e194b0261257ad28ded5853ec052570afef4a84e1d81189f3b/coverage-7.14.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b4f07cf7edcb7ec39431a5074d7ea83b29a9f71fcfc494f0f40af4e65180420f", size = 251839, upload-time = "2026-05-10T18:00:17.16Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ff/6699e7b71e60d3049eb2bdcbc95ee3f35707b2b0e48f32e9e63d3ce30c08/coverage-7.14.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ca3d9cf2c32b521bd9518385608787fa86f38daf993695307531822c3430ed67", size = 254576, upload-time = "2026-05-10T18:00:18.829Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ec/c936d495fcd67f48f03a9c4ad3297ff80d1f222a5df3980f15b34c186c21/coverage-7.14.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92af52828e7f29d827346b0294e5a0853fa206db77db0395b282918d41e28db9", size = 255690, upload-time = "2026-05-10T18:00:20.648Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/42/5af63f636cc62a4a2b1b3ba9146f6ee6f53a35a50d5cefc54d5670f60999/coverage-7.14.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7b2bb6c9d7e769360d0f20a0f219603fd64f0c8f97de17ab25853261602be0fb", size = 257949, upload-time = "2026-05-10T18:00:22.28Z" },
+    { url = "https://files.pythonhosted.org/packages/26/d3/a225317bd2012132a27e1176d51660b826f99bb975876463c44ea0d7ee5a/coverage-7.14.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1c9ed6ef99f88fb8c14aa8e2bf8eb0fe55fa2edfea68f8675d78741df1a5ac0e", size = 252242, upload-time = "2026-05-10T18:00:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/7f/9e65495298c3ea414742998539c37d048b5e81cc818fb1828cc6b51d10bf/coverage-7.14.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8231ade007f37959fbf58acc677f26b922c02eda6f0428ea307da0fd39681bf3", size = 253608, upload-time = "2026-05-10T18:00:25.588Z" },
+    { url = "https://files.pythonhosted.org/packages/94/46/1522b524a35bdad22b2b8c4f9d32d0a104b524726ec380b2db68db1746f5/coverage-7.14.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d8b013632cc1ce1d09dbe4f32667b4d320ec2f54fc326ebeffcd0b0bcc2bb6c4", size = 251753, upload-time = "2026-05-10T18:00:27.104Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/e9/cdf00d38817742c541ade405e115a3f7bf36e6f2a8b99d4f209861b85a2d/coverage-7.14.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1733198802d71ec4c524f322e2867ee05c62e9e75df86bdca545407a221827d1", size = 255823, upload-time = "2026-05-10T18:00:29.038Z" },
+    { url = "https://files.pythonhosted.org/packages/38/fc/5e7877cf5f902d08a17ff1c532511476d87e1bea355bd5028cb97f902e79/coverage-7.14.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:72a305291fa8ee01332f1aaf38b348ca34097f6aa0b0ef627eef2837e57bbba5", size = 251323, upload-time = "2026-05-10T18:00:30.647Z" },
+    { url = "https://files.pythonhosted.org/packages/18/9d/50f05a72dff8487464fdd4178dda5daed642a060e60afb644e3d45123559/coverage-7.14.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fcaba850dd317c65423a9d63d88f9573c53b00354d6dd95724576cc98a131595", size = 253197, upload-time = "2026-05-10T18:00:32.211Z" },
+    { url = "https://files.pythonhosted.org/packages/00/3f/6f61ffe6439df266c3cf60f5c99cfaa21103d0210d706a42fc6c30683ff8/coverage-7.14.0-cp312-cp312-win32.whl", hash = "sha256:5ac83957a80d0701310e96d8bec68cdcf4f90a7674b7d13f15a344315b41ab27", size = 222515, upload-time = "2026-05-10T18:00:33.717Z" },
+    { url = "https://files.pythonhosted.org/packages/85/19/93853133df2cb371083285ef6a93982a0173e7a233b0f61373ba9fd30eb2/coverage-7.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:70390b0da32cb90b501953716302906e8bcce087cb283e70d8c97729f22e92b2", size = 223324, upload-time = "2026-05-10T18:00:35.172Z" },
+    { url = "https://files.pythonhosted.org/packages/74/18/9f7fe62f659f24b7a82a0be56bf94c1bd0a89e0ae7ab4c668f6e82404294/coverage-7.14.0-cp312-cp312-win_arm64.whl", hash = "sha256:91b993743d959b8be85b4abf9d5478216a69329c321efe5be0433c1a841d691d", size = 221944, upload-time = "2026-05-10T18:00:37.014Z" },
+    { url = "https://files.pythonhosted.org/packages/61/e8/cb8e80d6f9f55b99588625062822bf946cf03ed06315df4bd8397f5632a1/coverage-7.14.0-py3-none-any.whl", hash = "sha256:8de5b61163aee3d05c8a2beab6f47913df7981dad1baf82c414d99158c286ab1", size = 211764, upload-time = "2026-05-10T18:02:29.538Z" },
 ]
 
 [package.optional-dependencies]
@@ -562,71 +580,104 @@ toml = [
 
 [[package]]
 name = "cryptography"
-version = "46.0.3"
+version = "48.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/42/9c391dd801d6cf0d561b5890549d4b27bafcc53b39c31a817e69d87c625b/cryptography-46.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:109d4ddfadf17e8e7779c39f9b18111a09efb969a301a31e987416a0191ed93a", size = 7225004, upload-time = "2025-10-15T23:16:52.239Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" },
-    { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" },
-    { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" },
-    { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" },
-    { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" },
-    { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" },
-    { url = "https://files.pythonhosted.org/packages/96/92/8a6a9525893325fc057a01f654d7efc2c64b9de90413adcf605a85744ff4/cryptography-46.0.3-cp311-abi3-win32.whl", hash = "sha256:f260d0d41e9b4da1ed1e0f1ce571f97fe370b152ab18778e9e8f67d6af432018", size = 3055988, upload-time = "2025-10-15T23:17:14.65Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/bf/80fbf45253ea585a1e492a6a17efcb93467701fa79e71550a430c5e60df0/cryptography-46.0.3-cp311-abi3-win_amd64.whl", hash = "sha256:a9a3008438615669153eb86b26b61e09993921ebdd75385ddd748702c5adfddb", size = 3514451, upload-time = "2025-10-15T23:17:16.142Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/af/9b302da4c87b0beb9db4e756386a7c6c5b8003cd0e742277888d352ae91d/cryptography-46.0.3-cp311-abi3-win_arm64.whl", hash = "sha256:5d7f93296ee28f68447397bf5198428c9aeeab45705a55d53a6343455dcb2c3c", size = 2928007, upload-time = "2025-10-15T23:17:18.04Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/23/45fe7f376a7df8daf6da3556603b36f53475a99ce4faacb6ba2cf3d82021/cryptography-46.0.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:cb3d760a6117f621261d662bccc8ef5bc32ca673e037c83fbe565324f5c46936", size = 7218248, upload-time = "2025-10-15T23:17:46.294Z" },
-    { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" },
-    { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" },
-    { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" },
-    { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/6e/1c8331ddf91ca4730ab3086a0f1be19c65510a33b5a441cb334e7a2d2560/cryptography-46.0.3-cp38-abi3-win32.whl", hash = "sha256:6276eb85ef938dc035d59b87c8a7dc559a232f954962520137529d77b18ff1df", size = 3036695, upload-time = "2025-10-15T23:18:08.672Z" },
-    { url = "https://files.pythonhosted.org/packages/90/45/b0d691df20633eff80955a0fc7695ff9051ffce8b69741444bd9ed7bd0db/cryptography-46.0.3-cp38-abi3-win_amd64.whl", hash = "sha256:416260257577718c05135c55958b674000baef9a1c7d9e8f306ec60d71db850f", size = 3501720, upload-time = "2025-10-15T23:18:10.632Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload-time = "2025-10-15T23:18:12.277Z" },
-    { url = "https://files.pythonhosted.org/packages/06/8a/e60e46adab4362a682cf142c7dcb5bf79b782ab2199b0dcb81f55970807f/cryptography-46.0.3-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7ce938a99998ed3c8aa7e7272dca1a610401ede816d36d0693907d863b10d9ea", size = 3698132, upload-time = "2025-10-15T23:18:17.056Z" },
-    { url = "https://files.pythonhosted.org/packages/da/38/f59940ec4ee91e93d3311f7532671a5cef5570eb04a144bf203b58552d11/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:191bb60a7be5e6f54e30ba16fdfae78ad3a342a0599eb4193ba88e3f3d6e185b", size = 4243992, upload-time = "2025-10-15T23:18:18.695Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/0c/35b3d92ddebfdfda76bb485738306545817253d0a3ded0bfe80ef8e67aa5/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c70cc23f12726be8f8bc72e41d5065d77e4515efae3690326764ea1b07845cfb", size = 4409944, upload-time = "2025-10-15T23:18:20.597Z" },
-    { url = "https://files.pythonhosted.org/packages/99/55/181022996c4063fc0e7666a47049a1ca705abb9c8a13830f074edb347495/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:9394673a9f4de09e28b5356e7fff97d778f8abad85c9d5ac4a4b7e25a0de7717", size = 4242957, upload-time = "2025-10-15T23:18:22.18Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/af/72cd6ef29f9c5f731251acadaeb821559fe25f10852f44a63374c9ca08c1/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:94cd0549accc38d1494e1f8de71eca837d0509d0d44bf11d158524b0e12cebf9", size = 4409447, upload-time = "2025-10-15T23:18:24.209Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/c3/e90f4a4feae6410f914f8ebac129b9ae7a8c92eb60a638012dde42030a9d/cryptography-46.0.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6b5063083824e5509fdba180721d55909ffacccc8adbec85268b48439423d78c", size = 3438528, upload-time = "2025-10-15T23:18:26.227Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/9f/a9/db8f313fdcd85d767d4973515e1db101f9c71f95fced83233de224673757/cryptography-48.0.0.tar.gz", hash = "sha256:5c3932f4436d1cccb036cb0eaef46e6e2db91035166f1ad6505c3c9d5a635920", size = 832984, upload-time = "2026-05-04T22:59:38.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/3d/01f6dd9190170a5a241e0e98c2d04be3664a9e6f5b9b872cde63aff1c3dd/cryptography-48.0.0-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:0c558d2cdffd8f4bbb30fc7134c74d2ca9a476f830bb053074498fbc86f41ed6", size = 8001587, upload-time = "2026-05-04T22:57:36.803Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/6e/e90527eef33f309beb811cf7c982c3aeffcce8e3edb178baa4ca3ae4a6fa/cryptography-48.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f5333311663ea94f75dd408665686aaf426563556bb5283554a3539177e03b8c", size = 4690433, upload-time = "2026-05-04T22:57:40.373Z" },
+    { url = "https://files.pythonhosted.org/packages/90/04/673510ed51ddff56575f306cf1617d80411ee76831ccd3097599140efdfe/cryptography-48.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7995ef305d7165c3f11ae07f2517e5a4f1d5c18da1376a0a9ed496336b69e5f3", size = 4710620, upload-time = "2026-05-04T22:57:42.935Z" },
+    { url = "https://files.pythonhosted.org/packages/14/d5/e9c4ef932c8d800490c34d8bd589d64a31d5890e27ec9e9ad532be893294/cryptography-48.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:40ba1f85eaa6959837b1d51c9767e230e14612eea4ef110ee8854ada22da1bf5", size = 4696283, upload-time = "2026-05-04T22:57:45.294Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/29/174b9dfb60b12d59ecfc6cfa04bc88c21b42a54f01b8aae09bb6e51e4c7f/cryptography-48.0.0-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:369a6348999f94bbd53435c894377b20ab95f25a9065c283570e70150d8abc3c", size = 5296573, upload-time = "2026-05-04T22:57:47.933Z" },
+    { url = "https://files.pythonhosted.org/packages/95/38/0d29a6fd7d0d1373f0c0c88a04ba20e359b257753ac497564cd660fc1d55/cryptography-48.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a0e692c683f4df67815a2d258b324e66f4738bd7a96a218c826dce4f4bd05d8f", size = 4743677, upload-time = "2026-05-04T22:57:50.067Z" },
+    { url = "https://files.pythonhosted.org/packages/30/be/eef653013d5c63b6a490529e0316f9ac14a37602965d4903efed1399f32b/cryptography-48.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:18349bbc56f4743c8b12dc32e2bccb2cf83ee8b69a3bba74ef8ae857e26b3d25", size = 4330808, upload-time = "2026-05-04T22:57:52.301Z" },
+    { url = "https://files.pythonhosted.org/packages/84/9e/500463e87abb7a0a0f9f256ec21123ecde0a7b5541a15e840ea54551fd81/cryptography-48.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:7e8eac43dfca5c4cccc6dad9a80504436fca53bb9bc3100a2386d730fbe6b602", size = 4695941, upload-time = "2026-05-04T22:57:54.603Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/dc/7303087450c2ec9e7fbb750e17c2abfbc658f23cbd0e54009509b7cc4091/cryptography-48.0.0-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:9ccdac7d40688ecb5a3b4a604b8a88c8002e3442d6c60aead1db2a89a041560c", size = 5252579, upload-time = "2026-05-04T22:57:57.207Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/c0/7101d3b7215edcdc90c45da544961fd8ed2d6448f77577460fa75a8443f7/cryptography-48.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:bd72e68b06bb1e96913f97dd4901119bc17f39d4586a5adf2d3e47bc2b9d58b5", size = 4743326, upload-time = "2026-05-04T22:57:59.535Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/d8/5b833bad13016f562ab9d063d68199a4bd121d18458e439515601d3357ec/cryptography-48.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:59baa2cb386c4f0b9905bd6eb4c2a79a69a128408fd31d32ca4d7102d4156321", size = 4826672, upload-time = "2026-05-04T22:58:01.996Z" },
+    { url = "https://files.pythonhosted.org/packages/98/e1/7074eb8bf3c135558c73fc2bcf0f5633f912e6fb87e868a55c454080ef09/cryptography-48.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9249e3cd978541d665967ac2cb2787fd6a62bddf1e75b3e347a594d7dacf4f74", size = 4972574, upload-time = "2026-05-04T22:58:03.968Z" },
+    { url = "https://files.pythonhosted.org/packages/04/70/e5a1b41d325f797f39427aa44ef8baf0be500065ab6d8e10369d850d4a4f/cryptography-48.0.0-cp311-abi3-win32.whl", hash = "sha256:9c459db21422be75e2809370b829a87eb37f74cd785fc4aa9ea1e5f43b47cda4", size = 3294868, upload-time = "2026-05-04T22:58:06.467Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/ac/8ac51b4a5fc5932eb7ee5c517ba7dc8cd834f0048962b6b352f00f41ebf9/cryptography-48.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:5b012212e08b8dd5edc78ef54da83dd9892fd9105323b3993eff6bea65dc21d7", size = 3817107, upload-time = "2026-05-04T22:58:08.845Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/63/61d4a4e1c6b6bab6ce1e213cd36a24c415d90e76d78c5eb8577c5541d2e8/cryptography-48.0.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:58d00498e8933e4a194f3076aee1b4a97dfec1a6da444535755822fe5d8b0b86", size = 7983482, upload-time = "2026-05-04T22:58:43.769Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ac/f5b5995b87770c693e2596559ffafe195b4033a57f14a82268a2842953f3/cryptography-48.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:614d0949f4790582d2cc25553abd09dd723025f0c0e7c67376a1d77196743d6e", size = 4683266, upload-time = "2026-05-04T22:58:46.064Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/c6/8b14f67e18338fbc4adb76f66c001f5c3610b3e2d1837f268f47a347dbbb/cryptography-48.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7ce4bfae76319a532a2dc68f82cc32f5676ee792a983187dac07183690e5c66f", size = 4696228, upload-time = "2026-05-04T22:58:48.22Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/73/f808fbae9514bd91b47875b003f13e284c8c6bdfd904b7944e803937eec1/cryptography-48.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:2eb992bbd4661238c5a397594c83f5b4dc2bc5b848c365c8f991b6780efcc5c7", size = 4689097, upload-time = "2026-05-04T22:58:50.9Z" },
+    { url = "https://files.pythonhosted.org/packages/93/01/d86632d7d28db8ae83221995752eeb6639ffb374c2d22955648cf8d52797/cryptography-48.0.0-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:22a5cb272895dce158b2cacdfdc3debd299019659f42947dbdac6f32d68fe832", size = 5283582, upload-time = "2026-05-04T22:58:53.017Z" },
+    { url = "https://files.pythonhosted.org/packages/02/e1/50edc7a50334807cc4791fc4a0ce7468b4a1416d9138eab358bfc9a3d70b/cryptography-48.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2b4d59804e8408e2fea7d1fbaf218e5ec984325221db76e6a241a9abd6cdd95c", size = 4730479, upload-time = "2026-05-04T22:58:55.611Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/af/99a582b1b1641ff5911ac559beb45097cf79efd4ead4657f578ef1af2d47/cryptography-48.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:984a20b0f62a26f48a3396c72e4bc34c66e356d356bf370053066b3b6d54634a", size = 4326481, upload-time = "2026-05-04T22:58:57.607Z" },
+    { url = "https://files.pythonhosted.org/packages/90/ee/89aa26a06ef0a7d7611788ffd571a7c50e368cc6a4d5eef8b4884e866edb/cryptography-48.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5a5ed8fde7a1d09376ca0b40e68cd59c69fe23b1f9768bd5824f54681626032a", size = 4688713, upload-time = "2026-05-04T22:59:00.077Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ba/bcb1b0bb7a33d4c7c0c4d4c7874b4a62ae4f56113a5f4baefa362dfb1f0f/cryptography-48.0.0-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:8cd666227ef7af430aa5914a9910e0ddd703e75f039cef0825cd0da71b6b711a", size = 5238165, upload-time = "2026-05-04T22:59:02.317Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/70/ca4003b1ce5ca3dc3186ada51908c8a9b9ff7d5cab83cc0d43ee14ec144f/cryptography-48.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9071196d81abc88b3516ac8cdfad32e2b66dd4a5393a8e68a961e9161ddc6239", size = 4729947, upload-time = "2026-05-04T22:59:05.255Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a0/4ec7cf774207905aef1a8d11c3750d5a1db805eb380ee4e16df317870128/cryptography-48.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1e2d54c8be6152856a36f0882ab231e70f8ec7f14e93cf87db8a2ed056bf160c", size = 4822059, upload-time = "2026-05-04T22:59:07.802Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/75/a2e55f99c16fcac7b5d6c1eb19ad8e00799854d6be5ca845f9259eae1681/cryptography-48.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a5da777e32ffed6f85a7b2b3f7c5cbc88c146bfcd0a1d7baf5fcc6c52ee35dd4", size = 4960575, upload-time = "2026-05-04T22:59:09.851Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/23/6e6f32143ab5d8b36ca848a502c4bcd477ae75b9e1677e3530d669062578/cryptography-48.0.0-cp39-abi3-win32.whl", hash = "sha256:77a2ccbbe917f6710e05ba9adaa25fb5075620bf3ea6fb751997875aff4ae4bd", size = 3279117, upload-time = "2026-05-04T22:59:12.019Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/9a/0fea98a70cf1749d41d738836f6349d97945f7c89433a259a6c2642eefeb/cryptography-48.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:16cd65b9330583e4619939b3a3843eec1e6e789744bb01e7c7e2e62e33c239c8", size = 3792100, upload-time = "2026-05-04T22:59:14.884Z" },
+    { url = "https://files.pythonhosted.org/packages/be/d2/024b5e06be9d44cb021fb0e1a03d34d63989cf56a0fe62f3dfbab695b9b4/cryptography-48.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:84cf79f0dc8b36ac5da873481716e87aef31fcfa0444f9e1d8b4b2cece142855", size = 3950391, upload-time = "2026-05-04T22:59:17.415Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/17/3861e17c56fa0fd37491a14a8673fdb77c57fc5693cafe745ea8b06dba75/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:fdfef35d751d510fcef5252703621574364fec16418c4a1e5e1055248401054b", size = 4637126, upload-time = "2026-05-04T22:59:20.197Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/0a/7e226dbff530f21480727eb764973a7bff2b912f8e15cd4f129e71b56d1d/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:0890f502ddf7d9c6426129c3f49f5c0a39278ed7cd6322c8755ffca6ee675a13", size = 4667270, upload-time = "2026-05-04T22:59:22.647Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/f2/5a72274ca9f1b2a8b44a662ee0bf1b435909deb473d6f97bcd035bcdbc71/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:ecde28a596bead48b0cfd2a1b4416c3d43074c2d785e3a398d7ec1fc4d0f7fbb", size = 4636797, upload-time = "2026-05-04T22:59:24.912Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/e1/48cedb2fe63626e91ded1edad159e2a4fb8b6906c4425eb7749673077ce7/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:4defde8685ae324a9eb9d818717e93b4638ef67070ac9bc15b8ca85f63048355", size = 4666800, upload-time = "2026-05-04T22:59:27.474Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/ca/7e8365deec19afb2b2c7be7c1c0aa8f99633b54e90c570999acda93260fc/cryptography-48.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:db63bf618e5dea46c07de12e900fe1cdd2541e6dc9dbae772a70b7d4d4765f6a", size = 3739536, upload-time = "2026-05-04T22:59:29.61Z" },
 ]
 
 [[package]]
 name = "cymem"
-version = "2.0.11"
+version = "2.0.13"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/2f0fbb32535c3731b7c2974c569fb9325e0a38ed5565a08e1139a3b71e82/cymem-2.0.13.tar.gz", hash = "sha256:1c91a92ae8c7104275ac26bd4d29b08ccd3e7faff5893d3858cb6fadf1bc1588", size = 12320, upload-time = "2025-11-14T14:58:36.902Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/64/1db41f7576a6b69f70367e3c15e968fd775ba7419e12059c9966ceb826f8/cymem-2.0.13-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:673183466b0ff2e060d97ec5116711d44200b8f7be524323e080d215ee2d44a5", size = 43587, upload-time = "2025-11-14T14:57:22.39Z" },
+    { url = "https://files.pythonhosted.org/packages/81/13/57f936fc08551323aab3f92ff6b7f4d4b89d5b4e495c870a67cb8d279757/cymem-2.0.13-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bee2791b3f6fc034ce41268851462bf662ff87e8947e35fb6dd0115b4644a61f", size = 43139, upload-time = "2025-11-14T14:57:23.363Z" },
+    { url = "https://files.pythonhosted.org/packages/32/a6/9345754be51e0479aa387b7b6cffc289d0fd3201aaeb8dade4623abd1e02/cymem-2.0.13-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f3aee3adf16272bca81c5826eed55ba3c938add6d8c9e273f01c6b829ecfde22", size = 245063, upload-time = "2025-11-14T14:57:24.839Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/01/6bc654101526fa86e82bf6b05d99b2cd47c30a333cfe8622c26c0592beb2/cymem-2.0.13-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:30c4e75a3a1d809e89106b0b21803eb78e839881aa1f5b9bd27b454bc73afde3", size = 244496, upload-time = "2025-11-14T14:57:26.42Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/fb/853b7b021e701a1f41687f3704d5f469aeb2a4f898c3fbb8076806885955/cymem-2.0.13-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ec99efa03cf8ec11c8906aa4d4cc0c47df393bc9095c9dd64b89b9b43e220b04", size = 243287, upload-time = "2025-11-14T14:57:27.542Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/2b/0e4664cafc581de2896d75000651fd2ce7094d33263f466185c28ffc96e4/cymem-2.0.13-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c90a6ecba994a15b17a3f45d7ec74d34081df2f73bd1b090e2adc0317e4e01b6", size = 248287, upload-time = "2025-11-14T14:57:29.055Z" },
+    { url = "https://files.pythonhosted.org/packages/21/0f/f94c6950edbfc2aafb81194fc40b6cacc8e994e9359d3cb4328c5705b9b5/cymem-2.0.13-cp311-cp311-win_amd64.whl", hash = "sha256:ce821e6ba59148ed17c4567113b8683a6a0be9c9ac86f14e969919121efb61a5", size = 40116, upload-time = "2025-11-14T14:57:30.592Z" },
+    { url = "https://files.pythonhosted.org/packages/00/df/2455eff6ac0381ff165db6883b311f7016e222e3dd62185517f8e8187ed0/cymem-2.0.13-cp311-cp311-win_arm64.whl", hash = "sha256:0dca715e708e545fd1d97693542378a00394b20a37779c1ae2c8bdbb43acef79", size = 36349, upload-time = "2025-11-14T14:57:31.573Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/52/478a2911ab5028cb710b4900d64aceba6f4f882fcb13fd8d40a456a1b6dc/cymem-2.0.13-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e8afbc5162a0fe14b6463e1c4e45248a1b2fe2cbcecc8a5b9e511117080da0eb", size = 43745, upload-time = "2025-11-14T14:57:32.52Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/71/f0f8adee945524774b16af326bd314a14a478ed369a728a22834e6785a18/cymem-2.0.13-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c9251d889348fe79a75e9b3e4d1b5fa651fca8a64500820685d73a3acc21b6a8", size = 42927, upload-time = "2025-11-14T14:57:33.827Z" },
+    { url = "https://files.pythonhosted.org/packages/62/6d/159780fe162ff715d62b809246e5fc20901cef87ca28b67d255a8d741861/cymem-2.0.13-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:742fc19764467a49ed22e56a4d2134c262d73a6c635409584ae3bf9afa092c33", size = 258346, upload-time = "2025-11-14T14:57:34.917Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/12/678d16f7aa1996f947bf17b8cfb917ea9c9674ef5e2bd3690c04123d5680/cymem-2.0.13-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f190a92fe46197ee64d32560eb121c2809bb843341733227f51538ce77b3410d", size = 260843, upload-time = "2025-11-14T14:57:36.503Z" },
+    { url = "https://files.pythonhosted.org/packages/31/5d/0dd8c167c08cd85e70d274b7235cfe1e31b3cebc99221178eaf4bbb95c6f/cymem-2.0.13-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d670329ee8dbbbf241b7c08069fe3f1d3a1a3e2d69c7d05ea008a7010d826298", size = 254607, upload-time = "2025-11-14T14:57:38.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/c9/d6514a412a1160aa65db539836b3d47f9b59f6675f294ec34ae32f867c82/cymem-2.0.13-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a84ba3178d9128b9ffb52ce81ebab456e9fe959125b51109f5b73ebdfc6b60d6", size = 262421, upload-time = "2025-11-14T14:57:39.265Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/fe/3ee37d02ca4040f2fb22d34eb415198f955862b5dd47eee01df4c8f5454c/cymem-2.0.13-cp312-cp312-win_amd64.whl", hash = "sha256:2ff1c41fd59b789579fdace78aa587c5fc091991fa59458c382b116fc36e30dc", size = 40176, upload-time = "2025-11-14T14:57:40.706Z" },
+    { url = "https://files.pythonhosted.org/packages/94/fb/1b681635bfd5f2274d0caa8f934b58435db6c091b97f5593738065ddb786/cymem-2.0.13-cp312-cp312-win_arm64.whl", hash = "sha256:6bbd701338df7bf408648191dff52472a9b334f71bcd31a21a41d83821050f67", size = 35959, upload-time = "2025-11-14T14:57:41.682Z" },
+]
+
+[[package]]
+name = "defusedxml"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" },
+]
+
+[[package]]
+name = "deprecated"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298, upload-time = "2025-10-30T08:19:00.758Z" },
+]
+
+[[package]]
+name = "deprecation"
+version = "2.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f2/4a/1acd761fb6ac4c560e823ce40536a62f886f2d59b2763b5c3fc7e9d92101/cymem-2.0.11.tar.gz", hash = "sha256:efe49a349d4a518be6b6c6b255d4a80f740a341544bde1a807707c058b88d0bd", size = 10346, upload-time = "2025-01-16T21:50:41.045Z" }
+dependencies = [
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5a/d3/8ae2869247df154b64c1884d7346d412fed0c49df84db635aab2d1c40e62/deprecation-2.1.0.tar.gz", hash = "sha256:72b3bde64e5d778694b0cf68178aed03d15e15477116add3fb773e581f9518ff", size = 173788, upload-time = "2020-04-20T14:23:38.738Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/e3/d98e3976f4ffa99cddebc1ce379d4d62e3eb1da22285267f902c99cc3395/cymem-2.0.11-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3ee54039aad3ef65de82d66c40516bf54586287b46d32c91ea0530c34e8a2745", size = 42005, upload-time = "2025-01-16T21:49:34.977Z" },
-    { url = "https://files.pythonhosted.org/packages/41/b4/7546faf2ab63e59befc95972316d62276cec153f7d4d60e7b0d5e08f0602/cymem-2.0.11-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4c05ef75b5db217be820604e43a47ccbbafea98ab6659d07cea92fa3c864ea58", size = 41747, upload-time = "2025-01-16T21:49:36.108Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/4e/042f372e5b3eb7f5f3dd7677161771d301de2b6fa3f7c74e1cebcd502552/cymem-2.0.11-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8d5381e5793ce531bac0dbc00829c8381f18605bb67e4b61d34f8850463da40", size = 217647, upload-time = "2025-01-16T21:49:37.433Z" },
-    { url = "https://files.pythonhosted.org/packages/48/cb/2207679e4b92701f78cf141e1ab4f81f55247dbe154eb426b842a0a993de/cymem-2.0.11-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2b9d3f42d7249ac81802135cad51d707def058001a32f73fc7fbf3de7045ac7", size = 218857, upload-time = "2025-01-16T21:49:40.09Z" },
-    { url = "https://files.pythonhosted.org/packages/31/7a/76ae3b7a39ab2531029d281e43fcfcaad728c2341b150a81a3a1f5587cf3/cymem-2.0.11-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:39b78f2195d20b75c2d465732f6b8e8721c5d4eb012777c2cb89bdb45a043185", size = 206148, upload-time = "2025-01-16T21:49:41.383Z" },
-    { url = "https://files.pythonhosted.org/packages/25/f9/d0fc0191ac79f15638ddb59237aa76f234691374d7d7950e10f384bd8a25/cymem-2.0.11-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:2203bd6525a80d8fd0c94654a263af21c0387ae1d5062cceaebb652bf9bad7bc", size = 207112, upload-time = "2025-01-16T21:49:43.986Z" },
-    { url = "https://files.pythonhosted.org/packages/56/c8/75f75889401b20f4c3a7c5965dda09df42913e904ddc2ffe7ef3bdf25061/cymem-2.0.11-cp311-cp311-win_amd64.whl", hash = "sha256:aa54af7314de400634448da1f935b61323da80a49484074688d344fb2036681b", size = 39360, upload-time = "2025-01-16T21:49:45.479Z" },
-    { url = "https://files.pythonhosted.org/packages/71/67/0d74f7e9d79f934368a78fb1d1466b94bebdbff14f8ae94dd3e4ea8738bb/cymem-2.0.11-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a0fbe19ce653cd688842d81e5819dc63f911a26e192ef30b0b89f0ab2b192ff2", size = 42621, upload-time = "2025-01-16T21:49:46.585Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/d6/f7a19c63b48efc3f00a3ee8d69070ac90202e1e378f6cf81b8671f0cf762/cymem-2.0.11-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de72101dc0e6326f6a2f73e05a438d1f3c6110d41044236d0fbe62925091267d", size = 42249, upload-time = "2025-01-16T21:49:48.973Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/60/cdc434239813eef547fb99b6d0bafe31178501702df9b77c4108c9a216f6/cymem-2.0.11-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee4395917f6588b8ac1699499128842768b391fe8896e8626950b4da5f9a406", size = 224758, upload-time = "2025-01-16T21:49:51.382Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/68/8fa6efae17cd3b2ba9a2f83b824867c5b65b06f7aec3f8a0d0cabdeffb9b/cymem-2.0.11-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5b02f2b17d760dc3fe5812737b1ce4f684641cdd751d67761d333a3b5ea97b83", size = 227995, upload-time = "2025-01-16T21:49:54.538Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/f3/ceda70bf6447880140602285b7c6fa171cb7c78b623d35345cc32505cd06/cymem-2.0.11-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:04ee6b4041ddec24512d6e969ed6445e57917f01e73b9dabbe17b7e6b27fef05", size = 215325, upload-time = "2025-01-16T21:49:57.229Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/47/6915eaa521e1ce7a0ba480eecb6870cb4f681bcd64ced88c2f0ed7a744b4/cymem-2.0.11-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e1048dae7e627ee25f22c87bb670b13e06bc0aecc114b89b959a798d487d1bf4", size = 216447, upload-time = "2025-01-16T21:50:00.432Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/be/8e02bdd31e557f642741a06c8e886782ef78f0b00daffd681922dc9bbc88/cymem-2.0.11-cp312-cp312-win_amd64.whl", hash = "sha256:0c269c7a867d74adeb9db65fa1d226342aacf44d64b7931282f0b0eb22eb6275", size = 39283, upload-time = "2025-01-16T21:50:03.384Z" },
+    { url = "https://files.pythonhosted.org/packages/02/c3/253a89ee03fc9b9682f1541728eb66db7db22148cd94f89ab22528cd1e1b/deprecation-2.1.0-py2.py3-none-any.whl", hash = "sha256:a10811591210e1fb0e768a8c25517cabeabcba6f0bf96564f8ff45189f90b14a", size = 11178, upload-time = "2020-04-20T14:23:36.581Z" },
 ]
 
 [[package]]
@@ -654,11 +705,24 @@ wheels = [
 
 [[package]]
 name = "docstring-parser"
-version = "0.17.0"
+version = "0.18.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b2/9d/c3b43da9515bd270df0f80548d9944e389870713cc1fe2b8fb35fe2bcefd/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912", size = 27442, upload-time = "2025-07-21T07:35:01.868Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", hash = "sha256:292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015", size = 29341, upload-time = "2026-04-14T04:09:19.867Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/55/e2/2537ebcff11c1ee1ff17d8d0b6f4db75873e3b0fb32c2d4a2ee31ecb310a/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708", size = 36896, upload-time = "2025-07-21T07:35:00.684Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", hash = "sha256:b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b", size = 22484, upload-time = "2026-04-14T04:09:18.638Z" },
+]
+
+[[package]]
+name = "ebooklib"
+version = "0.20"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lxml" },
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/77/85/322e8882a582d4b707220d1929cfb74c125f2ba513991edbce40dbc462de/ebooklib-0.20.tar.gz", hash = "sha256:35e2f9d7d39907be8d39ae2deb261b19848945903ae3dbb6577b187ead69e985", size = 127066, upload-time = "2025-10-26T20:56:20.968Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bf/ee/aa015c5de8b0dc42a8e507eae8c2de5d1c0e068c896858fec6d502402ed6/ebooklib-0.20-py3-none-any.whl", hash = "sha256:fff5322517a37e31c972d27be7d982cc3928c16b3dcc5fd7e8f7c0f5d7bcf42b", size = 40995, upload-time = "2025-10-26T20:56:19.104Z" },
 ]
 
 [[package]]
@@ -681,11 +745,14 @@ version = "0.1.0b6"
 source = { editable = "." }
 dependencies = [
     { name = "argon2-cffi" },
+    { name = "bleach", extra = ["css"] },
     { name = "boto3" },
+    { name = "ebooklib" },
     { name = "en-core-web-sm" },
     { name = "fastapi" },
     { name = "httpx" },
     { name = "httpx-sse" },
+    { name = "importlib-metadata" },
     { name = "itsdangerous" },
     { name = "jinja2" },
     { name = "joserfc" },
@@ -694,6 +761,8 @@ dependencies = [
     { name = "mdformat" },
     { name = "mdformat-gfm" },
     { name = "mistune" },
+    { name = "numpy" },
+    { name = "ocrmypdf" },
     { name = "opentelemetry-api" },
     { name = "opentelemetry-exporter-otlp" },
     { name = "opentelemetry-exporter-prometheus" },
@@ -703,7 +772,7 @@ dependencies = [
     { name = "presidio-analyzer" },
     { name = "prometheus-client" },
     { name = "pydantic" },
-    { name = "pydantic-ai" },
+    { name = "pydantic-ai-slim", extra = ["anthropic"] },
     { name = "pydantic-settings" },
     { name = "pylti1p3" },
     { name = "pymarkdownlnt" },
@@ -752,12 +821,15 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "argon2-cffi", specifier = ">=23.1.0" },
+    { name = "bleach", extras = ["css"], specifier = ">=6.1.0" },
     { name = "boto3", specifier = ">=1.35.0" },
+    { name = "ebooklib", specifier = ">=0.18" },
     { name = "en-core-web-sm", url = "https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl" },
     { name = "fastapi", specifier = ">=0.115.0" },
     { name = "httpx", specifier = ">=0.27.0" },
     { name = "httpx", marker = "extra == 'dev'", specifier = ">=0.27.0" },
     { name = "httpx-sse", specifier = ">=0.4.0" },
+    { name = "importlib-metadata", specifier = ">=7.0" },
     { name = "itsdangerous", specifier = ">=2.2.0" },
     { name = "jinja2", specifier = ">=3.1.0" },
     { name = "joserfc", specifier = ">=1.0.0" },
@@ -767,6 +839,8 @@ requires-dist = [
     { name = "mdformat-gfm", specifier = ">=1.0.0" },
     { name = "mistune", specifier = ">=3.0.0" },
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.5.0" },
+    { name = "numpy", specifier = ">=1.26,<2.0" },
+    { name = "ocrmypdf", specifier = ">=16.0" },
     { name = "opentelemetry-api", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-prometheus", specifier = ">=0.41b0" },
@@ -776,7 +850,7 @@ requires-dist = [
     { name = "presidio-analyzer", specifier = ">=2.2.0" },
     { name = "prometheus-client", specifier = ">=0.19.0" },
     { name = "pydantic", specifier = ">=2.0.0" },
-    { name = "pydantic-ai", extras = ["anthropic", "bedrock"], specifier = ">=1.0.12" },
+    { name = "pydantic-ai-slim", extras = ["anthropic"], specifier = ">=1.98.0" },
     { name = "pydantic-settings", specifier = ">=2.6.0" },
     { name = "pylti1p3", specifier = ">=2.0.0" },
     { name = "pymarkdownlnt", specifier = ">=0.9.0" },
@@ -817,22 +891,13 @@ dev = [
     { name = "types-redis", specifier = ">=4.6.0.20241004" },
 ]
 
-[[package]]
-name = "eval-type-backport"
-version = "0.2.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/30/ea/8b0ac4469d4c347c6a385ff09dc3c048c2d021696664e26c7ee6791631b5/eval_type_backport-0.2.2.tar.gz", hash = "sha256:f0576b4cf01ebb5bd358d02314d31846af5e07678387486e2c798af0e7d849c1", size = 9079, upload-time = "2024-12-21T20:09:46.005Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ce/31/55cd413eaccd39125368be33c46de24a1f639f2e12349b0361b4678f3915/eval_type_backport-0.2.2-py3-none-any.whl", hash = "sha256:cb6ad7c393517f476f96d456d0412ea80f0a8cf96f6892834cd9340149111b0a", size = 5830, upload-time = "2024-12-21T20:09:44.175Z" },
-]
-
 [[package]]
 name = "execnet"
-version = "2.1.1"
+version = "2.1.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/bb/ff/b4c0dc78fbe20c3e59c0c7334de0c27eb4001a2b2017999af398bf730817/execnet-2.1.1.tar.gz", hash = "sha256:5189b52c6121c24feae288166ab41b32549c7e2348652736540b9e6e7d4e72e3", size = 166524, upload-time = "2024-04-08T09:04:19.245Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/bf/89/780e11f9588d9e7128a3f87788354c7946a9cbb1401ad38a48c4db9a4f07/execnet-2.1.2.tar.gz", hash = "sha256:63d83bfdd9a23e35b9c6a3261412324f964c2ec8dcd8d3c6916ee9373e0befcd", size = 166622, upload-time = "2025-11-12T09:56:37.75Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/09/2aea36ff60d16dd8879bdb2f5b3ee0ba8d08cbbdcdfe870e695ce3784385/execnet-2.1.1-py3-none-any.whl", hash = "sha256:26dee51f1b80cebd6d0ca8e74dd8745419761d3bef34163928cbebbdc4749fdc", size = 40612, upload-time = "2024-04-08T09:04:17.414Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" },
 ]
 
 [[package]]
@@ -846,215 +911,172 @@ wheels = [
 
 [[package]]
 name = "fastapi"
-version = "0.118.0"
+version = "0.136.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/28/3c/2b9345a6504e4055eaa490e0b41c10e338ad61d9aeaae41d97807873cdf2/fastapi-0.118.0.tar.gz", hash = "sha256:5e81654d98c4d2f53790a7d32d25a7353b30c81441be7d0958a26b5d761fa1c8", size = 310536, upload-time = "2025-09-29T03:37:23.126Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5d/45/c130091c2dfa061bbfe3150f2a5091ef1adf149f2a8d2ae769ecaf6e99a2/fastapi-0.136.1.tar.gz", hash = "sha256:7af665ad7acfa0a3baf8983d393b6b471b9da10ede59c60045f49fbc89a0fa7f", size = 397448, upload-time = "2026-04-23T16:49:44.046Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/20/54e2bdaad22ca91a59455251998d43094d5c3d3567c52c7c04774b3f43f2/fastapi-0.118.0-py3-none-any.whl", hash = "sha256:705137a61e2ef71019d2445b123aa8845bd97273c395b744d5a7dfe559056855", size = 97694, upload-time = "2025-09-29T03:37:21.338Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", hash = "sha256:a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f", size = 117683, upload-time = "2026-04-23T16:49:42.437Z" },
 ]
 
 [[package]]
-name = "fastavro"
-version = "1.12.0"
+name = "filelock"
+version = "3.29.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cc/ec/762dcf213e5b97ea1733b27d5a2798599a1fa51565b70a93690246029f84/fastavro-1.12.0.tar.gz", hash = "sha256:a67a87be149825d74006b57e52be068dfa24f3bfc6382543ec92cd72327fe152", size = 1025604, upload-time = "2025-07-31T15:16:42.933Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", hash = "sha256:69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90", size = 57571, upload-time = "2026-04-19T15:39:10.068Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6f/51/6bd93f2c9f3bb98f84ee0ddb436eb46a308ec53e884d606b70ca9d6b132d/fastavro-1.12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:56f78d1d527bea4833945c3a8c716969ebd133c5762e2e34f64c795bd5a10b3e", size = 962215, upload-time = "2025-07-31T15:16:58.173Z" },
-    { url = "https://files.pythonhosted.org/packages/32/37/3e2e429cefe03d1fa98cc4c4edae1d133dc895db64dabe84c17b4dc0921c/fastavro-1.12.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7ce0d117642bb4265ef6e1619ec2d93e942a98f60636e3c0fbf1eb438c49026", size = 3412716, upload-time = "2025-07-31T15:17:00.301Z" },
-    { url = "https://files.pythonhosted.org/packages/33/28/eb37d9738ea3649bdcab1b6d4fd0facf9c36261623ea368554734d5d6821/fastavro-1.12.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:52e9d9648aad4cca5751bcbe2d3f98e85afb0ec6c6565707f4e2f647ba83ba85", size = 3439283, upload-time = "2025-07-31T15:17:02.505Z" },
-    { url = "https://files.pythonhosted.org/packages/57/6f/7aba4efbf73fd80ca20aa1db560936c222dd1b4e5cadbf9304361b9065e3/fastavro-1.12.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6183875381ec1cf85a1891bf46696fd1ec2ad732980e7bccc1e52e9904e7664d", size = 3354728, upload-time = "2025-07-31T15:17:04.705Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/2d/b0d8539f4622ebf5355b7898ac7930b1ff638de85b6c3acdd0718e05d09e/fastavro-1.12.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5ad00a2b94d3c8bf9239acf92d56e3e457e1d188687a8d80f31e858ccf91a6d6", size = 3442598, upload-time = "2025-07-31T15:17:06.986Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/33/882154b17e0fd468f1a5ae8cc903805531e1fcb699140315366c5f8ec20d/fastavro-1.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:6c4d1c276ff1410f3830648bb43312894ad65709ca0cb54361e28954387a46ac", size = 451836, upload-time = "2025-07-31T15:17:08.219Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/f0/df076a541144d2f351820f3d9e20afa0e4250e6e63cb5a26f94688ed508c/fastavro-1.12.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e849c70198e5bdf6f08df54a68db36ff72bd73e8f14b1fd664323df073c496d8", size = 944288, upload-time = "2025-07-31T15:17:09.756Z" },
-    { url = "https://files.pythonhosted.org/packages/52/1d/5c1ea0f6e98a441953de822c7455c9ce8c3afdc7b359dd23c5a5e5039249/fastavro-1.12.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b260e1cdc9a77853a2586b32208302c08dddfb5c20720b5179ac5330e06ce698", size = 3404895, upload-time = "2025-07-31T15:17:11.939Z" },
-    { url = "https://files.pythonhosted.org/packages/36/8b/115a3ffe67fb48de0de704284fa5e793afa70932b8b2e915cc7545752f05/fastavro-1.12.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:181779688d8b80957953031f0d82ec0761be667a78e03dac642511ff996c771a", size = 3469935, upload-time = "2025-07-31T15:17:14.145Z" },
-    { url = "https://files.pythonhosted.org/packages/14/f8/bf3b7370687ab21205e07b37acdd2455ca69f5d25c72d2b315faf357b1cd/fastavro-1.12.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6881caf914b36a57d1f90810f04a89bd9c837dd4a48e1b66a8b92136e85c415d", size = 3306148, upload-time = "2025-07-31T15:17:16.121Z" },
-    { url = "https://files.pythonhosted.org/packages/97/55/fba2726b59a984c7aa2fc19c6e8ef1865eca6a3f66e78810d602ca22af59/fastavro-1.12.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8bf638248499eb78c422f12fedc08f9b90b5646c3368415e388691db60e7defb", size = 3442851, upload-time = "2025-07-31T15:17:18.738Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/3e/25059b8fe0b8084fd858dca77caf0815d73e0ca4731485f34402e8d40c43/fastavro-1.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:ed4f18b7c2f651a5ee2233676f62aac332995086768301aa2c1741859d70b53e", size = 445449, upload-time = "2025-07-31T15:17:20.438Z" },
+    { url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", hash = "sha256:96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258", size = 39812, upload-time = "2026-04-19T15:39:08.752Z" },
 ]
 
 [[package]]
-name = "filelock"
-version = "3.19.1"
+name = "fonttools"
+version = "4.63.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/40/bb/0ab3e58d22305b6f5440629d20683af28959bf793d98d11950e305c1c326/filelock-3.19.1.tar.gz", hash = "sha256:66eda1888b0171c998b35be2bcc0f6d75c388a7ce20c3f3f37aa8e96c2dddf58", size = 17687, upload-time = "2025-08-14T16:56:03.016Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/84/69/c97f2c18e0db87d2c7b15da1974dace76ae938f1cfa22e2727a648b7ed43/fonttools-4.63.0.tar.gz", hash = "sha256:caeb583deeb5168e694b65cda8b4ee62abedfa66cf88488734466f2366b9c4e0", size = 3597189, upload-time = "2026-05-14T12:04:30.958Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/14/42b2651a2f46b022ccd948bca9f2d5af0fd8929c4eec235b8d6d844fbe67/filelock-3.19.1-py3-none-any.whl", hash = "sha256:d38e30481def20772f5baf097c122c3babc4fcdb7e14e57049eb9d88c6dc017d", size = 15988, upload-time = "2025-08-14T16:56:01.633Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2b/a7f1545bdf5da69c4bda0cea2a5781f0ad2a6623e0277267672db43c5fe6/fonttools-4.63.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2b8ae05d9eacf6081414d759c0a352769ac28ce31280d6bb8e77b03f9e3c449f", size = 2881793, upload-time = "2026-05-14T12:02:56.645Z" },
+    { url = "https://files.pythonhosted.org/packages/49/50/965308c703f085f225db2886813b27e015b8b3438c350b22dd65b52c2a2c/fonttools-4.63.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:79cdc9f567aec74a72918fd060283911406750cbc9fd28c1316023deb6ce31a9", size = 2428130, upload-time = "2026-05-14T12:02:58.891Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/38/6937fbd7f2dc3a6b48725851bc2c15ec949b9af14d9bbcb5fe83cdf9bdf9/fonttools-4.63.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c14b4fd138c4bafcca294765c547914e1aa431ae1ca94ab99d8db08c958bd3b", size = 5111952, upload-time = "2026-05-14T12:03:01.263Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/43/a81f20050a3115b57d62c8e781446949512eac36690dc384ccea65ff4cc1/fonttools-4.63.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d76ac49f929aecaf82d83250b8347e099d7aecba0f4726c1d9b6df3b8bb5fe18", size = 5082308, upload-time = "2026-05-14T12:03:03.211Z" },
+    { url = "https://files.pythonhosted.org/packages/67/00/cdd9d4944ca6ae280d01e69cc37bde3bf663630b837a6fc6d2cd65d80e0e/fonttools-4.63.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dcf076a4474fe0d7367e5bbf5b052c7284fa1feca729c04176ce513521afd8a0", size = 5087932, upload-time = "2026-05-14T12:03:05.147Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f1/0aa0dbea778c75adbef223c42019fd47d22262b905974d62d829545d485f/fonttools-4.63.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7dd683fef0663e9f0f45cf541d788d24caa3ec9db50796b588e1757d8b3bc007", size = 5213271, upload-time = "2026-05-14T12:03:07.238Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/99/253e4056e1f0e67b9390125a154b73b5eb73ad521bece95c004858fdeec2/fonttools-4.63.0-cp311-cp311-win32.whl", hash = "sha256:afefc1ed0a59785a7fb06ea7e1678e849c193e1e387db783579bc7b3056fcfcb", size = 2304473, upload-time = "2026-05-14T12:03:09.271Z" },
+    { url = "https://files.pythonhosted.org/packages/08/60/defa5e69641db890a63be281f41345f4c33b157824eaf0b9fad3e08b0dcb/fonttools-4.63.0-cp311-cp311-win_amd64.whl", hash = "sha256:063e08bd17bd5a90127a14123de0d6a952dbc847695fd98b63c043d58057f90c", size = 2356389, upload-time = "2026-05-14T12:03:11.53Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ef/b3c6b9b5be2f82416d73fe2ed2e96e2793cd80e7510bd6a17ca79cdd88ec/fonttools-4.63.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:37dd23e621e3b0aef1baa70a303b80aaf38449632cfc8fd2a55fb285bbccfc02", size = 2881131, upload-time = "2026-05-14T12:03:13.386Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a0/c815bea63117fa63e4e1c01f8a1110d2112fa003f838e6467094ec2432ce/fonttools-4.63.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a9faff9e0c1f76f9fd55899d2ce785832efebab37eb8ae13995853aef178bef0", size = 2426704, upload-time = "2026-05-14T12:03:15.801Z" },
+    { url = "https://files.pythonhosted.org/packages/44/04/0b91d8e916e92ad1fac9e4624760baf0fd5ff2ead614c2f68fb21373f03f/fonttools-4.63.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef3048ef05dbb552b89817713d9cac912e00d0fde4a3105c00d29e52e10c89af", size = 5044298, upload-time = "2026-05-14T12:03:18.085Z" },
+    { url = "https://files.pythonhosted.org/packages/77/c7/2342da9830e3e9d4870305ca5d2091d2a83284f2953079b7bdd3b5e029d8/fonttools-4.63.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58dc6bb86a78d782f00f9190ca02c119cf5bbe2807536e361e18d42019f877d8", size = 4999800, upload-time = "2026-05-14T12:03:20.161Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/6d/67fe16c48d7ce050979b33f47e0d28a318f02da030602e944c34f7a16ef3/fonttools-4.63.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ee08ebfa58f6e1aeff5697ab9582105bb620008c1caafb681e4c557e7483027b", size = 4982666, upload-time = "2026-05-14T12:03:22.87Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/00/3bbab338c07c71fa56269953845e92c951a61457bbbb0f1022551ea266d9/fonttools-4.63.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:27fdc65af8da6f88b9c6121c47a464cbe359fcfff7ff6fc2d37a1f395d755b78", size = 5133598, upload-time = "2026-05-14T12:03:25.168Z" },
+    { url = "https://files.pythonhosted.org/packages/62/f2/aa27c7f98db5b064883dadcc5283947e81e034de42e22a33675878d98b54/fonttools-4.63.0-cp312-cp312-win32.whl", hash = "sha256:af2fd1664d00a397d75f806985ddb36282091c2131a73a6485c23b4a34722263", size = 2292575, upload-time = "2026-05-14T12:03:27.496Z" },
+    { url = "https://files.pythonhosted.org/packages/87/36/cccb9bc2a6ab63d1b2980374f0dca72ce95ae267c9b4cfe77455bb70d0d4/fonttools-4.63.0-cp312-cp312-win_amd64.whl", hash = "sha256:59ac449f8cca9b4ffa08d2e7bbadad87ce710d69d1eda5c3c1ce579baa987272", size = 2343211, upload-time = "2026-05-14T12:03:30.057Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" },
 ]
 
 [[package]]
-name = "frozenlist"
-version = "1.7.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/79/b1/b64018016eeb087db503b038296fd782586432b9c077fc5c7839e9cb6ef6/frozenlist-1.7.0.tar.gz", hash = "sha256:2e310d81923c2437ea8670467121cc3e9b0f76d3043cc1d2331d56c7fb7a3a8f", size = 45078, upload-time = "2025-06-09T23:02:35.538Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/34/7e/803dde33760128acd393a27eb002f2020ddb8d99d30a44bfbaab31c5f08a/frozenlist-1.7.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:aa51e147a66b2d74de1e6e2cf5921890de6b0f4820b257465101d7f37b49fb5a", size = 82251, upload-time = "2025-06-09T23:00:16.279Z" },
-    { url = "https://files.pythonhosted.org/packages/75/a9/9c2c5760b6ba45eae11334db454c189d43d34a4c0b489feb2175e5e64277/frozenlist-1.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9b35db7ce1cd71d36ba24f80f0c9e7cff73a28d7a74e91fe83e23d27c7828750", size = 48183, upload-time = "2025-06-09T23:00:17.698Z" },
-    { url = "https://files.pythonhosted.org/packages/47/be/4038e2d869f8a2da165f35a6befb9158c259819be22eeaf9c9a8f6a87771/frozenlist-1.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:34a69a85e34ff37791e94542065c8416c1afbf820b68f720452f636d5fb990cd", size = 47107, upload-time = "2025-06-09T23:00:18.952Z" },
-    { url = "https://files.pythonhosted.org/packages/79/26/85314b8a83187c76a37183ceed886381a5f992975786f883472fcb6dc5f2/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a646531fa8d82c87fe4bb2e596f23173caec9185bfbca5d583b4ccfb95183e2", size = 237333, upload-time = "2025-06-09T23:00:20.275Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/fd/e5b64f7d2c92a41639ffb2ad44a6a82f347787abc0c7df5f49057cf11770/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:79b2ffbba483f4ed36a0f236ccb85fbb16e670c9238313709638167670ba235f", size = 231724, upload-time = "2025-06-09T23:00:21.705Z" },
-    { url = "https://files.pythonhosted.org/packages/20/fb/03395c0a43a5976af4bf7534759d214405fbbb4c114683f434dfdd3128ef/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a26f205c9ca5829cbf82bb2a84b5c36f7184c4316617d7ef1b271a56720d6b30", size = 245842, upload-time = "2025-06-09T23:00:23.148Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/15/c01c8e1dffdac5d9803507d824f27aed2ba76b6ed0026fab4d9866e82f1f/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bcacfad3185a623fa11ea0e0634aac7b691aa925d50a440f39b458e41c561d98", size = 239767, upload-time = "2025-06-09T23:00:25.103Z" },
-    { url = "https://files.pythonhosted.org/packages/14/99/3f4c6fe882c1f5514b6848aa0a69b20cb5e5d8e8f51a339d48c0e9305ed0/frozenlist-1.7.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:72c1b0fe8fe451b34f12dce46445ddf14bd2a5bcad7e324987194dc8e3a74c86", size = 224130, upload-time = "2025-06-09T23:00:27.061Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/83/220a374bd7b2aeba9d0725130665afe11de347d95c3620b9b82cc2fcab97/frozenlist-1.7.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:61d1a5baeaac6c0798ff6edfaeaa00e0e412d49946c53fae8d4b8e8b3566c4ae", size = 235301, upload-time = "2025-06-09T23:00:29.02Z" },
-    { url = "https://files.pythonhosted.org/packages/03/3c/3e3390d75334a063181625343e8daab61b77e1b8214802cc4e8a1bb678fc/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7edf5c043c062462f09b6820de9854bf28cc6cc5b6714b383149745e287181a8", size = 234606, upload-time = "2025-06-09T23:00:30.514Z" },
-    { url = "https://files.pythonhosted.org/packages/23/1e/58232c19608b7a549d72d9903005e2d82488f12554a32de2d5fb59b9b1ba/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:d50ac7627b3a1bd2dcef6f9da89a772694ec04d9a61b66cf87f7d9446b4a0c31", size = 248372, upload-time = "2025-06-09T23:00:31.966Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/a4/e4a567e01702a88a74ce8a324691e62a629bf47d4f8607f24bf1c7216e7f/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ce48b2fece5aeb45265bb7a58259f45027db0abff478e3077e12b05b17fb9da7", size = 229860, upload-time = "2025-06-09T23:00:33.375Z" },
-    { url = "https://files.pythonhosted.org/packages/73/a6/63b3374f7d22268b41a9db73d68a8233afa30ed164c46107b33c4d18ecdd/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:fe2365ae915a1fafd982c146754e1de6ab3478def8a59c86e1f7242d794f97d5", size = 245893, upload-time = "2025-06-09T23:00:35.002Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/eb/d18b3f6e64799a79673c4ba0b45e4cfbe49c240edfd03a68be20002eaeaa/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:45a6f2fdbd10e074e8814eb98b05292f27bad7d1883afbe009d96abdcf3bc898", size = 246323, upload-time = "2025-06-09T23:00:36.468Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/f5/720f3812e3d06cd89a1d5db9ff6450088b8f5c449dae8ffb2971a44da506/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:21884e23cffabb157a9dd7e353779077bf5b8f9a58e9b262c6caad2ef5f80a56", size = 233149, upload-time = "2025-06-09T23:00:37.963Z" },
-    { url = "https://files.pythonhosted.org/packages/69/68/03efbf545e217d5db8446acfd4c447c15b7c8cf4dbd4a58403111df9322d/frozenlist-1.7.0-cp311-cp311-win32.whl", hash = "sha256:284d233a8953d7b24f9159b8a3496fc1ddc00f4db99c324bd5fb5f22d8698ea7", size = 39565, upload-time = "2025-06-09T23:00:39.753Z" },
-    { url = "https://files.pythonhosted.org/packages/58/17/fe61124c5c333ae87f09bb67186d65038834a47d974fc10a5fadb4cc5ae1/frozenlist-1.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:387cbfdcde2f2353f19c2f66bbb52406d06ed77519ac7ee21be0232147c2592d", size = 44019, upload-time = "2025-06-09T23:00:40.988Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/a2/c8131383f1e66adad5f6ecfcce383d584ca94055a34d683bbb24ac5f2f1c/frozenlist-1.7.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3dbf9952c4bb0e90e98aec1bd992b3318685005702656bc6f67c1a32b76787f2", size = 81424, upload-time = "2025-06-09T23:00:42.24Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/9d/02754159955088cb52567337d1113f945b9e444c4960771ea90eb73de8db/frozenlist-1.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1f5906d3359300b8a9bb194239491122e6cf1444c2efb88865426f170c262cdb", size = 47952, upload-time = "2025-06-09T23:00:43.481Z" },
-    { url = "https://files.pythonhosted.org/packages/01/7a/0046ef1bd6699b40acd2067ed6d6670b4db2f425c56980fa21c982c2a9db/frozenlist-1.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3dabd5a8f84573c8d10d8859a50ea2dec01eea372031929871368c09fa103478", size = 46688, upload-time = "2025-06-09T23:00:44.793Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/a2/a910bafe29c86997363fb4c02069df4ff0b5bc39d33c5198b4e9dd42d8f8/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa57daa5917f1738064f302bf2626281a1cb01920c32f711fbc7bc36111058a8", size = 243084, upload-time = "2025-06-09T23:00:46.125Z" },
-    { url = "https://files.pythonhosted.org/packages/64/3e/5036af9d5031374c64c387469bfcc3af537fc0f5b1187d83a1cf6fab1639/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c193dda2b6d49f4c4398962810fa7d7c78f032bf45572b3e04dd5249dff27e08", size = 233524, upload-time = "2025-06-09T23:00:47.73Z" },
-    { url = "https://files.pythonhosted.org/packages/06/39/6a17b7c107a2887e781a48ecf20ad20f1c39d94b2a548c83615b5b879f28/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfe2b675cf0aaa6d61bf8fbffd3c274b3c9b7b1623beb3809df8a81399a4a9c4", size = 248493, upload-time = "2025-06-09T23:00:49.742Z" },
-    { url = "https://files.pythonhosted.org/packages/be/00/711d1337c7327d88c44d91dd0f556a1c47fb99afc060ae0ef66b4d24793d/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8fc5d5cda37f62b262405cf9652cf0856839c4be8ee41be0afe8858f17f4c94b", size = 244116, upload-time = "2025-06-09T23:00:51.352Z" },
-    { url = "https://files.pythonhosted.org/packages/24/fe/74e6ec0639c115df13d5850e75722750adabdc7de24e37e05a40527ca539/frozenlist-1.7.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b0d5ce521d1dd7d620198829b87ea002956e4319002ef0bc8d3e6d045cb4646e", size = 224557, upload-time = "2025-06-09T23:00:52.855Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/db/48421f62a6f77c553575201e89048e97198046b793f4a089c79a6e3268bd/frozenlist-1.7.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:488d0a7d6a0008ca0db273c542098a0fa9e7dfaa7e57f70acef43f32b3f69dca", size = 241820, upload-time = "2025-06-09T23:00:54.43Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/fa/cb4a76bea23047c8462976ea7b7a2bf53997a0ca171302deae9d6dd12096/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:15a7eaba63983d22c54d255b854e8108e7e5f3e89f647fc854bd77a237e767df", size = 236542, upload-time = "2025-06-09T23:00:56.409Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/32/476a4b5cfaa0ec94d3f808f193301debff2ea42288a099afe60757ef6282/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1eaa7e9c6d15df825bf255649e05bd8a74b04a4d2baa1ae46d9c2d00b2ca2cb5", size = 249350, upload-time = "2025-06-09T23:00:58.468Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/ba/9a28042f84a6bf8ea5dbc81cfff8eaef18d78b2a1ad9d51c7bc5b029ad16/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e4389e06714cfa9d47ab87f784a7c5be91d3934cd6e9a7b85beef808297cc025", size = 225093, upload-time = "2025-06-09T23:01:00.015Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/29/3a32959e68f9cf000b04e79ba574527c17e8842e38c91d68214a37455786/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:73bd45e1488c40b63fe5a7df892baf9e2a4d4bb6409a2b3b78ac1c6236178e01", size = 245482, upload-time = "2025-06-09T23:01:01.474Z" },
-    { url = "https://files.pythonhosted.org/packages/80/e8/edf2f9e00da553f07f5fa165325cfc302dead715cab6ac8336a5f3d0adc2/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99886d98e1643269760e5fe0df31e5ae7050788dd288947f7f007209b8c33f08", size = 249590, upload-time = "2025-06-09T23:01:02.961Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/80/9a0eb48b944050f94cc51ee1c413eb14a39543cc4f760ed12657a5a3c45a/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:290a172aae5a4c278c6da8a96222e6337744cd9c77313efe33d5670b9f65fc43", size = 237785, upload-time = "2025-06-09T23:01:05.095Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/74/87601e0fb0369b7a2baf404ea921769c53b7ae00dee7dcfe5162c8c6dbf0/frozenlist-1.7.0-cp312-cp312-win32.whl", hash = "sha256:426c7bc70e07cfebc178bc4c2bf2d861d720c4fff172181eeb4a4c41d4ca2ad3", size = 39487, upload-time = "2025-06-09T23:01:06.54Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/15/c026e9a9fc17585a9d461f65d8593d281fedf55fbf7eb53f16c6df2392f9/frozenlist-1.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:563b72efe5da92e02eb68c59cb37205457c977aa7a449ed1b37e6939e5c47c6a", size = 43874, upload-time = "2025-06-09T23:01:07.752Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/45/b82e3c16be2182bff01179db177fe144d58b5dc787a7d4492c6ed8b9317f/frozenlist-1.7.0-py3-none-any.whl", hash = "sha256:9a5af342e34f7e97caf8c995864c7a396418ae2859cc6fdf1b1073020d516a7e", size = 13106, upload-time = "2025-06-09T23:02:34.204Z" },
-]
-
-[[package]]
-name = "fsspec"
-version = "2025.9.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/de/e0/bab50af11c2d75c9c4a2a26a5254573c0bd97cea152254401510950486fa/fsspec-2025.9.0.tar.gz", hash = "sha256:19fd429483d25d28b65ec68f9f4adc16c17ea2c7c7bf54ec61360d478fb19c19", size = 304847, upload-time = "2025-09-02T19:10:49.215Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/71/70db47e4f6ce3e5c37a607355f80da8860a33226be640226ac52cb05ef2e/fsspec-2025.9.0-py3-none-any.whl", hash = "sha256:530dc2a2af60a414a832059574df4a6e10cce927f6f4a78209390fe38955cfb7", size = 199289, upload-time = "2025-09-02T19:10:47.708Z" },
-]
-
-[[package]]
-name = "genai-prices"
-version = "0.0.29"
+name = "fpdf2"
+version = "2.8.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "httpx" },
-    { name = "pydantic" },
+    { name = "defusedxml" },
+    { name = "fonttools" },
+    { name = "pillow" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b8/65/157725dc28e29afd54d26d10b6d5ca3b54e52b34494b6119ed474626cc56/genai_prices-0.0.29.tar.gz", hash = "sha256:efa8ba68e575357e2249b0c7ad53d4c2094e2b22e19c85ccfbf5ae3217335656", size = 45703, upload-time = "2025-09-29T20:42:50.442Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/27/f2/72feae0b2827ed38013e4307b14f95bf0b3d124adfef4d38a7d57533f7be/fpdf2-2.8.7.tar.gz", hash = "sha256:7060ccee5a9c7ab0a271fb765a36a23639f83ef8996c34e3d46af0a17ede57f9", size = 362351, upload-time = "2026-02-28T05:39:16.456Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a1/e3/2ffded479db7e78f6fb4d338417bbde64534f7608c515e8f8adbef083a36/genai_prices-0.0.29-py3-none-any.whl", hash = "sha256:447d10a3d38fe1b66c062a2678253c153761a3b5807f1bf8a1f2533971296f7d", size = 48324, upload-time = "2025-09-29T20:42:48.381Z" },
+    { url = "https://files.pythonhosted.org/packages/66/0a/cf50ecffa1e3747ed9380a3adfc829259f1f86b3fdbd9e505af789003141/fpdf2-2.8.7-py3-none-any.whl", hash = "sha256:d391fc508a3ce02fc43a577c830cda4fe6f37646f2d143d489839940932fbc19", size = 327056, upload-time = "2026-02-28T05:39:14.619Z" },
 ]
 
 [[package]]
-name = "google-auth"
-version = "2.41.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cachetools" },
-    { name = "pyasn1-modules" },
-    { name = "rsa" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a8/af/5129ce5b2f9688d2fa49b463e544972a7c82b0fdb50980dafee92e121d9f/google_auth-2.41.1.tar.gz", hash = "sha256:b76b7b1f9e61f0cb7e88870d14f6a94aeef248959ef6992670efee37709cbfd2", size = 292284, upload-time = "2025-09-30T22:51:26.363Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/a4/7319a2a8add4cc352be9e3efeff5e2aacee917c85ca2fa1647e29089983c/google_auth-2.41.1-py2.py3-none-any.whl", hash = "sha256:754843be95575b9a19c604a848a41be03f7f2afd8c019f716dc1f51ee41c639d", size = 221302, upload-time = "2025-09-30T22:51:24.212Z" },
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" },
+    { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" },
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
 ]
 
 [[package]]
-name = "google-genai"
-version = "1.41.0"
+name = "genai-prices"
+version = "0.0.61"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "anyio" },
-    { name = "google-auth" },
     { name = "httpx" },
     { name = "pydantic" },
-    { name = "requests" },
-    { name = "tenacity" },
-    { name = "typing-extensions" },
-    { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/72/8b/ee20bcf707769b3b0e1106c3b5c811507736af7e8a60f29a70af1750ba19/google_genai-1.41.0.tar.gz", hash = "sha256:134f861bb0ace4e34af0501ecb75ceee15f7662fd8120698cd185e8cb39f2800", size = 245812, upload-time = "2025-10-02T22:30:29.699Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/71/0c76010eec75f4b3623d521044785c0977c14adabe1cac72b004349567fb/genai_prices-0.0.61.tar.gz", hash = "sha256:4b3bcfd49f174c05831b09f9ee36557d3648569e2f594af6c24b72031b3f0e52", size = 67806, upload-time = "2026-05-19T17:01:36.902Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/15/14/e5e8fbca8863fee718208566c4e927b8e9f45fd46ec5cf89e24759da545b/google_genai-1.41.0-py3-none-any.whl", hash = "sha256:111a3ee64c1a0927d3879faddb368234594432479a40c311e5fe4db338ca8778", size = 245931, upload-time = "2025-10-02T22:30:27.885Z" },
+    { url = "https://files.pythonhosted.org/packages/de/ec/b08dc2e834ca00fd8dfedcb17ae2e920667adaad617b45e32b7a3b146f24/genai_prices-0.0.61-py3-none-any.whl", hash = "sha256:d77142f61c13e69909ac19c8e44fd315fd65f3afd714e8d55e914fab0eaf47a2", size = 70853, upload-time = "2026-05-19T17:01:37.858Z" },
 ]
 
 [[package]]
 name = "googleapis-common-protos"
-version = "1.70.0"
+version = "1.75.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/39/24/33db22342cf4a2ea27c9955e6713140fedd51e8b141b5ce5260897020f1a/googleapis_common_protos-1.70.0.tar.gz", hash = "sha256:0e1b44e0ea153e6594f9f394fef15193a68aaaea2d843f83e2742717ca753257", size = 145903, upload-time = "2025-04-14T10:17:02.924Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/c8/f439cffde755cffa462bfbb156278fa6f9d09119719af9814b858fd4f81f/googleapis_common_protos-1.75.0.tar.gz", hash = "sha256:53a062ff3c32552fbd62c11fe23768b78e4ddf0494d5e5fd97d3f4689c75fbbd", size = 151035, upload-time = "2026-05-07T08:04:49.423Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/86/f1/62a193f0227cf15a920390abe675f386dec35f7ae3ffe6da582d3ade42c7/googleapis_common_protos-1.70.0-py3-none-any.whl", hash = "sha256:b8bfcca8c25a2bb253e0e0b0adaf8c00773e5e6af6fd92397576680b807e0fd8", size = 294530, upload-time = "2025-04-14T10:17:01.271Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/c8/e2645aa8ed02fd4c7a2f59d68783b65b1f3cbdfe39a6308e156509d1fee8/googleapis_common_protos-1.75.0-py3-none-any.whl", hash = "sha256:961ed60399c457ceb0ee8f285a84c870aabc9c6a832b9d37bb281b5bebde43ed", size = 300631, upload-time = "2026-05-07T08:03:30.345Z" },
 ]
 
 [[package]]
-name = "griffe"
-version = "1.14.0"
+name = "griffelib"
+version = "2.0.2"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ec/d7/6c09dd7ce4c7837e4cdb11dce980cb45ae3cd87677298dc3b781b6bce7d3/griffe-1.14.0.tar.gz", hash = "sha256:9d2a15c1eca966d68e00517de5d69dd1bc5c9f2335ef6c1775362ba5b8651a13", size = 424684, upload-time = "2025-09-05T15:02:29.167Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/b1/9ff6578d789a89812ff21e4e0f80ffae20a65d5dd84e7a17873fe3b365be/griffe-1.14.0-py3-none-any.whl", hash = "sha256:0e9d52832cccf0f7188cfe585ba962d2674b241c01916d780925df34873bceb0", size = 144439, upload-time = "2025-09-05T15:02:27.511Z" },
-]
-
-[[package]]
-name = "groq"
-version = "0.32.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "distro" },
-    { name = "httpx" },
-    { name = "pydantic" },
-    { name = "sniffio" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/4d/8c/ed52c15fac63f577dd996367dd5d5133cba3e67e844df21800342461b916/groq-0.32.0.tar.gz", hash = "sha256:fb1ade61f47a06d1a1c1dc0fab690d269b799ebd57ad1dd867efaeaa7adeb2af", size = 141541, upload-time = "2025-09-27T23:01:34.617Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/82/74f4a3310cdabfbb10da554c3a672847f1ed33c6f61dd472681ce7f1fe67/griffelib-2.0.2.tar.gz", hash = "sha256:3cf20b3bc470e83763ffbf236e0076b1211bac1bc67de13daf494640f2de707e", size = 166461, upload-time = "2026-03-27T11:34:51.091Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9d/08/24d62fccb01c4e86c59ba79073af7e5c8ab643846823c2fa3e957bde4b58/groq-0.32.0-py3-none-any.whl", hash = "sha256:0ed0be290042f8826f851f3a1defaac4f979dcfce86ec4a0681a23af00ec800b", size = 135387, upload-time = "2025-09-27T23:01:33.223Z" },
+    { url = "https://files.pythonhosted.org/packages/11/8c/c9138d881c79aa0ea9ed83cbd58d5ca75624378b38cee225dcf5c42cc91f/griffelib-2.0.2-py3-none-any.whl", hash = "sha256:925c857658fb1ba40c0772c37acbc2ab650bd794d9c1b9726922e36ea4117ea1", size = 142357, upload-time = "2026-03-27T11:34:46.275Z" },
 ]
 
 [[package]]
 name = "grpcio"
-version = "1.76.0"
+version = "1.80.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b6/e0/318c1ce3ae5a17894d5791e87aea147587c9e702f24122cc7a5c8bbaeeb1/grpcio-1.76.0.tar.gz", hash = "sha256:7be78388d6da1a25c0d5ec506523db58b18be22d9c37d8d3a32c08be4987bd73", size = 12785182, upload-time = "2025-10-21T16:23:12.106Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/00/8163a1beeb6971f66b4bbe6ac9457b97948beba8dd2fc8e1281dce7f79ec/grpcio-1.76.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:2e1743fbd7f5fa713a1b0a8ac8ebabf0ec980b5d8809ec358d488e273b9cf02a", size = 5843567, upload-time = "2025-10-21T16:20:52.829Z" },
-    { url = "https://files.pythonhosted.org/packages/10/c1/934202f5cf335e6d852530ce14ddb0fef21be612ba9ecbbcbd4d748ca32d/grpcio-1.76.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:a8c2cf1209497cf659a667d7dea88985e834c24b7c3b605e6254cbb5076d985c", size = 11848017, upload-time = "2025-10-21T16:20:56.705Z" },
-    { url = "https://files.pythonhosted.org/packages/11/0b/8dec16b1863d74af6eb3543928600ec2195af49ca58b16334972f6775663/grpcio-1.76.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:08caea849a9d3c71a542827d6df9d5a69067b0a1efbea8a855633ff5d9571465", size = 6412027, upload-time = "2025-10-21T16:20:59.3Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/64/7b9e6e7ab910bea9d46f2c090380bab274a0b91fb0a2fe9b0cd399fffa12/grpcio-1.76.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f0e34c2079d47ae9f6188211db9e777c619a21d4faba6977774e8fa43b085e48", size = 7075913, upload-time = "2025-10-21T16:21:01.645Z" },
-    { url = "https://files.pythonhosted.org/packages/68/86/093c46e9546073cefa789bd76d44c5cb2abc824ca62af0c18be590ff13ba/grpcio-1.76.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8843114c0cfce61b40ad48df65abcfc00d4dba82eae8718fab5352390848c5da", size = 6615417, upload-time = "2025-10-21T16:21:03.844Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/b6/5709a3a68500a9c03da6fb71740dcdd5ef245e39266461a03f31a57036d8/grpcio-1.76.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8eddfb4d203a237da6f3cc8a540dad0517d274b5a1e9e636fd8d2c79b5c1d397", size = 7199683, upload-time = "2025-10-21T16:21:06.195Z" },
-    { url = "https://files.pythonhosted.org/packages/91/d3/4b1f2bf16ed52ce0b508161df3a2d186e4935379a159a834cb4a7d687429/grpcio-1.76.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:32483fe2aab2c3794101c2a159070584e5db11d0aa091b2c0ea9c4fc43d0d749", size = 8163109, upload-time = "2025-10-21T16:21:08.498Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/61/d9043f95f5f4cf085ac5dd6137b469d41befb04bd80280952ffa2a4c3f12/grpcio-1.76.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:dcfe41187da8992c5f40aa8c5ec086fa3672834d2be57a32384c08d5a05b4c00", size = 7626676, upload-time = "2025-10-21T16:21:10.693Z" },
-    { url = "https://files.pythonhosted.org/packages/36/95/fd9a5152ca02d8881e4dd419cdd790e11805979f499a2e5b96488b85cf27/grpcio-1.76.0-cp311-cp311-win32.whl", hash = "sha256:2107b0c024d1b35f4083f11245c0e23846ae64d02f40b2b226684840260ed054", size = 3997688, upload-time = "2025-10-21T16:21:12.746Z" },
-    { url = "https://files.pythonhosted.org/packages/60/9c/5c359c8d4c9176cfa3c61ecd4efe5affe1f38d9bae81e81ac7186b4c9cc8/grpcio-1.76.0-cp311-cp311-win_amd64.whl", hash = "sha256:522175aba7af9113c48ec10cc471b9b9bd4f6ceb36aeb4544a8e2c80ed9d252d", size = 4709315, upload-time = "2025-10-21T16:21:15.26Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/05/8e29121994b8d959ffa0afd28996d452f291b48cfc0875619de0bde2c50c/grpcio-1.76.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:81fd9652b37b36f16138611c7e884eb82e0cec137c40d3ef7c3f9b3ed00f6ed8", size = 5799718, upload-time = "2025-10-21T16:21:17.939Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/75/11d0e66b3cdf998c996489581bdad8900db79ebd83513e45c19548f1cba4/grpcio-1.76.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:04bbe1bfe3a68bbfd4e52402ab7d4eb59d72d02647ae2042204326cf4bbad280", size = 11825627, upload-time = "2025-10-21T16:21:20.466Z" },
-    { url = "https://files.pythonhosted.org/packages/28/50/2f0aa0498bc188048f5d9504dcc5c2c24f2eb1a9337cd0fa09a61a2e75f0/grpcio-1.76.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d388087771c837cdb6515539f43b9d4bf0b0f23593a24054ac16f7a960be16f4", size = 6359167, upload-time = "2025-10-21T16:21:23.122Z" },
-    { url = "https://files.pythonhosted.org/packages/66/e5/bbf0bb97d29ede1d59d6588af40018cfc345b17ce979b7b45424628dc8bb/grpcio-1.76.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:9f8f757bebaaea112c00dba718fc0d3260052ce714e25804a03f93f5d1c6cc11", size = 7044267, upload-time = "2025-10-21T16:21:25.995Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/86/f6ec2164f743d9609691115ae8ece098c76b894ebe4f7c94a655c6b03e98/grpcio-1.76.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:980a846182ce88c4f2f7e2c22c56aefd515daeb36149d1c897f83cf57999e0b6", size = 6573963, upload-time = "2025-10-21T16:21:28.631Z" },
-    { url = "https://files.pythonhosted.org/packages/60/bc/8d9d0d8505feccfdf38a766d262c71e73639c165b311c9457208b56d92ae/grpcio-1.76.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f92f88e6c033db65a5ae3d97905c8fea9c725b63e28d5a75cb73b49bda5024d8", size = 7164484, upload-time = "2025-10-21T16:21:30.837Z" },
-    { url = "https://files.pythonhosted.org/packages/67/e6/5d6c2fc10b95edf6df9b8f19cf10a34263b7fd48493936fffd5085521292/grpcio-1.76.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4baf3cbe2f0be3289eb68ac8ae771156971848bb8aaff60bad42005539431980", size = 8127777, upload-time = "2025-10-21T16:21:33.577Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/c8/dce8ff21c86abe025efe304d9e31fdb0deaaa3b502b6a78141080f206da0/grpcio-1.76.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:615ba64c208aaceb5ec83bfdce7728b80bfeb8be97562944836a7a0a9647d882", size = 7594014, upload-time = "2025-10-21T16:21:41.882Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/42/ad28191ebf983a5d0ecef90bab66baa5a6b18f2bfdef9d0a63b1973d9f75/grpcio-1.76.0-cp312-cp312-win32.whl", hash = "sha256:45d59a649a82df5718fd9527ce775fd66d1af35e6d31abdcdc906a49c6822958", size = 3984750, upload-time = "2025-10-21T16:21:44.006Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/00/7bd478cbb851c04a48baccaa49b75abaa8e4122f7d86da797500cccdd771/grpcio-1.76.0-cp312-cp312-win_amd64.whl", hash = "sha256:c088e7a90b6017307f423efbb9d1ba97a22aa2170876223f9709e9d1de0b5347", size = 4704003, upload-time = "2025-10-21T16:21:46.244Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/db/1d56e5f5823257b291962d6c0ce106146c6447f405b60b234c4f222a7cde/grpcio-1.80.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:dfab85db094068ff42e2a3563f60ab3dddcc9d6488a35abf0132daec13209c8a", size = 6055009, upload-time = "2026-03-30T08:46:46.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/18/c83f3cad64c5ca63bca7e91e5e46b0d026afc5af9d0a9972472ceba294b3/grpcio-1.80.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:5c07e82e822e1161354e32da2662f741a4944ea955f9f580ec8fb409dd6f6060", size = 12035295, upload-time = "2026-03-30T08:46:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/8e/e14966b435be2dda99fbe89db9525ea436edc79780431a1c2875a3582644/grpcio-1.80.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba0915d51fd4ced2db5ff719f84e270afe0e2d4c45a7bdb1e8d036e4502928c2", size = 6610297, upload-time = "2026-03-30T08:46:52.123Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/26/d5eb38f42ce0e3fdc8174ea4d52036ef8d58cc4426cb800f2610f625dd75/grpcio-1.80.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3cb8130ba457d2aa09fa6b7c3ed6b6e4e6a2685fce63cb803d479576c4d80e21", size = 7300208, upload-time = "2026-03-30T08:46:54.859Z" },
+    { url = "https://files.pythonhosted.org/packages/25/51/bd267c989f85a17a5b3eea65a6feb4ff672af41ca614e5a0279cc0ea381c/grpcio-1.80.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:09e5e478b3d14afd23f12e49e8b44c8684ac3c5f08561c43a5b9691c54d136ab", size = 6813442, upload-time = "2026-03-30T08:46:57.056Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d9/d80eef735b19e9169e30164bbf889b46f9df9127598a83d174eb13a48b26/grpcio-1.80.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:00168469238b022500e486c1c33916acf2f2a9b2c022202cf8a1885d2e3073c1", size = 7414743, upload-time = "2026-03-30T08:46:59.682Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f2/567f5bd5054398ed6b0509b9a30900376dcf2786bd936812098808b49d8d/grpcio-1.80.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8502122a3cc1714038e39a0b071acb1207ca7844208d5ea0d091317555ee7106", size = 8426046, upload-time = "2026-03-30T08:47:02.474Z" },
+    { url = "https://files.pythonhosted.org/packages/62/29/73ef0141b4732ff5eacd68430ff2512a65c004696997f70476a83e548e7e/grpcio-1.80.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce1794f4ea6cc3ca29463f42d665c32ba1b964b48958a66497917fe9069f26e6", size = 7851641, upload-time = "2026-03-30T08:47:05.462Z" },
+    { url = "https://files.pythonhosted.org/packages/46/69/abbfa360eb229a8623bab5f5a4f8105e445bd38ce81a89514ba55d281ad0/grpcio-1.80.0-cp311-cp311-win32.whl", hash = "sha256:51b4a7189b0bef2aa30adce3c78f09c83526cf3dddb24c6a96555e3b97340440", size = 4154368, upload-time = "2026-03-30T08:47:08.027Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d4/ae92206d01183b08613e846076115f5ac5991bae358d2a749fa864da5699/grpcio-1.80.0-cp311-cp311-win_amd64.whl", hash = "sha256:02e64bb0bb2da14d947a49e6f120a75e947250aebe65f9629b62bb1f5c14e6e9", size = 4894235, upload-time = "2026-03-30T08:47:10.839Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e8/a2b749265eb3415abc94f2e619bbd9e9707bebdda787e61c593004ec927a/grpcio-1.80.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:c624cc9f1008361014378c9d776de7182b11fe8b2e5a81bc69f23a295f2a1ad0", size = 6015616, upload-time = "2026-03-30T08:47:13.428Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/97/b1282161a15d699d1e90c360df18d19165a045ce1c343c7f313f5e8a0b77/grpcio-1.80.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:f49eddcac43c3bf350c0385366a58f36bed8cc2c0ec35ef7b74b49e56552c0c2", size = 12014204, upload-time = "2026-03-30T08:47:15.873Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/5e/d319c6e997b50c155ac5a8cb12f5173d5b42677510e886d250d50264949d/grpcio-1.80.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d334591df610ab94714048e0d5b4f3dd5ad1bee74dfec11eee344220077a79de", size = 6563866, upload-time = "2026-03-30T08:47:18.588Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/f6/fdd975a2cb4d78eb67769a7b3b3830970bfa2e919f1decf724ae4445f42c/grpcio-1.80.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0cb517eb1d0d0aaf1d87af7cc5b801d686557c1d88b2619f5e31fab3c2315921", size = 7273060, upload-time = "2026-03-30T08:47:21.113Z" },
+    { url = "https://files.pythonhosted.org/packages/db/f0/a3deb5feba60d9538a962913e37bd2e69a195f1c3376a3dd44fe0427e996/grpcio-1.80.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4e78c4ac0d97dc2e569b2f4bcbbb447491167cb358d1a389fc4af71ab6f70411", size = 6782121, upload-time = "2026-03-30T08:47:23.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/84/36c6dcfddc093e108141f757c407902a05085e0c328007cb090d56646cdf/grpcio-1.80.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2ed770b4c06984f3b47eb0517b1c69ad0b84ef3f40128f51448433be904634cd", size = 7383811, upload-time = "2026-03-30T08:47:26.517Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ef/f3a77e3dc5b471a0ec86c564c98d6adfa3510d38f8ee99010410858d591e/grpcio-1.80.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:256507e2f524092f1473071a05e65a5b10d84b82e3ff24c5b571513cfaa61e2f", size = 8393860, upload-time = "2026-03-30T08:47:29.439Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/8d/9d4d27ed7f33d109c50d6b5ce578a9914aa68edab75d65869a17e630a8d1/grpcio-1.80.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a6284a5d907c37db53350645567c522be314bac859a64a7a5ca63b77bb7958f", size = 7830132, upload-time = "2026-03-30T08:47:33.254Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e4/9990b41c6d7a44e1e9dee8ac11d7a9802ba1378b40d77468a7761d1ad288/grpcio-1.80.0-cp312-cp312-win32.whl", hash = "sha256:c71309cfce2f22be26aa4a847357c502db6c621f1a49825ae98aa0907595b193", size = 4140904, upload-time = "2026-03-30T08:47:35.319Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/2c/296f6138caca1f4b92a31ace4ae1b87dab692fc16a7a3417af3bb3c805bf/grpcio-1.80.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe648599c0e37594c4809d81a9e77bd138cc82eb8baa71b6a86af65426723ff", size = 4880944, upload-time = "2026-03-30T08:47:37.831Z" },
 ]
 
 [[package]]
@@ -1066,21 +1088,6 @@ 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 = "hf-xet"
-version = "1.1.10"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/74/31/feeddfce1748c4a233ec1aa5b7396161c07ae1aa9b7bdbc9a72c3c7dd768/hf_xet-1.1.10.tar.gz", hash = "sha256:408aef343800a2102374a883f283ff29068055c111f003ff840733d3b715bb97", size = 487910, upload-time = "2025-09-12T20:10:27.12Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/a2/343e6d05de96908366bdc0081f2d8607d61200be2ac802769c4284cc65bd/hf_xet-1.1.10-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:686083aca1a6669bc85c21c0563551cbcdaa5cf7876a91f3d074a030b577231d", size = 2761466, upload-time = "2025-09-12T20:10:22.836Z" },
-    { url = "https://files.pythonhosted.org/packages/31/f9/6215f948ac8f17566ee27af6430ea72045e0418ce757260248b483f4183b/hf_xet-1.1.10-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:71081925383b66b24eedff3013f8e6bbd41215c3338be4b94ba75fd75b21513b", size = 2623807, upload-time = "2025-09-12T20:10:21.118Z" },
-    { url = "https://files.pythonhosted.org/packages/15/07/86397573efefff941e100367bbda0b21496ffcdb34db7ab51912994c32a2/hf_xet-1.1.10-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b6bceb6361c80c1cc42b5a7b4e3efd90e64630bcf11224dcac50ef30a47e435", size = 3186960, upload-time = "2025-09-12T20:10:19.336Z" },
-    { url = "https://files.pythonhosted.org/packages/01/a7/0b2e242b918cc30e1f91980f3c4b026ff2eedaf1e2ad96933bca164b2869/hf_xet-1.1.10-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:eae7c1fc8a664e54753ffc235e11427ca61f4b0477d757cc4eb9ae374b69f09c", size = 3087167, upload-time = "2025-09-12T20:10:17.255Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/25/3e32ab61cc7145b11eee9d745988e2f0f4fafda81b25980eebf97d8cff15/hf_xet-1.1.10-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0a0005fd08f002180f7a12d4e13b22be277725bc23ed0529f8add5c7a6309c06", size = 3248612, upload-time = "2025-09-12T20:10:24.093Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/3d/ab7109e607ed321afaa690f557a9ada6d6d164ec852fd6bf9979665dc3d6/hf_xet-1.1.10-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f900481cf6e362a6c549c61ff77468bd59d6dd082f3170a36acfef2eb6a6793f", size = 3353360, upload-time = "2025-09-12T20:10:25.563Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/0e/471f0a21db36e71a2f1752767ad77e92d8cde24e974e03d662931b1305ec/hf_xet-1.1.10-cp37-abi3-win_amd64.whl", hash = "sha256:5f54b19cc347c13235ae7ee98b330c26dd65ef1df47e5316ffb1e87713ca7045", size = 2804691, upload-time = "2025-09-12T20:10:28.433Z" },
-]
-
 [[package]]
 name = "httpcore"
 version = "1.0.9"
@@ -1096,24 +1103,24 @@ wheels = [
 
 [[package]]
 name = "httptools"
-version = "0.6.4"
+version = "0.7.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a7/9a/ce5e1f7e131522e6d3426e8e7a490b3a01f39a6696602e1c4f33f9e94277/httptools-0.6.4.tar.gz", hash = "sha256:4e93eee4add6493b59a5c514da98c939b244fce4a0d8879cd3f466562f4b7d5c", size = 240639, upload-time = "2024-10-16T19:45:08.902Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7b/26/bb526d4d14c2774fe07113ca1db7255737ffbb119315839af2065abfdac3/httptools-0.6.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f47f8ed67cc0ff862b84a1189831d1d33c963fb3ce1ee0c65d3b0cbe7b711069", size = 199029, upload-time = "2024-10-16T19:44:18.427Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/17/3e0d3e9b901c732987a45f4f94d4e2c62b89a041d93db89eafb262afd8d5/httptools-0.6.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0614154d5454c21b6410fdf5262b4a3ddb0f53f1e1721cfd59d55f32138c578a", size = 103492, upload-time = "2024-10-16T19:44:19.515Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/24/0fe235d7b69c42423c7698d086d4db96475f9b50b6ad26a718ef27a0bce6/httptools-0.6.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8787367fbdfccae38e35abf7641dafc5310310a5987b689f4c32cc8cc3ee975", size = 462891, upload-time = "2024-10-16T19:44:21.067Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/2f/205d1f2a190b72da6ffb5f41a3736c26d6fa7871101212b15e9b5cd8f61d/httptools-0.6.4-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40b0f7fe4fd38e6a507bdb751db0379df1e99120c65fbdc8ee6c1d044897a636", size = 459788, upload-time = "2024-10-16T19:44:22.958Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/4c/d09ce0eff09057a206a74575ae8f1e1e2f0364d20e2442224f9e6612c8b9/httptools-0.6.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:40a5ec98d3f49904b9fe36827dcf1aadfef3b89e2bd05b0e35e94f97c2b14721", size = 433214, upload-time = "2024-10-16T19:44:24.513Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/d2/84c9e23edbccc4a4c6f96a1b8d99dfd2350289e94f00e9ccc7aadde26fb5/httptools-0.6.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:dacdd3d10ea1b4ca9df97a0a303cbacafc04b5cd375fa98732678151643d4988", size = 434120, upload-time = "2024-10-16T19:44:26.295Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/46/4d8e7ba9581416de1c425b8264e2cadd201eb709ec1584c381f3e98f51c1/httptools-0.6.4-cp311-cp311-win_amd64.whl", hash = "sha256:288cd628406cc53f9a541cfaf06041b4c71d751856bab45e3702191f931ccd17", size = 88565, upload-time = "2024-10-16T19:44:29.188Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/0e/d0b71465c66b9185f90a091ab36389a7352985fe857e352801c39d6127c8/httptools-0.6.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:df017d6c780287d5c80601dafa31f17bddb170232d85c066604d8558683711a2", size = 200683, upload-time = "2024-10-16T19:44:30.175Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/b8/412a9bb28d0a8988de3296e01efa0bd62068b33856cdda47fe1b5e890954/httptools-0.6.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:85071a1e8c2d051b507161f6c3e26155b5c790e4e28d7f236422dbacc2a9cc44", size = 104337, upload-time = "2024-10-16T19:44:31.786Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/01/6fb20be3196ffdc8eeec4e653bc2a275eca7f36634c86302242c4fbb2760/httptools-0.6.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69422b7f458c5af875922cdb5bd586cc1f1033295aa9ff63ee196a87519ac8e1", size = 508796, upload-time = "2024-10-16T19:44:32.825Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/d8/b644c44acc1368938317d76ac991c9bba1166311880bcc0ac297cb9d6bd7/httptools-0.6.4-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:16e603a3bff50db08cd578d54f07032ca1631450ceb972c2f834c2b860c28ea2", size = 510837, upload-time = "2024-10-16T19:44:33.974Z" },
-    { url = "https://files.pythonhosted.org/packages/52/d8/254d16a31d543073a0e57f1c329ca7378d8924e7e292eda72d0064987486/httptools-0.6.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec4f178901fa1834d4a060320d2f3abc5c9e39766953d038f1458cb885f47e81", size = 485289, upload-time = "2024-10-16T19:44:35.111Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/3c/4aee161b4b7a971660b8be71a92c24d6c64372c1ab3ae7f366b3680df20f/httptools-0.6.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f9eb89ecf8b290f2e293325c646a211ff1c2493222798bb80a530c5e7502494f", size = 489779, upload-time = "2024-10-16T19:44:36.253Z" },
-    { url = "https://files.pythonhosted.org/packages/12/b7/5cae71a8868e555f3f67a50ee7f673ce36eac970f029c0c5e9d584352961/httptools-0.6.4-cp312-cp312-win_amd64.whl", hash = "sha256:db78cb9ca56b59b016e64b6031eda5653be0589dba2b1b43453f6e8b405a0970", size = 88634, upload-time = "2024-10-16T19:44:37.357Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/08/17e07e8d89ab8f343c134616d72eebfe03798835058e2ab579dcc8353c06/httptools-0.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:474d3b7ab469fefcca3697a10d11a32ee2b9573250206ba1e50d5980910da657", size = 206521, upload-time = "2025-10-10T03:54:31.002Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/06/c9c1b41ff52f16aee526fd10fbda99fa4787938aa776858ddc4a1ea825ec/httptools-0.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3c3b7366bb6c7b96bd72d0dbe7f7d5eead261361f013be5f6d9590465ea1c70", size = 110375, upload-time = "2025-10-10T03:54:31.941Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/cc/10935db22fda0ee34c76f047590ca0a8bd9de531406a3ccb10a90e12ea21/httptools-0.7.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:379b479408b8747f47f3b253326183d7c009a3936518cdb70db58cffd369d9df", size = 456621, upload-time = "2025-10-10T03:54:33.176Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/84/875382b10d271b0c11aa5d414b44f92f8dd53e9b658aec338a79164fa548/httptools-0.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cad6b591a682dcc6cf1397c3900527f9affef1e55a06c4547264796bbd17cf5e", size = 454954, upload-time = "2025-10-10T03:54:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e1/44f89b280f7e46c0b1b2ccee5737d46b3bb13136383958f20b580a821ca0/httptools-0.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eb844698d11433d2139bbeeb56499102143beb582bd6c194e3ba69c22f25c274", size = 440175, upload-time = "2025-10-10T03:54:35.942Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/7e/b9287763159e700e335028bc1824359dc736fa9b829dacedace91a39b37e/httptools-0.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f65744d7a8bdb4bda5e1fa23e4ba16832860606fcc09d674d56e425e991539ec", size = 440310, upload-time = "2025-10-10T03:54:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/07/5b614f592868e07f5c94b1f301b5e14a21df4e8076215a3bccb830a687d8/httptools-0.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:135fbe974b3718eada677229312e97f3b31f8a9c8ffa3ae6f565bf808d5b6bcb", size = 86875, upload-time = "2025-10-10T03:54:38.421Z" },
+    { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280, upload-time = "2025-10-10T03:54:39.274Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004, upload-time = "2025-10-10T03:54:40.403Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655, upload-time = "2025-10-10T03:54:41.347Z" },
+    { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440, upload-time = "2025-10-10T03:54:42.452Z" },
+    { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186, upload-time = "2025-10-10T03:54:43.937Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192, upload-time = "2025-10-10T03:54:45.003Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/de/40a8f202b987d43afc4d54689600ff03ce65680ede2f31df348d7f368b8f/httptools-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3e14f530fefa7499334a79b0cf7e7cd2992870eb893526fb097d51b4f2d0f321", size = 86694, upload-time = "2025-10-10T03:54:45.923Z" },
 ]
 
 [[package]]
@@ -1133,74 +1140,54 @@ wheels = [
 
 [[package]]
 name = "httpx-sse"
-version = "0.4.0"
+version = "0.4.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4c/60/8f4281fa9bbf3c8034fd54c0e7412e66edbab6bc74c4996bd616f8d0406e/httpx-sse-0.4.0.tar.gz", hash = "sha256:1e81a3a3070ce322add1d3529ed42eb5f70817f45ed6ec915ab753f961139721", size = 12624, upload-time = "2023-12-22T08:01:21.083Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e1/9b/a181f281f65d776426002f330c31849b86b31fc9d848db62e16f03ff739f/httpx_sse-0.4.0-py3-none-any.whl", hash = "sha256:f329af6eae57eaa2bdfd962b42524764af68075ea87370a2de920af5341e318f", size = 7819, upload-time = "2023-12-22T08:01:19.89Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
 ]
 
 [[package]]
-name = "huggingface-hub"
-version = "0.35.3"
+name = "idna"
+version = "3.15"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "filelock" },
-    { name = "fsspec" },
-    { name = "hf-xet", marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" },
-    { name = "packaging" },
-    { name = "pyyaml" },
-    { name = "requests" },
-    { name = "tqdm" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/10/7e/a0a97de7c73671863ca6b3f61fa12518caf35db37825e43d63a70956738c/huggingface_hub-0.35.3.tar.gz", hash = "sha256:350932eaa5cc6a4747efae85126ee220e4ef1b54e29d31c3b45c5612ddf0b32a", size = 461798, upload-time = "2025-09-29T14:29:58.625Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/77/7b3966d0b9d1d31a36ddf1746926a11dface89a83409bf1483f0237aa758/idna-3.15.tar.gz", hash = "sha256:ca962446ea538f7092a95e057da437618e886f4d349216d2b1e294abfdb65fdc", size = 199245, upload-time = "2026-05-12T22:45:57.011Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/a0/651f93d154cb72323358bf2bbae3e642bdb5d2f1bfc874d096f7cb159fa0/huggingface_hub-0.35.3-py3-none-any.whl", hash = "sha256:0e3a01829c19d86d03793e4577816fe3bdfc1602ac62c7fb220d593d351224ba", size = 564262, upload-time = "2025-09-29T14:29:55.813Z" },
-]
-
-[package.optional-dependencies]
-inference = [
-    { name = "aiohttp" },
+    { url = "https://files.pythonhosted.org/packages/d2/23/408243171aa9aaba178d3e2559159c24c1171a641aa83b67bdd3394ead8e/idna-3.15-py3-none-any.whl", hash = "sha256:048adeaf8c2d788c40fee287673ccaa74c24ffd8dcf09ffa555a2fbb59f10ac8", size = 72340, upload-time = "2026-05-12T22:45:55.733Z" },
 ]
 
 [[package]]
-name = "idna"
-version = "3.10"
+name = "img2pdf"
+version = "0.6.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" }
+dependencies = [
+    { name = "pikepdf" },
+    { name = "pillow" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8e/97/ca44c467131b93fda82d2a2f21b738c8bcf63b5259e3b8250e928b8dd52a/img2pdf-0.6.3.tar.gz", hash = "sha256:219518020f5bd242bdc46493941ea3f756f664c2e86f2454721e74353f58cd95", size = 120350, upload-time = "2025-11-05T20:51:57.558Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/dc/91e3a4a11c25ae183bd5a71b84ecb298db76405ff70013f76b10877bdfe3/img2pdf-0.6.3-py3-none-any.whl", hash = "sha256:44d12d235752edd17c43c04ff39952cdc5dd4c6aba90569c4902bd445085266b", size = 49701, upload-time = "2025-11-05T20:51:55.469Z" },
 ]
 
 [[package]]
 name = "importlib-metadata"
-version = "8.7.0"
+version = "9.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "zipp" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405, upload-time = "2026-03-20T06:42:56.999Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" },
+    { url = "https://files.pythonhosted.org/packages/38/3d/2d244233ac4f76e38533cfcb2991c9eb4c7bf688ae0a036d30725b8faafe/importlib_metadata-9.0.0-py3-none-any.whl", hash = "sha256:2d21d1cc5a017bd0559e36150c21c830ab1dc304dedd1b7ea85d20f45ef3edd7", size = 27789, upload-time = "2026-03-20T06:42:55.665Z" },
 ]
 
 [[package]]
 name = "iniconfig"
-version = "2.1.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793, upload-time = "2025-03-19T20:09:59.721Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" },
-]
-
-[[package]]
-name = "invoke"
-version = "2.2.0"
+version = "2.3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f9/42/127e6d792884ab860defc3f4d80a8f9812e48ace584ffc5a346de58cdc6c/invoke-2.2.0.tar.gz", hash = "sha256:ee6cbb101af1a859c7fe84f2a264c059020b0cb7fe3535f9424300ab568f6bd5", size = 299835, upload-time = "2023-07-12T18:05:17.998Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0a/66/7f8c48009c72d73bc6bbe6eb87ac838d6a526146f7dab14af671121eb379/invoke-2.2.0-py3-none-any.whl", hash = "sha256:6ea924cc53d4f78e3d98bc436b08069a03077e6f85ad1ddaa8a116d7dad15820", size = 160274, upload-time = "2023-07-12T18:05:16.294Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
 ]
 
 [[package]]
@@ -1226,44 +1213,55 @@ wheels = [
 
 [[package]]
 name = "jiter"
-version = "0.11.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9d/c0/a3bb4cc13aced219dd18191ea66e874266bd8aa7b96744e495e1c733aa2d/jiter-0.11.0.tar.gz", hash = "sha256:1d9637eaf8c1d6a63d6562f2a6e5ab3af946c66037eb1b894e8fad75422266e4", size = 167094, upload-time = "2025-09-15T09:20:38.212Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/38/55/a69fefeef09c2eaabae44b935a1aa81517e49639c0a0c25d861cb18cd7ac/jiter-0.11.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:cb5d9db02979c3f49071fce51a48f4b4e4cf574175fb2b11c7a535fa4867b222", size = 309503, upload-time = "2025-09-15T09:19:08.191Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/d5/a6aba9e6551f32f9c127184f398208e4eddb96c59ac065c8a92056089d28/jiter-0.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1dc6a123f3471c4730db7ca8ba75f1bb3dcb6faeb8d46dd781083e7dee88b32d", size = 317688, upload-time = "2025-09-15T09:19:09.918Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/f3/5e86f57c1883971cdc8535d0429c2787bf734840a231da30a3be12850562/jiter-0.11.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09858f8d230f031c7b8e557429102bf050eea29c77ad9c34c8fe253c5329acb7", size = 337418, upload-time = "2025-09-15T09:19:11.078Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/4f/a71d8a24c2a70664970574a8e0b766663f5ef788f7fe1cc20ee0c016d488/jiter-0.11.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dbe2196c4a0ce760925a74ab4456bf644748ab0979762139626ad138f6dac72d", size = 361423, upload-time = "2025-09-15T09:19:13.286Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/e5/b09076f4e7fd9471b91e16f9f3dc7330b161b738f3b39b2c37054a36e26a/jiter-0.11.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5beb56d22b63647bafd0b74979216fdee80c580c0c63410be8c11053860ffd09", size = 486367, upload-time = "2025-09-15T09:19:14.546Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/f1/98cb3a36f5e62f80cd860f0179f948d9eab5a316d55d3e1bab98d9767af5/jiter-0.11.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97025d09ef549795d8dc720a824312cee3253c890ac73c621721ddfc75066789", size = 376335, upload-time = "2025-09-15T09:19:15.939Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/d8/ec74886497ea393c29dbd7651ddecc1899e86404a6b1f84a3ddab0ab59fd/jiter-0.11.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d50880a6da65d8c23a2cf53c412847d9757e74cc9a3b95c5704a1d1a24667347", size = 348981, upload-time = "2025-09-15T09:19:17.568Z" },
-    { url = "https://files.pythonhosted.org/packages/24/93/d22ad7fa3b86ade66c86153ceea73094fc2af8b20c59cb7fceab9fea4704/jiter-0.11.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:452d80a1c86c095a242007bd9fc5d21b8a8442307193378f891cb8727e469648", size = 385797, upload-time = "2025-09-15T09:19:19.121Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/bd/e25ff4a4df226e9b885f7cb01ee4b9dc74e3000e612d6f723860d71a1f34/jiter-0.11.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e84e58198d4894668eec2da660ffff60e0f3e60afa790ecc50cb12b0e02ca1d4", size = 516597, upload-time = "2025-09-15T09:19:20.301Z" },
-    { url = "https://files.pythonhosted.org/packages/be/fb/beda613db7d93ffa2fdd2683f90f2f5dce8daf4bc2d0d2829e7de35308c6/jiter-0.11.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:df64edcfc5dd5279a791eea52aa113d432c933119a025b0b5739f90d2e4e75f1", size = 508853, upload-time = "2025-09-15T09:19:22.075Z" },
-    { url = "https://files.pythonhosted.org/packages/20/64/c5b0d93490634e41e38e2a15de5d54fdbd2c9f64a19abb0f95305b63373c/jiter-0.11.0-cp311-cp311-win32.whl", hash = "sha256:144fc21337d21b1d048f7f44bf70881e1586401d405ed3a98c95a114a9994982", size = 205140, upload-time = "2025-09-15T09:19:23.351Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/e6/c347c0e6f5796e97d4356b7e5ff0ce336498b7f4ef848fae621a56f1ccf3/jiter-0.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:b0f32e644d241293b892b1a6dd8f0b9cc029bfd94c97376b2681c36548aabab7", size = 204311, upload-time = "2025-09-15T09:19:24.591Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/b5/3009b112b8f673e568ef79af9863d8309a15f0a8cdcc06ed6092051f377e/jiter-0.11.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:2fb7b377688cc3850bbe5c192a6bd493562a0bc50cbc8b047316428fbae00ada", size = 305510, upload-time = "2025-09-15T09:19:25.893Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/82/15514244e03b9e71e086bbe2a6de3e4616b48f07d5f834200c873956fb8c/jiter-0.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a1b7cbe3f25bd0d8abb468ba4302a5d45617ee61b2a7a638f63fee1dc086be99", size = 316521, upload-time = "2025-09-15T09:19:27.525Z" },
-    { url = "https://files.pythonhosted.org/packages/92/94/7a2e905f40ad2d6d660e00b68d818f9e29fb87ffe82774f06191e93cbe4a/jiter-0.11.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c0a7f0ec81d5b7588c5cade1eb1925b91436ae6726dc2df2348524aeabad5de6", size = 338214, upload-time = "2025-09-15T09:19:28.727Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/9c/5791ed5bdc76f12110158d3316a7a3ec0b1413d018b41c5ed399549d3ad5/jiter-0.11.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07630bb46ea2a6b9c6ed986c6e17e35b26148cce2c535454b26ee3f0e8dcaba1", size = 361280, upload-time = "2025-09-15T09:19:30.013Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/7f/b7d82d77ff0d2cb06424141000176b53a9e6b16a1125525bb51ea4990c2e/jiter-0.11.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7764f27d28cd4a9cbc61704dfcd80c903ce3aad106a37902d3270cd6673d17f4", size = 487895, upload-time = "2025-09-15T09:19:31.424Z" },
-    { url = "https://files.pythonhosted.org/packages/42/44/10a1475d46f1fc1fd5cc2e82c58e7bca0ce5852208e0fa5df2f949353321/jiter-0.11.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1d4a6c4a737d486f77f842aeb22807edecb4a9417e6700c7b981e16d34ba7c72", size = 378421, upload-time = "2025-09-15T09:19:32.746Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/5f/0dc34563d8164d31d07bc09d141d3da08157a68dcd1f9b886fa4e917805b/jiter-0.11.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf408d2a0abd919b60de8c2e7bc5eeab72d4dafd18784152acc7c9adc3291591", size = 347932, upload-time = "2025-09-15T09:19:34.612Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/de/b68f32a4fcb7b4a682b37c73a0e5dae32180140cd1caf11aef6ad40ddbf2/jiter-0.11.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cdef53eda7d18e799625023e1e250dbc18fbc275153039b873ec74d7e8883e09", size = 386959, upload-time = "2025-09-15T09:19:35.994Z" },
-    { url = "https://files.pythonhosted.org/packages/76/0a/c08c92e713b6e28972a846a81ce374883dac2f78ec6f39a0dad9f2339c3a/jiter-0.11.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:53933a38ef7b551dd9c7f1064f9d7bb235bb3168d0fa5f14f0798d1b7ea0d9c5", size = 517187, upload-time = "2025-09-15T09:19:37.426Z" },
-    { url = "https://files.pythonhosted.org/packages/89/b5/4a283bec43b15aad54fcae18d951f06a2ec3f78db5708d3b59a48e9c3fbd/jiter-0.11.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:11840d2324c9ab5162fc1abba23bc922124fedcff0d7b7f85fffa291e2f69206", size = 509461, upload-time = "2025-09-15T09:19:38.761Z" },
-    { url = "https://files.pythonhosted.org/packages/34/a5/f8bad793010534ea73c985caaeef8cc22dfb1fedb15220ecdf15c623c07a/jiter-0.11.0-cp312-cp312-win32.whl", hash = "sha256:4f01a744d24a5f2bb4a11657a1b27b61dc038ae2e674621a74020406e08f749b", size = 206664, upload-time = "2025-09-15T09:19:40.096Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/42/5823ec2b1469395a160b4bf5f14326b4a098f3b6898fbd327366789fa5d3/jiter-0.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:29fff31190ab3a26de026da2f187814f4b9c6695361e20a9ac2123e4d4378a4c", size = 203520, upload-time = "2025-09-15T09:19:41.798Z" },
-    { url = "https://files.pythonhosted.org/packages/70/f3/ce100253c80063a7b8b406e1d1562657fd4b9b4e1b562db40e68645342fb/jiter-0.11.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:902b43386c04739229076bd1c4c69de5d115553d982ab442a8ae82947c72ede7", size = 336380, upload-time = "2025-09-15T09:20:36.867Z" },
+version = "0.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/b5/55f06bb281d92fb3cc86d14e1def2bd908bb77693183e7cb1f5a3c388b0c/jiter-0.15.0.tar.gz", hash = "sha256:4251acc80e2b7c9b7b8823456ea0fceeb0734dac2df7636d3c711b38476b5a76", size = 166640, upload-time = "2026-05-19T10:09:48.361Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/13/daa722f5765c393576f466378f9dfd29d77c9bed939e0688f96afa3601ea/jiter-0.15.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0f862193b8696249d22ec433e85fd2ab0ad9596bc3e45e6c0bc55e8aeba97be2", size = 310899, upload-time = "2026-05-19T10:07:12.89Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/82/2d2551829b082f4b6d82b9f939b031fb808a10aab1ec0664f82e150bb9a2/jiter-0.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1303d4d68a9b051ea90502402063ecf3807da00ad2affa19ca1ae3b90b3c5f67", size = 314963, upload-time = "2026-05-19T10:07:14.539Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/0a/8b1a51466f7fe9f31dbe4bc7e0ca848674f9825e0f737b929b97e8c60aa7/jiter-0.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:392b8ab019e5502d08aff85c6272209c24bc2cbe706ea82a56368f524236614a", size = 341730, upload-time = "2026-05-19T10:07:15.869Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/2a/e71dea19822e2e404e83992a08c1d6b9b617bb944f28c9c2fbd85d02c91e/jiter-0.15.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:773b6eb282ce11ee19f05f6b2d4404fa308e5bbd353b0b80a0262caad6db2cd7", size = 366214, upload-time = "2026-05-19T10:07:17.259Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/59/97e1fa539d124a509a00ab7f669289d1c1d236ecabf12948a18f16c91082/jiter-0.15.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2c0c44d569ce0f2850f5c926f8caeb5f245fbc84475aeb36efccc2103e6dbd", size = 459527, upload-time = "2026-05-19T10:07:18.741Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/7a/4a68d331aef8cf2e2393c14a3aacb635c62aa86071b0229899fb5baaa907/jiter-0.15.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:032396229564bca02440396bd327710719f724f5e7b7e9f7a8eb3faa4a2c2281", size = 375451, upload-time = "2026-05-19T10:07:20.208Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/7e/1c445c2b6f0e30a274dc8082e0c3c7825411cce80d726bccd697c98cc8d3/jiter-0.15.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3d37768fce7f88dd2a8c6091f2325dea27d30d30d5c6e7a1c0f0af77723b708", size = 349428, upload-time = "2026-05-19T10:07:22.372Z" },
+    { url = "https://files.pythonhosted.org/packages/00/94/e20d38984fc17a636371bffd2ae0f698124fdc8e75ef969cd2da6ba7cea7/jiter-0.15.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:2c9cb907439d20bd0c7d7565ca01ee52234203208433749bae5b516907526928", size = 355405, upload-time = "2026-05-19T10:07:23.916Z" },
+    { url = "https://files.pythonhosted.org/packages/94/fa/4d09f814779d0ea80a28ed8e4c6662ec9a4a8ecef0ac52190ebac6262d14/jiter-0.15.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9100ddbec09741cc66feb0fc6773f8bdbd0e3c345689368f260082ff85dcc0cd", size = 393688, upload-time = "2026-05-19T10:07:25.854Z" },
+    { url = "https://files.pythonhosted.org/packages/54/9d/8eb5d4fb8bf7e93a75964a5da71a75c67c864baf7fa3f98598187b3c7e57/jiter-0.15.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ae1b0d82ac2d987f9ea512b1c9adfcc71a28de3dea3a6039b54d76cffda9901e", size = 520853, upload-time = "2026-05-19T10:07:27.303Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/2c/5e07874e59e623a943a0acf1552a80d05b70f31b402287a8fc6d7ec634c7/jiter-0.15.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8020c99ec13a7db2b6f96cbe82ef4721c88b426a4892f27478044af0284615ef", size = 551016, upload-time = "2026-05-19T10:07:28.846Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/d2d34422143474cadc15b60d482b1c35683dbc5c63c24346ddd0df09bcaf/jiter-0.15.0-cp311-cp311-win32.whl", hash = "sha256:42bfb257930800cf43e7c62c832402c704ab60797c992faf88d20e903eac8f32", size = 209518, upload-time = "2026-05-19T10:07:30.431Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/7d/52778b930e5cc3e52a37d950b1c10494244308b4329b25a0ff0d88303a81/jiter-0.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:860a74063284a2ae9bfedd694f299cc2c68e2696c5f3d440cc9d18bb81b9dd04", size = 200565, upload-time = "2026-05-19T10:07:32.125Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/4f/d9b4067feb69b3fa6eb0488e1b59e2ad5b463fe39f59e527eab2aca00bb0/jiter-0.15.0-cp311-cp311-win_arm64.whl", hash = "sha256:37a10c377ce3a4a85f4a67f28b7afe093154cde77eaf248a72e856aa08b4d865", size = 195488, upload-time = "2026-05-19T10:07:33.846Z" },
+    { url = "https://files.pythonhosted.org/packages/44/53/4f6bddbcde3c71e56d0aa1337ec95950f3d27dd4153e25aadf0feac71751/jiter-0.15.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:0e90a1c315a0226ec822d973817967f9223b7701546c8c2a7913e7ab0926294d", size = 308793, upload-time = "2026-05-19T10:07:35.25Z" },
+    { url = "https://files.pythonhosted.org/packages/01/84/c01099b59a285a1ebba64ae93f62bfa036675340fd1b0045ae65890a0442/jiter-0.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8c9004af7c8d67cce7f1aae1026fb55607f4aa600710d08ede3a3ce4aeefe7e0", size = 309570, upload-time = "2026-05-19T10:07:36.919Z" },
+    { url = "https://files.pythonhosted.org/packages/58/64/8fb7f9d45bb98190355454cd04dad8d8f27223d6bd52f83af07f637168a6/jiter-0.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c210f8b35dc6f30aafd4b4365ca89b9d1189f21ab49b8e68fa6322a847aef138", size = 336783, upload-time = "2026-05-19T10:07:38.694Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/b6/f5739011d009b3a30f6a53c5240979030ba29ae46a8c67e3a15759f7c37d/jiter-0.15.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f30bae8bc1c2d613e28e5af3e8cceb09b742f1c8a8a5f839fb67afaffc03b61", size = 363555, upload-time = "2026-05-19T10:07:40.832Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/12/98a9d9f766665e8a3b6252454e17cb0c464606a28cf2fa09399b003345fa/jiter-0.15.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c60e71b6d10cfc284c9bf36bd885e8d44c46f688ce50aa91b5edd90181dea687", size = 452255, upload-time = "2026-05-19T10:07:42.62Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/d5/60f972840f79c5e7544fce567c56f1e4e50468f996baba3e78d823dd62a6/jiter-0.15.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ab068bce62a45aa3e7367eceaffb5dde60b7eb853be8dece45132e3d0ff4879", size = 373559, upload-time = "2026-05-19T10:07:44.201Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/cf/d46ef1234ba335aabc2f013210db8e0821a22f5e644a2e9449df199ecc23/jiter-0.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa248c9eb220197d363f688818dac2fd4b2f0cd7d843ca7105d652034823427d", size = 346055, upload-time = "2026-05-19T10:07:46.005Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/63/4d2749d8d54d230bad9b3a6b0d00cc28c6ff6b2fdffc26a8ccf76cc5a974/jiter-0.15.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2a77aadd57cac1682e4401a72724d2796d89a4ba129b1a5812aa94ee480826eb", size = 351406, upload-time = "2026-05-19T10:07:47.855Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b9/9965b990035d8773328e0a8c8b457a87bf2b19f6c4126d9d99296be5d16a/jiter-0.15.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2ae901f3a55bfafdde31d289590fa25e3245735a2b1e8c7cc15871710a002871", size = 389357, upload-time = "2026-05-19T10:07:49.665Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/55/9ddf903deda1413e87fed792f416b7123daee5b8efbad6a202a7421c36a5/jiter-0.15.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:f0b271b462769543716f92d3a4f90527df6ef5ed05ee95ec4137f513e21e1b77", size = 517263, upload-time = "2026-05-19T10:07:51.537Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/76/a0c40ad064d3a20a4fde231e35d56e9a01ce82164278180e82d5daf85469/jiter-0.15.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2fb6a5d26af81fc0f00f9360a891e05cf755e149bba391c4d563adc54812973d", size = 548646, upload-time = "2026-05-19T10:07:53.196Z" },
+    { url = "https://files.pythonhosted.org/packages/23/4f/eca9b954942916ba2f453891b8593ab444cd872396fe66a3936616f236f3/jiter-0.15.0-cp312-cp312-win32.whl", hash = "sha256:c2f6bb8b5216ab9e7873bc08b5d7bef2b8abbb578a3069bf1cd14a45d71d771d", size = 206427, upload-time = "2026-05-19T10:07:55.307Z" },
+    { url = "https://files.pythonhosted.org/packages/95/bf/8ead82a87495149542748e828d153fd232a512a22c83b02c4815c1a9c7d8/jiter-0.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:40b2c7e92c44a84d748d21706c68dc6ff8161d80b59c99d774721a0d2317d7c7", size = 197300, upload-time = "2026-05-19T10:07:56.651Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/e4/9b8a78fb2d894471bc344e37f1949bdd784bd914d031dba0ba3a40c71dd7/jiter-0.15.0-cp312-cp312-win_arm64.whl", hash = "sha256:cc0bc345cf2df9d1c00ac443f50d543c1ccfa8b0422cb85b1ab70d681c0b255b", size = 192702, upload-time = "2026-05-19T10:07:58.307Z" },
+    { url = "https://files.pythonhosted.org/packages/65/43/1fc62172aa98b50a7de9a25554060db510f85c89cfbed0dfe13e1907a139/jiter-0.15.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:411fa4dfa5a7ae3d11491027ffb9beadec3996010a986862db70d91abba1c750", size = 305585, upload-time = "2026-05-19T10:09:35.995Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/c4/dd58fcd9e2df83666e5c1c1347bef58ce919cd8efc3ffa38aeea62ce493b/jiter-0.15.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:2b0074e2f56eb2dacca1689760fd2852a068f85a0547a157b82cb4cafeb6768b", size = 306936, upload-time = "2026-05-19T10:09:37.435Z" },
+    { url = "https://files.pythonhosted.org/packages/39/86/b695e16f1180c07f43ea98e73ecd21cf63fa2e1b0c1103739013784d11ae/jiter-0.15.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:913d02d29c9606643418d9ccfc3b72492ab25a6bf7889934e09a3490f8d3438b", size = 342453, upload-time = "2026-05-19T10:09:39.294Z" },
+    { url = "https://files.pythonhosted.org/packages/34/56/55d76614af37fe3f22a3347d1e410d2a15da581997cb2da499a625000bb5/jiter-0.15.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b15d3ec9b0449c40e85319bdb4caa8b77ab526e74f5532ed94bec15e2f66822c", size = 345606, upload-time = "2026-05-19T10:09:40.727Z" },
+    { url = "https://files.pythonhosted.org/packages/73/38/505941b2b092fd5bbbd60a52a880db1173f1690ae6751bed3af1c9ddcb4e/jiter-0.15.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:631f13a3d04e97d4e083993b10f4b99530e3a10d953e2eb5e196b7dc7f812ce0", size = 303769, upload-time = "2026-05-19T10:09:42.203Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/95/a06692b29e77473f286e1ec1f426d3ca44d7b5843be8ad21d7a5f3fcdcc0/jiter-0.15.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:b6c0ffae686c39bf3737be60793783267628783ea42545632c10b291105aee45", size = 305128, upload-time = "2026-05-19T10:09:43.657Z" },
+    { url = "https://files.pythonhosted.org/packages/23/85/7270d7ad41d6061a25b950c6bf91d638bd9aacb113200a8c8d57a055fd67/jiter-0.15.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d54fb5b31dea401a41af3f8a7d2512e9b6a6a005491e6166c7e4ffab9639a9c", size = 340459, upload-time = "2026-05-19T10:09:45.452Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/8d/302cb2057b7513327b4d575cff6b1d066ee6431a5357fc3f8867cd684406/jiter-0.15.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54d5d6090cdc1b7c9e780dfb04949a990adb1e301a2fc0bbcee7de4638d33f9a", size = 344469, upload-time = "2026-05-19T10:09:46.864Z" },
 ]
 
 [[package]]
 name = "jmespath"
-version = "1.0.1"
+version = "1.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843, upload-time = "2022-06-17T18:00:12.224Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload-time = "2022-06-17T18:00:10.251Z" },
+    { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },
 ]
 
 [[package]]
@@ -1278,85 +1276,77 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/54/3b/ad1cb22e75c963b1f07c8a2329bf47227ce7e4361df5eb2fb101b2ce33ef/joserfc-1.6.5-py3-none-any.whl", hash = "sha256:e9878a0f8243fe7b95e11fdda81374ca9f7a689e302751579d3dfdeec559675e", size = 70464, upload-time = "2026-05-06T04:58:11.668Z" },
 ]
 
-[[package]]
-name = "jsonschema"
-version = "4.25.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "attrs" },
-    { name = "jsonschema-specifications" },
-    { name = "referencing" },
-    { name = "rpds-py" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload-time = "2025-08-18T17:03:48.373Z" },
-]
-
-[[package]]
-name = "jsonschema-specifications"
-version = "2025.9.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "referencing" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
-]
-
 [[package]]
 name = "jwcrypto"
-version = "1.5.6"
+version = "1.5.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cryptography" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e1/db/870e5d5fb311b0bcf049630b5ba3abca2d339fd5e13ba175b4c13b456d08/jwcrypto-1.5.6.tar.gz", hash = "sha256:771a87762a0c081ae6166958a954f80848820b2ab066937dc8b8379d65b1b039", size = 87168, upload-time = "2024-03-06T19:58:31.831Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/90/f065668004d22715c1940d6e88e4c3afc8ee16d5664e4478d2c8fd23a250/jwcrypto-1.5.7.tar.gz", hash = "sha256:70204d7cca406eda8c82352e3c41ba2d946610dafd19e54403f0a1f4f18633c6", size = 89535, upload-time = "2026-04-07T00:35:36.116Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cd/58/4a1880ea64032185e9ae9f63940c9327c6952d5584ea544a8f66972f2fda/jwcrypto-1.5.6-py3-none-any.whl", hash = "sha256:150d2b0ebbdb8f40b77f543fb44ffd2baeff48788be71f67f03566692fd55789", size = 92520, upload-time = "2024-03-06T19:58:29.765Z" },
+    { url = "https://files.pythonhosted.org/packages/72/24/fb7da4d6613de7001feaf540d4b5969c6b5a1c42839043b0196cb13aa057/jwcrypto-1.5.7-py3-none-any.whl", hash = "sha256:729463fefe28b6de5cf1ebfda3e94f1a1b41d2799148ef98a01cb9678ebe2bb0", size = 94799, upload-time = "2026-04-07T00:35:35.085Z" },
 ]
 
 [[package]]
 name = "langcodes"
-version = "3.5.0"
+version = "3.5.1"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "language-data" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3a/7a/5a97e327063409a5caa21541e6d08ae4a0f2da328447e9f2c7b39e179226/langcodes-3.5.0.tar.gz", hash = "sha256:1eef8168d07e51e131a2497ffecad4b663f6208e7c3ae3b8dc15c51734a6f801", size = 191030, upload-time = "2024-11-19T10:23:45.546Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/75/f9edc5d72945019312f359e69ded9f82392a81d49c5051ed3209b100c0d2/langcodes-3.5.1.tar.gz", hash = "sha256:40bff315e01b01d11c2ae3928dd4f5cbd74dd38f9bd912c12b9a3606c143f731", size = 191084, upload-time = "2025-12-02T16:22:01.627Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/6b/068c2ea7a712bf805c62445bd9e9c06d7340358ef2824150eceac027444b/langcodes-3.5.0-py3-none-any.whl", hash = "sha256:853c69d1a35e0e13da2f427bb68fb2fa4a8f4fb899e0c62ad8df8d073dcfed33", size = 182974, upload-time = "2024-11-19T10:23:42.824Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/c1/d10b371bcba7abce05e2b33910e39c33cfa496a53f13640b7b8e10bb4d2b/langcodes-3.5.1-py3-none-any.whl", hash = "sha256:b6a9c25c603804e2d169165091d0cdb23934610524a21d226e4f463e8e958a72", size = 183050, upload-time = "2025-12-02T16:21:59.954Z" },
 ]
 
 [[package]]
-name = "language-data"
-version = "1.3.0"
+name = "librt"
+version = "0.11.0"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "marisa-trie" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/dd/ce/3f144716a9f2cbf42aa86ebc8b085a184be25c80aa453eea17c294d239c1/language_data-1.3.0.tar.gz", hash = "sha256:7600ef8aa39555145d06c89f0c324bf7dab834ea0b0a439d8243762e3ebad7ec", size = 5129310, upload-time = "2024-11-19T10:21:37.912Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5d/e9/5a5ffd9b286db82be70d677d0a91e4d58f7912bb8dd026ddeeb4abe70679/language_data-1.3.0-py3-none-any.whl", hash = "sha256:e2ee943551b5ae5f89cd0e801d1fc3835bb0ef5b7e9c3a4e8e17b2b214548fbf", size = 5385760, upload-time = "2024-11-19T10:21:36.005Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/40/08/9e7f6b5d2b5bed6ad055cdd5925f192bb403a51280f86b56554d9d0699a2/librt-0.11.0.tar.gz", hash = "sha256:075dc3ef4458a278e0195cbf6ac9d38808d9b906c5a6c7f7f79c3888276a3fb1", size = 200139, upload-time = "2026-05-10T18:17:25.138Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fe/87/2bf31fe17587b29e3f93ec31421e2b1e1c3e349b8bf6c7c313dbad1d5340/librt-0.11.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:93d95bd45b7d58343d8b90d904450a545144eec19a002511163426f8ab1fae29", size = 141092, upload-time = "2026-05-10T18:15:34.795Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/08/5c5bf772920b7ebac6e32bc91a643e0ab3870199c0b542356d3baa83970a/librt-0.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ee278c769a713638cdacd4c0436d72156e75df3ebc0166ab2b9dc43acc386c9", size = 142035, upload-time = "2026-05-10T18:15:36.242Z" },
+    { url = "https://files.pythonhosted.org/packages/06/20/662a03d254e5b000d838e8b345d83303ddb768c080fd488e40634c0fa66b/librt-0.11.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f230cb1cbc9faaa616f9a678f530ebcf186e414b6bcbd88b960e4ba1b92428d5", size = 475022, upload-time = "2026-05-10T18:15:37.56Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f3/aa81523e45184c6ec23dc7f63263362ec55f80a09d424c012359ecbe7e35/librt-0.11.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5d63c855d86938d9de93e265c9bd8c705b51ec494de5738340ee93767a686e4b", size = 467273, upload-time = "2026-05-10T18:15:39.182Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/6f/59c74b560ca8853834d5501d589c8a2519f4184f273a085ffd0f37a1cc47/librt-0.11.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:993f028be9e96a08d31df3479ac80d99be374d17f3b78e4796b3fd3c913d4e89", size = 497083, upload-time = "2026-05-10T18:15:40.634Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/7b/5aa4d2c9600a719401160bf7055417df0b2a47439b9d88286ce45e56b65f/librt-0.11.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:258d73a0aa66a055e65b2e4d1b8cdb23b9d132c5bb915d9547d804fcaed116cc", size = 489139, upload-time = "2026-05-10T18:15:41.934Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/31/9143803d7da6856a69153785768c4936864430eec0fd9461c3ea527d9922/librt-0.11.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0827efe7854718f04aaddf6496e96960a956e676fe1d0f04eb41511fd8ad06d5", size = 508442, upload-time = "2026-05-10T18:15:43.206Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/5a/bce08184488426bda4ccc2c4964ac048c8f68ae89bd7120082eef4233cfd/librt-0.11.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7753e57d6e12d019c0d8786f1c09c709f4c3fcc57c3887b24e36e6c06ec938b7", size = 514230, upload-time = "2026-05-10T18:15:44.761Z" },
+    { url = "https://files.pythonhosted.org/packages/89/8c/bb5e213d254b7505a0e658da199d8ab719086632ce09eef311ab27976523/librt-0.11.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:11bd19822431cc21af9f27374e7ae2e58103c7d98bda823536a6c47f6bb2bb3d", size = 494231, upload-time = "2026-05-10T18:15:46.308Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/fb/541cdad5b1ab1300398c74c4c9a497b88e5074c21b1244c8f49731d3a284/librt-0.11.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:22bdf239b219d3993761a148ffa134b19e52e9989c84f845d5d7b71d70a17412", size = 537585, upload-time = "2026-05-10T18:15:47.629Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/f2/464bb69295c320cb06bddb4f14a4ec67934ee14b2bffb12b19fb7ab287ba/librt-0.11.0-cp311-cp311-win32.whl", hash = "sha256:46c60b61e308eb535fbd6fa622b1ee1bb2815691c1ad9c98bf7b84952ec3bc8d", size = 100509, upload-time = "2026-05-10T18:15:49.157Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/e7/a17ee1788f9e4fbf548c19f4afa07c92089b9e24fef6cb2410863781ef4c/librt-0.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:902e546ff044f579ff1c953ff5fce97b636fe9e3943996b2177710c6ef076f73", size = 118628, upload-time = "2026-05-10T18:15:50.345Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/c7/6c766214f9f9903bcfcfbef97d807af8d8f5aa3502d247858ab17582d212/librt-0.11.0-cp311-cp311-win_arm64.whl", hash = "sha256:65ac3bc20f78aa0ee5ae84baa68917f89fef4af63e941084dd019a0d0e749f0c", size = 103122, upload-time = "2026-05-10T18:15:52.068Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/d0/07c77e067f0838949b43bd89232c29d72efebb9d2801a9750184eb706b71/librt-0.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b87504f1690a23b9a2cca841191a04f83895d4fc2dd04df91d82b1a04ca2ad46", size = 144147, upload-time = "2026-05-10T18:15:53.227Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/24/8493538fa4f62f982686398a5b8f68008138a75086abdea19ade64bf4255/librt-0.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40071fc5fe0ce8daa6de616702314a01e1250711682b0523d6ab8d4525910cb3", size = 143614, upload-time = "2026-05-10T18:15:54.657Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/1e/f8bad050810d9171f34a1648ed910e56814c2ba61639f2bd53c6377ae24b/librt-0.11.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:137e79445c896a0ea7b265f52d23954e05b64222ee1af69e2cb34219067cbb67", size = 485538, upload-time = "2026-05-10T18:15:56.117Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/fe/3594ebfbaf03084ba4b120c9ba5c3183fd938a48725e9bbe6ff0a5159ad8/librt-0.11.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:cca6644054e78746d8d4ef238681f9c34ff8b584fe6b988ecebb8db3b15e622a", size = 479623, upload-time = "2026-05-10T18:15:57.544Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/da/5d1876984b3746c85dbd219dbfcb73c85f54ee263fd32e5b2a632ec14571/librt-0.11.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5b0eea49f5562861ee8d757a32ef7d559c1d35be2aaaa1ec28941d74c9ffc8a", size = 513082, upload-time = "2026-05-10T18:15:58.805Z" },
+    { url = "https://files.pythonhosted.org/packages/19/6e/55bdf5d5ca00c3e18430690bf2c953d8d3ffd3c337418173d33dec985dc9/librt-0.11.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0d1029d7e1ae1a7e647ed6fb5df8c4ce2dffefb7a9f5fd1376a4554d96dac09f", size = 508105, upload-time = "2026-05-10T18:16:00.2Z" },
+    { url = "https://files.pythonhosted.org/packages/07/10/f1f23a7c595ee90ece4d35c851e5d104b1311a887ed1b4ac4c35bbd13da8/librt-0.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bc3ce6b33c5828d9e80592011a5c584cb2ce86edbc4088405f70da47dc1d1b3b", size = 522268, upload-time = "2026-05-10T18:16:01.708Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/02/5720f5697a7f54b78b3aefbe20df3a48cedcff1276618c4aa481177942ed/librt-0.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:936c5995f3514a42111f20099397d8177c79b4d7e70961e396c6f5a0a3566766", size = 527348, upload-time = "2026-05-10T18:16:03.496Z" },
+    { url = "https://files.pythonhosted.org/packages/50/db/b4a47c6f91db4ff76348a0b3dd0cc65e090a078b765a810a62ff9434c3d3/librt-0.11.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9bc0ca6ad9381cbe8e4aa6e5726e4c80c78115a6e9723c599ed1d73e092bc49d", size = 516294, upload-time = "2026-05-10T18:16:05.173Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/58/9384b2f4eb1ed1d273d40948a7c5c4b2360213b402ef3be4641c06299f9c/librt-0.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:070aa8c26c0a74774317a72df8851facc7f0f012a5b406557ac56992d92e1ec8", size = 553608, upload-time = "2026-05-10T18:16:06.839Z" },
+    { url = "https://files.pythonhosted.org/packages/21/7b/5aa8848a7c6a9278c79375146da1812e695754ceec5f005e6043461a7315/librt-0.11.0-cp312-cp312-win32.whl", hash = "sha256:6bf14feb84b05ae945277395451998c89c54d0def4070eb5c08de544930b245a", size = 101879, upload-time = "2026-05-10T18:16:08.103Z" },
+    { url = "https://files.pythonhosted.org/packages/37/33/8a745436944947575b584231750a41417de1a38cf6a2e9251d1065651c09/librt-0.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:75672f0bc524ede266287d532d7923dbce94c7514ad07627bac3d0c6d92cc4d9", size = 119831, upload-time = "2026-05-10T18:16:09.174Z" },
+    { url = "https://files.pythonhosted.org/packages/59/67/a6739ac96e28b7855808bdb0370e250606104a859750d209e5a0716fe7ab/librt-0.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:2f10cf143e4a9bb0f4f5af568a00df94a2d69ef41c2579584454bb0fe5cc642c", size = 103470, upload-time = "2026-05-10T18:16:10.369Z" },
 ]
 
 [[package]]
 name = "linkify-it-py"
-version = "2.0.3"
+version = "2.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "uc-micro-py" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946, upload-time = "2024-02-04T14:48:04.179Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/c9/06ea13676ef354f0af6169587ae292d3e2406e212876a413bf9eece4eb23/linkify_it_py-2.1.0.tar.gz", hash = "sha256:43360231720999c10e9328dc3691160e27a718e280673d444c38d7d3aaa3b98b", size = 29158, upload-time = "2026-03-01T07:48:47.683Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820, upload-time = "2024-02-04T14:48:02.496Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/de/88b3be5c31b22333b3ca2f6ff1de4e863d8fe45aaea7485f591970ec1d3e/linkify_it_py-2.1.0-py3-none-any.whl", hash = "sha256:0d252c1594ecba2ecedc444053db5d3a9b7ec1b0dd929c8f1d74dce89f86c05e", size = 19878, upload-time = "2026-03-01T07:48:46.098Z" },
 ]
 
 [[package]]
 name = "logfire"
-version = "4.11.0"
+version = "3.5.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "executing" },
@@ -1367,59 +1357,78 @@ dependencies = [
     { name = "rich" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7b/7d/7168f050e23c83731a458613d672cc54946848506be90784f95886dfb6e4/logfire-4.11.0.tar.gz", hash = "sha256:56a44e11f4670ba95c2da85e25d8ab6d3c3ab815bedb5845117fbc9a162d5126", size = 544803, upload-time = "2025-10-03T15:47:50.794Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b3/7a/e918a1f1ba62eaf1b20917a37b8fb820800e78a21eaf42677f925fb15f14/logfire-3.5.1.tar.gz", hash = "sha256:8ac97284af1e266257d640dcca584528ee015024e84f512ecef6e2cedd581f1d", size = 264880, upload-time = "2025-02-04T16:05:54.097Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/96/baaaf10240391bf36c699a2c20b9785a8ede228d75f6a31cb0e6d8da2032/logfire-4.11.0-py3-none-any.whl", hash = "sha256:b3dab5d4565a8682d42fed451fe349550ab67e69c7fc4f4eb9cbfdee1dfcc7e1", size = 226877, upload-time = "2025-10-03T15:47:47.014Z" },
-]
-
-[package.optional-dependencies]
-httpx = [
-    { name = "opentelemetry-instrumentation-httpx" },
+    { url = "https://files.pythonhosted.org/packages/78/13/8c181b24daaddcf7f259e63e914a1b19e645f06c7ea025e0bea0553c0f29/logfire-3.5.1-py3-none-any.whl", hash = "sha256:8821ef5c83e566354a63d35cff4486ae91103d86f1677fe61632178b40a3e081", size = 178547, upload-time = "2025-02-04T16:05:50.222Z" },
 ]
 
 [[package]]
 name = "logfire-api"
-version = "4.10.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/25/fb38c0e3f216ee72cda4d856147846f588a9ff9a863c2a981403916c3921/logfire_api-4.10.0.tar.gz", hash = "sha256:a9bf635a7c565c57f7c8145c0e7ac24ac4d34d0fb82774310d9b89d4c6968b6d", size = 55768, upload-time = "2025-09-24T17:57:18.735Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/22/e8/4355d4909eb1f07bba1ecf7a9b99be8bbc356db828e60b750e41dbb49dab/logfire_api-4.10.0-py3-none-any.whl", hash = "sha256:20819b2f3b43a53b66a500725553bdd52ed8c74f2147aa128c5ba5aa58668059", size = 92694, upload-time = "2025-09-24T17:57:15.686Z" },
-]
-
-[[package]]
-name = "marisa-trie"
-version = "1.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c5/e3/c9066e74076b90f9701ccd23d6a0b8c1d583feefdec576dc3e1bb093c50d/marisa_trie-1.3.1.tar.gz", hash = "sha256:97107fd12f30e4f8fea97790343a2d2d9a79d93697fe14e1b6f6363c984ff85b", size = 212454, upload-time = "2025-08-26T15:13:18.401Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/bf/2f1fe6c9fcd2b509c6dfaaf26e35128947d6d3718d0b39510903c55b7bed/marisa_trie-1.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5ef045f694ef66079b4e00c4c9063a00183d6af7d1ff643de6ea5c3b0d9af01b", size = 174027, upload-time = "2025-08-26T15:12:01.434Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/5a/de7936d58ed0de847180cee2b95143d420223c5ade0c093d55113f628237/marisa_trie-1.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cbd28f95d5f30d9a7af6130869568e75bfd7ef2e0adfb1480f1f44480f5d3603", size = 158478, upload-time = "2025-08-26T15:12:02.429Z" },
-    { url = "https://files.pythonhosted.org/packages/48/cc/80611aadefcd0bcf8cd1795cb4643bb27213319a221ba04fe071da0b75cd/marisa_trie-1.3.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b173ec46d521308f7c97d96d6e05cf2088e0548f82544ec9a8656af65593304d", size = 1257535, upload-time = "2025-08-26T15:12:04.271Z" },
-    { url = "https://files.pythonhosted.org/packages/36/89/c4eeefb956318047036e6bdc572b6112b2059d595e85961267a90aa40458/marisa_trie-1.3.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:954fef9185f8a79441b4e433695116636bf66402945cfee404f8983bafa59788", size = 1275566, upload-time = "2025-08-26T15:12:05.874Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/63/d775a2fdfc4b555120381cd2aa6dff1845576bc14fb13796ae1b1e8dbaf7/marisa_trie-1.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ca644534f15f85bba14c412afc17de07531e79a766ce85b8dbf3f8b6e7758f20", size = 2199831, upload-time = "2025-08-26T15:12:07.175Z" },
-    { url = "https://files.pythonhosted.org/packages/50/aa/e5053927dc3cac77acc9b27f6f87e75c880f5d3d5eac9111fe13b1d8bf6f/marisa_trie-1.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3834304fdeaa1c9b73596ad5a6c01a44fc19c13c115194704b85f7fbdf0a7b8e", size = 2283830, upload-time = "2025-08-26T15:12:08.319Z" },
-    { url = "https://files.pythonhosted.org/packages/71/3e/e314906d0de5b1a44780a23c79bb62a9aafd876e2a4e80fb34f58c721da4/marisa_trie-1.3.1-cp311-cp311-win32.whl", hash = "sha256:70b4c96f9119cfeb4dc6a0cf4afc9f92f0b002cde225bcd910915d976c78e66a", size = 117335, upload-time = "2025-08-26T15:12:09.776Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/2b/85623566621135de3d57497811f94679b4fb2a8f16148ef67133c2abab7a/marisa_trie-1.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:986eaf35a7f63c878280609ecd37edf8a074f7601c199acfec81d03f1ee9a39a", size = 143985, upload-time = "2025-08-26T15:12:10.988Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/40/ee7ea61b88d62d2189b5c4a27bc0fc8d9c32f8b8dc6daf1c93a7b7ad34ac/marisa_trie-1.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5b7c1e7fa6c3b855e8cfbabf38454d7decbaba1c567d0cd58880d033c6b363bd", size = 173454, upload-time = "2025-08-26T15:12:12.13Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/fc/58635811586898041004b2197a085253706ede211324a53ec01612a50e20/marisa_trie-1.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c12b44c190deb0d67655021da1f2d0a7d61a257bf844101cf982e68ed344f28d", size = 155305, upload-time = "2025-08-26T15:12:13.374Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/98/88ca0c98d37034a3237acaf461d210cbcfeb6687929e5ba0e354971fa3ed/marisa_trie-1.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9688c7b45f744366a4ef661e399f24636ebe440d315ab35d768676c59c613186", size = 1244834, upload-time = "2025-08-26T15:12:14.795Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/5f/93b3e3607ccd693a768eafee60829cd14ea1810b75aa48e8b20e27b332c4/marisa_trie-1.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99a00cab4cf9643a87977c87a5c8961aa44fff8d5dd46e00250135f686e7dedf", size = 1265148, upload-time = "2025-08-26T15:12:16.229Z" },
-    { url = "https://files.pythonhosted.org/packages/db/6e/051d7d25c7fb2b3df605c8bd782513ebbb33fddf3bae6cf46cf268cca89f/marisa_trie-1.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:83efc045fc58ca04c91a96c9b894d8a19ac6553677a76f96df01ff9f0405f53d", size = 2172726, upload-time = "2025-08-26T15:12:18.467Z" },
-    { url = "https://files.pythonhosted.org/packages/58/da/244d9d4e414ce6c73124cba4cc293dd140bf3b04ca18dec64c2775cca951/marisa_trie-1.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0b9816ab993001a7854b02a7daec228892f35bd5ab0ac493bacbd1b80baec9f1", size = 2256104, upload-time = "2025-08-26T15:12:20.168Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/f1/1a36ecd7da6668685a7753522af89a19928ffc80f1cc1dbc301af216f011/marisa_trie-1.3.1-cp312-cp312-win32.whl", hash = "sha256:c785fd6dae9daa6825734b7b494cdac972f958be1f9cb3fb1f32be8598d2b936", size = 115624, upload-time = "2025-08-26T15:12:21.233Z" },
-    { url = "https://files.pythonhosted.org/packages/35/b2/aabd1c9f1c102aa31d66633ed5328c447be166e0a703f9723e682478fd83/marisa_trie-1.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:9868b7a8e0f648d09ffe25ac29511e6e208cc5fb0d156c295385f9d5dc2a138e", size = 138562, upload-time = "2025-08-26T15:12:22.632Z" },
+version = "4.33.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/1a/c44eb3a02407aa739669822d19734e76e8751284b86cd99c73baca36998a/logfire_api-4.33.0.tar.gz", hash = "sha256:0a604f710e803db08a2ddc41e6152bf8d8a56b549f8856cbf82baa36bc7de2c9", size = 81483, upload-time = "2026-05-13T15:14:17.348Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/58/dc21672e0d5294668f4d35aaba4d839d031f096b4cf6802399c4b411b5fc/logfire_api-4.33.0-py3-none-any.whl", hash = "sha256:b992727bab71412b5a00f54453eec18e559232c83d7120cf5c6a9edd33fb0c4e", size = 128896, upload-time = "2026-05-13T15:14:14.322Z" },
+]
+
+[[package]]
+name = "lxml"
+version = "6.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/3b/aab6728cae887456f409b4d75e8a01856e4f04bd510de38052a47768b680/lxml-6.1.1.tar.gz", hash = "sha256:ba96ae44888e0185281e937633a743ea90d5a196c6000f82565ebb0580012d40", size = 4197430, upload-time = "2026-05-18T19:19:06.424Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/b0/83f481780d1548750b8ce2ec824073deef2f452d9cd1a6faff8507e3d16d/lxml-6.1.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:53b7d2b7a10b1c35c0a5e21e9224accf60c1bbfba523990732e521b2b73adef2", size = 8526461, upload-time = "2026-05-18T19:17:25.862Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/d5/30fa0f808002c7329397bfbb24e306789c0b29f04aa5842c07b174b4216f/lxml-6.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ff3f333630ab480244a1bff72043e511a91eb22e7595dead8653ee5612dd8f3d", size = 4595375, upload-time = "2026-05-18T19:17:34.555Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/d2/edb71cf0e561581a7c5eb2626244320eb04e9f8ce6d563184fd668b45073/lxml-6.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a4bbea04c97f6d78a48e3fbc1cb9116d2780b1b39e03a23f6eb9b603fd61f510", size = 4923654, upload-time = "2026-05-18T19:17:42.917Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/77/1bc7eeb0de4577d783fb625aa092cc9357883bba35845a3666bf1259f3dc/lxml-6.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:db1d75f6617a49c1c01bc7023713e0ff59ab32c9579ae62a7674c0e34f3b0b0a", size = 5067921, upload-time = "2026-05-18T19:17:49.175Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/3c/c0690d74bd2bc17bc03b5b0d093569ead597dd0bfa088bf99eef8c24e19c/lxml-6.1.1-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a12689be69a28ddaa0ab99a5a1137da2afd5f8f16df7b5680b66f616d3eda1d", size = 5002456, upload-time = "2026-05-18T19:17:59.715Z" },
+    { url = "https://files.pythonhosted.org/packages/66/8d/d1b3271af0c0f1e27e8472a849e4d2c65bc7766884b9ad2da9e76e145c88/lxml-6.1.1-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18b73c339ae29b90fd2d06e58ebd555a751bde9cd6bbd36cc0281b9a2c94e9d8", size = 5202776, upload-time = "2026-05-18T19:18:08.924Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/45/689824ffb237fd10125ad273f32b28ff04dc6203c2822c85ff65a93df65e/lxml-6.1.1-cp311-cp311-manylinux_2_28_i686.whl", hash = "sha256:752d3bbfe874715ccd0aec7f88d7fc623c0f1fd7aa7b3238a084e017bad2a009", size = 5329945, upload-time = "2026-05-18T19:18:13.673Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/c0/ef73af53767e958fd87d437c170f272e2f6e6c0f854939f133a895f1e711/lxml-6.1.1-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:6b1761fbf9ec984e2e9d9c589ef5f5fd684b7c19f92aadd567a26c5224958db6", size = 4659237, upload-time = "2026-05-18T19:18:18.657Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/5e/e1158e40397585e91cb0472374a1f63d0926a1ddeaa92f13d1a1ffe306d5/lxml-6.1.1-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d680fbcb768404c601ecb43519ecd8461f6954cb11c06a78962f666832ccfca8", size = 5265904, upload-time = "2026-05-18T19:18:24.883Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/16/8687e5d1400ed1c0bc41dace232ebb7553952b618ea1f2e5fb6e2cfbbe23/lxml-6.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:162af1091cd785f2f27e62d3547ae9bc58ec5c86dd314d67021fd02463708d83", size = 5045225, upload-time = "2026-05-18T19:17:20.073Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/18/d877bd1ae2e5ffdfd4836565aba350db31feb2f2656d6ce70316ed66a05e/lxml-6.1.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:e9308ff8241c532df3f3e570f9a5aeed6c853f888512ba4b75638d7c11c95ef6", size = 4712721, upload-time = "2026-05-18T19:17:40.512Z" },
+    { url = "https://files.pythonhosted.org/packages/44/4d/1f44fd1d770b10dacbf6b5c6e520f4d6e0708744930f719dc04e67cab981/lxml-6.1.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5f6994074ebae6ffb04447268e37dc16edc304f9859cf91acb86e0af6c1b395c", size = 5252549, upload-time = "2026-05-18T19:17:51.236Z" },
+    { url = "https://files.pythonhosted.org/packages/64/5d/1d66b84f850089254c230ef6ea6b267a5a54e2e179a5d960036a05d501d7/lxml-6.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:80c2dfadb855da477cf73373ad29a333535dedb9b12bad02c9814c8e2b43bf08", size = 5226877, upload-time = "2026-05-18T19:18:00.875Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/00/84c4b5302d42a2d0184f38d538c8a197f33b52a50bd4f7bcfe990bce3036/lxml-6.1.1-cp311-cp311-win32.whl", hash = "sha256:30a89d3ac8faec007453fb541f3f46807eeec88edd5826f6e3fe001752a2c621", size = 3594072, upload-time = "2026-05-18T19:17:12.714Z" },
+    { url = "https://files.pythonhosted.org/packages/61/9d/2e2f7d876349f45e0f3e29f72da311668853d59b58d473a2dea4f0160135/lxml-6.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:abbefa31eee84842140f67acef1c828e28bba8bbf0c3bc6e5492a9af88152c28", size = 4025469, upload-time = "2026-05-18T19:17:50.566Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/d5/570e6390e4110331e6208b2ba83d1482cc9146808ee118b22824a34c1070/lxml-6.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:dcb292aa7fe485ceff7af4f92e46c5af397daec5dff64871a528f0fc47a3cc5b", size = 3667640, upload-time = "2026-05-19T19:22:48.293Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/6e/c4add832b6fc1e887125b96f880d7b9b70aae5248718e046b1704bcac4b9/lxml-6.1.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:104c09bda8d2a562824c0e319d0768ce26a779b7601e0931d33b09b53c392ef7", size = 8570821, upload-time = "2026-05-18T19:17:42.068Z" },
+    { url = "https://files.pythonhosted.org/packages/22/00/ff3009c88e65de8011630acf8ab5a09cb2becd2aaf47fba2f3449f6224e9/lxml-6.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:25c6997a9a534e016695a0ba06b2f07945de682731ff01065b6d5a4474179da1", size = 4624252, upload-time = "2026-05-18T19:17:47.897Z" },
+    { url = "https://files.pythonhosted.org/packages/42/95/bb63f0fd62e554fe078e1fb3c8fe9083c14ddc7ad7fa178d10e57e071ac7/lxml-6.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c921ba5c51e4e9f63b8b00267d06566e1f63407408a0496da2d1d0bfc819c7fc", size = 4930746, upload-time = "2026-05-18T19:18:29.637Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/99/0013e8d9b5960f4f041cf0b73e2f80c23eb5205b1f7bfb20203243651359/lxml-6.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:54a7f95e4de5fb94e2f9f4b9055c6ba33bf3d628fd77a1d647c5923caa2cdcdc", size = 5093723, upload-time = "2026-05-18T19:18:34.168Z" },
+    { url = "https://files.pythonhosted.org/packages/29/91/317b332636bfc7bddcff828d41b3307f50043f4b237e40849c333d80fa1a/lxml-6.1.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f2ec43df44b1f76249ee0a615334f9b5b060e1c8bd90e706dad2d14d02f383", size = 5005557, upload-time = "2026-05-18T19:18:39.798Z" },
+    { url = "https://files.pythonhosted.org/packages/42/2f/cc9bf06afe70f9c9093ae60855d9759da9db601ec4080f7473319666ffd7/lxml-6.1.1-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:70ef8a7e102a1508f8121aae5b0867abd663f72c14f0a9c937e6554cb4587b7b", size = 5631036, upload-time = "2026-05-18T19:18:44.858Z" },
+    { url = "https://files.pythonhosted.org/packages/08/f6/af32e23e563971ffb0fb86be52bc5be5c2c118858ffc119bf6a9039b173d/lxml-6.1.1-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ebe6af670449830d6d9b752c256a983291c766a1365ba5d5460048f9e33a7818", size = 5240367, upload-time = "2026-05-18T19:18:49.217Z" },
+    { url = "https://files.pythonhosted.org/packages/78/83/8555d40948b09ce86f1bd0c68a7ac31d07b1929f92cc1b074006c97ef2d2/lxml-6.1.1-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:27acc820660aaffa4f7c087f29120e12980f7779d56d8492d263170111284740", size = 5350171, upload-time = "2026-05-18T19:18:52.779Z" },
+    { url = "https://files.pythonhosted.org/packages/63/75/5d92da93729b7bad783689e6496049fa40927b45bec7bf183c981de3ca70/lxml-6.1.1-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:1db753c9115ec7100d073b744d17e25e88a8f90f5c39b2f5dd878149af59671f", size = 4694874, upload-time = "2026-05-18T19:18:55.139Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/b5/3aad415a9a25b822e783f15deeb4dffccf5113030f1afa2222dd929313d9/lxml-6.1.1-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c4f469aebd783bb741c2ecb2a681008fd26bfe5c16a9a72ed5467f834e810df2", size = 5244492, upload-time = "2026-05-18T19:19:01.28Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/a1/5fcf7eb9904b80086aa47dcf0027de07b1bb990afad2e6823144c368ae04/lxml-6.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:766b010012d59470072c1816b5b6c69f1d243e5db36ea5968e94accf430a4635", size = 5048232, upload-time = "2026-05-18T19:18:12.67Z" },
+    { url = "https://files.pythonhosted.org/packages/77/74/1f601b63c7a69fcdf10fa9b148c81da8442204194f6c55509cc485c786b9/lxml-6.1.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b8d812c6011c08b8111a15e54dd990b8923692d80adf35488bee34026c35accf", size = 4777023, upload-time = "2026-05-18T19:18:15.928Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/b9/7a78f51aec95b1bf780d78e12705a9f6533284f8693dc5c0e6724fa53d3f/lxml-6.1.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:fe0306bd29505a9177aac19f1877174b0e7422c222a59f70b2cd41633448c3dc", size = 5645773, upload-time = "2026-05-18T19:18:23.223Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/6e/98a7b7ad54e4e74fa1f20fff776913980619d0ebe5558232d7da6580bdd8/lxml-6.1.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:5ba186ad207446c65d3bb3d3e0412b032b1d9f595e59861e2354798c5703d955", size = 5233088, upload-time = "2026-05-18T19:18:31.433Z" },
+    { url = "https://files.pythonhosted.org/packages/65/d1/bc0ed2427bf609f2ee10da303a6a226f9c8bce94f945dc29a32ce55de6e4/lxml-6.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aa366a1e55b8ebfe8ca8ddc3cfe75c8ebade181aeb0f661d0cb05986b647f72a", size = 5260995, upload-time = "2026-05-18T19:18:37.091Z" },
+    { url = "https://files.pythonhosted.org/packages/69/8b/6772e1a4b513fc50a8d931f19edde0e13ae6918510a1e13ff67864f3e5ed/lxml-6.1.1-cp312-cp312-win32.whl", hash = "sha256:126c93f7f56f0eda92f6d8c619edc463a4f23d9252f1c9d0405a76f25fa9f11a", size = 3596382, upload-time = "2026-05-18T19:17:18.37Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/89/45198e9624762af2dfd2cb8782598477ceb29f6e59caab560388ae1f4ec1/lxml-6.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:26e6eda8d38c1fcab1090dd196ee87cbd13788e531937610e2589085de074e77", size = 3997255, upload-time = "2026-05-18T19:17:56.781Z" },
+    { url = "https://files.pythonhosted.org/packages/90/a9/7a54b6834088d9ae528a7b780584ba6a39a9457b0ac330479f20ffbc9449/lxml-6.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:6540377fbd53fe1b629172288c464fb18db11ce1fa7dc15891da10aa9dcc3e7f", size = 3659610, upload-time = "2026-05-19T19:22:50.843Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/32/86a3f0f724a3a402d4627937a7fc27b160e45e7012b4adf47f6e1e844511/lxml-6.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:31033dc34636ea6b7d5cc11b1ddbda78a14de858ba9d3e1ed4b69a3085bc521e", size = 3930127, upload-time = "2026-05-18T19:19:02.27Z" },
+    { url = "https://files.pythonhosted.org/packages/40/44/d832e82af08723761556d004b1d04d281c09f9a8cecd7d3148548c9941a3/lxml-6.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3893c14c4b6ac5b2d54ba8cf03e99fe5104e592de491f19bd6b82756c09f8004", size = 4210769, upload-time = "2026-05-18T19:20:41.427Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/39/0dc5949f759ed7d951e0bb8c2f2d9d7aca1908d22352fa84a8afd2ea54af/lxml-6.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c07da4cebf6889f03ebac8d238f62318e29f495de0aa18a51ea14e61ae907e2e", size = 4318163, upload-time = "2026-05-18T19:20:44.702Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/fb/8ab3845fe046ba4cbf74536bcf6801a774b7caf4350de1c5d37f1f0a9e90/lxml-6.1.1-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f6f0ce10945fab9c4c06ce14e22af9059d1a87493a9af4501a5b0b9187e21cf2", size = 4250945, upload-time = "2026-05-18T19:20:47.385Z" },
+    { url = "https://files.pythonhosted.org/packages/68/1b/7553ab136894374ffae8851ec06f98f511cd8e66246e41b6be059d0a7289/lxml-6.1.1-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f8844cd288697c6425c9beba919302241e3278871dc6519515e72b04e987abcf", size = 4401664, upload-time = "2026-05-18T19:20:50.489Z" },
+    { url = "https://files.pythonhosted.org/packages/db/a4/441aee36c6f6b249823d20fd91f9be9ab89d7c5a8ae542a4a4ca6d342d56/lxml-6.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:ed21202aec73cda4d55d1ce57b389aadb90ffb044e6cd1080b8347efe1b1ec84", size = 3508989, upload-time = "2026-05-18T19:18:38.158Z" },
 ]
 
 [[package]]
 name = "markdown-it-py"
-version = "4.0.0"
+version = "4.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "mdurl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
 ]
 
 [package.optional-dependencies]
@@ -1457,28 +1466,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
 ]
 
-[[package]]
-name = "mcp"
-version = "1.16.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "httpx" },
-    { name = "httpx-sse" },
-    { name = "jsonschema" },
-    { name = "pydantic" },
-    { name = "pydantic-settings" },
-    { name = "python-multipart" },
-    { name = "pywin32", marker = "sys_platform == 'win32'" },
-    { name = "sse-starlette" },
-    { name = "starlette" },
-    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3d/a1/b1f328da3b153683d2ec34f849b4b6eac2790fb240e3aef06ff2fab3df9d/mcp-1.16.0.tar.gz", hash = "sha256:39b8ca25460c578ee2cdad33feeea122694cfdf73eef58bee76c42f6ef0589df", size = 472918, upload-time = "2025-10-02T16:58:20.631Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c9/0e/7cebc88e17daf94ebe28c95633af595ccb2864dc2ee7abd75542d98495cc/mcp-1.16.0-py3-none-any.whl", hash = "sha256:ec917be9a5d31b09ba331e1768aa576e0af45470d657a0319996a20a57d7d633", size = 167266, upload-time = "2025-10-02T16:58:19.039Z" },
-]
-
 [[package]]
 name = "mdformat"
 version = "1.0.0"
@@ -1508,14 +1495,14 @@ wheels = [
 
 [[package]]
 name = "mdit-py-plugins"
-version = "0.5.0"
+version = "0.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown-it-py" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/59/fc/f8d0863f8862f25602c0404d75568e89fb6b4109804645e5cdfb1be5cf56/mdit_py_plugins-0.6.1.tar.gz", hash = "sha256:a2bca0f039f39dbd35fb74ae1b5f998608c437463371f0ff7f49a19a17a114d0", size = 56114, upload-time = "2026-05-13T09:03:38.91Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/69/6da5581c6a7fede7dc261bf4e67d6adca4196f176b43288b55b3db395b6e/mdit_py_plugins-0.6.1-py3-none-any.whl", hash = "sha256:214c82fb2ac524472ab6a5bcab1de80f73b50443e187f401bfd77efbc7c6481d", size = 66663, upload-time = "2026-05-13T09:03:37.76Z" },
 ]
 
 [[package]]
@@ -1527,124 +1514,112 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
 ]
 
-[[package]]
-name = "mistralai"
-version = "1.9.11"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "eval-type-backport" },
-    { name = "httpx" },
-    { name = "invoke" },
-    { name = "pydantic" },
-    { name = "python-dateutil" },
-    { name = "pyyaml" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5a/8d/d8b7af67a966b6f227024e1cb7287fc19901a434f87a5a391dcfe635d338/mistralai-1.9.11.tar.gz", hash = "sha256:3df9e403c31a756ec79e78df25ee73cea3eb15f86693773e16b16adaf59c9b8a", size = 208051, upload-time = "2025-10-02T15:53:40.473Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/76/4ce12563aea5a76016f8643eff30ab731e6656c845e9e4d090ef10c7b925/mistralai-1.9.11-py3-none-any.whl", hash = "sha256:7a3dc2b8ef3fceaa3582220234261b5c4e3e03a972563b07afa150e44a25a6d3", size = 442796, upload-time = "2025-10-02T15:53:39.134Z" },
-]
-
 [[package]]
 name = "mistune"
-version = "3.2.0"
+version = "3.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9d/55/d01f0c4b45ade6536c51170b9043db8b2ec6ddf4a35c7ea3f5f559ac935b/mistune-3.2.0.tar.gz", hash = "sha256:708487c8a8cdd99c9d90eb3ed4c3ed961246ff78ac82f03418f5183ab70e398a", size = 95467, upload-time = "2025-12-23T11:36:34.994Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/84/620cc3f7e3adf6f5067e10f4dbae71295d8f9e16d5d3f9ef97c40f2f592c/mistune-3.2.1.tar.gz", hash = "sha256:7c8e5501d38bac1582e067e46c8343f17d57ea1aaa735823f3aba1fd59c88a28", size = 98003, upload-time = "2026-05-03T14:33:22.312Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9b/f7/4a5e785ec9fbd65146a27b6b70b6cdc161a66f2024e4b04ac06a67f5578b/mistune-3.2.0-py3-none-any.whl", hash = "sha256:febdc629a3c78616b94393c6580551e0e34cc289987ec6c35ed3f4be42d0eee1", size = 53598, upload-time = "2025-12-23T11:36:33.211Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/7f/a946aa4f8752b37102b41e64dca18a1976ac705c3a0d1dfe74d820a02552/mistune-3.2.1-py3-none-any.whl", hash = "sha256:78cdb0ba5e938053ccf63651b352508d2efa9411dc8810bfb05f2dc5140c0048", size = 53749, upload-time = "2026-05-03T14:33:20.551Z" },
 ]
 
 [[package]]
 name = "multidict"
-version = "6.6.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/69/7f/0652e6ed47ab288e3756ea9c0df8b14950781184d4bd7883f4d87dd41245/multidict-6.6.4.tar.gz", hash = "sha256:d2d4e4787672911b48350df02ed3fa3fffdc2f2e8ca06dd6afdf34189b76a9dd", size = 101843, upload-time = "2025-08-11T12:08:48.217Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6b/7f/90a7f01e2d005d6653c689039977f6856718c75c5579445effb7e60923d1/multidict-6.6.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c7a0e9b561e6460484318a7612e725df1145d46b0ef57c6b9866441bf6e27e0c", size = 76472, upload-time = "2025-08-11T12:06:29.006Z" },
-    { url = "https://files.pythonhosted.org/packages/54/a3/bed07bc9e2bb302ce752f1dabc69e884cd6a676da44fb0e501b246031fdd/multidict-6.6.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6bf2f10f70acc7a2446965ffbc726e5fc0b272c97a90b485857e5c70022213eb", size = 44634, upload-time = "2025-08-11T12:06:30.374Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/4b/ceeb4f8f33cf81277da464307afeaf164fb0297947642585884f5cad4f28/multidict-6.6.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:66247d72ed62d5dd29752ffc1d3b88f135c6a8de8b5f63b7c14e973ef5bda19e", size = 44282, upload-time = "2025-08-11T12:06:31.958Z" },
-    { url = "https://files.pythonhosted.org/packages/03/35/436a5da8702b06866189b69f655ffdb8f70796252a8772a77815f1812679/multidict-6.6.4-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:105245cc6b76f51e408451a844a54e6823bbd5a490ebfe5bdfc79798511ceded", size = 229696, upload-time = "2025-08-11T12:06:33.087Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/0e/915160be8fecf1fca35f790c08fb74ca684d752fcba62c11daaf3d92c216/multidict-6.6.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cbbc54e58b34c3bae389ef00046be0961f30fef7cb0dd9c7756aee376a4f7683", size = 246665, upload-time = "2025-08-11T12:06:34.448Z" },
-    { url = "https://files.pythonhosted.org/packages/08/ee/2f464330acd83f77dcc346f0b1a0eaae10230291450887f96b204b8ac4d3/multidict-6.6.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:56c6b3652f945c9bc3ac6c8178cd93132b8d82dd581fcbc3a00676c51302bc1a", size = 225485, upload-time = "2025-08-11T12:06:35.672Z" },
-    { url = "https://files.pythonhosted.org/packages/71/cc/9a117f828b4d7fbaec6adeed2204f211e9caf0a012692a1ee32169f846ae/multidict-6.6.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b95494daf857602eccf4c18ca33337dd2be705bccdb6dddbfc9d513e6addb9d9", size = 257318, upload-time = "2025-08-11T12:06:36.98Z" },
-    { url = "https://files.pythonhosted.org/packages/25/77/62752d3dbd70e27fdd68e86626c1ae6bccfebe2bb1f84ae226363e112f5a/multidict-6.6.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e5b1413361cef15340ab9dc61523e653d25723e82d488ef7d60a12878227ed50", size = 254689, upload-time = "2025-08-11T12:06:38.233Z" },
-    { url = "https://files.pythonhosted.org/packages/00/6e/fac58b1072a6fc59af5e7acb245e8754d3e1f97f4f808a6559951f72a0d4/multidict-6.6.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e167bf899c3d724f9662ef00b4f7fef87a19c22b2fead198a6f68b263618df52", size = 246709, upload-time = "2025-08-11T12:06:39.517Z" },
-    { url = "https://files.pythonhosted.org/packages/01/ef/4698d6842ef5e797c6db7744b0081e36fb5de3d00002cc4c58071097fac3/multidict-6.6.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:aaea28ba20a9026dfa77f4b80369e51cb767c61e33a2d4043399c67bd95fb7c6", size = 243185, upload-time = "2025-08-11T12:06:40.796Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/c9/d82e95ae1d6e4ef396934e9b0e942dfc428775f9554acf04393cce66b157/multidict-6.6.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:8c91cdb30809a96d9ecf442ec9bc45e8cfaa0f7f8bdf534e082c2443a196727e", size = 237838, upload-time = "2025-08-11T12:06:42.595Z" },
-    { url = "https://files.pythonhosted.org/packages/57/cf/f94af5c36baaa75d44fab9f02e2a6bcfa0cd90acb44d4976a80960759dbc/multidict-6.6.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1a0ccbfe93ca114c5d65a2471d52d8829e56d467c97b0e341cf5ee45410033b3", size = 246368, upload-time = "2025-08-11T12:06:44.304Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/fe/29f23460c3d995f6a4b678cb2e9730e7277231b981f0b234702f0177818a/multidict-6.6.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:55624b3f321d84c403cb7d8e6e982f41ae233d85f85db54ba6286f7295dc8a9c", size = 253339, upload-time = "2025-08-11T12:06:45.597Z" },
-    { url = "https://files.pythonhosted.org/packages/29/b6/fd59449204426187b82bf8a75f629310f68c6adc9559dc922d5abe34797b/multidict-6.6.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:4a1fb393a2c9d202cb766c76208bd7945bc194eba8ac920ce98c6e458f0b524b", size = 246933, upload-time = "2025-08-11T12:06:46.841Z" },
-    { url = "https://files.pythonhosted.org/packages/19/52/d5d6b344f176a5ac3606f7a61fb44dc746e04550e1a13834dff722b8d7d6/multidict-6.6.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:43868297a5759a845fa3a483fb4392973a95fb1de891605a3728130c52b8f40f", size = 242225, upload-time = "2025-08-11T12:06:48.588Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/d3/5b2281ed89ff4d5318d82478a2a2450fcdfc3300da48ff15c1778280ad26/multidict-6.6.4-cp311-cp311-win32.whl", hash = "sha256:ed3b94c5e362a8a84d69642dbeac615452e8af9b8eb825b7bc9f31a53a1051e2", size = 41306, upload-time = "2025-08-11T12:06:49.95Z" },
-    { url = "https://files.pythonhosted.org/packages/74/7d/36b045c23a1ab98507aefd44fd8b264ee1dd5e5010543c6fccf82141ccef/multidict-6.6.4-cp311-cp311-win_amd64.whl", hash = "sha256:d8c112f7a90d8ca5d20213aa41eac690bb50a76da153e3afb3886418e61cb22e", size = 46029, upload-time = "2025-08-11T12:06:51.082Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/5e/553d67d24432c5cd52b49047f2d248821843743ee6d29a704594f656d182/multidict-6.6.4-cp311-cp311-win_arm64.whl", hash = "sha256:3bb0eae408fa1996d87247ca0d6a57b7fc1dcf83e8a5c47ab82c558c250d4adf", size = 43017, upload-time = "2025-08-11T12:06:52.243Z" },
-    { url = "https://files.pythonhosted.org/packages/05/f6/512ffd8fd8b37fb2680e5ac35d788f1d71bbaf37789d21a820bdc441e565/multidict-6.6.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0ffb87be160942d56d7b87b0fdf098e81ed565add09eaa1294268c7f3caac4c8", size = 76516, upload-time = "2025-08-11T12:06:53.393Z" },
-    { url = "https://files.pythonhosted.org/packages/99/58/45c3e75deb8855c36bd66cc1658007589662ba584dbf423d01df478dd1c5/multidict-6.6.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d191de6cbab2aff5de6c5723101705fd044b3e4c7cfd587a1929b5028b9714b3", size = 45394, upload-time = "2025-08-11T12:06:54.555Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/ca/e8c4472a93a26e4507c0b8e1f0762c0d8a32de1328ef72fd704ef9cc5447/multidict-6.6.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:38a0956dd92d918ad5feff3db8fcb4a5eb7dba114da917e1a88475619781b57b", size = 43591, upload-time = "2025-08-11T12:06:55.672Z" },
-    { url = "https://files.pythonhosted.org/packages/05/51/edf414f4df058574a7265034d04c935aa84a89e79ce90fcf4df211f47b16/multidict-6.6.4-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6865f6d3b7900ae020b495d599fcf3765653bc927951c1abb959017f81ae8287", size = 237215, upload-time = "2025-08-11T12:06:57.213Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/45/8b3d6dbad8cf3252553cc41abea09ad527b33ce47a5e199072620b296902/multidict-6.6.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a2088c126b6f72db6c9212ad827d0ba088c01d951cee25e758c450da732c138", size = 258299, upload-time = "2025-08-11T12:06:58.946Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/e8/8ca2e9a9f5a435fc6db40438a55730a4bf4956b554e487fa1b9ae920f825/multidict-6.6.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0f37bed7319b848097085d7d48116f545985db988e2256b2e6f00563a3416ee6", size = 242357, upload-time = "2025-08-11T12:07:00.301Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/84/80c77c99df05a75c28490b2af8f7cba2a12621186e0a8b0865d8e745c104/multidict-6.6.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:01368e3c94032ba6ca0b78e7ccb099643466cf24f8dc8eefcfdc0571d56e58f9", size = 268369, upload-time = "2025-08-11T12:07:01.638Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/e9/920bfa46c27b05fb3e1ad85121fd49f441492dca2449c5bcfe42e4565d8a/multidict-6.6.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fe323540c255db0bffee79ad7f048c909f2ab0edb87a597e1c17da6a54e493c", size = 269341, upload-time = "2025-08-11T12:07:02.943Z" },
-    { url = "https://files.pythonhosted.org/packages/af/65/753a2d8b05daf496f4a9c367fe844e90a1b2cac78e2be2c844200d10cc4c/multidict-6.6.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8eb3025f17b0a4c3cd08cda49acf312a19ad6e8a4edd9dbd591e6506d999402", size = 256100, upload-time = "2025-08-11T12:07:04.564Z" },
-    { url = "https://files.pythonhosted.org/packages/09/54/655be13ae324212bf0bc15d665a4e34844f34c206f78801be42f7a0a8aaa/multidict-6.6.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bbc14f0365534d35a06970d6a83478b249752e922d662dc24d489af1aa0d1be7", size = 253584, upload-time = "2025-08-11T12:07:05.914Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/74/ab2039ecc05264b5cec73eb018ce417af3ebb384ae9c0e9ed42cb33f8151/multidict-6.6.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:75aa52fba2d96bf972e85451b99d8e19cc37ce26fd016f6d4aa60da9ab2b005f", size = 251018, upload-time = "2025-08-11T12:07:08.301Z" },
-    { url = "https://files.pythonhosted.org/packages/af/0a/ccbb244ac848e56c6427f2392741c06302bbfba49c0042f1eb3c5b606497/multidict-6.6.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4fefd4a815e362d4f011919d97d7b4a1e566f1dde83dc4ad8cfb5b41de1df68d", size = 251477, upload-time = "2025-08-11T12:07:10.248Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/b0/0ed49bba775b135937f52fe13922bc64a7eaf0a3ead84a36e8e4e446e096/multidict-6.6.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:db9801fe021f59a5b375ab778973127ca0ac52429a26e2fd86aa9508f4d26eb7", size = 263575, upload-time = "2025-08-11T12:07:11.928Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/d9/7fb85a85e14de2e44dfb6a24f03c41e2af8697a6df83daddb0e9b7569f73/multidict-6.6.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a650629970fa21ac1fb06ba25dabfc5b8a2054fcbf6ae97c758aa956b8dba802", size = 259649, upload-time = "2025-08-11T12:07:13.244Z" },
-    { url = "https://files.pythonhosted.org/packages/03/9e/b3a459bcf9b6e74fa461a5222a10ff9b544cb1cd52fd482fb1b75ecda2a2/multidict-6.6.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:452ff5da78d4720d7516a3a2abd804957532dd69296cb77319c193e3ffb87e24", size = 251505, upload-time = "2025-08-11T12:07:14.57Z" },
-    { url = "https://files.pythonhosted.org/packages/86/a2/8022f78f041dfe6d71e364001a5cf987c30edfc83c8a5fb7a3f0974cff39/multidict-6.6.4-cp312-cp312-win32.whl", hash = "sha256:8c2fcb12136530ed19572bbba61b407f655e3953ba669b96a35036a11a485793", size = 41888, upload-time = "2025-08-11T12:07:15.904Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/eb/d88b1780d43a56db2cba24289fa744a9d216c1a8546a0dc3956563fd53ea/multidict-6.6.4-cp312-cp312-win_amd64.whl", hash = "sha256:047d9425860a8c9544fed1b9584f0c8bcd31bcde9568b047c5e567a1025ecd6e", size = 46072, upload-time = "2025-08-11T12:07:17.045Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/16/b929320bf5750e2d9d4931835a4c638a19d2494a5b519caaaa7492ebe105/multidict-6.6.4-cp312-cp312-win_arm64.whl", hash = "sha256:14754eb72feaa1e8ae528468f24250dd997b8e2188c3d2f593f9eba259e4b364", size = 43222, upload-time = "2025-08-11T12:07:18.328Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/69/b547032297c7e63ba2af494edba695d781af8a0c6e89e4d06cf848b21d80/multidict-6.6.4-py3-none-any.whl", hash = "sha256:27d8f8e125c07cb954e54d75d04905a9bba8a439c1d84aca94949d4d03d8601c", size = 12313, upload-time = "2025-08-11T12:08:46.891Z" },
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" },
+    { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" },
+    { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
 ]
 
 [[package]]
 name = "murmurhash"
-version = "1.0.13"
+version = "1.0.15"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/54/e9/02efbc6dfc2dd2085da3daacf9a8c17e8356019eceaedbfa21555e32d2af/murmurhash-1.0.13.tar.gz", hash = "sha256:737246d41ee00ff74b07b0bd1f0888be304d203ce668e642c86aa64ede30f8b7", size = 13258, upload-time = "2025-05-22T12:35:57.019Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/23/2e/88c147931ea9725d634840d538622e94122bceaf346233349b7b5c62964b/murmurhash-1.0.15.tar.gz", hash = "sha256:58e2b27b7847f9e2a6edf10b47a8c8dd70a4705f45dccb7bf76aeadacf56ba01", size = 13291, upload-time = "2025-11-14T09:51:15.272Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/d1/9d13a02d9c8bfff10b1f68d19df206eaf2a8011defeccf7eb05ea0b8c54e/murmurhash-1.0.13-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b20d168370bc3ce82920121b78ab35ae244070a9b18798f4a2e8678fa03bd7e0", size = 26410, upload-time = "2025-05-22T12:35:20.786Z" },
-    { url = "https://files.pythonhosted.org/packages/14/b0/3ee762e98cf9a8c2df9c8b377c326f3dd4495066d4eace9066fca46eba7a/murmurhash-1.0.13-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cef667d2e83bdceea3bc20c586c491fa442662ace1aea66ff5e3a18bb38268d8", size = 26679, upload-time = "2025-05-22T12:35:21.808Z" },
-    { url = "https://files.pythonhosted.org/packages/39/06/24618f79cd5aac48490932e50263bddfd1ea90f7123d49bfe806a5982675/murmurhash-1.0.13-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:507148e50929ba1fce36898808573b9f81c763d5676f3fc6e4e832ff56b66992", size = 125970, upload-time = "2025-05-22T12:35:23.222Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/09/0e7afce0a422692506c85474a26fb3a03c1971b2b5f7e7745276c4b3de7f/murmurhash-1.0.13-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64d50f6173d266ad165beb8bca6101d824217fc9279f9e9981f4c0245c1e7ee6", size = 123390, upload-time = "2025-05-22T12:35:24.303Z" },
-    { url = "https://files.pythonhosted.org/packages/22/4c/c98f579b1a951b2bcc722a35270a2eec105c1e21585c9b314a02079e3c4d/murmurhash-1.0.13-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0f272e15a84a8ae5f8b4bc0a68f9f47be38518ddffc72405791178058e9d019a", size = 124007, upload-time = "2025-05-22T12:35:25.446Z" },
-    { url = "https://files.pythonhosted.org/packages/df/f8/1b0dcebc8df8e091341617102b5b3b97deb6435f345b84f75382c290ec2c/murmurhash-1.0.13-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9423e0b0964ed1013a06c970199538c7ef9ca28c0be54798c0f1473a6591761", size = 123705, upload-time = "2025-05-22T12:35:26.709Z" },
-    { url = "https://files.pythonhosted.org/packages/79/17/f2a38558e150a0669d843f75e128afb83c1a67af41885ea2acb940e18e2a/murmurhash-1.0.13-cp311-cp311-win_amd64.whl", hash = "sha256:83b81e7084b696df3d853f2c78e0c9bda6b285d643f923f1a6fa9ab145d705c5", size = 24572, upload-time = "2025-05-22T12:35:30.38Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/53/56ce2d8d4b9ab89557cb1d00ffce346b80a2eb2d8c7944015e5c83eacdec/murmurhash-1.0.13-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bbe882e46cb3f86e092d8a1dd7a5a1c992da1ae3b39f7dd4507b6ce33dae7f92", size = 26859, upload-time = "2025-05-22T12:35:31.815Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/85/3a0ad54a61257c31496545ae6861515d640316f93681d1dd917e7be06634/murmurhash-1.0.13-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:52a33a12ecedc432493692c207c784b06b6427ffaa897fc90b7a76e65846478d", size = 26900, upload-time = "2025-05-22T12:35:34.267Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/cd/6651de26744b50ff11c79f0c0d41244db039625de53c0467a7a52876b2d8/murmurhash-1.0.13-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:950403a7f0dc2d9c8d0710f07c296f2daab66299d9677d6c65d6b6fa2cb30aaa", size = 131367, upload-time = "2025-05-22T12:35:35.258Z" },
-    { url = "https://files.pythonhosted.org/packages/50/6c/01ded95ddce33811c9766cae4ce32e0a54288da1d909ee2bcaa6ed13b9f1/murmurhash-1.0.13-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fde9fb5d2c106d86ff3ef2e4a9a69c2a8d23ba46e28c6b30034dc58421bc107b", size = 128943, upload-time = "2025-05-22T12:35:36.358Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/27/e539a9622d7bea3ae22706c1eb80d4af80f9dddd93b54d151955c2ae4011/murmurhash-1.0.13-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3aa55d62773745616e1ab19345dece122f6e6d09224f7be939cc5b4c513c8473", size = 129108, upload-time = "2025-05-22T12:35:37.864Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/84/18af5662e07d06839ad4db18ce026e6f8ef850d7b0ba92817b28dad28ba6/murmurhash-1.0.13-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:060dfef1b405cf02c450f182fb629f76ebe7f79657cced2db5054bc29b34938b", size = 129175, upload-time = "2025-05-22T12:35:38.928Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/8d/b01d3ee1f1cf3957250223b7c6ce35454f38fbf4abe236bf04a3f769341d/murmurhash-1.0.13-cp312-cp312-win_amd64.whl", hash = "sha256:a8e79627d44a6e20a6487effc30bfe1c74754c13d179106e68cc6d07941b022c", size = 24869, upload-time = "2025-05-22T12:35:40.035Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ca/77d3e69924a8eb4508bb4f0ad34e46adbeedeb93616a71080e61e53dad71/murmurhash-1.0.15-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f32307fb9347680bb4fe1cbef6362fb39bd994f1b59abd8c09ca174e44199081", size = 27397, upload-time = "2025-11-14T09:50:03.077Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/53/a936f577d35b245d47b310f29e5e9f09fcac776c8c992f1ab51a9fb0cee2/murmurhash-1.0.15-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:539d8405885d1d19c005f3a2313b47e8e54b0ee89915eb8dfbb430b194328e6c", size = 27692, upload-time = "2025-11-14T09:50:04.144Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/64/5f8cfd1fd9cbeb43fcff96672f5bd9e7e1598d1c970f808ecd915490dc20/murmurhash-1.0.15-cp311-cp311-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c4cd739a00f5a4602201b74568ddabae46ec304719d9be752fd8f534a9464b5e", size = 128396, upload-time = "2025-11-14T09:50:05.268Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/10/d9ce29d559a75db0d8a3f13ea12c7f541ec9de2afca38dc70418b890eedb/murmurhash-1.0.15-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:44d211bcc3ec203c47dac06f48ee871093fcbdffa6652a6cc5ea7180306680a8", size = 128687, upload-time = "2025-11-14T09:50:06.527Z" },
+    { url = "https://files.pythonhosted.org/packages/48/cd/dc97ab7e68cdfa1537a56e36dbc846c5a66701cc39ecee2d4399fe61996c/murmurhash-1.0.15-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f9bf47101354fb1dc4b2e313192566f04ba295c28a37e2f71c692759acc1ba3c", size = 128198, upload-time = "2025-11-14T09:50:08.062Z" },
+    { url = "https://files.pythonhosted.org/packages/53/73/32f2aaa22c1e4afae337106baf0c938abf36a6cc879cfee83a00461bbbf7/murmurhash-1.0.15-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3c69b4d3bcd6233782a78907fe10b9b7a796bdc5d28060cf097d067bec280a5d", size = 127214, upload-time = "2025-11-14T09:50:09.265Z" },
+    { url = "https://files.pythonhosted.org/packages/82/ed/812103a7f353eba2d83655b08205e13a38c93b4db0692f94756e1eb44516/murmurhash-1.0.15-cp311-cp311-win_amd64.whl", hash = "sha256:e43a69496342ce530bdd670264cb7c8f45490b296e4764c837ce577e3c7ebd53", size = 25241, upload-time = "2025-11-14T09:50:10.373Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/5f/2c511bdd28f7c24da37a00116ffd0432b65669d098f0d0260c66ac0ffdc2/murmurhash-1.0.15-cp311-cp311-win_arm64.whl", hash = "sha256:f3e99a6ee36ef5372df5f138e3d9c801420776d3641a34a49e5c2555f44edba7", size = 23216, upload-time = "2025-11-14T09:50:11.651Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/46/be8522d3456fdccf1b8b049c6d82e7a3c1114c4fc2cfe14b04cba4b3e701/murmurhash-1.0.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d37e3ae44746bca80b1a917c2ea625cf216913564ed43f69d2888e5df97db0cb", size = 27884, upload-time = "2025-11-14T09:50:13.133Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/cc/630449bf4f6178d7daf948ce46ad00b25d279065fc30abd8d706be3d87e0/murmurhash-1.0.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0861cb11039409eaf46878456b7d985ef17b6b484103a6fc367b2ecec846891d", size = 27855, upload-time = "2025-11-14T09:50:14.859Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/30/ea8f601a9bf44db99468696efd59eb9cff1157cd55cb586d67116697583f/murmurhash-1.0.15-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5a301decfaccfec70fe55cb01dde2a012c3014a874542eaa7cc73477bb749616", size = 134088, upload-time = "2025-11-14T09:50:15.958Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/de/c40ce8c0877d406691e735b8d6e9c815f36a82b499d358313db5dbe219d7/murmurhash-1.0.15-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:32c6fde7bd7e9407003370a07b5f4addacabe1556ad3dc2cac246b7a2bba3400", size = 133978, upload-time = "2025-11-14T09:50:17.572Z" },
+    { url = "https://files.pythonhosted.org/packages/47/84/bd49963ecd84ebab2fe66595e2d1ed41d5e8b5153af5dc930f0bd827007c/murmurhash-1.0.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5d8b43a7011540dc3c7ce66f2134df9732e2bc3bbb4a35f6458bc755e48bde26", size = 132956, upload-time = "2025-11-14T09:50:18.742Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/7c/2530769c545074417c862583f05f4245644599f1e9ff619b3dfe2969aafc/murmurhash-1.0.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:43bf4541892ecd95963fcd307bf1c575fc0fee1682f41c93007adee71ca2bb40", size = 134184, upload-time = "2025-11-14T09:50:19.941Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a4/b249b042f5afe34d14ada2dc4afc777e883c15863296756179652e081c44/murmurhash-1.0.15-cp312-cp312-win_amd64.whl", hash = "sha256:f4ac15a2089dc42e6eb0966622d42d2521590a12c92480aafecf34c085302cca", size = 25647, upload-time = "2025-11-14T09:50:21.049Z" },
+    { url = "https://files.pythonhosted.org/packages/13/bf/028179259aebc18fd4ba5cae2601d1d47517427a537ab44336446431a215/murmurhash-1.0.15-cp312-cp312-win_arm64.whl", hash = "sha256:4a70ca4ae19e600d9be3da64d00710e79dde388a4d162f22078d64844d0ebdda", size = 23338, upload-time = "2025-11-14T09:50:22.359Z" },
 ]
 
 [[package]]
 name = "mypy"
-version = "1.18.2"
+version = "2.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "ast-serialize" },
+    { name = "librt", marker = "platform_python_implementation != 'PyPy'" },
     { name = "mypy-extensions" },
     { name = "pathspec" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c0/77/8f0d0001ffad290cef2f7f216f96c814866248a0b92a722365ed54648e7e/mypy-1.18.2.tar.gz", hash = "sha256:06a398102a5f203d7477b2923dda3634c36727fa5c237d8f859ef90c42a9924b", size = 3448846, upload-time = "2025-09-19T00:11:10.519Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/15/cca9d88503549ed6fedeaa1d448cdddd542ee8a490232d732e278036fbf2/mypy-2.1.0.tar.gz", hash = "sha256:81e76ad12c2d804512e9b13240d1588316531bfba07558286078bfbce9613633", size = 3898359, upload-time = "2026-05-11T18:37:36.237Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/87/cafd3ae563f88f94eec33f35ff722d043e09832ea8530ef149ec1efbaf08/mypy-1.18.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:807d9315ab9d464125aa9fcf6d84fde6e1dc67da0b6f80e7405506b8ac72bc7f", size = 12731198, upload-time = "2025-09-19T00:09:44.857Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/e0/1e96c3d4266a06d4b0197ace5356d67d937d8358e2ee3ffac71faa843724/mypy-1.18.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:776bb00de1778caf4db739c6e83919c1d85a448f71979b6a0edd774ea8399341", size = 11817879, upload-time = "2025-09-19T00:09:47.131Z" },
-    { url = "https://files.pythonhosted.org/packages/72/ef/0c9ba89eb03453e76bdac5a78b08260a848c7bfc5d6603634774d9cd9525/mypy-1.18.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1379451880512ffce14505493bd9fe469e0697543717298242574882cf8cdb8d", size = 12427292, upload-time = "2025-09-19T00:10:22.472Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/52/ec4a061dd599eb8179d5411d99775bec2a20542505988f40fc2fee781068/mypy-1.18.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1331eb7fd110d60c24999893320967594ff84c38ac6d19e0a76c5fd809a84c86", size = 13163750, upload-time = "2025-09-19T00:09:51.472Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/5f/2cf2ceb3b36372d51568f2208c021870fe7834cf3186b653ac6446511839/mypy-1.18.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3ca30b50a51e7ba93b00422e486cbb124f1c56a535e20eff7b2d6ab72b3b2e37", size = 13351827, upload-time = "2025-09-19T00:09:58.311Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/7d/2697b930179e7277529eaaec1513f8de622818696857f689e4a5432e5e27/mypy-1.18.2-cp311-cp311-win_amd64.whl", hash = "sha256:664dc726e67fa54e14536f6e1224bcfce1d9e5ac02426d2326e2bb4e081d1ce8", size = 9757983, upload-time = "2025-09-19T00:10:09.071Z" },
-    { url = "https://files.pythonhosted.org/packages/07/06/dfdd2bc60c66611dd8335f463818514733bc763e4760dee289dcc33df709/mypy-1.18.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:33eca32dd124b29400c31d7cf784e795b050ace0e1f91b8dc035672725617e34", size = 12908273, upload-time = "2025-09-19T00:10:58.321Z" },
-    { url = "https://files.pythonhosted.org/packages/81/14/6a9de6d13a122d5608e1a04130724caf9170333ac5a924e10f670687d3eb/mypy-1.18.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a3c47adf30d65e89b2dcd2fa32f3aeb5e94ca970d2c15fcb25e297871c8e4764", size = 11920910, upload-time = "2025-09-19T00:10:20.043Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/a9/b29de53e42f18e8cc547e38daa9dfa132ffdc64f7250e353f5c8cdd44bee/mypy-1.18.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d6c838e831a062f5f29d11c9057c6009f60cb294fea33a98422688181fe2893", size = 12465585, upload-time = "2025-09-19T00:10:33.005Z" },
-    { url = "https://files.pythonhosted.org/packages/77/ae/6c3d2c7c61ff21f2bee938c917616c92ebf852f015fb55917fd6e2811db2/mypy-1.18.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01199871b6110a2ce984bde85acd481232d17413868c9807e95c1b0739a58914", size = 13348562, upload-time = "2025-09-19T00:10:11.51Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/31/aec68ab3b4aebdf8f36d191b0685d99faa899ab990753ca0fee60fb99511/mypy-1.18.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a2afc0fa0b0e91b4599ddfe0f91e2c26c2b5a5ab263737e998d6817874c5f7c8", size = 13533296, upload-time = "2025-09-19T00:10:06.568Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/83/abcb3ad9478fca3ebeb6a5358bb0b22c95ea42b43b7789c7fb1297ca44f4/mypy-1.18.2-cp312-cp312-win_amd64.whl", hash = "sha256:d8068d0afe682c7c4897c0f7ce84ea77f6de953262b12d07038f4d296d547074", size = 9828828, upload-time = "2025-09-19T00:10:28.203Z" },
-    { url = "https://files.pythonhosted.org/packages/87/e3/be76d87158ebafa0309946c4a73831974d4d6ab4f4ef40c3b53a385a66fd/mypy-1.18.2-py3-none-any.whl", hash = "sha256:22a1748707dd62b58d2ae53562ffc4d7f8bcc727e8ac7cbc69c053ddc874d47e", size = 2352367, upload-time = "2025-09-19T00:10:15.489Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/a1/639f3024794a2a15899cb90707fe02e044c4412794c39c5769fd3df2e2ef/mypy-2.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a683016b16fe2f572dc04c72be7ee0504ac1605a265d0200f5cea695fb788f41", size = 14691685, upload-time = "2026-05-11T18:33:27.973Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/08/9a585dea4325f20d8b80dc78623fa50d1fd2173b710f6237afd6ba6ab39b/mypy-2.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1a293c534adb55271fef24a26da04b855540a8c13cc07bc5917b9fd2c394f2ca", size = 13555165, upload-time = "2026-05-11T18:32:16.107Z" },
+    { url = "https://files.pythonhosted.org/packages/81/dc/7c42cc9c6cb01e8eb09961f1f738741d3e9c7e9d5c5b30ec69222625cd5f/mypy-2.1.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7406f4d048e71e576f5356d317e5b0a9e666dfd966bd99f9d14ca06e1a341538", size = 13994376, upload-time = "2026-05-11T18:32:39.256Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/285946c33bce716e082c11dfeee9ee196eaf1f5042efb3581a31f9f205e4/mypy-2.1.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e0210d626fc8b31ccc90233754c7bc90e1f43205e85d96387f7db1285b55c398", size = 14864618, upload-time = "2026-05-11T18:34:49.765Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/83/82397f48af6c27e295d57979ded8490c9829040152cf7571b2f026aeb9a0/mypy-2.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3712c20deed54e814eaaa825603bada8ea1c390670a397c95b98405347acc563", size = 15102063, upload-time = "2026-05-11T18:34:05.855Z" },
+    { url = "https://files.pythonhosted.org/packages/40/68/b02dec39057b88eb03dc0aa854732e26e8361f34f9d0e20c7614967d1eba/mypy-2.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fcaa0e479066e31f7cceb6a3bea39cb22b2ff51a6b2f24f193d19179ba17c389", size = 11060564, upload-time = "2026-05-11T18:35:36.494Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/a8/ea3dcbef31f99b634f2ee23bb0321cbc8c1b388b76a861eb849f13c347dc/mypy-2.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:0b1a5260c95aa443083f9ed3592662941951bca3d4ca224a5dc517c38b7cf666", size = 9966983, upload-time = "2026-05-11T18:37:14.139Z" },
+    { url = "https://files.pythonhosted.org/packages/95/b1/55861beb5c339b44f9a2ba92df9e2cb1eeb4ae1eee674cdf7772c797778b/mypy-2.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:244358bf1c0da7722230bce60683d52e8e9fd030554926f15b747a84efb5b3af", size = 14874381, upload-time = "2026-05-11T18:37:31.784Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/b3/b7f770114b7d0ac92d0f76e8d93c2780844a70488a90e91821927850da86/mypy-2.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4ec7c57657493c7a75534df2751c8ae2cda383c16ecc55d2106c54476b1b16f6", size = 13665501, upload-time = "2026-05-11T18:34:23.063Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/f3/8ae2037967e2126689a0c11d99e2b707134a565191e92c60ca2572aec60a/mypy-2.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8161b6ff4392410023224f0969d17db93e1e154bc3e4ba62598e720723ae211", size = 14045750, upload-time = "2026-05-11T18:31:48.151Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/32/615eb5911859e43d054941b0d0a7d06cfa2870eba86529cf385b052b111c/mypy-2.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bf03e12003084a67395184d3eb8cbd6a489dc3655b5664b28c210a9e2403ab0b", size = 15061630, upload-time = "2026-05-11T18:37:06.898Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/03/4eafbfff8bfab1b87082741eae6e6a624028c984e6708b73bce2a8570c9d/mypy-2.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:20509760fd791c51579d573153407d226385ec1f8bcce55d730b354f3336bc22", size = 15288831, upload-time = "2026-05-11T18:31:18.07Z" },
+    { url = "https://files.pythonhosted.org/packages/99/ee/919661478e5891a3c96e549c036e467e64563ab85995b10c53c8358e16a3/mypy-2.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:6753d0c1fdd6b1a23b9e4f283ce80b2153b724adcb2653b20b85a8a28ac6436b", size = 11135228, upload-time = "2026-05-11T18:34:31.23Z" },
+    { url = "https://files.pythonhosted.org/packages/24/0a/6a12b9782ca0831a553192f351679f4548abc9d19a7cc93bb7feb02084c7/mypy-2.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:98ebb6589bb3b6d0c6f0c459d53ca55b8091fbc13d277c4041c885392e8195e8", size = 10040684, upload-time = "2026-05-11T18:36:48.199Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/2a/13ca1f292f6db1b98ff495ef3467736b331621c5917cad984b7043e7348d/mypy-2.1.0-py3-none-any.whl", hash = "sha256:a663814603a5c563fb87a4f96fb473eeb30d1f5a4885afcf44f9db000a366289", size = 2693302, upload-time = "2026-05-11T18:31:29.246Z" },
 ]
 
 [[package]]
@@ -1656,18 +1631,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
 ]
 
-[[package]]
-name = "nexus-rpc"
-version = "1.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ef/66/540687556bd28cf1ec370cc6881456203dfddb9dab047b8979c6865b5984/nexus_rpc-1.1.0.tar.gz", hash = "sha256:d65ad6a2f54f14e53ebe39ee30555eaeb894102437125733fb13034a04a44553", size = 77383, upload-time = "2025-07-07T19:03:58.368Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bf/2f/9e9d0dcaa4c6ffa22b7aa31069a8a264c753ff8027b36af602cce038c92f/nexus_rpc-1.1.0-py3-none-any.whl", hash = "sha256:d1b007af2aba186a27e736f8eaae39c03aed05b488084ff6c3d1785c9ba2ad38", size = 27743, upload-time = "2025-07-07T19:03:57.556Z" },
-]
-
 [[package]]
 name = "numpy"
 version = "1.26.4"
@@ -1693,65 +1656,69 @@ wheels = [
 ]
 
 [[package]]
-name = "openai"
-version = "2.1.0"
+name = "ocrmypdf"
+version = "17.4.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "anyio" },
-    { name = "distro" },
-    { name = "httpx" },
-    { name = "jiter" },
+    { name = "deprecation" },
+    { name = "fpdf2" },
+    { name = "img2pdf" },
+    { name = "packaging" },
+    { name = "pdfminer-six" },
+    { name = "pi-heif" },
+    { name = "pikepdf" },
+    { name = "pillow" },
+    { name = "pluggy" },
     { name = "pydantic" },
-    { name = "sniffio" },
-    { name = "tqdm" },
-    { name = "typing-extensions" },
+    { name = "pypdfium2" },
+    { name = "rich" },
+    { name = "uharfbuzz" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1a/dd/4d4d46a06943e37c95b6e388237e1e38d1e9aab264ff070f86345d60b7a4/openai-2.1.0.tar.gz", hash = "sha256:47f3463a5047340a989b4c0cd5378054acfca966ff61a96553b22f098e3270a2", size = 572998, upload-time = "2025-10-02T20:43:15.385Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/ba/26dd03706f5f387acb5d0e11d33dbe716f5cbce95e033e68404636eb3de5/ocrmypdf-17.4.2.tar.gz", hash = "sha256:b564557411c9a2695137cdc34e0a1a5084c5f33d7b3ef593f2659aa6a6a1c3cd", size = 7392178, upload-time = "2026-04-20T19:33:33.572Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/83/88f64fc8f037885efa8a629d1215f5bc1f037453bab4d4f823b5533319eb/openai-2.1.0-py3-none-any.whl", hash = "sha256:33172e8c06a4576144ba4137a493807a9ca427421dcabc54ad3aa656daf757d3", size = 964939, upload-time = "2025-10-02T20:43:13.568Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/e98af5616f3627dcef5b3c15cc28e566f77e96fb6f9b7592c24ff063cf5d/ocrmypdf-17.4.2-py3-none-any.whl", hash = "sha256:486d783dad386826ce052269111b1e9847f2e236a20465de0688af8c7a9bf7ad", size = 489269, upload-time = "2026-04-20T19:33:31.271Z" },
 ]
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.37.0"
+version = "1.42.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/63/04/05040d7ce33a907a2a02257e601992f0cdf11c73b33f13c4492bf6c3d6d5/opentelemetry_api-1.37.0.tar.gz", hash = "sha256:540735b120355bd5112738ea53621f8d5edb35ebcd6fe21ada3ab1c61d1cd9a7", size = 64923, upload-time = "2025-09-11T10:29:01.662Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/86/ca/25288069c399be6769159d9fb7b1190b603537d82aad2fa2746a0cc2c8c6/opentelemetry_api-1.42.0.tar.gz", hash = "sha256:ea84c893ad177791d138e0349d6ceebd8d3bf006440900400ce220008dafc372", size = 72300, upload-time = "2026-05-19T09:46:29.885Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/91/48/28ed9e55dcf2f453128df738210a980e09f4e468a456fa3c763dbc8be70a/opentelemetry_api-1.37.0-py3-none-any.whl", hash = "sha256:accf2024d3e89faec14302213bc39550ec0f4095d1cf5ca688e1bfb1c8612f47", size = 65732, upload-time = "2025-09-11T10:28:41.826Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/0b/be5daf659b82b525338fde371dfcfab09b606a19bb5620c37076964710ec/opentelemetry_api-1.42.0-py3-none-any.whl", hash = "sha256:558d88f88192a973579910ef6f2c13db47a268d5ec2e53e83e50e74a39a02922", size = 61310, upload-time = "2026-05-19T09:46:06.561Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp"
-version = "1.37.0"
+version = "1.42.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-exporter-otlp-proto-grpc" },
     { name = "opentelemetry-exporter-otlp-proto-http" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/64/df/47fde1de15a3d5ad410e98710fac60cd3d509df5dc7ec1359b71d6bf7e70/opentelemetry_exporter_otlp-1.37.0.tar.gz", hash = "sha256:f85b1929dd0d750751cc9159376fb05aa88bb7a08b6cdbf84edb0054d93e9f26", size = 6145, upload-time = "2025-09-11T10:29:03.075Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/03/428f61444ddd113ecd998390e25a6591191df238f826cebbaa01481e01ce/opentelemetry_exporter_otlp-1.42.0.tar.gz", hash = "sha256:246db750a55b70419395d60e68f3f3ec4c75af72366d81cac93bcc341976d595", size = 6085, upload-time = "2026-05-19T09:46:31.288Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f5/23/7e35e41111e3834d918e414eca41555d585e8860c9149507298bb3b9b061/opentelemetry_exporter_otlp-1.37.0-py3-none-any.whl", hash = "sha256:bd44592c6bc7fc3e5c0a9b60f2ee813c84c2800c449e59504ab93f356cc450fc", size = 7019, upload-time = "2025-09-11T10:28:44.094Z" },
+    { url = "https://files.pythonhosted.org/packages/17/23/bdb43e546ce6c00ba5d855babaed56c1ebfef6fc9fb5c27003160f0cbf33/opentelemetry_exporter_otlp-1.42.0-py3-none-any.whl", hash = "sha256:28c92bf13aad554cca6a22b9e508f2220d3a90882737a8d650327902dcc4959f", size = 6725, upload-time = "2026-05-19T09:46:08.975Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.37.0"
+version = "1.42.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/dc/6c/10018cbcc1e6fff23aac67d7fd977c3d692dbe5f9ef9bb4db5c1268726cc/opentelemetry_exporter_otlp_proto_common-1.37.0.tar.gz", hash = "sha256:c87a1bdd9f41fdc408d9cc9367bb53f8d2602829659f2b90be9f9d79d0bfe62c", size = 20430, upload-time = "2025-09-11T10:29:03.605Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/a9/1496f27ecdfc7d504eac80f5e16474ee9d47cd08cda1f2917b58cf1c299c/opentelemetry_exporter_otlp_proto_common-1.42.0.tar.gz", hash = "sha256:c7a1a61f3a4c4dfa83127353edb1c75b873289d9ee42379db46eb835963b72e3", size = 21430, upload-time = "2026-05-19T09:46:32.838Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/13/b4ef09837409a777f3c0af2a5b4ba9b7af34872bc43609dda0c209e4060d/opentelemetry_exporter_otlp_proto_common-1.37.0-py3-none-any.whl", hash = "sha256:53038428449c559b0c564b8d718df3314da387109c4d36bd1b94c9a641b0292e", size = 18359, upload-time = "2025-09-11T10:28:44.939Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/7b/1542eb6e3d941a7dd93648d485b7c8495bc2841a2bb7dd5f394f370cf607/opentelemetry_exporter_otlp_proto_common-1.42.0-py3-none-any.whl", hash = "sha256:92de67f096c9200770f16fbdb63b96fb6061d604b4bc266726d8355caeb864e8", size = 17328, upload-time = "2026-05-19T09:46:11.291Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-grpc"
-version = "1.37.0"
+version = "1.42.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
@@ -1762,14 +1729,14 @@ dependencies = [
     { name = "opentelemetry-sdk" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/11/4ad0979d0bb13ae5a845214e97c8d42da43980034c30d6f72d8e0ebe580e/opentelemetry_exporter_otlp_proto_grpc-1.37.0.tar.gz", hash = "sha256:f55bcb9fc848ce05ad3dd954058bc7b126624d22c4d9e958da24d8537763bec5", size = 24465, upload-time = "2025-09-11T10:29:04.172Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/6a/63812e4f67d3658b21e94bc890b67296951f3aa8f6950fdf735f763500e5/opentelemetry_exporter_otlp_proto_grpc-1.42.0.tar.gz", hash = "sha256:75eac4e9d0bd69bea8199d75dfeb585cce05a9baa8215d1f7aad9e3583bf5ef9", size = 27136, upload-time = "2026-05-19T09:46:33.594Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/17/46630b74751031a658706bef23ac99cdc2953cd3b2d28ec90590a0766b3e/opentelemetry_exporter_otlp_proto_grpc-1.37.0-py3-none-any.whl", hash = "sha256:aee5104835bf7993b7ddaaf380b6467472abaedb1f1dbfcc54a52a7d781a3890", size = 19305, upload-time = "2025-09-11T10:28:45.776Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/e9/308c4c03b536005a1443bee0d9f06de38aad8b94f59f58ac688ead7a8cf9/opentelemetry_exporter_otlp_proto_grpc-1.42.0-py3-none-any.whl", hash = "sha256:5d6d1691586f2e656fd14187f2f2f5fa06e94834e1acdce71edcbbe35730b31d", size = 19614, upload-time = "2026-05-19T09:46:12.331Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.37.0"
+version = "1.42.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
@@ -1780,28 +1747,28 @@ dependencies = [
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5d/e3/6e320aeb24f951449e73867e53c55542bebbaf24faeee7623ef677d66736/opentelemetry_exporter_otlp_proto_http-1.37.0.tar.gz", hash = "sha256:e52e8600f1720d6de298419a802108a8f5afa63c96809ff83becb03f874e44ac", size = 17281, upload-time = "2025-09-11T10:29:04.844Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/da/be1a80ca82f155e6067213243f5bae5c10985d3c7603eadaf8c750ebe9eb/opentelemetry_exporter_otlp_proto_http-1.42.0.tar.gz", hash = "sha256:640013aacdbbe01bfb187c66dd331b24249517b7f36c0cd994ef75544d1dbd0b", size = 25405, upload-time = "2026-05-19T09:46:34.356Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/e9/70d74a664d83976556cec395d6bfedd9b85ec1498b778367d5f93e373397/opentelemetry_exporter_otlp_proto_http-1.37.0-py3-none-any.whl", hash = "sha256:54c42b39945a6cc9d9a2a33decb876eabb9547e0dcb49df090122773447f1aef", size = 19576, upload-time = "2025-09-11T10:28:46.726Z" },
+    { url = "https://files.pythonhosted.org/packages/97/df/a5b8df72a4ef59519170d6f5fc4bd06528fed42e593b9b16b027cb477e50/opentelemetry_exporter_otlp_proto_http-1.42.0-py3-none-any.whl", hash = "sha256:f2cb9ea5dfac29e91b7b04034ca5a4bfae14b51cb334172c5b42b86a48843324", size = 21792, upload-time = "2026-05-19T09:46:13.67Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-prometheus"
-version = "0.58b0"
+version = "0.63b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-sdk" },
     { name = "prometheus-client" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1a/4c/e351559526ee35fa36d990d3455e81a5607c1fa3e544b599ad802f2481f8/opentelemetry_exporter_prometheus-0.58b0.tar.gz", hash = "sha256:70f2627b4bb82bac65a1fcf95f6e0dcce9e823dd47379ced854753a7e14dfc93", size = 14972, upload-time = "2025-09-11T10:29:05.513Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/2c/0643113a5bef20e8242f7ae7915913fab61e8c901d391518a0aefa2da6fc/opentelemetry_exporter_prometheus-0.63b0.tar.gz", hash = "sha256:76b52078ee70131542e53d5cf1942cadd6d5628e7a1bf1f60047f29fa079e9b1", size = 15231, upload-time = "2026-05-19T09:46:35.1Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a6/e3/50e9cdc5a52c2ab19585dd69e668ec9fee0343fafc4bffa919ca79230a4f/opentelemetry_exporter_prometheus-0.58b0-py3-none-any.whl", hash = "sha256:02005033a7a108ab9f3000ff3aa49e2d03a8893b5bf3431322ffa246affbf951", size = 13016, upload-time = "2025-09-11T10:28:47.67Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/48/18e2b0eec9242beb168b1100ed6c602c2a378d0ccb779d1c0a1b85b9ba89/opentelemetry_exporter_prometheus-0.63b0-py3-none-any.whl", hash = "sha256:0cfe4846bf5905f096a4d9678ffe25c7fe6f662f6c7282d2b191138d6bf487fb", size = 12466, upload-time = "2026-05-19T09:46:15.025Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.58b0"
+version = "0.63b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -1809,14 +1776,14 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f6/36/7c307d9be8ce4ee7beb86d7f1d31027f2a6a89228240405a858d6e4d64f9/opentelemetry_instrumentation-0.58b0.tar.gz", hash = "sha256:df640f3ac715a3e05af145c18f527f4422c6ab6c467e40bd24d2ad75a00cb705", size = 31549, upload-time = "2025-09-11T11:42:14.084Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/2d/322d464f4105966fb8555f871a84f43e821ce9aaf64ecae9586e9691c6a2/opentelemetry_instrumentation-0.63b0.tar.gz", hash = "sha256:80a339ef030a8d0fd1962375a9801dd31954e5063d74c00bc3d4e6581f43bab1", size = 41083, upload-time = "2026-05-19T09:47:06.194Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d4/db/5ff1cd6c5ca1d12ecf1b73be16fbb2a8af2114ee46d4b0e6d4b23f4f4db7/opentelemetry_instrumentation-0.58b0-py3-none-any.whl", hash = "sha256:50f97ac03100676c9f7fc28197f8240c7290ca1baa12da8bfbb9a1de4f34cc45", size = 33019, upload-time = "2025-09-11T11:41:00.624Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/45/a38e74da3f1b5c82c97289da91d978caa04321877f0ab170fc620a0753f2/opentelemetry_instrumentation-0.63b0-py3-none-any.whl", hash = "sha256:984b18763b652a881ac5a596098d89923f74cf53a658c2dde660387e018147ca", size = 35574, upload-time = "2026-05-19T09:46:07.257Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation-asgi"
-version = "0.58b0"
+version = "0.63b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "asgiref" },
@@ -1825,14 +1792,14 @@ dependencies = [
     { name = "opentelemetry-semantic-conventions" },
     { name = "opentelemetry-util-http" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7b/e2/03ff707d881d590c7adaed5e9d1979aed7e5e53fc1ed89035e5ed9f304af/opentelemetry_instrumentation_asgi-0.58b0.tar.gz", hash = "sha256:3ccc0c9c1c8c71e8d9da5945c6dcd9c0c8d147839f208536b7042c6dd98e65c9", size = 25116, upload-time = "2025-09-11T11:42:18.437Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/ba/dd540189230d211898ccc4df899874bc0d84f5c54a1e07a13a2bde606a57/opentelemetry_instrumentation_asgi-0.63b0.tar.gz", hash = "sha256:e201eed7616f7da0840adf8ab8c5ea64db7ab19b920373b38983e2bac8d3645d", size = 26154, upload-time = "2026-05-19T09:47:10.023Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8c/71/a00884c6655387c70070138acbf79a6616ad5d4489680f40708d75b598a7/opentelemetry_instrumentation_asgi-0.58b0-py3-none-any.whl", hash = "sha256:508a6d79e333d648d2afee0e140b6e80eb5d443be183be58e81d9ff88373168a", size = 16798, upload-time = "2025-09-11T11:41:08.105Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/4f/caa793347febb9dae45f3d03d8bac04bf0752170a19c53016a0a91a214a0/opentelemetry_instrumentation_asgi-0.63b0-py3-none-any.whl", hash = "sha256:4e89555c110677226b9ca1734eda248360916bccf0ebadf8db8baf0015c9efca", size = 15907, upload-time = "2026-05-19T09:46:13.675Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation-fastapi"
-version = "0.58b0"
+version = "0.63b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -1841,91 +1808,75 @@ dependencies = [
     { name = "opentelemetry-semantic-conventions" },
     { name = "opentelemetry-util-http" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/64/09/4f8fcab834af6b403e5e2d94bdfb2d0835ba8cd1049bcc156995f47b65fb/opentelemetry_instrumentation_fastapi-0.58b0.tar.gz", hash = "sha256:03da470d694116a0a40f4e76319e42f3ff9efc49abf804b2acc2c07f96661497", size = 24598, upload-time = "2025-09-11T11:42:35.325Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/45/fb/82de06eba54e5cb979274f073065ebc374794853502d342b5155073d1194/opentelemetry_instrumentation_fastapi-0.58b0-py3-none-any.whl", hash = "sha256:d89bfec69c9ffc5d9f3fe58655d6660a66b2bca863b9132712c06edcde68b6fa", size = 13460, upload-time = "2025-09-11T11:41:28.507Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-httpx"
-version = "0.58b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/07/21/ba3a0106795337716e5e324f58fd3c04f5967e330c0408d0d68d873454db/opentelemetry_instrumentation_httpx-0.58b0.tar.gz", hash = "sha256:3cd747e7785a06d06bd58875e8eb11595337c98c4341f4fe176ff1f734a90db7", size = 19887, upload-time = "2025-09-11T11:42:37.926Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/51/73/6e44cd21b17d4affd41a621804421d476940b1dab352254b1a9c08a08df6/opentelemetry_instrumentation_fastapi-0.63b0.tar.gz", hash = "sha256:5117df842d0ce47e1fb9eb3c2ad2a7594bd139b129de9f3fa1ce5b28e970c046", size = 25387, upload-time = "2026-05-19T09:47:20.726Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/e7/6dc8ee4881889993fa4a7d3da225e5eded239c975b9831eff392abd5a5e4/opentelemetry_instrumentation_httpx-0.58b0-py3-none-any.whl", hash = "sha256:d3f5a36c7fed08c245f1b06d1efd91f624caf2bff679766df80981486daaccdb", size = 15197, upload-time = "2025-09-11T11:41:32.66Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/f869b45eddbb7332cce7a863a4d1e758d58a9c890db6dbf0fe6aedd3eda1/opentelemetry_instrumentation_fastapi-0.63b0-py3-none-any.whl", hash = "sha256:ed43d2358164df83d811a8d69a7578cad3ab66fde4db027296c1ee20f703e3f0", size = 12797, upload-time = "2026-05-19T09:46:28.885Z" },
 ]
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.37.0"
+version = "1.42.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/dd/ea/a75f36b463a36f3c5a10c0b5292c58b31dbdde74f6f905d3d0ab2313987b/opentelemetry_proto-1.37.0.tar.gz", hash = "sha256:30f5c494faf66f77faeaefa35ed4443c5edb3b0aa46dad073ed7210e1a789538", size = 46151, upload-time = "2025-09-11T10:29:11.04Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/2c/7c56a19498b46da4c54dc4e765c95d17f8fec2ba86bec1817b41ae635360/opentelemetry_proto-1.42.0.tar.gz", hash = "sha256:5d56a9067b631ea931a135d7b86428ae99649f591d4db69b9fc8c8e0465fce65", size = 45841, upload-time = "2026-05-19T09:46:42.058Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/25/f89ea66c59bd7687e218361826c969443c4fa15dfe89733f3bf1e2a9e971/opentelemetry_proto-1.37.0-py3-none-any.whl", hash = "sha256:8ed8c066ae8828bbf0c39229979bdf583a126981142378a9cbe9d6fd5701c6e2", size = 72534, upload-time = "2025-09-11T10:28:56.831Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/ad/ff5f619a04cddb4936ead0dd8f590c5b373c5b4b9f2eef555e9d3d951ccb/opentelemetry_proto-1.42.0-py3-none-any.whl", hash = "sha256:2c0716a37e5c12efef37cbd01906d649b7fb85c85ac687518d0bd28527c6498e", size = 71779, upload-time = "2026-05-19T09:46:24.536Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.37.0"
+version = "1.42.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/62/2e0ca80d7fe94f0b193135375da92c640d15fe81f636658d2acf373086bc/opentelemetry_sdk-1.37.0.tar.gz", hash = "sha256:cc8e089c10953ded765b5ab5669b198bbe0af1b3f89f1007d19acd32dc46dda5", size = 170404, upload-time = "2025-09-11T10:29:11.779Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b7/c9/dabaaf1c754a57b82b5a36aeca3806d92c1877ccfb12a697b65f88bf027c/opentelemetry_sdk-1.42.0.tar.gz", hash = "sha256:2479e462cc69357825c2c847ce4a601bc1b17e1279aa7f80d3490f0ae614d0e5", size = 239072, upload-time = "2026-05-19T09:46:42.992Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9f/62/9f4ad6a54126fb00f7ed4bb5034964c6e4f00fcd5a905e115bd22707e20d/opentelemetry_sdk-1.37.0-py3-none-any.whl", hash = "sha256:8f3c3c22063e52475c5dbced7209495c2c16723d016d39287dfc215d1771257c", size = 131941, upload-time = "2025-09-11T10:28:57.83Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/7d/16bf9a9d42ebbd1679e0cda018d57a0712f3b6f6f1e7ae5ef3c7ee5927c0/opentelemetry_sdk-1.42.0-py3-none-any.whl", hash = "sha256:ec4a4f69e15220b3d7bccd93217aac745682bb6435b9381f7bb44cb7e07b4f2b", size = 170879, upload-time = "2026-05-19T09:46:25.871Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.58b0"
+version = "0.63b0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/aa/1b/90701d91e6300d9f2fb352153fb1721ed99ed1f6ea14fa992c756016e63a/opentelemetry_semantic_conventions-0.58b0.tar.gz", hash = "sha256:6bd46f51264279c433755767bb44ad00f1c9e2367e1b42af563372c5a6fa0c25", size = 129867, upload-time = "2025-09-11T10:29:12.597Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/f8/be4625838aae098c2f9fbdc062a1b3128ebb9e799b891b654ee8cad94897/opentelemetry_semantic_conventions-0.63b0.tar.gz", hash = "sha256:cfea295264654fa324fcef24aa56fb1836fdc0da27db128645dc6aa76115cc6c", size = 148333, upload-time = "2026-05-19T09:46:44.01Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/07/90/68152b7465f50285d3ce2481b3aec2f82822e3f52e5152eeeaf516bab841/opentelemetry_semantic_conventions-0.58b0-py3-none-any.whl", hash = "sha256:5564905ab1458b96684db1340232729fce3b5375a06e140e8904c78e4f815b28", size = 207954, upload-time = "2025-09-11T10:28:59.218Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/6f/8d0ce225b8fdbb72c97cf4130107d861eafcb3d8e5c3f5891e8556177316/opentelemetry_semantic_conventions-0.63b0-py3-none-any.whl", hash = "sha256:1f3962732b04f43e4fef28173c9a3615b8847b4b2d6386fdc085361b29875ab9", size = 203712, upload-time = "2026-05-19T09:46:27.569Z" },
 ]
 
 [[package]]
 name = "opentelemetry-util-http"
-version = "0.58b0"
+version = "0.63b0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c6/5f/02f31530faf50ef8a41ab34901c05cbbf8e9d76963ba2fb852b0b4065f4e/opentelemetry_util_http-0.58b0.tar.gz", hash = "sha256:de0154896c3472c6599311c83e0ecee856c4da1b17808d39fdc5cce5312e4d89", size = 9411, upload-time = "2025-09-11T11:43:05.602Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/cf/0b53c5fe1113fb01e23c6c88b66d8289f979e61cece444576b286a3415fd/opentelemetry_util_http-0.63b0.tar.gz", hash = "sha256:401ddd686cd943ef801b9384b0722b904250f6bf3906951ce4f27bb6b63b04a3", size = 11101, upload-time = "2026-05-19T09:47:42.885Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a5/a3/0a1430c42c6d34d8372a16c104e7408028f0c30270d8f3eb6cccf2e82934/opentelemetry_util_http-0.58b0-py3-none-any.whl", hash = "sha256:6c6b86762ed43025fbd593dc5f700ba0aa3e09711aedc36fd48a13b23d8cb1e7", size = 7652, upload-time = "2025-09-11T11:42:09.682Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/8c/7fd6f06139cca88a6341bebf2b01f3e97bb8fd8d12e7d3ad3d2ad88b8c49/opentelemetry_util_http-0.63b0-py3-none-any.whl", hash = "sha256:80536361b6348e57503cdae8c1b1be79574d14c30e879367336c5a076fd4f673", size = 8209, upload-time = "2026-05-19T09:47:01.712Z" },
 ]
 
 [[package]]
 name = "packaging"
-version = "25.0"
+version = "26.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
 ]
 
 [[package]]
 name = "pathspec"
-version = "0.12.1"
+version = "1.1.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" },
 ]
 
 [[package]]
@@ -1940,59 +1891,130 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/62/33/61766ae033518957f877ab246f87ca30a85b778ebaad65b7f74fa7e52988/pdf2image-1.17.0-py3-none-any.whl", hash = "sha256:ecdd58d7afb810dffe21ef2b1bbc057ef434dabbac6c33778a38a3f7744a27e2", size = 11618, upload-time = "2024-01-07T20:32:59.957Z" },
 ]
 
+[[package]]
+name = "pdfminer-six"
+version = "20260107"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "charset-normalizer" },
+    { name = "cryptography" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/a4/5cec1112009f0439a5ca6afa8ace321f0ab2f48da3255b7a1c8953014670/pdfminer_six-20260107.tar.gz", hash = "sha256:96bfd431e3577a55a0efd25676968ca4ce8fd5b53f14565f85716ff363889602", size = 8512094, upload-time = "2026-01-07T13:29:12.937Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/8b/28c4eaec9d6b036a52cb44720408f26b1a143ca9bce76cc19e8f5de00ab4/pdfminer_six-20260107-py3-none-any.whl", hash = "sha256:366585ba97e80dffa8f00cebe303d2f381884d8637af4ce422f1df3ef38111a9", size = 6592252, upload-time = "2026-01-07T13:29:10.742Z" },
+]
+
 [[package]]
 name = "phonenumbers"
-version = "9.0.15"
+version = "9.0.30"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/f1/249f843f4107c6a6ed17e5ece17620d75e532c2a355106e26d889a0c72c7/phonenumbers-9.0.30.tar.gz", hash = "sha256:d42d232ccde69c1af1bb5916a7e46f4edbcc72975b02759830f4ea1fba7b00c9", size = 2306521, upload-time = "2026-05-07T10:20:38.884Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/22/e4442aabea04daf16fda50d89bce2ff585e44f204089986b2cc6679cae10/phonenumbers-9.0.30-py2.py3-none-any.whl", hash = "sha256:e0890d4cda206ef6ac18ef07e8f3ab225c31c7edce237ac870b4729d4c1d2520", size = 2595222, upload-time = "2026-05-07T10:20:35.387Z" },
+]
+
+[[package]]
+name = "pi-heif"
+version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/14/8e/755749f61b93c39493730428cbfe14897198c0151e8b6d832f0a3c71ff16/phonenumbers-9.0.15.tar.gz", hash = "sha256:345ff7f23768332d866f37732f815cdf1d33c7f0961246562a5c5b78c12c3ff3", size = 2298105, upload-time = "2025-09-26T05:32:39.052Z" }
+dependencies = [
+    { name = "pillow" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/4a/4a18057a7b64254abdcc4f78d92503fc4f5b8fcc66da118ba87989111ee8/pi_heif-1.3.0.tar.gz", hash = "sha256:58151840d0d60507330654a466b06cbf7ca8fb3759eadb5234d70b4dc2bc990c", size = 17131114, upload-time = "2026-02-27T12:22:40.544Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f1/52/e9bbc1b092bb17b86f56da84a36ca98320330a1904d9b0ca3d685155db2c/phonenumbers-9.0.15-py2.py3-none-any.whl", hash = "sha256:269b73bc05258e8fd57582770b9559307099ea677c8f1dc5272476f661344776", size = 2583916, upload-time = "2025-09-26T05:32:35.736Z" },
+    { url = "https://files.pythonhosted.org/packages/01/cb/2d351be04962981a0deb49d747bcc721a7ece8e2272aa156e9251511804b/pi_heif-1.3.0-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:183ebd05e88f8e1b69e603164619f6ca79031e26078a6795d2a81c6afff36190", size = 1047016, upload-time = "2026-02-27T12:21:48.211Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/b3/2706ee866c6b461363f9fadb13a850a13a41f26952a52e6f50158cecd303/pi_heif-1.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3513f82c6039d00cd2f9b4e025f3742115f4802bb613d5bb50a8be62b256830a", size = 942338, upload-time = "2026-02-27T12:21:50.306Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/aa/1d6b92b782ac82ee8fa1f45f9dc8545866d738bad65f4f847ec7e53f246b/pi_heif-1.3.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39e84d64681adae5184f9376ce53d24b738831612dfa595f3efd4a4479393a7d", size = 1362499, upload-time = "2026-02-27T12:21:51.304Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/e6/3a72c309807942ff3a944fa69eb8e47b52a8a5f9670ef3168bf18fb901bb/pi_heif-1.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de8d6705b4b118ef3fa140c8ebdc6981e9d77b6176cd1315ad5a9ac79549dbc3", size = 1490234, upload-time = "2026-02-27T12:21:52.284Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/09/cac5841d60f85d72272ed2d46fd37d4d0aabe5cf7db2823693db9e136e17/pi_heif-1.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:beb9dd91455a0bd2a3c7a5da66fb922efac86b24e45ddcde6dc4121909de6db0", size = 2345034, upload-time = "2026-02-27T12:21:53.414Z" },
+    { url = "https://files.pythonhosted.org/packages/95/89/2ff1499e18ad0160d6458a8113337beb8379a19ed54a38b699bf806b8b64/pi_heif-1.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6d248f8b83009a980cd86719524ac3f7aa81427d998460479df36b8188326985", size = 2508816, upload-time = "2026-02-27T12:21:55.074Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/aa/05c66d09afca1b1c37c3cfa1f5b32f9d3cd9944aa1274fc28a87c157b10f/pi_heif-1.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:d714ad7292b53020a651015417fccc6017fee7420b47f5d31aaf6d02398159de", size = 1946873, upload-time = "2026-02-27T12:21:56.525Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/eb/4cb3f9789c2fff42ca0b40b0f57fc2a72f68cf62d54c836864cbc2032ec6/pi_heif-1.3.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:09cba007708cef90f95c15c382ece6f51e7ba33fb7fce96b54d786b02c9544e6", size = 1047196, upload-time = "2026-02-27T12:21:58.035Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/58/5aeeec1b7f0030902f9d96b168f26b7adaae0c8f758262bba0fa489036a4/pi_heif-1.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:04ce68ac95103d59b5c8fd25a8a51b40541e76d161d0eff834b9a9a3350fa401", size = 942299, upload-time = "2026-02-27T12:21:59.041Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/5b/d706a05b96945aabb122932028f14c21524a81e9655f38fad40de9c096f1/pi_heif-1.3.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7aa8e52e3d736cc07dd0657f87c841be069954a7717ecd6fd24ca8afcc16f6cb", size = 1361016, upload-time = "2026-02-27T12:22:00.039Z" },
+    { url = "https://files.pythonhosted.org/packages/90/78/c7e141f8a9943d711a63d1f9c55b4f69b6cad0718d8c80e3a65ca3d42a61/pi_heif-1.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ed464485f7df1d1b575dc1ff539182b09b8312d06c141882bbcfd428dc842cb1", size = 1489604, upload-time = "2026-02-27T12:22:01.096Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/26/06f0ba0fcb6a800d8afa73e63c78be6baaae0c442d17da13ff3e7d9033af/pi_heif-1.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6c2f7d26435d25be915914aba7ed383025a594453e3e84fd297975a9584b580c", size = 2343656, upload-time = "2026-02-27T12:22:02.153Z" },
+    { url = "https://files.pythonhosted.org/packages/87/f5/9deb76f59f36451dea69ebf0330171c1f953ae514dd03ac82ef2aa902ee3/pi_heif-1.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:26b3d101f838fbacebaa63e0c8b60a4333ba4d3fe93f4a3b51169ecaaf13c0ac", size = 2507970, upload-time = "2026-02-27T12:22:03.23Z" },
+    { url = "https://files.pythonhosted.org/packages/95/08/41c95822b8bbbd61a15e34a25e9a170035a17ef64bf12f95ad0040441b2e/pi_heif-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:633b6053875b8e482538fdc18cf66ba1f94ce7704d244aa325ed7197073155ee", size = 1946959, upload-time = "2026-02-27T12:22:04.672Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c8/54667ba54daac7e0abf84044bcace1c75df4bf3cf6caf9eec1f8a8b510cb/pi_heif-1.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e9b8a8f91336e64d9f5c334ca769ccb1063452043bac7297ab8048f424bd4b92", size = 1035290, upload-time = "2026-02-27T12:22:32.155Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/7b/faa0b54c6598afc8880c6d63914cfdc8f30569dbba96cb649aeaea2dff76/pi_heif-1.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:8cb3e208171db38926b48feaa874365e37f2ff98389cb9dc8d3cfbd027114e63", size = 938798, upload-time = "2026-02-27T12:22:33.131Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/30/9b9d61c429d8e6e3bc867c3fd13a3cb80579d53aea143de57d74ce7b390d/pi_heif-1.3.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f5827ccf996649b32c473ea965cde3b5221734b5d366242348038c819ff7ae33", size = 1320483, upload-time = "2026-02-27T12:22:34.152Z" },
+    { url = "https://files.pythonhosted.org/packages/29/ae/ac8fac4afbafeeb63f02e4faad05b1fcc2e3e8c8903fe3c3d669b27bf14a/pi_heif-1.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f378ca0bc5f9c8bef69911c9a1965f2469cff67f3e2a8c1c17c535733e3767e", size = 1445293, upload-time = "2026-02-27T12:22:36.566Z" },
+    { url = "https://files.pythonhosted.org/packages/42/4e/59acac0719f67475f3a4305daf7e66c0ee878999bf15e60b9622ff68ef84/pi_heif-1.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:28fde66eb57dae59bae151e6d51f362d05bb52c52ec82dbe09649e9b3c4e633d", size = 1947280, upload-time = "2026-02-27T12:22:38.332Z" },
+]
+
+[[package]]
+name = "pikepdf"
+version = "10.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "deprecated" },
+    { name = "lxml" },
+    { name = "packaging" },
+    { name = "pillow" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cf/20/06636c3c7351d7292308e848700cd26a2092233093d4cabe770aaee73319/pikepdf-10.6.0.tar.gz", hash = "sha256:172611c32ab0a6097cfbccb397847b8e84d3f7bc7d32d5fc2f50e7e61f164725", size = 23670594, upload-time = "2026-05-14T16:22:27.099Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f6/26/764fe0b5e4b2b9d1dbee361c7da3f790fcf807a979fb9bc7348ef8efec12/pikepdf-10.6.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:1874beb5761fef5063592c3dc147026bf878fcfa4cb49d8715dc9ed0ca778d85", size = 4370013, upload-time = "2026-05-14T16:21:23.708Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/a4/0f82e708d457005e51a22fe3a8b6629c9f291f29488a4f124404d8687341/pikepdf-10.6.0-cp311-cp311-macosx_15_0_x86_64.whl", hash = "sha256:2b69620e63252a80bbe191f8ea7b898fff059d7387fcd76b4a263734ded2f9c3", size = 4686951, upload-time = "2026-05-14T16:21:25.608Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/d6/aa4f8b4b1f56d5a1c4a9f186bbf7ff7cdbaf92c577e46044321c630fb022/pikepdf-10.6.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cdea20d3a354aa793dc5c58cfe434c355d776fc62baf17431db778bedbd52a00", size = 1942151, upload-time = "2026-05-14T16:21:28.095Z" },
+    { url = "https://files.pythonhosted.org/packages/94/11/faa8c71fc9c2cd77b0485c37ed202f107a42764cf2a41e17adbfa6f05c6a/pikepdf-10.6.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:82c38aa4e3bca73d1e37ac2306db44fdf3d61caae0047bfdae524f01a01e2896", size = 2132059, upload-time = "2026-05-14T16:21:30.241Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3f/18efbdc3710d50e412a954f16de54bfa7abaa323f606e503a08f16c93e9a/pikepdf-10.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9202eb9f49843a93d28be7cf29e9bb9c423bbd4029bf55c530869888a132a7c", size = 3581202, upload-time = "2026-05-14T16:21:32.428Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/74/4df4bbbb7f1e78aa39074fc878c6cea5f54651530bf85d28a9987b58d892/pikepdf-10.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8e5d4cb93c68e8b3d58ecfbfc4e93d3ef9874348e5f390acf247daa2851b5c50", size = 3776772, upload-time = "2026-05-14T16:21:34.823Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a6/a12db11a702f086cf58f20d9dfa8c5fa05446336c189742ac01f9007d87a/pikepdf-10.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:8fdaef50f6d8555b9edd0f5f62f8e77030a5eedb8e8e1ed12c533263a29cecf2", size = 3242948, upload-time = "2026-05-14T16:21:36.751Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/54/892884d0b36816087c80f7feef360168f6f4bd2387c19abf0497f4aa09e6/pikepdf-10.6.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3795c78304abea6d41384a26b2eb14cdedb05c64919da977c5d36c4bf54e5452", size = 4369370, upload-time = "2026-05-14T16:21:39.369Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/4f/99eb30942bae14295a02af63fdeed48932a3205a680716c25a0e315dce1f/pikepdf-10.6.0-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:e20a502f35e2c2ecd7df390ba890c73317845e9bd298c688f0b312116f419761", size = 4687951, upload-time = "2026-05-14T16:21:41.361Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6e/e12aa3128c3d6b1c952b1351d1c2b5d19f98eaacda05e5c20620c4b49e19/pikepdf-10.6.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:520748239e5e2919ea7b0e148de3939473ac6a687d1a6b2d32f10d99b05bd2ff", size = 1942636, upload-time = "2026-05-14T16:21:43.74Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/71/c732fb5b8b9953556b56bb504d57bbd622c86f78d9747666f17b3f2911eb/pikepdf-10.6.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8122e4945b7450d61cc693f0f8accfdc4b0273122a7d0ad9c3e1e60ef65fcab0", size = 2131880, upload-time = "2026-05-14T16:21:45.56Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/a2/f7be1ecd69a1070efd63b8fcf76b70a08dd54a87100fcc00ccdd8801cdd0/pikepdf-10.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a144ef5fac0569dc9600d6e807a0bf8a8e86b38bc0bcc146f5ebefca41d7a00e", size = 3581013, upload-time = "2026-05-14T16:21:47.76Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/94/f61ba738b28ef52ad662a04c3ebcb40cfc70162174fbddd6bf4450196a55/pikepdf-10.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:411292f912431e52adab742ddc5626e7f9f1aa2f1fc6d3542ec520078946f3ff", size = 3776849, upload-time = "2026-05-14T16:21:49.698Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b1/9a2fdd37134d0a9457339c1506c788731225e0208e0f3bf1667da3955368/pikepdf-10.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:e14563fe50abb106f1cf57a10dbc175b14c616b32f086a899288546443c7b7b8", size = 3244124, upload-time = "2026-05-14T16:21:51.875Z" },
 ]
 
 [[package]]
 name = "pillow"
-version = "11.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069, upload-time = "2025-07-01T09:16:30.666Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/db/26/77f8ed17ca4ffd60e1dcd220a6ec6d71210ba398cfa33a13a1cd614c5613/pillow-11.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1cd110edf822773368b396281a2293aeb91c90a2db00d78ea43e7e861631b722", size = 5316531, upload-time = "2025-07-01T09:13:59.203Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/39/ee475903197ce709322a17a866892efb560f57900d9af2e55f86db51b0a5/pillow-11.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9c412fddd1b77a75aa904615ebaa6001f169b26fd467b4be93aded278266b288", size = 4686560, upload-time = "2025-07-01T09:14:01.101Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/90/442068a160fd179938ba55ec8c97050a612426fae5ec0a764e345839f76d/pillow-11.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1aa4de119a0ecac0a34a9c8bde33f34022e2e8f99104e47a3ca392fd60e37d", size = 5870978, upload-time = "2025-07-03T13:09:55.638Z" },
-    { url = "https://files.pythonhosted.org/packages/13/92/dcdd147ab02daf405387f0218dcf792dc6dd5b14d2573d40b4caeef01059/pillow-11.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:91da1d88226663594e3f6b4b8c3c8d85bd504117d043740a8e0ec449087cc494", size = 7641168, upload-time = "2025-07-03T13:10:00.37Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/db/839d6ba7fd38b51af641aa904e2960e7a5644d60ec754c046b7d2aee00e5/pillow-11.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:643f189248837533073c405ec2f0bb250ba54598cf80e8c1e043381a60632f58", size = 5973053, upload-time = "2025-07-01T09:14:04.491Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/2f/d7675ecae6c43e9f12aa8d58b6012683b20b6edfbdac7abcb4e6af7a3784/pillow-11.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:106064daa23a745510dabce1d84f29137a37224831d88eb4ce94bb187b1d7e5f", size = 6640273, upload-time = "2025-07-01T09:14:06.235Z" },
-    { url = "https://files.pythonhosted.org/packages/45/ad/931694675ede172e15b2ff03c8144a0ddaea1d87adb72bb07655eaffb654/pillow-11.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd8ff254faf15591e724dc7c4ddb6bf4793efcbe13802a4ae3e863cd300b493e", size = 6082043, upload-time = "2025-07-01T09:14:07.978Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/04/ba8f2b11fc80d2dd462d7abec16351b45ec99cbbaea4387648a44190351a/pillow-11.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:932c754c2d51ad2b2271fd01c3d121daaa35e27efae2a616f77bf164bc0b3e94", size = 6715516, upload-time = "2025-07-01T09:14:10.233Z" },
-    { url = "https://files.pythonhosted.org/packages/48/59/8cd06d7f3944cc7d892e8533c56b0acb68399f640786313275faec1e3b6f/pillow-11.3.0-cp311-cp311-win32.whl", hash = "sha256:b4b8f3efc8d530a1544e5962bd6b403d5f7fe8b9e08227c6b255f98ad82b4ba0", size = 6274768, upload-time = "2025-07-01T09:14:11.921Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/cc/29c0f5d64ab8eae20f3232da8f8571660aa0ab4b8f1331da5c2f5f9a938e/pillow-11.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:1a992e86b0dd7aeb1f053cd506508c0999d710a8f07b4c791c63843fc6a807ac", size = 6986055, upload-time = "2025-07-01T09:14:13.623Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/df/90bd886fabd544c25addd63e5ca6932c86f2b701d5da6c7839387a076b4a/pillow-11.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:30807c931ff7c095620fe04448e2c2fc673fcbb1ffe2a7da3fb39613489b1ddd", size = 2423079, upload-time = "2025-07-01T09:14:15.268Z" },
-    { url = "https://files.pythonhosted.org/packages/40/fe/1bc9b3ee13f68487a99ac9529968035cca2f0a51ec36892060edcc51d06a/pillow-11.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdae223722da47b024b867c1ea0be64e0df702c5e0a60e27daad39bf960dd1e4", size = 5278800, upload-time = "2025-07-01T09:14:17.648Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/32/7e2ac19b5713657384cec55f89065fb306b06af008cfd87e572035b27119/pillow-11.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:921bd305b10e82b4d1f5e802b6850677f965d8394203d182f078873851dada69", size = 4686296, upload-time = "2025-07-01T09:14:19.828Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/1e/b9e12bbe6e4c2220effebc09ea0923a07a6da1e1f1bfbc8d7d29a01ce32b/pillow-11.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb76541cba2f958032d79d143b98a3a6b3ea87f0959bbe256c0b5e416599fd5d", size = 5871726, upload-time = "2025-07-03T13:10:04.448Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/33/e9200d2bd7ba00dc3ddb78df1198a6e80d7669cce6c2bdbeb2530a74ec58/pillow-11.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67172f2944ebba3d4a7b54f2e95c786a3a50c21b88456329314caaa28cda70f6", size = 7644652, upload-time = "2025-07-03T13:10:10.391Z" },
-    { url = "https://files.pythonhosted.org/packages/41/f1/6f2427a26fc683e00d985bc391bdd76d8dd4e92fac33d841127eb8fb2313/pillow-11.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f07ed9f56a3b9b5f49d3661dc9607484e85c67e27f3e8be2c7d28ca032fec7", size = 5977787, upload-time = "2025-07-01T09:14:21.63Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/c9/06dd4a38974e24f932ff5f98ea3c546ce3f8c995d3f0985f8e5ba48bba19/pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:676b2815362456b5b3216b4fd5bd89d362100dc6f4945154ff172e206a22c024", size = 6645236, upload-time = "2025-07-01T09:14:23.321Z" },
-    { url = "https://files.pythonhosted.org/packages/40/e7/848f69fb79843b3d91241bad658e9c14f39a32f71a301bcd1d139416d1be/pillow-11.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e184b2f26ff146363dd07bde8b711833d7b0202e27d13540bfe2e35a323a809", size = 6086950, upload-time = "2025-07-01T09:14:25.237Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/1a/7cff92e695a2a29ac1958c2a0fe4c0b2393b60aac13b04a4fe2735cad52d/pillow-11.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6be31e3fc9a621e071bc17bb7de63b85cbe0bfae91bb0363c893cbe67247780d", size = 6723358, upload-time = "2025-07-01T09:14:27.053Z" },
-    { url = "https://files.pythonhosted.org/packages/26/7d/73699ad77895f69edff76b0f332acc3d497f22f5d75e5360f78cbcaff248/pillow-11.3.0-cp312-cp312-win32.whl", hash = "sha256:7b161756381f0918e05e7cb8a371fff367e807770f8fe92ecb20d905d0e1c149", size = 6275079, upload-time = "2025-07-01T09:14:30.104Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/ce/e7dfc873bdd9828f3b6e5c2bbb74e47a98ec23cc5c74fc4e54462f0d9204/pillow-11.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a6444696fce635783440b7f7a9fc24b3ad10a9ea3f0ab66c5905be1c19ccf17d", size = 6986324, upload-time = "2025-07-01T09:14:31.899Z" },
-    { url = "https://files.pythonhosted.org/packages/16/8f/b13447d1bf0b1f7467ce7d86f6e6edf66c0ad7cf44cf5c87a37f9bed9936/pillow-11.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:2aceea54f957dd4448264f9bf40875da0415c83eb85f55069d89c0ed436e3542", size = 2423067, upload-time = "2025-07-01T09:14:33.709Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/e3/6fa84033758276fb31da12e5fb66ad747ae83b93c67af17f8c6ff4cc8f34/pillow-11.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7c8ec7a017ad1bd562f93dbd8505763e688d388cde6e4a010ae1486916e713e6", size = 5270566, upload-time = "2025-07-01T09:16:19.801Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/ee/e8d2e1ab4892970b561e1ba96cbd59c0d28cf66737fc44abb2aec3795a4e/pillow-11.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9ab6ae226de48019caa8074894544af5b53a117ccb9d3b3dcb2871464c829438", size = 4654618, upload-time = "2025-07-01T09:16:21.818Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/6d/17f80f4e1f0761f02160fc433abd4109fa1548dcfdca46cfdadaf9efa565/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe27fb049cdcca11f11a7bfda64043c37b30e6b91f10cb5bab275806c32f6ab3", size = 4874248, upload-time = "2025-07-03T13:11:20.738Z" },
-    { url = "https://files.pythonhosted.org/packages/de/5f/c22340acd61cef960130585bbe2120e2fd8434c214802f07e8c03596b17e/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:465b9e8844e3c3519a983d58b80be3f668e2a7a5db97f2784e7079fbc9f9822c", size = 6583963, upload-time = "2025-07-03T13:11:26.283Z" },
-    { url = "https://files.pythonhosted.org/packages/31/5e/03966aedfbfcbb4d5f8aa042452d3361f325b963ebbadddac05b122e47dd/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5418b53c0d59b3824d05e029669efa023bbef0f3e92e75ec8428f3799487f361", size = 4957170, upload-time = "2025-07-01T09:16:23.762Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/2d/e082982aacc927fc2cab48e1e731bdb1643a1406acace8bed0900a61464e/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:504b6f59505f08ae014f724b6207ff6222662aab5cc9542577fb084ed0676ac7", size = 5581505, upload-time = "2025-07-01T09:16:25.593Z" },
-    { url = "https://files.pythonhosted.org/packages/34/e7/ae39f538fd6844e982063c3a5e4598b8ced43b9633baa3a85ef33af8c05c/pillow-11.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c84d689db21a1c397d001aa08241044aa2069e7587b398c8cc63020390b1c1b8", size = 6984598, upload-time = "2025-07-01T09:16:27.732Z" },
+version = "12.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" },
+    { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" },
+    { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" },
+    { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" },
+    { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" },
+    { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" },
+    { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" },
+    { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" },
 ]
 
 [[package]]
 name = "platformdirs"
-version = "4.5.1"
+version = "4.9.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cf/86/0248f086a84f01b37aaec0fa567b397df1a119f73c16f6c7a9aac73ea309/platformdirs-4.5.1.tar.gz", hash = "sha256:61d5cdcc6065745cdd94f0f878977f8de9437be93de97c1c12f853c9c0cdcbda", size = 21715, upload-time = "2025-12-05T13:52:58.638Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/28/3bfe2fa5a7b9c46fe7e13c97bda14c895fb10fa2ebf1d0abb90e0cea7ee1/platformdirs-4.5.1-py3-none-any.whl", hash = "sha256:d03afa3963c806a9bed9d5125c8f4cb2fdaf74a55ab60e5d59b3fde758104d31", size = 18731, upload-time = "2025-12-05T13:52:56.823Z" },
+    { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" },
 ]
 
 [[package]]
@@ -2006,154 +2028,139 @@ wheels = [
 
 [[package]]
 name = "preshed"
-version = "3.0.10"
+version = "3.0.13"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cymem" },
     { name = "murmurhash" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4d/3a/db814f67a05b6d7f9c15d38edef5ec9b21415710705b393883de92aee5ef/preshed-3.0.10.tar.gz", hash = "sha256:5a5c8e685e941f4ffec97f1fbf32694b8107858891a4bc34107fac981d8296ff", size = 15039, upload-time = "2025-05-26T15:18:33.612Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/75/fe6b7bbd0dea530a001b0e24c331b21a0be2786e402abf3c57f5dce43d4b/preshed-3.0.13.tar.gz", hash = "sha256:d75f718bbfd97e992f7827e0fa7faf6a91bdd9c922d5baa4b50d62731396cb89", size = 18338, upload-time = "2026-03-23T08:57:31.378Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/99/c3709638f687da339504d1daeca48604cadb338bf3556a1484d1f0cd95e6/preshed-3.0.10-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d96c4fe2b41c1cdcc8c4fc1fdb10f922a6095c0430a3ebe361fe62c78902d068", size = 131486, upload-time = "2025-05-26T15:17:52.231Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/27/0fd36b63caa8bbf57b31a121d9565d385bbd7521771d4eb93e17d326873d/preshed-3.0.10-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cb01ea930b96f3301526a2ab26f41347d07555e4378c4144c6b7645074f2ebb0", size = 127938, upload-time = "2025-05-26T15:17:54.19Z" },
-    { url = "https://files.pythonhosted.org/packages/90/54/6a876d9cc8d401a9c1fb6bb8ca5a31b3664d0bcb888a9016258a1ae17344/preshed-3.0.10-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9dd1f0a7b7d150e229d073fd4fe94f72610cae992e907cee74687c4695873a98", size = 842263, upload-time = "2025-05-26T15:17:55.398Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/7d/ff19f74d15ee587905bafa3582883cfe2f72b574e6d691ee64dc690dc276/preshed-3.0.10-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fd7b350c280137f324cd447afbf6ba9a849af0e8898850046ac6f34010e08bd", size = 842913, upload-time = "2025-05-26T15:17:56.687Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/3a/1c345a26463345557705b61965e1e0a732cc0e9c6dfd4787845dbfa50b4a/preshed-3.0.10-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cf6a5fdc89ad06079aa6ee63621e417d4f4cf2a3d8b63c72728baad35a9ff641", size = 820548, upload-time = "2025-05-26T15:17:58.057Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/6b/71f25e2b7a23dba168f43edfae0bb508552dbef89114ce65c73f2ea7172f/preshed-3.0.10-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b4c29a7bd66985808ad181c9ad05205a6aa7400cd0f98426acd7bc86588b93f8", size = 840379, upload-time = "2025-05-26T15:17:59.565Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/86/d8f32b0b31a36ee8770a9b1a95321430e364cd0ba4bfebb7348aed2f198d/preshed-3.0.10-cp311-cp311-win_amd64.whl", hash = "sha256:1367c1fd6f44296305315d4e1c3fe3171787d4d01c1008a76bc9466bd79c3249", size = 117655, upload-time = "2025-05-26T15:18:00.836Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/14/322a4f58bc25991a87f216acb1351800739b0794185d27508ee86c35f382/preshed-3.0.10-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6e9c46933d55c8898c8f7a6019a8062cd87ef257b075ada2dd5d1e57810189ea", size = 131367, upload-time = "2025-05-26T15:18:02.408Z" },
-    { url = "https://files.pythonhosted.org/packages/38/80/67507653c35620cace913f617df6d6f658b87e8da83087b851557d65dd86/preshed-3.0.10-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5c4ebc4f8ef0114d55f2ffdce4965378129c7453d0203664aeeb03055572d9e4", size = 126535, upload-time = "2025-05-26T15:18:03.589Z" },
-    { url = "https://files.pythonhosted.org/packages/db/b1/ab4f811aeaf20af0fa47148c1c54b62d7e8120d59025bd0a3f773bb67725/preshed-3.0.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ab5ab4c6dfd3746fb4328e7fbeb2a0544416b872db02903bfac18e6f5cd412f", size = 864907, upload-time = "2025-05-26T15:18:04.794Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/db/fe37c1f99cfb26805dd89381ddd54901307feceb267332eaaca228e9f9c1/preshed-3.0.10-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40586fd96ae3974c552a7cd78781b6844ecb1559ee7556586f487058cf13dd96", size = 869329, upload-time = "2025-05-26T15:18:06.353Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/fd/efb6a6233d1cd969966f3f65bdd8e662579c3d83114e5c356cec1927b1f7/preshed-3.0.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a606c24cda931306b98e0edfafed3309bffcf8d6ecfe07804db26024c4f03cd6", size = 846829, upload-time = "2025-05-26T15:18:07.716Z" },
-    { url = "https://files.pythonhosted.org/packages/14/49/0e4ce5db3bf86b081abb08a404fb37b7c2dbfd7a73ec6c0bc71b650307eb/preshed-3.0.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:394015566f9354738be903447039e8dbc6d93ba5adf091af694eb03c4e726b1e", size = 874008, upload-time = "2025-05-26T15:18:09.364Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/17/76d6593fc2d055d4e413b68a8c87b70aa9b7697d4972cb8062559edcf6e9/preshed-3.0.10-cp312-cp312-win_amd64.whl", hash = "sha256:fd7e38225937e580420c84d1996dde9b4f726aacd9405093455c3a2fa60fede5", size = 116701, upload-time = "2025-05-26T15:18:11.905Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/d1/7bc39738388b38ff48cecbb326a9b2bb3f422bb32097be92e010f3162395/preshed-3.0.13-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5268c0e6fa96f50cdf87f516c2d4b32563c12706ee768e75c00e8d0098acd545", size = 136718, upload-time = "2026-03-23T08:56:23.889Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/65/de465b6801740140c2b5d2db6c312ca7937dcfd0442f1ae7d50dee529544/preshed-3.0.13-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:df642547a1a94079978a0ea8f4593ab4b8d3bd43f767bef0ef64d9a214f8c4c9", size = 137261, upload-time = "2026-03-23T08:56:25.303Z" },
+    { url = "https://files.pythonhosted.org/packages/89/83/478ee078746a4a413c841542caebd2ea74b659475b8bf5f2e3724b6fe655/preshed-3.0.13-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09397592d333a77f88454e72b7f1f941b2afaf040b392b9e74898dbc4648cdf5", size = 821010, upload-time = "2026-03-23T08:56:26.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/2e/1ac761e973966893cd3a0ad3256360365276e2d1e779e351448981a1156a/preshed-3.0.13-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f8e6fe0620ed0f96a246d46447055c447e071cd8222731a045c235e8a758c918", size = 823096, upload-time = "2026-03-23T08:56:28.126Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/7824cfd85dd7fe547888de20228ebd87d9acd3708206d30b82211e382d23/preshed-3.0.13-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:502f93f49a22788203f02d3067d4ea077a0cca3864de6a792eae12e7ce589e14", size = 1812148, upload-time = "2026-03-23T08:56:29.755Z" },
+    { url = "https://files.pythonhosted.org/packages/34/48/32160a24705d56179de6af838c10a0c735c955dae5f9e4bb344750b79bc2/preshed-3.0.13-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:acd4d89abeca3678c5d8c89b3cd351314465bc67c7fa053d2644f8513e543386", size = 1881154, upload-time = "2026-03-23T08:56:31.49Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/22/0344b50f8b1ad9e3aac08099c47e1aba91c81602fd117d2673f6606ecae6/preshed-3.0.13-cp311-cp311-win_amd64.whl", hash = "sha256:de87fbabb0f37c3c92d4dd9b94fc82ab73cdab4247cdfbd57ab3926caa983919", size = 122219, upload-time = "2026-03-23T08:56:32.74Z" },
+    { url = "https://files.pythonhosted.org/packages/33/c4/812eeaa568510f396e27edab01100ca71418f032fd7098b107f12e572361/preshed-3.0.13-cp311-cp311-win_arm64.whl", hash = "sha256:5e2753779832e411e93eb727f3d409c0a6b7408e5ce4dd868076d8ece48c7693", size = 109308, upload-time = "2026-03-23T08:56:33.839Z" },
+    { url = "https://files.pythonhosted.org/packages/39/fb/ccff23c44c04088c248539005fcda78b9014512a34d170c5360f02ad908b/preshed-3.0.13-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5d14eea14bd01291388928991d7df7d60b9fd19ae970e55006eb4d29b0c1e8eb", size = 138497, upload-time = "2026-03-23T08:56:35.321Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ce/cad5a8145881a771e6c0d002f2e585fc19b962f120860b54d32af5baa342/preshed-3.0.13-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f05b08ce92399c0655b5e0eb5a1cc1f9e295703ed3aabdfaf6538dfa8ae23d57", size = 138010, upload-time = "2026-03-23T08:56:36.399Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/a2/c5fed4fb3e946699259d11e4036a3cfdd8c89b3e542e3077d46781642425/preshed-3.0.13-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:62cf7f3113132891d6bba70ff547ad81c6fe50a31930bbbb8499f1d47cd122b7", size = 861498, upload-time = "2026-03-23T08:56:37.67Z" },
+    { url = "https://files.pythonhosted.org/packages/51/94/8c9bc48a6ea4903f53a1a0031ce8e35687526949f25821762ef21493c007/preshed-3.0.13-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8b8de3f58043070a354477995acdd98626ce43e4193c708ebd0f694e467f5155", size = 868988, upload-time = "2026-03-23T08:56:39.324Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/df/ecd2f40055ff52527ca117ffbfafb888c1a3079b59fbabe03c5b8f9b7240/preshed-3.0.13-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:183b339956a9e1d7a4a00038a3b9587a734db9e8bd915939a49791bd1b372156", size = 1847382, upload-time = "2026-03-23T08:56:40.89Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/88/bdb244e40284ded3632a9f88c23bc80230bd7b2ae4a8b7f2cc91adead7a8/preshed-3.0.13-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2e77bed56aded7cbe5d28d6bd2178bc5b13eda0e0e464dab205fb578fa915000", size = 1919236, upload-time = "2026-03-23T08:56:42.616Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c9/c91ea56342e6c364fc69b444a1ac5432327857199c44032c9cc9dc4c3a23/preshed-3.0.13-cp312-cp312-win_amd64.whl", hash = "sha256:04d8f13f2986e5d11af5ac51f55ce3106c70c41b483d20ea392e6180bdd0f870", size = 122938, upload-time = "2026-03-23T08:56:44.271Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/0b/6a99d99619fd83b14c696e2489caed7070647488d4d3ac0b723d35db2de0/preshed-3.0.13-cp312-cp312-win_arm64.whl", hash = "sha256:19318dc1cd8cac6663c6c830bf7e0002d2de853769fb03e056774e97c21bedfd", size = 109194, upload-time = "2026-03-23T08:56:45.346Z" },
 ]
 
 [[package]]
 name = "presidio-analyzer"
-version = "2.2.360"
+version = "2.2.362"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "phonenumbers" },
+    { name = "pydantic" },
     { name = "pyyaml" },
     { name = "regex" },
     { name = "spacy" },
     { name = "tldextract" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/dd/df0d00ff44977868878f391b08feb65b8269904262d0f1387de827c13c7d/presidio_analyzer-2.2.360-py3-none-any.whl", hash = "sha256:aa6e83779b8f23587000ccfa3ef47aa34356a60b51284742e0d2a96b33205c4e", size = 128661, upload-time = "2025-09-09T09:24:20.75Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/8a/d6cf4bddbb11d9c78f5c9342bbbcde4f90fe4e3c7de114a836ec4ed8a6cf/presidio_analyzer-2.2.362-py3-none-any.whl", hash = "sha256:4c36438924b1fcb4df92ea5cf2d8dc57508808e116b10923c983b8732aa07d90", size = 201084, upload-time = "2026-03-15T12:40:43.801Z" },
 ]
 
 [[package]]
 name = "prometheus-client"
-version = "0.23.1"
+version = "0.25.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/23/53/3edb5d68ecf6b38fcbcc1ad28391117d2a322d9a1a3eff04bfdb184d8c3b/prometheus_client-0.23.1.tar.gz", hash = "sha256:6ae8f9081eaaaf153a2e959d2e6c4f4fb57b12ef76c8c7980202f1e57b48b2ce", size = 80481, upload-time = "2025-09-18T20:47:25.043Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/fb/d9aa83ffe43ce1f19e557c0971d04b90561b0cfd50762aafb01968285553/prometheus_client-0.25.0.tar.gz", hash = "sha256:5e373b75c31afb3c86f1a52fa1ad470c9aace18082d39ec0d2f918d11cc9ba28", size = 86035, upload-time = "2026-04-09T19:53:42.359Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b8/db/14bafcb4af2139e046d03fd00dea7873e48eafe18b7d2797e73d6681f210/prometheus_client-0.23.1-py3-none-any.whl", hash = "sha256:dd1913e6e76b59cfe44e7a4b83e01afc9873c1bdfd2ed8739f1e76aeca115f99", size = 61145, upload-time = "2025-09-18T20:47:23.875Z" },
-]
-
-[[package]]
-name = "prompt-toolkit"
-version = "3.0.52"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "wcwidth" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/9b/d4b1e644385499c8346fa9b622a3f030dce14cd6ef8a1871c221a17a67e7/prometheus_client-0.25.0-py3-none-any.whl", hash = "sha256:d5aec89e349a6ec230805d0df882f3807f74fd6c1a2fa86864e3c2279059fed1", size = 64154, upload-time = "2026-04-09T19:53:41.324Z" },
 ]
 
 [[package]]
 name = "propcache"
-version = "0.3.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/16/43264e4a779dd8588c21a70f0709665ee8f611211bdd2c87d952cfa7c776/propcache-0.3.2.tar.gz", hash = "sha256:20d7d62e4e7ef05f221e0db2856b979540686342e7dd9973b815599c7057e168", size = 44139, upload-time = "2025-06-09T22:56:06.081Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/80/8d/e8b436717ab9c2cfc23b116d2c297305aa4cd8339172a456d61ebf5669b8/propcache-0.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0b8d2f607bd8f80ddc04088bc2a037fdd17884a6fcadc47a96e334d72f3717be", size = 74207, upload-time = "2025-06-09T22:54:05.399Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/29/1e34000e9766d112171764b9fa3226fa0153ab565d0c242c70e9945318a7/propcache-0.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:06766d8f34733416e2e34f46fea488ad5d60726bb9481d3cddf89a6fa2d9603f", size = 43648, upload-time = "2025-06-09T22:54:08.023Z" },
-    { url = "https://files.pythonhosted.org/packages/46/92/1ad5af0df781e76988897da39b5f086c2bf0f028b7f9bd1f409bb05b6874/propcache-0.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2dc1f4a1df4fecf4e6f68013575ff4af84ef6f478fe5344317a65d38a8e6dc9", size = 43496, upload-time = "2025-06-09T22:54:09.228Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/ce/e96392460f9fb68461fabab3e095cb00c8ddf901205be4eae5ce246e5b7e/propcache-0.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be29c4f4810c5789cf10ddf6af80b041c724e629fa51e308a7a0fb19ed1ef7bf", size = 217288, upload-time = "2025-06-09T22:54:10.466Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/2a/866726ea345299f7ceefc861a5e782b045545ae6940851930a6adaf1fca6/propcache-0.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59d61f6970ecbd8ff2e9360304d5c8876a6abd4530cb752c06586849ac8a9dc9", size = 227456, upload-time = "2025-06-09T22:54:11.828Z" },
-    { url = "https://files.pythonhosted.org/packages/de/03/07d992ccb6d930398689187e1b3c718339a1c06b8b145a8d9650e4726166/propcache-0.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:62180e0b8dbb6b004baec00a7983e4cc52f5ada9cd11f48c3528d8cfa7b96a66", size = 225429, upload-time = "2025-06-09T22:54:13.823Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/e6/116ba39448753b1330f48ab8ba927dcd6cf0baea8a0ccbc512dfb49ba670/propcache-0.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c144ca294a204c470f18cf4c9d78887810d04a3e2fbb30eea903575a779159df", size = 213472, upload-time = "2025-06-09T22:54:15.232Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/85/f01f5d97e54e428885a5497ccf7f54404cbb4f906688a1690cd51bf597dc/propcache-0.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5c2a784234c28854878d68978265617aa6dc0780e53d44b4d67f3651a17a9a2", size = 204480, upload-time = "2025-06-09T22:54:17.104Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/79/7bf5ab9033b8b8194cc3f7cf1aaa0e9c3256320726f64a3e1f113a812dce/propcache-0.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5745bc7acdafa978ca1642891b82c19238eadc78ba2aaa293c6863b304e552d7", size = 214530, upload-time = "2025-06-09T22:54:18.512Z" },
-    { url = "https://files.pythonhosted.org/packages/31/0b/bd3e0c00509b609317df4a18e6b05a450ef2d9a963e1d8bc9c9415d86f30/propcache-0.3.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:c0075bf773d66fa8c9d41f66cc132ecc75e5bb9dd7cce3cfd14adc5ca184cb95", size = 205230, upload-time = "2025-06-09T22:54:19.947Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/23/fae0ff9b54b0de4e819bbe559508da132d5683c32d84d0dc2ccce3563ed4/propcache-0.3.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5f57aa0847730daceff0497f417c9de353c575d8da3579162cc74ac294c5369e", size = 206754, upload-time = "2025-06-09T22:54:21.716Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/7f/ad6a3c22630aaa5f618b4dc3c3598974a72abb4c18e45a50b3cdd091eb2f/propcache-0.3.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:eef914c014bf72d18efb55619447e0aecd5fb7c2e3fa7441e2e5d6099bddff7e", size = 218430, upload-time = "2025-06-09T22:54:23.17Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/2c/ba4f1c0e8a4b4c75910742f0d333759d441f65a1c7f34683b4a74c0ee015/propcache-0.3.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2a4092e8549031e82facf3decdbc0883755d5bbcc62d3aea9d9e185549936dcf", size = 223884, upload-time = "2025-06-09T22:54:25.539Z" },
-    { url = "https://files.pythonhosted.org/packages/88/e4/ebe30fc399e98572019eee82ad0caf512401661985cbd3da5e3140ffa1b0/propcache-0.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:85871b050f174bc0bfb437efbdb68aaf860611953ed12418e4361bc9c392749e", size = 211480, upload-time = "2025-06-09T22:54:26.892Z" },
-    { url = "https://files.pythonhosted.org/packages/96/0a/7d5260b914e01d1d0906f7f38af101f8d8ed0dc47426219eeaf05e8ea7c2/propcache-0.3.2-cp311-cp311-win32.whl", hash = "sha256:36c8d9b673ec57900c3554264e630d45980fd302458e4ac801802a7fd2ef7897", size = 37757, upload-time = "2025-06-09T22:54:28.241Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/2d/89fe4489a884bc0da0c3278c552bd4ffe06a1ace559db5ef02ef24ab446b/propcache-0.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53af8cb6a781b02d2ea079b5b853ba9430fcbe18a8e3ce647d5982a3ff69f39", size = 41500, upload-time = "2025-06-09T22:54:29.4Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/42/9ca01b0a6f48e81615dca4765a8f1dd2c057e0540f6116a27dc5ee01dfb6/propcache-0.3.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8de106b6c84506b31c27168582cd3cb3000a6412c16df14a8628e5871ff83c10", size = 73674, upload-time = "2025-06-09T22:54:30.551Z" },
-    { url = "https://files.pythonhosted.org/packages/af/6e/21293133beb550f9c901bbece755d582bfaf2176bee4774000bd4dd41884/propcache-0.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:28710b0d3975117239c76600ea351934ac7b5ff56e60953474342608dbbb6154", size = 43570, upload-time = "2025-06-09T22:54:32.296Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/c8/0393a0a3a2b8760eb3bde3c147f62b20044f0ddac81e9d6ed7318ec0d852/propcache-0.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce26862344bdf836650ed2487c3d724b00fbfec4233a1013f597b78c1cb73615", size = 43094, upload-time = "2025-06-09T22:54:33.929Z" },
-    { url = "https://files.pythonhosted.org/packages/37/2c/489afe311a690399d04a3e03b069225670c1d489eb7b044a566511c1c498/propcache-0.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bca54bd347a253af2cf4544bbec232ab982f4868de0dd684246b67a51bc6b1db", size = 226958, upload-time = "2025-06-09T22:54:35.186Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/ca/63b520d2f3d418c968bf596839ae26cf7f87bead026b6192d4da6a08c467/propcache-0.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55780d5e9a2ddc59711d727226bb1ba83a22dd32f64ee15594b9392b1f544eb1", size = 234894, upload-time = "2025-06-09T22:54:36.708Z" },
-    { url = "https://files.pythonhosted.org/packages/11/60/1d0ed6fff455a028d678df30cc28dcee7af77fa2b0e6962ce1df95c9a2a9/propcache-0.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:035e631be25d6975ed87ab23153db6a73426a48db688070d925aa27e996fe93c", size = 233672, upload-time = "2025-06-09T22:54:38.062Z" },
-    { url = "https://files.pythonhosted.org/packages/37/7c/54fd5301ef38505ab235d98827207176a5c9b2aa61939b10a460ca53e123/propcache-0.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ee6f22b6eaa39297c751d0e80c0d3a454f112f5c6481214fcf4c092074cecd67", size = 224395, upload-time = "2025-06-09T22:54:39.634Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/1a/89a40e0846f5de05fdc6779883bf46ba980e6df4d2ff8fb02643de126592/propcache-0.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ca3aee1aa955438c4dba34fc20a9f390e4c79967257d830f137bd5a8a32ed3b", size = 212510, upload-time = "2025-06-09T22:54:41.565Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/33/ca98368586c9566a6b8d5ef66e30484f8da84c0aac3f2d9aec6d31a11bd5/propcache-0.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7a4f30862869fa2b68380d677cc1c5fcf1e0f2b9ea0cf665812895c75d0ca3b8", size = 222949, upload-time = "2025-06-09T22:54:43.038Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/11/ace870d0aafe443b33b2f0b7efdb872b7c3abd505bfb4890716ad7865e9d/propcache-0.3.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b77ec3c257d7816d9f3700013639db7491a434644c906a2578a11daf13176251", size = 217258, upload-time = "2025-06-09T22:54:44.376Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/d2/86fd6f7adffcfc74b42c10a6b7db721d1d9ca1055c45d39a1a8f2a740a21/propcache-0.3.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cab90ac9d3f14b2d5050928483d3d3b8fb6b4018893fc75710e6aa361ecb2474", size = 213036, upload-time = "2025-06-09T22:54:46.243Z" },
-    { url = "https://files.pythonhosted.org/packages/07/94/2d7d1e328f45ff34a0a284cf5a2847013701e24c2a53117e7c280a4316b3/propcache-0.3.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:0b504d29f3c47cf6b9e936c1852246c83d450e8e063d50562115a6be6d3a2535", size = 227684, upload-time = "2025-06-09T22:54:47.63Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/05/37ae63a0087677e90b1d14710e532ff104d44bc1efa3b3970fff99b891dc/propcache-0.3.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:ce2ac2675a6aa41ddb2a0c9cbff53780a617ac3d43e620f8fd77ba1c84dcfc06", size = 234562, upload-time = "2025-06-09T22:54:48.982Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/7c/3f539fcae630408d0bd8bf3208b9a647ccad10976eda62402a80adf8fc34/propcache-0.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:62b4239611205294cc433845b914131b2a1f03500ff3c1ed093ed216b82621e1", size = 222142, upload-time = "2025-06-09T22:54:50.424Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/d2/34b9eac8c35f79f8a962546b3e97e9d4b990c420ee66ac8255d5d9611648/propcache-0.3.2-cp312-cp312-win32.whl", hash = "sha256:df4a81b9b53449ebc90cc4deefb052c1dd934ba85012aa912c7ea7b7e38b60c1", size = 37711, upload-time = "2025-06-09T22:54:52.072Z" },
-    { url = "https://files.pythonhosted.org/packages/19/61/d582be5d226cf79071681d1b46b848d6cb03d7b70af7063e33a2787eaa03/propcache-0.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:7046e79b989d7fe457bb755844019e10f693752d169076138abf17f31380800c", size = 41479, upload-time = "2025-06-09T22:54:53.234Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/35/cc0aaecf278bb4575b8555f2b137de5ab821595ddae9da9d3cd1da4072c7/propcache-0.3.2-py3-none-any.whl", hash = "sha256:98f1ec44fb675f5052cccc8e609c46ed23a35a1cfd18545ad4e29002d858a43f", size = 12663, upload-time = "2025-06-09T22:56:04.484Z" },
+version = "0.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/44/c87281c333769159c50594f22610f77398a47ccbfbbf23074e744e86f87c/propcache-0.5.2.tar.gz", hash = "sha256:01c4fc7480cd0598bb4b57022df55b9ca296da7fc5a8760bd8451a7e63a7d427", size = 50208, upload-time = "2026-05-08T21:02:12.199Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/f1/8a8cc1c2c7e7934ab77e0163414f736fadbc0f5e8dd9673b952355ac175b/propcache-0.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:74b70780220e2dd89175ca24b81b68b67c83db499ae611e7f2313cb329801c78", size = 90744, upload-time = "2026-05-08T20:59:45.799Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/f4/651b1225e976bd1a2ba5cfba0c29d096581c2636b437e3a9a7ab6276270a/propcache-0.5.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a4840ab0ae0216d952f4b53dc6d0b992bfc2bedbfe360bdd9b548bc184c08959", size = 52033, upload-time = "2026-05-08T20:59:47.408Z" },
+    { url = "https://files.pythonhosted.org/packages/15/a8/8ede85d6aa1f79fc7dc2f8fd2c8d65920b8272c3892903c8a1affde48cfb/propcache-0.5.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c6844ba6364fb12f403928a82cfd295ab103a2b315c77c747b2dbe4a41894ea7", size = 52754, upload-time = "2026-05-08T20:59:49.202Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/fe/b3551b41bbc2f5b5bb088fc6920567cd43101253e68fbaa261339eb96fe1/propcache-0.5.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2293949b855ce597f2826452d17c2d545fb5622379c4ea6fdf525e9b8e8a2511", size = 57573, upload-time = "2026-05-08T20:59:50.778Z" },
+    { url = "https://files.pythonhosted.org/packages/83/27/ab851ebd1b7172e3e161f5f8d39e315d54a91bea246f01f4d872d3376aef/propcache-0.5.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0fd59b5af35f74da48d905dcbad55449ba13be91823cb05a9bd590bbf5b61660", size = 60645, upload-time = "2026-05-08T20:59:52.227Z" },
+    { url = "https://files.pythonhosted.org/packages/95/7d/466b3d18022e9897cbda9c735c493c5bd747d7a4c6f5ea1480b4cec434b6/propcache-0.5.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29f9309a2e42b0d273be006fdb4be2d6c39a47f6f57d8fb1cf9f81481df81b66", size = 61563, upload-time = "2026-05-08T20:59:53.866Z" },
+    { url = "https://files.pythonhosted.org/packages/27/1b/16ab7f2cf2041da2f60d156ba64c2484eadf9168075b4ff43c3ef60045af/propcache-0.5.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5aaa2b923c1944ac8febd6609cb373540a5563e7cbcb0fd770f75dace2eb817b", size = 58888, upload-time = "2026-05-08T20:59:55.457Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/67/bb777ffd907633563bf35fd859c4ce97b0512c32f4633cf5d1eb7c33512b/propcache-0.5.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66ea454f095ddf5b6b14f56c064c0941c4788be11e18d2464cf643bf7203ff67", size = 59253, upload-time = "2026-05-08T20:59:57.075Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/42/64f8d90b73fd9cdc1499b48057ff6d9cd2a98a25734c9bb62ecf07e87061/propcache-0.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:95f1e3f4760d404b13c9976c0229b2b49a3c8e2c62a9ce92efdd2b11ada75e3f", size = 57558, upload-time = "2026-05-08T20:59:58.602Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/02/dba5bc03c9041f2092ea55a449caf5dfe68352c6654511b29ba0654ddb69/propcache-0.5.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:85341b12b9d55bad0bded24cac341bb34289469e03a11f3f583ea1cc1db0326c", size = 55007, upload-time = "2026-05-08T20:59:59.837Z" },
+    { url = "https://files.pythonhosted.org/packages/14/c0/43f649c7aa2a77a3b100d84e9dea3a483120ecb608bfe36ce49eaff517fe/propcache-0.5.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:26a4dca084132874e639895c3135dfad5eb20bae209f62d1aeb31b03e601c3c0", size = 60355, upload-time = "2026-05-08T21:00:01.144Z" },
+    { url = "https://files.pythonhosted.org/packages/83/c0/435dafd27f1cb4a495381dae60e25883ccfe4020bb72818e8184c1678092/propcache-0.5.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3b199b9b2b3d6a7edf3183ba8a9a137a22b97f7df525feb5ae1eccf026d2a9c6", size = 59057, upload-time = "2026-05-08T21:00:02.401Z" },
+    { url = "https://files.pythonhosted.org/packages/53/ae/6e292df9135d659944e96cb3389258e4a663e5b2b5f6c217ef0ddc8d2f73/propcache-0.5.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e59bc9e66329185b93dab73f210f1a37f81cb40f321501db8017c9aea15dba27", size = 61938, upload-time = "2026-05-08T21:00:03.638Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/42/314ebc50d8159055411fd6b0bda322ff510e4b1f7d2e4927940ad0f6af20/propcache-0.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:552ffadf6ad409844bc5919c42a0a83d88314cedddaea0e41e80a8b8fffe881f", size = 59731, upload-time = "2026-05-08T21:00:04.881Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/9b/2da6dee38871c3c8772fabc2758325a5c9077d6d18c597737dc04dd884cd/propcache-0.5.2-cp311-cp311-win32.whl", hash = "sha256:cd416c1de191973c52ff1a12a57446bfc7642797b282d7caf2162d7d1b8aa9a0", size = 38966, upload-time = "2026-05-08T21:00:06.511Z" },
+    { url = "https://files.pythonhosted.org/packages/42/4e/f17363fb58c0afe05b067361cb6d86ed2d29de6506779a27547c4d183075/propcache-0.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:44e488ef40dbb452700b2b1f8188934121f6648f52c295055662d2191959ff82", size = 42135, upload-time = "2026-05-08T21:00:08.088Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/eb/6af6685077d22e8b33358d3c548e3282706a0b3cd85044ffba4e5dd08e3b/propcache-0.5.2-cp311-cp311-win_arm64.whl", hash = "sha256:54adaa85a22078d1e306304a40984dc5be99d599bf3dc0a24dc98f7daeab89ab", size = 38381, upload-time = "2026-05-08T21:00:09.692Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/cb/e27bc2b2737a0bb49962b275efa051e8f1c35a936df7d5139b6b658b7dc9/propcache-0.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:806719138ecd720339a12410fb9614ac9b2b2d3a5fdf8235d56981c36f4039ba", size = 95887, upload-time = "2026-05-08T21:00:11.277Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/13/b8ae04c59392f8d11c6cd9fb4011d1dc7c86b81225c770280300e259ffe1/propcache-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:db2b80ea58eab4f86b2beec3cc8b39e8ff9276ac20e96b7cce43c8ae84cd6b5a", size = 54654, upload-time = "2026-05-08T21:00:12.604Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/7d/49777a3e20b55863d4794384a38acd460c04157b0a00f8602b0d508b8431/propcache-0.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e5cbfac9f61484f7e9f3597775500cd3ebe8274e9b050c38f9525c77c97520bf", size = 55190, upload-time = "2026-05-08T21:00:13.935Z" },
+    { url = "https://files.pythonhosted.org/packages/44/c7/085d0cd63062e84044e3f05797749c3f8e3938ff3aeb0eb2f69d43fafc91/propcache-0.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbc581d2814337da56222fab8dc5f161cd798a434e49bac27930aaef798e144", size = 59995, upload-time = "2026-05-08T21:00:15.526Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/42/32cf8e3009e92b2645cf1e944f701e8ea4e924dffde1ee26db860bcbf7e4/propcache-0.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:857187f381f88c8e2fa2fe56ab94879d011b883d5a2ee5a1b60a8cd2a06846d9", size = 63422, upload-time = "2026-05-08T21:00:16.824Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/1b/f112433f99fc979431b87a39ef169e3f8df070d99a72792c56d6937ac48b/propcache-0.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:178b4a2cdaac1818e2bf1c5a99b94383fa73ea5382e032a48dec07dc5668dc42", size = 64342, upload-time = "2026-05-08T21:00:18.362Z" },
+    { url = "https://files.pythonhosted.org/packages/14/15/5574111ae50dd6e879456888c0eadd4c5a869959775854e18e18a6b345f3/propcache-0.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f328175a2cde1f0ff2c4ed8ce968b9dcfb55f3a7153f39e2957ed994da13476", size = 61639, upload-time = "2026-05-08T21:00:19.692Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/da/4d775080b1490c0ae604acda868bd71aabe3a89ed16f2aa4339eb8a283e7/propcache-0.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5671d09a36b06d0fd4a3da0fccbcae360e9b1570924171a15e9e0997f0249fba", size = 61588, upload-time = "2026-05-08T21:00:21.155Z" },
+    { url = "https://files.pythonhosted.org/packages/04/ac/f076982cbe2195ee9cf32de5a1e46951d9fb399fc207f390562dd0fd8fb2/propcache-0.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80168e2ebe4d3ec6599d10ad8f520304ae1cad9b6c5a95372aef1b66b7bfb53a", size = 60029, upload-time = "2026-05-08T21:00:22.713Z" },
+    { url = "https://files.pythonhosted.org/packages/70/60/189be62e0dd898dce3b331e1b8c7a543cd3a405ac0c81fe8ee8a9d5d77e1/propcache-0.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:45f11346f884bc47444f6e6647131055844134c3175b629f84952e2b5cd62b64", size = 56774, upload-time = "2026-05-08T21:00:24.001Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/9e/93377b9c7939c1ffae98f878dee955efadfd638078bc86dbc21f9d52f651/propcache-0.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e778ebd44ef4f66ed60a0416b06b489687db264a9c0b3620362f26489492913", size = 63532, upload-time = "2026-05-08T21:00:25.545Z" },
+    { url = "https://files.pythonhosted.org/packages/14/f9/590ef6cfb9b8028d516d287812ece32bb0bc5f11fbb9c8bf6b2e6313fec8/propcache-0.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c0cb9ed24c8964e172768d455a38254c2dd8a552905729ce006cad3d3dda59b1", size = 61592, upload-time = "2026-05-08T21:00:27.186Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/5e/70958b3034c297a630bba2f17ca7abc2d5f39a803ad7e370ab79d1ecd022/propcache-0.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1d1ad32d9d4355e2be65574fd0bfd3677e7066b009cd5b9b2dee8aa6a6393b33", size = 64788, upload-time = "2026-05-08T21:00:28.8Z" },
+    { url = "https://files.pythonhosted.org/packages/12/fd/77fe5936d8c3086ca9048f7f415f122ed82e53884a9ec193646b42deef06/propcache-0.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c80f4ba3e8f00189165999a742ee526ebeccedf6c3f7beb0c7df821e9772435a", size = 62514, upload-time = "2026-05-08T21:00:30.098Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/74/66bd798b5b3be70aa1b391f5cc9d6a0a5532d7fd3b19ec0b213e72e6ad9d/propcache-0.5.2-cp312-cp312-win32.whl", hash = "sha256:8c7972d8f193740d9175f0998ab38717e6cd322d5935c5b0fef8c0d323fd9031", size = 39018, upload-time = "2026-05-08T21:00:31.622Z" },
+    { url = "https://files.pythonhosted.org/packages/61/7c/5c0d34aa3024694d6dcb9271cdbdd08c4e47c1c0ad95ec7e7bc74cdea145/propcache-0.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:d9ee8826a7d47863a08ac44e1a5f611a462eefc3a194b492da242128bec75b42", size = 42322, upload-time = "2026-05-08T21:00:32.918Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/91/875812f1a3feb20ceba818ef39fbe4d92f1081e04ac815c822496d0d038b/propcache-0.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:2800a4a8ead6b28cccd1ec54b59346f0def7922ee1c7598e8499c733cfbb7c84", size = 38172, upload-time = "2026-05-08T21:00:35.124Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/ed/1cdcab6ba3d6ab7feca11fc14f0eeea80755bb53ef4e892079f31b10a25f/propcache-0.5.2-py3-none-any.whl", hash = "sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe", size = 14036, upload-time = "2026-05-08T21:02:10.673Z" },
 ]
 
 [[package]]
 name = "protobuf"
-version = "6.32.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fa/a4/cc17347aa2897568beece2e674674359f911d6fe21b0b8d6268cd42727ac/protobuf-6.32.1.tar.gz", hash = "sha256:ee2469e4a021474ab9baafea6cd070e5bf27c7d29433504ddea1a4ee5850f68d", size = 440635, upload-time = "2025-09-11T21:38:42.935Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c0/98/645183ea03ab3995d29086b8bf4f7562ebd3d10c9a4b14ee3f20d47cfe50/protobuf-6.32.1-cp310-abi3-win32.whl", hash = "sha256:a8a32a84bc9f2aad712041b8b366190f71dde248926da517bde9e832e4412085", size = 424411, upload-time = "2025-09-11T21:38:27.427Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/f3/6f58f841f6ebafe076cebeae33fc336e900619d34b1c93e4b5c97a81fdfa/protobuf-6.32.1-cp310-abi3-win_amd64.whl", hash = "sha256:b00a7d8c25fa471f16bc8153d0e53d6c9e827f0953f3c09aaa4331c718cae5e1", size = 435738, upload-time = "2025-09-11T21:38:30.959Z" },
-    { url = "https://files.pythonhosted.org/packages/10/56/a8a3f4e7190837139e68c7002ec749190a163af3e330f65d90309145a210/protobuf-6.32.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d8c7e6eb619ffdf105ee4ab76af5a68b60a9d0f66da3ea12d1640e6d8dab7281", size = 426454, upload-time = "2025-09-11T21:38:34.076Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/be/8dd0a927c559b37d7a6c8ab79034fd167dcc1f851595f2e641ad62be8643/protobuf-6.32.1-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:2f5b80a49e1eb7b86d85fcd23fe92df154b9730a725c3b38c4e43b9d77018bf4", size = 322874, upload-time = "2025-09-11T21:38:35.509Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/f6/88d77011b605ef979aace37b7703e4eefad066f7e84d935e5a696515c2dd/protobuf-6.32.1-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:b1864818300c297265c83a4982fd3169f97122c299f56a56e2445c3698d34710", size = 322013, upload-time = "2025-09-11T21:38:37.017Z" },
-    { url = "https://files.pythonhosted.org/packages/97/b7/15cc7d93443d6c6a84626ae3258a91f4c6ac8c0edd5df35ea7658f71b79c/protobuf-6.32.1-py3-none-any.whl", hash = "sha256:2601b779fc7d32a866c6b4404f9d42a3f67c5b9f3f15b4db3cccabe06b95c346", size = 169289, upload-time = "2025-09-11T21:38:41.234Z" },
-]
-
-[[package]]
-name = "pyasn1"
-version = "0.6.1"
+version = "6.33.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322, upload-time = "2024-09-10T22:41:42.55Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", hash = "sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135", size = 444531, upload-time = "2026-03-18T19:05:00.988Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135, upload-time = "2024-09-11T16:00:36.122Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/9f/2f509339e89cfa6f6a4c4ff50438db9ca488dec341f7e454adad60150b00/protobuf-6.33.6-cp310-abi3-win32.whl", hash = "sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3", size = 425739, upload-time = "2026-03-18T19:04:48.373Z" },
+    { url = "https://files.pythonhosted.org/packages/76/5d/683efcd4798e0030c1bab27374fd13a89f7c2515fb1f3123efdfaa5eab57/protobuf-6.33.6-cp310-abi3-win_amd64.whl", hash = "sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326", size = 437089, upload-time = "2026-03-18T19:04:50.381Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/01/a3c3ed5cd186f39e7880f8303cc51385a198a81469d53d0fdecf1f64d929/protobuf-6.33.6-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a", size = 427737, upload-time = "2026-03-18T19:04:51.866Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2", size = 324610, upload-time = "2026-03-18T19:04:53.096Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/ca/25afc144934014700c52e05103c2421997482d561f3101ff352e1292fb81/protobuf-6.33.6-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3", size = 339381, upload-time = "2026-03-18T19:04:54.616Z" },
+    { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593", size = 323436, upload-time = "2026-03-18T19:04:55.768Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" },
 ]
 
 [[package]]
-name = "pyasn1-modules"
-version = "0.4.2"
+name = "py-walk"
+version = "0.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pyasn1" },
+    { name = "sly" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892, upload-time = "2025-03-28T02:41:22.17Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b3/b5/e2f3fab1e11d4089b1c3dfd72175fdb2408ff8028e01bdb0d308923609bb/py_walk-0.3.3.tar.gz", hash = "sha256:a1b28d6079f27203fa3098b69a98572675b3ff5bd02286c43e6dacd66615f879", size = 1815727, upload-time = "2024-10-26T14:30:39.421Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259, upload-time = "2025-03-28T02:41:19.028Z" },
+    { url = "https://files.pythonhosted.org/packages/27/38/56b67abdbf6797475dfe2f62d391b4a6ead851c76acbaf07e118e53651b6/py_walk-0.3.3-py3-none-any.whl", hash = "sha256:238fc018165138021ce0bfd9c351cdc473d3120ccc5534df35611b92608c94d5", size = 14537, upload-time = "2024-10-26T14:30:38.06Z" },
 ]
 
 [[package]]
 name = "pycparser"
-version = "2.23"
+version = "3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
 ]
 
 [[package]]
 name = "pydantic"
-version = "2.11.9"
+version = "2.13.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-types" },
@@ -2161,164 +2168,94 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ff/5d/09a551ba512d7ca404d785072700d3f6727a02f6f3c24ecfd081c7cf0aa8/pydantic-2.11.9.tar.gz", hash = "sha256:6b8ffda597a14812a7975c90b82a8a2e777d9257aba3453f973acd3c032a18e2", size = 788495, upload-time = "2025-09-13T11:26:39.325Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3e/d3/108f2006987c58e76691d5ae5d200dd3e0f532cb4e5fa3560751c3a1feba/pydantic-2.11.9-py3-none-any.whl", hash = "sha256:c42dd626f5cfc1c6950ce6205ea58c93efa406da65f479dcb4029d5934857da2", size = 444855, upload-time = "2025-09-13T11:26:36.909Z" },
-]
-
-[[package]]
-name = "pydantic-ai"
-version = "1.0.15"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pydantic-ai-slim", extra = ["ag-ui", "anthropic", "bedrock", "cli", "cohere", "evals", "google", "groq", "huggingface", "logfire", "mcp", "mistral", "openai", "retries", "temporal", "vertexai"] },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3a/17/6de11e398a8ab91eb204ac2110c574675f0ad1dd31fe06ef1b19bee3fa40/pydantic_ai-1.0.15.tar.gz", hash = "sha256:2798f70ef53b056e486f1b2ff661820cbc6bc9990e022ba1393f79ab2684535c", size = 100447681, upload-time = "2025-10-03T23:49:27.801Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/15/d3/b8f112c0e56523d3e62c849c3063337384bbd3c6941ca1f23d086f4429cb/pydantic_ai-1.0.15-py3-none-any.whl", hash = "sha256:b1c2e055f13bf5c89fc18bb764b5b3564416922082df53f5d812ad1fc0bc5d9e", size = 11677, upload-time = "2025-10-03T23:49:18.263Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" },
 ]
 
 [[package]]
 name = "pydantic-ai-slim"
-version = "1.0.15"
+version = "1.98.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "genai-prices" },
-    { name = "griffe" },
+    { name = "griffelib" },
     { name = "httpx" },
     { name = "opentelemetry-api" },
     { name = "pydantic" },
     { name = "pydantic-graph" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/56/2d/b8dda22ffe532df5ee73f73c0a359900a4525c8f8f03c19cf7509af31eab/pydantic_ai_slim-1.0.15.tar.gz", hash = "sha256:45141ad0b0e76a6473d006ccb191874218b15504f3a9133be7be1274e4de2b51", size = 262510, upload-time = "2025-10-03T23:49:33.743Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3b/cf/a35a7a3bcc04d703bff2f25af25c4d82b70f2f13693b0f3fcc9b5a9d350c/pydantic_ai_slim-1.98.0.tar.gz", hash = "sha256:688599356638fe160cd22856ea0ad43b26c056f22929caf68cb3419fe41135a3", size = 720662, upload-time = "2026-05-19T01:08:27.909Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bb/dd/66cf84d6a9ac175d2c0511d0600d08396fc713b3f86ab96364760e0e9310/pydantic_ai_slim-1.0.15-py3-none-any.whl", hash = "sha256:f6f2d556d40ddb8419d7936b8d4513952a4c9ddea43f257880bf8b963d36b87a", size = 344917, upload-time = "2025-10-03T23:49:21.326Z" },
+    { url = "https://files.pythonhosted.org/packages/93/a7/472f305cabc42e60971b11499057b07999af5bbe8e5d28df385077f27ae5/pydantic_ai_slim-1.98.0-py3-none-any.whl", hash = "sha256:edfcd6e0b44d2726500f1e753967e71286d13138585562ef8a7ad25c9b8d460e", size = 894760, upload-time = "2026-05-19T01:08:18.967Z" },
 ]
 
 [package.optional-dependencies]
-ag-ui = [
-    { name = "ag-ui-protocol" },
-    { name = "starlette" },
-]
 anthropic = [
     { name = "anthropic" },
 ]
-bedrock = [
-    { name = "boto3" },
-]
-cli = [
-    { name = "argcomplete" },
-    { name = "prompt-toolkit" },
-    { name = "pyperclip" },
-    { name = "rich" },
-]
-cohere = [
-    { name = "cohere", marker = "sys_platform != 'emscripten'" },
-]
-evals = [
-    { name = "pydantic-evals" },
-]
-google = [
-    { name = "google-genai" },
-]
-groq = [
-    { name = "groq" },
-]
-huggingface = [
-    { name = "huggingface-hub", extra = ["inference"] },
-]
-logfire = [
-    { name = "logfire", extra = ["httpx"] },
-]
-mcp = [
-    { name = "mcp" },
-]
-mistral = [
-    { name = "mistralai" },
-]
-openai = [
-    { name = "openai" },
-]
-retries = [
-    { name = "tenacity" },
-]
-temporal = [
-    { name = "temporalio" },
-]
-vertexai = [
-    { name = "google-auth" },
-    { name = "requests" },
-]
 
 [[package]]
 name = "pydantic-core"
-version = "2.33.2"
+version = "2.46.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/8d/71db63483d518cbbf290261a1fc2839d17ff89fce7089e08cad07ccfce67/pydantic_core-2.33.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4c5b0a576fb381edd6d27f0a85915c6daf2f8138dc5c267a57c08a62900758c7", size = 2028584, upload-time = "2025-04-23T18:31:03.106Z" },
-    { url = "https://files.pythonhosted.org/packages/24/2f/3cfa7244ae292dd850989f328722d2aef313f74ffc471184dc509e1e4e5a/pydantic_core-2.33.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e799c050df38a639db758c617ec771fd8fb7a5f8eaaa4b27b101f266b216a246", size = 1855071, upload-time = "2025-04-23T18:31:04.621Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/d3/4ae42d33f5e3f50dd467761304be2fa0a9417fbf09735bc2cce003480f2a/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dc46a01bf8d62f227d5ecee74178ffc448ff4e5197c756331f71efcc66dc980f", size = 1897823, upload-time = "2025-04-23T18:31:06.377Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/f3/aa5976e8352b7695ff808599794b1fba2a9ae2ee954a3426855935799488/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a144d4f717285c6d9234a66778059f33a89096dfb9b39117663fd8413d582dcc", size = 1983792, upload-time = "2025-04-23T18:31:07.93Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/7a/cda9b5a23c552037717f2b2a5257e9b2bfe45e687386df9591eff7b46d28/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73cf6373c21bc80b2e0dc88444f41ae60b2f070ed02095754eb5a01df12256de", size = 2136338, upload-time = "2025-04-23T18:31:09.283Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/9f/b8f9ec8dd1417eb9da784e91e1667d58a2a4a7b7b34cf4af765ef663a7e5/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dc625f4aa79713512d1976fe9f0bc99f706a9dee21dfd1810b4bbbf228d0e8a", size = 2730998, upload-time = "2025-04-23T18:31:11.7Z" },
-    { url = "https://files.pythonhosted.org/packages/47/bc/cd720e078576bdb8255d5032c5d63ee5c0bf4b7173dd955185a1d658c456/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b21b5549499972441da4758d662aeea93f1923f953e9cbaff14b8b9565aef", size = 2003200, upload-time = "2025-04-23T18:31:13.536Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/22/3602b895ee2cd29d11a2b349372446ae9727c32e78a94b3d588a40fdf187/pydantic_core-2.33.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bdc25f3681f7b78572699569514036afe3c243bc3059d3942624e936ec93450e", size = 2113890, upload-time = "2025-04-23T18:31:15.011Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/e6/e3c5908c03cf00d629eb38393a98fccc38ee0ce8ecce32f69fc7d7b558a7/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fe5b32187cbc0c862ee201ad66c30cf218e5ed468ec8dc1cf49dec66e160cc4d", size = 2073359, upload-time = "2025-04-23T18:31:16.393Z" },
-    { url = "https://files.pythonhosted.org/packages/12/e7/6a36a07c59ebefc8777d1ffdaf5ae71b06b21952582e4b07eba88a421c79/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:bc7aee6f634a6f4a95676fcb5d6559a2c2a390330098dba5e5a5f28a2e4ada30", size = 2245883, upload-time = "2025-04-23T18:31:17.892Z" },
-    { url = "https://files.pythonhosted.org/packages/16/3f/59b3187aaa6cc0c1e6616e8045b284de2b6a87b027cce2ffcea073adf1d2/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:235f45e5dbcccf6bd99f9f472858849f73d11120d76ea8707115415f8e5ebebf", size = 2241074, upload-time = "2025-04-23T18:31:19.205Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/ed/55532bb88f674d5d8f67ab121a2a13c385df382de2a1677f30ad385f7438/pydantic_core-2.33.2-cp311-cp311-win32.whl", hash = "sha256:6368900c2d3ef09b69cb0b913f9f8263b03786e5b2a387706c5afb66800efd51", size = 1910538, upload-time = "2025-04-23T18:31:20.541Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/1b/25b7cccd4519c0b23c2dd636ad39d381abf113085ce4f7bec2b0dc755eb1/pydantic_core-2.33.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e063337ef9e9820c77acc768546325ebe04ee38b08703244c1309cccc4f1bab", size = 1952909, upload-time = "2025-04-23T18:31:22.371Z" },
-    { url = "https://files.pythonhosted.org/packages/49/a9/d809358e49126438055884c4366a1f6227f0f84f635a9014e2deb9b9de54/pydantic_core-2.33.2-cp311-cp311-win_arm64.whl", hash = "sha256:6b99022f1d19bc32a4c2a0d544fc9a76e3be90f0b3f4af413f87d38749300e65", size = 1897786, upload-time = "2025-04-23T18:31:24.161Z" },
-    { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" },
-    { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" },
-    { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" },
-    { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/27/d4ae6487d73948d6f20dddcd94be4ea43e74349b56eba82e9bdee2d7494c/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:dd14041875d09cc0f9308e37a6f8b65f5585cf2598a53aa0123df8b129d481f8", size = 2025200, upload-time = "2025-04-23T18:33:14.199Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/b8/b3cb95375f05d33801024079b9392a5ab45267a63400bf1866e7ce0f0de4/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d87c561733f66531dced0da6e864f44ebf89a8fba55f31407b00c2f7f9449593", size = 1859123, upload-time = "2025-04-23T18:33:16.555Z" },
-    { url = "https://files.pythonhosted.org/packages/05/bc/0d0b5adeda59a261cd30a1235a445bf55c7e46ae44aea28f7bd6ed46e091/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f82865531efd18d6e07a04a17331af02cb7a651583c418df8266f17a63c6612", size = 1892852, upload-time = "2025-04-23T18:33:18.513Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/11/d37bdebbda2e449cb3f519f6ce950927b56d62f0b84fd9cb9e372a26a3d5/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bfb5112df54209d820d7bf9317c7a6c9025ea52e49f46b6a2060104bba37de7", size = 2067484, upload-time = "2025-04-23T18:33:20.475Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/55/1f95f0a05ce72ecb02a8a8a1c3be0579bbc29b1d5ab68f1378b7bebc5057/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:64632ff9d614e5eecfb495796ad51b0ed98c453e447a76bcbeeb69615079fc7e", size = 2108896, upload-time = "2025-04-23T18:33:22.501Z" },
-    { url = "https://files.pythonhosted.org/packages/53/89/2b2de6c81fa131f423246a9109d7b2a375e83968ad0800d6e57d0574629b/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:f889f7a40498cc077332c7ab6b4608d296d852182211787d4f3ee377aaae66e8", size = 2069475, upload-time = "2025-04-23T18:33:24.528Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/e9/1f7efbe20d0b2b10f6718944b5d8ece9152390904f29a78e68d4e7961159/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:de4b83bb311557e439b9e186f733f6c645b9417c84e2eb8203f3f820a4b988bf", size = 2239013, upload-time = "2025-04-23T18:33:26.621Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/b2/5309c905a93811524a49b4e031e9851a6b00ff0fb668794472ea7746b448/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:82f68293f055f51b51ea42fafc74b6aad03e70e191799430b90c13d643059ebb", size = 2238715, upload-time = "2025-04-23T18:33:28.656Z" },
-    { url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757, upload-time = "2025-04-23T18:33:30.645Z" },
-]
-
-[[package]]
-name = "pydantic-evals"
-version = "1.0.15"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "logfire-api" },
-    { name = "pydantic" },
-    { name = "pydantic-ai-slim" },
-    { name = "pyyaml" },
-    { name = "rich" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/81/45/f5dc751d08a2e75b85aa9d99197ee6bd085ccf52b9abbafc8442fbbe1bcf/pydantic_evals-1.0.15.tar.gz", hash = "sha256:271fd12233bf6c98e92a3d31f2968c15a36ccf267b205c2f9c31437ed01bee08", size = 45868, upload-time = "2025-10-03T23:49:34.78Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d5/45/cb23f25a72c92ac62f9b403c7e3acdf8f791ca71b7afbeb821b2ad9ec30c/pydantic_evals-1.0.15-py3-none-any.whl", hash = "sha256:4bf0a39a8d55bfc41d39da0bfb6d3d4e86560f9e7040f61b8df1155a08694ea2", size = 55015, upload-time = "2025-10-03T23:49:23.002Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/fa/6d7708d2cfc1a832acb6aeb0cd16e801902df8a0f583bb3b4b527fde022e/pydantic_core-2.46.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0e96592440881c74a213e5ad528e2b24d3d4f940de2766bed9010ab1d9e51594", size = 2111872, upload-time = "2026-05-06T13:40:27.596Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/6f/aa064a3e74b5745afbdf250594f38e7ead05e2d651bcb35994b9417a0d4d/pydantic_core-2.46.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e0d65b8c354be7fb5f720c3caa8bc940bc2d20ce749c8e06135f07f8ed95dd7c", size = 1948255, upload-time = "2026-05-06T13:39:12.574Z" },
+    { url = "https://files.pythonhosted.org/packages/43/3a/41114a9f7569b84b4d84e7a018c57c56347dac30c0d4a872946ec4e36c46/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bfb192b3f4b9e8a89b6277b6ce787564f62cfd272055f6e685726b111dc7826", size = 1972827, upload-time = "2026-05-06T13:38:19.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/25/1ab42e8048fe551934d9884e8d64daa7e990ad386f310a15981aeb6a5b08/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9037063db01f09b09e237c282b6792bd4da634b5402c4e7f0c61effed7701a04", size = 2041051, upload-time = "2026-05-06T13:38:10.447Z" },
+    { url = "https://files.pythonhosted.org/packages/94/c2/1a934597ddf08da410385b3b7aae91956a5a76c635effef456074fad7e88/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc010ab034c8c7452522748bf937df58020d256ccae0874463d1f4d01758af8e", size = 2221314, upload-time = "2026-05-06T13:40:13.089Z" },
+    { url = "https://files.pythonhosted.org/packages/02/6d/9e8ad178c9c4df27ad3c8f25d1fe2a7ab0d2ba0559fad4aee5d3d1f16771/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c5dac79fa1614d1e06ca695109c6105923bd9c7d1d6c918d4e637b7e6b32fd3", size = 2285146, upload-time = "2026-05-06T13:38:59.224Z" },
+    { url = "https://files.pythonhosted.org/packages/80/50/540cd3aeefc041beb111125c4bff779831a2111fc6b15a9138cda277d32c/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f9fa868638bf362d3d138ea55829cefb3d5f4b0d7f142234382a15e2485dbec4", size = 2089685, upload-time = "2026-05-06T13:38:17.762Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/a4/b440ad35f05f6a38f89fa0f149accb3f0e02be94ca5e15f3c449a61b4bc9/pydantic_core-2.46.4-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:17299feefe090f2caa5b8e37222bb5f663e4935a8bfa6931d4102e5df1a9f398", size = 2115420, upload-time = "2026-05-06T13:37:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/99/61/de4f55db8dfd57bfdfa9a12ec90fe1b57c4f41062f7ca86f08586b3e0ac0/pydantic_core-2.46.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4c63ebc82684aa89d9a3bcbd13d515b3be44250dc68dd3bd81526c1cb31286c3", size = 2165122, upload-time = "2026-05-06T13:37:01.167Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/52/7c529d7bdb2d1068bd52f51fe32572c8301f9a4febf1948f10639f1436f5/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:aaa2a54443eff1950ba5ddc6b6ccda0d9c84a364276a62f969bdf2a390650848", size = 2182573, upload-time = "2026-05-06T13:38:45.04Z" },
+    { url = "https://files.pythonhosted.org/packages/37/b3/7c40325848ba78247f2812dcf9c7274e38cd801820ca6dd9fe63bcfb0eb4/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:18e5ceec2ab67e6d5f1a9085e5a24c9c4e2ac4545730bfe668680bca05e555f3", size = 2317139, upload-time = "2026-05-06T13:37:15.539Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/37/f913f81a657c865b75da6c0dbed79876073c2a43b5bd9edbe8da785e4d49/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a0f62d0a58f4e7da165457e995725421e0064f2255d8eccebc49f41bbc23b109", size = 2360433, upload-time = "2026-05-06T13:37:30.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/67/6acaa1be2567f9256b056d8477158cac7240813956ce86e49deae8e173b4/pydantic_core-2.46.4-cp311-cp311-win32.whl", hash = "sha256:041bde0a48fd37cf71cab1c9d56d3e8625a3793fef1f7dd232b3ff37e978ecda", size = 1985513, upload-time = "2026-05-06T13:38:15.669Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/e6/c505f83dfeda9a2e5c995cfd872949e4d05e12f7feb3dca72f633daefa94/pydantic_core-2.46.4-cp311-cp311-win_amd64.whl", hash = "sha256:6f2eeda33a839975441c86a4119e1383c50b47faf0cbb5176985565c6bb02c33", size = 2071114, upload-time = "2026-05-06T13:40:35.416Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/da/7a263a96d965d9d0df5e8de8a475f33495451117035b09acb110288c381f/pydantic_core-2.46.4-cp311-cp311-win_arm64.whl", hash = "sha256:14f4c5d6db102bd796a627bbb3a17b4cf4574b9ae861d8b7c9a9661c6dd3362d", size = 2044298, upload-time = "2026-05-06T13:38:29.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" },
+    { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" },
+    { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" },
+    { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" },
+    { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" },
+    { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" },
+    { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/a4/73995fd4ebbb46ba0ee51e6fa049b8f02c40daebb762208feda8a6b7894d/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:14d4edf427bdcf950a8a02d7cb44a08614388dd6e1bdcbf4f67504fa7887da9c", size = 2111589, upload-time = "2026-05-06T13:37:10.817Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/7f/f37d3a5e8bfcc2e403f5c57a730f2d815693fb42119e8ea48b3789335af1/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0ce40cd7b21210e99342afafbd4d0f76d784eb5b1d60f3bdc566be4983c6c73b", size = 1944552, upload-time = "2026-05-06T13:36:56.717Z" },
+    { url = "https://files.pythonhosted.org/packages/15/3c/d7eb777b3ff43e8433a4efb39a17aa8fd98a4ee8561a24a67ef5db07b2d6/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:90884113d8b48f760e9587002789ddd741e76ab9f89518cd1e43b1f1a52ec44b", size = 1982984, upload-time = "2026-05-06T13:39:06.207Z" },
+    { url = "https://files.pythonhosted.org/packages/63/87/70b9f40170a81afd55ca26c9b2acb25c20d64bcfbf888fafecb3ba077d4c/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66ce7632c22d837c95301830e111ad0128a32b8207533b60896a96c4915192ea", size = 2138417, upload-time = "2026-05-06T13:39:45.476Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" },
+    { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" },
+    { url = "https://files.pythonhosted.org/packages/11/cb/428de0385b6c8d44b716feba566abfacfbd23ee3c4439faa789a1456242f/pydantic_core-2.46.4-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:0c563b08bca408dc7f65f700633d8442fffb2421fc47b8101377e9fd65051ff0", size = 2112782, upload-time = "2026-05-06T13:37:04.016Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/b5/6a17bdadd0fc1f170adfd05a20d37c832f52b117b4d9131da1f41bb097ce/pydantic_core-2.46.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:db06ffe51636ffe9ca531fe9023dd64bdd794be8754cb5df57c5498ae5b518a7", size = 1952146, upload-time = "2026-05-06T13:39:43.092Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/dc/03734d80e362cd43ef65428e9de77c730ce7f2f11c60d2b1e1b39f0fbf99/pydantic_core-2.46.4-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:133878133d271ade3d41d1bfb2a45ec38dbdbda40bc065921c6b04e4630127e2", size = 2134492, upload-time = "2026-05-06T13:36:58.124Z" },
+    { url = "https://files.pythonhosted.org/packages/de/df/5e5ffc085ed07cc22d298134d3d911c63e91f6a0eb91fe646750a3209910/pydantic_core-2.46.4-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9bc519fbf2b7578398853d815009ae5e4d4603d12f4e3f91da8c06852d3da3e9", size = 2156604, upload-time = "2026-05-06T13:37:49.88Z" },
+    { url = "https://files.pythonhosted.org/packages/81/44/6e112a4253e56f5705467cbab7ab5e91ee7398ba3d56d358635958893d3e/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:c7a7bd4e39e8e4c12c39cd480356842b6a8a06e41b23a55a5e3e191718838ddf", size = 2183828, upload-time = "2026-05-06T13:37:43.053Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/5565071e937d8e752842ac241463944c9eb14c87e2d269f2658a5bd05e98/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:d396ec2b979760aaf3218e76c24e65bd0aca24983298653b3a9d7a45f9e47b30", size = 2310000, upload-time = "2026-05-06T13:37:56.694Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/c3/66883a5cec183e7fba4d024b4cbbe61851a63750ef606b0afecc46d1f2bf/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:86e1a4418c6cd97d60c95c71164158eaf7324fae7b0923264016baa993eba6fc", size = 2361286, upload-time = "2026-05-06T13:40:05.667Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/2d/69abac8f838090bbecd5df894befb2c2619e7996a98ddb949db9f3b93225/pydantic_core-2.46.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:d51026d73fcfd93610abc7b27789c26b313920fcfb20e27462d74a7f8b06e983", size = 2193071, upload-time = "2026-05-06T13:38:08.682Z" },
 ]
 
 [[package]]
 name = "pydantic-graph"
-version = "1.0.15"
+version = "1.98.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -2326,89 +2263,89 @@ dependencies = [
     { name = "pydantic" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7d/9d/53bfb44f18f8693faa4a000aae8c16e61066318ce340395e9fac2c746d69/pydantic_graph-1.0.15.tar.gz", hash = "sha256:c4ddf8574b0f7b8d3a310f7d5ce218aa3563e15d7251c596b1dfb61ae61d4097", size = 21903, upload-time = "2025-10-03T23:49:35.619Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/91/df/e69fcda43e3b835603bf698c2fe47a5fffd30d18c027b980fe53b00617ca/pydantic_graph-1.98.0.tar.gz", hash = "sha256:c9e8c7be5efd1433eeed1bc86d1daa912a78c8a42f69864d1d1e2fc7e3f5d939", size = 62551, upload-time = "2026-05-19T01:08:30.55Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/0a/9cf13c0e0cd7cbea87538d3a0e45e501b3c11e4942a21860d13d985c3e94/pydantic_graph-1.0.15-py3-none-any.whl", hash = "sha256:c1f3b093429365c48f4b27f034fae0f3ba1a82eb24859a601a1f15cc688aad63", size = 27548, upload-time = "2025-10-03T23:49:24.413Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/50/f58156776e4b10f9cf5896f2a7cefdacb90c8c50e6a7a07bda4d6c9dc2b1/pydantic_graph-1.98.0-py3-none-any.whl", hash = "sha256:ddb744041eca0d19973cedbcf4208422d8847ac5aeea24ae794b2ea136aa2f84", size = 80093, upload-time = "2026-05-19T01:08:22.907Z" },
 ]
 
 [[package]]
 name = "pydantic-settings"
-version = "2.11.0"
+version = "2.14.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "python-dotenv" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/20/c5/dbbc27b814c71676593d1c3f718e6cd7d4f00652cefa24b75f7aa3efb25e/pydantic_settings-2.11.0.tar.gz", hash = "sha256:d0e87a1c7d33593beb7194adb8470fc426e95ba02af83a0f23474a04c9a08180", size = 188394, upload-time = "2025-09-24T14:19:11.764Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/07/60/1d1e59c9c90d54591469ada7d268251f71c24bdb765f1a8a832cee8c6653/pydantic_settings-2.14.1.tar.gz", hash = "sha256:e874d3bec7e787b0c9958277956ed9b4dd5de6a80e162188fdaff7c5e26fd5fa", size = 235551, upload-time = "2026-05-08T13:40:06.542Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/83/d6/887a1ff844e64aa823fb4905978d882a633cfe295c32eacad582b78a7d8b/pydantic_settings-2.11.0-py3-none-any.whl", hash = "sha256:fe2cea3413b9530d10f3a5875adffb17ada5c1e1bab0b2885546d7310415207c", size = 48608, upload-time = "2025-09-24T14:19:10.015Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8d/f1af3832f5e6eb13ba94ee809e72b8ecb5eef226d27ee0bef7d963d943c7/pydantic_settings-2.14.1-py3-none-any.whl", hash = "sha256:6e3c7edfd8277687cdc598f56e5cff0e9bfff0910a3749deaa8d4401c3a2b9de", size = 60964, upload-time = "2026-05-08T13:40:04.958Z" },
 ]
 
 [[package]]
 name = "pygments"
-version = "2.19.2"
+version = "2.20.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
 ]
 
 [[package]]
 name = "pyjson5"
-version = "2.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6e/d9/005aaaf5077cde946282b22da9404965477fb140fa6836b52d2e0955a391/pyjson5-2.0.0.tar.gz", hash = "sha256:7ccc98586cf87dfeadfa76de8df4c9cb0c3d21d1b559e28812dd9633748d6e25", size = 305865, upload-time = "2025-10-02T00:23:02.154Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/2b/2cb73dba9ffeabd91d67577f5fc7fa67040eae6876c632214145893844da/pyjson5-2.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1e6870507311765249f6cb533d8d53e0c9b1837f2e1b0b2ba7825181bd980a48", size = 299572, upload-time = "2025-10-02T00:19:18.448Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/1b/ebf7d13d57fffccb2d5b7bbf609800ccf8ff09678a8a7ae6c0764b04b1c8/pyjson5-2.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:68f931934d736bfd0d9d9c666b9495a10807821c44a7c58069b2f6a12ceb47ae", size = 157385, upload-time = "2025-10-02T00:19:19.905Z" },
-    { url = "https://files.pythonhosted.org/packages/29/7c/eb6fcb6e94075bea4ab56c50d1bfb8a66d43fdc2fb67001181928dd7ddb1/pyjson5-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:47eda4d30024bfa8074a6f17145e55e60cf74a43215db99685fe6998cd0130aa", size = 151838, upload-time = "2025-10-02T00:19:20.91Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/7c/478456b8683bc3d964cf1ca060188b1d4bc03d01548d1449d033542aee91/pyjson5-2.0.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5cc27c08bf33c7be0622ada8ff6dc7aa203287d1e585e343e90d2f2c19f31977", size = 192102, upload-time = "2025-10-02T00:19:22.238Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/17/bce2b2641aa140c761807d50cf30a7e09c53d0bd8737bf63dada0e8613f4/pyjson5-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3af072ff4cb1046c17d6108fd01f4c39519c95e8aa5b2084fd6fea57379eafc", size = 176766, upload-time = "2025-10-02T00:19:23.181Z" },
-    { url = "https://files.pythonhosted.org/packages/30/61/7e51cd104e4514edd21b6e0c7e841da14ba80d3372d028b62719d8cb3f9e/pyjson5-2.0.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:eec8b9067aa041a177a07596c8e800e7616e5ad87ce97836c3489f977231dc1a", size = 170313, upload-time = "2025-10-02T00:19:24.602Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/7e/2398eeffafc924809d4a708588f7f697398ca095b6c399849bfd0867780a/pyjson5-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e91417ead40a468698d0eb6654685986c03afc53290b8dd58d51f28803451506", size = 196097, upload-time = "2025-10-02T00:19:25.536Z" },
-    { url = "https://files.pythonhosted.org/packages/98/70/550d7d634e46a71bf00b93ec2c4a8a7d63f9629e1a5117cbf249995c0e3a/pyjson5-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:023466521ce06f314979589fcd7fa01cdcff4d7a0cd32d1545ca0d566bca7761", size = 198474, upload-time = "2025-10-02T00:19:26.495Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/3c/e4ef8f3ef83254de96aba69f24fa613bc1277cf34802c6b4e82cc311121f/pyjson5-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:913488fb34610b900bef4244bf99d8585b3d1431a7ba28d9538fb6b3bc34150c", size = 186299, upload-time = "2025-10-02T00:19:27.525Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/35/60c473c7970e4239149e7e4dcf7b10ca8712779e47be47b9d9fd076e54ea/pyjson5-2.0.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e25ca44bcb3ce47938d739c5b2bbecdefca919132b7f46a3f57a6d06a38c02f0", size = 185624, upload-time = "2025-10-02T00:19:28.532Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/15/876e53cc43c98ff036c05c90fa8a9ccbf704478a69ffc6efe2c9f898bf77/pyjson5-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c3192eaf57cd17c367dd1726354e992c10dfb810b4c2b87284f55f00840b2245", size = 1158339, upload-time = "2025-10-02T00:19:30.089Z" },
-    { url = "https://files.pythonhosted.org/packages/82/57/2ef4f05a29c04ae1beceae2739b3428bca064f963758284b1633fccc5190/pyjson5-2.0.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:6ecc3f3216aa9795a80836a1f206fc87c4d2d71f0d90228ff10f1f55b16f72c2", size = 1013974, upload-time = "2025-10-02T00:19:31.486Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/9a/28b8655c6c6715e15c20ab98574a793f6b3435badd0ddf67ba3ea1bd420c/pyjson5-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0e9f21938060afe6f6cd64e76f2f4849c22a7aa61ee794e9885b0a760064deb4", size = 1329463, upload-time = "2025-10-02T00:19:32.824Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/6a/e427b03a02ff45cc7432a7d1e16066512321f643457039c2b955449f4148/pyjson5-2.0.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:78133797816d47780b25a1cf55e66ee9cd3e00a9e3abae66040fb975c39b1d23", size = 1255206, upload-time = "2025-10-02T00:19:34.778Z" },
-    { url = "https://files.pythonhosted.org/packages/28/2b/d2b4a3137842de3ba66195fa5e3da96ac8c93790c77a8d76b1d30245b327/pyjson5-2.0.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:19d7dfb9d5d32839e1b77506c6b8023f83c72f531e2d6248400ca832efdb2349", size = 1190884, upload-time = "2025-10-02T00:19:36.24Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/6a/e590e10b7e9f145d0e7b02fde0b0b3ffec45998fc7d454e5c64f98aff6d5/pyjson5-2.0.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:95012228c10803512f515e70af06ec11a8621ce3742226ba507ebf6e91020d8d", size = 1367769, upload-time = "2025-10-02T00:19:37.74Z" },
-    { url = "https://files.pythonhosted.org/packages/df/3b/705305653470ef31f177ba8f70df6d5d85858e2f2bf3df7624a1c454b7cb/pyjson5-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4facf0fc1bcdd7d57308bbc3dfa2ad0498c8e4d76672c35f1e7976f02d3f7df8", size = 1219001, upload-time = "2025-10-02T00:19:39.586Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/b9/1a072afcfba936d3dabc9db08d18ca3aec03b82002be7b1d6d781019b317/pyjson5-2.0.0-cp311-cp311-win32.whl", hash = "sha256:6fb1bba20ebd3a0b26bca5ee906757a9d82652ca31730d40cd921b88245ec780", size = 114294, upload-time = "2025-10-02T00:19:41.05Z" },
-    { url = "https://files.pythonhosted.org/packages/28/4d/303b9ad667d7440cfd4a45c75408cb868281b60864b917b285aba668a6f3/pyjson5-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:58b17386a96a308c8295e2c2a82526aefaa33ed2abaff84a916f90484b047cc4", size = 134665, upload-time = "2025-10-02T00:19:41.972Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/eb/29d8d48730b1ad0a6b3762190dd2c3f43c39f4f89e20be1b8c0015b24246/pyjson5-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:4f4cde947ea68da7df8fb91b682491bcc0b916e3adb942febe866703853d8301", size = 117666, upload-time = "2025-10-02T00:19:42.861Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/25/429e6cc1b6ba7a1ce730f172d8653f16dfff991de7c1122627b5d9a7dfd6/pyjson5-2.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:dbb701b2b19ef5860a2409baf7fd576af8619fdaffa96ca37e0e8e0b2f030be8", size = 300589, upload-time = "2025-10-02T00:19:44.285Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/58/251cc5bfcced1f18dbe36ad54b25f376ab47e8a4bcd6239c7bd69b86218e/pyjson5-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c0f29297836f4a4f8090f5bfc7b0e2b70af235c8dcfd9476a159814f734441d3", size = 159389, upload-time = "2025-10-02T00:19:45.39Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/4b/4e69ccbf34f2f303e32dc0dc8853d82282f109ba41b7a9366d518751e500/pyjson5-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76d4c8d8bf56696c5b9bc3b18f51c840499e7b485817ddba89ae399fcc25c923", size = 150788, upload-time = "2025-10-02T00:19:46.454Z" },
-    { url = "https://files.pythonhosted.org/packages/49/67/caa7dd84ab554d83bb68a7a27f09ed750681cd305d13feb38c2df90ccdbe/pyjson5-2.0.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e94e1a05c8a42a4828a50c520eb2330fe5732d5d04f3ebe771680f7db16f7df3", size = 188298, upload-time = "2025-10-02T00:19:47.456Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/39/26fffaff9ebf720a05e2867c40e2023cebe33a41e1f511e3c1b42452fe7d/pyjson5-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9ab533ccd75bfda9ffd34a818f283b481e78c5c315919c4f620f69639044bdd3", size = 168159, upload-time = "2025-10-02T00:19:48.459Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/c9/f7170d4903cb1526836a458f7e4650f0ff465001b7ef7066bc4b0577e601/pyjson5-2.0.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16e9295bf9f80fc5fb63046a0df4a3adef4e945d27f61f0f6e5db0a4f1510a15", size = 169039, upload-time = "2025-10-02T00:19:49.478Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/d1/b84322897a861e85528c9621372441c4db57b8af615a647a9a8223e7e00a/pyjson5-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4191eced0e77207afc2f82782ef3dbee88c38ec386da8c0af9190653e8c8557f", size = 185596, upload-time = "2025-10-02T00:19:50.5Z" },
-    { url = "https://files.pythonhosted.org/packages/56/3c/fea02294217c0b93f017ddc032bbacc805e669014c784b42b5cf366d4aa1/pyjson5-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9efc441991cd31a5d1fea04d8a024649bbd9a005d7e0ec6a870670b47adf43e8", size = 187665, upload-time = "2025-10-02T00:19:51.513Z" },
-    { url = "https://files.pythonhosted.org/packages/10/39/de2423e6a13fb2f44ecf068df41ff1c7368ecd8b06f728afa1fb30f4ff0a/pyjson5-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:467c5e0856152bbe539e38f126f698189f1ecc4feb5292d47ad0f20472d24b6d", size = 178950, upload-time = "2025-10-02T00:19:52.591Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/9c/3de848f4441b95ad5f8499f7aed9b86da1c7eee776b0e673d85703416f15/pyjson5-2.0.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a2fc21d0f59c75dd3cc0a9943fface3729a4cf2e4dfbd14a90680a97bbfe23d1", size = 175149, upload-time = "2025-10-02T00:19:53.655Z" },
-    { url = "https://files.pythonhosted.org/packages/44/b8/fb33760617875852f299e06aa9cd9bbaf68d2f939189736ebf9099f4f305/pyjson5-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7a4887291c830dbc30528833eb8cdcc44d0531626a61ac9bac80b17df369cb33", size = 1149408, upload-time = "2025-10-02T00:19:54.885Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/b2/ea1806e14704b5087a637a0b126ce63376f39e3762099614bca446dc7fa4/pyjson5-2.0.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:4a1497408a18ddd2501b1c6bdd1dd01d69809450d145c13c42913f98dfa59d20", size = 1012047, upload-time = "2025-10-02T00:19:56.254Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/79/bbd9e037d2758b3da79a4bf02d6234e88908ad62fd6fc299144d4efe7466/pyjson5-2.0.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9617abb9022fcd3d1034a5e07972dc0440af3d91da86c45f81750b6c324e9bcf", size = 1324907, upload-time = "2025-10-02T00:19:57.961Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/5d/f984d6008fa0dcf64624eed4334c88cdae31b48d0546a17017beea6f6978/pyjson5-2.0.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:247a8f29e4fecdf7ff894dd3b5759a21c5336b5e3c21ba2ee31a03b52b73a98c", size = 1243097, upload-time = "2025-10-02T00:19:59.37Z" },
-    { url = "https://files.pythonhosted.org/packages/14/dc/c07f02d3e5f307540f884cb9ae1c2b17849ebcbf112f81663abe8ca04511/pyjson5-2.0.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:6a464e605113b09d2f235fc6d7df8425831bbe40078fe6755b30058b8a904694", size = 1181197, upload-time = "2025-10-02T00:20:00.893Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/59/6cf634b199a4e71cb11cc8157d3c8c0baea1d8c89b2bea3bf83a482ac742/pyjson5-2.0.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d355134c9735f3eb3724f3985551203976c823909aec118f616b8da096ffd9b5", size = 1356466, upload-time = "2025-10-02T00:20:02.497Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/f1/ae443709da9396396545c1ecfc30fd2f69629a65e894341a72fa286f0c26/pyjson5-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6c3353d214db15d6b05d941cdb2fc2e3d1c94650e5baecc6986424f20ebe76d1", size = 1211084, upload-time = "2025-10-02T00:20:03.99Z" },
-    { url = "https://files.pythonhosted.org/packages/28/a7/291e4ac2890dd94f773aa7fe606ffb7b5424ad5c21d888feccb0b0fbf76b/pyjson5-2.0.0-cp312-cp312-win32.whl", hash = "sha256:9f164c973f0d6b79ed3c92a4bb5506b04c810dcf84dc48b543d968ec0acfbfc8", size = 115425, upload-time = "2025-10-02T00:20:40.058Z" },
-    { url = "https://files.pythonhosted.org/packages/af/cb/cf69e6e080149b8993d553c683d364e714c6646f70f55b7c135efe942366/pyjson5-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:296cb2e2c6f64dc61397bd48f04569f1532cd9062d8ebca29ed02644b298e4fc", size = 135552, upload-time = "2025-10-02T00:20:41.392Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/f7/b7784d5dd52a34f23efd4118bf856877a8f15bb2a53c43c192e4dee7d10f/pyjson5-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:b36fa4a4b6f632bbc2afc4caaa16e7f585cd2345de85a439e6ce734f915b8018", size = 116874, upload-time = "2025-10-02T00:20:42.379Z" },
+version = "2.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/9a/3db19560e968d6e85b2a4ddf4b949c6ebf9dd1dcfb5a9f37736f8adeb927/pyjson5-2.0.1.tar.gz", hash = "sha256:a5b0e322e847b198a50d8a1ef16d6b2b19129644dc018d76773e81ef1487ca39", size = 352242, upload-time = "2026-05-15T16:12:54.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/72/75/bd6b2297beef9730e7f265679de7105fbc9a49dd85dff28563851b9c679a/pyjson5-2.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1727cebec0ca73597188057bb826cd96c8503ced9b22a9cc73501f2e68d91ea0", size = 297438, upload-time = "2026-05-15T16:05:33.756Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/18/663ab5ad9aff987889440a2cb6f0415d334850444aba759211aa3eec10aa/pyjson5-2.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4833d46e8dc4bcba54db038305c8a7455d05cf8533d52a2297abff634cf69fa3", size = 155300, upload-time = "2026-05-15T16:05:35.039Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/57/9f68629021052044cf46bb89652a442f14505f3087d786ac4b18268235b9/pyjson5-2.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d73d09a5cad4e3325bd6737697d649a4594c4fde8df8eb784ed795dea845435f", size = 151680, upload-time = "2026-05-15T16:05:36.26Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/06/21da19b96b3215d266bf4662147d5ef70f65daf9bd4e82305ae61584908a/pyjson5-2.0.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ac66d237c78b9ecda45506225c7eed648d2e6750532e15e1ac2052acf3e2d444", size = 189073, upload-time = "2026-05-15T16:05:37.691Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/5b/48ec81dcee70f8d188ac04499207e3c8a893ec306a1ba4db5c38988f98c1/pyjson5-2.0.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef1c0fa8af1cac361b2bbb030be942ead42bf872f279bc8e2666a8d5d6e7e7ee", size = 171985, upload-time = "2026-05-15T16:05:39.852Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/89/d79ac6cd317b3488e38f225c2cd8315fa54145faf939295b853bae70fe3c/pyjson5-2.0.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3e2e3ade7f34e1ad2b270fdaa6a11c31c7cb5f07379a422e9a714791d345e4bf", size = 169481, upload-time = "2026-05-15T16:05:41.751Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/db/e15cc07bf375a59d102536b233171eec621d1b8e9412596c0ef656828baf/pyjson5-2.0.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:55780f15c6d00a8d7847c7291c1a09492beab61460cf1b4725177b189cfaab65", size = 191706, upload-time = "2026-05-15T16:05:43.54Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/64/3c1c2b350071ccbfcc3a8e4eae66af960cc3193008cf47846cc1c775aebb/pyjson5-2.0.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2f80ec4e18b2a8d42832f843b48cf06e77240c8e9cb046ea7e10752e8135ce87", size = 195462, upload-time = "2026-05-15T16:05:45.164Z" },
+    { url = "https://files.pythonhosted.org/packages/19/87/e0774939571faad2609fce9865ffd7a30b648f828fc2ca5acc364411f0ce/pyjson5-2.0.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:94a645be2b846a6a1155296047176099b6ce987030fb7723208d364cb1b73eed", size = 183993, upload-time = "2026-05-15T16:05:46.952Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a2/ce59cab1733bed125193765f8d55ff316f151703eeb5c264b63200c4b26a/pyjson5-2.0.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:2c34ddc5a211ecebcfadeb9c698abd047245bac83ab7340811b77fd41aab76e4", size = 182419, upload-time = "2026-05-15T16:05:48.351Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/8d/cf77e9193cbff64a8488fa005c62544d102fcc7f8d233932b8c026adf00a/pyjson5-2.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3614a579966cc22bc4e83599a786bd875e2c1de4baf71898763623f670df69a2", size = 1153689, upload-time = "2026-05-15T16:05:50.295Z" },
+    { url = "https://files.pythonhosted.org/packages/27/d3/fb75865e713871e0fbb2c6c46a1569365f8778c59601939432dcf540b9d4/pyjson5-2.0.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1925fa0b53bf722d6d263e1eeafd6c009dd4dc975bc481e03786497b2c25eb08", size = 1013811, upload-time = "2026-05-15T16:05:52.246Z" },
+    { url = "https://files.pythonhosted.org/packages/26/7f/678c7a3ca28439558f42e78560d5e8096918e5fa1995edfc23702cb10a90/pyjson5-2.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:497b4d61617db4498a20b47827939034d9234c695d44df7dc907ec455068070e", size = 1327361, upload-time = "2026-05-15T16:05:54.035Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/86/f4b57480f00d546031f6ec6dda17780f996cceb1adf02fed586d2d985aa7/pyjson5-2.0.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d8ca0d3e4fc92dd20ae76d067ae692cac35161f83f0712c5b20d8f7ba73730b9", size = 1251975, upload-time = "2026-05-15T16:05:56.082Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/72/27be9cdb773cdeb334d423d57cc68be30c280df3d3b163c68b7a963d4e50/pyjson5-2.0.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:6899d9e22660862fb9baf3eb5ac9b2887eb478b18d14f95de94feffed5ce0558", size = 1188190, upload-time = "2026-05-15T16:05:57.841Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/59/c9672530a00d433e5411440940d2454d39b19fde29c69eab064af136a157/pyjson5-2.0.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:4671741493245604579cd9a9c044fd12341a0a61cf0fda8fb844812e29a1a488", size = 1367103, upload-time = "2026-05-15T16:05:59.577Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/14/356b2a67f1d6d062df8345c98b1337556f75c18ca0f9f32921d2a28e1946/pyjson5-2.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1f5ae05506fc86bbe5716ec102cd023d20d2051f43f4eb3a741b557616c3245d", size = 1217145, upload-time = "2026-05-15T16:06:01.671Z" },
+    { url = "https://files.pythonhosted.org/packages/93/ca/dbf1f6f20cd54be3588b890648f46c1a0db111c7c988d3325e31c14f3510/pyjson5-2.0.1-cp311-cp311-win32.whl", hash = "sha256:90ef60fe98b6d0eaef3a6cdc81a6b1c6acb135a061bc695c00f3b6fdb86f3f90", size = 114798, upload-time = "2026-05-15T16:06:03.289Z" },
+    { url = "https://files.pythonhosted.org/packages/48/87/933712d67031be67cf7c0298d655026b46b30539144f9f12f9084d80b03b/pyjson5-2.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:9f5d62dfe22810a3ad2252c1b0d7f89b0673255263410d999d88bfd6f46b0ca8", size = 134709, upload-time = "2026-05-15T16:06:04.683Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/77/ce42988444b3e567d2b949970f96949e61aadbe535ceacb12afc2570b553/pyjson5-2.0.1-cp311-cp311-win_arm64.whl", hash = "sha256:25ee8af17c19d0a31adc3672adc9c92429130e171e6fbe374468519892fd218b", size = 117230, upload-time = "2026-05-15T16:06:06.173Z" },
+    { url = "https://files.pythonhosted.org/packages/68/41/be622b742fe4749fefa9d8a923b1cf5e51a1e8e4b4930fa8ea8c531b243d/pyjson5-2.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ee62394660d54e76ff8a968c8194b252be23d184f05a00238d4def9624454ea6", size = 302636, upload-time = "2026-05-15T16:06:08.006Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/e2/50378c3bec9164c1bb983ca15ed59f8be498981b790a90d1410a1016ffe2/pyjson5-2.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:58dfa4cf5c327e14c530b16c23e812c021fe53b19e6f9cdfce257d8c02244895", size = 158588, upload-time = "2026-05-15T16:06:09.684Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/7d/5de0f82c144b6fc2fa2e3fde5517257733a91d24734b5d2415b7e991e8fd/pyjson5-2.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:07cb90a31f962a6de9e49592a306046ee015da73510c6d215e9481a2a21c9ac2", size = 153741, upload-time = "2026-05-15T16:06:11.114Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/ac/174ca02e5f3ed8245dc48247e534880bbec1528c0c4eaa768fafa9417dda/pyjson5-2.0.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ef4026a90a68cd2bcb64d89ca064a1615b60a61c7694714e2b8ef30434f365b5", size = 185450, upload-time = "2026-05-15T16:06:12.883Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/0d/bfc553176b7e109b72f23697ab1fd1a77d7fd5c6626d6e23936f13d5884e/pyjson5-2.0.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:04b4929a7adf0e0720da92ac54c92d408e8057158be3ccc34da17c7767a9af78", size = 163331, upload-time = "2026-05-15T16:06:14.314Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/05/b0e67106f78c8ea5ffcf6ce0b8421f38a04d5f37ea88ac70123199755bcb/pyjson5-2.0.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e889b039d6bffda9a6b8d822073bbdb4a60166af22f075e7faa0c03c2dfcf17b", size = 166429, upload-time = "2026-05-15T16:06:16.076Z" },
+    { url = "https://files.pythonhosted.org/packages/81/3c/2366f8ecf053434470eafe1f120f2e235d13015fc50d7f06e55e39b550ab/pyjson5-2.0.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a08e99d0a33463728fb016f5eec680504499c4be280dac016de2da70ec55b0db", size = 180499, upload-time = "2026-05-15T16:06:17.544Z" },
+    { url = "https://files.pythonhosted.org/packages/76/65/9a70876d4dd09ce17678024266406b94b8f1edf9db6c2e3bf76cfa653a13/pyjson5-2.0.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:035c094feb6a9d4312183f9f34228d976102eefb971e9e3dd972d8c7900a466a", size = 187469, upload-time = "2026-05-15T16:06:19.212Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/43/0c0bcbf9a9ef7fdcd49dc0992a3a206244c2c2baa7b409932464cf26f1a5/pyjson5-2.0.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6d178025a5317db44663dc87aab90f34674991b3da40dbedc3c108e7b03b6466", size = 176032, upload-time = "2026-05-15T16:06:21.153Z" },
+    { url = "https://files.pythonhosted.org/packages/82/2c/32213674010c44db265d45e977a431cbde971c45342b483f7af337811403/pyjson5-2.0.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:381ca5b3172bccf9c29c5823a0173ab9118d579d0f5bb4fca20b803daa6e72d5", size = 171477, upload-time = "2026-05-15T16:06:23.017Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/49/da5417d592ac75a23d1ca2dfda846391ccf137edd89054b780866c592b65/pyjson5-2.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8e158caf0dd7fbf7afe12f92fcc9cba26bceac4b38615c087fd592e9e3240d9f", size = 1145571, upload-time = "2026-05-15T16:06:24.757Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/1f0c326b3a3267f28b7b9e2ac07121386ec20ee8f9dd49955af4faa17ba7/pyjson5-2.0.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c8010e9a02b6a0719234f8d074639f9051afe579ff0f74d3367af1d8b4c7d839", size = 1010388, upload-time = "2026-05-15T16:06:26.574Z" },
+    { url = "https://files.pythonhosted.org/packages/de/c8/76f2739a8715061755f12f4d2795f6c4079aeadd166c56d0992521442d5b/pyjson5-2.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3543e067d1d8ab6cb1cd41add38a42eaf82e9a7e802e8a08f1acda9f22199b00", size = 1323111, upload-time = "2026-05-15T16:06:28.805Z" },
+    { url = "https://files.pythonhosted.org/packages/50/7a/683e1586fa076fb344aec23a647d67f427847b6bffb1001d56e86aa8da33/pyjson5-2.0.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3e496938e7e0defc33bfbd0ff581d4ffdc428c598cc5d679232f34df27f7330a", size = 1240671, upload-time = "2026-05-15T16:06:30.473Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/8e/6638b0b22344b23cae1271b0211668be54b3f76183bd8d4f89a2edd8e562/pyjson5-2.0.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:2badbc101908123905a38789cc552b99ab896a7ec0ce4fa6ee2bb7b613c85c1b", size = 1178013, upload-time = "2026-05-15T16:06:32.212Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/21/d44540d3cdc670e5c6e665471361f557ef8c7d56964cd433524208b3707b/pyjson5-2.0.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:b1b0df4898e2e046fa1e9b5df436fe11d9b681b1e5fc9877508d982d2059aaf1", size = 1354907, upload-time = "2026-05-15T16:06:33.922Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/74/fceedd2709760f5c85e75b508002af9b4c2da8af20a80e62b2d0e2358a15/pyjson5-2.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8fcc96c429888f2293f672e33d01da8a0847cd5116a773c9a1903b8bc2f12bc1", size = 1208847, upload-time = "2026-05-15T16:06:35.883Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/3a/d2f062b5801b3034ecb16ffb0801d7b4a1d6abae4cd4615482dbf62f1ed8/pyjson5-2.0.1-cp312-cp312-win32.whl", hash = "sha256:48c97e2f7f02171948f8a7ed6c9b2b2faea00653a3348d9e810238a688f07b6c", size = 115562, upload-time = "2026-05-15T16:09:24.807Z" },
+    { url = "https://files.pythonhosted.org/packages/26/13/2265cf16720defdc87672b68ff5edf83820bd76e59e32f8384c9cb1ae619/pyjson5-2.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:8dea9976eea0aa7af8b5ad49df3fa831d6bda08ffd7bb11409d6a81961491219", size = 136176, upload-time = "2026-05-15T16:09:25.931Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/92/a8947e646ce642555ac22b31f44b7168c81b0e364d0f2711d571955229b6/pyjson5-2.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:264ab65fb7d68a763567c2302151f1f074bf053c8479939aa8e75f5f9518fe31", size = 116752, upload-time = "2026-05-15T16:09:27.274Z" },
 ]
 
 [[package]]
 name = "pyjwt"
-version = "2.10.1"
+version = "2.12.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785, upload-time = "2024-11-28T03:43:29.933Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997, upload-time = "2024-11-28T03:43:27.893Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" },
 ]
 
 [[package]]
@@ -2428,59 +2365,61 @@ wheels = [
 
 [[package]]
 name = "pymarkdownlnt"
-version = "0.9.33"
+version = "0.9.37"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "application-file-scanner" },
     { name = "application-properties" },
     { name = "columnar" },
+    { name = "py-walk" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/30/15/cb76156751bafceebba839aa3f679940dda4fadee20b8864a4d36a9b1644/pymarkdownlnt-0.9.33.tar.gz", hash = "sha256:4486eb34fed9b66d2e4e91c5b5159b5242b816a7847585aa2a94afc58cc5583d", size = 422332, upload-time = "2025-10-24T03:17:15.291Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/27/b1/3cb62d33eaf59e95d3aab1d0ffb240a90c2d6b7acee12e02661d59a38efd/pymarkdownlnt-0.9.37.tar.gz", hash = "sha256:d0d7882ae08263a12130b159c1a27a728630b1b53bb75246f2f61f81b9289fd9", size = 442920, upload-time = "2026-05-04T04:00:05.757Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9c/b1/04c96cbbf8a209ff4059560c2c5c3e4be23926ce397699f09e4551510703/pymarkdownlnt-0.9.33-py3-none-any.whl", hash = "sha256:c5341a6f2539d087f76c88cda2dfc0c39e7632ebae915ea9399a083030951f35", size = 505133, upload-time = "2025-10-24T03:17:14.05Z" },
+    { url = "https://files.pythonhosted.org/packages/05/30/3f234125f9385ed45dfdb77b20d4f42825f3317d89689883761dfa5f2fca/pymarkdownlnt-0.9.37-py3-none-any.whl", hash = "sha256:1dc7296f9bf96c26736571b3b73311e516dbaf8ec587c3539fdf63c8d30f66e6", size = 514924, upload-time = "2026-05-04T04:00:04.163Z" },
 ]
 
 [[package]]
 name = "pypdfium2"
-version = "4.30.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a1/14/838b3ba247a0ba92e4df5d23f2bea9478edcfd72b78a39d6ca36ccd84ad2/pypdfium2-4.30.0.tar.gz", hash = "sha256:48b5b7e5566665bc1015b9d69c1ebabe21f6aee468b509531c3c8318eeee2e16", size = 140239, upload-time = "2024-05-09T18:33:17.552Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/9a/c8ff5cc352c1b60b0b97642ae734f51edbab6e28b45b4fcdfe5306ee3c83/pypdfium2-4.30.0-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:b33ceded0b6ff5b2b93bc1fe0ad4b71aa6b7e7bd5875f1ca0cdfb6ba6ac01aab", size = 2837254, upload-time = "2024-05-09T18:32:48.653Z" },
-    { url = "https://files.pythonhosted.org/packages/21/8b/27d4d5409f3c76b985f4ee4afe147b606594411e15ac4dc1c3363c9a9810/pypdfium2-4.30.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:4e55689f4b06e2d2406203e771f78789bd4f190731b5d57383d05cf611d829de", size = 2707624, upload-time = "2024-05-09T18:32:51.458Z" },
-    { url = "https://files.pythonhosted.org/packages/11/63/28a73ca17c24b41a205d658e177d68e198d7dde65a8c99c821d231b6ee3d/pypdfium2-4.30.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e6e50f5ce7f65a40a33d7c9edc39f23140c57e37144c2d6d9e9262a2a854854", size = 2793126, upload-time = "2024-05-09T18:32:53.581Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/96/53b3ebf0955edbd02ac6da16a818ecc65c939e98fdeb4e0958362bd385c8/pypdfium2-4.30.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3d0dd3ecaffd0b6dbda3da663220e705cb563918249bda26058c6036752ba3a2", size = 2591077, upload-time = "2024-05-09T18:32:55.99Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/ee/0394e56e7cab8b5b21f744d988400948ef71a9a892cbeb0b200d324ab2c7/pypdfium2-4.30.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cc3bf29b0db8c76cdfaac1ec1cde8edf211a7de7390fbf8934ad2aa9b4d6dfad", size = 2864431, upload-time = "2024-05-09T18:32:57.911Z" },
-    { url = "https://files.pythonhosted.org/packages/65/cd/3f1edf20a0ef4a212a5e20a5900e64942c5a374473671ac0780eaa08ea80/pypdfium2-4.30.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f1f78d2189e0ddf9ac2b7a9b9bd4f0c66f54d1389ff6c17e9fd9dc034d06eb3f", size = 2812008, upload-time = "2024-05-09T18:32:59.886Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/91/2d517db61845698f41a2a974de90762e50faeb529201c6b3574935969045/pypdfium2-4.30.0-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:5eda3641a2da7a7a0b2f4dbd71d706401a656fea521b6b6faa0675b15d31a163", size = 6181543, upload-time = "2024-05-09T18:33:02.597Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/c4/ed1315143a7a84b2c7616569dfb472473968d628f17c231c39e29ae9d780/pypdfium2-4.30.0-py3-none-musllinux_1_1_i686.whl", hash = "sha256:0dfa61421b5eb68e1188b0b2231e7ba35735aef2d867d86e48ee6cab6975195e", size = 6175911, upload-time = "2024-05-09T18:33:05.376Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/c4/9e62d03f414e0e3051c56d5943c3bf42aa9608ede4e19dc96438364e9e03/pypdfium2-4.30.0-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:f33bd79e7a09d5f7acca3b0b69ff6c8a488869a7fab48fdf400fec6e20b9c8be", size = 6267430, upload-time = "2024-05-09T18:33:08.067Z" },
-    { url = "https://files.pythonhosted.org/packages/90/47/eda4904f715fb98561e34012826e883816945934a851745570521ec89520/pypdfium2-4.30.0-py3-none-win32.whl", hash = "sha256:ee2410f15d576d976c2ab2558c93d392a25fb9f6635e8dd0a8a3a5241b275e0e", size = 2775951, upload-time = "2024-05-09T18:33:10.567Z" },
-    { url = "https://files.pythonhosted.org/packages/25/bd/56d9ec6b9f0fc4e0d95288759f3179f0fcd34b1a1526b75673d2f6d5196f/pypdfium2-4.30.0-py3-none-win_amd64.whl", hash = "sha256:90dbb2ac07be53219f56be09961eb95cf2473f834d01a42d901d13ccfad64b4c", size = 2892098, upload-time = "2024-05-09T18:33:13.107Z" },
-    { url = "https://files.pythonhosted.org/packages/be/7a/097801205b991bc3115e8af1edb850d30aeaf0118520b016354cf5ccd3f6/pypdfium2-4.30.0-py3-none-win_arm64.whl", hash = "sha256:119b2969a6d6b1e8d55e99caaf05290294f2d0fe49c12a3f17102d01c441bd29", size = 2752118, upload-time = "2024-05-09T18:33:15.489Z" },
-]
-
-[[package]]
-name = "pyperclip"
-version = "1.11.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e8/52/d87eba7cb129b81563019d1679026e7a112ef76855d6159d24754dbd2a51/pyperclip-1.11.0.tar.gz", hash = "sha256:244035963e4428530d9e3a6101a1ef97209c6825edab1567beac148ccc1db1b6", size = 12185, upload-time = "2025-09-26T14:40:37.245Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/df/80/fc9d01d5ed37ba4c42ca2b55b4339ae6e200b456be3a1aaddf4a9fa99b8c/pyperclip-1.11.0-py3-none-any.whl", hash = "sha256:299403e9ff44581cb9ba2ffeed69c7aa96a008622ad0c46cb575ca75b5b84273", size = 11063, upload-time = "2025-09-26T14:40:36.069Z" },
+version = "5.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/3d/dc934d3b606c51c3ecc95b6731d84b7dd7ab8e513a50b0e98a4da6c8a719/pypdfium2-5.8.0.tar.gz", hash = "sha256:049397c647e50f83115ee951c49394dab9e9ba52ebdd5a11ab1109390eb3d34e", size = 271934, upload-time = "2026-05-04T17:39:43.794Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6f/8c/6b75b923cb81368fa3ea7c48a0616b839620a3aeff899885bd930449b89e/pypdfium2-5.8.0-py3-none-android_23_arm64_v8a.whl", hash = "sha256:f67b6c74b716d9ac725ad1af49ae786ad813ac20823d45606d59f1fc06caa8af", size = 3374554, upload-time = "2026-05-04T17:39:05.552Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/61/a885c7f36efba89ec98e3d1fe95c83b48c2d6dea321e9194ac6460e7a834/pypdfium2-5.8.0-py3-none-android_23_armeabi_v7a.whl", hash = "sha256:53e82bf3e6a2da170b1bda83f93b7eec57cb6efe3cacd05cba78823879a85203", size = 2831667, upload-time = "2026-05-04T17:39:08.028Z" },
+    { url = "https://files.pythonhosted.org/packages/86/1f/04b5627f6dba312d3e707e5b019c9f24d8b03b5aa366866a9e02ec00f8d4/pypdfium2-5.8.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:085e633dcc89b65ff4035a4787e98ce7ae636836eb39c83dd0db26113d9774bc", size = 3450815, upload-time = "2026-05-04T17:39:09.551Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/77/8e3a2aba2bc4aef5abe1b1306d05b00588dc0bf7f5c850d1adf6164c786b/pypdfium2-5.8.0-py3-none-macosx_11_0_x86_64.whl", hash = "sha256:bc84b7c6efede88fcfb9467f81daf416f26b973a54fc1cf4d3410d622fda6d7a", size = 3634395, upload-time = "2026-05-04T17:39:11.225Z" },
+    { url = "https://files.pythonhosted.org/packages/93/11/6f2b1847d9fa457b3b7251afc2bba2706d104a0c6f01431dfae5d679a839/pypdfium2-5.8.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a63bf09b2e13ba8545c930d243f0650c664a1b51314daa3b5f38df6d1a17b4bc", size = 3617413, upload-time = "2026-05-04T17:39:13.139Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/fd/99ce639de5ca06d21743c740dd988cd209dda623bc763ae10b8a162022e1/pypdfium2-5.8.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:937881c1698456749ed203a58db1895baa5eb7178cdb837ef84867790638da28", size = 3347639, upload-time = "2026-05-04T17:39:15.086Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/47/82864cc6e26dd8969d5594c168635acb16458d35cf5fed65d6b2e32abb42/pypdfium2-5.8.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6be9dc2b84a8694ad7e626bab133244e8241014d5ed1930d865a9bdf90df1e24", size = 3746404, upload-time = "2026-05-04T17:39:17.094Z" },
+    { url = "https://files.pythonhosted.org/packages/82/58/e41e49bba951f61921bac7289e67fe02af5ac57192d0bbfb5f459dc3691d/pypdfium2-5.8.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7f27bd82891ae302dd02d736b14809661f6d1220ee1e96dbed9b23e2811922a3", size = 4177893, upload-time = "2026-05-04T17:39:18.729Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/15/fa7031010d5cf6853dadb4864680a0bfb7782c5bb6a1a401e0c25c4fca87/pypdfium2-5.8.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26c1089cdbbdc7fe1248f6d17fe3f30214be4f287dd0196b31aaee18a1564240", size = 3665152, upload-time = "2026-05-04T17:39:20.207Z" },
+    { url = "https://files.pythonhosted.org/packages/de/6a/5a3520a8b0cfa8d7fdc3f03a07ad9d6146c28ffd519330706f64fd8939a8/pypdfium2-5.8.0-py3-none-manylinux_2_27_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c038a9290864aaa4862dd32e591993d82551ca4d152b4e8ce6d43ba37dc04a8", size = 3095365, upload-time = "2026-05-04T17:39:22.054Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d3/845bae4de3cfa36865959046156edb5bf9baea400ccdecdd84fdd911b0f5/pypdfium2-5.8.0-py3-none-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f104bc1a6d8bfc1ff088aa50db13b9729cfdb3722b44975c3c457e9a7b9c7318", size = 2961801, upload-time = "2026-05-04T17:39:23.817Z" },
+    { url = "https://files.pythonhosted.org/packages/99/76/cf54eabee4a172241dfcfe63533bd1e11e2162114a983453a5a40bfec114/pypdfium2-5.8.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:04ca7c57a553facf8d46c6ea8ba6fa557e698670cfa4a58e0e01fdae2f6be87d", size = 4133067, upload-time = "2026-05-04T17:39:25.619Z" },
+    { url = "https://files.pythonhosted.org/packages/77/66/dcf871d19187ca04ea184a99801a6e7e556d8347aa49540fee33cda6dfc5/pypdfium2-5.8.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ad42b9c22477b32dbedcbc8232833f385d92fd0cf92822547b02383cf9a476d7", size = 3749100, upload-time = "2026-05-04T17:39:27.203Z" },
+    { url = "https://files.pythonhosted.org/packages/32/67/0d456c79660959ca45ad307b4d67161d29f9ed4083ee1e8fe8c6925b7c82/pypdfium2-5.8.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:388e3119cf5ca0979b7d5f6d40b7fcd5ab49e17ed4e6de6af89ba116061acfda", size = 4339212, upload-time = "2026-05-04T17:39:29.277Z" },
+    { url = "https://files.pythonhosted.org/packages/76/89/e5b0e0f7936be341c91c0f45cd70d693878894ed62aed93a6ee32e9c43c4/pypdfium2-5.8.0-py3-none-musllinux_1_2_ppc64le.whl", hash = "sha256:aa05bbfa485ce7916217aa78d856c9f9cd86b08b20846c650392a67975ee72e9", size = 4383943, upload-time = "2026-05-04T17:39:31.287Z" },
+    { url = "https://files.pythonhosted.org/packages/82/21/4502ed255f082f579cd3537c2971cf1a57778d43703a08bcd1a92253189f/pypdfium2-5.8.0-py3-none-musllinux_1_2_riscv64.whl", hash = "sha256:f0813a16bb39d5ebd173ea5484430bb67a89b4b181db0a636c73b64ad063c3ea", size = 3925680, upload-time = "2026-05-04T17:39:33.241Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/4f/2e59723e7a07779439bd885c1b4960079c9710603308888d29ac926ae69a/pypdfium2-5.8.0-py3-none-musllinux_1_2_s390x.whl", hash = "sha256:a3c78f7d20dd821bec6c072efdb21a1370b9efe10fdeeb68c969e67608e25385", size = 4269560, upload-time = "2026-05-04T17:39:34.926Z" },
+    { url = "https://files.pythonhosted.org/packages/34/4e/7b6b1bde3788c8b880d4b8131d95d9d339cebafb3ad9102d82e234bb65be/pypdfium2-5.8.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:86d302e207c138c827b885a72784f7b306d840646ebeae07e8efdbc39321c629", size = 4182434, upload-time = "2026-05-04T17:39:36.624Z" },
+    { url = "https://files.pythonhosted.org/packages/11/7b/6ed4782e0d7a5278330598ce8c4b2df7255f4585a0b3d04520fa580d6507/pypdfium2-5.8.0-py3-none-win32.whl", hash = "sha256:3f25fd436920a907291462b41bdc0ab9f8235c3944b4c9c15398da595ffd1fed", size = 3636680, upload-time = "2026-05-04T17:39:38.49Z" },
+    { url = "https://files.pythonhosted.org/packages/19/55/da7223d4202b2461f4f889b0baf10dddec3db7f88e6fd8c52db4a516eecd/pypdfium2-5.8.0-py3-none-win_amd64.whl", hash = "sha256:55592af0bddd2d62bed18e0053c546c9b72041430c5115e54870f7f6163125b0", size = 3754962, upload-time = "2026-05-04T17:39:40.13Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7a/f3dcefe6ee7389aad3ca1488c177e8fbf978206de21c7a99ccf487ea38ab/pypdfium2-5.8.0-py3-none-win_arm64.whl", hash = "sha256:3f17ed97ae8a5a1705301ca93af256a5b02f9009dee4e99c5e175831d46ebd7c", size = 3548362, upload-time = "2026-05-04T17:39:42.304Z" },
 ]
 
 [[package]]
 name = "pyspellchecker"
-version = "0.8.4"
+version = "0.9.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a8/f4/870865239781117f75f788594c98fc3c65836ad9b93779550f369700187a/pyspellchecker-0.8.4.tar.gz", hash = "sha256:48cafa76d65c30ce4d81d0831938f25e8f34ede243c1cc6840014b0eb51ad629", size = 7238678, upload-time = "2025-11-30T00:18:39.415Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b9/70/58443d052adb868fee9fafb26553d482f2cc4d7c5ed5bb46846a7ce62a01/pyspellchecker-0.9.0.tar.gz", hash = "sha256:eb1a594161c84a4e67df7db1c269a3392a645bd50e4c82e1298892db0cdb0965", size = 7239784, upload-time = "2026-03-07T17:14:53.219Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8e/79/2a6993dd02c537ae1344a693f20f9b556206a5385c398022fb66cb004b3a/pyspellchecker-0.8.4-py3-none-any.whl", hash = "sha256:20c53d119568011bbaef68608aceb956b888bcd9d563798f7770721a112b8255", size = 7236997, upload-time = "2025-11-30T00:18:37.411Z" },
+    { url = "https://files.pythonhosted.org/packages/11/70/df4b8816f5e1aa8b46fbc2b1d104d8f5bc13ec92fb69310b35bc56ea7260/pyspellchecker-0.9.0-py3-none-any.whl", hash = "sha256:97eaed776e0854f69aafb723f6962b403099e50c9a1d9c05525c819f4b0f5d54", size = 7237077, upload-time = "2026-03-07T17:14:51.444Z" },
 ]
 
 [[package]]
 name = "pytest"
-version = "8.4.2"
+version = "9.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -2489,36 +2428,36 @@ dependencies = [
     { name = "pluggy" },
     { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 
 [[package]]
 name = "pytest-asyncio"
-version = "1.2.0"
+version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/42/86/9e3c5f48f7b7b638b216e4b9e645f54d199d7abbbab7a64a13b4e12ba10f/pytest_asyncio-1.2.0.tar.gz", hash = "sha256:c609a64a2a8768462d0c99811ddb8bd2583c33fd33cf7f21af1c142e824ffb57", size = 50119, upload-time = "2025-09-12T07:33:53.816Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/93/2fa34714b7a4ae72f2f8dad66ba17dd9a2c793220719e736dda28b7aec27/pytest_asyncio-1.2.0-py3-none-any.whl", hash = "sha256:8e17ae5e46d8e7efe51ab6494dd2010f4ca8dae51652aa3c8d55acf50bfb2e99", size = 15095, upload-time = "2025-09-12T07:33:52.639Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
 ]
 
 [[package]]
 name = "pytest-cov"
-version = "7.0.0"
+version = "7.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "coverage", extra = ["toml"] },
     { name = "pluggy" },
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
 ]
 
 [[package]]
@@ -2572,20 +2511,20 @@ wheels = [
 
 [[package]]
 name = "python-dotenv"
-version = "1.1.1"
+version = "1.2.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload-time = "2025-06-24T04:21:07.341Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
 ]
 
 [[package]]
 name = "python-multipart"
-version = "0.0.20"
+version = "0.0.29"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158, upload-time = "2024-12-16T19:45:46.972Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/fe/70bd71a6738b09a0bdf6480ca6436b167469ca4578b2a0efbe390b4b0e70/python_multipart-0.0.29.tar.gz", hash = "sha256:643e93849196645e2dbdd81a0f8829a23123ad7f797a84a364c6fb3563f18904", size = 45678, upload-time = "2026-05-17T17:29:47.654Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546, upload-time = "2024-12-16T19:45:44.423Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/cb/769cfc37177252872a45a71f3fbdde9d51b471a3f3c14bfe95dde3407386/python_multipart-0.0.29-py3-none-any.whl", hash = "sha256:2ddcc971cef266225f54f552d8fa10bcfbb1f14446caec199060daac59ff2d69", size = 29640, upload-time = "2026-05-17T17:29:45.69Z" },
 ]
 
 [[package]]
@@ -2630,82 +2569,72 @@ wheels = [
 
 [[package]]
 name = "redis"
-version = "6.4.0"
+version = "7.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "async-timeout", marker = "python_full_version < '3.11.3'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0d/d6/e8b92798a5bd67d659d51a18170e91c16ac3b59738d91894651ee255ed49/redis-6.4.0.tar.gz", hash = "sha256:b01bc7282b8444e28ec36b261df5375183bb47a07eb9c603f284e89cbc5ef010", size = 4647399, upload-time = "2025-08-07T08:10:11.441Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e8/02/89e2ed7e85db6c93dfa9e8f691c5087df4e3551ab39081a4d7c6d1f90e05/redis-6.4.0-py3-none-any.whl", hash = "sha256:f0544fa9604264e9464cdf4814e7d4830f74b165d52f2a330a760a88dd248b7f", size = 279847, upload-time = "2025-08-07T08:10:09.84Z" },
-]
-
-[[package]]
-name = "referencing"
-version = "0.36.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "attrs" },
-    { name = "rpds-py" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744, upload-time = "2025-01-25T08:48:16.138Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/7f/3759b1d0d72b7c92f0d70ffd9dc962b7b7b5ee74e135f9d7d8ab06b8a318/redis-7.4.0.tar.gz", hash = "sha256:64a6ea7bf567ad43c964d2c30d82853f8df927c5c9017766c55a1d1ed95d18ad", size = 4943913, upload-time = "2026-03-24T09:14:37.53Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775, upload-time = "2025-01-25T08:48:14.241Z" },
+    { url = "https://files.pythonhosted.org/packages/74/3a/95deec7db1eb53979973ebd156f3369a72732208d1391cd2e5d127062a32/redis-7.4.0-py3-none-any.whl", hash = "sha256:a9c74a5c893a5ef8455a5adb793a31bb70feb821c86eccb62eebef5a19c429ec", size = 409772, upload-time = "2026-03-24T09:14:35.968Z" },
 ]
 
 [[package]]
 name = "regex"
-version = "2025.9.18"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/49/d3/eaa0d28aba6ad1827ad1e716d9a93e1ba963ada61887498297d3da715133/regex-2025.9.18.tar.gz", hash = "sha256:c5ba23274c61c6fef447ba6a39333297d0c247f53059dba0bca415cac511edc4", size = 400917, upload-time = "2025-09-19T00:38:35.79Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/58/61/80eda662fc4eb32bfedc331f42390974c9e89c7eac1b79cd9eea4d7c458c/regex-2025.9.18-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:51076980cd08cd13c88eb7365427ae27f0d94e7cebe9ceb2bb9ffdae8fc4d82a", size = 484832, upload-time = "2025-09-19T00:35:30.011Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/d9/33833d9abddf3f07ad48504ddb53fe3b22f353214bbb878a72eee1e3ddbf/regex-2025.9.18-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:828446870bd7dee4e0cbeed767f07961aa07f0ea3129f38b3ccecebc9742e0b8", size = 288994, upload-time = "2025-09-19T00:35:31.733Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/b3/526ee96b0d70ea81980cbc20c3496fa582f775a52e001e2743cc33b2fa75/regex-2025.9.18-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c28821d5637866479ec4cc23b8c990f5bc6dd24e5e4384ba4a11d38a526e1414", size = 286619, upload-time = "2025-09-19T00:35:33.221Z" },
-    { url = "https://files.pythonhosted.org/packages/65/4f/c2c096b02a351b33442aed5895cdd8bf87d372498d2100927c5a053d7ba3/regex-2025.9.18-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:726177ade8e481db669e76bf99de0b278783be8acd11cef71165327abd1f170a", size = 792454, upload-time = "2025-09-19T00:35:35.361Z" },
-    { url = "https://files.pythonhosted.org/packages/24/15/b562c9d6e47c403c4b5deb744f8b4bf6e40684cf866c7b077960a925bdff/regex-2025.9.18-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f5cca697da89b9f8ea44115ce3130f6c54c22f541943ac8e9900461edc2b8bd4", size = 858723, upload-time = "2025-09-19T00:35:36.949Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/01/dba305409849e85b8a1a681eac4c03ed327d8de37895ddf9dc137f59c140/regex-2025.9.18-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:dfbde38f38004703c35666a1e1c088b778e35d55348da2b7b278914491698d6a", size = 905899, upload-time = "2025-09-19T00:35:38.723Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/d0/c51d1e6a80eab11ef96a4cbad17fc0310cf68994fb01a7283276b7e5bbd6/regex-2025.9.18-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f2f422214a03fab16bfa495cfec72bee4aaa5731843b771860a471282f1bf74f", size = 798981, upload-time = "2025-09-19T00:35:40.416Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/5e/72db90970887bbe02296612bd61b0fa31e6d88aa24f6a4853db3e96c575e/regex-2025.9.18-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a295916890f4df0902e4286bc7223ee7f9e925daa6dcdec4192364255b70561a", size = 781900, upload-time = "2025-09-19T00:35:42.077Z" },
-    { url = "https://files.pythonhosted.org/packages/50/ff/596be45eea8e9bc31677fde243fa2904d00aad1b32c31bce26c3dbba0b9e/regex-2025.9.18-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:5db95ff632dbabc8c38c4e82bf545ab78d902e81160e6e455598014f0abe66b9", size = 852952, upload-time = "2025-09-19T00:35:43.751Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1b/2dfa348fa551e900ed3f5f63f74185b6a08e8a76bc62bc9c106f4f92668b/regex-2025.9.18-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:fb967eb441b0f15ae610b7069bdb760b929f267efbf522e814bbbfffdf125ce2", size = 844355, upload-time = "2025-09-19T00:35:45.309Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/bf/aefb1def27fe33b8cbbb19c75c13aefccfbef1c6686f8e7f7095705969c7/regex-2025.9.18-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f04d2f20da4053d96c08f7fde6e1419b7ec9dbcee89c96e3d731fca77f411b95", size = 787254, upload-time = "2025-09-19T00:35:46.904Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/4e/8ef042e7cf0dbbb401e784e896acfc1b367b95dfbfc9ada94c2ed55a081f/regex-2025.9.18-cp311-cp311-win32.whl", hash = "sha256:895197241fccf18c0cea7550c80e75f185b8bd55b6924fcae269a1a92c614a07", size = 264129, upload-time = "2025-09-19T00:35:48.597Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/7d/c4fcabf80dcdd6821c0578ad9b451f8640b9110fb3dcb74793dd077069ff/regex-2025.9.18-cp311-cp311-win_amd64.whl", hash = "sha256:7e2b414deae99166e22c005e154a5513ac31493db178d8aec92b3269c9cce8c9", size = 276160, upload-time = "2025-09-19T00:36:00.45Z" },
-    { url = "https://files.pythonhosted.org/packages/64/f8/0e13c8ae4d6df9d128afaba138342d532283d53a4c1e7a8c93d6756c8f4a/regex-2025.9.18-cp311-cp311-win_arm64.whl", hash = "sha256:fb137ec7c5c54f34a25ff9b31f6b7b0c2757be80176435bf367111e3f71d72df", size = 268471, upload-time = "2025-09-19T00:36:02.149Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/99/05859d87a66ae7098222d65748f11ef7f2dff51bfd7482a4e2256c90d72b/regex-2025.9.18-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:436e1b31d7efd4dcd52091d076482031c611dde58bf9c46ca6d0a26e33053a7e", size = 486335, upload-time = "2025-09-19T00:36:03.661Z" },
-    { url = "https://files.pythonhosted.org/packages/97/7e/d43d4e8b978890932cf7b0957fce58c5b08c66f32698f695b0c2c24a48bf/regex-2025.9.18-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c190af81e5576b9c5fdc708f781a52ff20f8b96386c6e2e0557a78402b029f4a", size = 289720, upload-time = "2025-09-19T00:36:05.471Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/3b/ff80886089eb5dcf7e0d2040d9aaed539e25a94300403814bb24cc775058/regex-2025.9.18-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e4121f1ce2b2b5eec4b397cc1b277686e577e658d8f5870b7eb2d726bd2300ab", size = 287257, upload-time = "2025-09-19T00:36:07.072Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/66/243edf49dd8720cba8d5245dd4d6adcb03a1defab7238598c0c97cf549b8/regex-2025.9.18-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:300e25dbbf8299d87205e821a201057f2ef9aa3deb29caa01cd2cac669e508d5", size = 797463, upload-time = "2025-09-19T00:36:08.399Z" },
-    { url = "https://files.pythonhosted.org/packages/df/71/c9d25a1142c70432e68bb03211d4a82299cd1c1fbc41db9409a394374ef5/regex-2025.9.18-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7b47fcf9f5316c0bdaf449e879407e1b9937a23c3b369135ca94ebc8d74b1742", size = 862670, upload-time = "2025-09-19T00:36:10.101Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/8f/329b1efc3a64375a294e3a92d43372bf1a351aa418e83c21f2f01cf6ec41/regex-2025.9.18-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:57a161bd3acaa4b513220b49949b07e252165e6b6dc910ee7617a37ff4f5b425", size = 910881, upload-time = "2025-09-19T00:36:12.223Z" },
-    { url = "https://files.pythonhosted.org/packages/35/9e/a91b50332a9750519320ed30ec378b74c996f6befe282cfa6bb6cea7e9fd/regex-2025.9.18-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4f130c3a7845ba42de42f380fff3c8aebe89a810747d91bcf56d40a069f15352", size = 802011, upload-time = "2025-09-19T00:36:13.901Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/1d/6be3b8d7856b6e0d7ee7f942f437d0a76e0d5622983abbb6d21e21ab9a17/regex-2025.9.18-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5f96fa342b6f54dcba928dd452e8d8cb9f0d63e711d1721cd765bb9f73bb048d", size = 786668, upload-time = "2025-09-19T00:36:15.391Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/ce/4a60e53df58bd157c5156a1736d3636f9910bdcc271d067b32b7fcd0c3a8/regex-2025.9.18-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:0f0d676522d68c207828dcd01fb6f214f63f238c283d9f01d85fc664c7c85b56", size = 856578, upload-time = "2025-09-19T00:36:16.845Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e8/162c91bfe7217253afccde112868afb239f94703de6580fb235058d506a6/regex-2025.9.18-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:40532bff8a1a0621e7903ae57fce88feb2e8a9a9116d341701302c9302aef06e", size = 849017, upload-time = "2025-09-19T00:36:18.597Z" },
-    { url = "https://files.pythonhosted.org/packages/35/34/42b165bc45289646ea0959a1bc7531733e90b47c56a72067adfe6b3251f6/regex-2025.9.18-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:039f11b618ce8d71a1c364fdee37da1012f5a3e79b1b2819a9f389cd82fd6282", size = 788150, upload-time = "2025-09-19T00:36:20.464Z" },
-    { url = "https://files.pythonhosted.org/packages/79/5d/cdd13b1f3c53afa7191593a7ad2ee24092a5a46417725ffff7f64be8342d/regex-2025.9.18-cp312-cp312-win32.whl", hash = "sha256:e1dd06f981eb226edf87c55d523131ade7285137fbde837c34dc9d1bf309f459", size = 264536, upload-time = "2025-09-19T00:36:21.922Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/f5/4a7770c9a522e7d2dc1fa3ffc83ab2ab33b0b22b447e62cffef186805302/regex-2025.9.18-cp312-cp312-win_amd64.whl", hash = "sha256:3d86b5247bf25fa3715e385aa9ff272c307e0636ce0c9595f64568b41f0a9c77", size = 275501, upload-time = "2025-09-19T00:36:23.4Z" },
-    { url = "https://files.pythonhosted.org/packages/df/05/9ce3e110e70d225ecbed455b966003a3afda5e58e8aec2964042363a18f4/regex-2025.9.18-cp312-cp312-win_arm64.whl", hash = "sha256:032720248cbeeae6444c269b78cb15664458b7bb9ed02401d3da59fe4d68c3a5", size = 268601, upload-time = "2025-09-19T00:36:25.092Z" },
+version = "2026.5.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/0e/49aee608ad09480e7fd276898c99ec6192985fa331abe4eb3a986094490b/regex-2026.5.9.tar.gz", hash = "sha256:a8234aa23ec39894bfe4a3f1b85616a7032481964a13ac6fc9f10de4f6fca270", size = 416074, upload-time = "2026-05-09T23:15:19.37Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/dc/c1f2df4027e82fc54b5a473e4b250f5139faca49a0fbe29a48668d228f34/regex-2026.5.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ccf5249114cc3e772ecdd88a98a86eca0fd74c61ce32a94743758c083fc05d48", size = 489445, upload-time = "2026-05-09T23:12:06.111Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d2/59f01110660081cce9c0bc30ebd0b5ee250dacf658e3248ed92f01e0e8ee/regex-2026.5.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:46f1326ca6e65b0879d23ca302c0f2415aad42ff0309b9c818e7949fe19a41d8", size = 291271, upload-time = "2026-05-09T23:12:07.731Z" },
+    { url = "https://files.pythonhosted.org/packages/58/b6/14b2c84ff90ddb370c81d27503f4a0fcf071496416f4855f6cc8c5d81c35/regex-2026.5.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ef31cbfe458e21c6122ba8150ff060e0c7789ed0d26eb423f25472584920b555", size = 289212, upload-time = "2026-05-09T23:12:09.266Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d0/4db86529117320de0c84afd90e70bb47434625875e34fcef9d8c127c5b16/regex-2026.5.9-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:992604d02e6d9c6d786c24a706a71ecffe1020fc1ef264044474cd81fa2c3919", size = 792310, upload-time = "2026-05-09T23:12:11.416Z" },
+    { url = "https://files.pythonhosted.org/packages/07/78/fe4800cd322f862ecffd2d553409b20d80650e5ed71b9d178f853d020b82/regex-2026.5.9-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9411dd64ca95477225734a93dfc8583b51916b8d5942f99d6cac21e09965451", size = 861721, upload-time = "2026-05-09T23:12:13.681Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/d0/b3618a895dd8feb897c61bb2954edd265e1767d82a01d53065d5871127a3/regex-2026.5.9-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4a3ff360dfb836fecdb93a4598f9d6e2ac81e3e397125145c6221bf58cf4c", size = 906460, upload-time = "2026-05-09T23:12:15.443Z" },
+    { url = "https://files.pythonhosted.org/packages/33/6f/1481597e859ef19508b345eec4afd1416ed6e6b459c75a64026ef193aecf/regex-2026.5.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a661a7d270a61f7cf460caee8b9fa2d5ef9e5c681234bcb9e0fe14f488e7dfc", size = 799843, upload-time = "2026-05-09T23:12:16.892Z" },
+    { url = "https://files.pythonhosted.org/packages/73/59/955734c803f59108deccba3597ae440c76b62a652733c0006e6243758420/regex-2026.5.9-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f079e50a0d3cc3cd5091fa9ff45869a2e6b2cd35895731edafb0327901a8d86d", size = 773610, upload-time = "2026-05-09T23:12:19.127Z" },
+    { url = "https://files.pythonhosted.org/packages/68/8f/70c04a236d651c81881dac42ef8538bddda6121434509d0a22d9e601503b/regex-2026.5.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4ebe8f0b5ec5a5024dc4a4c59f444c4e9afc5f2abdbb8962065b75d27fb971f9", size = 781645, upload-time = "2026-05-09T23:12:20.806Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/96/05c7434d88185e5d27fe54aeb74df86bd77cd79f52f0b4eae54faa8fea70/regex-2026.5.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:97cf3bc1b7d7d2306772ec07366c80d9df00ff79e79cea32898883a646d2fae2", size = 854473, upload-time = "2026-05-09T23:12:22.465Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/c1/6e3d8202d981f3117004bf341ee74893ba4ba8a9fbaf4b94615846550a08/regex-2026.5.9-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0f9eede6a5cbdc02d4978090186390936e1776a7d1359b21e41014c609880bcf", size = 763311, upload-time = "2026-05-09T23:12:24.351Z" },
+    { url = "https://files.pythonhosted.org/packages/93/c7/e7737f1526b3fb32bd4c337fd6c71c3ebb5c8296fc34d11197e0955d2e35/regex-2026.5.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:01f0f5f55f4b64dacec85dc116d3c05fd23ad3ff037bbc73a2085775953c2611", size = 844593, upload-time = "2026-05-09T23:12:26.341Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/27/0daffb1a535bb39f422c3d200f4ab023c71110ad66a32b366bee708baba0/regex-2026.5.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1268eddd8486dc561d08eee1156e40aa3a8fe10f4bdec8fa653b455fcbffd12c", size = 789167, upload-time = "2026-05-09T23:12:27.975Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/fc/294fe4fac4f2ed67207b17471815870c1c45b3a489e08e0ac96daea16ef6/regex-2026.5.9-cp311-cp311-win32.whl", hash = "sha256:8676474c07469d6f33dd1085ca2cd45f65785f32518f2b20e36d9953ca07f994", size = 266249, upload-time = "2026-05-09T23:12:30.141Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/b0/8dce459f6245bcf8f6e9f23ac9569f1a0f15c131cc0745e82b43226204cf/regex-2026.5.9-cp311-cp311-win_amd64.whl", hash = "sha256:246de9d60aa3f8538b519834dd95cbf276ea263d6a7bd5a3666dc3fa0230505b", size = 278423, upload-time = "2026-05-09T23:12:31.676Z" },
+    { url = "https://files.pythonhosted.org/packages/db/8d/f9aeff6ad63a3ef720386f2907e6d34a35a510a6e498ebad28b0fb3f6ab6/regex-2026.5.9-cp311-cp311-win_arm64.whl", hash = "sha256:d726ca3f0d76969bf1e8e477d160d3d666bbf999f6860bd314889e5345782046", size = 270420, upload-time = "2026-05-09T23:12:33.194Z" },
+    { url = "https://files.pythonhosted.org/packages/50/9b/6550044bc44e17c84d312c031c2ec42fbdb6a4ec4e29093be3a172d08772/regex-2026.5.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:57eeeb05db7979413dec5438f2db21d7ecbba787cde7a711df1a6f6df672aa06", size = 490451, upload-time = "2026-05-09T23:12:34.72Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/95/fc7ba4303b5a0f92446a12ee6778ef2c6c799233f5060042a31bf390cfe9/regex-2026.5.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:398c521292f4c7fb807001dcd54694d3a1fcafc179a36ad9cc56f98df85930b6", size = 292112, upload-time = "2026-05-09T23:12:36.285Z" },
+    { url = "https://files.pythonhosted.org/packages/54/4b/ee27938d1b2c443e89a9a10e00d2d19aa5ee300cd3d61140644e93bb083e/regex-2026.5.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f7a7c26137296beba7784de6eba69c6a93a63ccebc385e4962fe67e267a91225", size = 289599, upload-time = "2026-05-09T23:12:38.089Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/dd/ba103dc19614e25f3880800ca67ce093d6e21b325d72b8383c7bf906e9fa/regex-2026.5.9-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6441cc660d76107934a09c22167200839a0e89604a6297f78a974e66e931d2c0", size = 796732, upload-time = "2026-05-09T23:12:40.062Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e7/f035b4fd858b050b0080bf302968dc0f59ba34e391872d54936758e6844e/regex-2026.5.9-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:91328f1c23d47595ca3ef0a7557fa129c5a23404b775c770697d2f35b33e0107", size = 865440, upload-time = "2026-05-09T23:12:42.059Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/51/8cd301ecc899aea28124357f729f4272f44de7806fc7ca02490bfbe253e8/regex-2026.5.9-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:93a7860539414dddaefba2b40f8771765ae17949d4c7182b876ce429e11a8309", size = 912329, upload-time = "2026-05-09T23:12:44.373Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/1e/3fbe2fa1e8cebd62f3bb7d3321cff1640aca2e240b51d9bd624aad949260/regex-2026.5.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd2810d22146b6d838acc5ec15602cb6b47920aa4e33015df3868eedfd20bab8", size = 801239, upload-time = "2026-05-09T23:12:46.268Z" },
+    { url = "https://files.pythonhosted.org/packages/17/2f/6f6008682bf2cf98040a0d3153a8e557b6ab728d7713d045cee4ce544ab8/regex-2026.5.9-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:daff2bdbaf1d23e52fdff7c0b7bc2048b68f978df6a4d107ac981f94caef2e66", size = 777054, upload-time = "2026-05-09T23:12:48.051Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2b/eee0d20a6842ba04df4b8847a920b57ef56853f14ef85405473e586b605a/regex-2026.5.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4eeb011098fcb77af513dcef521a3dbecbf8849b1e38940759d293b7a93f5026", size = 785098, upload-time = "2026-05-09T23:12:49.851Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/98/6fc1e6410feefb92159edaed5041992bfe390e8d26c721865434acbca558/regex-2026.5.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:ea9c8ecfa1b73c73b626534d6626e5340d429630943672b8480724f44e84b962", size = 860095, upload-time = "2026-05-09T23:12:51.666Z" },
+    { url = "https://files.pythonhosted.org/packages/18/a3/bd855e0f2cb1a978ecf6fa6bb69632dd9c3f6ea3b81cde62fde14c9daec7/regex-2026.5.9-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cd2846168eb9ee3c513902bc8225409cb1caab31d04728b145171fa1625d9621", size = 765762, upload-time = "2026-05-09T23:12:53.413Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/66/0ae8c092e60b14c79d24f8e0b7f0aea5bfbffdcab00b5483d13404d3c3a5/regex-2026.5.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:39617fb0cde9c0e6306dc70e3bfc096f3da793219879f7ae7aa341a69fbdcf6d", size = 852100, upload-time = "2026-05-09T23:12:55.256Z" },
+    { url = "https://files.pythonhosted.org/packages/21/de/8dfde60fc1b21c946a893ba273403b72617edb261370cb1087099a83f088/regex-2026.5.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fd03c4f0e33280d15cae17159b899245d6b7c53d21def19b263b39655061f5ce", size = 789479, upload-time = "2026-05-09T23:12:57.573Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/1c/bdcc98f9a4af4fdd166c74941174619ccff4726d3ce32faa8e9a2ecd38dd/regex-2026.5.9-cp312-cp312-win32.whl", hash = "sha256:164eba9b755ea6f244b0d881196fbc1fac09714e9782c9e2732b813142033c8e", size = 266699, upload-time = "2026-05-09T23:12:59.14Z" },
+    { url = "https://files.pythonhosted.org/packages/78/87/240d36864f9e48ace85f72e79ced97ceb7f27ce87739a947dcb834b4e6bc/regex-2026.5.9-cp312-cp312-win_amd64.whl", hash = "sha256:86f40a5d6444db30a125c9c9177e6b25dad981cbc37451fd838f145e6edac92e", size = 277783, upload-time = "2026-05-09T23:13:00.789Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/b5/7b30f312b0669dff5beebe5b0989dc2d1a312b1a44fab852199c387a5b96/regex-2026.5.9-cp312-cp312-win_arm64.whl", hash = "sha256:96f5f58b54a063d7ea9dca08e1cf57bfe10499c4d579ee672da284f57f5f0070", size = 270513, upload-time = "2026-05-09T23:13:02.426Z" },
 ]
 
 [[package]]
 name = "reportlab"
-version = "4.4.4"
+version = "4.5.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "charset-normalizer" },
     { name = "pillow" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f8/fa/ed71f3e750afb77497641eb0194aeda069e271ce6d6931140f8787e0e69a/reportlab-4.4.4.tar.gz", hash = "sha256:cb2f658b7f4a15be2cc68f7203aa67faef67213edd4f2d4bdd3eb20dab75a80d", size = 3711935, upload-time = "2025-09-19T10:43:36.502Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4d/3f/b3861b7e40c9d66f4a04e018958d681d16b948bfd1963c962d43a8c23f66/reportlab-4.5.1.tar.gz", hash = "sha256:9fdf68f4de9171ec66acb4a5feed8f8ca2af43479e707a6fbb0daa75d88e5494", size = 3939748, upload-time = "2026-05-12T10:14:13.663Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/57/66/e040586fe6f9ae7f3a6986186653791fb865947f0b745290ee4ab026b834/reportlab-4.4.4-py3-none-any.whl", hash = "sha256:299b3b0534e7202bb94ed2ddcd7179b818dcda7de9d8518a57c85a58a1ebaadb", size = 1954981, upload-time = "2025-09-19T10:43:33.589Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/45/ea7fad10122440de6e845568d106bffdc456ca0e8a1d8ae10b46016087e4/reportlab-4.5.1-py3-none-any.whl", hash = "sha256:06fce8cb56c83307cfa4909cdf4e6a2ddbb44e5d6ef4d2edca896d7e9769f091", size = 1957812, upload-time = "2026-05-12T10:14:10.622Z" },
 ]
 
 [[package]]
 name = "requests"
-version = "2.32.5"
+version = "2.34.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -2713,21 +2642,21 @@ dependencies = [
     { name = "idna" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
 ]
 
 [[package]]
 name = "requests-file"
-version = "2.1.0"
+version = "3.0.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/72/97/bf44e6c6bd8ddbb99943baf7ba8b1a8485bcd2fe0e55e5708d7fee4ff1ae/requests_file-2.1.0.tar.gz", hash = "sha256:0f549a3f3b0699415ac04d167e9cb39bccfb730cb832b4d20be3d9867356e658", size = 6891, upload-time = "2024-05-21T16:28:00.24Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3c/f8/5dc70102e4d337063452c82e1f0d95e39abfe67aa222ed8a5ddeb9df8de8/requests_file-3.0.1.tar.gz", hash = "sha256:f14243d7796c588f3521bd423c5dea2ee4cc730e54a3cac9574d78aca1272576", size = 6967, upload-time = "2025-10-20T18:56:42.279Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d7/25/dd878a121fcfdf38f52850f11c512e13ec87c2ea72385933818e5b6c15ce/requests_file-2.1.0-py2.py3-none-any.whl", hash = "sha256:cf270de5a4c5874e84599fc5778303d496c10ae5e870bfa378818f35d21bda5c", size = 4244, upload-time = "2024-05-21T16:27:57.733Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/d5/de8f089119205a09da657ed4784c584ede8381a0ce6821212a6d4ca47054/requests_file-3.0.1-py2.py3-none-any.whl", hash = "sha256:d0f5eb94353986d998f80ac63c7f146a307728be051d4d1cd390dbdb59c10fa2", size = 4514, upload-time = "2025-10-20T18:56:41.184Z" },
 ]
 
 [[package]]
@@ -2744,124 +2673,61 @@ wheels = [
 
 [[package]]
 name = "rich"
-version = "14.2.0"
+version = "15.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown-it-py" },
     { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" },
-]
-
-[[package]]
-name = "rpds-py"
-version = "0.27.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e9/dd/2c0cbe774744272b0ae725f44032c77bdcab6e8bcf544bffa3b6e70c8dba/rpds_py-0.27.1.tar.gz", hash = "sha256:26a1c73171d10b7acccbded82bf6a586ab8203601e565badc74bbbf8bc5a10f8", size = 27479, upload-time = "2025-08-27T12:16:36.024Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b5/c1/7907329fbef97cbd49db6f7303893bd1dd5a4a3eae415839ffdfb0762cae/rpds_py-0.27.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:be898f271f851f68b318872ce6ebebbc62f303b654e43bf72683dbdc25b7c881", size = 371063, upload-time = "2025-08-27T12:12:47.856Z" },
-    { url = "https://files.pythonhosted.org/packages/11/94/2aab4bc86228bcf7c48760990273653a4900de89c7537ffe1b0d6097ed39/rpds_py-0.27.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:62ac3d4e3e07b58ee0ddecd71d6ce3b1637de2d373501412df395a0ec5f9beb5", size = 353210, upload-time = "2025-08-27T12:12:49.187Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/57/f5eb3ecf434342f4f1a46009530e93fd201a0b5b83379034ebdb1d7c1a58/rpds_py-0.27.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4708c5c0ceb2d034f9991623631d3d23cb16e65c83736ea020cdbe28d57c0a0e", size = 381636, upload-time = "2025-08-27T12:12:50.492Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/f4/ef95c5945e2ceb5119571b184dd5a1cc4b8541bbdf67461998cfeac9cb1e/rpds_py-0.27.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:abfa1171a9952d2e0002aba2ad3780820b00cc3d9c98c6630f2e93271501f66c", size = 394341, upload-time = "2025-08-27T12:12:52.024Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/7e/4bd610754bf492d398b61725eb9598ddd5eb86b07d7d9483dbcd810e20bc/rpds_py-0.27.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4b507d19f817ebaca79574b16eb2ae412e5c0835542c93fe9983f1e432aca195", size = 523428, upload-time = "2025-08-27T12:12:53.779Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/e5/059b9f65a8c9149361a8b75094864ab83b94718344db511fd6117936ed2a/rpds_py-0.27.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:168b025f8fd8d8d10957405f3fdcef3dc20f5982d398f90851f4abc58c566c52", size = 402923, upload-time = "2025-08-27T12:12:55.15Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/48/64cabb7daced2968dd08e8a1b7988bf358d7bd5bcd5dc89a652f4668543c/rpds_py-0.27.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb56c6210ef77caa58e16e8c17d35c63fe3f5b60fd9ba9d424470c3400bcf9ed", size = 384094, upload-time = "2025-08-27T12:12:57.194Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/e1/dc9094d6ff566bff87add8a510c89b9e158ad2ecd97ee26e677da29a9e1b/rpds_py-0.27.1-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:d252f2d8ca0195faa707f8eb9368955760880b2b42a8ee16d382bf5dd807f89a", size = 401093, upload-time = "2025-08-27T12:12:58.985Z" },
-    { url = "https://files.pythonhosted.org/packages/37/8e/ac8577e3ecdd5593e283d46907d7011618994e1d7ab992711ae0f78b9937/rpds_py-0.27.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6e5e54da1e74b91dbc7996b56640f79b195d5925c2b78efaa8c5d53e1d88edde", size = 417969, upload-time = "2025-08-27T12:13:00.367Z" },
-    { url = "https://files.pythonhosted.org/packages/66/6d/87507430a8f74a93556fe55c6485ba9c259949a853ce407b1e23fea5ba31/rpds_py-0.27.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ffce0481cc6e95e5b3f0a47ee17ffbd234399e6d532f394c8dce320c3b089c21", size = 558302, upload-time = "2025-08-27T12:13:01.737Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/bb/1db4781ce1dda3eecc735e3152659a27b90a02ca62bfeea17aee45cc0fbc/rpds_py-0.27.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:a205fdfe55c90c2cd8e540ca9ceba65cbe6629b443bc05db1f590a3db8189ff9", size = 589259, upload-time = "2025-08-27T12:13:03.127Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/0e/ae1c8943d11a814d01b482e1f8da903f88047a962dff9bbdadf3bd6e6fd1/rpds_py-0.27.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:689fb5200a749db0415b092972e8eba85847c23885c8543a8b0f5c009b1a5948", size = 554983, upload-time = "2025-08-27T12:13:04.516Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/d5/0b2a55415931db4f112bdab072443ff76131b5ac4f4dc98d10d2d357eb03/rpds_py-0.27.1-cp311-cp311-win32.whl", hash = "sha256:3182af66048c00a075010bc7f4860f33913528a4b6fc09094a6e7598e462fe39", size = 217154, upload-time = "2025-08-27T12:13:06.278Z" },
-    { url = "https://files.pythonhosted.org/packages/24/75/3b7ffe0d50dc86a6a964af0d1cc3a4a2cdf437cb7b099a4747bbb96d1819/rpds_py-0.27.1-cp311-cp311-win_amd64.whl", hash = "sha256:b4938466c6b257b2f5c4ff98acd8128ec36b5059e5c8f8372d79316b1c36bb15", size = 228627, upload-time = "2025-08-27T12:13:07.625Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/3f/4fd04c32abc02c710f09a72a30c9a55ea3cc154ef8099078fd50a0596f8e/rpds_py-0.27.1-cp311-cp311-win_arm64.whl", hash = "sha256:2f57af9b4d0793e53266ee4325535a31ba48e2f875da81a9177c9926dfa60746", size = 220998, upload-time = "2025-08-27T12:13:08.972Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/fe/38de28dee5df58b8198c743fe2bea0c785c6d40941b9950bac4cdb71a014/rpds_py-0.27.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:ae2775c1973e3c30316892737b91f9283f9908e3cc7625b9331271eaaed7dc90", size = 361887, upload-time = "2025-08-27T12:13:10.233Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/9a/4b6c7eedc7dd90986bf0fab6ea2a091ec11c01b15f8ba0a14d3f80450468/rpds_py-0.27.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2643400120f55c8a96f7c9d858f7be0c88d383cd4653ae2cf0d0c88f668073e5", size = 345795, upload-time = "2025-08-27T12:13:11.65Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/0e/e650e1b81922847a09cca820237b0edee69416a01268b7754d506ade11ad/rpds_py-0.27.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:16323f674c089b0360674a4abd28d5042947d54ba620f72514d69be4ff64845e", size = 385121, upload-time = "2025-08-27T12:13:13.008Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/ea/b306067a712988e2bff00dcc7c8f31d26c29b6d5931b461aa4b60a013e33/rpds_py-0.27.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9a1f4814b65eacac94a00fc9a526e3fdafd78e439469644032032d0d63de4881", size = 398976, upload-time = "2025-08-27T12:13:14.368Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/0a/26dc43c8840cb8fe239fe12dbc8d8de40f2365e838f3d395835dde72f0e5/rpds_py-0.27.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ba32c16b064267b22f1850a34051121d423b6f7338a12b9459550eb2096e7ec", size = 525953, upload-time = "2025-08-27T12:13:15.774Z" },
-    { url = "https://files.pythonhosted.org/packages/22/14/c85e8127b573aaf3a0cbd7fbb8c9c99e735a4a02180c84da2a463b766e9e/rpds_py-0.27.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5c20f33fd10485b80f65e800bbe5f6785af510b9f4056c5a3c612ebc83ba6cb", size = 407915, upload-time = "2025-08-27T12:13:17.379Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/7b/8f4fee9ba1fb5ec856eb22d725a4efa3deb47f769597c809e03578b0f9d9/rpds_py-0.27.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:466bfe65bd932da36ff279ddd92de56b042f2266d752719beb97b08526268ec5", size = 386883, upload-time = "2025-08-27T12:13:18.704Z" },
-    { url = "https://files.pythonhosted.org/packages/86/47/28fa6d60f8b74fcdceba81b272f8d9836ac0340570f68f5df6b41838547b/rpds_py-0.27.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:41e532bbdcb57c92ba3be62c42e9f096431b4cf478da9bc3bc6ce5c38ab7ba7a", size = 405699, upload-time = "2025-08-27T12:13:20.089Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/fd/c5987b5e054548df56953a21fe2ebed51fc1ec7c8f24fd41c067b68c4a0a/rpds_py-0.27.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f149826d742b406579466283769a8ea448eed82a789af0ed17b0cd5770433444", size = 423713, upload-time = "2025-08-27T12:13:21.436Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/ba/3c4978b54a73ed19a7d74531be37a8bcc542d917c770e14d372b8daea186/rpds_py-0.27.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80c60cfb5310677bd67cb1e85a1e8eb52e12529545441b43e6f14d90b878775a", size = 562324, upload-time = "2025-08-27T12:13:22.789Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/6c/6943a91768fec16db09a42b08644b960cff540c66aab89b74be6d4a144ba/rpds_py-0.27.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:7ee6521b9baf06085f62ba9c7a3e5becffbc32480d2f1b351559c001c38ce4c1", size = 593646, upload-time = "2025-08-27T12:13:24.122Z" },
-    { url = "https://files.pythonhosted.org/packages/11/73/9d7a8f4be5f4396f011a6bb7a19fe26303a0dac9064462f5651ced2f572f/rpds_py-0.27.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a512c8263249a9d68cac08b05dd59d2b3f2061d99b322813cbcc14c3c7421998", size = 558137, upload-time = "2025-08-27T12:13:25.557Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/96/6772cbfa0e2485bcceef8071de7821f81aeac8bb45fbfd5542a3e8108165/rpds_py-0.27.1-cp312-cp312-win32.whl", hash = "sha256:819064fa048ba01b6dadc5116f3ac48610435ac9a0058bbde98e569f9e785c39", size = 221343, upload-time = "2025-08-27T12:13:26.967Z" },
-    { url = "https://files.pythonhosted.org/packages/67/b6/c82f0faa9af1c6a64669f73a17ee0eeef25aff30bb9a1c318509efe45d84/rpds_py-0.27.1-cp312-cp312-win_amd64.whl", hash = "sha256:d9199717881f13c32c4046a15f024971a3b78ad4ea029e8da6b86e5aa9cf4594", size = 232497, upload-time = "2025-08-27T12:13:28.326Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/96/2817b44bd2ed11aebacc9251da03689d56109b9aba5e311297b6902136e2/rpds_py-0.27.1-cp312-cp312-win_arm64.whl", hash = "sha256:33aa65b97826a0e885ef6e278fbd934e98cdcfed80b63946025f01e2f5b29502", size = 222790, upload-time = "2025-08-27T12:13:29.71Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/ed/e1fba02de17f4f76318b834425257c8ea297e415e12c68b4361f63e8ae92/rpds_py-0.27.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:cdfe4bb2f9fe7458b7453ad3c33e726d6d1c7c0a72960bcc23800d77384e42df", size = 371402, upload-time = "2025-08-27T12:15:51.561Z" },
-    { url = "https://files.pythonhosted.org/packages/af/7c/e16b959b316048b55585a697e94add55a4ae0d984434d279ea83442e460d/rpds_py-0.27.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:8fabb8fd848a5f75a2324e4a84501ee3a5e3c78d8603f83475441866e60b94a3", size = 354084, upload-time = "2025-08-27T12:15:53.219Z" },
-    { url = "https://files.pythonhosted.org/packages/de/c1/ade645f55de76799fdd08682d51ae6724cb46f318573f18be49b1e040428/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eda8719d598f2f7f3e0f885cba8646644b55a187762bec091fa14a2b819746a9", size = 383090, upload-time = "2025-08-27T12:15:55.158Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/27/89070ca9b856e52960da1472efcb6c20ba27cfe902f4f23ed095b9cfc61d/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3c64d07e95606ec402a0a1c511fe003873fa6af630bda59bac77fac8b4318ebc", size = 394519, upload-time = "2025-08-27T12:15:57.238Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/28/be120586874ef906aa5aeeae95ae8df4184bc757e5b6bd1c729ccff45ed5/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:93a2ed40de81bcff59aabebb626562d48332f3d028ca2036f1d23cbb52750be4", size = 523817, upload-time = "2025-08-27T12:15:59.237Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/ef/70cc197bc11cfcde02a86f36ac1eed15c56667c2ebddbdb76a47e90306da/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:387ce8c44ae94e0ec50532d9cb0edce17311024c9794eb196b90e1058aadeb66", size = 403240, upload-time = "2025-08-27T12:16:00.923Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/35/46936cca449f7f518f2f4996e0e8344db4b57e2081e752441154089d2a5f/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aaf94f812c95b5e60ebaf8bfb1898a7d7cb9c1af5744d4a67fa47796e0465d4e", size = 385194, upload-time = "2025-08-27T12:16:02.802Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/62/29c0d3e5125c3270b51415af7cbff1ec587379c84f55a5761cc9efa8cd06/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:4848ca84d6ded9b58e474dfdbad4b8bfb450344c0551ddc8d958bf4b36aa837c", size = 402086, upload-time = "2025-08-27T12:16:04.806Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/66/03e1087679227785474466fdd04157fb793b3b76e3fcf01cbf4c693c1949/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2bde09cbcf2248b73c7c323be49b280180ff39fadcfe04e7b6f54a678d02a7cf", size = 419272, upload-time = "2025-08-27T12:16:06.471Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/24/e3e72d265121e00b063aef3e3501e5b2473cf1b23511d56e529531acf01e/rpds_py-0.27.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:94c44ee01fd21c9058f124d2d4f0c9dc7634bec93cd4b38eefc385dabe71acbf", size = 560003, upload-time = "2025-08-27T12:16:08.06Z" },
-    { url = "https://files.pythonhosted.org/packages/26/ca/f5a344c534214cc2d41118c0699fffbdc2c1bc7046f2a2b9609765ab9c92/rpds_py-0.27.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:df8b74962e35c9249425d90144e721eed198e6555a0e22a563d29fe4486b51f6", size = 590482, upload-time = "2025-08-27T12:16:10.137Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/08/4349bdd5c64d9d193c360aa9db89adeee6f6682ab8825dca0a3f535f434f/rpds_py-0.27.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:dc23e6820e3b40847e2f4a7726462ba0cf53089512abe9ee16318c366494c17a", size = 556523, upload-time = "2025-08-27T12:16:12.188Z" },
-]
-
-[[package]]
-name = "rsa"
-version = "4.9.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pyasn1" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/da/8a/22b7beea3ee0d44b1916c0c1cb0ee3af23b700b6da9f04991899d0c555d4/rsa-4.9.1.tar.gz", hash = "sha256:e7bdbfdb5497da4c07dfd35530e1a902659db6ff241e39d9953cad06ebd0ae75", size = 29034, upload-time = "2025-04-16T09:51:18.218Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696, upload-time = "2025-04-16T09:51:17.142Z" },
+    { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
 ]
 
 [[package]]
 name = "ruff"
-version = "0.14.7"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b7/5b/dd7406afa6c95e3d8fa9d652b6d6dd17dd4a6bf63cb477014e8ccd3dcd46/ruff-0.14.7.tar.gz", hash = "sha256:3417deb75d23bd14a722b57b0a1435561db65f0ad97435b4cf9f85ffcef34ae5", size = 5727324, upload-time = "2025-11-28T20:55:10.525Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8c/b1/7ea5647aaf90106f6d102230e5df874613da43d1089864da1553b899ba5e/ruff-0.14.7-py3-none-linux_armv6l.whl", hash = "sha256:b9d5cb5a176c7236892ad7224bc1e63902e4842c460a0b5210701b13e3de4fca", size = 13414475, upload-time = "2025-11-28T20:54:54.569Z" },
-    { url = "https://files.pythonhosted.org/packages/af/19/fddb4cd532299db9cdaf0efdc20f5c573ce9952a11cb532d3b859d6d9871/ruff-0.14.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:3f64fe375aefaf36ca7d7250292141e39b4cea8250427482ae779a2aa5d90015", size = 13634613, upload-time = "2025-11-28T20:55:17.54Z" },
-    { url = "https://files.pythonhosted.org/packages/40/2b/469a66e821d4f3de0440676ed3e04b8e2a1dc7575cf6fa3ba6d55e3c8557/ruff-0.14.7-py3-none-macosx_11_0_arm64.whl", hash = "sha256:93e83bd3a9e1a3bda64cb771c0d47cda0e0d148165013ae2d3554d718632d554", size = 12765458, upload-time = "2025-11-28T20:55:26.128Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/05/0b001f734fe550bcfde4ce845948ac620ff908ab7241a39a1b39bb3c5f49/ruff-0.14.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3838948e3facc59a6070795de2ae16e5786861850f78d5914a03f12659e88f94", size = 13236412, upload-time = "2025-11-28T20:55:28.602Z" },
-    { url = "https://files.pythonhosted.org/packages/11/36/8ed15d243f011b4e5da75cd56d6131c6766f55334d14ba31cce5461f28aa/ruff-0.14.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:24c8487194d38b6d71cd0fd17a5b6715cda29f59baca1defe1e3a03240f851d1", size = 13182949, upload-time = "2025-11-28T20:55:33.265Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/cf/fcb0b5a195455729834f2a6eadfe2e4519d8ca08c74f6d2b564a4f18f553/ruff-0.14.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:79c73db6833f058a4be8ffe4a0913b6d4ad41f6324745179bd2aa09275b01d0b", size = 13816470, upload-time = "2025-11-28T20:55:08.203Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/5d/34a4748577ff7a5ed2f2471456740f02e86d1568a18c9faccfc73bd9ca3f/ruff-0.14.7-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:12eb7014fccff10fc62d15c79d8a6be4d0c2d60fe3f8e4d169a0d2def75f5dad", size = 15289621, upload-time = "2025-11-28T20:55:30.837Z" },
-    { url = "https://files.pythonhosted.org/packages/53/53/0a9385f047a858ba133d96f3f8e3c9c66a31cc7c4b445368ef88ebeac209/ruff-0.14.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c623bbdc902de7ff715a93fa3bb377a4e42dd696937bf95669118773dbf0c50", size = 14975817, upload-time = "2025-11-28T20:55:24.107Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/d7/2f1c32af54c3b46e7fadbf8006d8b9bcfbea535c316b0bd8813d6fb25e5d/ruff-0.14.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f53accc02ed2d200fa621593cdb3c1ae06aa9b2c3cae70bc96f72f0000ae97a9", size = 14284549, upload-time = "2025-11-28T20:55:06.08Z" },
-    { url = "https://files.pythonhosted.org/packages/92/05/434ddd86becd64629c25fb6b4ce7637dd52a45cc4a4415a3008fe61c27b9/ruff-0.14.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:281f0e61a23fcdcffca210591f0f53aafaa15f9025b5b3f9706879aaa8683bc4", size = 14071389, upload-time = "2025-11-28T20:55:35.617Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/50/fdf89d4d80f7f9d4f420d26089a79b3bb1538fe44586b148451bc2ba8d9c/ruff-0.14.7-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:dbbaa5e14148965b91cb090236931182ee522a5fac9bc5575bafc5c07b9f9682", size = 14202679, upload-time = "2025-11-28T20:55:01.472Z" },
-    { url = "https://files.pythonhosted.org/packages/77/54/87b34988984555425ce967f08a36df0ebd339bb5d9d0e92a47e41151eafc/ruff-0.14.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:1464b6e54880c0fe2f2d6eaefb6db15373331414eddf89d6b903767ae2458143", size = 13147677, upload-time = "2025-11-28T20:55:19.933Z" },
-    { url = "https://files.pythonhosted.org/packages/67/29/f55e4d44edfe053918a16a3299e758e1c18eef216b7a7092550d7a9ec51c/ruff-0.14.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f217ed871e4621ea6128460df57b19ce0580606c23aeab50f5de425d05226784", size = 13151392, upload-time = "2025-11-28T20:55:21.967Z" },
-    { url = "https://files.pythonhosted.org/packages/36/69/47aae6dbd4f1d9b4f7085f4d9dcc84e04561ee7ad067bf52e0f9b02e3209/ruff-0.14.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6be02e849440ed3602d2eb478ff7ff07d53e3758f7948a2a598829660988619e", size = 13412230, upload-time = "2025-11-28T20:55:12.749Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/4b/6e96cb6ba297f2ba502a231cd732ed7c3de98b1a896671b932a5eefa3804/ruff-0.14.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:19a0f116ee5e2b468dfe80c41c84e2bbd6b74f7b719bee86c2ecde0a34563bcc", size = 14195397, upload-time = "2025-11-28T20:54:56.896Z" },
-    { url = "https://files.pythonhosted.org/packages/69/82/251d5f1aa4dcad30aed491b4657cecd9fb4274214da6960ffec144c260f7/ruff-0.14.7-py3-none-win32.whl", hash = "sha256:e33052c9199b347c8937937163b9b149ef6ab2e4bb37b042e593da2e6f6cccfa", size = 13126751, upload-time = "2025-11-28T20:55:03.47Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/b5/d0b7d145963136b564806f6584647af45ab98946660d399ec4da79cae036/ruff-0.14.7-py3-none-win_amd64.whl", hash = "sha256:e17a20ad0d3fad47a326d773a042b924d3ac31c6ca6deb6c72e9e6b5f661a7c6", size = 14531726, upload-time = "2025-11-28T20:54:59.121Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/d2/1637f4360ada6a368d3265bf39f2cf737a0aaab15ab520fc005903e883f8/ruff-0.14.7-py3-none-win_arm64.whl", hash = "sha256:be4d653d3bea1b19742fcc6502354e32f65cd61ff2fbdb365803ef2c2aec6228", size = 13609215, upload-time = "2025-11-28T20:55:15.375Z" },
+version = "0.15.13"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/21/a7d5c126d5b557715ef81098f3db2fe20f622a039ff2e626af28d674ab80/ruff-0.15.13.tar.gz", hash = "sha256:f9d89f17f7ba7fb2ed42921f0df75da797a9a5d71bc39049e2c687cf2baf44b7", size = 4678180, upload-time = "2026-05-14T13:44:37.869Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/61/11d458dc6ac22504fd8e237b29dfd40504c7fbbcc8930402cfe51a8e63ed/ruff-0.15.13-py3-none-linux_armv6l.whl", hash = "sha256:444b580fc72fd6887e650acd3e575e18cdc79dbcf42fb4030b491057921f61f8", size = 10738279, upload-time = "2026-05-14T13:44:18.7Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ca/caa871ee7be718c45256fada4e16a218ee3e33f0c4a46b729a60a24912e6/ruff-0.15.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6590d009e7cb7ebf36f83dbdd44a3fa48a0994ff6f1cdc1b08006abe58f98dc7", size = 11124798, upload-time = "2026-05-14T13:44:06.427Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/19/43f5f2e568dddde567fc41f8471f9432c09563e19d3e617a48cfa52f8f0a/ruff-0.15.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1c26d2f66163deeb6e08d8b39fbbe983ce3c71cea06a6d7591cfd1421793c629", size = 10460761, upload-time = "2026-05-14T13:44:04.375Z" },
+    { url = "https://files.pythonhosted.org/packages/99/df/cf938cd6de3003178f03ad7c1ea2a6c099468c03a35037985070b37e76be/ruff-0.15.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9dbd6f94b434f896308e4d57fb7bfde0d02b99f7a64b3bdab0fdfa6a864203a5", size = 10804451, upload-time = "2026-05-14T13:44:25.221Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/7d/5d0973129b154ded2225729169d7068f26b467760b146493fde138415f23/ruff-0.15.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bf3259f3be4d181bda591da5db2571aed6853c6a048157756448020bc6c5cd22", size = 10534285, upload-time = "2026-05-14T13:44:08.888Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/e3/6b999bbc66cd51e5f073842bc2a3995e99c5e0e72e16b15e7261f7abf57a/ruff-0.15.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae9c17e5eb4430c154e76abc25d79a318190f5a997f38fb6b114416c5319ffc9", size = 11312063, upload-time = "2026-05-14T13:44:11.274Z" },
+    { url = "https://files.pythonhosted.org/packages/af/5a/642639e9f5db04f1e97fbd6e091c6fd20725bdf072fb114d00eefb9e6eb8/ruff-0.15.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2e2e39bff6c341f4b577a21b801326fab0b11847f48fcaa83f00a113c9b3cb55", size = 12183079, upload-time = "2026-05-14T13:44:01.634Z" },
+    { url = "https://files.pythonhosted.org/packages/19/4c/7585735f6b53b0f12de13618b2f7d250a844f018822efc899df2e7b8295f/ruff-0.15.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e8d9a8e08013542e94d3220bc5b62cc3e5ef87c5f74bff367d3fac14fab013e6", size = 11440833, upload-time = "2026-05-14T13:43:59.043Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/31/bf1a0803d077e679cfeee5f2f67290a0fa79c7385b5d9a8c17b9db2c48f0/ruff-0.15.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc411dfebe5eebe55ce041c6ae080eb7668955e866daa2fbb16692a784f1c4ca", size = 11434486, upload-time = "2026-05-14T13:44:27.761Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4e/62c9b999875d4f14db80f277c030578f5e249c9852d65b7ac7ad0b43c041/ruff-0.15.13-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:768494eb08b9cee54e2fd27969966f74db5a57f6eaa7a90fcb3306af34dfc4bd", size = 11385189, upload-time = "2026-05-14T13:44:13.704Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/89/7e959047a104df3eb12863447c110140191fc5b6c4f379ea2e803fcdb0e4/ruff-0.15.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:fb75f9a3a7e42ffe117d734494e6c5e5cb3565d66e12612cb63d0e572a41a5b6", size = 10781380, upload-time = "2026-05-14T13:43:56.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/52/5fd18f3b88cab63e88aa11516b3b4e1e5f720e5c330f8dbe5c26210f41f8/ruff-0.15.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8cb74dd33bb2f6613faf7fc03b660053b5ac4f80e706d5788c6335e2a8048d51", size = 10540605, upload-time = "2026-05-14T13:44:20.748Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/e0/9e35f338990d3e41a82875ff7053ffe97541dae81c9d02143177f381d572/ruff-0.15.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:7ef823f817fcd191dc934e984be9cf4094f808effa16f2542ad8e821ba02bbf2", size = 11036554, upload-time = "2026-05-14T13:44:16.256Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/13/070fb048c24080fba188f66371e2a92785be257ad02242066dc7255ac6e9/ruff-0.15.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:f345a13937bd7f09f6f5d19fa0721b0c103e00e7f62bc67089a8e5e037719e0b", size = 11528133, upload-time = "2026-05-14T13:44:22.808Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/8c/b1e1666aef7fc6555094d73ae6cd981701781ae85b97ceefc0eebd0b4668/ruff-0.15.13-py3-none-win32.whl", hash = "sha256:4044f94208b3b05ba0fc4a4abd0558cf4d6459bd18325eead7fd8cc66f909b41", size = 10721455, upload-time = "2026-05-14T13:44:35.697Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a6/870a3e8a50590bb92be184ad928c2922f088b00d9dc5c5ec7b924ee08c22/ruff-0.15.13-py3-none-win_amd64.whl", hash = "sha256:7064884d442b7d477b4e7473d12da7f08851d2b1982763c5d3f388a19468a1a4", size = 11900409, upload-time = "2026-05-14T13:44:30.389Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/36/9c015cd052fca743dae8cb2aeb16b551444787467db42ceab0fc968865af/ruff-0.15.13-py3-none-win_arm64.whl", hash = "sha256:2471da9bd1068c8c064b5fd9c0c4b6dddffd6369cb1cd68b29993b1709ff1b21", size = 11179336, upload-time = "2026-05-14T13:44:33.026Z" },
 ]
 
 [[package]]
 name = "s3transfer"
-version = "0.13.1"
+version = "0.14.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "botocore" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/05/d52bf1e65044b4e5e27d4e63e8d1579dbdec54fce685908ae09bc3720030/s3transfer-0.13.1.tar.gz", hash = "sha256:c3fdba22ba1bd367922f27ec8032d6a1cf5f10c934fb5d68cf60fd5a23d936cf", size = 150589, upload-time = "2025-07-18T19:22:42.31Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/62/74/8d69dcb7a9efe8baa2046891735e5dfe433ad558ae23d9e3c14c633d1d58/s3transfer-0.14.0.tar.gz", hash = "sha256:eff12264e7c8b4985074ccce27a3b38a485bb7f7422cc8046fee9be4983e4125", size = 151547, upload-time = "2025-09-09T19:23:31.089Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6d/4f/d073e09df851cfa251ef7840007d04db3293a0482ce607d2b993926089be/s3transfer-0.13.1-py3-none-any.whl", hash = "sha256:a981aa7429be23fe6dfc13e80e4020057cbab622b08c0315288758d67cabc724", size = 85308, upload-time = "2025-07-18T19:22:40.947Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f0/ae7ca09223a81a1d890b2557186ea015f6e0502e9b8cb8e1813f1d8cfa4e/s3transfer-0.14.0-py3-none-any.whl", hash = "sha256:ea3b790c7077558ed1f02a3072fb3cb992bbbd253392f4b6e9e8976941c7d456", size = 85712, upload-time = "2025-09-09T19:23:30.041Z" },
 ]
 
 [[package]]
 name = "setuptools"
-version = "80.9.0"
+version = "82.0.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4f/db/cfac1baf10650ab4d1c111714410d2fbb77ac5a616db26775db562c8fab2/setuptools-82.0.1.tar.gz", hash = "sha256:7d872682c5d01cfde07da7bccc7b65469d3dca203318515ada1de5eda35efbf9", size = 1152316, upload-time = "2026-03-09T12:47:17.221Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/76/f789f7a86709c6b087c5a2f52f911838cad707cc613162401badc665acfe/setuptools-82.0.1-py3-none-any.whl", hash = "sha256:a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb", size = 1006223, upload-time = "2026-03-09T12:47:15.026Z" },
 ]
 
 [[package]]
@@ -2882,16 +2748,25 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
 ]
 
+[[package]]
+name = "sly"
+version = "0.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/41/8a/59e943f7b27904c7756a7b565ffbd55f3841f5cd3d2da2b2b0713c49e488/sly-0.5.tar.gz", hash = "sha256:251d42015e8507158aec2164f06035df4a82b0314ce6450f457d7125e7649024", size = 66702, upload-time = "2022-10-25T14:35:30.592Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/4d/c96d807295183f2360329cd8d8bf5e8072c53d664125b3858c04153f026e/sly-0.5-py3-none-any.whl", hash = "sha256:20485483259eec7f6ba85ff4d2e96a4e50c6621902667fc2695cc8bc2a3e5133", size = 28864, upload-time = "2022-10-25T14:35:28.054Z" },
+]
+
 [[package]]
 name = "smart-open"
-version = "7.3.1"
+version = "7.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/16/be/bf2d60280a9d7fac98ece2150a22538fa4332cda67d04d9618c8406f791e/smart_open-7.3.1.tar.gz", hash = "sha256:b33fee8dffd206f189d5e704106a8723afb4210d2ff47e0e1f7fbe436187a990", size = 51405, upload-time = "2025-09-08T10:03:53.726Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c5/65/3ada667d32675399001bf022ad3d9f3989b57101351ebc71d6fbe2384634/smart_open-7.6.1.tar.gz", hash = "sha256:4347996e7ba21db7cd1e059632e0b30395407e4f6c660d2ddffc8f2a9ae5f990", size = 54754, upload-time = "2026-05-09T06:23:37.06Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/d9/460cf1d58945dd771c228c29d5664f431dfc4060d3d092fed40546b11472/smart_open-7.3.1-py3-none-any.whl", hash = "sha256:e243b2e7f69d6c0c96dd763d6fbbedbb4e0e4fc6d74aa007acc5b018d523858c", size = 61722, upload-time = "2025-09-08T10:03:52.02Z" },
+    { url = "https://files.pythonhosted.org/packages/14/78/0f68b93564b8c6b6987a0696c582ba2591a381ab2f733a501909e949f241/smart_open-7.6.1-py3-none-any.whl", hash = "sha256:b4de6aebef023aca91cc9fb372052e1343ba3f152de215bd22391a663e3ddd21", size = 64845, upload-time = "2026-05-09T06:23:35.386Z" },
 ]
 
 [[package]]
@@ -2962,85 +2837,47 @@ wheels = [
 
 [[package]]
 name = "srsly"
-version = "2.5.1"
+version = "2.5.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "catalogue" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b7/e8/eb51b1349f50bac0222398af0942613fdc9d1453ae67cbe4bf9936a1a54b/srsly-2.5.1.tar.gz", hash = "sha256:ab1b4bf6cf3e29da23dae0493dd1517fb787075206512351421b89b4fc27c77e", size = 466464, upload-time = "2025-01-17T09:26:26.919Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2b/db/f794f219a6c788b881252d2536a8c4a97d2bdaadc690391e1cb53d123d71/srsly-2.5.3.tar.gz", hash = "sha256:08f98dbecbff3a31466c4ae7c833131f59d3655a0ad8ac749e6e2c149e2b0680", size = 490881, upload-time = "2026-03-23T11:56:59.865Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/df/9c/a248bb49de499fe0990e3cb0fb341c2373d8863ef9a8b5799353cade5731/srsly-2.5.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:58f0736794ce00a71d62a39cbba1d62ea8d5be4751df956e802d147da20ecad7", size = 635917, upload-time = "2025-01-17T09:25:25.109Z" },
-    { url = "https://files.pythonhosted.org/packages/41/47/1bdaad84502df973ecb8ca658117234cf7fb20e1dec60da71dce82de993f/srsly-2.5.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7a8269c40859806d71920396d185f4f38dc985cdb6a28d3a326a701e29a5f629", size = 634374, upload-time = "2025-01-17T09:25:26.609Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/2a/d73c71989fcf2a6d1fa518d75322aff4db01a8763f167f8c5e00aac11097/srsly-2.5.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:889905900401fefc1032e22b73aecbed8b4251aa363f632b2d1f86fc16f1ad8e", size = 1108390, upload-time = "2025-01-17T09:25:29.32Z" },
-    { url = "https://files.pythonhosted.org/packages/35/a3/9eda9997a8bd011caed18fdaa5ce606714eb06d8dab587ed0522b3e92ab1/srsly-2.5.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf454755f22589df49c25dc799d8af7b47dce3d861dded35baf0f0b6ceab4422", size = 1110712, upload-time = "2025-01-17T09:25:31.051Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/ef/4b50bc05d06349f905b27f824cc23b652098efd4be19aead3af4981df647/srsly-2.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cc0607c8a59013a51dde5c1b4e465558728e9e0a35dcfa73c7cbefa91a0aad50", size = 1081244, upload-time = "2025-01-17T09:25:32.611Z" },
-    { url = "https://files.pythonhosted.org/packages/90/af/d4a2512d9a5048d2b18efead39d4c4404bddd4972935bbc68211292a736c/srsly-2.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d5421ba3ab3c790e8b41939c51a1d0f44326bfc052d7a0508860fb79a47aee7f", size = 1091692, upload-time = "2025-01-17T09:25:34.15Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/da/657a685f63028dcb00ccdc4ac125ed347c8bff6fa0dab6a9eb3dc45f3223/srsly-2.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:b96ea5a9a0d0379a79c46d255464a372fb14c30f59a8bc113e4316d131a530ab", size = 632627, upload-time = "2025-01-17T09:25:37.36Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/f6/bebc20d75bd02121fc0f65ad8c92a5dd2570e870005e940faa55a263e61a/srsly-2.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:683b54ed63d7dfee03bc2abc4b4a5f2152f81ec217bbadbac01ef1aaf2a75790", size = 636717, upload-time = "2025-01-17T09:25:40.236Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/e8/9372317a4742c70b87b413335adfcdfb2bee4f88f3faba89fabb9e6abf21/srsly-2.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:459d987130e57e83ce9e160899afbeb871d975f811e6958158763dd9a8a20f23", size = 634697, upload-time = "2025-01-17T09:25:43.605Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/00/c6a7b99ab27b051a27bd26fe1a8c1885225bb8980282bf9cb99f70610368/srsly-2.5.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:184e3c98389aab68ff04aab9095bd5f1a8e5a72cc5edcba9d733bac928f5cf9f", size = 1134655, upload-time = "2025-01-17T09:25:45.238Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/e6/861459e8241ec3b78c111081bd5efa414ef85867e17c45b6882954468d6e/srsly-2.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c2a3e4856e63b7efd47591d049aaee8e5a250e098917f50d93ea68853fab78", size = 1143544, upload-time = "2025-01-17T09:25:47.485Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/85/8448fe874dd2042a4eceea5315cfff3af03ac77ff5073812071852c4e7e2/srsly-2.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:366b4708933cd8d6025c13c2cea3331f079c7bb5c25ec76fca392b6fc09818a0", size = 1098330, upload-time = "2025-01-17T09:25:52.55Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/7e/04d0e1417da140b2ac4053a3d4fcfc86cd59bf4829f69d370bb899f74d5d/srsly-2.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c8a0b03c64eb6e150d772c5149befbadd981cc734ab13184b0561c17c8cef9b1", size = 1110670, upload-time = "2025-01-17T09:25:54.02Z" },
-    { url = "https://files.pythonhosted.org/packages/96/1a/a8cd627eaa81a91feb6ceab50155f4ceff3eef6107916cb87ef796958427/srsly-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:7952538f6bba91b9d8bf31a642ac9e8b9ccc0ccbb309feb88518bfb84bb0dc0d", size = 632598, upload-time = "2025-01-17T09:25:55.499Z" },
-]
-
-[[package]]
-name = "sse-starlette"
-version = "3.0.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/42/6f/22ed6e33f8a9e76ca0a412405f31abb844b779d52c5f96660766edcd737c/sse_starlette-3.0.2.tar.gz", hash = "sha256:ccd60b5765ebb3584d0de2d7a6e4f745672581de4f5005ab31c3a25d10b52b3a", size = 20985, upload-time = "2025-07-27T09:07:44.565Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/10/c78f463b4ef22eef8491f218f692be838282cd65480f6e423d7730dfd1fb/sse_starlette-3.0.2-py3-none-any.whl", hash = "sha256:16b7cbfddbcd4eaca11f7b586f3b8a080f1afe952c15813455b162edea619e5a", size = 11297, upload-time = "2025-07-27T09:07:43.268Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/36/5d7bb412d52e9cca787f9bfe838b596367189b254e50bf90f234a97184bf/srsly-2.5.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:785a09216ac31570fb301ddb9f61ee73d1f18f8b9561f712dce0b8ac8628bc88", size = 656760, upload-time = "2026-03-23T11:55:47.155Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/dc/124f008cd2be3e887e972cbdeb17c5aee0f42093eca02c7cfd63bb5daf19/srsly-2.5.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0017c7d2a0cd9a4f1bdc00d946b45edcf90bb0e271e8f084c1ce542bf6708c32", size = 657503, upload-time = "2026-03-23T11:55:48.681Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8a/2c97244ebab125d55f1bfb7bb94e9572b3e819410dffd6a040eca1112350/srsly-2.5.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:66ebae2c70305987341519ec1a720072a3cb3e4b1d52ac0e9e841f4d02658d3d", size = 1139161, upload-time = "2026-03-23T11:55:50.179Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/ea/ecd396188f7591d80b89665f7af9e3ae02e42683daef57033ad7993ad3f9/srsly-2.5.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4ca4a068f6e14d84113a02fcb875c6b50a6285a12938c0e7a157eb3a63c50a86", size = 1142438, upload-time = "2026-03-23T11:55:52.607Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/65/143e2e143c53d498ad0956f69d0e09189aa7a6e0ee6017758c285ba1ab2d/srsly-2.5.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e283fa2a8f7350fb9fb70ecdee28d59d39c92f4c7f1cc90a44d6b86db3b3a8b3", size = 1101783, upload-time = "2026-03-23T11:55:53.906Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/86/1392a5593de0cd3d08c2d6c071b877c84358a37f63172c4e9cb71706842d/srsly-2.5.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9ffc97e22730ea97b00f7c303ccc60b1305e786afadb2a4a46578dafa4d29da0", size = 1115876, upload-time = "2026-03-23T11:55:55.624Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/a5/6193aa4c08e488821538fcbce2282449e228fd2183ed67d118bb5ccd8b54/srsly-2.5.3-cp311-cp311-win_amd64.whl", hash = "sha256:f09b551f6c3e334652831ac68c770ee4284741ce0a3895bf1ccf2a1178d66cdd", size = 651733, upload-time = "2026-03-23T11:55:56.964Z" },
+    { url = "https://files.pythonhosted.org/packages/66/a8/a73181743b6d237026615ca75c3fb3e4780736f1390550a7350d0c7f1149/srsly-2.5.3-cp311-cp311-win_arm64.whl", hash = "sha256:21cf09e417d3e4f3fbf7dd337fd6d948c97abd01896b9b4cb80e81cd9778a73a", size = 639124, upload-time = "2026-03-23T11:55:58.532Z" },
+    { url = "https://files.pythonhosted.org/packages/02/cc/e9f7fcec4cc92ad8bad6316c4241638b8cf7380382d4489d94ec6c436452/srsly-2.5.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:71e51c046ccbeefb86524c6b1e17574f579c6ac4dc8ea4a09437d3e8f88342d3", size = 658379, upload-time = "2026-03-23T11:55:59.85Z" },
+    { url = "https://files.pythonhosted.org/packages/21/e4/fea4512e9785f58509b2cf67d993323848e583161b5fcfdc7dd9d7c1f3df/srsly-2.5.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f73c0db911552e94fe2016e1759d261d2f47926f68826664cada3723c87006a", size = 658513, upload-time = "2026-03-23T11:56:01.239Z" },
+    { url = "https://files.pythonhosted.org/packages/20/b1/53591681b6ff2699a4f97b2d5552ba196eaa6a979b0873605f4c04b5f7ee/srsly-2.5.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c1ac27ae5f4bb9163c7d2c45fc8ec173aac3d92e32086d9472b326c5c6e570e", size = 1172265, upload-time = "2026-03-23T11:56:02.589Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/c9/741e29f534919a944a16da4184924b1d3404c4bf60716ab2b91be771d1e3/srsly-2.5.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:99026bcd9cbd3211cc36517400b04ca0fc5d3e412b14daf84ee6e65f67d9a2d8", size = 1180873, upload-time = "2026-03-23T11:56:03.944Z" },
+    { url = "https://files.pythonhosted.org/packages/89/57/5554f786eccf78b2750d6ac63be126e1b67badec2cb409dd611cf6f8c52b/srsly-2.5.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:07d682679e639eb46ff7e6da4a92714f4d5ffe351d088ee66f221e9b1f8865bb", size = 1120437, upload-time = "2026-03-23T11:56:05.283Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/95/9b4f73b1be3692f86d72ccc131c8e50f26f824d5c8830a59390bcc5b60ef/srsly-2.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8e0542d85d6b55cf2934050d6ffcb1cd76c768dcf9572e7467002cf087bb366d", size = 1137376, upload-time = "2026-03-23T11:56:06.613Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/de/89ca640ca1953c4612279ce515d0af35658df3c06cdb324329bc91b4a7e1/srsly-2.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:598f1e494c18cacb978299d77125415a586417081959f8ec3f068b32d97f8933", size = 652459, upload-time = "2026-03-23T11:56:07.994Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/4f/7ab6d49e36d9cc72ee15746cabd116eb6f338be8a06c1882968ee9d6c7d7/srsly-2.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:4b1b721cd3ad1a9b2343519aadc786a4d09d5c0666962d49852eb12d6ec3fe26", size = 638411, upload-time = "2026-03-23T11:56:09.31Z" },
 ]
 
 [[package]]
 name = "starlette"
-version = "0.48.0"
+version = "1.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a7/a5/d6f429d43394057b67a6b5bbe6eae2f77a6bf7459d961fdb224bf206eee6/starlette-0.48.0.tar.gz", hash = "sha256:7e8cee469a8ab2352911528110ce9088fdc6a37d9876926e73da7ce4aa4c7a46", size = 2652949, upload-time = "2025-09-13T08:41:05.699Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/72/2db2f49247d0a18b4f1bb9a5a39a0162869acf235f3a96418363947b3d46/starlette-0.48.0-py3-none-any.whl", hash = "sha256:0764ca97b097582558ecb498132ed0c7d942f233f365b86ba37770e026510659", size = 73736, upload-time = "2025-09-13T08:41:03.869Z" },
-]
-
-[[package]]
-name = "temporalio"
-version = "1.18.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "nexus-rpc" },
-    { name = "protobuf" },
-    { name = "types-protobuf" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/7e/20/b52c96b37bf00ead6e8a4a197075770ebad516db765cc3abca8396de0689/temporalio-1.18.0.tar.gz", hash = "sha256:7ff7f833eb1e7697084b4ed9d86c3167cbff1ec77f1b40df774313a5d0fd5f6d", size = 1781572, upload-time = "2025-09-19T23:40:52.511Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2f/28/c5a4ee259748450ac0765837f8c78cbfa36800264158d98bd2cde4496d87/temporalio-1.18.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:ac5d30d8b010c9b042065ea1259da7638db1a0a25e81ee4be0671a393ed329c5", size = 12734753, upload-time = "2025-09-19T23:40:06.575Z" },
-    { url = "https://files.pythonhosted.org/packages/be/94/24bd903b5594420a4d131bfa3de965313f9a409af77b47e9a9a56d85bb9e/temporalio-1.18.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:19315d192247230c9bd7c60a566c2b3a80ad4d9de891c6aa13df63d72d3ec169", size = 12323141, upload-time = "2025-09-19T23:40:16.817Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/76/82415b43c68e2c6bb3a85e8800555d206767815088c8cad0ade9a06bd7ac/temporalio-1.18.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a023b25033e48b2e43f623a78737047a45b8cb553f69f457d09272fce5c723da", size = 12694061, upload-time = "2025-09-19T23:40:26.388Z" },
-    { url = "https://files.pythonhosted.org/packages/41/60/176a3224c2739fee270052dd9224ae36370c4e13d2ab1bb96a2f9bbb513c/temporalio-1.18.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:695211dddbcffc20077d5b3b9a9b41bd09f60393c4ff211bcc7d6d895d607cc1", size = 12879404, upload-time = "2025-09-19T23:40:37.487Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/8d/e3809b356262d1d398d8cbb78df1e19d460c0a89e6ab64ca8d9c05d5fe5a/temporalio-1.18.0-cp39-abi3-win_amd64.whl", hash = "sha256:e3f691bd0a01a22c0fe40e87b6236cc8a292628e3a5a490880d1bf94709249c9", size = 13088041, upload-time = "2025-09-19T23:40:49.469Z" },
-]
-
-[[package]]
-name = "tenacity"
-version = "9.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0a/d4/2b0cd0fe285e14b36db076e78c93766ff1d529d70408bd1d2a5a84f1d929/tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb", size = 48036, upload-time = "2025-04-02T08:25:09.966Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/81/69/17425771797c36cded50b7fe44e850315d039f28b15901ab44839e70b593/starlette-1.0.0.tar.gz", hash = "sha256:6a4beaf1f81bb472fd19ea9b918b50dc3a77a6f2e190a12954b25e6ed5eea149", size = 2655289, upload-time = "2026-03-22T18:29:46.779Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248, upload-time = "2025-04-02T08:25:07.678Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/c9/584bc9651441b4ba60cc4d557d8a547b5aff901af35bda3a4ee30c819b82/starlette-1.0.0-py3-none-any.whl", hash = "sha256:d3ec55e0bb321692d275455ddfd3df75fff145d009685eb40dc91fc66b03d38b", size = 72651, upload-time = "2026-03-22T18:29:45.111Z" },
 ]
 
 [[package]]
 name = "testcontainers"
-version = "4.13.2"
+version = "4.14.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "docker" },
@@ -3049,9 +2886,9 @@ dependencies = [
     { name = "urllib3" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/18/51/edac83edab339d8b4dce9a7b659163afb1ea7e011bfed1d5573d495a4485/testcontainers-4.13.2.tar.gz", hash = "sha256:2315f1e21b059427a9d11e8921f85fef322fbe0d50749bcca4eaa11271708ba4", size = 78692, upload-time = "2025-10-07T21:53:07.531Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/ac/a597c3a0e02b26cbed6dd07df68be1e57684766fd1c381dee9b170a99690/testcontainers-4.14.2.tar.gz", hash = "sha256:1340ccf16fe3acd9389a6c9e1d9ab21d9fe99a8afdf8165f89c3e69c1967d239", size = 166841, upload-time = "2026-03-18T05:19:16.696Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/5e/73aa94770f1df0595364aed526f31d54440db5492911e2857318ed326e51/testcontainers-4.13.2-py3-none-any.whl", hash = "sha256:0209baf8f4274b568cde95bef2cadf7b1d33b375321f793790462e235cd684ee", size = 124771, upload-time = "2025-10-07T21:53:05.937Z" },
+    { url = "https://files.pythonhosted.org/packages/13/2d/26b8b30067d94339afee62c3edc9b803a6eb9332f521ba77d8aaab5de873/testcontainers-4.14.2-py3-none-any.whl", hash = "sha256:0d0522c3cd8f8d9627cda41f7a6b51b639fa57bdc492923c045117933c668d68", size = 125712, upload-time = "2026-03-18T05:19:15.29Z" },
 ]
 
 [package.optional-dependencies]
@@ -3061,7 +2898,7 @@ redis = [
 
 [[package]]
 name = "textual"
-version = "6.11.0"
+version = "8.2.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown-it-py", extra = ["linkify"] },
@@ -3071,14 +2908,14 @@ dependencies = [
     { name = "rich" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/55/06/906f86bbc59ec7cd3fb424250e19ce670406d1f28e49e86c2221e9fd7ed2/textual-6.11.0.tar.gz", hash = "sha256:08237ebda0cfbbfd1a4e2fd3039882b35894a73994f6f0fcc12c5b0d78acf3cc", size = 1584292, upload-time = "2025-12-18T10:48:38.033Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9b/7a/c519db0aba5024f86e71e9631810bfdd6866ed2c8695bd7fa34b90e7ef59/textual-8.2.7.tar.gz", hash = "sha256:658f568ff81e30ed43890c3e07520390e5cf1b4763822006e060656b0a88f105", size = 1859249, upload-time = "2026-05-19T10:52:49.531Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b5/fc/5e2988590ff2e0128eea6446806c904445a44e17256c67141573ea16b5a5/textual-6.11.0-py3-none-any.whl", hash = "sha256:9e663b73ed37123a9b13c16a0c85e09ef917a4cfded97814361ed5cccfa40f89", size = 714886, upload-time = "2025-12-18T10:48:36.269Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f5/c1e18bc0707300a0e90204343abbf7d7acd6fb7ebe03a6d4893b99a234b8/textual-8.2.7-py3-none-any.whl", hash = "sha256:4caaa13a90bc4cf9c6c862c067ccd34fe84e9c161710a2a907a8026313b6bd73", size = 731129, upload-time = "2026-05-19T10:52:51.773Z" },
 ]
 
 [[package]]
 name = "thinc"
-version = "8.2.4"
+version = "8.2.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "blis" },
@@ -3094,87 +2931,72 @@ dependencies = [
     { name = "srsly" },
     { name = "wasabi" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/39/e6/12f9d4ade7af128db91f725675bc9f417e6f6ea777478f5c1c3140a105a9/thinc-8.2.4.tar.gz", hash = "sha256:9383b39f286291519ebbb6454bab76404992599b0cbdfaec56b2f985023186a7", size = 192961, upload-time = "2024-06-04T21:15:34.148Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3b/2a/0e2e961e6152bedecca70e6833f6e827ee621efcee7496643242b506d54f/thinc-8.2.5.tar.gz", hash = "sha256:c2963791c934cc7fbd8f9b942d571cac79892ad11630bfca690a868c32752b75", size = 193031, upload-time = "2024-06-19T16:42:44.563Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4c/5c/7229e7c8878a480f352ab3536372287919f84c6396391c1709a73eb05182/thinc-8.2.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ccc58e47bc285e9afbf92ed6104f555abfa285a4b92198d955d344c4c1942607", size = 863703, upload-time = "2024-06-04T21:13:56.189Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/3f/7daca81216723222b3353dd9cefbda1ea2f3bfbac7ff9a725bfacbfa1c96/thinc-8.2.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:baa4af044bfcaf9df6a02d6c6d6e96c960da540478a522daabfbde8923df3554", size = 781179, upload-time = "2024-06-04T21:13:58.412Z" },
-    { url = "https://files.pythonhosted.org/packages/20/a0/dfc97237ae66d3ce9bb892c8b91ed729d1dfe01548f85953716169f98aec/thinc-8.2.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b0e34bf322516a039e45c1da72eb82bcc97eb1f7c232b66b88f0c86f15a1202", size = 868315, upload-time = "2024-06-04T21:14:00.57Z" },
-    { url = "https://files.pythonhosted.org/packages/06/06/cb247012a34e7043f911e9bcb0bdf0b5daa37cd1130e51afaa48a61ff5a6/thinc-8.2.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ebc8ab48d19cd69ad9a0de2bbe49b7c20a91150faeb119638bea4c502c52b77f", size = 920139, upload-time = "2024-06-04T21:14:03.502Z" },
-    { url = "https://files.pythonhosted.org/packages/46/a9/34b82ee16f4b5da2ced75a068ea0ab616e178269af17d6555266a44dfcc4/thinc-8.2.4-cp311-cp311-win_amd64.whl", hash = "sha256:9f8c6c006b7cbe3ebb543c224159b004b52a8ff8922615577656e1458ee4bbf0", size = 1480113, upload-time = "2024-06-04T21:14:09.606Z" },
-    { url = "https://files.pythonhosted.org/packages/74/09/b9de561b34642a6f2f522bf17d29c7bd735fffa2964a677be62ec0b94311/thinc-8.2.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:997a1a399af074b34e25695f37ad48f8437e7c150705891f4db89aeb430df35a", size = 829635, upload-time = "2024-06-04T21:14:12.25Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/b2/8391b1e5400d7a8260b321c957fa4d2cca0754e16c1e2aad7c74dfd2e0f2/thinc-8.2.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8e28ba753cdf925ac25b52ea6c4baf5104c6ed6874d9e3dfe768ff98d5118db1", size = 760510, upload-time = "2024-06-04T21:14:14.524Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/be/d7b87674bc08805ebef56199595eb3aa7bd17f1230c4eb7416ec0369e9cb/thinc-8.2.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5c3874361a1d3c469dd7c9054d4d16b7afcf791e9c47705766d690685fe702d", size = 818804, upload-time = "2024-06-04T21:14:16.909Z" },
-    { url = "https://files.pythonhosted.org/packages/65/1c/83d806f09a7d8a0b4ff76c93330c07dfec5bd5105160f45e890f7af0b7c2/thinc-8.2.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c4a22e76e4651fb6b209cfba2e1c167e8537286ae35fb87769a17af491f995b5", size = 865027, upload-time = "2024-06-04T21:14:19.213Z" },
-    { url = "https://files.pythonhosted.org/packages/68/4a/e8e172cc172e514d39f3f9dc33a60d44bab420ce0bb1b696e4e97cce63db/thinc-8.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:ebfd9d79d2bdadec551cb9ca8c7fdeacb56db642158c56cdb039de47e9aad995", size = 1447894, upload-time = "2024-06-04T21:14:22.35Z" },
+    { url = "https://files.pythonhosted.org/packages/76/37/8acfeba6bb25b08c2a33bfae5301a5df4dc164d2d17040bebbcf66d783a1/thinc-8.2.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a75c0de3340afed594beda293661de145f3842873df56d9989bc338148f13fab", size = 839072, upload-time = "2024-06-19T16:41:18.429Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/eb/753a85875fb0261c83ca87a1a36d41346bde662c3a029ace9d68fe32bc5b/thinc-8.2.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6b166d1a22003ee03bc236370fff2884744c1fb758a6209a2512d305773d07d7", size = 773885, upload-time = "2024-06-19T16:41:24.693Z" },
+    { url = "https://files.pythonhosted.org/packages/34/47/06810a1bd9d3287076ba17299abec82c8c643563661b1af9b1d5d9aeab38/thinc-8.2.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:34db8a023b9f70645fdf06c510584ba6d8b97ec53c1e094f42d95652bf8c875f", size = 868332, upload-time = "2024-06-19T16:41:31.038Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/19/cd73e3b5f22d5d9399f6f2931ab0fb985415f34030dcfead070181866761/thinc-8.2.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8901b30db1071ea8d5e4437429c8632535bf5ed87938ce3bb5057bed9f15aed8", size = 920152, upload-time = "2024-06-19T16:41:36.939Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0e/5e7b24e046e0725eafc37ded0cd9bfaf789efb894101a7aca8a73dba81de/thinc-8.2.5-cp311-cp311-win_amd64.whl", hash = "sha256:8ef5d46d62e31f2450224ab22391a606cf427b13e20cfc570f70422e2f333872", size = 1480120, upload-time = "2024-06-19T16:41:40.877Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/9d/d2ed3aef9bb75ab86c521bde58f897db6a572c9fd639448173b516269a69/thinc-8.2.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9fc26697e2358c71a5fe243d52e98ae67ee1a3b314eead5031845b6d1c0d121c", size = 824150, upload-time = "2024-06-19T16:41:45.045Z" },
+    { url = "https://files.pythonhosted.org/packages/66/a6/30ed1edb2adab585b5f7d5d99e89b5be3014dcbf3f4e263997b2c2426681/thinc-8.2.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8e299d4dc41107385d6d14d8604a060825798a031cabe2b894b22f9d75d9eaad", size = 760640, upload-time = "2024-06-19T16:41:51.182Z" },
+    { url = "https://files.pythonhosted.org/packages/82/ce/aaff1f39bcc1e9a97bec5f3d20aa771c005a9faff3944fc56c7492c24466/thinc-8.2.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8a8f2f249f2be9a5ce2a81a6efe7503b68be7b57e47ad54ab28204e1f0c723b", size = 818820, upload-time = "2024-06-19T16:41:56.868Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/fa/c96b01e46e5962d02de1206e497fda2902aef2b8ffb2926d66d5f0159040/thinc-8.2.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87e729f33c76ec6df9b375989743252ab880d79f3a2b4175169b21dece90f102", size = 865047, upload-time = "2024-06-19T16:42:06.181Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/26/306b8bedb678c52464ed00e576edf9d365fce0bcae597a333bdad9fb5d67/thinc-8.2.5-cp312-cp312-win_amd64.whl", hash = "sha256:c5f750ea2dd32ca6d46947025dacfc0f6037340c4e5f7adb9af84c75f65aa7d8", size = 1447893, upload-time = "2024-06-19T16:42:12.145Z" },
 ]
 
 [[package]]
-name = "tldextract"
-version = "5.3.0"
+name = "tinycss2"
+version = "1.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "filelock" },
-    { name = "idna" },
-    { name = "requests" },
-    { name = "requests-file" },
+    { name = "webencodings" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/97/78/182641ea38e3cfd56e9c7b3c0d48a53d432eea755003aa544af96403d4ac/tldextract-5.3.0.tar.gz", hash = "sha256:b3d2b70a1594a0ecfa6967d57251527d58e00bb5a91a74387baa0d87a0678609", size = 128502, upload-time = "2025-04-22T06:19:37.491Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085, upload-time = "2024-10-24T14:58:29.895Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/67/7c/ea488ef48f2f544566947ced88541bc45fae9e0e422b2edbf165ee07da99/tldextract-5.3.0-py3-none-any.whl", hash = "sha256:f70f31d10b55c83993f55e91ecb7c5d84532a8972f22ec578ecfbe5ea2292db2", size = 107384, upload-time = "2025-04-22T06:19:36.304Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610, upload-time = "2024-10-24T14:58:28.029Z" },
 ]
 
 [[package]]
-name = "tokenizers"
-version = "0.22.1"
+name = "tldextract"
+version = "5.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "huggingface-hub" },
+    { name = "filelock" },
+    { name = "idna" },
+    { name = "requests" },
+    { name = "requests-file" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1c/46/fb6854cec3278fbfa4a75b50232c77622bc517ac886156e6afbfa4d8fc6e/tokenizers-0.22.1.tar.gz", hash = "sha256:61de6522785310a309b3407bac22d99c4db5dba349935e99e4d15ea2226af2d9", size = 363123, upload-time = "2025-09-19T09:49:23.424Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/7b/644fbbb49564a6cb124a8582013315a41148dba2f72209bba14a84242bf0/tldextract-5.3.1.tar.gz", hash = "sha256:a72756ca170b2510315076383ea2993478f7da6f897eef1f4a5400735d5057fb", size = 126105, upload-time = "2025-12-28T23:58:05.532Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bf/33/f4b2d94ada7ab297328fc671fed209368ddb82f965ec2224eb1892674c3a/tokenizers-0.22.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:59fdb013df17455e5f950b4b834a7b3ee2e0271e6378ccb33aa74d178b513c73", size = 3069318, upload-time = "2025-09-19T09:49:11.848Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/58/2aa8c874d02b974990e89ff95826a4852a8b2a273c7d1b4411cdd45a4565/tokenizers-0.22.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:8d4e484f7b0827021ac5f9f71d4794aaef62b979ab7608593da22b1d2e3c4edc", size = 2926478, upload-time = "2025-09-19T09:49:09.759Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/3b/55e64befa1e7bfea963cf4b787b2cea1011362c4193f5477047532ce127e/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19d2962dd28bc67c1f205ab180578a78eef89ac60ca7ef7cbe9635a46a56422a", size = 3256994, upload-time = "2025-09-19T09:48:56.701Z" },
-    { url = "https://files.pythonhosted.org/packages/71/0b/fbfecf42f67d9b7b80fde4aabb2b3110a97fac6585c9470b5bff103a80cb/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:38201f15cdb1f8a6843e6563e6e79f4abd053394992b9bbdf5213ea3469b4ae7", size = 3153141, upload-time = "2025-09-19T09:48:59.749Z" },
-    { url = "https://files.pythonhosted.org/packages/17/a9/b38f4e74e0817af8f8ef925507c63c6ae8171e3c4cb2d5d4624bf58fca69/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d1cbe5454c9a15df1b3443c726063d930c16f047a3cc724b9e6e1a91140e5a21", size = 3508049, upload-time = "2025-09-19T09:49:05.868Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/48/dd2b3dac46bb9134a88e35d72e1aa4869579eacc1a27238f1577270773ff/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e7d094ae6312d69cc2a872b54b91b309f4f6fbce871ef28eb27b52a98e4d0214", size = 3710730, upload-time = "2025-09-19T09:49:01.832Z" },
-    { url = "https://files.pythonhosted.org/packages/93/0e/ccabc8d16ae4ba84a55d41345207c1e2ea88784651a5a487547d80851398/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afd7594a56656ace95cdd6df4cca2e4059d294c5cfb1679c57824b605556cb2f", size = 3412560, upload-time = "2025-09-19T09:49:03.867Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/c6/dc3a0db5a6766416c32c034286d7c2d406da1f498e4de04ab1b8959edd00/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2ef6063d7a84994129732b47e7915e8710f27f99f3a3260b8a38fc7ccd083f4", size = 3250221, upload-time = "2025-09-19T09:49:07.664Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/a6/2c8486eef79671601ff57b093889a345dd3d576713ef047776015dc66de7/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ba0a64f450b9ef412c98f6bcd2a50c6df6e2443b560024a09fa6a03189726879", size = 9345569, upload-time = "2025-09-19T09:49:14.214Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/16/32ce667f14c35537f5f605fe9bea3e415ea1b0a646389d2295ec348d5657/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:331d6d149fa9c7d632cde4490fb8bbb12337fa3a0232e77892be656464f4b446", size = 9271599, upload-time = "2025-09-19T09:49:16.639Z" },
-    { url = "https://files.pythonhosted.org/packages/51/7c/a5f7898a3f6baa3fc2685c705e04c98c1094c523051c805cdd9306b8f87e/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:607989f2ea68a46cb1dfbaf3e3aabdf3f21d8748312dbeb6263d1b3b66c5010a", size = 9533862, upload-time = "2025-09-19T09:49:19.146Z" },
-    { url = "https://files.pythonhosted.org/packages/36/65/7e75caea90bc73c1dd8d40438adf1a7bc26af3b8d0a6705ea190462506e1/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a0f307d490295717726598ef6fa4f24af9d484809223bbc253b201c740a06390", size = 9681250, upload-time = "2025-09-19T09:49:21.501Z" },
-    { url = "https://files.pythonhosted.org/packages/30/2c/959dddef581b46e6209da82df3b78471e96260e2bc463f89d23b1bf0e52a/tokenizers-0.22.1-cp39-abi3-win32.whl", hash = "sha256:b5120eed1442765cd90b903bb6cfef781fd8fe64e34ccaecbae4c619b7b12a82", size = 2472003, upload-time = "2025-09-19T09:49:27.089Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/46/e33a8c93907b631a99377ef4c5f817ab453d0b34f93529421f42ff559671/tokenizers-0.22.1-cp39-abi3-win_amd64.whl", hash = "sha256:65fd6e3fb11ca1e78a6a93602490f134d1fdeb13bcef99389d5102ea318ed138", size = 2674684, upload-time = "2025-09-19T09:49:24.953Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/42/0e49d6d0aac449ca71952ec5bae764af009754fcb2e76a5cc097543747b3/tldextract-5.3.1-py3-none-any.whl", hash = "sha256:6bfe36d518de569c572062b788e16a659ccaceffc486d243af0484e8ecf432d9", size = 105886, upload-time = "2025-12-28T23:58:04.071Z" },
 ]
 
 [[package]]
 name = "tomli"
-version = "2.2.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175, upload-time = "2024-11-27T22:38:36.873Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077, upload-time = "2024-11-27T22:37:54.956Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429, upload-time = "2024-11-27T22:37:56.698Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067, upload-time = "2024-11-27T22:37:57.63Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030, upload-time = "2024-11-27T22:37:59.344Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898, upload-time = "2024-11-27T22:38:00.429Z" },
-    { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894, upload-time = "2024-11-27T22:38:02.094Z" },
-    { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319, upload-time = "2024-11-27T22:38:03.206Z" },
-    { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273, upload-time = "2024-11-27T22:38:04.217Z" },
-    { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310, upload-time = "2024-11-27T22:38:05.908Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309, upload-time = "2024-11-27T22:38:06.812Z" },
-    { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762, upload-time = "2024-11-27T22:38:07.731Z" },
-    { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453, upload-time = "2024-11-27T22:38:09.384Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486, upload-time = "2024-11-27T22:38:10.329Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349, upload-time = "2024-11-27T22:38:11.443Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159, upload-time = "2024-11-27T22:38:13.099Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243, upload-time = "2024-11-27T22:38:14.766Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645, upload-time = "2024-11-27T22:38:15.843Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584, upload-time = "2024-11-27T22:38:17.645Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875, upload-time = "2024-11-27T22:38:19.159Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418, upload-time = "2024-11-27T22:38:20.064Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257, upload-time = "2024-11-27T22:38:35.385Z" },
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" },
+    { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" },
+    { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" },
+    { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" },
+    { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" },
+    { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
 ]
 
 [[package]]
@@ -3188,59 +3010,62 @@ wheels = [
 
 [[package]]
 name = "tqdm"
-version = "4.67.1"
+version = "4.67.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" },
+    { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" },
 ]
 
 [[package]]
 name = "typer"
-version = "0.19.2"
+version = "0.25.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "annotated-doc" },
     { name = "click" },
     { name = "rich" },
     { name = "shellingham" },
-    { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/21/ca/950278884e2ca20547ff3eb109478c6baf6b8cf219318e6bc4f666fad8e8/typer-0.19.2.tar.gz", hash = "sha256:9ad824308ded0ad06cc716434705f691d4ee0bfd0fb081839d2e426860e7fdca", size = 104755, upload-time = "2025-09-23T09:47:48.256Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e4/51/9aed62104cea109b820bbd6c14245af756112017d309da813ef107d42e7e/typer-0.25.1.tar.gz", hash = "sha256:9616eb8853a09ffeabab1698952f33c6f29ffdbceb4eaeecf571880e8d7664cc", size = 122276, upload-time = "2026-04-30T19:32:16.964Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/22/35617eee79080a5d071d0f14ad698d325ee6b3bf824fc0467c03b30e7fa8/typer-0.19.2-py3-none-any.whl", hash = "sha256:755e7e19670ffad8283db353267cb81ef252f595aa6834a0d1ca9312d9326cb9", size = 46748, upload-time = "2025-09-23T09:47:46.777Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/f9/2b3ff4e56e5fa7debfaf9eb135d0da96f3e9a1d5b27222223c7296336e5f/typer-0.25.1-py3-none-any.whl", hash = "sha256:75caa44ed46a03fb2dab8808753ffacdbfea88495e74c85a28c5eefcf5f39c89", size = 58409, upload-time = "2026-04-30T19:32:18.271Z" },
 ]
 
 [[package]]
-name = "types-awscrt"
-version = "0.29.2"
+name = "typer-slim"
+version = "0.24.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4b/55/880afcfb08a8f683444074c1be70ad6141cf873b7f8115e9cc9e87a487b3/types_awscrt-0.29.2.tar.gz", hash = "sha256:41e01e14d646877bd310e7e3c49ff193f8361480b9568e97b1639775009bbefa", size = 17761, upload-time = "2025-12-04T01:53:21.148Z" }
+dependencies = [
+    { name = "typer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a7/a7/e6aecc4b4eb59598829a3b5076a93aff291b4fdaa2ded25efc4e1f4d219c/typer_slim-0.24.0.tar.gz", hash = "sha256:f0ed36127183f52ae6ced2ecb2521789995992c521a46083bfcdbb652d22ad34", size = 4776, upload-time = "2026-02-16T22:08:51.2Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/26/dcbfda45af027355647c8860429066922f8405197af912817e79bc75efa4/types_awscrt-0.29.2-py3-none-any.whl", hash = "sha256:3f5d1e6c99b0b551af6365f9c04d8ce2effbcfe18bb719a34501efea279ae7bb", size = 42394, upload-time = "2025-12-04T01:53:19.074Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/24/5480c20380dfd18cf33d14784096dca45a24eae6102e91d49a718d3b6855/typer_slim-0.24.0-py3-none-any.whl", hash = "sha256:d5d7ee1ee2834d5020c7c616ed5e0d0f29b9a4b1dd283bdebae198ec09778d0e", size = 3394, upload-time = "2026-02-16T22:08:49.92Z" },
 ]
 
 [[package]]
-name = "types-cffi"
-version = "1.17.0.20250915"
+name = "types-awscrt"
+version = "0.31.3"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "types-setuptools" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/2a/98/ea454cea03e5f351323af6a482c65924f3c26c515efd9090dede58f2b4b6/types_cffi-1.17.0.20250915.tar.gz", hash = "sha256:4362e20368f78dabd5c56bca8004752cc890e07a71605d9e0d9e069dbaac8c06", size = 17229, upload-time = "2025-09-15T03:01:25.31Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/26/0aa563e229c269c528a3b8c709fc671ac2a5c564732fab0852ac6ee006cf/types_awscrt-0.31.3.tar.gz", hash = "sha256:09d3eaf00231e0f47e101bd9867e430873bc57040050e2a3bd8305cb4fc30865", size = 18178, upload-time = "2026-03-08T02:31:14.569Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/aa/ec/092f2b74b49ec4855cdb53050deb9699f7105b8fda6fe034c0781b8687f3/types_cffi-1.17.0.20250915-py3-none-any.whl", hash = "sha256:cef4af1116c83359c11bb4269283c50f0688e9fc1d7f0eeb390f3661546da52c", size = 20112, upload-time = "2025-09-15T03:01:24.187Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/e5/47a573bbbd0a790f8f9fe452f7188ea72b212d21c9be57d5fc0cbc442075/types_awscrt-0.31.3-py3-none-any.whl", hash = "sha256:e5ce65a00a2ab4f35eacc1e3d700d792338d56e4823ee7b4dbe017f94cfc4458", size = 43340, upload-time = "2026-03-08T02:31:13.38Z" },
 ]
 
 [[package]]
-name = "types-protobuf"
-version = "6.32.1.20250918"
+name = "types-cffi"
+version = "2.0.0.20260518"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/69/5a/bd06c2dbb77ebd4ea764473c9c4c014c7ba94432192cb965a274f8544b9d/types_protobuf-6.32.1.20250918.tar.gz", hash = "sha256:44ce0ae98475909ca72379946ab61a4435eec2a41090821e713c17e8faf5b88f", size = 63780, upload-time = "2025-09-18T02:50:39.391Z" }
+dependencies = [
+    { name = "types-setuptools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bd/0b/b352742758a6054d1053783887bf8cfb739deda1102fda8722294bdc01f7/types_cffi-2.0.0.20260518.tar.gz", hash = "sha256:f9707e66c13454789a58f8843d1ded4a66f1e9c8b10bd24d5eb5e0f25c0c5472", size = 17790, upload-time = "2026-05-18T06:06:50.672Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/37/5a/8d93d4f4af5dc3dd62aa4f020deae746b34b1d94fb5bee1f776c6b7e9d6c/types_protobuf-6.32.1.20250918-py3-none-any.whl", hash = "sha256:22ba6133d142d11cc34d3788ad6dead2732368ebb0406eaa7790ea6ae46c8d0b", size = 77885, upload-time = "2025-09-18T02:50:38.028Z" },
+    { url = "https://files.pythonhosted.org/packages/68/44/d3b4aafa20a3f76384ba19a513d39272add13746dcfe0409d8d4974fd464/types_cffi-2.0.0.20260518-py3-none-any.whl", hash = "sha256:5b68a215a95d0eac4203b58e766ff7fe40c2e091b1fa1a9e54111f04cc560084", size = 20198, upload-time = "2026-05-18T06:06:49.83Z" },
 ]
 
 [[package]]
@@ -3258,11 +3083,11 @@ wheels = [
 
 [[package]]
 name = "types-pyyaml"
-version = "6.0.12.20250915"
+version = "6.0.12.20260518"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7e/69/3c51b36d04da19b92f9e815be12753125bd8bc247ba0470a982e6979e71c/types_pyyaml-6.0.12.20250915.tar.gz", hash = "sha256:0f8b54a528c303f0e6f7165687dd33fafa81c807fcac23f632b63aa624ced1d3", size = 17522, upload-time = "2025-09-15T03:01:00.728Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b8/83/4a1afc3fbfcf5b8d46fc390cd95ed6b0dc9010a265f4e9f46314efffa37a/types_pyyaml-6.0.12.20260518.tar.gz", hash = "sha256:d917f83fb38462550338c1297faedd860b3ec83912b96b1e3d73255f7473e466", size = 17850, upload-time = "2026-05-18T06:01:58.675Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bd/e0/1eed384f02555dde685fff1a1ac805c1c7dcb6dd019c916fe659b1c1f9ec/types_pyyaml-6.0.12.20250915-py3-none-any.whl", hash = "sha256:e7d4d9e064e89a3b3cae120b4990cd370874d2bf12fa5f46c97018dd5d3c9ab6", size = 20338, upload-time = "2025-09-15T03:00:59.218Z" },
+    { url = "https://files.pythonhosted.org/packages/06/a2/c01db32be2ae7d6a1689972f3c492b149ee4e164b12fdfd9f64b50888215/types_pyyaml-6.0.12.20260518-py3-none-any.whl", hash = "sha256:d2150f75a231c9fe9c7463bd29487d93e60bac90400287351384bc2284eba7cd", size = 20312, upload-time = "2026-05-18T06:01:57.368Z" },
 ]
 
 [[package]]
@@ -3278,18 +3103,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/55/82/7d25dce10aad92d2226b269bce2f85cfd843b4477cd50245d7d40ecf8f89/types_redis-4.6.0.20241004-py3-none-any.whl", hash = "sha256:ef5da68cb827e5f606c8f9c0b49eeee4c2669d6d97122f301d3a55dc6a63f6ed", size = 58737, upload-time = "2024-10-04T02:43:57.968Z" },
 ]
 
-[[package]]
-name = "types-requests"
-version = "2.32.4.20250913"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "urllib3" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/36/27/489922f4505975b11de2b5ad07b4fe1dca0bca9be81a703f26c5f3acfce5/types_requests-2.32.4.20250913.tar.gz", hash = "sha256:abd6d4f9ce3a9383f269775a9835a4c24e5cd6b9f647d64f88aa4613c33def5d", size = 23113, upload-time = "2025-09-13T02:40:02.309Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/20/9a227ea57c1285986c4cf78400d0a91615d25b24e257fd9e2969606bdfae/types_requests-2.32.4.20250913-py3-none-any.whl", hash = "sha256:78c9c1fffebbe0fa487a418e0fa5252017e9c60d1a2da394077f1780f655d7e1", size = 20658, upload-time = "2025-09-13T02:40:01.115Z" },
-]
-
 [[package]]
 name = "types-s3transfer"
 version = "0.16.0"
@@ -3301,11 +3114,11 @@ wheels = [
 
 [[package]]
 name = "types-setuptools"
-version = "80.9.0.20250822"
+version = "82.0.0.20260518"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/bd/1e5f949b7cb740c9f0feaac430e301b8f1c5f11a81e26324299ea671a237/types_setuptools-80.9.0.20250822.tar.gz", hash = "sha256:070ea7716968ec67a84c7f7768d9952ff24d28b65b6594797a464f1b3066f965", size = 41296, upload-time = "2025-08-22T03:02:08.771Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/38/bc/73c2c27e047e42f114ac50fb3bdef986c56cbdb68096f8690eeafb839a93/types_setuptools-82.0.0.20260518.tar.gz", hash = "sha256:3b743cfe63d0981ea4c15b90710fc1ed41e3464a537d51e705be514e891c1d07", size = 44999, upload-time = "2026-05-18T06:02:55.642Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b6/2d/475bf15c1cdc172e7a0d665b6e373ebfb1e9bf734d3f2f543d668b07a142/types_setuptools-80.9.0.20250822-py3-none-any.whl", hash = "sha256:53bf881cb9d7e46ed12c76ef76c0aaf28cfe6211d3fab12e0b83620b1a8642c3", size = 63179, upload-time = "2025-08-22T03:02:07.643Z" },
+    { url = "https://files.pythonhosted.org/packages/32/8f/d5e2d493f09a7a98c95619edda1cb37cee377626c0a869d53274c26f2858/types_setuptools-82.0.0.20260518-py3-none-any.whl", hash = "sha256:31c04a62b57a653a5021caf191be0f10f70df890f813b51f02bab3969d300f20", size = 68444, upload-time = "2026-05-18T06:02:54.582Z" },
 ]
 
 [[package]]
@@ -3319,45 +3132,65 @@ wheels = [
 
 [[package]]
 name = "typing-inspection"
-version = "0.4.1"
+version = "0.4.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload-time = "2025-05-21T18:55:22.152Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
 ]
 
 [[package]]
 name = "uc-micro-py"
-version = "1.0.3"
+version = "2.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043, upload-time = "2024-02-09T16:52:01.654Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/78/67/9a363818028526e2d4579334460df777115bdec1bb77c08f9db88f6389f2/uc_micro_py-2.0.0.tar.gz", hash = "sha256:c53691e495c8db60e16ffc4861a35469b0ba0821fe409a8a7a0a71864d33a811", size = 6611, upload-time = "2026-03-01T06:31:27.526Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229, upload-time = "2024-02-09T16:52:00.371Z" },
+    { url = "https://files.pythonhosted.org/packages/61/73/d21edf5b204d1467e06500080a50f79d49ef2b997c79123a536d4a17d97c/uc_micro_py-2.0.0-py3-none-any.whl", hash = "sha256:3603a3859af53e5a39bc7677713c78ea6589ff188d70f4fee165db88e22b242c", size = 6383, upload-time = "2026-03-01T06:31:26.257Z" },
+]
+
+[[package]]
+name = "uharfbuzz"
+version = "0.54.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/cf/f46264008f4f654f823c6a61e02556a4ca2ca04ac28df951a7ed7d11aa52/uharfbuzz-0.54.1.tar.gz", hash = "sha256:ded760c284c686f1f17f5c4bf44527857ef488b7f0aebceae4c1ef1903ddddb3", size = 1899039, upload-time = "2026-04-30T22:19:50.695Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/3c/4bcd6c360808c0d5a9e3970dd0a50a2eeac2610974ea71974c576699fc42/uharfbuzz-0.54.1-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:ddc0ef83d51985c63f50f11781ca2f36c0bc8b9f9d6bd6bb00f4860ae0814700", size = 2976592, upload-time = "2026-04-30T22:19:25.18Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/aa/41e3e71a25c6db6b32774fb09b43dd8b7bf44f2273bad6250eb5658c0cd5/uharfbuzz-0.54.1-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d3fee855690c6059fb9b5fc64a3ea0e367b5f71095b2e62e18ce144e9e782b47", size = 1762988, upload-time = "2026-04-30T22:19:27.855Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/0c/538e1dc6194418df025e237f74df279b0b27c9ec498aeda6a4b2082ca4f4/uharfbuzz-0.54.1-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1059de9a7764611c214bff4fd0ed81526dbde024b11dc697dfca0bc590ebaf15", size = 1831201, upload-time = "2026-04-30T22:19:30.45Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/2f/575c9df77090aa068b8002d6cfd1027897fc887eb2eb85dbee991440f2f5/uharfbuzz-0.54.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:bca97e4a5b288297473128869cbd1bb0f6e4619caa8a248f66986da3e21c1773", size = 2779537, upload-time = "2026-04-30T22:19:32.623Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/b3/76bc2c44346a65c3316fa473bf4d64e642e9f0b77d53a3fc675b13b639b8/uharfbuzz-0.54.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:fe6b06bfc6f223cbee6a42018ede4161e0c1020f2b8e22b245530b77bcbd9cd7", size = 2882718, upload-time = "2026-04-30T22:19:34.892Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/81/cd40cf2fa27029354947f4b27e62cc9edc9ba9c94fcd2de3b21e0aac4b9b/uharfbuzz-0.54.1-cp310-abi3-win32.whl", hash = "sha256:9d859baa4df2bba238458c47d5dd58a66b16d135777457d05d4f447e15670d70", size = 1065318, upload-time = "2026-04-30T22:19:36.674Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/8a/dc83b840d7f6b43255cb5f4ee9ae369b6e4c67b11226c6be6af80faf4bc9/uharfbuzz-0.54.1-cp310-abi3-win_amd64.whl", hash = "sha256:94dc73f45d8943ddeaae3336cd40c0f398397ca915db1fc96dd5566107dbb6f2", size = 1327439, upload-time = "2026-04-30T22:19:38.731Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/68/362df7801a3f634938dc51af91231c391c4ba9513e2fbb6ed4a00ac63894/uharfbuzz-0.54.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:9c44559b52899dbbf3db3d49ac0372db78255ae5b2cbc2b1d2eb50fdb197f28c", size = 1457033, upload-time = "2026-04-30T22:19:40.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/02/95d25586ceb8ff8dcf38c0c1ed6bfd5bb9c2165dda060ed46a907faca6ef/uharfbuzz-0.54.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:8c81285dabaa2150a34f18062cdb13eb443a8db0a1e59b261be8644fd1732301", size = 1352268, upload-time = "2026-04-30T22:19:42.733Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/c3/64189774b5d6468e4d844e71c09cc9f9ac990a39c5b008858869d6521195/uharfbuzz-0.54.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55342a09f8a0bfbf570e4765cd3b02b1a999822127f891d944cbb0c26dc2090a", size = 1604654, upload-time = "2026-04-30T22:19:44.807Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1c/f59f22c5e1237965165fe424195198770c05b5b22766acec165fa9fcad56/uharfbuzz-0.54.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:918ebca8fecc89d0e9f9df71e9e5ef5cede5f2bc571a9e82a3e932f4189ac432", size = 1662895, upload-time = "2026-04-30T22:19:46.682Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d0/f47fd04ce8fc980d2dce5979b0595d80f284448ccd47780c426609f951a0/uharfbuzz-0.54.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:5863c255a380e860cbc2a35d6ac8a26b518de42210f6186010e6277afdf4b5ce", size = 1317950, upload-time = "2026-04-30T22:19:48.769Z" },
 ]
 
 [[package]]
 name = "urllib3"
-version = "2.5.0"
+version = "2.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
 ]
 
 [[package]]
 name = "uvicorn"
-version = "0.37.0"
+version = "0.47.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
     { name = "h11" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/71/57/1616c8274c3442d802621abf5deb230771c7a0fec9414cb6763900eb3868/uvicorn-0.37.0.tar.gz", hash = "sha256:4115c8add6d3fd536c8ee77f0e14a7fd2ebba939fed9b02583a97f80648f9e13", size = 80367, upload-time = "2025-09-23T13:33:47.486Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/b1/8e7077a8641086aea449e1b5752a570f1b5906c64e0a33cd6d93b63a066b/uvicorn-0.47.0.tar.gz", hash = "sha256:7c9a0ea1a9414106bbab7324609c162d8fa0cdcdcb703060987269d77c7bb533", size = 90582, upload-time = "2026-05-14T18:16:54.455Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/cd/584a2ceb5532af99dd09e50919e3615ba99aa127e9850eafe5f31ddfdb9a/uvicorn-0.37.0-py3-none-any.whl", hash = "sha256:913b2b88672343739927ce381ff9e2ad62541f9f8289664fa1d1d3803fa2ce6c", size = 67976, upload-time = "2025-09-23T13:33:45.842Z" },
+    { url = "https://files.pythonhosted.org/packages/15/41/ac2dfdbc1f60c7af4f994c7a335cfa7040c01642b605d65f611cecc2a1e4/uvicorn-0.47.0-py3-none-any.whl", hash = "sha256:2c5715bc12d1892d84752049f400cd1c3cb018514967fdfeb97640443a6a9432", size = 71301, upload-time = "2026-05-14T18:16:51.762Z" },
 ]
 
 [package.optional-dependencies]
@@ -3373,22 +3206,22 @@ standard = [
 
 [[package]]
 name = "uvloop"
-version = "0.21.0"
+version = "0.22.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/c0/854216d09d33c543f12a44b393c402e89a920b1a0a7dc634c42de91b9cf6/uvloop-0.21.0.tar.gz", hash = "sha256:3bf12b0fda68447806a7ad847bfa591613177275d35b6724b1ee573faa3704e3", size = 2492741, upload-time = "2024-10-14T23:38:35.489Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/57/a7/4cf0334105c1160dd6819f3297f8700fda7fc30ab4f61fbf3e725acbc7cc/uvloop-0.21.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c0f3fa6200b3108919f8bdabb9a7f87f20e7097ea3c543754cabc7d717d95cf8", size = 1447410, upload-time = "2024-10-14T23:37:33.612Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/7c/1517b0bbc2dbe784b563d6ab54f2ef88c890fdad77232c98ed490aa07132/uvloop-0.21.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0878c2640cf341b269b7e128b1a5fed890adc4455513ca710d77d5e93aa6d6a0", size = 805476, upload-time = "2024-10-14T23:37:36.11Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/ea/0bfae1aceb82a503f358d8d2fa126ca9dbdb2ba9c7866974faec1cb5875c/uvloop-0.21.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9fb766bb57b7388745d8bcc53a359b116b8a04c83a2288069809d2b3466c37e", size = 3960855, upload-time = "2024-10-14T23:37:37.683Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/ca/0864176a649838b838f36d44bf31c451597ab363b60dc9e09c9630619d41/uvloop-0.21.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a375441696e2eda1c43c44ccb66e04d61ceeffcd76e4929e527b7fa401b90fb", size = 3973185, upload-time = "2024-10-14T23:37:40.226Z" },
-    { url = "https://files.pythonhosted.org/packages/30/bf/08ad29979a936d63787ba47a540de2132169f140d54aa25bc8c3df3e67f4/uvloop-0.21.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:baa0e6291d91649c6ba4ed4b2f982f9fa165b5bbd50a9e203c416a2797bab3c6", size = 3820256, upload-time = "2024-10-14T23:37:42.839Z" },
-    { url = "https://files.pythonhosted.org/packages/da/e2/5cf6ef37e3daf2f06e651aae5ea108ad30df3cb269102678b61ebf1fdf42/uvloop-0.21.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4509360fcc4c3bd2c70d87573ad472de40c13387f5fda8cb58350a1d7475e58d", size = 3937323, upload-time = "2024-10-14T23:37:45.337Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/4c/03f93178830dc7ce8b4cdee1d36770d2f5ebb6f3d37d354e061eefc73545/uvloop-0.21.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:359ec2c888397b9e592a889c4d72ba3d6befba8b2bb01743f72fffbde663b59c", size = 1471284, upload-time = "2024-10-14T23:37:47.833Z" },
-    { url = "https://files.pythonhosted.org/packages/43/3e/92c03f4d05e50f09251bd8b2b2b584a2a7f8fe600008bcc4523337abe676/uvloop-0.21.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f7089d2dc73179ce5ac255bdf37c236a9f914b264825fdaacaded6990a7fb4c2", size = 821349, upload-time = "2024-10-14T23:37:50.149Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/ef/a02ec5da49909dbbfb1fd205a9a1ac4e88ea92dcae885e7c961847cd51e2/uvloop-0.21.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:baa4dcdbd9ae0a372f2167a207cd98c9f9a1ea1188a8a526431eef2f8116cc8d", size = 4580089, upload-time = "2024-10-14T23:37:51.703Z" },
-    { url = "https://files.pythonhosted.org/packages/06/a7/b4e6a19925c900be9f98bec0a75e6e8f79bb53bdeb891916609ab3958967/uvloop-0.21.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86975dca1c773a2c9864f4c52c5a55631038e387b47eaf56210f873887b6c8dc", size = 4693770, upload-time = "2024-10-14T23:37:54.122Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/0c/f07435a18a4b94ce6bd0677d8319cd3de61f3a9eeb1e5f8ab4e8b5edfcb3/uvloop-0.21.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:461d9ae6660fbbafedd07559c6a2e57cd553b34b0065b6550685f6653a98c1cb", size = 4451321, upload-time = "2024-10-14T23:37:55.766Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/eb/f7032be105877bcf924709c97b1bf3b90255b4ec251f9340cef912559f28/uvloop-0.21.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:183aef7c8730e54c9a3ee3227464daed66e37ba13040bb3f350bc2ddc040f22f", size = 4659022, upload-time = "2024-10-14T23:37:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/d5/69900f7883235562f1f50d8184bb7dd84a2fb61e9ec63f3782546fdbd057/uvloop-0.22.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c60ebcd36f7b240b30788554b6f0782454826a0ed765d8430652621b5de674b9", size = 1352420, upload-time = "2025-10-16T22:16:21.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/73/c4e271b3bce59724e291465cc936c37758886a4868787da0278b3b56b905/uvloop-0.22.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3b7f102bf3cb1995cfeaee9321105e8f5da76fdb104cdad8986f85461a1b7b77", size = 748677, upload-time = "2025-10-16T22:16:22.558Z" },
+    { url = "https://files.pythonhosted.org/packages/86/94/9fb7fad2f824d25f8ecac0d70b94d0d48107ad5ece03769a9c543444f78a/uvloop-0.22.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53c85520781d84a4b8b230e24a5af5b0778efdb39142b424990ff1ef7c48ba21", size = 3753819, upload-time = "2025-10-16T22:16:23.903Z" },
+    { url = "https://files.pythonhosted.org/packages/74/4f/256aca690709e9b008b7108bc85fba619a2bc37c6d80743d18abad16ee09/uvloop-0.22.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56a2d1fae65fd82197cb8c53c367310b3eabe1bbb9fb5a04d28e3e3520e4f702", size = 3804529, upload-time = "2025-10-16T22:16:25.246Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/74/03c05ae4737e871923d21a76fe28b6aad57f5c03b6e6bfcfa5ad616013e4/uvloop-0.22.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:40631b049d5972c6755b06d0bfe8233b1bd9a8a6392d9d1c45c10b6f9e9b2733", size = 3621267, upload-time = "2025-10-16T22:16:26.819Z" },
+    { url = "https://files.pythonhosted.org/packages/75/be/f8e590fe61d18b4a92070905497aec4c0e64ae1761498cad09023f3f4b3e/uvloop-0.22.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:535cc37b3a04f6cd2c1ef65fa1d370c9a35b6695df735fcff5427323f2cd5473", size = 3723105, upload-time = "2025-10-16T22:16:28.252Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
 ]
 
 [[package]]
@@ -3405,57 +3238,59 @@ wheels = [
 
 [[package]]
 name = "watchfiles"
-version = "1.1.0"
+version = "1.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2a/9a/d451fcc97d029f5812e898fd30a53fd8c15c7bbd058fd75cfc6beb9bd761/watchfiles-1.1.0.tar.gz", hash = "sha256:693ed7ec72cbfcee399e92c895362b6e66d63dac6b91e2c11ae03d10d503e575", size = 94406, upload-time = "2025-06-15T19:06:59.42Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/78/7401154b78ab484ccaaeef970dc2af0cb88b5ba8a1b415383da444cdd8d3/watchfiles-1.1.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:c9649dfc57cc1f9835551deb17689e8d44666315f2e82d337b9f07bd76ae3aa2", size = 405751, upload-time = "2025-06-15T19:05:07.679Z" },
-    { url = "https://files.pythonhosted.org/packages/76/63/e6c3dbc1f78d001589b75e56a288c47723de28c580ad715eb116639152b5/watchfiles-1.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:406520216186b99374cdb58bc48e34bb74535adec160c8459894884c983a149c", size = 397313, upload-time = "2025-06-15T19:05:08.764Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/a2/8afa359ff52e99af1632f90cbf359da46184207e893a5f179301b0c8d6df/watchfiles-1.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb45350fd1dc75cd68d3d72c47f5b513cb0578da716df5fba02fff31c69d5f2d", size = 450792, upload-time = "2025-06-15T19:05:09.869Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/bf/7446b401667f5c64972a57a0233be1104157fc3abf72c4ef2666c1bd09b2/watchfiles-1.1.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:11ee4444250fcbeb47459a877e5e80ed994ce8e8d20283857fc128be1715dac7", size = 458196, upload-time = "2025-06-15T19:05:11.91Z" },
-    { url = "https://files.pythonhosted.org/packages/58/2f/501ddbdfa3fa874ea5597c77eeea3d413579c29af26c1091b08d0c792280/watchfiles-1.1.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bda8136e6a80bdea23e5e74e09df0362744d24ffb8cd59c4a95a6ce3d142f79c", size = 484788, upload-time = "2025-06-15T19:05:13.373Z" },
-    { url = "https://files.pythonhosted.org/packages/61/1e/9c18eb2eb5c953c96bc0e5f626f0e53cfef4bd19bd50d71d1a049c63a575/watchfiles-1.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b915daeb2d8c1f5cee4b970f2e2c988ce6514aace3c9296e58dd64dc9aa5d575", size = 597879, upload-time = "2025-06-15T19:05:14.725Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/6c/1467402e5185d89388b4486745af1e0325007af0017c3384cc786fff0542/watchfiles-1.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed8fc66786de8d0376f9f913c09e963c66e90ced9aa11997f93bdb30f7c872a8", size = 477447, upload-time = "2025-06-15T19:05:15.775Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/a1/ec0a606bde4853d6c4a578f9391eeb3684a9aea736a8eb217e3e00aa89a1/watchfiles-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fe4371595edf78c41ef8ac8df20df3943e13defd0efcb732b2e393b5a8a7a71f", size = 453145, upload-time = "2025-06-15T19:05:17.17Z" },
-    { url = "https://files.pythonhosted.org/packages/90/b9/ef6f0c247a6a35d689fc970dc7f6734f9257451aefb30def5d100d6246a5/watchfiles-1.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:b7c5f6fe273291f4d414d55b2c80d33c457b8a42677ad14b4b47ff025d0893e4", size = 626539, upload-time = "2025-06-15T19:05:18.557Z" },
-    { url = "https://files.pythonhosted.org/packages/34/44/6ffda5537085106ff5aaa762b0d130ac6c75a08015dd1621376f708c94de/watchfiles-1.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7738027989881e70e3723c75921f1efa45225084228788fc59ea8c6d732eb30d", size = 624472, upload-time = "2025-06-15T19:05:19.588Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/e3/71170985c48028fa3f0a50946916a14055e741db11c2e7bc2f3b61f4d0e3/watchfiles-1.1.0-cp311-cp311-win32.whl", hash = "sha256:622d6b2c06be19f6e89b1d951485a232e3b59618def88dbeda575ed8f0d8dbf2", size = 279348, upload-time = "2025-06-15T19:05:20.856Z" },
-    { url = "https://files.pythonhosted.org/packages/89/1b/3e39c68b68a7a171070f81fc2561d23ce8d6859659406842a0e4bebf3bba/watchfiles-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:48aa25e5992b61debc908a61ab4d3f216b64f44fdaa71eb082d8b2de846b7d12", size = 292607, upload-time = "2025-06-15T19:05:21.937Z" },
-    { url = "https://files.pythonhosted.org/packages/61/9f/2973b7539f2bdb6ea86d2c87f70f615a71a1fc2dba2911795cea25968aea/watchfiles-1.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:00645eb79a3faa70d9cb15c8d4187bb72970b2470e938670240c7998dad9f13a", size = 285056, upload-time = "2025-06-15T19:05:23.12Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/b8/858957045a38a4079203a33aaa7d23ea9269ca7761c8a074af3524fbb240/watchfiles-1.1.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9dc001c3e10de4725c749d4c2f2bdc6ae24de5a88a339c4bce32300a31ede179", size = 402339, upload-time = "2025-06-15T19:05:24.516Z" },
-    { url = "https://files.pythonhosted.org/packages/80/28/98b222cca751ba68e88521fabd79a4fab64005fc5976ea49b53fa205d1fa/watchfiles-1.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d9ba68ec283153dead62cbe81872d28e053745f12335d037de9cbd14bd1877f5", size = 394409, upload-time = "2025-06-15T19:05:25.469Z" },
-    { url = "https://files.pythonhosted.org/packages/86/50/dee79968566c03190677c26f7f47960aff738d32087087bdf63a5473e7df/watchfiles-1.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:130fc497b8ee68dce163e4254d9b0356411d1490e868bd8790028bc46c5cc297", size = 450939, upload-time = "2025-06-15T19:05:26.494Z" },
-    { url = "https://files.pythonhosted.org/packages/40/45/a7b56fb129700f3cfe2594a01aa38d033b92a33dddce86c8dfdfc1247b72/watchfiles-1.1.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:50a51a90610d0845a5931a780d8e51d7bd7f309ebc25132ba975aca016b576a0", size = 457270, upload-time = "2025-06-15T19:05:27.466Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/c8/fa5ef9476b1d02dc6b5e258f515fcaaecf559037edf8b6feffcbc097c4b8/watchfiles-1.1.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc44678a72ac0910bac46fa6a0de6af9ba1355669b3dfaf1ce5f05ca7a74364e", size = 483370, upload-time = "2025-06-15T19:05:28.548Z" },
-    { url = "https://files.pythonhosted.org/packages/98/68/42cfcdd6533ec94f0a7aab83f759ec11280f70b11bfba0b0f885e298f9bd/watchfiles-1.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a543492513a93b001975ae283a51f4b67973662a375a403ae82f420d2c7205ee", size = 598654, upload-time = "2025-06-15T19:05:29.997Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/74/b2a1544224118cc28df7e59008a929e711f9c68ce7d554e171b2dc531352/watchfiles-1.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ac164e20d17cc285f2b94dc31c384bc3aa3dd5e7490473b3db043dd70fbccfd", size = 478667, upload-time = "2025-06-15T19:05:31.172Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/77/e3362fe308358dc9f8588102481e599c83e1b91c2ae843780a7ded939a35/watchfiles-1.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f7590d5a455321e53857892ab8879dce62d1f4b04748769f5adf2e707afb9d4f", size = 452213, upload-time = "2025-06-15T19:05:32.299Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/17/c8f1a36540c9a1558d4faf08e909399e8133599fa359bf52ec8fcee5be6f/watchfiles-1.1.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:37d3d3f7defb13f62ece99e9be912afe9dd8a0077b7c45ee5a57c74811d581a4", size = 626718, upload-time = "2025-06-15T19:05:33.415Z" },
-    { url = "https://files.pythonhosted.org/packages/26/45/fb599be38b4bd38032643783d7496a26a6f9ae05dea1a42e58229a20ac13/watchfiles-1.1.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:7080c4bb3efd70a07b1cc2df99a7aa51d98685be56be6038c3169199d0a1c69f", size = 623098, upload-time = "2025-06-15T19:05:34.534Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/e7/fdf40e038475498e160cd167333c946e45d8563ae4dd65caf757e9ffe6b4/watchfiles-1.1.0-cp312-cp312-win32.whl", hash = "sha256:cbcf8630ef4afb05dc30107bfa17f16c0896bb30ee48fc24bf64c1f970f3b1fd", size = 279209, upload-time = "2025-06-15T19:05:35.577Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/d3/3ae9d5124ec75143bdf088d436cba39812122edc47709cd2caafeac3266f/watchfiles-1.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:cbd949bdd87567b0ad183d7676feb98136cde5bb9025403794a4c0db28ed3a47", size = 292786, upload-time = "2025-06-15T19:05:36.559Z" },
-    { url = "https://files.pythonhosted.org/packages/26/2f/7dd4fc8b5f2b34b545e19629b4a018bfb1de23b3a496766a2c1165ca890d/watchfiles-1.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:0a7d40b77f07be87c6faa93d0951a0fcd8cbca1ddff60a1b65d741bac6f3a9f6", size = 284343, upload-time = "2025-06-15T19:05:37.5Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/6b/686dcf5d3525ad17b384fd94708e95193529b460a1b7bf40851f1328ec6e/watchfiles-1.1.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:0ece16b563b17ab26eaa2d52230c9a7ae46cf01759621f4fbbca280e438267b3", size = 406910, upload-time = "2025-06-15T19:06:49.335Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/d3/71c2dcf81dc1edcf8af9f4d8d63b1316fb0a2dd90cbfd427e8d9dd584a90/watchfiles-1.1.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:51b81e55d40c4b4aa8658427a3ee7ea847c591ae9e8b81ef94a90b668999353c", size = 398816, upload-time = "2025-06-15T19:06:50.433Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/fa/12269467b2fc006f8fce4cd6c3acfa77491dd0777d2a747415f28ccc8c60/watchfiles-1.1.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2bcdc54ea267fe72bfc7d83c041e4eb58d7d8dc6f578dfddb52f037ce62f432", size = 451584, upload-time = "2025-06-15T19:06:51.834Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/d3/254cea30f918f489db09d6a8435a7de7047f8cb68584477a515f160541d6/watchfiles-1.1.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:923fec6e5461c42bd7e3fd5ec37492c6f3468be0499bc0707b4bbbc16ac21792", size = 454009, upload-time = "2025-06-15T19:06:52.896Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252, upload-time = "2026-05-18T04:32:04.251Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/3d/8024c801df84d1587740d0359e7fdd80afeae3d159011f3d5376dd82f18e/watchfiles-1.2.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:704fd259e332e01f9b9c178f4bce9e49027e5587cc2600eeeaf8e76e1c846201", size = 400242, upload-time = "2026-05-18T04:31:19.014Z" },
+    { url = "https://files.pythonhosted.org/packages/87/5b/f4dfd45323e949984a3a7f9dc31d1cbb049921e7d98253488dda72ccdaa9/watchfiles-1.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6543cf55d170003296d185c0af981f3e1311564907e1f4e08671fc7693a890a5", size = 394562, upload-time = "2026-05-18T04:30:08.46Z" },
+    { url = "https://files.pythonhosted.org/packages/98/d8/19483ef075d601c409bce8bcbb5c0f81a10876fff870400568f08ce484a1/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89d8c2394a065ca86f5d2910ff263ae67c127e1376ccc4f9fc35c71db879f80a", size = 456611, upload-time = "2026-05-18T04:30:45.723Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/6a/cc81fbe7ee42f2f22e661a6e12def7807e01b14b2f39e0ff83fd373fd307/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:772b80df316480d894a0e3165fdd19cf77f5d17f9a787f94029465ad0e3529d1", size = 461379, upload-time = "2026-05-18T04:31:29.292Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/57/7e669002082c0a0f4fb5113bb70125f7110124b846b0a11bc5ae8e90eac1/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d158cd89df6053823533e06fb1d73c549133bff5f0396170c0e53d9559340717", size = 493556, upload-time = "2026-05-18T04:30:05.44Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7d/f60a2b19807b21fe8281f3a8da4f59eef0d5f96825ac4680ba2d4f2ebf91/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d516b3283a758e087841aedb8031549fb41ced08f3db10aa6d2bf32dc042525b", size = 575255, upload-time = "2026-05-18T04:30:40.568Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/49/77f5b5e6efbcd57482f74948ebb1b97e5c0046d6b61475042d830c84b3ff/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:53b2290c92e0506d102cd448fbc610d87079553f86caa39d67440856a8b8bba5", size = 467052, upload-time = "2026-05-18T04:31:17.942Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/5a/73e2959af1b97fd5d556f9a8bdba017be23ceeef731869d5eaa0a753d5a3/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a711b51aec4370d0dcda5b6c09463206f133a5759341d7744b953a7b62e1100e", size = 456858, upload-time = "2026-05-18T04:30:30.182Z" },
+    { url = "https://files.pythonhosted.org/packages/50/57/1bc8c27fad7e6c19bddee15d276dbb6ab72480ec01c127afff1673aee417/watchfiles-1.2.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:e2ca07fa7d89195ec0865d3d285666286740bfa83d83e5cee204043a31ecc165", size = 467579, upload-time = "2026-05-18T04:32:15.897Z" },
+    { url = "https://files.pythonhosted.org/packages/09/6c/3c2e44edba3553c5e3c3b8c8a2a6dee6b9e12ae2cf4bd2378bebf9dc3038/watchfiles-1.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e0618518f282c4ebff60f5e5b1247b6d91bb8b9f4476947563a1e74acc66f3c6", size = 633253, upload-time = "2026-05-18T04:31:37.123Z" },
+    { url = "https://files.pythonhosted.org/packages/30/c2/d8c84a882ab39bbefcc4915ab3e91830b7a7e990c5570b0b69075aba3faf/watchfiles-1.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0d191c054d0715c3c95c99df9b8dbf6fd096d8c1e021e8f212e1bd8bc444ccb5", size = 660713, upload-time = "2026-05-18T04:31:24.62Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/07/f97736a5fc605364fe67b25e9fa4a6965dfd4840d50c406ada507e9d735f/watchfiles-1.2.0-cp311-cp311-win32.whl", hash = "sha256:9342472aff9b093c5acd4f6d8f70ae0937964ab56542502bcf5579782da69ae8", size = 277222, upload-time = "2026-05-18T04:31:21.131Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/99/2b04981977fc2608afd60360d928c6aecf6b950292ca221d98f4005f6694/watchfiles-1.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:dbd6c97045dad81227c8d040173da044c1de08de64a5ea8b555da4aee1d5fa22", size = 290274, upload-time = "2026-05-18T04:31:45.966Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/74/f7f58a7075ee9cf612b0cfcddb78b8cd8234f0742d6f0075cf0da2dde1c6/watchfiles-1.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:57a2d9fa4fb4c2ecae57b13dfff2c7ab53e21a2ba674fe9f05506680fcdcc0d7", size = 283460, upload-time = "2026-05-18T04:31:39.126Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/2f/e42c992d2afda3108ea1c02acecc991b9f31d05c14adc2a7cee9ee211fc4/watchfiles-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26", size = 400115, upload-time = "2026-05-18T04:32:02.06Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/8f/6af2ea19065c91d8b0ea3516fdfc8c0d349f407e8e9fbf4e5a17360de8ad/watchfiles-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c", size = 393659, upload-time = "2026-05-18T04:30:50.951Z" },
+    { url = "https://files.pythonhosted.org/packages/13/01/b32a967c56fb3e3e5be3db52c3d3b87fa4513aa367d8ed1ad96d42952e5f/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc", size = 453207, upload-time = "2026-05-18T04:31:04.231Z" },
+    { url = "https://files.pythonhosted.org/packages/04/98/97557a812180338cb1abd32e1cffcc4588f59b5f23e0cb006b2ba95ba64a/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0", size = 459273, upload-time = "2026-05-18T04:31:50.377Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/a8/b4b08dcb7653b8087c6586f7ce649505900e866bbcfe40dc9587af02e686/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c", size = 489927, upload-time = "2026-05-18T04:31:42.485Z" },
+    { url = "https://files.pythonhosted.org/packages/50/94/3dceea03545d2e5ddfd839f0ddd5e1cecbf1697b5a428d5ba11cef6af95d/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01", size = 570476, upload-time = "2026-05-18T04:31:03.071Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/f2/d39a5450c3532092b91f81d274360e613c2371bc874a89c7a1a3c5e8d138/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8", size = 465650, upload-time = "2026-05-18T04:30:12.701Z" },
+    { url = "https://files.pythonhosted.org/packages/22/24/ed72f68cbc1333ca9b9f2200aa048bb6658ae41709bc1caad4310f4bdffd/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5", size = 456398, upload-time = "2026-05-18T04:30:13.784Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/64/982ef4a4e5bab5b6e5b6becc8cd5e732f6130a78b855f0abec6439a9a135/watchfiles-1.2.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d", size = 465140, upload-time = "2026-05-18T04:31:52.111Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0c/95282abf4ed680b6096010bcfc30c5fa7a041fc5aa5a2ad17a2cc6c75bba/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c", size = 630259, upload-time = "2026-05-18T04:31:25.676Z" },
+    { url = "https://files.pythonhosted.org/packages/30/45/607c1de1530c4bdcf2cf1d1ecc2505ddba5d96bd43ba9f2b0e79876f850f/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906", size = 659859, upload-time = "2026-05-18T04:30:24.333Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/08/d9e2e0f9e8e6791d33aefc694ad7eefa7f901f63caff84a81ded38692f9c/watchfiles-1.2.0-cp312-cp312-win32.whl", hash = "sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898", size = 275480, upload-time = "2026-05-18T04:30:31.307Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/e6/9d42569c0102645cc8cea5d8c7d8a1e9d4ada2cb7f05f75e554b8aa2202a/watchfiles-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379", size = 288718, upload-time = "2026-05-18T04:32:10.745Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/26/88e0dc6ee3898169d7fa22bb6a69cabf2502d2ee25cb8c876d1262d204f8/watchfiles-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5", size = 281026, upload-time = "2026-05-18T04:30:22.23Z" },
+    { url = "https://files.pythonhosted.org/packages/23/f4/7513ef1e85fc4c6331b59479d6d72661fc391fbe543678052ac72c8b6c19/watchfiles-1.2.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:4674d49eb94706dfe666c069fc0a1b646ffcf920473492e209f6d5f60d3f0cc2", size = 403050, upload-time = "2026-05-18T04:30:36.753Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0b/a54103cfd732bb703c7a749222011a0483ef3705948dae3b203158601119/watchfiles-1.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:094b9b70103d4e963499bdea001ee3c2697b144cd9ae6218a62c0f89ec9e31db", size = 396629, upload-time = "2026-05-18T04:32:03.268Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2c/73f31a3b893886206c3f54d73e8ad8dee58cdb2f69ad2622e0a8a9e07f4e/watchfiles-1.2.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0ef001f8c25ad0fa9529f914c1600647ecd0f542d11c19b7894768c67b6acb7", size = 457318, upload-time = "2026-05-18T04:31:01.932Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/f9/45d021e4a5cc7b9dd567f7cbb06d3b75f751a690063fb6cc7ec60f4e46b7/watchfiles-1.2.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a88fc94e647bc4eec523f1caa540258eb71d14278b9daf72fa1e2658a98df0f0", size = 457771, upload-time = "2026-05-18T04:30:56.331Z" },
 ]
 
 [[package]]
 name = "wcwidth"
-version = "0.2.14"
+version = "0.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293, upload-time = "2025-09-22T16:29:53.023Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/ee/afaf0f85a9a18fe47a67f1e4422ed6cf1fe642f0ae0a2f81166231303c52/wcwidth-0.7.0.tar.gz", hash = "sha256:90e3a7ea092341c44b99562e75d09e4d5160fe7a3974c6fb842a101a95e7eed0", size = 182132, upload-time = "2026-05-02T16:04:12.653Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286, upload-time = "2025-09-22T16:29:51.641Z" },
+    { url = "https://files.pythonhosted.org/packages/41/52/e465037f5375f43533d1a80b6923955201596a99142ed524d77b571a1418/wcwidth-0.7.0-py3-none-any.whl", hash = "sha256:5d69154c429a82910e241c738cd0e2976fac8a2dd47a1a805f4afed1c0f136f2", size = 110825, upload-time = "2026-05-02T16:04:11.033Z" },
 ]
 
 [[package]]
 name = "weasel"
-version = "0.4.1"
+version = "0.4.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cloudpathlib" },
@@ -3465,43 +3300,53 @@ dependencies = [
     { name = "requests" },
     { name = "smart-open" },
     { name = "srsly" },
-    { name = "typer" },
+    { name = "typer-slim" },
     { name = "wasabi" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a7/1a/9c522dd61b52939c217925d3e55c95f9348b73a66a956f52608e1e59a2c0/weasel-0.4.1.tar.gz", hash = "sha256:aabc210f072e13f6744e5c3a28037f93702433405cd35673f7c6279147085aa9", size = 38417, upload-time = "2024-05-15T08:52:54.765Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/09/d7/edd9c24e60cf8e5de130aa2e8af3b01521f4d0216c371d01212f580d0d8e/weasel-0.4.3.tar.gz", hash = "sha256:f293d6174398e8f478c78481e00c503ee4b82ea7a3e6d0d6a01e46a6b1396845", size = 38733, upload-time = "2025-11-13T23:52:28.193Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/74/a148b41572656904a39dfcfed3f84dd1066014eed94e209223ae8e9d088d/weasel-0.4.3-py3-none-any.whl", hash = "sha256:08f65b5d0dbded4879e08a64882de9b9514753d9eaa4c4e2a576e33666ac12cf", size = 50757, upload-time = "2025-11-13T23:52:26.982Z" },
+]
+
+[[package]]
+name = "webencodings"
+version = "0.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/87/abd57374044e1f627f0a905ac33c1a7daab35a3a815abfea4e1bafd3fdb1/weasel-0.4.1-py3-none-any.whl", hash = "sha256:24140a090ea1ac512a2b2f479cc64192fd1d527a7f3627671268d08ed5ac418c", size = 50270, upload-time = "2024-05-15T08:52:52.977Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" },
 ]
 
 [[package]]
 name = "websockets"
-version = "15.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
-    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
-    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
-    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
-    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
-    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
-    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
-    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
-    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
-    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
-    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+version = "16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/db/de907251b4ff46ae804ad0409809504153b3f30984daf82a1d84a9875830/websockets-16.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:31a52addea25187bde0797a97d6fc3d2f92b6f72a9370792d65a6e84615ac8a8", size = 177340, upload-time = "2026-01-10T09:22:34.539Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/fa/abe89019d8d8815c8781e90d697dec52523fb8ebe308bf11664e8de1877e/websockets-16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:417b28978cdccab24f46400586d128366313e8a96312e4b9362a4af504f3bbad", size = 175022, upload-time = "2026-01-10T09:22:36.332Z" },
+    { url = "https://files.pythonhosted.org/packages/58/5d/88ea17ed1ded2079358b40d31d48abe90a73c9e5819dbcde1606e991e2ad/websockets-16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:af80d74d4edfa3cb9ed973a0a5ba2b2a549371f8a741e0800cb07becdd20f23d", size = 175319, upload-time = "2026-01-10T09:22:37.602Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ae/0ee92b33087a33632f37a635e11e1d99d429d3d323329675a6022312aac2/websockets-16.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:08d7af67b64d29823fed316505a89b86705f2b7981c07848fb5e3ea3020c1abe", size = 184631, upload-time = "2026-01-10T09:22:38.789Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/c5/27178df583b6c5b31b29f526ba2da5e2f864ecc79c99dae630a85d68c304/websockets-16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7be95cfb0a4dae143eaed2bcba8ac23f4892d8971311f1b06f3c6b78952ee70b", size = 185870, upload-time = "2026-01-10T09:22:39.893Z" },
+    { url = "https://files.pythonhosted.org/packages/87/05/536652aa84ddc1c018dbb7e2c4cbcd0db884580bf8e95aece7593fde526f/websockets-16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d6297ce39ce5c2e6feb13c1a996a2ded3b6832155fcfc920265c76f24c7cceb5", size = 185361, upload-time = "2026-01-10T09:22:41.016Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/e2/d5332c90da12b1e01f06fb1b85c50cfc489783076547415bf9f0a659ec19/websockets-16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1c1b30e4f497b0b354057f3467f56244c603a79c0d1dafce1d16c283c25f6e64", size = 184615, upload-time = "2026-01-10T09:22:42.442Z" },
+    { url = "https://files.pythonhosted.org/packages/77/fb/d3f9576691cae9253b51555f841bc6600bf0a983a461c79500ace5a5b364/websockets-16.0-cp311-cp311-win32.whl", hash = "sha256:5f451484aeb5cafee1ccf789b1b66f535409d038c56966d6101740c1614b86c6", size = 178246, upload-time = "2026-01-10T09:22:43.654Z" },
+    { url = "https://files.pythonhosted.org/packages/54/67/eaff76b3dbaf18dcddabc3b8c1dba50b483761cccff67793897945b37408/websockets-16.0-cp311-cp311-win_amd64.whl", hash = "sha256:8d7f0659570eefb578dacde98e24fb60af35350193e4f56e11190787bee77dac", size = 178684, upload-time = "2026-01-10T09:22:44.941Z" },
+    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" },
+    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" },
+    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" },
+    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" },
+    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" },
+    { url = "https://files.pythonhosted.org/packages/72/07/c98a68571dcf256e74f1f816b8cc5eae6eb2d3d5cfa44d37f801619d9166/websockets-16.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:349f83cd6c9a415428ee1005cadb5c2c56f4389bc06a9af16103c3bc3dcc8b7d", size = 174947, upload-time = "2026-01-10T09:23:36.166Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/52/93e166a81e0305b33fe416338be92ae863563fe7bce446b0f687b9df5aea/websockets-16.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:4a1aba3340a8dca8db6eb5a7986157f52eb9e436b74813764241981ca4888f03", size = 175260, upload-time = "2026-01-10T09:23:37.409Z" },
+    { url = "https://files.pythonhosted.org/packages/56/0c/2dbf513bafd24889d33de2ff0368190a0e69f37bcfa19009ef819fe4d507/websockets-16.0-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f4a32d1bd841d4bcbffdcb3d2ce50c09c3909fbead375ab28d0181af89fd04da", size = 176071, upload-time = "2026-01-10T09:23:39.158Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/8f/aea9c71cc92bf9b6cc0f7f70df8f0b420636b6c96ef4feee1e16f80f75dd/websockets-16.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0298d07ee155e2e9fda5be8a9042200dd2e3bb0b8a38482156576f863a9d457c", size = 176968, upload-time = "2026-01-10T09:23:41.031Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/3f/f70e03f40ffc9a30d817eef7da1be72ee4956ba8d7255c399a01b135902a/websockets-16.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:a653aea902e0324b52f1613332ddf50b00c06fdaf7e92624fbf8c77c78fa5767", size = 178735, upload-time = "2026-01-10T09:23:42.259Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" },
 ]
 
 [[package]]
@@ -3535,57 +3380,59 @@ wheels = [
 
 [[package]]
 name = "yarl"
-version = "1.20.1"
+version = "1.23.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "multidict" },
     { name = "propcache" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3c/fb/efaa23fa4e45537b827620f04cf8f3cd658b76642205162e072703a5b963/yarl-1.20.1.tar.gz", hash = "sha256:d017a4997ee50c91fd5466cef416231bb82177b93b029906cefc542ce14c35ac", size = 186428, upload-time = "2025-06-10T00:46:09.923Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/18/893b50efc2350e47a874c5c2d67e55a0ea5df91186b2a6f5ac52eff887cd/yarl-1.20.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:47ee6188fea634bdfaeb2cc420f5b3b17332e6225ce88149a17c413c77ff269e", size = 133833, upload-time = "2025-06-10T00:43:07.393Z" },
-    { url = "https://files.pythonhosted.org/packages/89/ed/b8773448030e6fc47fa797f099ab9eab151a43a25717f9ac043844ad5ea3/yarl-1.20.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d0f6500f69e8402d513e5eedb77a4e1818691e8f45e6b687147963514d84b44b", size = 91070, upload-time = "2025-06-10T00:43:09.538Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/e3/409bd17b1e42619bf69f60e4f031ce1ccb29bd7380117a55529e76933464/yarl-1.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7a8900a42fcdaad568de58887c7b2f602962356908eedb7628eaf6021a6e435b", size = 89818, upload-time = "2025-06-10T00:43:11.575Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/77/64d8431a4d77c856eb2d82aa3de2ad6741365245a29b3a9543cd598ed8c5/yarl-1.20.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bad6d131fda8ef508b36be3ece16d0902e80b88ea7200f030a0f6c11d9e508d4", size = 347003, upload-time = "2025-06-10T00:43:14.088Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/d2/0c7e4def093dcef0bd9fa22d4d24b023788b0a33b8d0088b51aa51e21e99/yarl-1.20.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:df018d92fe22aaebb679a7f89fe0c0f368ec497e3dda6cb81a567610f04501f1", size = 336537, upload-time = "2025-06-10T00:43:16.431Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/f3/fc514f4b2cf02cb59d10cbfe228691d25929ce8f72a38db07d3febc3f706/yarl-1.20.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f969afbb0a9b63c18d0feecf0db09d164b7a44a053e78a7d05f5df163e43833", size = 362358, upload-time = "2025-06-10T00:43:18.704Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/6d/a313ac8d8391381ff9006ac05f1d4331cee3b1efaa833a53d12253733255/yarl-1.20.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:812303eb4aa98e302886ccda58d6b099e3576b1b9276161469c25803a8db277d", size = 357362, upload-time = "2025-06-10T00:43:20.888Z" },
-    { url = "https://files.pythonhosted.org/packages/00/70/8f78a95d6935a70263d46caa3dd18e1f223cf2f2ff2037baa01a22bc5b22/yarl-1.20.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98c4a7d166635147924aa0bf9bfe8d8abad6fffa6102de9c99ea04a1376f91e8", size = 348979, upload-time = "2025-06-10T00:43:23.169Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/05/42773027968968f4f15143553970ee36ead27038d627f457cc44bbbeecf3/yarl-1.20.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:12e768f966538e81e6e7550f9086a6236b16e26cd964cf4df35349970f3551cf", size = 337274, upload-time = "2025-06-10T00:43:27.111Z" },
-    { url = "https://files.pythonhosted.org/packages/05/be/665634aa196954156741ea591d2f946f1b78ceee8bb8f28488bf28c0dd62/yarl-1.20.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fe41919b9d899661c5c28a8b4b0acf704510b88f27f0934ac7a7bebdd8938d5e", size = 363294, upload-time = "2025-06-10T00:43:28.96Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/90/73448401d36fa4e210ece5579895731f190d5119c4b66b43b52182e88cd5/yarl-1.20.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:8601bc010d1d7780592f3fc1bdc6c72e2b6466ea34569778422943e1a1f3c389", size = 358169, upload-time = "2025-06-10T00:43:30.701Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/b0/fce922d46dc1eb43c811f1889f7daa6001b27a4005587e94878570300881/yarl-1.20.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:daadbdc1f2a9033a2399c42646fbd46da7992e868a5fe9513860122d7fe7a73f", size = 362776, upload-time = "2025-06-10T00:43:32.51Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/0d/b172628fce039dae8977fd22caeff3eeebffd52e86060413f5673767c427/yarl-1.20.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:03aa1e041727cb438ca762628109ef1333498b122e4c76dd858d186a37cec845", size = 381341, upload-time = "2025-06-10T00:43:34.543Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/9b/5b886d7671f4580209e855974fe1cecec409aa4a89ea58b8f0560dc529b1/yarl-1.20.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:642980ef5e0fa1de5fa96d905c7e00cb2c47cb468bfcac5a18c58e27dbf8d8d1", size = 379988, upload-time = "2025-06-10T00:43:36.489Z" },
-    { url = "https://files.pythonhosted.org/packages/73/be/75ef5fd0fcd8f083a5d13f78fd3f009528132a1f2a1d7c925c39fa20aa79/yarl-1.20.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:86971e2795584fe8c002356d3b97ef6c61862720eeff03db2a7c86b678d85b3e", size = 371113, upload-time = "2025-06-10T00:43:38.592Z" },
-    { url = "https://files.pythonhosted.org/packages/50/4f/62faab3b479dfdcb741fe9e3f0323e2a7d5cd1ab2edc73221d57ad4834b2/yarl-1.20.1-cp311-cp311-win32.whl", hash = "sha256:597f40615b8d25812f14562699e287f0dcc035d25eb74da72cae043bb884d773", size = 81485, upload-time = "2025-06-10T00:43:41.038Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/09/d9c7942f8f05c32ec72cd5c8e041c8b29b5807328b68b4801ff2511d4d5e/yarl-1.20.1-cp311-cp311-win_amd64.whl", hash = "sha256:26ef53a9e726e61e9cd1cda6b478f17e350fb5800b4bd1cd9fe81c4d91cfeb2e", size = 86686, upload-time = "2025-06-10T00:43:42.692Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/9a/cb7fad7d73c69f296eda6815e4a2c7ed53fc70c2f136479a91c8e5fbdb6d/yarl-1.20.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdcc4cd244e58593a4379fe60fdee5ac0331f8eb70320a24d591a3be197b94a9", size = 133667, upload-time = "2025-06-10T00:43:44.369Z" },
-    { url = "https://files.pythonhosted.org/packages/67/38/688577a1cb1e656e3971fb66a3492501c5a5df56d99722e57c98249e5b8a/yarl-1.20.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b29a2c385a5f5b9c7d9347e5812b6f7ab267193c62d282a540b4fc528c8a9d2a", size = 91025, upload-time = "2025-06-10T00:43:46.295Z" },
-    { url = "https://files.pythonhosted.org/packages/50/ec/72991ae51febeb11a42813fc259f0d4c8e0507f2b74b5514618d8b640365/yarl-1.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1112ae8154186dfe2de4732197f59c05a83dc814849a5ced892b708033f40dc2", size = 89709, upload-time = "2025-06-10T00:43:48.22Z" },
-    { url = "https://files.pythonhosted.org/packages/99/da/4d798025490e89426e9f976702e5f9482005c548c579bdae792a4c37769e/yarl-1.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:90bbd29c4fe234233f7fa2b9b121fb63c321830e5d05b45153a2ca68f7d310ee", size = 352287, upload-time = "2025-06-10T00:43:49.924Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/26/54a15c6a567aac1c61b18aa0f4b8aa2e285a52d547d1be8bf48abe2b3991/yarl-1.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:680e19c7ce3710ac4cd964e90dad99bf9b5029372ba0c7cbfcd55e54d90ea819", size = 345429, upload-time = "2025-06-10T00:43:51.7Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/95/9dcf2386cb875b234353b93ec43e40219e14900e046bf6ac118f94b1e353/yarl-1.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4a979218c1fdb4246a05efc2cc23859d47c89af463a90b99b7c56094daf25a16", size = 365429, upload-time = "2025-06-10T00:43:53.494Z" },
-    { url = "https://files.pythonhosted.org/packages/91/b2/33a8750f6a4bc224242a635f5f2cff6d6ad5ba651f6edcccf721992c21a0/yarl-1.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:255b468adf57b4a7b65d8aad5b5138dce6a0752c139965711bdcb81bc370e1b6", size = 363862, upload-time = "2025-06-10T00:43:55.766Z" },
-    { url = "https://files.pythonhosted.org/packages/98/28/3ab7acc5b51f4434b181b0cee8f1f4b77a65919700a355fb3617f9488874/yarl-1.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a97d67108e79cfe22e2b430d80d7571ae57d19f17cda8bb967057ca8a7bf5bfd", size = 355616, upload-time = "2025-06-10T00:43:58.056Z" },
-    { url = "https://files.pythonhosted.org/packages/36/a3/f666894aa947a371724ec7cd2e5daa78ee8a777b21509b4252dd7bd15e29/yarl-1.20.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8570d998db4ddbfb9a590b185a0a33dbf8aafb831d07a5257b4ec9948df9cb0a", size = 339954, upload-time = "2025-06-10T00:43:59.773Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/81/5f466427e09773c04219d3450d7a1256138a010b6c9f0af2d48565e9ad13/yarl-1.20.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:97c75596019baae7c71ccf1d8cc4738bc08134060d0adfcbe5642f778d1dca38", size = 365575, upload-time = "2025-06-10T00:44:02.051Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/e3/e4b0ad8403e97e6c9972dd587388940a032f030ebec196ab81a3b8e94d31/yarl-1.20.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1c48912653e63aef91ff988c5432832692ac5a1d8f0fb8a33091520b5bbe19ef", size = 365061, upload-time = "2025-06-10T00:44:04.196Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/99/b8a142e79eb86c926f9f06452eb13ecb1bb5713bd01dc0038faf5452e544/yarl-1.20.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4c3ae28f3ae1563c50f3d37f064ddb1511ecc1d5584e88c6b7c63cf7702a6d5f", size = 364142, upload-time = "2025-06-10T00:44:06.527Z" },
-    { url = "https://files.pythonhosted.org/packages/34/f2/08ed34a4a506d82a1a3e5bab99ccd930a040f9b6449e9fd050320e45845c/yarl-1.20.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c5e9642f27036283550f5f57dc6156c51084b458570b9d0d96100c8bebb186a8", size = 381894, upload-time = "2025-06-10T00:44:08.379Z" },
-    { url = "https://files.pythonhosted.org/packages/92/f8/9a3fbf0968eac704f681726eff595dce9b49c8a25cd92bf83df209668285/yarl-1.20.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:2c26b0c49220d5799f7b22c6838409ee9bc58ee5c95361a4d7831f03cc225b5a", size = 383378, upload-time = "2025-06-10T00:44:10.51Z" },
-    { url = "https://files.pythonhosted.org/packages/af/85/9363f77bdfa1e4d690957cd39d192c4cacd1c58965df0470a4905253b54f/yarl-1.20.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:564ab3d517e3d01c408c67f2e5247aad4019dcf1969982aba3974b4093279004", size = 374069, upload-time = "2025-06-10T00:44:12.834Z" },
-    { url = "https://files.pythonhosted.org/packages/35/99/9918c8739ba271dcd935400cff8b32e3cd319eaf02fcd023d5dcd487a7c8/yarl-1.20.1-cp312-cp312-win32.whl", hash = "sha256:daea0d313868da1cf2fac6b2d3a25c6e3a9e879483244be38c8e6a41f1d876a5", size = 81249, upload-time = "2025-06-10T00:44:14.731Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/83/5d9092950565481b413b31a23e75dd3418ff0a277d6e0abf3729d4d1ce25/yarl-1.20.1-cp312-cp312-win_amd64.whl", hash = "sha256:48ea7d7f9be0487339828a4de0360d7ce0efc06524a48e1810f945c45b813698", size = 86710, upload-time = "2025-06-10T00:44:16.716Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/2d/2345fce04cfd4bee161bf1e7d9cdc702e3e16109021035dbb24db654a622/yarl-1.20.1-py3-none-any.whl", hash = "sha256:83b8eb083fe4683c6115795d9fc1cfaf2cbbefb19b3a1cb68f6527460f483a77", size = 46542, upload-time = "2025-06-10T00:46:07.521Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
+    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
+    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
+    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
+    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
+    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
+    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
+    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
+    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
+    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
+    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
+    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
+    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
 ]
 
 [[package]]
 name = "zipp"
-version = "3.23.0"
+version = "4.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b9/d8/eab98a517c14134c0b2eb4e2387bc5f457334293ec5d2dd3857ec2966802/zipp-4.1.0.tar.gz", hash = "sha256:4cb57381f544315db7688e976e922a2b18cdb513d21cc194eb42232ba2a3e602", size = 26214, upload-time = "2026-05-18T20:08:57.967Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/13/547360d81e6d88d58492968ffda9f9542854f11310ee556fef14260cc886/zipp-4.1.0-py3-none-any.whl", hash = "sha256:25ad4e16390cd314347dd8f1de67a2ac538ae658ed4ab9db16029c07c188e97f", size = 10238, upload-time = "2026-05-18T20:08:57.045Z" },
 ]