diff --git a/.specs/issue-14-explore-filters.md b/.specs/issue-14-explore-filters.md
new file mode 100644
index 0000000..2073dcf
--- /dev/null
+++ b/.specs/issue-14-explore-filters.md
@@ -0,0 +1,131 @@
+# Spec: Explore Filters — search, ranges, method, star type, all in the URL
+Issue: #14
+Status: approved
+
+## Problem Statement
+ROADMAP item 3 says "Improve Advanced Filters", but there is little to improve: the explore
+page's only controls are a search box and a single-select discovery-method dropdown that live
+as component-local state inside `PlanetTable` — they apply only to the table view (grid view is
+unfiltered), vanish on reload, and can't be shared. A visitor who narrows ~6,000 planets down
+to "temperate, roughly Earth-sized, around a red dwarf" has no way to do it, and no way to send
+that view to anyone. This is a build, not an enhancement (#14).
+
+## Goals
+- Filter the explore list by name/host search, radius, mass, orbital period, discovery method(s), and star type.
+- Filter and sort state lives in the URL: shareable, bookmarkable, reload-safe.
+- One module owns filter semantics; grid and table views always show the same filtered set.
+- Controls are keyboard- and screen-reader-accessible, with a live results count.
+
+## Out of Scope
+- localStorage persistence — the URL is the single share primitive (per #14 discussion).
+- The grid/table `view` toggle stays component-local and out of the URL — it's a presentation preference, not part of the selection; a shared URL reproduces *what* is shown, not *how*.
+- Server-side filtering or API query params (see Technical Approach).
+- Comparison tool, saved searches, 3D visualisation — downstream, part of the #36 direction discussion.
+- Fixing #6 (keyboard access to table rows/sort headers) — separate task issue; should land before this epic's UI tasks.
+
+## Acceptance Criteria
+- [ ] Search box filters by planet name or host star (case-insensitive substring, current semantics), reflected in `?q=`, and applies to **both** grid and table views.
+- [ ] Radius, mass, and orbital period each have a min/max range control on a log scale, reflected in the URL; a planet lacking that measurement is excluded **only while that filter is active**, and the UI says so (e.g. "planets without a measured mass are hidden").
+- [ ] Discovery method is a multi-select whose options are the distinct values present in the data, reflected as `?method=` (comma-separated).
+- [ ] Star type filter offers O/B/A/F/G/K/M classes with plain-language labels ("M — red dwarf"), reflected as `?star=`.
+- [ ] Table sort key/direction is reflected as `?sort=` (e.g. `?sort=pl_rade.asc`); the default (`disc_year.desc`) is omitted from the URL; a shared URL reproduces both the filtered set and its ordering, and Back/Forward keeps the header ▲/▼ indicators in sync with the actual order.
+- [ ] "Clear all" resets every filter and the URL; the results count ("N of M planets", M computed from the fetched list — never a hardcoded total) updates in an `aria-live=polite` region.
+- [ ] Malformed or unknown URL params are silently ignored — the page never shows an error state because of a bad query string.
+- [ ] Changing any filter clamps/resets pagination; no empty page-37-of-2 states.
+- [ ] `lib/planetFilters.ts` is pure and unit-tested: URL codec round-trips, null-value semantics, and teff→class banding (band edges exactly as tabulated in Technical Approach, including boundary values and the sub-2,300 K/unclassified case).
+- [ ] `applyFilters` over the full list is memoised in `ExploreClient` (`useMemo` on planets + filter state) — `PlanetTable` already memoises today, and the hoist must not silently drop that.
+- [ ] `/api/planets` projection includes `pl_orbper` and `st_teff`; `route.test.ts` updated accordingly.
+- [ ] All range/select controls are native HTML inputs or have full keyboard operation with visible focus; labels associated via `<label>`/`aria-labelledby`.
+
+## Technical Approach
+All frontend (`exoplanethub.com/`), plus a two-line data-plumbing change to the API projection.
+
+**Where filtering happens — client side, over the already-fetched full dataset.**
+Alternative: query params on `/api/planets` with DynamoDB `FilterExpression` — rejected: a
+filtered Scan still reads the whole table (no cost win), and it shatters today's single
+CDN-cacheable response into a cache miss per filter combination. ~6k rows × 11 summary fields
+filters in memory in well under a frame.
+
+**One pure module owns filter semantics: `lib/planetFilters.ts`.**
+Exports a `FilterState` type, `parseFilters(searchParams)` / `serializeFilters(state)` (the URL
+schema lives *only* here), `applyFilters(planets, state)`, and the teff→class band table.
+A thin `useFilterParams()` hook (client) binds it to `useSearchParams` + `router.replace`
+(debounced, `scroll: false`; `replace` not `push` so Back doesn't step through keystrokes —
+alternative was `push` per discrete change, rejected as history spam for marginal benefit).
+Filtering is applied once in `ExploreClient`; `PlanetTable` loses its local `search`/`typeFilter`
+state and becomes a dumb renderer of the filtered list. This fixes the current grid/table
+inconsistency and keeps the URL schema encapsulated in one file.
+Alternative: the `nuqs` library — solid, but a dependency for one page when the custom hook is
+~40 lines; rejected. Revisit if URL state spreads to other pages.
+`planetFilters.ts` holds the codec, the predicate engine, and the band table — fine at this
+size; if it passes ~200 lines, split the band table into its own file (`esiBands.ts` is the
+precedent).
+
+**URL schema** (public contract, so pinned here): `q` (string), `radius`, `mass`, `period` as
+`min..max` with either end omissible (`radius=0.5..2`, `period=..365`), `method` and `star`
+comma-separated, `sort` as `key.dir` (`sort=pl_rade.asc`; default `disc_year.desc` omitted).
+Values are real units (Earth radii/masses, days), not slider positions — URLs stay
+human-readable. Absent/malformed → filter inactive / default sort, never an error.
+Sort lives in `FilterState`: `sortKey`/`sortOrder` move out of `PlanetTable`'s local state into
+the single `useFilterParams()` in `ExploreClient`, which passes `sortKey`/`sortOrder`/`onSort`
+to `PlanetTable` as props (the comparator still runs inside the table). One hook instance means
+one debounced `router.replace` writer for the whole query string, and Back/Forward can't desync
+the ▲/▼ indicator from the actual ordering. Alternative: keep sort in table state and persist
+only its URL slice from there — rejected: two hook instances are two debounced writers racing on
+the same URL (a pending `?q=` write and a sort click each serialize a snapshot missing the
+other's slice; last write wins and drops one), and Back changes the URL without changing the
+table's state. Alternative: leave sort out of the URL entirely — rejected because a shared URL
+that reproduces the filters but not the ordering shows the recipient a different first page,
+the Problem Statement's own complaint half-fixed.
+
+**Range controls — paired min/max number inputs as the primary mechanism, with a log-scale
+dual-thumb track built from two overlaid native `<input type="range">` as enhancement.**
+These quantities span up to ~8 orders of magnitude (period: ~0.09 to ~8×10⁶ days in the current
+dataset), so linear sliders are useless; the slider maps position↔value through log10, and the
+track bounds are derived from the fetched data's actual min/max — never hardcoded, or the
+longest-period planets fall off the end of the track. Native inputs keep keyboard and
+screen-reader behaviour for free. Alternative: a custom ARIA slider widget — rejected; hand-rolled
+ARIA sliders are where a11y bugs live, and number inputs already give precise entry.
+
+**Star type — derive O/B/A/F/G/K/M from `st_teff` bands in the frontend.**
+Alternative: sync NASA's `st_spectype` column — rejected: backend schema change plus full
+resync, and the column is messy free text ("G2 V", "sdB", many nulls) that needs parsing anyway.
+Temperature bands are deterministic, already per-planet, and the band table sits next to the
+other filter logic. Decided in #14 (2026-08-30): Zack deferred to team consensus, and both the
+architect and PM back temperature bands — no `st_spectype` column, no sync migration.
+
+Cut points (pinned here so they aren't an implementation-time judgment call): class edges from
+the Pecaut & Mamajek 2013 dwarf calibration (Mamajek's maintained "Modern Mean Dwarf Stellar
+Color and Effective Temperature Sequence"). Alternative: the traditional Harvard/MK edges
+(30,000/10,000/7,500/6,000/5,200/3,700/2,400) — rejected because they disagree with the modern
+calibration at five of seven edges, and at K/M specifically they mislabel ~150 planets in the
+current dataset (hosts in 3,700–3,900 K, M dwarfs per P&M) as "K — orange dwarf" on this spec's
+own flagship "red dwarf" filter. Intervals are half-open, lower bound inclusive, in K:
+
+| Class | `st_teff` range   | Label            |
+|-------|-------------------|------------------|
+| O     | ≥ 33,000          | O — blue giant   |
+| B     | 10,000 – 33,000   | B — blue-white   |
+| A     | 7,300 – 10,000    | A — white        |
+| F     | 6,000 – 7,300     | F — yellow-white |
+| G     | 5,300 – 6,000     | G — sun-like     |
+| K     | 3,900 – 5,300     | K — orange dwarf |
+| M     | 2,300 – 3,900     | M — red dwarf    |
+
+A star below 2,300 K (brown-dwarf hosts, e.g. L/T types) or with no `st_teff` is *unclassified*
+and follows the same rule as any missing measurement: hidden only while the star filter is
+active, and the UI says so. (Extending M downward instead was rejected — labelling a brown
+dwarf "red dwarf" is exactly the kind of quiet wrongness a curious visitor would catch.)
+
+**Constraints/risks:** Verified on Next 16.3.3 (review of this spec): `useSearchParams` in
+`ExploreClient` needs no Suspense boundary — `/explore` stays statically prerendered
+(`○ (Static)` in `next build`) and reads params correctly after hydration.
+Payload grows two numeric fields (~10%); harmless under the existing CDN caching. #6 should merge
+before tasks 2–4 so new controls land on an already-keyboard-sound page.
+
+## Task Breakdown
+Order matches the shape approved in #14; each later task is a thin addition once task 1 exists.
+1. Filter foundation: `lib/planetFilters.ts` + `useFilterParams`; hoist search box, method select, *and sort state* out of `PlanetTable` into `ExploreClient` (sort passed back to the table as `sortKey`/`sortOrder`/`onSort` props), wire `?q=` and `?sort=`, filter both views, clamp pagination (size: M)
+2. Range filters for radius, mass, orbital period; add `pl_orbper` to `PLANET_SUMMARY_FIELDS`; log-scale control + number inputs (size: L)
+3. Upgrade discovery method to multi-select with `?method=` (size: S)
+4. Star type filter (`st_teff` into fields, teff→class bands) + "clear all" + live results count (size: M)
diff --git a/.specs/issue-51-planet-pages.md b/.specs/issue-51-planet-pages.md
new file mode 100644
index 0000000..6297b9d
--- /dev/null
+++ b/.specs/issue-51-planet-pages.md
@@ -0,0 +1,118 @@
+# Spec: Shareable Planet Pages
+Issue: #51
+Status: approved
+
+## Problem Statement
+A planet currently exists only as `PlanetModal` inside the explore view — it has no URL, so it
+cannot be linked, bookmarked, or previewed in a message, and search engines cannot discover
+individual planets at all. The archive-first direction (#36) says the thing people share is a
+planet; this gives every planet a permanent, server-rendered address with real `<title>`/OG
+metadata, and room for the plain-language context a modal can't fit.
+
+## Goals
+- Every archived planet gets a canonical URL: `/planet/[name]`, server-rendered from DynamoDB.
+- Shared links preview meaningfully ("Kepler-452 b — 1.6 R⊕, 385-day orbit"), not as a bare domain.
+- The page shows the full field set the sync writes (star, system, discovery, ESI) with
+  plain-language framing for non-astronomers — richer than the modal, which stays as the quick look.
+- Planets become discoverable: real links (`next/link`) throughout the site plus a sitemap.
+
+## Out of Scope
+- Comparison tool, 3D visualisation, favorites (Future Ideas; comparison builds on this later).
+- Any backend/sync change — this reads existing data only.
+- Retraction/tombstone handling for removed planets (#40's lane); a removed planet simply 404s for now.
+- Redesigning the explore modal or changing explore's filter/URL behavior.
+- User-generated content, images of planets (we have no imagery; the page is data + explanation).
+
+## Acceptance Criteria
+- [ ] `/planet/<name>` server-renders a full profile for every planet in the archive; the HTML
+      (not client JS) contains the planet data.
+- [ ] Unknown planet name renders a 404 page with a link to `/explore?q=<name>` prefilled.
+- [ ] Page shows grouped sections — Planet (radius, mass, density, temperature, insolation, orbital
+      period, semi-major axis), Star (hostname, spectral class via `starClassOf`, temperature,
+      radius, mass, age), System (distance, star/planet counts), Discovery (year, method, facility)
+      — plus the ESI badge with its band and a plain-language Earth comparison. (`st_logg` is
+      deliberately omitted: log-cgs surface gravity means nothing to a lay reader — an intentional
+      cut, not a gap to fill later.)
+- [ ] Every nullable field degrades to a clear "—"/unknown state; no layout breakage (all fields
+      except `pl_name` and `last_updated` can be null).
+- [ ] A provenance line cites NASA Exoplanet Archive and the item's `last_updated`.
+- [ ] `<title>` and meta description are planet-specific; OG/Twitter tags produce a stat-bearing
+      link preview.
+- [ ] Planet names in `PlanetTable`, `PlanetCard`, `PlanetModal`, and `LatestDiscoveries` link to
+      the planet page via `next/link` (renders a real `<a>` — middle-click and copy-link work).
+      In the table, the modal keeps a keyboard-reachable entry point via a separate quick-look
+      control (decision 5); mouse row-click still opens the modal. The modal gains a "View full
+      profile" link.
+- [ ] `sitemap.xml` lists every planet page and revalidates on the same cadence as the archive cache.
+- [ ] Page is keyboard/screen-reader accessible: one `<h1>` (planet name), hierarchical headings,
+      stats readable as label/value pairs.
+
+## Technical Approach
+Frontend only (Next.js App Router). Five decisions matter:
+
+**1. URL is the exact `pl_name`, URI-encoded.** `/planet/Kepler-452%20b` (browsers display the
+decoded form). One helper pair in a new module owns the mapping: `planetUrl(pl_name)` builds every
+internal link and the route decodes `params.name` back — no other file encodes or decodes, so
+internal links can never miss. *Alternative: pretty slugs (`kepler-452-b`) — rejected because
+DynamoDB is keyed by exact `pl_name`, so slugs need a stored slug attribute, a sync-Lambda change,
+a backfill, and a collision policy ("Kepler-452b" vs "Kepler-452 b"), all for cosmetics. Exact
+names keep lookup a single GetItem and the URL unambiguous.*
+
+**2. The page reads DynamoDB directly from the server component.** New `lib/planetDetail.ts`
+(`import 'server-only'`) does a GetItem by `pl_name` and returns the full `Planet` item or `null` —
+same pattern as `lib/latestDiscoveries.ts`. *Alternative: an `/api/planets/[name]` route the page
+fetches — rejected as a pass-through layer with exactly one consumer; RSCs exist to skip it.* The
+existing `/api/planets` summary projection is untouched; the page is the one place the full item
+surfaces, so `PLANET_SUMMARY_FIELDS` doesn't grow.
+
+**3. Dynamic rendering with ISR, not prebuilt pages.** `export const revalidate = 3600` on the
+route segment — first hit renders and caches on Vercel, matching `/api/planets`' 1h CDN policy
+against the ~6h sync. *Alternative: `generateStaticParams` prebuilding ~6,000 pages — rejected:
+it puts a full table Scan in every build, bloats build time, and pages go stale until redeploy.*
+The sitemap (task 5) is the one full-table read that remains, and that's deliberate: one paginated
+Scan per revalidate window — the same cadence `/api/planets` already scans hourly — with a
+projection limited to `pl_name` and `last_updated`, never full items. "Paginated" is load-bearing:
+follow `scanAllPlanets()`'s `LastEvaluatedKey` loop rather than a single `ScanCommand`, which
+truncates at 1MB and would silently drop planets as the archive grows. Cheap and periodic, unlike
+the per-build Scan-plus-6,000-renders that made prebuilding a bad deal.
+
+**4. Misses are defined out of existence internally, handled once externally.** Internal links are
+generated from archive rows via `planetUrl`, so they always resolve while the planet exists. Only
+external/stale URLs can miss: `getPlanetDetail` returning `null` triggers `notFound()`, and one
+`not-found.tsx` offers the explore-search escape hatch. (When #40 lands tombstones, this same
+boundary is where a "retracted" notice would slot in — nothing else changes.)
+
+**5. The table row gets two controls; the pattern spreads nowhere else.** In `PlanetTable` today
+the name `<button>` is the *only* keyboard-reachable way to open the modal — the `<tr>` click
+handler is deliberately mouse-only. So the name becomes a `next/link` to the planet page (stopping
+propagation so a mouse click on it navigates without also firing the row's modal handler), and each
+row gains one explicit quick-look button (accessible label "Quick view: <name>") that opens the
+modal. The button lives inside the existing name `<td>` alongside the link — not a new column,
+which would force a matching `<th>` and widen the table for one icon-sized control. Keyboard users keep their modal entry point and gain a navigation one; mouse row-click still
+opens the modal. *Alternative: leave the name as the modal button and reach the page only through
+the modal's "View full profile" link — rejected: the table is the densest planet listing on the
+site, and the middle-click/copy-link promise dies exactly there.* `PlanetCard` (plain `<h3>` with
+a separate "Learn More" button) and `LatestDiscoveries` (bare `<h3>`) have no such conflict — their
+names simply become links, and the two-control pattern must not spread to them.
+
+Metadata via `generateMetadata` reusing the same fetch (deduped by React `cache()`). A per-planet
+OG *image* (`opengraph-image.tsx` + `ImageResponse` rendering name/stats on brand background) is a
+separate final task — links preview usefully from text metadata alone, so it can ship later without
+blocking. Reuse `getESIBand`, `starClassOf`, and existing formatting conventions; no new band logic.
+
+Risk: none of this touches explore state; the only shared surface is link markup inside
+card/table/modal, and decision 5 pins exactly how the table preserves the modal's keyboard and
+click flows that #41 just shipped.
+
+## Task Breakdown
+1. `lib/planetDetail.ts` (server-only GetItem returning full `Planet` | null) + `planetUrl()`/param
+   decode helper, with tests (size: S)
+2. `/planet/[name]` route: page layout with grouped sections, ESI + star-class reuse, plain-language
+   Earth comparison, provenance line, null-field handling, `not-found.tsx` (size: L)
+3. `generateMetadata`: planet-specific title, description, OG/Twitter tags, shared cached fetch (size: S)
+4. Link-up: `next/link` names in `PlanetCard`, `PlanetModal` ("View full profile"), and
+   `LatestDiscoveries`; in `PlanetTable`, name→link plus the new quick-look modal control per
+   decision 5 (size: M)
+5. `app/sitemap.ts`: one paginated runtime Scan (`LastEvaluatedKey` loop per `scanAllPlanets()`)
+   projected to `pl_name`/`last_updated` only, `revalidate` aligned with data cadence (size: S)
+6. Per-planet OG image via `opengraph-image.tsx`/`ImageResponse` (size: M — can trail the rest)
diff --git a/ROADMAP.md b/ROADMAP.md
index 212b221..9528831 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -1,6 +1,14 @@
 # Roadmap
 
-## Current Focus
+## Direction
+
+ExoplanetHub is an archive first: a complete, queryable, shareable view of NASA's confirmed
+exoplanets. What the site presents as new is derived from the scheduled sync's diff against the
+archive, never hand-written. Today that is the latest-confirmations feed; retractions and records
+broken follow from the same diff. There is no blog and no editorial pipeline; if the data does not
+say it, the site does not claim it.
+
+## Shipped
 
 ### 1. Earth-Similarity Index (ESI) Badge & Sorting
 Add visual indicators and sorting for planets most similar to Earth based on radius, density, and temperature.
@@ -20,14 +28,27 @@ Highlight recently confirmed exoplanets on the homepage.
 - Add to homepage with last 10 discoveries
 - Include discovery method and date
 
-### 3. Improve Advanced Filters
-Enhance filtering capabilities for power users.
+### 3. Explore Filters
+Narrow the archive by name, size, orbit and star type, and keep the result in the address bar so any
+view can be shared, bookmarked and reloaded unchanged.
 
 **Tasks:**
-- Add range sliders for mass, radius, orbital period
+- Search by planet or host name
+- Range filters for radius, mass and orbital period
 - Multi-select for discovery methods
-- Filter by stellar type
-- Persist filter state in URL params
+- Filter by star type
+- Persist all filter and sort state in URL params
+
+### 4. Shareable Planet Pages
+Give every confirmed planet a permanent, server-rendered address that reads clearly to a
+non-astronomer and unfurls with a real preview wherever the link is shared.
+
+**Tasks:**
+- Server-rendered `/planet/<name>` with grouped planet, star, system and discovery sections
+- Plain-language Earth comparison alongside the ESI badge
+- Per-planet titles, descriptions and link-preview images
+- Link planet names from the table, cards, modal and Latest Discoveries
+- Sitemap and robots entries so the pages are indexable
 
 ## Future Ideas
 
diff --git a/aws-backend/README.md b/aws-backend/README.md
index 25aa1b6..00cfd7c 100644
--- a/aws-backend/README.md
+++ b/aws-backend/README.md
@@ -1,5 +1,17 @@
 # AWS Backend
 
+## Data Sync
+
+The sync Lambda upserts every record the NASA archive returns, then deletes stored records the
+archive no longer lists, so the table converges to the archive's count unless the guard trips. The
+sweep refuses to delete more than 5% of the table in one run — a truncated fetch aborts it with an
+error log and leaves the drift in place rather than emptying the table, and the upserts still stand.
+
+The invocation result reports `total_synced`, `removals_submitted` and `sweep_aborted`; every
+removed `pl_name` is logged individually. `removals_submitted` counts what was handed to DynamoDB:
+exact when `sweep_aborted` is false, an upper bound when it is true, because a batch can commit and
+still fail. A run that aborts mid-sweep is safe to retry — deletions are idempotent.
+
 ## Local Deployment
 
 ```bash
diff --git a/aws-backend/lambda/sync/app.py b/aws-backend/lambda/sync/app.py
index ccb85e7..348f5b1 100644
--- a/aws-backend/lambda/sync/app.py
+++ b/aws-backend/lambda/sync/app.py
@@ -1,10 +1,14 @@
 import json
+import logging
 import os
 import urllib.request
 import boto3
 from decimal import Decimal
 from datetime import datetime
 from esi import compute_esi
+from sweep import sweep_removed
+
+logging.getLogger('sweep').setLevel(logging.INFO)
 
 dynamodb = boto3.resource('dynamodb')
 table = dynamodb.Table(os.environ['TABLE_NAME'])
@@ -16,7 +20,8 @@ def lambda_handler(event, context):
         data = json.loads(response.read())
     
     timestamp = datetime.utcnow().isoformat()
-    
+    archive_names = {planet['pl_name'] for planet in data}
+
     with table.batch_writer() as batch:
         for planet in data:
             item = {
@@ -48,11 +53,15 @@ def lambda_handler(event, context):
                 item['esi'] = score
 
             batch.put_item(Item=item)
-    
+
+    sweep = sweep_removed(table, archive_names)
+
     return {
         'statusCode': 200,
         'body': json.dumps({
-            'total_synced': len(data)
+            'total_synced': len(data),
+            'removals_submitted': len(sweep.submitted),
+            'sweep_aborted': sweep.aborted
         })
     }
 
diff --git a/aws-backend/lambda/sync/sweep.py b/aws-backend/lambda/sync/sweep.py
new file mode 100644
index 0000000..8f9835c
--- /dev/null
+++ b/aws-backend/lambda/sync/sweep.py
@@ -0,0 +1,66 @@
+import logging
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+# A truncated archive fetch would otherwise sweep the table; no real run drops this much at once.
+MAXIMUM_DELETION_FRACTION = 0.05
+
+
+# `submitted` is what was handed to DynamoDB: exact when `aborted` is False, an upper bound when True.
+@dataclass(frozen=True)
+class SweepResult:
+    submitted: tuple[str, ...]
+    aborted: bool
+
+
+# Never raises: the ingest has already committed and must still report success.
+def sweep_removed(table, archive_names):
+    try:
+        return _delete_missing_from(table, archive_names)
+    except Exception:
+        logger.exception('sweep aborted: removal pass failed against %d archive records', len(archive_names))
+        return SweepResult(submitted=(), aborted=True)
+
+
+def _delete_missing_from(table, archive_names):
+    stored_names = _scan_names(table)
+    stale = sorted(stored_names - archive_names)
+
+    if len(stale) > MAXIMUM_DELETION_FRACTION * len(stored_names):
+        logger.error(
+            'sweep aborted: %d of %d stored records are absent from the archive, above the %.0f%% ceiling',
+            len(stale),
+            len(stored_names),
+            100 * MAXIMUM_DELETION_FRACTION,
+        )
+        return SweepResult(submitted=(), aborted=True)
+
+    return _submit_deletions(table, stale)
+
+
+def _submit_deletions(table, stale):
+    submitted = []
+    try:
+        with table.batch_writer() as batch:
+            for name in stale:
+                logger.info('removing %s: no longer listed in the NASA archive', name)
+                # Counted before the call: a buffered item can commit in the very flush that raises.
+                submitted.append(name)
+                batch.delete_item(Key={'pl_name': name})
+    except Exception:
+        logger.exception('sweep incomplete: %d of %d removals submitted', len(submitted), len(stale))
+        return SweepResult(submitted=tuple(submitted), aborted=True)
+
+    return SweepResult(submitted=tuple(submitted), aborted=False)
+
+
+def _scan_names(table):
+    request = {'ProjectionExpression': 'pl_name'}
+    names = set()
+    while True:
+        page = table.scan(**request)
+        names.update(item['pl_name'] for item in page['Items'])
+        if not page.get('LastEvaluatedKey'):
+            return names
+        request['ExclusiveStartKey'] = page['LastEvaluatedKey']
diff --git a/aws-backend/tests/test_sweep.py b/aws-backend/tests/test_sweep.py
new file mode 100644
index 0000000..272e668
--- /dev/null
+++ b/aws-backend/tests/test_sweep.py
@@ -0,0 +1,213 @@
+import logging
+
+import pytest
+
+from sweep import MAXIMUM_DELETION_FRACTION, sweep_removed
+
+# Wide enough that a couple of stale records stay under the deletion ceiling.
+ARCHIVE = {'Kepler-22 b', 'TRAPPIST-1e', 'Proxima Cen b'} | {f'Filler {index}' for index in range(97)}
+
+FLUSH_SIZE = 25  # boto3 BatchWriter's default flush_amount
+
+# 60 stale records span three flushes and stay under 5% of the 1260 stored.
+SPANNING_STALE = {f'Retracted {index}' for index in range(60)}
+SPANNING_SURVIVORS = {f'Planet {index}' for index in range(1200)}
+
+
+# Mirrors boto3's BatchWriter: buffer, flush every 25, and flush the remainder on exit.
+class FakeBatchWriter:
+    def __init__(self, table):
+        self.table = table
+        self.buffer = []
+
+    def delete_item(self, Key):
+        self.table.handed.append(Key['pl_name'])
+        self.buffer.append(Key['pl_name'])
+        if len(self.buffer) >= FLUSH_SIZE:
+            self._flush()
+
+    def _flush(self):
+        sending, self.buffer = self.buffer[:FLUSH_SIZE], self.buffer[FLUSH_SIZE:]
+        self.table.flushes += 1
+        failing = self.table.flushes == self.table.failing_flush
+        if not failing or self.table.failing_flush_commits:
+            self.table.committed.extend(sending)
+        if failing:
+            raise RuntimeError('throttled')
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exception):
+        while self.buffer:
+            self._flush()
+
+
+class FakeTable:
+    def __init__(self, stored_names, page_size=1000, scan_error=None, failing_flush=None, failing_flush_commits=False):
+        self.stored_names = list(stored_names)
+        self.page_size = page_size
+        self.scan_error = scan_error
+        self.failing_flush = failing_flush
+        self.failing_flush_commits = failing_flush_commits
+        self.committed = []
+        self.handed = []
+        self.flushes = 0
+        self.scan_requests = []
+
+    def scan(self, **request):
+        if self.scan_error:
+            raise self.scan_error
+        self.scan_requests.append(request)
+        start = self.stored_names.index(request['ExclusiveStartKey']['pl_name']) + 1 if 'ExclusiveStartKey' in request else 0
+        page = self.stored_names[start:start + self.page_size]
+        response = {'Items': [{'pl_name': name} for name in page]}
+        if start + self.page_size < len(self.stored_names):
+            response['LastEvaluatedKey'] = {'pl_name': page[-1]}
+        return response
+
+    def batch_writer(self):
+        return FakeBatchWriter(self)
+
+
+def test_deletes_only_records_absent_from_the_archive():
+    table = FakeTable(ARCHIVE | {'Retracted b', 'Renamed c'})
+
+    result = sweep_removed(table, ARCHIVE)
+
+    assert set(result.submitted) == {'Retracted b', 'Renamed c'}
+    assert sorted(table.committed) == ['Renamed c', 'Retracted b']
+    assert result.aborted is False
+
+
+def test_deletes_nothing_when_the_table_matches_the_archive():
+    table = FakeTable(ARCHIVE)
+
+    result = sweep_removed(table, ARCHIVE)
+
+    assert result.submitted == ()
+    assert table.committed == []
+    assert result.aborted is False
+
+
+def test_ignores_archive_records_the_table_has_not_stored_yet():
+    table = FakeTable({'Kepler-22 b'})
+
+    result = sweep_removed(table, ARCHIVE)
+
+    assert result.submitted == ()
+    assert result.aborted is False
+
+
+def test_scan_pages_until_the_table_is_exhausted():
+    stored = [f'Planet {index}' for index in range(250)]
+    table = FakeTable(stored + ['Retracted b'], page_size=100)
+
+    result = sweep_removed(table, set(stored))
+
+    assert result.submitted == ('Retracted b',)
+    assert len(table.scan_requests) == 3
+    assert 'ExclusiveStartKey' not in table.scan_requests[0]
+
+
+def test_reports_every_removal_when_deletions_span_several_flushes():
+    table = FakeTable(SPANNING_SURVIVORS | SPANNING_STALE)
+
+    result = sweep_removed(table, SPANNING_SURVIVORS)
+
+    assert result.aborted is False
+    assert set(result.submitted) == SPANNING_STALE
+    assert set(table.committed) == SPANNING_STALE
+
+
+def test_partial_flush_failure_reports_the_records_it_may_have_committed(caplog):
+    table = FakeTable(SPANNING_SURVIVORS | SPANNING_STALE, failing_flush=2, failing_flush_commits=True)
+
+    with caplog.at_level(logging.ERROR, logger='sweep'):
+        result = sweep_removed(table, SPANNING_SURVIVORS)
+
+    assert result.aborted is True
+    assert len(table.committed) == 2 * FLUSH_SIZE
+    assert set(result.submitted) == set(table.handed)
+    assert set(table.committed) <= set(result.submitted) <= SPANNING_STALE
+    assert 'sweep incomplete' in caplog.text
+
+
+def test_flush_failure_before_anything_commits_still_bounds_the_damage():
+    table = FakeTable(ARCHIVE | {'Retracted b', 'Renamed c'}, failing_flush=1)
+
+    result = sweep_removed(table, ARCHIVE)
+
+    assert result.aborted is True
+    assert table.committed == []
+    assert set(result.submitted) == {'Retracted b', 'Renamed c'}
+
+
+# 1 of 20 stored records is exactly the 5% ceiling; 2 of 20 is over it.
+@pytest.mark.parametrize(
+    'stale_count, expected_aborted',
+    [(1, False), (2, True)],
+    ids=['at-the-ceiling', 'over-the-ceiling'],
+)
+def test_ceiling_bounds_how_much_one_sweep_may_delete(stale_count, expected_aborted):
+    assert MAXIMUM_DELETION_FRACTION == 0.05, 'the counts below are hand-computed against a 5% ceiling'
+
+    survivors = {f'Planet {index}' for index in range(20 - stale_count)}
+    stale = {f'Retracted {index}' for index in range(stale_count)}
+    table = FakeTable(survivors | stale)
+
+    result = sweep_removed(table, survivors)
+
+    assert result.aborted is expected_aborted
+    assert table.committed == ([] if expected_aborted else list(stale))
+
+
+def test_truncated_archive_fetch_aborts_instead_of_emptying_the_table():
+    table = FakeTable(ARCHIVE)
+
+    result = sweep_removed(table, set())
+
+    assert result.aborted is True
+    assert result.submitted == ()
+    assert table.committed == []
+
+
+def test_empty_table_is_not_a_division_by_zero():
+    table = FakeTable([])
+
+    result = sweep_removed(table, ARCHIVE)
+
+    assert result.submitted == ()
+    assert result.aborted is False
+
+
+def test_scan_failure_aborts_the_sweep_without_raising(caplog):
+    table = FakeTable(ARCHIVE | {'Retracted b'}, scan_error=RuntimeError('throttled'))
+
+    with caplog.at_level(logging.ERROR, logger='sweep'):
+        result = sweep_removed(table, ARCHIVE)
+
+    assert result.aborted is True
+    assert result.submitted == ()
+    assert table.committed == []
+    assert 'sweep aborted' in caplog.text
+
+
+def test_logs_every_deleted_name(caplog):
+    table = FakeTable(ARCHIVE | {'Retracted b', 'Renamed c'})
+
+    with caplog.at_level(logging.INFO, logger='sweep'):
+        sweep_removed(table, ARCHIVE)
+
+    logged = '\n'.join(record.getMessage() for record in caplog.records)
+    assert 'Retracted b' in logged
+    assert 'Renamed c' in logged
+
+
+def test_logs_an_error_when_the_ceiling_aborts_the_sweep(caplog):
+    table = FakeTable(ARCHIVE)
+
+    with caplog.at_level(logging.INFO, logger='sweep'):
+        sweep_removed(table, set())
+
+    assert [record.levelno for record in caplog.records] == [logging.ERROR]
diff --git a/exoplanethub.com/app/api/planets/route.test.ts b/exoplanethub.com/app/api/planets/route.test.ts
index 9d0a45d..4279649 100644
--- a/exoplanethub.com/app/api/planets/route.test.ts
+++ b/exoplanethub.com/app/api/planets/route.test.ts
@@ -78,13 +78,17 @@ describe('GET /api/planets', () => {
 });
 
 describe('GET /api/planets projection', () => {
-  it('projects esi so the badge has a score to render', async () => {
+  it.each([
+    ['esi', 'the badge has a score to render'],
+    ['pl_orbper', 'the orbital period range filter has a value to compare'],
+    ['st_teff', 'the star type filter has a temperature to band'],
+  ])('projects %s, so %s', async (field) => {
     send.mockResolvedValue({ Items: [] });
     const GET = await importRouteWithCurrentEnv();
 
     await GET();
 
-    expect(projectedFields(scanInputs()[0])).toContain('esi');
+    expect(projectedFields(scanInputs()[0])).toContain(field);
   });
 
   it('projects exactly the shared summary field list', async () => {
diff --git a/exoplanethub.com/app/api/planets/route.ts b/exoplanethub.com/app/api/planets/route.ts
index b29c874..0bb4a27 100644
--- a/exoplanethub.com/app/api/planets/route.ts
+++ b/exoplanethub.com/app/api/planets/route.ts
@@ -1,41 +1,13 @@
 import { NextResponse } from 'next/server';
-import { ScanCommand, type ScanCommandOutput } from '@aws-sdk/lib-dynamodb';
-import { documentClient, planetsTableName } from '@/lib/dynamo';
-import { PLANET_SUMMARY_FIELDS, type PlanetSummary } from '@/lib/mockPlanets';
-
-// Aliasing every projected name keeps the field list free to grow without hitting a DynamoDB reserved word.
-const expressionAttributeNames = Object.fromEntries(
-  PLANET_SUMMARY_FIELDS.map((field) => [`#${field}`, field])
-);
-const projectionExpression = PLANET_SUMMARY_FIELDS.map((field) => `#${field}`).join(', ');
+import { scanAllPlanets } from '@/lib/dynamo';
+import { PLANET_SUMMARY_FIELDS } from '@/lib/mockPlanets';
 
 // Data changes at most every 6h, so CDN staleness up to an hour is harmless and spares a full Scan per request.
 const CACHE_CONTROL = 'public, s-maxage=3600, stale-while-revalidate=21600';
 
-async function scanAllPlanets(): Promise<PlanetSummary[]> {
-  const planets: PlanetSummary[] = [];
-  let cursor: ScanCommandOutput['LastEvaluatedKey'];
-
-  do {
-    const page: ScanCommandOutput = await documentClient.send(
-      new ScanCommand({
-        TableName: planetsTableName,
-        ExpressionAttributeNames: expressionAttributeNames,
-        ProjectionExpression: projectionExpression,
-        ExclusiveStartKey: cursor,
-      })
-    );
-
-    planets.push(...((page.Items ?? []) as PlanetSummary[]));
-    cursor = page.LastEvaluatedKey;
-  } while (cursor);
-
-  return planets;
-}
-
 export async function GET() {
   try {
-    return NextResponse.json(await scanAllPlanets(), {
+    return NextResponse.json(await scanAllPlanets(PLANET_SUMMARY_FIELDS), {
       headers: { 'Cache-Control': CACHE_CONTROL },
     });
   } catch (error) {
diff --git a/exoplanethub.com/app/explore/ExploreClient.filters.test.tsx b/exoplanethub.com/app/explore/ExploreClient.filters.test.tsx
new file mode 100644
index 0000000..b803af3
--- /dev/null
+++ b/exoplanethub.com/app/explore/ExploreClient.filters.test.tsx
@@ -0,0 +1,520 @@
+import { act, fireEvent, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  boundInput,
+  cardNames,
+  emptyState,
+  makePlanet,
+  methodBox,
+  rangeGroup,
+  rangeRail,
+  renderExplore,
+  replace,
+  resultsCount,
+  searchBox,
+  showGrid,
+  sortHeader,
+  starBox,
+  startAtUrl,
+  tableNames,
+} from './exploreTestUtils';
+
+describe('ExploreClient filtering', () => {
+  it('filters the table as the visitor types', async () => {
+    const { user } = renderExplore();
+
+    await user.type(searchBox(), 'beta');
+
+    expect(tableNames()).toEqual(['Beta c']);
+  });
+
+  it('filters the grid by the same search, which it used to ignore', async () => {
+    const { user } = renderExplore();
+
+    await user.type(searchBox(), 'wolf');
+    await showGrid(user);
+
+    expect(cardNames()).toEqual(['Gamma d']);
+  });
+
+  it('keeps one search box across both views, so switching view never drops the filter', async () => {
+    const { user } = renderExplore();
+
+    await user.type(searchBox(), 'beta');
+    await showGrid(user);
+
+    expect(searchBox()).toHaveValue('beta');
+    expect(cardNames()).toEqual(['Beta c']);
+  });
+
+  // Whatever the URL asks for is what gets filtered, so the checkboxes have to be able to say so.
+  it('offers a box for a method the data does not contain, checked, rather than hiding it', () => {
+    startAtUrl('method=Astrometry');
+    renderExplore();
+
+    expect(methodBox('Astrometry')).toBeChecked();
+    expect(emptyState()).toBeInTheDocument();
+  });
+
+  it('offers the discovery methods present in the data and applies the chosen one', async () => {
+    const { user } = renderExplore();
+
+    expect(methodBox('Transit')).not.toBeChecked();
+    await user.click(methodBox('Radial Velocity'));
+
+    expect(tableNames()).toEqual(['Beta c']);
+  });
+
+  it('widens rather than narrows the results as more methods are ticked', async () => {
+    const { user } = renderExplore();
+
+    await user.click(methodBox('Radial Velocity'));
+    expect(tableNames()).toEqual(['Beta c']);
+
+    await user.click(methodBox('Transit'));
+    expect(tableNames()).toEqual(['Beta c', 'Alpha b', 'Gamma d']);
+  });
+
+  it('restores every ticked method from a shared URL', () => {
+    startAtUrl('method=Radial%20Velocity,Transit');
+    renderExplore();
+
+    expect(methodBox('Radial Velocity')).toBeChecked();
+    expect(methodBox('Transit')).toBeChecked();
+    expect(tableNames()).toEqual(['Beta c', 'Alpha b', 'Gamma d']);
+  });
+
+  it('drops a method the visitor unticks from the results', async () => {
+    startAtUrl('method=Radial%20Velocity,Transit');
+    const { user } = renderExplore();
+
+    await user.click(methodBox('Transit'));
+
+    expect(tableNames()).toEqual(['Beta c']);
+  });
+});
+
+describe('ExploreClient range filters', () => {
+  it.each([
+    ['radius', 'radius=2..3', ['Alpha b', 'Gamma d']],
+    ['mass', 'mass=..5', ['Beta c', 'Gamma d']],
+    ['orbital period', 'period=1..365', ['Beta c']],
+  ])('filters the table by %s from the URL', (_label, badQuery, expected) => {
+    startAtUrl(badQuery);
+    renderExplore();
+
+    expect(tableNames().sort()).toEqual(expected);
+  });
+
+  it('filters the grid by the same range, so both views agree', async () => {
+    startAtUrl('period=1..365');
+    const { user } = renderExplore();
+
+    await showGrid(user);
+
+    expect(cardNames()).toEqual(['Beta c']);
+  });
+
+  it('shows the bounds from the URL in the number inputs, so a shared link is editable', () => {
+    startAtUrl('radius=0.5..2');
+    renderExplore();
+
+    expect(boundInput(/radius/i, /min/i)).toHaveValue(0.5);
+    expect(boundInput(/radius/i, /max/i)).toHaveValue(2);
+  });
+
+  it('leaves the inputs empty for an end the URL omits', () => {
+    startAtUrl('mass=..10');
+    renderExplore();
+
+    expect(boundInput(/mass/i, /min/i)).toHaveValue(null);
+    expect(boundInput(/mass/i, /max/i)).toHaveValue(10);
+  });
+
+  it('writes a bound the visitor types to the URL', () => {
+    vi.useFakeTimers();
+    renderExplore();
+
+    fireEvent.change(boundInput(/radius/i, /min/i), { target: { value: '2' } });
+    vi.advanceTimersByTime(1000);
+
+    expect(replace).toHaveBeenCalledExactlyOnceWith('/explore?radius=2..', { scroll: false });
+  });
+
+  it('drops the range from the URL again once both bounds are cleared', () => {
+    vi.useFakeTimers();
+    startAtUrl('radius=2..');
+    renderExplore();
+
+    fireEvent.change(boundInput(/radius/i, /min/i), { target: { value: '' } });
+    vi.advanceTimersByTime(1000);
+
+    expect(replace).toHaveBeenLastCalledWith('/explore', { scroll: false });
+  });
+
+  it('keeps the range when Back returns to it, filtering by whatever the URL now says', () => {
+    startAtUrl('radius=2..3');
+    const { navigateTo } = renderExplore();
+    expect(tableNames().sort()).toEqual(['Alpha b', 'Gamma d']);
+
+    navigateTo('radius=..1');
+
+    expect(tableNames()).toEqual(['Beta c']);
+    expect(boundInput(/radius/i, /max/i)).toHaveValue(1);
+  });
+
+  it.each([
+    ['a bound that is not a number', 'radius=small..2'],
+    ['a range with no separator', 'radius=2'],
+    ['an empty range', 'period='],
+  ])('renders the ordinary unfiltered page for %s', (_label, badQuery) => {
+    startAtUrl(badQuery);
+    renderExplore();
+
+    expect(tableNames()).toEqual(['Beta c', 'Alpha b', 'Gamma d']);
+  });
+
+  it('says which planets a live range is hiding, and says nothing while it is inactive', () => {
+    startAtUrl('mass=1..10');
+    const { navigateTo } = renderExplore();
+    expect(rangeGroup(/mass/i).getByText(/without a measured mass are hidden/i)).toBeInTheDocument();
+    expect(rangeGroup(/radius/i).queryByText(/hidden/i)).toBeNull();
+
+    navigateTo('');
+
+    expect(rangeGroup(/mass/i).queryByText(/hidden/i)).toBeNull();
+  });
+
+  it('points the visitor at the note explaining the exclusion from the input that caused it', () => {
+    startAtUrl('mass=1..10');
+    renderExplore();
+
+    const note = rangeGroup(/mass/i).getByText(/without a measured mass are hidden/i);
+
+    expect(boundInput(/mass/i, /min/i)).toHaveAttribute('aria-describedby', note.id);
+  });
+
+  it('offers a slider per bound, spanning the measurements actually present', () => {
+    renderExplore();
+    const sliders = rangeGroup(/orbital period/i).getAllByRole('slider');
+
+    expect(sliders).toHaveLength(2);
+    expect(rangeGroup(/orbital period/i).getByRole('spinbutton', { name: /min/i })).toHaveAttribute(
+      'placeholder',
+      '0.5'
+    );
+    expect(rangeGroup(/orbital period/i).getByRole('spinbutton', { name: /max/i })).toHaveAttribute(
+      'placeholder',
+      '1000'
+    );
+  });
+
+  it('drops the slider but keeps the number inputs when nothing was measured', () => {
+    renderExplore([makePlanet({ pl_name: 'Blank', pl_bmasse: null })]);
+
+    expect(rangeGroup(/mass/i).queryAllByRole('slider')).toEqual([]);
+    expect(rangeGroup(/mass/i).getByRole('spinbutton', { name: /min/i })).toBeInTheDocument();
+  });
+
+  it('moves the filter when a slider moves, so keyboard use of the track really filters', () => {
+    startAtUrl('radius=1..3');
+    renderExplore();
+    const [lower] = rangeGroup(/radius/i).getAllByRole('slider');
+
+    fireEvent.change(lower, { target: { value: '1000' } });
+
+    expect(tableNames()).toEqual(['Alpha b']);
+  });
+
+  it('parks a dragged thumb at its neighbour rather than letting the bounds cross', () => {
+    startAtUrl('radius=1..2');
+    renderExplore();
+
+    fireEvent.change(rangeGroup(/radius/i).getAllByRole('slider')[0], { target: { value: '1000' } });
+
+    expect(boundInput(/radius/i, /min/i)).toHaveValue(2);
+    expect(boundInput(/radius/i, /max/i)).toHaveValue(2);
+  });
+
+  it('announces each thumb as a measurement, not as a position on the log track', () => {
+    startAtUrl('period=10..');
+    renderExplore();
+    const [lower, upper] = rangeGroup(/orbital period/i).getAllByRole('slider');
+
+    expect(lower.getAttribute('value')).not.toBe('10');
+    expect(lower).toHaveAttribute('aria-valuetext', '10 days');
+    expect(upper).toHaveAttribute('aria-valuetext', '1000 days');
+
+    fireEvent.change(lower, { target: { value: '0' } });
+
+    expect(rangeGroup(/orbital period/i).getAllByRole('slider')[0]).toHaveAttribute(
+      'aria-valuetext',
+      '0.5 days'
+    );
+  });
+
+  // A range input with min === max paints its thumb at the left end whatever its value, which
+  // drew "radius at least 3" as the entire track selected.
+  it.each(['radius=3..3', 'radius=1..1'])(
+    'never collapses a thumb with both bounds on one measurement (%s)',
+    (range) => {
+      startAtUrl(range);
+      renderExplore();
+
+      for (const thumb of rangeGroup(/radius/i).getAllByRole('slider')) {
+        expect(thumb.getAttribute('min')).not.toBe(thumb.getAttribute('max'));
+      }
+    }
+  );
+
+  it('raises the lower thumb where they stack, so the pointer reaches the one that can move', () => {
+    startAtUrl('radius=3..');
+    renderExplore();
+    const [lower, upper] = rangeGroup(/radius/i).getAllByRole('slider');
+
+    expect(lower.getAttribute('value')).toBe(upper.getAttribute('value'));
+    expect(lower.style.zIndex).toBe('1');
+  });
+
+  it('leaves the thumbs in document order while they sit apart', () => {
+    startAtUrl('radius=1..3');
+    renderExplore();
+
+    expect(rangeGroup(/radius/i).getAllByRole('slider')[0].style.zIndex).toBe('');
+  });
+
+  it('drops the thumbs when the bounds cross, rather than drawing the range they swap into', () => {
+    startAtUrl('radius=3..1');
+    renderExplore();
+
+    expect(rangeGroup(/radius/i).queryAllByRole('slider')).toEqual([]);
+    expect(boundInput(/radius/i, /min/i)).toHaveValue(3);
+    expect(boundInput(/radius/i, /max/i)).toHaveValue(1);
+  });
+
+  // Typing a max crosses the bounds on the first keystroke for most entries, so an unmounted rail
+  // would jerk the card and everything under it on nearly every edit.
+  it('keeps the rail through a crossing, so the card holds its height while a bound is typed', () => {
+    startAtUrl('radius=1..');
+    const { navigateTo } = renderExplore();
+    expect(rangeRail(/radius/i)).toBeInTheDocument();
+
+    navigateTo('radius=3..1');
+
+    expect(rangeRail(/radius/i)).toBeInTheDocument();
+  });
+
+  // Narrowed to 100 planets, so page 2 still exists and only an explicit reset can move off it.
+  it('returns to the first page when a range narrows the results under a later page', async () => {
+    const many = Array.from({ length: 120 }, (_, i) =>
+      makePlanet({ pl_name: `Planet ${String(i).padStart(3, '0')}`, pl_rade: i + 1 })
+    );
+    const { user } = renderExplore(many);
+    await user.click(screen.getByRole('button', { name: /next/i }));
+    expect(screen.getByText(/page 2 of 3/i)).toBeInTheDocument();
+
+    fireEvent.change(boundInput(/radius/i, /max/i), { target: { value: '100' } });
+
+    expect(screen.getByText(/page 1 of 2/i)).toBeInTheDocument();
+    expect(resultsCount()).toHaveTextContent('100 of 120 planets');
+  });
+});
+
+describe('ExploreClient star type filter', () => {
+  const SUNLIKE = makePlanet({ pl_name: 'Sunlike b', st_teff: 5800 });
+  const RED = makePlanet({ pl_name: 'Red c', st_teff: 3000 });
+  const BLUE = makePlanet({ pl_name: 'Blue d', st_teff: 12000 });
+  const BROWN = makePlanet({ pl_name: 'Brown e', st_teff: 1200 });
+  const UNMEASURED = makePlanet({ pl_name: 'Unmeasured f', st_teff: null });
+  const STARS = [SUNLIKE, RED, BLUE, BROWN, UNMEASURED];
+
+  it('filters the table by the class the URL names', () => {
+    startAtUrl('star=G');
+    renderExplore(STARS);
+
+    expect(tableNames()).toEqual(['Sunlike b']);
+  });
+
+  it('filters the grid by the same class, so both views agree', async () => {
+    startAtUrl('star=M');
+    const { user } = renderExplore(STARS);
+
+    await showGrid(user);
+
+    expect(cardNames()).toEqual(['Red c']);
+  });
+
+  it('widens rather than narrows the results as more classes are ticked', async () => {
+    const { user } = renderExplore(STARS);
+
+    await user.click(starBox(/sun-like/i));
+    expect(tableNames()).toEqual(['Sunlike b']);
+
+    await user.click(starBox(/red dwarf/i));
+    expect(tableNames()).toEqual(['Sunlike b', 'Red c']);
+  });
+
+  it.each([
+    ['a host cooler than the M band', 'Brown e'],
+    ['a host the archive never measured', 'Unmeasured f'],
+  ])('hides %s while a class is chosen, and says so', (_label, hidden) => {
+    startAtUrl('star=G,M');
+    renderExplore(STARS);
+
+    expect(tableNames()).not.toContain(hidden);
+    expect(screen.getByText(/unclassified/i)).toBeInTheDocument();
+  });
+
+  it('shows the unclassified planets again once the filter is off', () => {
+    const { navigateTo } = renderExplore(STARS);
+    expect(tableNames()).toHaveLength(STARS.length);
+
+    navigateTo('star=G');
+    expect(tableNames()).toEqual(['Sunlike b']);
+
+    navigateTo('');
+    expect(tableNames()).toHaveLength(STARS.length);
+    expect(screen.queryByText(/unclassified/i)).toBeNull();
+  });
+
+  it('restores every ticked class from a shared URL', () => {
+    startAtUrl('star=B,M');
+    renderExplore(STARS);
+
+    expect(starBox(/blue-white/i)).toBeChecked();
+    expect(starBox(/red dwarf/i)).toBeChecked();
+    expect(starBox(/sun-like/i)).not.toBeChecked();
+    expect(tableNames()).toEqual(['Red c', 'Blue d']);
+  });
+
+  it('writes every ticked class to one comma-separated param, hottest first', () => {
+    vi.useFakeTimers();
+    renderExplore(STARS);
+
+    fireEvent.click(starBox(/red dwarf/i));
+    vi.advanceTimersByTime(1000);
+    expect(replace).toHaveBeenLastCalledWith('/explore?star=M', { scroll: false });
+
+    fireEvent.click(starBox(/blue-white/i));
+    vi.advanceTimersByTime(1000);
+    expect(replace).toHaveBeenLastCalledWith('/explore?star=B%2CM', { scroll: false });
+
+    fireEvent.click(starBox(/red dwarf/i));
+    vi.advanceTimersByTime(1000);
+    expect(replace).toHaveBeenLastCalledWith('/explore?star=B', { scroll: false });
+  });
+
+  it.each([
+    ['a class that does not exist', 'star=Q'],
+    ['a spectral subtype', 'star=G2V'],
+    ['nothing but separators', 'star=,,'],
+    ['an empty value', 'star='],
+  ])('renders the ordinary unfiltered page for %s', (_label, badQuery) => {
+    startAtUrl(badQuery);
+    renderExplore(STARS);
+
+    expect(tableNames()).toHaveLength(STARS.length);
+    expect(emptyState()).toBeNull();
+  });
+
+  it('returns to the first page when the star filter narrows the results under a later page', async () => {
+    const many = Array.from({ length: 120 }, (_, i) =>
+      makePlanet({ pl_name: `Planet ${String(i).padStart(3, '0')}`, st_teff: i < 100 ? 5800 : 3000 })
+    );
+    const { user } = renderExplore(many);
+    await user.click(screen.getByRole('button', { name: /next/i }));
+    expect(screen.getByText(/page 2 of 3/i)).toBeInTheDocument();
+
+    await user.click(starBox(/sun-like/i));
+
+    expect(screen.getByText(/page 1 of 2/i)).toBeInTheDocument();
+    expect(resultsCount()).toHaveTextContent('100 of 120 planets');
+  });
+});
+
+describe('ExploreClient empty results', () => {
+  it.each([
+    ['a search that matches nothing', 'q=no such planet'],
+    ['a range that crosses', 'radius=3..1'],
+    ['a star class no host falls in', 'star=O'],
+  ])('offers a way out of the empty page left by %s', (_label, badQuery) => {
+    startAtUrl(badQuery);
+    renderExplore();
+
+    expect(emptyState()).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /clear all filters/i })).toBeInTheDocument();
+    expect(screen.queryByRole('table')).toBeNull();
+  });
+
+  it('reaches the grid as well as the table', async () => {
+    startAtUrl('q=no such planet');
+    const { user } = renderExplore();
+
+    await showGrid(user);
+
+    expect(emptyState()).toBeInTheDocument();
+    expect(screen.queryAllByRole('heading', { level: 3 })).toEqual([]);
+  });
+
+  // Nothing is hidden, so offering to clear filters would be a lie.
+  it('does not offer to clear filters when the archive itself came back empty', () => {
+    renderExplore([]);
+
+    expect(screen.getByText(/no planets to show/i)).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: /clear all filters/i })).toBeNull();
+    expect(resultsCount()).toHaveTextContent('0 of 0 planets');
+  });
+});
+
+describe('ExploreClient clear all', () => {
+  const EVERYTHING = 'q=beta&method=Transit&star=G&radius=0.5..2&sort=pl_rade.asc';
+
+  it('puts every filter back and strips them from the query string', () => {
+    vi.useFakeTimers();
+    startAtUrl(EVERYTHING);
+    renderExplore();
+
+    fireEvent.click(screen.getByRole('button', { name: 'Clear all' }));
+    act(() => vi.advanceTimersByTime(1000));
+
+    expect(replace).toHaveBeenLastCalledWith('/explore?sort=pl_rade.asc', { scroll: false });
+    expect(searchBox()).toHaveValue('');
+    expect(methodBox('Transit')).not.toBeChecked();
+    expect(starBox(/sun-like/i)).not.toBeChecked();
+    expect(boundInput(/radius/i, /min/i)).toHaveValue(null);
+  });
+
+  // `Clear all` stays disabled under a sort alone, so it must not quietly throw one away either.
+  it('leaves the chosen sort standing, since sort is not one of the filters it clears', () => {
+    startAtUrl('q=beta&sort=pl_rade.asc');
+    renderExplore();
+    expect(tableNames()).toEqual(['Beta c']);
+
+    fireEvent.click(screen.getByRole('button', { name: 'Clear all' }));
+
+    expect(tableNames()).toEqual(['Beta c', 'Gamma d', 'Alpha b']);
+    expect(sortHeader(/radius/i)).toHaveTextContent('▲');
+  });
+
+  it('is offered only once something is actually filtered', () => {
+    const { navigateTo } = renderExplore();
+    expect(screen.getByRole('button', { name: 'Clear all' })).toBeDisabled();
+
+    navigateTo('star=G');
+
+    expect(screen.getByRole('button', { name: 'Clear all' })).toBeEnabled();
+  });
+
+  // Both clear buttons stop being focusable the moment they work, so focus needs a real home.
+  it.each([
+    ['the filter control', 'Clear all'],
+    ['the empty state', 'Clear all filters'],
+  ])('moves focus to the search box after clearing from %s', async (_label, name) => {
+    startAtUrl('q=no such planet');
+    const { user } = renderExplore();
+
+    await user.click(screen.getByRole('button', { name }));
+
+    expect(searchBox()).toHaveFocus();
+  });
+});
diff --git a/exoplanethub.com/app/explore/ExploreClient.tsx b/exoplanethub.com/app/explore/ExploreClient.tsx
index 3c1d961..d23e1c9 100644
--- a/exoplanethub.com/app/explore/ExploreClient.tsx
+++ b/exoplanethub.com/app/explore/ExploreClient.tsx
@@ -1,16 +1,50 @@
 'use client';
-import { useState } from 'react';
-import PlanetCard from '@/components/explore/PlanetCard';
-import PlanetTable from '@/components/explore/PlanetTable';
+import { useMemo, useRef, useState } from 'react';
+import FilterControls from '@/components/explore/FilterControls';
+import NoResults from '@/components/explore/NoResults';
+import PlanetGrid from '@/components/explore/PlanetGrid';
 import PlanetModal from '@/components/explore/PlanetModal';
+import PlanetTable from '@/components/explore/PlanetTable';
+import ResultsCount from '@/components/explore/ResultsCount';
 import { PlanetSummary } from '@/lib/mockPlanets';
+import {
+  FilterState,
+  SortKey,
+  applyFilters,
+  cleared,
+  isFiltered,
+  sortPlanets,
+  withSort,
+} from '@/lib/planetFilters';
+import { useFilterParams } from '@/lib/useFilterParams';
+import { usePagination } from '@/lib/usePagination';
 import styles from './page.module.css';
 
+const ITEMS_PER_PAGE = 50;
+
 export default function ExploreClient({ planets }: { planets: PlanetSummary[] }) {
   const [selectedPlanet, setSelectedPlanet] = useState<PlanetSummary | null>(null);
   const [view, setView] = useState<'grid' | 'table'>('table');
-  const [page, setPage] = useState(1);
-  const itemsPerPage = 50;
+  const [filters, setFilters] = useFilterParams();
+  const searchRef = useRef<HTMLInputElement>(null);
+
+  const visible = useMemo(
+    () => sortPlanets(applyFilters(planets, filters), filters),
+    [planets, filters],
+  );
+  const pagination = usePagination(visible.length, ITEMS_PER_PAGE);
+
+  const changeFilters = (next: FilterState) => {
+    setFilters(next);
+    pagination.goTo(1);
+  };
+
+  // Every control that clears is gone or disabled the instant it works, so focus needs somewhere
+  // real to land; the search box is both still present and the likeliest next move.
+  const clearFilters = () => {
+    changeFilters(cleared(filters));
+    searchRef.current?.focus();
+  };
 
   return (
     <main className={styles.page}>
@@ -23,61 +57,50 @@ export default function ExploreClient({ planets }: { planets: PlanetSummary[] })
           <button 
             className={`${styles.toggleBtn} ${view === 'grid' ? styles.active : ''}`}
             onClick={() => setView('grid')}
+            aria-pressed={view === 'grid'}
           >
             Grid
           </button>
           <button 
             className={`${styles.toggleBtn} ${view === 'table' ? styles.active : ''}`}
             onClick={() => setView('table')}
+            aria-pressed={view === 'table'}
           >
             Table
           </button>
         </div>
       </div>
-      
+
       <div className={styles.content}>
-        {view === 'grid' ? (
-          <div className={styles.grid}>
-            {planets.slice((page - 1) * itemsPerPage, page * itemsPerPage).map((planet) => (
-              <PlanetCard 
-                key={planet.pl_name} 
-                planet={planet} 
-                onClick={() => setSelectedPlanet(planet)}
-              />
-            ))}
-          </div>
+        <FilterControls
+          planets={planets}
+          filters={filters}
+          onChange={changeFilters}
+          onClear={clearFilters}
+          searchRef={searchRef}
+        />
+
+        <ResultsCount visible={visible.length} total={planets.length} />
+
+        {visible.length === 0 ? (
+          <NoResults onClear={isFiltered(filters) ? clearFilters : undefined} />
+        ) : view === 'grid' ? (
+          <PlanetGrid
+            planets={visible}
+            pagination={pagination}
+            onPlanetClick={setSelectedPlanet}
+          />
         ) : (
           <PlanetTable 
-            planets={planets}
-            page={page}
-            itemsPerPage={itemsPerPage}
-            onPageChange={setPage}
+            planets={visible}
+            pagination={pagination}
             onPlanetClick={setSelectedPlanet}
+            sortKey={filters.sortKey}
+            sortOrder={filters.sortOrder}
+            onSort={(key: SortKey) => changeFilters(withSort(filters, key))}
           />
         )}
       </div>
-      
-      {view === 'grid' && (
-        <div className={styles.pagination}>
-          <button 
-            onClick={() => setPage(p => Math.max(1, p - 1))} 
-            disabled={page === 1}
-            className={styles.paginationBtn}
-          >
-            Previous
-          </button>
-          <span className={styles.pageInfo}>
-            Page {page} of {Math.ceil(planets.length / itemsPerPage)}
-          </span>
-          <button 
-            onClick={() => setPage(p => Math.min(Math.ceil(planets.length / itemsPerPage), p + 1))} 
-            disabled={page === Math.ceil(planets.length / itemsPerPage)}
-            className={styles.paginationBtn}
-          >
-            Next
-          </button>
-        </div>
-      )}
 
       {selectedPlanet && (
         <PlanetModal 
diff --git a/exoplanethub.com/app/explore/ExploreClient.url.test.tsx b/exoplanethub.com/app/explore/ExploreClient.url.test.tsx
new file mode 100644
index 0000000..39f36fd
--- /dev/null
+++ b/exoplanethub.com/app/explore/ExploreClient.url.test.tsx
@@ -0,0 +1,120 @@
+import { fireEvent, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  cardNames,
+  makePlanet,
+  methodBox,
+  renderExplore,
+  replace,
+  searchBox,
+  showGrid,
+  sortHeader,
+  startAtUrl,
+  tableNames,
+} from './exploreTestUtils';
+
+describe('ExploreClient URL state', () => {
+  it('reproduces both the filtered set and its ordering from a shared URL', () => {
+    startAtUrl('q=o&sort=pl_rade.asc');
+    renderExplore();
+
+    expect(tableNames()).toEqual(['Gamma d', 'Alpha b']);
+  });
+
+  // fireEvent rather than userEvent: userEvent's own timers deadlock against vi's fake ones.
+  it('replaces rather than pushes, so Back does not step through the search', () => {
+    vi.useFakeTimers();
+    renderExplore();
+
+    fireEvent.change(searchBox(), { target: { value: 'beta' } });
+    vi.advanceTimersByTime(1000);
+
+    expect(replace).toHaveBeenCalledExactlyOnceWith('/explore?q=beta', { scroll: false });
+  });
+
+  it('writes the chosen sort to the URL and leaves the default sort out of it', () => {
+    vi.useFakeTimers();
+    renderExplore();
+
+    fireEvent.click(sortHeader(/radius/i));
+    vi.advanceTimersByTime(1000);
+    expect(replace).toHaveBeenLastCalledWith('/explore?sort=pl_rade.desc', { scroll: false });
+
+    fireEvent.click(sortHeader(/discovered/i));
+    vi.advanceTimersByTime(1000);
+    expect(replace).toHaveBeenLastCalledWith('/explore', { scroll: false });
+  });
+
+  it('writes every ticked method to one comma-separated param', () => {
+    vi.useFakeTimers();
+    renderExplore();
+
+    fireEvent.click(methodBox('Transit'));
+    vi.advanceTimersByTime(1000);
+    expect(replace).toHaveBeenLastCalledWith('/explore?method=Transit', { scroll: false });
+
+    fireEvent.click(methodBox('Radial Velocity'));
+    vi.advanceTimersByTime(1000);
+    expect(replace).toHaveBeenLastCalledWith('/explore?method=Radial+Velocity%2CTransit', { scroll: false });
+
+    fireEvent.click(methodBox('Transit'));
+    vi.advanceTimersByTime(1000);
+    expect(replace).toHaveBeenLastCalledWith('/explore?method=Radial+Velocity', { scroll: false });
+  });
+
+  it('keeps the sort indicator on the column the rows are actually ordered by after Back', () => {
+    startAtUrl('sort=pl_rade.asc');
+    const { navigateTo } = renderExplore();
+    expect(sortHeader(/radius/i)).toHaveTextContent('▲');
+
+    navigateTo('');
+
+    expect(sortHeader(/radius/i)).not.toHaveTextContent(/[▲▼]/);
+    expect(sortHeader(/discovered/i)).toHaveTextContent('▼');
+    expect(tableNames()).toEqual(['Beta c', 'Alpha b', 'Gamma d']);
+  });
+
+  it.each([
+    ['an unknown sort key', 'sort=nonsense.sideways'],
+    ['an empty search', 'q='],
+    ['params it does not own', 'utm_source=newsletter'],
+  ])('renders the ordinary page for %s', (_label, badQuery) => {
+    startAtUrl(badQuery);
+    renderExplore();
+
+    expect(tableNames()).toEqual(['Beta c', 'Alpha b', 'Gamma d']);
+  });
+});
+
+describe('ExploreClient shared ordering', () => {
+  // 120 planets whose alphabetical order is the reverse of their discovery order, so a page of
+  // one ordering can never coincidentally match the same page of the other.
+  const many = Array.from({ length: 120 }, (_, i) =>
+    makePlanet({ pl_name: `Planet ${String(119 - i).padStart(3, '0')}`, disc_year: 2000 + i })
+  );
+
+  it('orders the grid by ?sort=, which it used to ignore', async () => {
+    startAtUrl('sort=pl_name.asc');
+    const { user } = renderExplore(many);
+    await showGrid(user);
+
+    expect(cardNames()!.slice(0, 3)).toEqual(['Planet 000', 'Planet 001', 'Planet 002']);
+  });
+
+  // The promise a shared URL makes: the recipient sees the set the sender saw, in that order.
+  it.each([
+    ['the default sort', ''],
+    ['a sort the URL asks for', 'sort=pl_name.asc'],
+    ['a sort applied over a filter', 'q=Planet 0&sort=pl_name.asc'],
+  ])('shows the same planets on grid page 2 as on table page 2 under %s', async (_label, shared) => {
+    startAtUrl(shared);
+    const { user } = renderExplore(many);
+    await user.click(screen.getByRole('button', { name: /next/i }));
+    const fromTable = tableNames();
+
+    await showGrid(user);
+
+    expect(fromTable).toHaveLength(50);
+    expect(cardNames()).toEqual(fromTable);
+  });
+});
diff --git a/exoplanethub.com/app/explore/ExploreClient.view.test.tsx b/exoplanethub.com/app/explore/ExploreClient.view.test.tsx
new file mode 100644
index 0000000..e0da867
--- /dev/null
+++ b/exoplanethub.com/app/explore/ExploreClient.view.test.tsx
@@ -0,0 +1,162 @@
+import { act, fireEvent, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  ALPHA,
+  announcement,
+  cardNames,
+  emptyState,
+  makePlanet,
+  quickViewButton,
+  renderExplore,
+  resultsCount,
+  searchBox,
+  showGrid,
+  tableNames,
+  viewButton,
+} from './exploreTestUtils';
+
+describe('ExploreClient pagination', () => {
+  const many = Array.from({ length: 120 }, (_, i) =>
+    makePlanet({ pl_name: `Planet ${String(i).padStart(3, '0')}`, disc_year: 2000 + i })
+  );
+
+  async function goToPage2(user: ReturnType<typeof userEvent.setup>) {
+    await user.click(screen.getByRole('button', { name: /next/i }));
+  }
+
+  // Narrowed to 100 planets, so page 2 still exists and only an explicit reset can move off it.
+  it('returns to the first page when the filter changes under a later page', async () => {
+    const { user } = renderExplore(many);
+    await goToPage2(user);
+    expect(screen.getByText(/page 2 of 3/i)).toBeInTheDocument();
+
+    await user.type(searchBox(), 'Planet 0');
+
+    expect(screen.getByText(/page 1 of 2/i)).toBeInTheDocument();
+    expect(resultsCount()).toHaveTextContent('100 of 120 planets');
+  });
+
+  // Back/Forward changes the filters without going through the reset, leaving the page behind.
+  it('never leaves the visitor on a page past the end of the results', async () => {
+    const { user, navigateTo } = renderExplore(many);
+    await goToPage2(user);
+
+    navigateTo('q=Planet 007');
+
+    expect(screen.getByText(/page 1 of 1/i)).toBeInTheDocument();
+    expect(tableNames()).toEqual(['Planet 007']);
+  });
+
+  // Previous used to read the page that was asked for rather than the one on screen, so once
+  // the clamp was active it set the page straight back to where it already was.
+  it('steps back from a clamped grid page instead of dead-clicking', async () => {
+    const { user, navigateTo } = renderExplore(many);
+    await showGrid(user);
+    await goToPage2(user);
+    await goToPage2(user);
+    expect(screen.getByText(/page 3 of 3/i)).toBeInTheDocument();
+
+    navigateTo('q=Planet 0');
+    expect(screen.getByText(/page 2 of 2/i)).toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: /previous/i }));
+
+    expect(screen.getByText(/page 1 of 2/i)).toBeInTheDocument();
+  });
+
+  // Both views page through one hook, so a second page size cannot creep back into either.
+  it('keeps the same page window when the visitor switches view', async () => {
+    const { user } = renderExplore(many);
+    await goToPage2(user);
+    expect(screen.getByText(/page 2 of 3/i)).toBeInTheDocument();
+    expect(tableNames()).toHaveLength(50);
+
+    await showGrid(user);
+
+    expect(screen.getByText(/page 2 of 3/i)).toBeInTheDocument();
+    expect(cardNames()).toHaveLength(50);
+  });
+
+  // The empty state replaces the list, so there is no page to be stranded on — and clearing
+  // has to land back on page 1 rather than the page the visitor left.
+  it('drops the grid paging while nothing matches and returns to page 1 after clearing', async () => {
+    const { user } = renderExplore(many);
+    await showGrid(user);
+    await goToPage2(user);
+
+    await user.type(searchBox(), 'no such planet');
+    expect(emptyState()).toBeInTheDocument();
+    expect(screen.queryByText(/page 1 of 1/i)).toBeNull();
+    expect(screen.queryAllByRole('heading', { level: 3 })).toEqual([]);
+
+    await user.click(screen.getByRole('button', { name: /clear all filters/i }));
+
+    expect(screen.getByText(/page 1 of 3/i)).toBeInTheDocument();
+  });
+});
+
+describe('ExploreClient results count', () => {
+  it('counts the whole fetched list, not just the page on screen', () => {
+    const many = Array.from({ length: 120 }, (_, i) =>
+      makePlanet({ pl_name: `Planet ${String(i).padStart(3, '0')}` })
+    );
+    renderExplore(many);
+
+    expect(resultsCount()).toHaveTextContent('120 of 120 planets');
+  });
+
+  it('narrows the first number as a filter bites, leaving the total alone', async () => {
+    const { user } = renderExplore();
+    expect(resultsCount()).toHaveTextContent('3 of 3 planets');
+
+    await user.type(searchBox(), 'beta');
+
+    expect(resultsCount()).toHaveTextContent('1 of 3 planets');
+  });
+
+  it('waits for typing to settle before announcing, so it does not read every keystroke', () => {
+    vi.useFakeTimers();
+    renderExplore();
+    expect(announcement()).toHaveTextContent('Showing 3 of 3 planets');
+
+    fireEvent.change(searchBox(), { target: { value: 'beta' } });
+
+    expect(resultsCount()).toHaveTextContent('1 of 3 planets');
+    expect(announcement()).toHaveTextContent('Showing 3 of 3 planets');
+
+    act(() => vi.advanceTimersByTime(1000));
+
+    expect(announcement()).toHaveTextContent('Showing 1 of 3 planets');
+  });
+
+  it('keeps counting while nothing matches, rather than disappearing with the list', async () => {
+    const { user } = renderExplore();
+
+    await user.type(searchBox(), 'no such planet');
+
+    expect(resultsCount()).toHaveTextContent('0 of 3 planets');
+  });
+});
+
+describe('ExploreClient view toggle', () => {
+  it('reports which view is active, rather than signalling it by colour alone', async () => {
+    const { user } = renderExplore([ALPHA]);
+
+    expect(viewButton('Table')).toHaveAttribute('aria-pressed', 'true');
+    expect(viewButton('Grid')).toHaveAttribute('aria-pressed', 'false');
+
+    await showGrid(user);
+
+    expect(viewButton('Grid')).toHaveAttribute('aria-pressed', 'true');
+    expect(viewButton('Table')).toHaveAttribute('aria-pressed', 'false');
+  });
+
+  it('opens the planet dialog from the table, the default view', async () => {
+    const { user } = renderExplore([ALPHA]);
+
+    await user.click(quickViewButton('Alpha b'));
+
+    expect(screen.getByRole('dialog')).toHaveAccessibleName('Alpha b');
+  });
+});
diff --git a/exoplanethub.com/app/explore/exploreTestUtils.tsx b/exoplanethub.com/app/explore/exploreTestUtils.tsx
new file mode 100644
index 0000000..b7fe897
--- /dev/null
+++ b/exoplanethub.com/app/explore/exploreTestUtils.tsx
@@ -0,0 +1,130 @@
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { afterEach, beforeEach, vi } from 'vitest';
+import rangeStyles from '@/components/explore/RangeFilter.module.css';
+import type { PlanetSummary } from '@/lib/mockPlanets';
+import ExploreClient from './ExploreClient';
+
+export const replace = vi.fn();
+let query = '';
+
+// Stable, as the real useRouter is: a fresh object each render hides missing effect deps.
+const router = { replace };
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => router,
+  usePathname: () => '/explore',
+  useSearchParams: () => new URLSearchParams(query),
+}));
+
+// Only takes effect on the next render, so call it before renderExplore.
+export function startAtUrl(search: string) {
+  query = search;
+}
+
+export function makePlanet(overrides: Partial<PlanetSummary> & Pick<PlanetSummary, 'pl_name'>): PlanetSummary {
+  return {
+    hostname: 'Host',
+    sy_dist: 10,
+    discoverymethod: 'Transit',
+    disc_year: 2000,
+    pl_orbper: 10,
+    pl_rade: 1,
+    pl_bmasse: 1,
+    pl_eqt: 1,
+    st_teff: 5800,
+    ...overrides,
+  };
+}
+
+export const ALPHA = makePlanet({ pl_name: 'Alpha b', hostname: 'Ross 128', disc_year: 2015, pl_rade: 3, pl_bmasse: 30, pl_orbper: 1000 });
+const BETA = makePlanet({ pl_name: 'Beta c', hostname: 'Kepler-186', disc_year: 2021, pl_rade: 1, pl_bmasse: 1, pl_orbper: 10, discoverymethod: 'Radial Velocity' });
+const GAMMA = makePlanet({ pl_name: 'Gamma d', hostname: 'Wolf 359', disc_year: 2008, pl_rade: 2, pl_bmasse: 5, pl_orbper: 0.5 });
+
+export function renderExplore(planets: PlanetSummary[] = [ALPHA, BETA, GAMMA]) {
+  const { rerender } = render(<ExploreClient planets={planets} />);
+
+  return {
+    user: userEvent.setup(),
+    navigateTo(next: string) {
+      query = next;
+      rerender(<ExploreClient planets={planets} />);
+    },
+  };
+}
+
+// Reads the name link rather than the whole cell, which also holds the quick-view control.
+export function tableNames() {
+  return screen
+    .getAllByRole('row')
+    .slice(1)
+    .map((row) => within(row).getByRole('link').textContent);
+}
+
+export function quickViewButton(name: string) {
+  return screen.getByRole('button', { name: `Quick view: ${name}` });
+}
+
+export function cardNames() {
+  return screen.getAllByRole('heading', { level: 3 }).map((heading) => heading.textContent);
+}
+
+export function searchBox() {
+  return screen.getByRole('textbox', { name: /search by planet or host star/i });
+}
+
+export function sortHeader(name: RegExp) {
+  return within(screen.getByRole('columnheader', { name })).getByRole('button', { name });
+}
+
+export function rangeGroup(name: RegExp) {
+  return within(screen.getByRole('group', { name }));
+}
+
+// The rail is decorative, so it has no role to query by; its class is the only handle on it.
+export function rangeRail(name: RegExp) {
+  return screen.getByRole('group', { name }).querySelector(`.${rangeStyles.track}`);
+}
+
+export function boundInput(name: RegExp, edge: RegExp) {
+  return rangeGroup(name).getByRole('spinbutton', { name: edge });
+}
+
+export function methodBox(name: string) {
+  return within(screen.getByRole('group', { name: /discovery method/i })).getByRole('checkbox', {
+    name,
+  });
+}
+
+export function starBox(name: RegExp) {
+  return within(screen.getByRole('group', { name: /star type/i })).getByRole('checkbox', { name });
+}
+
+export function resultsCount() {
+  return screen.getByText(/^\d+ of \d+ planets$/i);
+}
+
+export function announcement() {
+  return screen.getByRole('status');
+}
+
+export function emptyState() {
+  return screen.queryByText(/no planets match these filters/i);
+}
+
+export async function showGrid(user: ReturnType<typeof userEvent.setup>) {
+  await user.click(screen.getByRole('button', { name: 'Grid' }));
+}
+
+export function viewButton(name: 'Grid' | 'Table') {
+  return screen.getByRole('button', { name });
+}
+
+beforeEach(() => {
+  replace.mockClear();
+  query = '';
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
diff --git a/exoplanethub.com/app/explore/page.module.css b/exoplanethub.com/app/explore/page.module.css
index f17ada0..8f6e48e 100644
--- a/exoplanethub.com/app/explore/page.module.css
+++ b/exoplanethub.com/app/explore/page.module.css
@@ -88,13 +88,7 @@
   transform: scale(1.1);
 }
 
-.grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(340px, 1fr));
-  gap: 24px;
-}
-
-.loadingContainer {
+.statusPanel {
   display: flex;
   flex-direction: column;
   align-items: center;
@@ -190,56 +184,47 @@
   margin: 0;
 }
 
-.pagination {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 24px;
-  margin-top: 32px;
-}
-
-.paginationBtn {
-  background: var(--color-surface);
-  border: 1px solid var(--color-border);
-  border-radius: 8px;
-  padding: 10px 20px;
-  color: var(--color-text);
-  font-size: 14px;
-  font-weight: 600;
-  cursor: pointer;
-  transition: all 0.2s;
+.loading {
+  text-align: center;
+  padding: 64px 24px;
+  font-size: 18px;
+  color: var(--color-text-muted);
 }
 
-.paginationBtn:hover:not(:disabled) {
-  background: var(--color-primary);
-  color: var(--color-primary-contrast);
-  border-color: var(--color-primary);
+@media (max-width: 768px) {
+  .title {
+    font-size: 32px;
+  }
 }
 
-.paginationBtn:disabled {
-  opacity: 0.5;
-  cursor: not-allowed;
+.errorHeadline {
+  color: var(--color-text);
+  font-size: 18px;
+  font-weight: 600;
+  margin: 0;
+  text-align: center;
 }
 
-.pageInfo {
+.errorDetail {
   color: var(--color-text-muted);
   font-size: 14px;
-  font-weight: 500;
+  max-width: 42ch;
+  margin: 0;
+  text-align: center;
 }
 
-.loading {
-  text-align: center;
-  padding: 64px 24px;
-  font-size: 18px;
-  color: var(--color-text-muted);
+.retry {
+  background: var(--color-primary);
+  border: 1px solid var(--color-primary);
+  border-radius: 8px;
+  padding: 10px 20px;
+  color: var(--color-primary-contrast);
+  font-size: 14px;
+  font-weight: 600;
+  cursor: pointer;
 }
 
-@media (max-width: 768px) {
-  .title {
-    font-size: 32px;
-  }
-  
-  .grid {
-    grid-template-columns: 1fr;
-  }
+.retry:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
 }
diff --git a/exoplanethub.com/app/explore/page.test.tsx b/exoplanethub.com/app/explore/page.test.tsx
new file mode 100644
index 0000000..7f10d4e
--- /dev/null
+++ b/exoplanethub.com/app/explore/page.test.tsx
@@ -0,0 +1,89 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { PlanetSummary } from '@/lib/mockPlanets';
+import ExplorePage from './page';
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({ replace: vi.fn() }),
+  usePathname: () => '/explore',
+  useSearchParams: () => new URLSearchParams(),
+}));
+
+const KEPLER: PlanetSummary = {
+  pl_name: 'Kepler-186 f',
+  hostname: 'Kepler-186',
+  sy_dist: 178,
+  discoverymethod: 'Transit',
+  disc_year: 2014,
+  pl_orbper: 129.9,
+  pl_rade: 1.17,
+  pl_bmasse: 1.71,
+  pl_eqt: 188,
+  st_teff: 3755,
+};
+
+function respondWith(payload: unknown) {
+  return vi.fn().mockResolvedValue({ json: () => Promise.resolve(payload) });
+}
+
+function errorPanel() {
+  return screen.queryByRole('alert');
+}
+
+beforeEach(() => {
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+describe('ExplorePage', () => {
+  it('shows the loader until the archive arrives, then hands over to the explorer', async () => {
+    vi.stubGlobal('fetch', respondWith([KEPLER]));
+    render(<ExplorePage />);
+
+    expect(screen.getByText(/loading exoplanets/i)).toBeInTheDocument();
+
+    expect(await screen.findByText('Kepler-186 f')).toBeInTheDocument();
+    expect(errorPanel()).toBeNull();
+  });
+
+  // The explorer reads an empty list as an empty archive, so a failure must never reach it.
+  it.each([
+    ['the request fails', () => vi.fn().mockRejectedValue(new Error('offline'))],
+    ['the endpoint answers with an error body', () => respondWith({ error: 'Failed to fetch planets' })],
+  ])('says the archive would not load when %s, rather than that it is empty', async (_label, mock) => {
+    vi.stubGlobal('fetch', mock());
+    render(<ExplorePage />);
+
+    expect(await screen.findByText(/couldn.t load the exoplanet archive/i)).toBeInTheDocument();
+    expect(screen.queryByText(/no planets to show/i)).toBeNull();
+    expect(screen.queryByRole('textbox', { name: /search/i })).toBeNull();
+  });
+
+  it('shows the loader again while a retry is in flight, then the archive it reached', async () => {
+    const user = userEvent.setup();
+    let answerRetry: (response: unknown) => void = () => {};
+    vi.stubGlobal(
+      'fetch',
+      vi
+        .fn()
+        .mockRejectedValueOnce(new Error('offline'))
+        .mockReturnValueOnce(new Promise((resolve) => (answerRetry = resolve)))
+    );
+    render(<ExplorePage />);
+    await screen.findByRole('button', { name: /try again/i });
+
+    await user.click(screen.getByRole('button', { name: /try again/i }));
+
+    expect(screen.getByText(/loading exoplanets/i)).toBeInTheDocument();
+    expect(errorPanel()).toBeNull();
+
+    answerRetry({ json: () => Promise.resolve([KEPLER]) });
+
+    expect(await screen.findByText('Kepler-186 f')).toBeInTheDocument();
+  });
+});
diff --git a/exoplanethub.com/app/explore/page.tsx b/exoplanethub.com/app/explore/page.tsx
index 80ebd94..6638785 100644
--- a/exoplanethub.com/app/explore/page.tsx
+++ b/exoplanethub.com/app/explore/page.tsx
@@ -1,33 +1,40 @@
 'use client';
-import { useState, useEffect } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 import ExploreClient from './ExploreClient';
 import { PlanetSummary } from '@/lib/mockPlanets';
 import styles from './page.module.css';
 
+type Archive =
+  | { status: 'loading' }
+  | { status: 'unavailable' }
+  | { status: 'loaded'; planets: PlanetSummary[] };
+
 export default function ExplorePage() {
-  const [planets, setPlanets] = useState<PlanetSummary[]>([]);
-  const [loading, setLoading] = useState(true);
+  const [archive, setArchive] = useState<Archive>({ status: 'loading' });
 
-  useEffect(() => {
+  const load = useCallback(() => {
     fetch('/api/planets')
-      .then(res => res.json())
-      .then(data => {
-        if (Array.isArray(data)) {
-          setPlanets(data);
-        } else {
-          console.error('API returned non-array data:', data);
-          setPlanets([]);
-        }
-        setLoading(false);
+      .then((res) => res.json())
+      .then((data) => {
+        if (!Array.isArray(data)) throw new Error('Planets endpoint did not return a list');
+        setArchive({ status: 'loaded', planets: data });
       })
-      .catch(err => {
+      .catch((err) => {
         console.error('Error loading planets:', err);
-        setPlanets([]);
-        setLoading(false);
+        setArchive({ status: 'unavailable' });
       });
   }, []);
 
-  return loading ? (
+  useEffect(load, [load]);
+
+  const retry = () => {
+    setArchive({ status: 'loading' });
+    load();
+  };
+
+  if (archive.status === 'loaded') return <ExploreClient planets={archive.planets} />;
+
+  return (
     <main className={styles.page}>
       <div className={styles.header}>
         <h1 className={styles.title}>Explore Exoplanets</h1>
@@ -35,23 +42,41 @@ export default function ExplorePage() {
           Browse all confirmed exoplanets from NASA&apos;s archive
         </p>
       </div>
-      <div className={styles.loadingContainer}>
-        <div className={styles.solarSystem}>
-          <div className={styles.sun}></div>
-          <div className={styles.orbit}>
-            <div className={styles.planet}></div>
-          </div>
-          <div className={`${styles.orbit} ${styles.orbit2}`}>
-            <div className={`${styles.planet} ${styles.planet2}`}></div>
-          </div>
-          <div className={`${styles.orbit} ${styles.orbit3}`}>
-            <div className={`${styles.planet} ${styles.planet3}`}></div>
-          </div>
+      {archive.status === 'loading' ? <LoadingOrbits /> : <Unavailable onRetry={retry} />}
+    </main>
+  );
+}
+
+function LoadingOrbits() {
+  return (
+    <div className={styles.statusPanel}>
+      <div className={styles.solarSystem}>
+        <div className={styles.sun}></div>
+        <div className={styles.orbit}>
+          <div className={styles.planet}></div>
+        </div>
+        <div className={`${styles.orbit} ${styles.orbit2}`}>
+          <div className={`${styles.planet} ${styles.planet2}`}></div>
+        </div>
+        <div className={`${styles.orbit} ${styles.orbit3}`}>
+          <div className={`${styles.planet} ${styles.planet3}`}></div>
         </div>
-        <p className={styles.loadingText}>Loading exoplanets...</p>
       </div>
-    </main>
-  ) : (
-    <ExploreClient planets={planets} />
+      <p className={styles.loadingText}>Loading exoplanets...</p>
+    </div>
+  );
+}
+
+function Unavailable({ onRetry }: { onRetry: () => void }) {
+  return (
+    <div className={styles.statusPanel} role="alert">
+      <p className={styles.errorHeadline}>We couldn&apos;t load the exoplanet archive</p>
+      <p className={styles.errorDetail}>
+        The request for planet data didn&apos;t come back. This is usually temporary.
+      </p>
+      <button type="button" className={styles.retry} onClick={onRetry}>
+        Try again
+      </button>
+    </div>
   );
 }
diff --git a/exoplanethub.com/app/layout.tsx b/exoplanethub.com/app/layout.tsx
index 1cd2553..f81817d 100644
--- a/exoplanethub.com/app/layout.tsx
+++ b/exoplanethub.com/app/layout.tsx
@@ -2,8 +2,9 @@ import type { Metadata } from "next";
 import { Inter, Poppins } from "next/font/google";
 import "./globals.css";
 import NavBar from "@/components/layout/NavBar";
-import { generateCSSVariables } from "@/lib/theme";
-// Push
+import { generateCSSVariables, SITE_THEME } from "@/lib/theme";
+import { SITE_ORIGIN } from "@/lib/site";
+
 const inter = Inter({
   variable: "--font-inter",
   subsets: ["latin"],
@@ -15,7 +16,9 @@ const poppins = Poppins({
   subsets: ["latin"],
 });
 
+// Resolves the relative canonical and og:url a page returns, so a shared link is absolute.
 export const metadata: Metadata = {
+  metadataBase: new URL(SITE_ORIGIN),
   title: "ExoplanetHub - Discover Worlds Beyond Our Solar System",
   description: "Explore thousands of confirmed exoplanets with detailed data and visualizations",
 };
@@ -27,7 +30,7 @@ export default function RootLayout({
 }>) {
   return (
     <html lang="en">
-      <body className={`${inter.variable} ${poppins.variable}`} style={generateCSSVariables('nautilus')}>
+      <body className={`${inter.variable} ${poppins.variable}`} style={generateCSSVariables(SITE_THEME)}>
         <NavBar />
         {children}
       </body>
diff --git a/exoplanethub.com/app/planet/[name]/MissingPlanetSearch.test.tsx b/exoplanethub.com/app/planet/[name]/MissingPlanetSearch.test.tsx
new file mode 100644
index 0000000..38a5d42
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/MissingPlanetSearch.test.tsx
@@ -0,0 +1,46 @@
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import MissingPlanetSearch from './MissingPlanetSearch';
+
+const { usePathname } = vi.hoisted(() => ({ usePathname: vi.fn() }));
+
+vi.mock('next/navigation', () => ({ usePathname }));
+
+function renderAt(pathname: string | null) {
+  usePathname.mockReturnValue(pathname);
+  render(<MissingPlanetSearch />);
+  return screen.getByRole('link');
+}
+
+describe('MissingPlanetSearch', () => {
+  it('carries the attempted name into the explore search', () => {
+    const link = renderAt('/planet/Kepler-452%20b');
+
+    expect(link).toHaveAttribute('href', '/explore?q=Kepler-452%20b');
+    expect(link).toHaveTextContent('Search the archive for “Kepler-452 b”');
+  });
+
+  // Next has decoded the pathname before now; re-decoding a name is a no-op, not a corruption.
+  it('reads a name the router already decoded', () => {
+    expect(renderAt('/planet/Kepler-452 b')).toHaveAttribute('href', '/explore?q=Kepler-452%20b');
+  });
+
+  it('keeps a name containing a plus sign searchable', () => {
+    expect(renderAt('/planet/2MASS%20J0249-0557%20c')).toHaveAttribute(
+      'href',
+      '/explore?q=2MASS%20J0249-0557%20c'
+    );
+  });
+
+  it.each([
+    ['the segment is malformed', '/planet/%ZZ'],
+    ['no name was given', '/planet/'],
+    ['the router has no path to offer', null],
+    ['the segment is a spoofed sentence, not a name', `/planet/${'Your account is locked. '.repeat(10)}`],
+  ])('falls back to browsing the whole archive when %s', (_case, pathname) => {
+    const link = renderAt(pathname);
+
+    expect(link).toHaveAttribute('href', '/explore');
+    expect(link).toHaveTextContent('Browse the archive');
+  });
+});
diff --git a/exoplanethub.com/app/planet/[name]/MissingPlanetSearch.tsx b/exoplanethub.com/app/planet/[name]/MissingPlanetSearch.tsx
new file mode 100644
index 0000000..592499f
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/MissingPlanetSearch.tsx
@@ -0,0 +1,29 @@
+'use client';
+import Link from 'next/link';
+import { usePathname } from 'next/navigation';
+import { planetNameFromParam } from '@/lib/planetUrl';
+import styles from './page.module.css';
+
+// Next hands a not-found boundary no params, so the name that missed comes back off the URL.
+export default function MissingPlanetSearch() {
+  const attemptedName = planetNameFromPathname(usePathname());
+
+  if (attemptedName === null) {
+    return (
+      <Link className={styles.action} href="/explore">
+        Browse the archive
+      </Link>
+    );
+  }
+
+  return (
+    <Link className={styles.action} href={`/explore?q=${encodeURIComponent(attemptedName)}`}>
+      Search the archive for &ldquo;{attemptedName}&rdquo;
+    </Link>
+  );
+}
+
+function planetNameFromPathname(pathname: string | null): string | null {
+  const segment = pathname?.split('/').at(-1);
+  return segment ? planetNameFromParam(segment) : null;
+}
diff --git a/exoplanethub.com/app/planet/[name]/PageSection.module.css b/exoplanethub.com/app/planet/[name]/PageSection.module.css
new file mode 100644
index 0000000..186d881
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/PageSection.module.css
@@ -0,0 +1,20 @@
+.section {
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: 16px;
+  padding: 32px;
+}
+
+.title {
+  font-family: var(--font-heading);
+  font-size: 22px;
+  font-weight: 600;
+  color: var(--color-text);
+  margin: 0 0 20px;
+}
+
+@media (max-width: 768px) {
+  .section {
+    padding: 24px;
+  }
+}
diff --git a/exoplanethub.com/app/planet/[name]/PageSection.tsx b/exoplanethub.com/app/planet/[name]/PageSection.tsx
new file mode 100644
index 0000000..47f0b51
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/PageSection.tsx
@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import styles from './PageSection.module.css';
+
+interface PageSectionProps {
+  id: string;
+  title: string;
+  children: ReactNode;
+}
+
+// Deriving the heading id from the section id is what keeps aria-labelledby from drifting.
+export default function PageSection({ id, title, children }: PageSectionProps) {
+  const headingId = `${id}-heading`;
+
+  return (
+    <section className={styles.section} aria-labelledby={headingId}>
+      <h2 id={headingId} className={styles.title}>
+        {title}
+      </h2>
+      {children}
+    </section>
+  );
+}
diff --git a/exoplanethub.com/app/planet/[name]/error.test.tsx b/exoplanethub.com/app/planet/[name]/error.test.tsx
new file mode 100644
index 0000000..222eb67
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/error.test.tsx
@@ -0,0 +1,44 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+import PlanetError from './error';
+
+function renderError(reset = vi.fn()) {
+  render(<PlanetError error={new Error('DynamoDB unavailable')} reset={reset} />);
+  return reset;
+}
+
+describe('PlanetError', () => {
+  it('explains the outage in the app voice rather than leaving Next to say "Application error"', () => {
+    renderError();
+
+    expect(
+      screen.getByRole('heading', { level: 1, name: "We couldn't load this planet" })
+    ).toBeInTheDocument();
+    expect(screen.getByRole('alert')).toHaveTextContent('This is usually temporary.');
+  });
+
+  it('retries the render in place', async () => {
+    const reset = renderError();
+
+    await userEvent.click(screen.getByRole('button', { name: 'Try again' }));
+
+    expect(reset).toHaveBeenCalledTimes(1);
+  });
+
+  it('offers the archive as a way out when the retry keeps failing', () => {
+    renderError();
+
+    expect(screen.getByRole('link', { name: 'Browse the archive' })).toHaveAttribute(
+      'href',
+      '/explore'
+    );
+  });
+
+  // The thrown Error is the outage's own text; a reader gets our copy, not DynamoDB's.
+  it('never prints the underlying failure', () => {
+    renderError();
+
+    expect(screen.queryByText(/DynamoDB/)).toBeNull();
+  });
+});
diff --git a/exoplanethub.com/app/planet/[name]/error.tsx b/exoplanethub.com/app/planet/[name]/error.tsx
new file mode 100644
index 0000000..6faf5a4
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/error.tsx
@@ -0,0 +1,28 @@
+'use client';
+import Link from 'next/link';
+import styles from './page.module.css';
+
+// getPlanetDetail throws on an outage so it can't cache as a 404, which lands the reader here.
+export default function PlanetError({ reset }: { error: Error; reset: () => void }) {
+  return (
+    <main className={styles.page}>
+      <div className={styles.container} role="alert">
+        <header className={styles.header}>
+          <h1 className={styles.title}>We couldn&apos;t load this planet</h1>
+          <p className={styles.summary}>
+            The request for this planet&apos;s data didn&apos;t come back. This is usually
+            temporary.
+          </p>
+        </header>
+        <div className={styles.actions}>
+          <button type="button" className={styles.action} onClick={reset}>
+            Try again
+          </button>
+          <Link className={`${styles.action} ${styles.actionQuiet}`} href="/explore">
+            Browse the archive
+          </Link>
+        </div>
+      </div>
+    </main>
+  );
+}
diff --git a/exoplanethub.com/app/planet/[name]/not-found.test.tsx b/exoplanethub.com/app/planet/[name]/not-found.test.tsx
new file mode 100644
index 0000000..40c1605
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/not-found.test.tsx
@@ -0,0 +1,22 @@
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import PlanetNotFound from './not-found';
+
+vi.mock('next/navigation', () => ({ usePathname: () => '/planet/Kepler-452%20b' }));
+
+describe('PlanetNotFound', () => {
+  it('leads with a single heading that says the planet is missing, not that the site broke', () => {
+    render(<PlanetNotFound />);
+
+    expect(screen.getAllByRole('heading', { level: 1 })).toHaveLength(1);
+    expect(screen.getByRole('heading', { level: 1 })).toHaveTextContent(
+      "We don't have that planet"
+    );
+  });
+
+  it('offers the attempted name as a way back into the archive', () => {
+    render(<PlanetNotFound />);
+
+    expect(screen.getByRole('link')).toHaveAttribute('href', '/explore?q=Kepler-452%20b');
+  });
+});
diff --git a/exoplanethub.com/app/planet/[name]/not-found.tsx b/exoplanethub.com/app/planet/[name]/not-found.tsx
new file mode 100644
index 0000000..84903e2
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/not-found.tsx
@@ -0,0 +1,19 @@
+import MissingPlanetSearch from './MissingPlanetSearch';
+import styles from './page.module.css';
+
+export default function PlanetNotFound() {
+  return (
+    <main className={styles.page}>
+      <div className={styles.container}>
+        <header className={styles.header}>
+          <h1 className={styles.title}>We don&apos;t have that planet</h1>
+          <p className={styles.summary}>
+            No planet by that name is in our copy of NASA&apos;s archive. The link may be
+            mistyped, or the planet may be catalogued under a different name.
+          </p>
+        </header>
+        <MissingPlanetSearch />
+      </div>
+    </main>
+  );
+}
diff --git a/exoplanethub.com/app/planet/[name]/opengraph-image.render.test.tsx b/exoplanethub.com/app/planet/[name]/opengraph-image.render.test.tsx
new file mode 100644
index 0000000..62a57a0
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/opengraph-image.render.test.tsx
@@ -0,0 +1,63 @@
+// @vitest-environment node
+import { describe, expect, it, vi } from 'vitest';
+import type { Planet } from '@/lib/mockPlanets';
+import OpenGraphImage, { size } from './opengraph-image';
+
+const { getPlanetDetail } = vi.hoisted(() => ({ getPlanetDetail: vi.fn() }));
+
+vi.mock('@/lib/planetDetail', () => ({ getPlanetDetail }));
+
+const KEPLER: Planet = {
+  pl_name: 'Kepler-452 b',
+  hostname: 'Kepler-452',
+  sy_snum: 1,
+  sy_pnum: 1,
+  sy_dist: 551.7,
+  discoverymethod: 'Transit',
+  disc_year: 2015,
+  disc_facility: 'Kepler',
+  pl_orbper: 384.8,
+  pl_orbsmax: 1.046,
+  pl_rade: 1.63,
+  pl_bmasse: 3.29,
+  pl_dens: null,
+  pl_eqt: 265,
+  pl_insol: 1.1,
+  st_teff: 5757,
+  st_rad: 1.11,
+  st_mass: 1.04,
+  st_logg: null,
+  st_age: 6,
+  last_updated: '2026-01-01T00:00:00Z',
+  esi: 83,
+};
+
+async function renderPng(name: string): Promise<Buffer> {
+  const response = await OpenGraphImage({ params: Promise.resolve({ name }) });
+  return Buffer.from(await response.arrayBuffer());
+}
+
+function pngDimensions(png: Buffer) {
+  return { width: png.readUInt32BE(16), height: png.readUInt32BE(20) };
+}
+
+// Satori rejects layouts tsc and the mocked tests both accept, so the card is rendered for real here.
+describe('opengraph-image rendered through satori', () => {
+  it('encodes a planet card at the declared size', async () => {
+    getPlanetDetail.mockResolvedValue(KEPLER);
+
+    const png = await renderPng('Kepler-452%20b');
+
+    expect(png.subarray(1, 4).toString()).toBe('PNG');
+    expect(pngDimensions(png)).toEqual(size);
+  });
+
+  it('encodes the factless fallback card rather than throwing', async () => {
+    getPlanetDetail.mockResolvedValue(null);
+
+    const png = await renderPng('Nowhere%20b');
+
+    expect(png.subarray(1, 4).toString()).toBe('PNG');
+    expect(pngDimensions(png)).toEqual(size);
+  });
+});
diff --git a/exoplanethub.com/app/planet/[name]/opengraph-image.test.tsx b/exoplanethub.com/app/planet/[name]/opengraph-image.test.tsx
new file mode 100644
index 0000000..1e26189
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/opengraph-image.test.tsx
@@ -0,0 +1,88 @@
+// @vitest-environment node
+import { renderToStaticMarkup } from 'react-dom/server';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Planet } from '@/lib/mockPlanets';
+import OpenGraphImage, { alt, contentType, revalidate, size } from './opengraph-image';
+
+const { ImageResponse, getPlanetDetail } = vi.hoisted(() => ({
+  ImageResponse: vi.fn(),
+  getPlanetDetail: vi.fn(),
+}));
+
+vi.mock('next/og', () => ({ ImageResponse }));
+vi.mock('@/lib/planetDetail', () => ({ getPlanetDetail }));
+
+const KEPLER: Planet = {
+  pl_name: 'Kepler-452 b',
+  hostname: 'Kepler-452',
+  sy_snum: 1,
+  sy_pnum: 1,
+  sy_dist: 551.7,
+  discoverymethod: 'Transit',
+  disc_year: 2015,
+  disc_facility: 'Kepler',
+  pl_orbper: 384.8,
+  pl_orbsmax: 1.046,
+  pl_rade: 1.63,
+  pl_bmasse: 3.29,
+  pl_dens: null,
+  pl_eqt: 265,
+  pl_insol: 1.1,
+  st_teff: 5757,
+  st_rad: 1.11,
+  st_mass: 1.04,
+  st_logg: null,
+  st_age: 6,
+  last_updated: '2026-01-01T00:00:00Z',
+  esi: 83,
+};
+
+async function renderCard(name: string): Promise<string> {
+  await OpenGraphImage({ params: Promise.resolve({ name }) });
+  return renderToStaticMarkup(ImageResponse.mock.calls[0][0]);
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('opengraph-image', () => {
+  it('declares the 1200x630 PNG contract share crawlers expect, cached for an hour', () => {
+    expect(size).toEqual({ width: 1200, height: 630 });
+    expect(contentType).toBe('image/png');
+    expect(revalidate).toBe(3600);
+    expect(alt).not.toBe('');
+  });
+
+  it('draws the planet name, its star and its facts at the size it declares', async () => {
+    getPlanetDetail.mockResolvedValue(KEPLER);
+
+    const markup = await renderCard('Kepler-452%20b');
+
+    expect(markup).toContain('Kepler-452 b');
+    expect(markup).toContain('Orbiting Kepler-452');
+    expect(markup).toContain('1,799 light-years away');
+    expect(markup).toContain('Discovered in 2015');
+    expect(markup).toContain('ESI 83');
+    expect(ImageResponse.mock.calls[0][1]).toEqual(size);
+  });
+
+  it('decodes the route segment before looking the planet up', async () => {
+    getPlanetDetail.mockResolvedValue(KEPLER);
+
+    await renderCard('Kepler-452%20b');
+
+    expect(getPlanetDetail).toHaveBeenCalledWith('Kepler-452 b');
+  });
+
+  it('answers with the branded card when the archive does not stock the name', async () => {
+    getPlanetDetail.mockResolvedValue(null);
+
+    await expect(renderCard('Nowhere%20b')).resolves.toContain('Explore exoplanets');
+  });
+
+  it('answers a segment that cannot be decoded without touching DynamoDB', async () => {
+    await expect(renderCard('%ZZ')).resolves.toContain('Explore exoplanets');
+    expect(getPlanetDetail).not.toHaveBeenCalled();
+  });
+});
diff --git a/exoplanethub.com/app/planet/[name]/opengraph-image.tsx b/exoplanethub.com/app/planet/[name]/opengraph-image.tsx
new file mode 100644
index 0000000..cf94e72
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/opengraph-image.tsx
@@ -0,0 +1,114 @@
+import { ImageResponse } from 'next/og';
+import { getPlanetDetail } from '@/lib/planetDetail';
+import { planetNameFromParam } from '@/lib/planetUrl';
+import { SHARE_IMAGE_SIZE } from '@/lib/shareImage';
+import { getTheme, SITE_THEME } from '@/lib/theme';
+import { shareCard, type ShareCardBadge } from './shareCard';
+
+export const revalidate = 3600;
+
+export const size = SHARE_IMAGE_SIZE;
+
+export const contentType = 'image/png';
+
+// Only the not-found card falls back to this; a found planet's alt is named in its page metadata.
+// generateImageMetadata could name it here, but it adds an /<id> segment and flips this route to SSG.
+export const alt = "ExoplanetHub — explore confirmed exoplanets from NASA's Exoplanet Archive";
+
+const { colors } = getTheme(SITE_THEME);
+
+interface OpenGraphImageProps {
+  params: Promise<{ name: string }>;
+}
+
+// next/og ships a single Geist face, so the card's hierarchy is size, colour and shape — never weight.
+export default async function OpenGraphImage({ params }: OpenGraphImageProps) {
+  const planetName = planetNameFromParam((await params).name);
+  const { heading, headingSize, subheading, facts, badge } = shareCard(
+    planetName === null ? null : await getPlanetDetail(planetName)
+  );
+
+  return new ImageResponse(
+    (
+      <div
+        style={{
+          display: 'flex',
+          flexDirection: 'column',
+          width: '100%',
+          height: '100%',
+          color: colors.text,
+          backgroundColor: colors.background,
+          backgroundImage: `linear-gradient(135deg, ${colors.background} 0%, ${colors.surfaceAlt} 50%, ${colors.surface} 100%)`,
+        }}
+      >
+        <div
+          style={{
+            display: 'flex',
+            height: 14,
+            backgroundImage: `linear-gradient(90deg, ${colors.primary}, ${colors.accent})`,
+          }}
+        />
+
+        <div
+          style={{
+            display: 'flex',
+            flexDirection: 'column',
+            flexGrow: 1,
+            justifyContent: 'space-between',
+            padding: '56px 64px 64px',
+          }}
+        >
+          <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+            <span style={{ fontSize: 28, letterSpacing: 6, color: colors.primary }}>
+              EXOPLANETHUB
+            </span>
+            <Badge badge={badge} />
+          </div>
+
+          <div style={{ display: 'flex', flexDirection: 'column' }}>
+            <div style={{ fontSize: headingSize, lineHeight: 1.1 }}>{heading}</div>
+            <div style={{ fontSize: 38, marginTop: 18, color: colors.textMuted }}>{subheading}</div>
+          </div>
+
+          <div style={{ display: 'flex', gap: 20 }}>
+            {facts.map((fact) => (
+              <div
+                key={fact}
+                style={{
+                  display: 'flex',
+                  fontSize: 32,
+                  padding: '14px 30px',
+                  borderRadius: 16,
+                  border: `2px solid ${colors.border}`,
+                  backgroundColor: colors.surface,
+                }}
+              >
+                {fact}
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+    ),
+    size
+  );
+}
+
+function Badge({ badge }: { badge: ShareCardBadge | null }) {
+  if (badge === null) return null;
+
+  return (
+    <div
+      style={{
+        display: 'flex',
+        fontSize: 30,
+        padding: '12px 30px',
+        borderRadius: 999,
+        backgroundColor: badge.background,
+        color: badge.color,
+      }}
+    >
+      {badge.text}
+    </div>
+  );
+}
diff --git a/exoplanethub.com/app/planet/[name]/page.module.css b/exoplanethub.com/app/planet/[name]/page.module.css
new file mode 100644
index 0000000..e9ccbf0
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/page.module.css
@@ -0,0 +1,176 @@
+.page {
+  min-height: 100vh;
+  background: var(--color-background);
+  padding: 120px 24px 64px;
+}
+
+.container {
+  max-width: 900px;
+  margin: 0 auto;
+}
+
+.header {
+  margin: 0 0 40px;
+  text-align: center;
+}
+
+.title {
+  font-family: var(--font-heading);
+  font-size: 48px;
+  font-weight: 700;
+  color: var(--color-text);
+  margin: 0 0 12px;
+}
+
+.summary {
+  font-size: 18px;
+  line-height: 1.6;
+  color: var(--color-text-muted);
+  margin: 0;
+}
+
+.sections {
+  display: flex;
+  flex-direction: column;
+  gap: 24px;
+}
+
+.stats {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  gap: 20px 32px;
+}
+
+.stat {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.statLabel {
+  font-size: 13px;
+  font-weight: 600;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--color-text-muted);
+}
+
+.statValue {
+  font-size: 17px;
+  line-height: 1.4;
+  color: var(--color-text);
+}
+
+.comparisons {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.comparison {
+  display: grid;
+  grid-template-columns: 120px 1fr;
+  gap: 4px 24px;
+  align-items: baseline;
+}
+
+.comparisonDetail {
+  font-size: 17px;
+  line-height: 1.5;
+  color: var(--color-text);
+  margin: 0;
+}
+
+@media (max-width: 560px) {
+  .comparison {
+    grid-template-columns: 1fr;
+  }
+}
+
+.provenance {
+  margin: 32px 0 0;
+  font-size: 14px;
+  line-height: 1.6;
+  color: var(--color-text-muted);
+  text-align: center;
+}
+
+.provenanceLink {
+  color: var(--color-primary);
+  font-weight: 600;
+  text-decoration: underline;
+}
+
+.provenanceLink:hover {
+  color: var(--color-accent);
+}
+
+.provenanceLink:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 3px;
+}
+
+.actions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: 12px;
+}
+
+.action {
+  display: block;
+  width: fit-content;
+  margin: 0 auto;
+  padding: 12px 24px;
+  background: var(--color-primary);
+  border: 1px solid var(--color-primary);
+  border-radius: 8px;
+  color: var(--color-primary-contrast);
+  font-family: inherit;
+  font-size: 16px;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.actions .action {
+  margin: 0;
+}
+
+.action:hover {
+  background: var(--color-accent);
+  border-color: var(--color-accent);
+}
+
+.actionQuiet {
+  background: transparent;
+  border-color: var(--color-border);
+  color: var(--color-text);
+}
+
+.actionQuiet:hover {
+  background: var(--color-surface);
+  border-color: var(--color-primary);
+  color: var(--color-text);
+}
+
+.action:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 3px;
+}
+
+.visuallyHidden {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  margin: -1px;
+  padding: 0;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+}
+
+@media (max-width: 768px) {
+  .title {
+    font-size: 32px;
+  }
+}
diff --git a/exoplanethub.com/app/planet/[name]/page.test.tsx b/exoplanethub.com/app/planet/[name]/page.test.tsx
new file mode 100644
index 0000000..cfd8823
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/page.test.tsx
@@ -0,0 +1,293 @@
+import { render, screen, within } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getESIBand } from '@/components/explore/esiBands';
+import type { Planet } from '@/lib/mockPlanets';
+import PlanetPage, { generateMetadata } from './page';
+
+const { NotFoundSignal, getPlanetDetail } = vi.hoisted(() => ({
+  NotFoundSignal: class NotFoundSignal extends Error {},
+  getPlanetDetail: vi.fn(),
+}));
+
+vi.mock('next/navigation', () => ({
+  notFound: () => {
+    throw new NotFoundSignal('NEXT_NOT_FOUND');
+  },
+}));
+
+vi.mock('@/lib/planetDetail', () => ({ getPlanetDetail }));
+
+const NAME_ONLY: Planet = {
+  pl_name: 'HD 000001 b',
+  hostname: null,
+  sy_snum: null,
+  sy_pnum: null,
+  sy_dist: null,
+  discoverymethod: null,
+  disc_year: null,
+  disc_facility: null,
+  pl_orbper: null,
+  pl_orbsmax: null,
+  pl_rade: null,
+  pl_bmasse: null,
+  pl_dens: null,
+  pl_eqt: null,
+  pl_insol: null,
+  st_teff: null,
+  st_rad: null,
+  st_mass: null,
+  st_logg: null,
+  st_age: null,
+  last_updated: '2026-08-30T06:00:00Z',
+};
+
+const KEPLER_452B: Planet = {
+  ...NAME_ONLY,
+  pl_name: 'Kepler-452 b',
+  hostname: 'Kepler-452',
+  sy_snum: 1,
+  sy_pnum: 1,
+  sy_dist: 551.7,
+  discoverymethod: 'Transit',
+  disc_year: 2015,
+  disc_facility: 'Kepler',
+  pl_orbper: 384.843,
+  pl_orbsmax: 1.046,
+  pl_rade: 1.63,
+  pl_eqt: 265,
+  pl_insol: 1.1,
+  st_teff: 5757,
+  st_rad: 1.11,
+  st_mass: 1.04,
+  st_age: 6,
+  esi: 83,
+};
+
+async function renderPage(segment: string) {
+  render(await PlanetPage({ params: Promise.resolve({ name: segment }) }));
+}
+
+function sectionNamed(title: string) {
+  return screen.getByRole('region', { name: title });
+}
+
+function statValue(section: string, label: string) {
+  return within(sectionNamed(section)).getByText(label, { selector: 'dt' }).nextElementSibling;
+}
+
+function comparisonDetail(aspect: string) {
+  return statValue('Compared with Earth', aspect);
+}
+
+beforeEach(() => {
+  getPlanetDetail.mockReset();
+});
+
+describe('PlanetPage', () => {
+  beforeEach(() => {
+    getPlanetDetail.mockResolvedValue(KEPLER_452B);
+  });
+
+  it('looks the planet up by the decoded name, not the URL segment', async () => {
+    await renderPage('Kepler-452%20b');
+
+    expect(getPlanetDetail).toHaveBeenCalledWith('Kepler-452 b');
+  });
+
+  it('titles the page with the planet and names no other top-level heading', async () => {
+    await renderPage('Kepler-452%20b');
+
+    expect(screen.getAllByRole('heading', { level: 1 })).toHaveLength(1);
+    expect(screen.getByRole('heading', { level: 1 })).toHaveTextContent('Kepler-452 b');
+  });
+
+  it('groups the profile under second-level section headings', async () => {
+    await renderPage('Kepler-452%20b');
+
+    expect(screen.getAllByRole('heading', { level: 2 }).map((h) => h.textContent)).toEqual([
+      'Compared with Earth',
+      'Planet',
+      'Star',
+      'System',
+      'Discovery',
+    ]);
+  });
+
+  // PageSection derives every heading id from the section id, so labelling cannot drift or collide.
+  it('exposes each section as a region named by its own heading', async () => {
+    await renderPage('Kepler-452%20b');
+
+    const headings = screen.getAllByRole('heading', { level: 2 });
+    const regions = screen.getAllByRole('region');
+
+    expect(regions).toHaveLength(headings.length);
+    regions.forEach((region, index) => {
+      expect(headings[index].id).not.toBe('');
+      expect(region).toHaveAttribute('aria-labelledby', headings[index].id);
+    });
+  });
+
+  it.each([
+    ['Planet', 'Radius', '1.63 × Earth'],
+    ['Planet', 'Orbital period', '384.8 days'],
+    ['Star', 'Host star', 'Kepler-452'],
+    ['Star', 'Spectral class', 'G — sun-like'],
+    ['System', 'Distance from Earth', '1,799 light-years (551.7 parsecs)'],
+    ['Discovery', 'Year', '2015'],
+    ['Discovery', 'Facility', 'Kepler'],
+  ])('pairs %s / %s with its value for a screen reader', async (section, label, value) => {
+    await renderPage('Kepler-452%20b');
+
+    expect(statValue(section, label)).toHaveTextContent(value);
+  });
+
+  it('badges the ESI score with the band label from the shared thresholds', async () => {
+    await renderPage('Kepler-452%20b');
+
+    const badge = screen.getByRole('button', { name: /^ESI 83, / });
+    expect(badge).toHaveTextContent('ESI 83');
+    expect(badge).toHaveTextContent(getESIBand(83).label);
+  });
+
+  it.each([
+    ['Size', "About 1.6 times Earth's width."],
+    ['Temperature', 'About -8 °C (17 °F) from starlight alone'],
+    ['Starlight', 'About 1.1 times the starlight Earth gets from the Sun.'],
+    ['Year', 'A year here lasts about 1.1 Earth years.'],
+  ])('pairs the %s comparison with its plain-language reading', async (aspect, detail) => {
+    await renderPage('Kepler-452%20b');
+
+    expect(comparisonDetail(aspect)).toHaveTextContent(detail);
+  });
+
+  it('leaves out the mass comparison the archive cannot support', async () => {
+    await renderPage('Kepler-452%20b');
+
+    expect(within(sectionNamed('Compared with Earth')).queryByText('Mass')).toBeNull();
+  });
+
+  it('says the star it orbits above the stats', async () => {
+    await renderPage('Kepler-452%20b');
+
+    expect(screen.getByText('A confirmed exoplanet orbiting Kepler-452.')).toBeInTheDocument();
+  });
+
+  it('credits the archive and dates the record', async () => {
+    await renderPage('Kepler-452%20b');
+
+    const credit = screen.getByRole('link', { name: 'NASA Exoplanet Archive' });
+    expect(credit).toHaveAttribute('href', 'https://exoplanetarchive.ipac.caltech.edu/');
+    expect(credit.parentElement).toHaveTextContent('synced August 30, 2026');
+  });
+
+  it('reads the item once per render', async () => {
+    await renderPage('Kepler-452%20b');
+
+    expect(getPlanetDetail).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('PlanetPage with unmeasured fields', () => {
+  beforeEach(() => {
+    getPlanetDetail.mockResolvedValue(NAME_ONLY);
+  });
+
+  it('still renders every row, marked unknown rather than collapsed', async () => {
+    await renderPage('HD%20000001%20b');
+
+    expect(screen.getAllByRole('definition')).toHaveLength(19);
+    expect(screen.getAllByText('Unknown')).toHaveLength(19);
+  });
+
+  it.each(['undefined', 'NaN', 'null'])('never prints %s as a value', async (leak) => {
+    await renderPage('HD%20000001%20b');
+
+    expect(screen.queryByText(leak)).toBeNull();
+  });
+
+  it('omits the comparison block entirely rather than framing an empty one', async () => {
+    await renderPage('HD%20000001%20b');
+
+    expect(screen.queryByRole('region', { name: 'Compared with Earth' })).toBeNull();
+  });
+
+  it('shows no ESI badge for a planet the sync could not score', async () => {
+    await renderPage('HD%20000001%20b');
+
+    expect(screen.queryByRole('button', { name: /^ESI /i })).toBeNull();
+  });
+
+  it('drops the host-star clause instead of naming an unknown star', async () => {
+    await renderPage('HD%20000001%20b');
+
+    expect(screen.getByText('A confirmed exoplanet.')).toBeInTheDocument();
+  });
+});
+
+describe('PlanetPage misses', () => {
+  it('renders the not-found page when the archive has no such planet', async () => {
+    getPlanetDetail.mockResolvedValue(null);
+
+    await expect(renderPage('Definitely%20Not%20A%20Planet%20b')).rejects.toBeInstanceOf(
+      NotFoundSignal
+    );
+  });
+
+  it.each(['%ZZ', ''])(
+    'renders the not-found page for the malformed segment "%s" without reading the table',
+    async (segment) => {
+      await expect(renderPage(segment)).rejects.toBeInstanceOf(NotFoundSignal);
+      expect(getPlanetDetail).not.toHaveBeenCalled();
+    }
+  );
+
+  // A throttled or broken read is not a missing planet; a cached 404 would outlive the outage.
+  it('lets a read failure surface instead of cacheing it as a 404', async () => {
+    getPlanetDetail.mockRejectedValue(new Error('ProvisionedThroughputExceededException'));
+
+    await expect(renderPage('Kepler-452%20b')).rejects.toThrow(
+      'ProvisionedThroughputExceededException'
+    );
+  });
+});
+
+describe('PlanetPage metadata', () => {
+  it('titles and describes the planet rather than inheriting the site defaults', async () => {
+    getPlanetDetail.mockResolvedValue(KEPLER_452B);
+
+    const metadata = await generateMetadata({ params: Promise.resolve({ name: 'Kepler-452%20b' }) });
+
+    expect(metadata.title).toBe('Kepler-452 b — Exoplanet Profile | ExoplanetHub');
+    expect(metadata.description).toContain("1.63\u00d7 Earth's radius");
+  });
+
+  // Both entry points resolve to the same key, which is what lets planetDetail's cache() serve
+  // the title and the body from one GetItem.
+  it('asks for the same planet when titling as when rendering', async () => {
+    getPlanetDetail.mockResolvedValue(KEPLER_452B);
+    const params = Promise.resolve({ name: 'Kepler-452%20b' });
+
+    await generateMetadata({ params });
+    render(await PlanetPage({ params }));
+
+    expect(getPlanetDetail.mock.calls).toEqual([['Kepler-452 b'], ['Kepler-452 b']]);
+  });
+
+  it('describes the 404 for an unstocked name instead of throwing', async () => {
+    getPlanetDetail.mockResolvedValue(null);
+
+    const metadata = await generateMetadata({
+      params: Promise.resolve({ name: 'Definitely%20Not%20A%20Planet%20b' }),
+    });
+
+    expect(metadata.title).toBe('Planet not found | ExoplanetHub');
+    expect(metadata.robots).toMatchObject({ index: false });
+  });
+
+  it('describes the 404 for a malformed segment without reading the table', async () => {
+    const metadata = await generateMetadata({ params: Promise.resolve({ name: '%ZZ' }) });
+
+    expect(metadata.title).toBe('Planet not found | ExoplanetHub');
+    expect(getPlanetDetail).not.toHaveBeenCalled();
+  });
+});
diff --git a/exoplanethub.com/app/planet/[name]/page.tsx b/exoplanethub.com/app/planet/[name]/page.tsx
new file mode 100644
index 0000000..10dc007
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/page.tsx
@@ -0,0 +1,115 @@
+import type { Metadata } from 'next';
+import { notFound } from 'next/navigation';
+import ESIBadge from '@/components/explore/ESIBadge';
+import { earthComparisons, type EarthComparison } from '@/lib/earthComparison';
+import type { Planet } from '@/lib/mockPlanets';
+import { getPlanetDetail } from '@/lib/planetDetail';
+import { planetMetadata } from '@/lib/planetMetadata';
+import { planetNameFromParam } from '@/lib/planetUrl';
+import { planetStatSections, type PlanetStatSection } from '@/lib/planetStats';
+import PageSection from './PageSection';
+import styles from './page.module.css';
+
+export const revalidate = 3600;
+
+const ARCHIVE_URL = 'https://exoplanetarchive.ipac.caltech.edu/';
+
+const SYNC_DATE = new Intl.DateTimeFormat('en-US', { dateStyle: 'long', timeZone: 'UTC' });
+
+interface PlanetPageProps {
+  params: Promise<{ name: string }>;
+}
+
+// A malformed segment and an unstocked name are the same answer, so callers get one null.
+async function loadPlanet(params: PlanetPageProps['params']): Promise<Planet | null> {
+  const planetName = planetNameFromParam((await params).name);
+  return planetName === null ? null : getPlanetDetail(planetName);
+}
+
+// getPlanetDetail is cache()d, so titling the page and rendering it share one GetItem.
+export async function generateMetadata({ params }: PlanetPageProps): Promise<Metadata> {
+  return planetMetadata(await loadPlanet(params));
+}
+
+export default async function PlanetPage({ params }: PlanetPageProps) {
+  const planet = await loadPlanet(params);
+  if (planet === null) notFound();
+
+  return (
+    <main className={styles.page}>
+      <article className={styles.container}>
+        <header className={styles.header}>
+          <h1 className={styles.title}>{planet.pl_name}</h1>
+          <p className={styles.summary}>
+            {planet.hostname
+              ? `A confirmed exoplanet orbiting ${planet.hostname}.`
+              : 'A confirmed exoplanet.'}
+          </p>
+          <ESIBadge score={planet.esi} variant="page" />
+        </header>
+
+        <div className={styles.sections}>
+          <EarthComparisonSection comparisons={earthComparisons(planet)} />
+          {planetStatSections(planet).map((section) => (
+            <StatSection key={section.id} section={section} />
+          ))}
+        </div>
+
+        <p className={styles.provenance}>
+          Data from the{' '}
+          <a className={styles.provenanceLink} href={ARCHIVE_URL} target="_blank" rel="noopener noreferrer">
+            NASA Exoplanet Archive
+          </a>
+          {describeSync(planet.last_updated)}
+        </p>
+      </article>
+    </main>
+  );
+}
+
+function EarthComparisonSection({ comparisons }: { comparisons: EarthComparison[] }) {
+  if (comparisons.length === 0) return null;
+
+  return (
+    <PageSection id="earth-comparison" title="Compared with Earth">
+      <dl className={styles.comparisons}>
+        {comparisons.map(({ aspect, detail }) => (
+          <div key={aspect} className={styles.comparison}>
+            <dt className={styles.statLabel}>{aspect}</dt>
+            <dd className={styles.comparisonDetail}>{detail}</dd>
+          </div>
+        ))}
+      </dl>
+    </PageSection>
+  );
+}
+
+function StatSection({ section }: { section: PlanetStatSection }) {
+  return (
+    <PageSection id={section.id} title={section.title}>
+      <dl className={styles.stats}>
+        {section.stats.map(({ label, value }) => (
+          <div key={label} className={styles.stat}>
+            <dt className={styles.statLabel}>{label}</dt>
+            <dd className={styles.statValue}>{value ?? <Unknown />}</dd>
+          </div>
+        ))}
+      </dl>
+    </PageSection>
+  );
+}
+
+// A bare em dash is silence to a screen reader, so the two audiences get separate copy.
+function Unknown() {
+  return (
+    <>
+      <span aria-hidden="true">—</span>
+      <span className={styles.visuallyHidden}>Unknown</span>
+    </>
+  );
+}
+
+function describeSync(lastUpdated: string): string {
+  const synced = new Date(lastUpdated);
+  return Number.isNaN(synced.getTime()) ? '.' : `, synced ${SYNC_DATE.format(synced)}.`;
+}
diff --git a/exoplanethub.com/app/planet/[name]/shareCard.test.ts b/exoplanethub.com/app/planet/[name]/shareCard.test.ts
new file mode 100644
index 0000000..5e30594
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/shareCard.test.ts
@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import { getESIBand } from '@/components/explore/esiBands';
+import type { Planet } from '@/lib/mockPlanets';
+import { getTheme, SITE_THEME } from '@/lib/theme';
+import { shareCard } from './shareCard';
+
+const UNMEASURED: Planet = {
+  pl_name: 'HD 000001 b',
+  hostname: null,
+  sy_snum: null,
+  sy_pnum: null,
+  sy_dist: null,
+  discoverymethod: null,
+  disc_year: null,
+  disc_facility: null,
+  pl_orbper: null,
+  pl_orbsmax: null,
+  pl_rade: null,
+  pl_bmasse: null,
+  pl_dens: null,
+  pl_eqt: null,
+  pl_insol: null,
+  st_teff: null,
+  st_rad: null,
+  st_mass: null,
+  st_logg: null,
+  st_age: null,
+  last_updated: '2026-01-01T00:00:00Z',
+};
+
+function cardFor(planet: Partial<Planet>) {
+  return shareCard({ ...UNMEASURED, ...planet });
+}
+
+describe('shareCard', () => {
+  it('leads with the planet name and the star it orbits', () => {
+    const card = cardFor({ pl_name: 'Kepler-452 b', hostname: 'Kepler-452' });
+
+    expect(card.heading).toBe('Kepler-452 b');
+    expect(card.subheading).toBe('Orbiting Kepler-452');
+  });
+
+  it.each([null, '', '   '])('names no star when the archive stored %o for the host', (hostname) => {
+    expect(cardFor({ hostname }).subheading).toBe('A confirmed exoplanet');
+  });
+
+  it('quotes distance and discovery year in the same words the profile page uses', () => {
+    const card = cardFor({ sy_dist: 551.7, disc_year: 2015 });
+
+    expect(card.facts).toEqual(['1,799 light-years away', 'Discovered in 2015']);
+  });
+
+  it('drops a fact the archive never measured rather than captioning it unknown', () => {
+    expect(cardFor({ disc_year: 2015 }).facts).toEqual(['Discovered in 2015']);
+    expect(cardFor({}).facts).toEqual([]);
+  });
+
+  it('paints the ESI badge with the theme colours of the band the score falls in', () => {
+    const { colors } = getTheme(SITE_THEME);
+
+    expect(cardFor({ esi: 83 }).badge).toEqual({
+      text: `ESI 83 · ${getESIBand(83).label}`,
+      background: colors.esiBand2,
+      color: colors.esiBand2Text,
+    });
+  });
+
+  it.each([undefined, Number.NaN])('omits the badge when the stored ESI is %o', (esi) => {
+    expect(cardFor({ esi }).badge).toBeNull();
+  });
+
+  it('gives a name the archive does not stock a branded card instead of an error', () => {
+    const card = shareCard(null);
+
+    expect(card.heading).toBe('Explore exoplanets');
+    expect(card.facts).toEqual([]);
+    expect(card.badge).toBeNull();
+  });
+
+  it('shrinks the heading as the designation lengthens, so it stays on one line', () => {
+    const sizes = ['Kepler-452 b', 'OGLE-2016-BLG-1195L b', '2MASS J04414489+2301513 b'].map(
+      (pl_name) => cardFor({ pl_name }).headingSize
+    );
+
+    expect(sizes).toEqual([...sizes].sort((a, b) => b - a));
+    expect(new Set(sizes).size).toBe(sizes.length);
+  });
+
+  it('settles on the smallest step for any designation longer than the steps cover', () => {
+    expect(cardFor({ pl_name: 'x'.repeat(80) }).headingSize).toBe(
+      cardFor({ pl_name: 'x'.repeat(40) }).headingSize
+    );
+  });
+});
diff --git a/exoplanethub.com/app/planet/[name]/shareCard.ts b/exoplanethub.com/app/planet/[name]/shareCard.ts
new file mode 100644
index 0000000..077605f
--- /dev/null
+++ b/exoplanethub.com/app/planet/[name]/shareCard.ts
@@ -0,0 +1,77 @@
+import { getESIBand } from '@/components/explore/esiBands';
+import type { Planet } from '@/lib/mockPlanets';
+import { discoveredIn, lightYearsAway } from '@/lib/planetStats';
+import { getTheme, SITE_THEME } from '@/lib/theme';
+
+const { colors } = getTheme(SITE_THEME);
+
+export interface ShareCardBadge {
+  text: string;
+  background: string;
+  color: string;
+}
+
+export interface ShareCard {
+  heading: string;
+  headingSize: number;
+  subheading: string;
+  facts: string[];
+  badge: ShareCardBadge | null;
+}
+
+type ShareCardContent = Omit<ShareCard, 'headingSize'>;
+
+// Satori wraps text but never shrinks it, so a long designation has to be handed a smaller
+// hero to stay on one line across the card's 1072px of usable width.
+const HEADING_SIZES = [
+  { maxCharacters: 16, size: 104 },
+  { maxCharacters: 24, size: 80 },
+  { maxCharacters: 32, size: 62 },
+];
+
+const SMALLEST_HEADING_SIZE = 48;
+
+// An unfurl that shows the site is better than one that shows a broken image, so a name the
+// archive does not stock still gets a card.
+const UNKNOWN_PLANET: ShareCardContent = {
+  heading: 'Explore exoplanets',
+  subheading: "Confirmed worlds from NASA's Exoplanet Archive.",
+  facts: [],
+  badge: null,
+};
+
+export function shareCard(planet: Planet | null): ShareCard {
+  const content = planet === null ? UNKNOWN_PLANET : describePlanet(planet);
+
+  return { ...content, headingSize: headingSize(content.heading) };
+}
+
+function headingSize(heading: string): number {
+  const fitted = HEADING_SIZES.find(({ maxCharacters }) => heading.length <= maxCharacters);
+  return fitted?.size ?? SMALLEST_HEADING_SIZE;
+}
+
+function describePlanet(planet: Planet): ShareCardContent {
+  const host = planet.hostname?.trim();
+
+  return {
+    heading: planet.pl_name,
+    subheading: host ? `Orbiting ${host}` : 'A confirmed exoplanet',
+    facts: [lightYearsAway(planet.sy_dist), discoveredIn(planet.disc_year)].filter(
+      (fact): fact is string => fact !== null
+    ),
+    badge: esiBadge(planet.esi),
+  };
+}
+
+function esiBadge(score: number | undefined): ShareCardBadge | null {
+  if (typeof score !== 'number' || !Number.isFinite(score)) return null;
+
+  const { tier, label } = getESIBand(score);
+
+  return {
+    text: `ESI ${score} · ${label}`,
+    background: colors[`esiBand${tier}`],
+    color: colors[`esiBand${tier}Text`],
+  };
+}
diff --git a/exoplanethub.com/app/robots.test.ts b/exoplanethub.com/app/robots.test.ts
new file mode 100644
index 0000000..2454a29
--- /dev/null
+++ b/exoplanethub.com/app/robots.test.ts
@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import robots from '@/app/robots';
+import { SITE_ORIGIN } from '@/lib/site';
+
+describe('robots', () => {
+  // Relative sitemap URLs in robots.txt are ignored, and the origin must match the canonicals.
+  it('advertises the sitemap at its absolute canonical URL', () => {
+    expect(robots().sitemap).toBe(`${SITE_ORIGIN}/sitemap.xml`);
+  });
+
+  it('leaves the whole site crawlable', () => {
+    expect(robots().rules).toEqual({ userAgent: '*', allow: '/' });
+  });
+});
diff --git a/exoplanethub.com/app/robots.ts b/exoplanethub.com/app/robots.ts
new file mode 100644
index 0000000..fa1434a
--- /dev/null
+++ b/exoplanethub.com/app/robots.ts
@@ -0,0 +1,10 @@
+import type { MetadataRoute } from 'next';
+import { SITE_ORIGIN } from '@/lib/site';
+
+// Crawlers find the sitemap through robots.txt; they do not reliably probe /sitemap.xml.
+export default function robots(): MetadataRoute.Robots {
+  return {
+    rules: { userAgent: '*', allow: '/' },
+    sitemap: `${SITE_ORIGIN}/sitemap.xml`,
+  };
+}
diff --git a/exoplanethub.com/app/sitemap.test.ts b/exoplanethub.com/app/sitemap.test.ts
new file mode 100644
index 0000000..4fe4a53
--- /dev/null
+++ b/exoplanethub.com/app/sitemap.test.ts
@@ -0,0 +1,198 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Planet } from '@/lib/mockPlanets';
+import { planetMetadata } from '@/lib/planetMetadata';
+import { SITE_ORIGIN } from '@/lib/site';
+
+const { send, connection, unstableCache } = vi.hoisted(() => ({
+  send: vi.fn(),
+  connection: vi.fn(async () => {}),
+  unstableCache: vi.fn<(scan: unknown, keys: string[], options: { revalidate: number }) => unknown>(
+    (scan) => scan
+  ),
+}));
+
+vi.mock('@aws-sdk/client-dynamodb', () => ({
+  DynamoDBClient: class {},
+}));
+
+vi.mock('@aws-sdk/lib-dynamodb', () => ({
+  DynamoDBDocumentClient: { from: () => ({ send }) },
+  ScanCommand: class {
+    constructor(readonly input: Record<string, unknown>) {}
+  },
+}));
+
+vi.mock('next/server', () => ({ connection }));
+vi.mock('next/cache', () => ({ unstable_cache: unstableCache }));
+
+const STATIC_URLS = [
+  'https://www.exoplanethub.com/',
+  'https://www.exoplanethub.com/explore',
+  'https://www.exoplanethub.com/about',
+  'https://www.exoplanethub.com/contact',
+];
+
+// planetMetadata reads the whole item, so the canonical cross-check needs every field present.
+const UNMEASURED_PLANET: Omit<Planet, 'pl_name'> = {
+  hostname: null,
+  sy_snum: null,
+  sy_pnum: null,
+  sy_dist: null,
+  discoverymethod: null,
+  disc_year: null,
+  disc_facility: null,
+  pl_orbper: null,
+  pl_orbsmax: null,
+  pl_rade: null,
+  pl_bmasse: null,
+  pl_dens: null,
+  pl_eqt: null,
+  pl_insol: null,
+  st_teff: null,
+  st_rad: null,
+  st_mass: null,
+  st_logg: null,
+  st_age: null,
+  last_updated: '2026-08-30T06:00:00Z',
+};
+
+// Re-evaluates the module graph, so a table name captured at import still reflects env set in the test body.
+async function loadSitemap() {
+  vi.resetModules();
+  return (await import('@/app/sitemap')).default();
+}
+
+function scanInputs() {
+  return send.mock.calls.map(([command]) => command.input as Record<string, unknown>);
+}
+
+// Resolves the '#alias, #alias' projection back to the attribute names DynamoDB will actually return.
+function projectedFields(input: Record<string, unknown>) {
+  const names = input.ExpressionAttributeNames as Record<string, string>;
+  return (input.ProjectionExpression as string).split(', ').map((alias) => names[alias]);
+}
+
+function planetUrls(entries: Awaited<ReturnType<typeof loadSitemap>>) {
+  return entries.map((entry) => entry.url).filter((url) => !STATIC_URLS.includes(url));
+}
+
+beforeEach(() => {
+  send.mockReset();
+  connection.mockClear();
+  unstableCache.mockClear();
+});
+
+describe('sitemap', () => {
+  it('lists the hand-written pages ahead of the archive', async () => {
+    send.mockResolvedValue({ Items: [{ pl_name: 'Kepler-22 b' }] });
+
+    const entries = await loadSitemap();
+
+    expect(entries.slice(0, 4).map((entry) => entry.url)).toEqual(STATIC_URLS);
+  });
+
+  it('emits one absolute URL per archived planet', async () => {
+    send.mockResolvedValue({ Items: [{ pl_name: 'Kepler-22 b' }, { pl_name: 'TRAPPIST-1 e' }] });
+
+    expect(planetUrls(await loadSitemap())).toEqual([
+      'https://www.exoplanethub.com/planet/Kepler-22%20b',
+      'https://www.exoplanethub.com/planet/TRAPPIST-1%20e',
+    ]);
+  });
+
+  it.each([
+    ['Kepler-16 b', 'https://www.exoplanethub.com/planet/Kepler-16%20b'],
+    ['HD 189733 A+b', 'https://www.exoplanethub.com/planet/HD%20189733%20A%2Bb'],
+  ])('encodes %s so the URL resolves to that planet', async (name, expected) => {
+    send.mockResolvedValue({ Items: [{ pl_name: name }] });
+
+    expect(planetUrls(await loadSitemap())).toEqual([expected]);
+  });
+
+  it('emits the URL the planet page declares as its canonical', async () => {
+    const pl_name = 'Kepler-16 b';
+    send.mockResolvedValue({ Items: [{ pl_name }] });
+    const canonical = planetMetadata({ pl_name, ...UNMEASURED_PLANET }).alternates?.canonical;
+
+    expect(planetUrls(await loadSitemap())[0]).toBe(new URL(String(canonical), SITE_ORIGIN).href);
+  });
+
+  it('serves an empty archive as the static pages alone rather than failing', async () => {
+    send.mockResolvedValue({});
+
+    expect((await loadSitemap()).map((entry) => entry.url)).toEqual(STATIC_URLS);
+  });
+});
+
+describe('sitemap freshness', () => {
+  // The sync stamps every row with one per-run timestamp, so last_updated cannot date an
+  // individual planet and a <lastmod> built from it would be false for ~6k URLs at once.
+  it('dates no URL, because the archive records no per-planet modification time', async () => {
+    send.mockResolvedValue({
+      Items: [{ pl_name: 'Kepler-22 b', last_updated: '2026-08-30T06:00:00Z' }],
+    });
+
+    const entries = await loadSitemap();
+
+    expect(entries.every((entry) => entry.lastModified === undefined)).toBe(true);
+  });
+
+  it('rescans at the cadence the planet pages revalidate on', async () => {
+    send.mockResolvedValue({ Items: [] });
+
+    await loadSitemap();
+
+    expect(unstableCache.mock.calls[0][2]).toEqual({ revalidate: 3600 });
+  });
+
+  it('defers the scan to request time so a credential-less build cannot bake a planet-less sitemap', async () => {
+    send.mockResolvedValue({ Items: [] });
+
+    await loadSitemap();
+
+    expect(connection).toHaveBeenCalled();
+  });
+});
+
+describe('sitemap scan', () => {
+  it('follows LastEvaluatedKey until every planet is listed', async () => {
+    send
+      .mockResolvedValueOnce({ Items: [{ pl_name: 'Kepler-22 b' }], LastEvaluatedKey: { pl_name: 'Kepler-22 b' } })
+      .mockResolvedValueOnce({ Items: [{ pl_name: 'TRAPPIST-1 e' }], LastEvaluatedKey: { pl_name: 'TRAPPIST-1 e' } })
+      .mockResolvedValueOnce({ Items: [{ pl_name: 'Proxima Cen b' }] });
+
+    expect(planetUrls(await loadSitemap())).toEqual([
+      'https://www.exoplanethub.com/planet/Kepler-22%20b',
+      'https://www.exoplanethub.com/planet/TRAPPIST-1%20e',
+      'https://www.exoplanethub.com/planet/Proxima%20Cen%20b',
+    ]);
+    expect(send).toHaveBeenCalledTimes(3);
+    expect(scanInputs()[1].ExclusiveStartKey).toEqual({ pl_name: 'Kepler-22 b' });
+    expect(scanInputs()[2].ExclusiveStartKey).toEqual({ pl_name: 'TRAPPIST-1 e' });
+  });
+
+  it('projects only the attribute a URL entry needs', async () => {
+    send.mockResolvedValue({ Items: [] });
+
+    await loadSitemap();
+
+    expect(projectedFields(scanInputs()[0])).toEqual(['pl_name']);
+  });
+
+  it('scans the table named by EXOPLANETS_DATABASE_TABLE', async () => {
+    process.env.EXOPLANETS_DATABASE_TABLE = 'exoplanets-prod';
+    send.mockResolvedValue({ Items: [] });
+
+    await loadSitemap();
+    delete process.env.EXOPLANETS_DATABASE_TABLE;
+
+    expect(scanInputs()[0].TableName).toBe('exoplanets-prod');
+  });
+
+  it('propagates a scan failure rather than publishing a truncated sitemap', async () => {
+    send.mockRejectedValue(new Error('ProvisionedThroughputExceededException'));
+
+    await expect(loadSitemap()).rejects.toThrow('ProvisionedThroughputExceededException');
+  });
+});
diff --git a/exoplanethub.com/app/sitemap.ts b/exoplanethub.com/app/sitemap.ts
new file mode 100644
index 0000000..066b700
--- /dev/null
+++ b/exoplanethub.com/app/sitemap.ts
@@ -0,0 +1,28 @@
+import type { MetadataRoute } from 'next';
+import { unstable_cache } from 'next/cache';
+import { connection } from 'next/server';
+import { scanAllPlanets } from '@/lib/dynamo';
+import { planetUrl } from '@/lib/planetUrl';
+import { SITE_ORIGIN } from '@/lib/site';
+
+const REVALIDATE_SECONDS = 3600;
+
+const STATIC_PATHS = ['/', '/explore', '/about', '/contact'];
+
+// Bounds a public endpoint that would otherwise Scan ~6k items on every crawler request.
+const cachedPlanetNames = unstable_cache(() => scanAllPlanets(['pl_name']), ['sitemap-planet-urls'], {
+  revalidate: REVALIDATE_SECONDS,
+});
+
+// No <lastmod>: last_updated stamps every row on each sync run, so it would date ~6k URLs
+// identically and advance four times a day whether or not the planet changed.
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  // Defers the Scan to request time: a deploy without Dynamo access must not bake a planet-less sitemap.
+  await connection();
+
+  const planets = await cachedPlanetNames();
+
+  return [...STATIC_PATHS, ...planets.map(({ pl_name }) => planetUrl(pl_name))].map((path) => ({
+    url: `${SITE_ORIGIN}${path}`,
+  }));
+}
diff --git a/exoplanethub.com/components/explore/CheckboxGroup.module.css b/exoplanethub.com/components/explore/CheckboxGroup.module.css
new file mode 100644
index 0000000..ff2b31c
--- /dev/null
+++ b/exoplanethub.com/components/explore/CheckboxGroup.module.css
@@ -0,0 +1,53 @@
+.group {
+  border: none;
+  padding: 0;
+  margin: 0;
+  min-width: 0;
+}
+
+.legend {
+  padding: 0 0 8px;
+  color: var(--color-text-muted);
+  font-size: 13px;
+}
+
+.options {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.option {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: 999px;
+  padding: 8px 16px;
+  color: var(--color-text);
+  font-size: 14px;
+  cursor: pointer;
+}
+
+.option input {
+  accent-color: var(--color-primary);
+  cursor: pointer;
+  margin: 0;
+}
+
+.option:hover,
+.option:has(input:checked) {
+  border-color: var(--color-primary);
+}
+
+.option:has(input:focus-visible) {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
+
+.note {
+  color: var(--color-text-muted);
+  font-size: 12px;
+  margin-top: 8px;
+}
diff --git a/exoplanethub.com/components/explore/CheckboxGroup.tsx b/exoplanethub.com/components/explore/CheckboxGroup.tsx
new file mode 100644
index 0000000..abb3eee
--- /dev/null
+++ b/exoplanethub.com/components/explore/CheckboxGroup.tsx
@@ -0,0 +1,44 @@
+'use client';
+import { useId } from 'react';
+import styles from './CheckboxGroup.module.css';
+
+interface CheckboxGroupProps<T extends string> {
+  legend: string;
+  options: readonly { value: T; label: string }[];
+  selected: readonly T[];
+  onToggle: (value: T, selected: boolean) => void;
+  note?: string;
+}
+
+export default function CheckboxGroup<T extends string>({
+  legend,
+  options,
+  selected,
+  onToggle,
+  note,
+}: CheckboxGroupProps<T>) {
+  const noteId = `${useId()}-note`;
+
+  return (
+    <fieldset className={styles.group} aria-describedby={note ? noteId : undefined}>
+      <legend className={styles.legend}>{legend}</legend>
+      <div className={styles.options}>
+        {options.map(({ value, label }) => (
+          <label key={value} className={styles.option}>
+            <input
+              type="checkbox"
+              checked={selected.includes(value)}
+              onChange={(event) => onToggle(value, event.target.checked)}
+            />
+            {label}
+          </label>
+        ))}
+      </div>
+      {note && (
+        <p className={styles.note} id={noteId}>
+          {note}
+        </p>
+      )}
+    </fieldset>
+  );
+}
diff --git a/exoplanethub.com/components/explore/ESIBadge.module.css b/exoplanethub.com/components/explore/ESIBadge.module.css
index 9c3d7d0..5645592 100644
--- a/exoplanethub.com/components/explore/ESIBadge.module.css
+++ b/exoplanethub.com/components/explore/ESIBadge.module.css
@@ -1,14 +1,8 @@
-/* Absolute so a card without a score reserves no space and its layout is untouched. */
 .badge {
-  position: absolute;
-  top: 16px;
-  right: 16px;
-  max-width: calc(100% - 32px);
   display: flex;
   flex-wrap: wrap;
   align-items: baseline;
   gap: 8px;
-  padding: 8px 14px;
   border: none;
   border-radius: 999px;
   cursor: pointer;
@@ -21,6 +15,27 @@
   transform: scale(1.04);
 }
 
+.badge:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
+
+/* Absolute so a card without a score reserves no space and its layout is untouched. */
+.card {
+  position: absolute;
+  top: 16px;
+  right: 16px;
+  max-width: calc(100% - 32px);
+  padding: 8px 14px;
+}
+
+.page {
+  display: inline-flex;
+  margin-top: 20px;
+  padding: 12px 22px;
+  gap: 12px;
+}
+
 .score {
   font-family: var(--font-heading);
   font-size: 16px;
@@ -33,3 +48,11 @@
   font-weight: 600;
   letter-spacing: 0.3px;
 }
+
+.page .score {
+  font-size: 22px;
+}
+
+.page .band {
+  font-size: 14px;
+}
diff --git a/exoplanethub.com/components/explore/ESIBadge.tsx b/exoplanethub.com/components/explore/ESIBadge.tsx
index 5fac847..6c0c4cd 100644
--- a/exoplanethub.com/components/explore/ESIBadge.tsx
+++ b/exoplanethub.com/components/explore/ESIBadge.tsx
@@ -6,9 +6,10 @@ import styles from './ESIBadge.module.css';
 
 interface ESIBadgeProps {
   score: number | undefined;
+  variant?: 'card' | 'page';
 }
 
-export default function ESIBadge({ score }: ESIBadgeProps) {
+export default function ESIBadge({ score, variant = 'card' }: ESIBadgeProps) {
   const [explainerOpen, setExplainerOpen] = useState(false);
 
   if (typeof score !== 'number') return null;
@@ -18,7 +19,7 @@ export default function ESIBadge({ score }: ESIBadgeProps) {
   return (
     <>
       <button
-        className={styles.badge}
+        className={`${styles.badge} ${styles[variant]}`}
         style={band.style}
         aria-label={`ESI ${score}, ${band.label}. What is the Earth Similarity Index?`}
         // The badge sits inside cards and rows that activate on click and on Enter/Space themselves.
diff --git a/exoplanethub.com/components/explore/ESIModal.module.css b/exoplanethub.com/components/explore/ESIModal.module.css
index ddc5ef6..8dcc700 100644
--- a/exoplanethub.com/components/explore/ESIModal.module.css
+++ b/exoplanethub.com/components/explore/ESIModal.module.css
@@ -1,42 +1,8 @@
-.overlay {
-  position: fixed;
-  inset: 0;
-  background: rgba(0, 0, 0, 0.8);
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  z-index: 1000;
-  padding: 24px;
-  animation: fadeIn 0.2s;
-}
-
-@keyframes fadeIn {
-  from { opacity: 0; }
-  to { opacity: 1; }
-}
-
-/* Scrolling lives on .content, not here: .closeBtn anchors to .modal and would scroll away with it. */
+/* Scrolling lives on .content, not here: .closeBtn anchors to the dialog and would scroll away with it. */
 .modal {
-  position: relative;
   display: flex;
   flex-direction: column;
-  background: var(--color-surface);
-  border: 1px solid var(--color-border);
-  border-radius: 16px;
-  max-width: 700px;
-  width: 100%;
-  max-height: 90vh;
   overflow: hidden;
-  animation: slideUp 0.3s;
-}
-
-.modal:focus {
-  outline: none;
-}
-
-@keyframes slideUp {
-  from { transform: translateY(20px); opacity: 0; }
-  to { transform: translateY(0); opacity: 1; }
 }
 
 .closeBtn {
diff --git a/exoplanethub.com/components/explore/ESIModal.tsx b/exoplanethub.com/components/explore/ESIModal.tsx
index ac0a901..e9d86fd 100644
--- a/exoplanethub.com/components/explore/ESIModal.tsx
+++ b/exoplanethub.com/components/explore/ESIModal.tsx
@@ -1,6 +1,5 @@
 'use client';
-import { useEffect, useRef } from 'react';
-import { createPortal } from 'react-dom';
+import ModalDialog from '@/components/ui/ModalDialog';
 import { ESI_BANDS } from './esiBands';
 import styles from './ESIModal.module.css';
 
@@ -8,142 +7,77 @@ interface ESIModalProps {
   onClose: () => void;
 }
 
-const FOCUSABLE = 'a[href], button:not([disabled]), [tabindex]:not([tabindex="-1"])';
-
 export default function ESIModal({ onClose }: ESIModalProps) {
-  const dialogRef = useRef<HTMLDivElement>(null);
-
-  useEffect(() => {
-    const trigger = document.activeElement as HTMLElement | null;
-    dialogRef.current?.focus();
-    return () => trigger?.focus();
-  }, []);
-
-  useEffect(() => {
-    // aria-modal only claims the rest of the page is inert; Tab has to be contained to make it true.
-    const handleKeyDown = (e: KeyboardEvent) => {
-      if (e.key === 'Escape') {
-        onClose();
-        return;
-      }
-      if (e.key !== 'Tab' || !dialogRef.current) return;
-
-      const stops = Array.from(dialogRef.current.querySelectorAll<HTMLElement>(FOCUSABLE));
-      if (stops.length === 0) return;
-
-      const first = stops[0];
-      const last = stops[stops.length - 1];
-      const leavingBackwards = e.shiftKey && (document.activeElement === first || document.activeElement === dialogRef.current);
-      const leavingForwards = !e.shiftKey && document.activeElement === last;
+  return (
+    <ModalDialog onClose={onClose} labelledBy="esi-modal-title" className={styles.modal}>
+      <button className={styles.closeBtn} onClick={onClose} aria-label="Close">×</button>
 
-      if (leavingBackwards) {
-        e.preventDefault();
-        last.focus();
-      } else if (leavingForwards) {
-        e.preventDefault();
-        first.focus();
-      }
-    };
+      <h2 id="esi-modal-title" className={styles.title}>Earth Similarity Index (ESI)</h2>
 
-    document.addEventListener('keydown', handleKeyDown);
-    document.body.style.overflow = 'hidden';
-
-    return () => {
-      document.removeEventListener('keydown', handleKeyDown);
-      document.body.style.overflow = 'unset';
-    };
-  }, [onClose]);
-
-  // Portalled because triggers sit inside cards that transform on hover, which would otherwise
-  // make the card the containing block for this fixed overlay and clip it to the card.
-  // Portalled events bubble the React tree, so the overlay must stop them reaching that card.
-  return createPortal(
-    <div
-      className={styles.overlay}
-      onClick={(e) => {
-        e.stopPropagation();
-        onClose();
-      }}
-    >
+      {/* Focusable because this, not .modal, is the scroll container — an unfocusable scroller cannot be scrolled by keyboard. */}
       <div
-        ref={dialogRef}
-        role="dialog"
-        aria-modal="true"
+        className={styles.content}
+        role="region"
         aria-labelledby="esi-modal-title"
-        tabIndex={-1}
-        className={styles.modal}
-        onClick={(e) => e.stopPropagation()}
+        tabIndex={0}
       >
-        <button className={styles.closeBtn} onClick={onClose} aria-label="Close">×</button>
-
-        <h2 id="esi-modal-title" className={styles.title}>Earth Similarity Index (ESI)</h2>
-
-        {/* Focusable because this, not .modal, is the scroll container — an unfocusable scroller cannot be scrolled by keyboard. */}
-        <div
-          className={styles.content}
-          role="region"
-          aria-labelledby="esi-modal-title"
-          tabIndex={0}
-        >
-          <p className={styles.intro}>
-            Our scores are based on the <strong>Earth Similarity Index (ESI)</strong>,
-            a peer-reviewed scientific metric that measures how similar a planet is to Earth in physical characteristics—not a guarantee of habitability.
+        <p className={styles.intro}>
+          Our scores are based on the <strong>Earth Similarity Index (ESI)</strong>,
+          a peer-reviewed scientific metric that measures how similar a planet is to Earth in physical characteristics—not a guarantee of habitability.
+        </p>
+
+        <div className={styles.section}>
+          <h3 className={styles.sectionTitle}>The Formula</h3>
+          <div className={styles.formula}>
+            ESI = [(Radius Component) × (Temperature Component) × (Mass Component)]^(1/n)
+          </div>
+          <p className={styles.description}>
+            Where n is the number of available components (2-3 depending on data availability)
           </p>
+        </div>
 
-          <div className={styles.section}>
-            <h3 className={styles.sectionTitle}>The Formula</h3>
-            <div className={styles.formula}>
-              ESI = [(Radius Component) × (Temperature Component) × (Mass Component)]^(1/n)
-            </div>
-            <p className={styles.description}>
-              Where n is the number of available components (2-3 depending on data availability)
-            </p>
-          </div>
+        <div className={styles.section}>
+          <h3 className={styles.sectionTitle}>Components</h3>
+          <ul className={styles.list}>
+            <li>
+              <strong>Radius:</strong> 1 - |((R_planet - R_earth) / (R_planet + R_earth))|
+            </li>
+            <li>
+              <strong>Temperature:</strong> 1 - |((T_planet - 288K) / (T_planet + 288K))|
+            </li>
+            <li>
+              <strong>Mass:</strong> 1 - |((M_planet - M_earth) / (M_planet + M_earth))|
+            </li>
+          </ul>
+        </div>
 
-          <div className={styles.section}>
-            <h3 className={styles.sectionTitle}>Components</h3>
-            <ul className={styles.list}>
-              <li>
-                <strong>Radius:</strong> 1 - |((R_planet - R_earth) / (R_planet + R_earth))|
-              </li>
-              <li>
-                <strong>Temperature:</strong> 1 - |((T_planet - 288K) / (T_planet + 288K))|
-              </li>
-              <li>
-                <strong>Mass:</strong> 1 - |((M_planet - M_earth) / (M_planet + M_earth))|
+        <div className={styles.section}>
+          <h3 className={styles.sectionTitle}>Score Interpretation</h3>
+          <ul className={styles.bandList} role="list" aria-label="Score bands">
+            {ESI_BANDS.map((band) => (
+              <li key={band.label} className={styles.bandItem}>
+                <span className={styles.bandRange} style={band.style}>{band.range}</span>
+                <span className={styles.bandText}>
+                  <strong>{band.label}</strong> — {band.description}
+                </span>
               </li>
-            </ul>
-          </div>
-
-          <div className={styles.section}>
-            <h3 className={styles.sectionTitle}>Score Interpretation</h3>
-            <ul className={styles.bandList} role="list" aria-label="Score bands">
-              {ESI_BANDS.map((band) => (
-                <li key={band.label} className={styles.bandItem}>
-                  <span className={styles.bandRange} style={band.style}>{band.range}</span>
-                  <span className={styles.bandText}>
-                    <strong>{band.label}</strong> — {band.description}
-                  </span>
-                </li>
-              ))}
-            </ul>
-            <p className={styles.description}>
-              <strong>Important:</strong> A high ESI score indicates physical similarity to Earth, but does not account for atmosphere composition, magnetic fields, stellar activity, or other factors critical for life.
-            </p>
-          </div>
-
-          <p className={styles.reference}>
-            Formula source: Schulze-Makuch et al. (2011), <em>Astrobiology</em>.
-            <br />
-            Learn more: <a href="https://en.wikipedia.org/wiki/Earth_Similarity_Index" target="_blank" rel="noopener noreferrer">
-              Earth Similarity Index (Wikipedia)
-            </a> | <a href="https://phl.upr.edu/projects/habitable-exoplanets-catalog" target="_blank" rel="noopener noreferrer">
-              Habitable Exoplanets Catalog (UPR Arecibo)
-            </a>
+            ))}
+          </ul>
+          <p className={styles.description}>
+            <strong>Important:</strong> A high ESI score indicates physical similarity to Earth, but does not account for atmosphere composition, magnetic fields, stellar activity, or other factors critical for life.
           </p>
         </div>
+
+        <p className={styles.reference}>
+          Formula source: Schulze-Makuch et al. (2011), <em>Astrobiology</em>.
+          <br />
+          Learn more: <a href="https://en.wikipedia.org/wiki/Earth_Similarity_Index" target="_blank" rel="noopener noreferrer">
+            Earth Similarity Index (Wikipedia)
+          </a> | <a href="https://phl.upr.edu/projects/habitable-exoplanets-catalog" target="_blank" rel="noopener noreferrer">
+            Habitable Exoplanets Catalog (UPR Arecibo)
+          </a>
+        </p>
       </div>
-    </div>,
-    document.body,
+    </ModalDialog>
   );
 }
diff --git a/exoplanethub.com/components/explore/FilterControls.module.css b/exoplanethub.com/components/explore/FilterControls.module.css
new file mode 100644
index 0000000..a2abb11
--- /dev/null
+++ b/exoplanethub.com/components/explore/FilterControls.module.css
@@ -0,0 +1,52 @@
+.controls {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  margin-bottom: 24px;
+}
+
+.row {
+  display: flex;
+  gap: 16px;
+  flex-wrap: wrap;
+}
+
+.searchInput {
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: 999px;
+  padding: 12px 20px;
+  color: var(--color-text);
+  font-size: 14px;
+}
+
+.searchInput::placeholder {
+  color: var(--color-text-muted);
+}
+
+.clearAll {
+  align-self: flex-start;
+  background: transparent;
+  border: 1px solid var(--color-border);
+  border-radius: 999px;
+  padding: 8px 16px;
+  color: var(--color-text);
+  font-size: 14px;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.clearAll:hover:not(:disabled) {
+  border-color: var(--color-primary);
+  color: var(--color-primary);
+}
+
+.clearAll:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
+
+.clearAll:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
diff --git a/exoplanethub.com/components/explore/FilterControls.test.tsx b/exoplanethub.com/components/explore/FilterControls.test.tsx
new file mode 100644
index 0000000..9f9bcb4
--- /dev/null
+++ b/exoplanethub.com/components/explore/FilterControls.test.tsx
@@ -0,0 +1,219 @@
+import { createRef } from 'react';
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+import type { PlanetSummary } from '@/lib/mockPlanets';
+import { DEFAULT_FILTERS, FilterState } from '@/lib/planetFilters';
+import FilterControls from '@/components/explore/FilterControls';
+
+function makePlanet(pl_name: string, discoverymethod: string | null): PlanetSummary {
+  return {
+    pl_name,
+    hostname: 'Host',
+    sy_dist: 10,
+    discoverymethod,
+    disc_year: 2000,
+    pl_orbper: 1,
+    pl_rade: 1,
+    pl_bmasse: 1,
+    pl_eqt: 300,
+    st_teff: 5800,
+  };
+}
+
+const PLANETS = [makePlanet('Alpha b', 'Transit'), makePlanet('Beta c', 'Imaging')];
+
+// Astrometry is deliberately absent from PLANETS: only the URL can put its box on screen.
+const URL_ONLY = 'Astrometry';
+
+function renderControls(filters: Partial<FilterState> = {}) {
+  const onChange = vi.fn();
+  const onClear = vi.fn();
+  const searchRef = createRef<HTMLInputElement>();
+  const props = { planets: PLANETS, onChange, onClear, searchRef };
+  const { rerender } = render(<FilterControls {...props} filters={{ ...DEFAULT_FILTERS, ...filters }} />);
+
+  return {
+    onChange,
+    onClear,
+    // The real page feeds the new state back through the URL; this stands in for that round trip.
+    apply: (next: FilterState) => rerender(<FilterControls {...props} filters={next} />),
+  };
+}
+
+function group(name: RegExp) {
+  return within(screen.getByRole('group', { name }));
+}
+
+function methodBox(name: string) {
+  return group(/discovery method/i).getByRole('checkbox', { name });
+}
+
+function starBox(name: RegExp) {
+  return group(/star type/i).getByRole('checkbox', { name });
+}
+
+function clearAll() {
+  return screen.getByRole('button', { name: /clear all/i });
+}
+
+describe('FilterControls discovery method', () => {
+  it('offers a box for every method the data carries', () => {
+    renderControls();
+
+    expect(
+      group(/discovery method/i)
+        .getAllByRole('checkbox')
+        .map((box) => box.closest('label')?.textContent),
+    ).toEqual(['Imaging', 'Transit']);
+  });
+
+  it('offers a box for a method only the URL names, so a shared link shows what it filters by', () => {
+    renderControls({ methods: [URL_ONLY] });
+
+    expect(methodBox(URL_ONLY)).toBeChecked();
+  });
+
+  it('keeps focus on a URL-only method after unticking it', async () => {
+    const user = userEvent.setup();
+    const { onChange, apply } = renderControls({ methods: [URL_ONLY] });
+
+    await user.click(methodBox(URL_ONLY));
+    apply(onChange.mock.calls[0][0]);
+
+    expect(methodBox(URL_ONLY)).toHaveFocus();
+  });
+
+  it('leaves a URL-only method on offer once unticked, so the choice can be undone', async () => {
+    const user = userEvent.setup();
+    const { onChange, apply } = renderControls({ methods: [URL_ONLY] });
+
+    await user.click(methodBox(URL_ONLY));
+    apply(onChange.mock.calls[0][0]);
+    expect(methodBox(URL_ONLY)).not.toBeChecked();
+
+    await user.click(methodBox(URL_ONLY));
+
+    expect(onChange.mock.calls[1][0].methods).toEqual([URL_ONLY]);
+  });
+
+  it('adds a method the URL names later without dropping the ones already on screen', () => {
+    const { apply } = renderControls();
+
+    apply({ ...DEFAULT_FILTERS, methods: [URL_ONLY] });
+
+    expect(methodBox(URL_ONLY)).toBeChecked();
+    expect(methodBox('Transit')).toBeInTheDocument();
+  });
+});
+
+describe('FilterControls star type', () => {
+  it('offers all seven classes hottest first, whatever the data happens to contain', () => {
+    renderControls();
+
+    expect(
+      group(/star type/i)
+        .getAllByRole('checkbox')
+        .map((box) => box.closest('label')?.textContent),
+    ).toEqual([
+      'O — blue',
+      'B — blue-white',
+      'A — white',
+      'F — yellow-white',
+      'G — sun-like',
+      'K — orange dwarf',
+      'M — red dwarf',
+    ]);
+  });
+
+  it('checks the classes the filter names and leaves the rest alone', () => {
+    renderControls({ starClasses: ['M'] });
+
+    expect(starBox(/red dwarf/i)).toBeChecked();
+    expect(starBox(/sun-like/i)).not.toBeChecked();
+  });
+
+  it('reports a tick as a selection of that class', async () => {
+    const user = userEvent.setup();
+    const { onChange } = renderControls();
+
+    await user.click(starBox(/sun-like/i));
+
+    expect(onChange.mock.calls[0][0].starClasses).toEqual(['G']);
+  });
+
+  it('reports an untick as a deselection', async () => {
+    const user = userEvent.setup();
+    const { onChange } = renderControls({ starClasses: ['G', 'M'] });
+
+    await user.click(starBox(/sun-like/i));
+
+    expect(onChange.mock.calls[0][0].starClasses).toEqual(['M']);
+  });
+
+  it('says which planets a live star filter is hiding, and says nothing while it is inactive', () => {
+    const { apply } = renderControls({ starClasses: ['G'] });
+    expect(group(/star type/i).getByText(/unclassified/i)).toBeInTheDocument();
+
+    apply(DEFAULT_FILTERS);
+
+    expect(group(/star type/i).queryByText(/unclassified/i)).toBeNull();
+  });
+
+  it('points the fieldset at the note explaining the exclusion it caused', () => {
+    renderControls({ starClasses: ['G'] });
+    const note = group(/star type/i).getByText(/unclassified/i);
+
+    expect(screen.getByRole('group', { name: /star type/i })).toHaveAttribute(
+      'aria-describedby',
+      note.id,
+    );
+  });
+
+  // A star the filter would hide is exactly the one whose box must stay reachable to undo it.
+  it('keeps focus on a class box after unticking it', async () => {
+    const user = userEvent.setup();
+    const { onChange, apply } = renderControls({ starClasses: ['M'] });
+
+    await user.click(starBox(/red dwarf/i));
+    apply(onChange.mock.calls[0][0]);
+
+    expect(starBox(/red dwarf/i)).toHaveFocus();
+  });
+});
+
+describe('FilterControls clear all', () => {
+  it('offers nothing to clear on the default view', () => {
+    renderControls();
+
+    expect(clearAll()).toBeDisabled();
+  });
+
+  it.each([
+    ['a search', { q: 'kepler' }],
+    ['a method', { methods: ['Transit'] }],
+    ['a star class', { starClasses: ['G' as const] }],
+    ['a range', { ranges: { ...DEFAULT_FILTERS.ranges, radius: { min: 1, max: null } } }],
+  ])('becomes clearable once the visitor has set %s', (_label, active) => {
+    renderControls(active);
+
+    expect(clearAll()).toBeEnabled();
+  });
+
+  // Sort reorders the page rather than hiding anything, so there is nothing for it to clear.
+  it('stays unclearable under a non-default sort alone', () => {
+    renderControls({ sortKey: 'esi', sortOrder: 'asc' });
+
+    expect(clearAll()).toBeDisabled();
+  });
+
+  it('asks the page to clear rather than editing the filters itself', async () => {
+    const user = userEvent.setup();
+    const { onChange, onClear } = renderControls({ q: 'kepler' });
+
+    await user.click(clearAll());
+
+    expect(onClear).toHaveBeenCalledOnce();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});
diff --git a/exoplanethub.com/components/explore/FilterControls.tsx b/exoplanethub.com/components/explore/FilterControls.tsx
new file mode 100644
index 0000000..38ddaab
--- /dev/null
+++ b/exoplanethub.com/components/explore/FilterControls.tsx
@@ -0,0 +1,131 @@
+'use client';
+import { RefObject, useMemo, useState } from 'react';
+import { PlanetSummary } from '@/lib/mockPlanets';
+import {
+  FilterState,
+  RANGE_KEYS,
+  RangeKey,
+  discoveryMethods,
+  isFiltered,
+  measuredExtent,
+  withMethod,
+  withRange,
+  withStarClass,
+} from '@/lib/planetFilters';
+import { STAR_BANDS } from '@/lib/starBands';
+import CheckboxGroup from './CheckboxGroup';
+import RangeFilter from './RangeFilter';
+import styles from './FilterControls.module.css';
+
+interface FilterControlsProps {
+  planets: PlanetSummary[];
+  filters: FilterState;
+  onChange: (next: FilterState) => void;
+  onClear: () => void;
+  searchRef: RefObject<HTMLInputElement | null>;
+}
+
+const RANGE_COPY: Record<RangeKey, { label: string; unit: string; missingNote: string }> = {
+  radius: {
+    label: 'Radius',
+    unit: 'Earth radii',
+    missingNote: 'Planets without a measured radius are hidden.',
+  },
+  mass: {
+    label: 'Mass',
+    unit: 'Earth masses',
+    missingNote: 'Planets without a measured mass are hidden.',
+  },
+  period: {
+    label: 'Orbital period',
+    unit: 'days',
+    missingNote: 'Planets without a measured orbital period are hidden.',
+  },
+};
+
+const STAR_OPTIONS = STAR_BANDS.map(({ starClass, label }) => ({ value: starClass, label }));
+
+const UNCLASSIFIED_NOTE =
+  'Planets whose host star is unclassified — no measured temperature, or cooler than 2,300 K — are hidden.';
+
+export default function FilterControls({
+  planets,
+  filters,
+  onChange,
+  onClear,
+  searchRef,
+}: FilterControlsProps) {
+  // Kept apart from the merge below so ticking a box never rescans the whole archive.
+  const present = useMemo(() => discoveryMethods(planets), [planets]);
+
+  // Deriving the boxes from the selection they mutate would unmount one mid-click, dropping the
+  // visitor's focus on <body>, so a method stays on offer for the rest of the mount once selected.
+  const [everSelected, setEverSelected] = useState(filters.methods);
+  const unoffered = filters.methods.filter((method) => !everSelected.includes(method));
+  if (unoffered.length > 0) setEverSelected([...everSelected, ...unoffered]);
+
+  // A method the data no longer contains still gets a box, so a shared URL shows what it filters by.
+  const methodOptions = useMemo(
+    () =>
+      Array.from(new Set([...present, ...everSelected]))
+        .sort()
+        .map((method) => ({ value: method, label: method })),
+    [present, everSelected],
+  );
+  const extents = useMemo(
+    () => RANGE_KEYS.map((key) => ({ key, extent: measuredExtent(planets, key) })),
+    [planets],
+  );
+
+  return (
+    <div className={styles.controls}>
+      <input
+        ref={searchRef}
+        type="text"
+        aria-label="Search by planet or host star name"
+        placeholder="Search exoplanets..."
+        value={filters.q}
+        onChange={(e) => onChange({ ...filters, q: e.target.value })}
+        className={styles.searchInput}
+      />
+
+      {methodOptions.length > 0 && (
+        <CheckboxGroup
+          legend="Discovery method"
+          options={methodOptions}
+          selected={filters.methods}
+          onToggle={(method, selected) => onChange(withMethod(filters, method, selected))}
+        />
+      )}
+
+      <CheckboxGroup
+        legend="Star type"
+        options={STAR_OPTIONS}
+        selected={filters.starClasses}
+        onToggle={(starClass, selected) => onChange(withStarClass(filters, starClass, selected))}
+        note={filters.starClasses.length > 0 ? UNCLASSIFIED_NOTE : undefined}
+      />
+
+      <div className={styles.row}>
+        {extents.map(({ key, extent }) => (
+          <RangeFilter
+            key={key}
+            {...RANGE_COPY[key]}
+            extent={extent}
+            value={filters.ranges[key]}
+            onChange={(range) => onChange(withRange(filters, key, range))}
+          />
+        ))}
+      </div>
+
+      <button
+        type="button"
+        className={styles.clearAll}
+        onClick={onClear}
+        disabled={!isFiltered(filters)}
+      >
+        Clear all
+      </button>
+    </div>
+  );
+}
diff --git a/exoplanethub.com/components/explore/NoResults.module.css b/exoplanethub.com/components/explore/NoResults.module.css
new file mode 100644
index 0000000..f87e9e4
--- /dev/null
+++ b/exoplanethub.com/components/explore/NoResults.module.css
@@ -0,0 +1,40 @@
+.empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 8px;
+  border: 1px dashed var(--color-border);
+  border-radius: 12px;
+  padding: 48px 24px;
+  margin-top: 24px;
+  text-align: center;
+}
+
+.headline {
+  color: var(--color-text);
+  font-size: 18px;
+  font-weight: 600;
+}
+
+.detail {
+  color: var(--color-text-muted);
+  font-size: 14px;
+  max-width: 42ch;
+}
+
+.clear {
+  margin-top: 8px;
+  background: var(--color-primary);
+  border: 1px solid var(--color-primary);
+  border-radius: 8px;
+  padding: 10px 20px;
+  color: var(--color-primary-contrast);
+  font-size: 14px;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.clear:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
diff --git a/exoplanethub.com/components/explore/NoResults.tsx b/exoplanethub.com/components/explore/NoResults.tsx
new file mode 100644
index 0000000..59d895f
--- /dev/null
+++ b/exoplanethub.com/components/explore/NoResults.tsx
@@ -0,0 +1,28 @@
+'use client';
+import styles from './NoResults.module.css';
+
+// No clear action means no filter is hiding anything, and a failed load never reaches here — the
+// page shows its own error instead — so an empty list really is an empty response.
+export default function NoResults({ onClear }: { onClear?: () => void }) {
+  const copy = onClear
+    ? {
+        headline: 'No planets match these filters',
+        detail: 'Try widening a range, or start again from the whole archive.',
+      }
+    : {
+        headline: 'No planets to show',
+        detail: 'The archive came back without a single planet in it.',
+      };
+
+  return (
+    <div className={styles.empty}>
+      <p className={styles.headline}>{copy.headline}</p>
+      <p className={styles.detail}>{copy.detail}</p>
+      {onClear && (
+        <button type="button" className={styles.clear} onClick={onClear}>
+          Clear all filters
+        </button>
+      )}
+    </div>
+  );
+}
diff --git a/exoplanethub.com/components/explore/PaginationControls.module.css b/exoplanethub.com/components/explore/PaginationControls.module.css
new file mode 100644
index 0000000..40bd17d
--- /dev/null
+++ b/exoplanethub.com/components/explore/PaginationControls.module.css
@@ -0,0 +1,53 @@
+.pagination {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 24px;
+  margin-top: 24px;
+  padding: 16px;
+}
+
+.button {
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  padding: 10px 20px;
+  color: var(--color-text);
+  font-size: 14px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.button:hover:not(:disabled) {
+  background: var(--color-primary);
+  color: var(--color-primary-contrast);
+  border-color: var(--color-primary);
+}
+
+.button:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
+
+.button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.pageInfo {
+  color: var(--color-text-muted);
+  font-size: 14px;
+  font-weight: 500;
+}
+
+/* Focused only as a landing spot, so a mouse user should never see the ring a keyboard user needs. */
+.pageInfo:focus {
+  outline: none;
+}
+
+.pageInfo:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 4px;
+  border-radius: 4px;
+}
diff --git a/exoplanethub.com/components/explore/PaginationControls.test.tsx b/exoplanethub.com/components/explore/PaginationControls.test.tsx
new file mode 100644
index 0000000..f0770a7
--- /dev/null
+++ b/exoplanethub.com/components/explore/PaginationControls.test.tsx
@@ -0,0 +1,91 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+import PaginationControls from '@/components/explore/PaginationControls';
+import { usePagination } from '@/lib/usePagination';
+
+function Harness({ itemCount, itemsPerPage }: { itemCount: number; itemsPerPage: number }) {
+  return <PaginationControls pagination={usePagination(itemCount, itemsPerPage)} />;
+}
+
+function step(name: RegExp) {
+  return screen.getByRole('button', { name });
+}
+
+describe('PaginationControls', () => {
+  it('reports the page it is on out of the total', () => {
+    render(<Harness itemCount={5} itemsPerPage={2} />);
+
+    expect(screen.getByText(/page 1 of 3/i)).toBeInTheDocument();
+  });
+
+  it('reports a single empty page rather than "page 1 of 0" when nothing matches', () => {
+    render(<Harness itemCount={0} itemsPerPage={2} />);
+
+    expect(screen.getByText(/page 1 of 1/i)).toBeInTheDocument();
+    expect(step(/next/i)).toBeDisabled();
+  });
+
+  it('disables Previous on the first page and advances via Next', async () => {
+    const user = userEvent.setup();
+    render(<Harness itemCount={5} itemsPerPage={2} />);
+    expect(step(/previous/i)).toBeDisabled();
+
+    await user.click(step(/next/i));
+
+    expect(screen.getByText(/page 2 of 3/i)).toBeInTheDocument();
+    expect(step(/previous/i)).toBeEnabled();
+  });
+
+  it('disables Next on the last page', async () => {
+    const user = userEvent.setup();
+    render(<Harness itemCount={3} itemsPerPage={2} />);
+
+    await user.click(step(/next/i));
+
+    expect(step(/next/i)).toBeDisabled();
+  });
+
+  it('asks for the neighbouring page rather than moving itself', async () => {
+    const user = userEvent.setup();
+    const goTo = vi.fn();
+    render(
+      <PaginationControls pagination={{ page: 3, totalPages: 7, goTo, pageItems: (items) => items }} />,
+    );
+
+    await user.click(step(/previous/i));
+    expect(goTo).toHaveBeenLastCalledWith(2);
+
+    await user.click(step(/next/i));
+    expect(goTo).toHaveBeenLastCalledWith(4);
+  });
+
+  // A button that disables itself the instant it works would drop focus to the top of the document.
+  it('hands focus to the page indicator when Next disables itself at the last page', async () => {
+    const user = userEvent.setup();
+    render(<Harness itemCount={3} itemsPerPage={2} />);
+
+    await user.click(step(/next/i));
+
+    expect(screen.getByText(/page 2 of 2/i)).toHaveFocus();
+  });
+
+  it('hands focus to the page indicator when Previous disables itself at the first page', async () => {
+    const user = userEvent.setup();
+    render(<Harness itemCount={5} itemsPerPage={2} />);
+    await user.click(step(/next/i));
+
+    await user.click(step(/previous/i));
+
+    expect(screen.getByText(/page 1 of 3/i)).toHaveFocus();
+  });
+
+  it('leaves focus on the button while it stays usable, so paging can be repeated', async () => {
+    const user = userEvent.setup();
+    render(<Harness itemCount={9} itemsPerPage={2} />);
+
+    await user.click(step(/next/i));
+
+    expect(step(/next/i)).toHaveFocus();
+  });
+});
diff --git a/exoplanethub.com/components/explore/PaginationControls.tsx b/exoplanethub.com/components/explore/PaginationControls.tsx
new file mode 100644
index 0000000..42402cf
--- /dev/null
+++ b/exoplanethub.com/components/explore/PaginationControls.tsx
@@ -0,0 +1,33 @@
+'use client';
+import { useRef } from 'react';
+import { Pagination } from '@/lib/usePagination';
+import styles from './PaginationControls.module.css';
+
+export default function PaginationControls({ pagination }: { pagination: Pagination }) {
+  const { page, totalPages, goTo } = pagination;
+  const pageInfoRef = useRef<HTMLSpanElement>(null);
+
+  // Reaching an end disables the button that got you there, so focus lands on the page it reports.
+  const step = (target: number) => {
+    goTo(target);
+    if (target === 1 || target === totalPages) pageInfoRef.current?.focus();
+  };
+
+  return (
+    <div className={styles.pagination}>
+      <button className={styles.button} onClick={() => step(page - 1)} disabled={page === 1}>
+        Previous
+      </button>
+      <span className={styles.pageInfo} ref={pageInfoRef} tabIndex={-1}>
+        Page {page} of {totalPages}
+      </span>
+      <button
+        className={styles.button}
+        onClick={() => step(page + 1)}
+        disabled={page === totalPages}
+      >
+        Next
+      </button>
+    </div>
+  );
+}
diff --git a/exoplanethub.com/components/explore/PlanetCard.test.tsx b/exoplanethub.com/components/explore/PlanetCard.test.tsx
index 6dcfd99..5444c9e 100644
--- a/exoplanethub.com/components/explore/PlanetCard.test.tsx
+++ b/exoplanethub.com/components/explore/PlanetCard.test.tsx
@@ -9,9 +9,11 @@ const SCORED: PlanetSummary = {
   sy_dist: 370.53,
   discoverymethod: 'Transit',
   disc_year: 2015,
+  pl_orbper: 112.3,
   pl_rade: 1.34,
   pl_bmasse: 2.36,
   pl_eqt: 233,
+  st_teff: 4402,
   esi: 84,
 };
 
@@ -36,4 +38,43 @@ describe('PlanetCard', () => {
     expect(screen.getByRole('heading', { name: 'Kepler-442 b' })).toBeInTheDocument();
     expect(screen.getByRole('button', { name: 'Learn More' })).toBeInTheDocument();
   });
+
+  it('links the name to the planet page, encoding names that need it', () => {
+    renderCard(SCORED);
+
+    expect(screen.getByRole('link', { name: 'Kepler-442 b' })).toHaveAttribute(
+      'href',
+      '/planet/Kepler-442%20b',
+    );
+  });
+
+  // Decision 5 keeps the two-control pattern in the table; the card's button still only opens the modal.
+  it('keeps Learn More as the modal control rather than a second link', () => {
+    const onClick = vi.fn();
+    render(<PlanetCard planet={SCORED} onClick={onClick} />);
+
+    expect(screen.getAllByRole('link')).toHaveLength(1);
+    expect(screen.getByRole('button', { name: 'Learn More' })).toBeInTheDocument();
+  });
+
+  it('rounds its stats to the figures the planet page shows', () => {
+    renderCard(SCORED);
+
+    expect(screen.getByText('370.5 pc')).toBeInTheDocument();
+    expect(screen.getByText('1.34 \u00d7 Earth')).toBeInTheDocument();
+  });
+
+  it('reports an unmeasured stat as N/A without stranding its unit', () => {
+    renderCard({ ...SCORED, sy_dist: null, pl_rade: null });
+
+    expect(screen.getAllByText('N/A')).toHaveLength(2);
+    expect(screen.queryByText(/N\/A\s*(pc|\u00d7)/)).not.toBeInTheDocument();
+  });
+
+  // The emoji stands in for planet imagery; announcing "ringed planet" says nothing about this planet.
+  it('hides the decorative planet glyph from assistive tech', () => {
+    renderCard(SCORED);
+
+    expect(screen.getByText('🪐')).toHaveAttribute('aria-hidden', 'true');
+  });
 });
diff --git a/exoplanethub.com/components/explore/PlanetCard.tsx b/exoplanethub.com/components/explore/PlanetCard.tsx
index 77e4b11..1ff907d 100644
--- a/exoplanethub.com/components/explore/PlanetCard.tsx
+++ b/exoplanethub.com/components/explore/PlanetCard.tsx
@@ -1,5 +1,7 @@
 'use client';
 import { PlanetSummary } from '@/lib/mockPlanets';
+import { measurement } from '@/lib/planetStats';
+import PlanetNameLink from '@/components/planet/PlanetNameLink';
 import ESIBadge from './ESIBadge';
 import styles from './PlanetCard.module.css';
 
@@ -12,22 +14,24 @@ export default function PlanetCard({ planet, onClick }: PlanetCardProps) {
   return (
     <div className={styles.card}>
       <div className={styles.imageContainer}>
-        <div className={styles.imagePlaceholder}>🪐</div>
+        <div className={styles.imagePlaceholder} aria-hidden="true">🪐</div>
         <ESIBadge score={planet.esi} />
       </div>
       
       <div className={styles.content}>
-        <h3 className={styles.name}>{planet.pl_name}</h3>
+        <h3 className={styles.name}>
+          <PlanetNameLink name={planet.pl_name} />
+        </h3>
         <p className={styles.star}>{planet.hostname || 'Unknown'}</p>
         
         <div className={styles.stats}>
           <div className={styles.statItem}>
             <span className={styles.statLabel}>Distance</span>
-            <span className={styles.statValue}>{planet.sy_dist ? planet.sy_dist.toFixed(2) : 'N/A'} pc</span>
+            <span className={styles.statValue}>{measurement(planet.sy_dist, 'pc') ?? 'N/A'}</span>
           </div>
           <div className={styles.statItem}>
             <span className={styles.statLabel}>Radius</span>
-            <span className={styles.statValue}>{planet.pl_rade ? planet.pl_rade.toFixed(2) : 'N/A'}× Earth</span>
+            <span className={styles.statValue}>{measurement(planet.pl_rade, '× Earth') ?? 'N/A'}</span>
           </div>
           <div className={styles.statItem}>
             <span className={styles.statLabel}>Method</span>
diff --git a/exoplanethub.com/components/explore/PlanetGrid.module.css b/exoplanethub.com/components/explore/PlanetGrid.module.css
new file mode 100644
index 0000000..1f566c9
--- /dev/null
+++ b/exoplanethub.com/components/explore/PlanetGrid.module.css
@@ -0,0 +1,11 @@
+.grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(340px, 1fr));
+  gap: 24px;
+}
+
+@media (max-width: 768px) {
+  .grid {
+    grid-template-columns: 1fr;
+  }
+}
diff --git a/exoplanethub.com/components/explore/PlanetGrid.tsx b/exoplanethub.com/components/explore/PlanetGrid.tsx
new file mode 100644
index 0000000..a04afae
--- /dev/null
+++ b/exoplanethub.com/components/explore/PlanetGrid.tsx
@@ -0,0 +1,26 @@
+'use client';
+import { PlanetSummary } from '@/lib/mockPlanets';
+import { Pagination } from '@/lib/usePagination';
+import PaginationControls from './PaginationControls';
+import PlanetCard from './PlanetCard';
+import styles from './PlanetGrid.module.css';
+
+interface PlanetGridProps {
+  planets: PlanetSummary[];
+  pagination: Pagination;
+  onPlanetClick: (planet: PlanetSummary) => void;
+}
+
+export default function PlanetGrid({ planets, pagination, onPlanetClick }: PlanetGridProps) {
+  return (
+    <>
+      <div className={styles.grid}>
+        {pagination.pageItems(planets).map((planet) => (
+          <PlanetCard key={planet.pl_name} planet={planet} onClick={() => onPlanetClick(planet)} />
+        ))}
+      </div>
+
+      <PaginationControls pagination={pagination} />
+    </>
+  );
+}
diff --git a/exoplanethub.com/components/explore/PlanetModal.module.css b/exoplanethub.com/components/explore/PlanetModal.module.css
index 5c3bce0..8655509 100644
--- a/exoplanethub.com/components/explore/PlanetModal.module.css
+++ b/exoplanethub.com/components/explore/PlanetModal.module.css
@@ -1,34 +1,5 @@
-.overlay {
-  position: fixed;
-  inset: 0;
-  background: rgba(0, 0, 0, 0.8);
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  z-index: 1000;
-  padding: 24px;
-  animation: fadeIn 0.2s;
-}
-
-@keyframes fadeIn {
-  from { opacity: 0; }
-  to { opacity: 1; }
-}
-
 .modal {
-  background: var(--color-surface);
-  border: 1px solid var(--color-border);
-  border-radius: 16px;
-  max-width: 700px;
-  width: 100%;
-  max-height: 90vh;
   overflow-y: auto;
-  animation: slideUp 0.3s;
-}
-
-@keyframes slideUp {
-  from { transform: translateY(20px); opacity: 0; }
-  to { transform: translateY(0); opacity: 1; }
 }
 
 .header {
@@ -170,3 +141,26 @@
     grid-template-columns: 1fr;
   }
 }
+
+.fullProfile {
+  display: block;
+  background: var(--color-primary);
+  color: var(--color-primary-contrast);
+  border-radius: 999px;
+  padding: 12px 24px;
+  text-align: center;
+  font-size: 15px;
+  font-weight: 600;
+  text-decoration: none;
+  transition: background 0.2s;
+}
+
+.fullProfile:hover {
+  background: var(--color-accent);
+  color: var(--color-background);
+}
+
+.fullProfile:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
diff --git a/exoplanethub.com/components/explore/PlanetModal.test.tsx b/exoplanethub.com/components/explore/PlanetModal.test.tsx
new file mode 100644
index 0000000..a333325
--- /dev/null
+++ b/exoplanethub.com/components/explore/PlanetModal.test.tsx
@@ -0,0 +1,169 @@
+import { useState } from 'react';
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it } from 'vitest';
+import type { Planet } from '@/lib/mockPlanets';
+import PlanetModal from '@/components/explore/PlanetModal';
+
+const TRIGGER_LABEL = 'Learn More';
+
+const KEPLER: Planet = {
+  pl_name: 'Kepler-186 f',
+  hostname: 'Kepler-186',
+  sy_snum: 1,
+  sy_pnum: 5,
+  sy_dist: 178.5,
+  discoverymethod: 'Transit',
+  disc_year: 2014,
+  disc_facility: 'Kepler',
+  pl_orbper: 129.9,
+  pl_orbsmax: 0.432,
+  pl_rade: 1.17,
+  pl_bmasse: 1.71,
+  pl_dens: 5.5,
+  pl_eqt: 188,
+  pl_insol: 0.29,
+  st_teff: 3755,
+  st_rad: 0.52,
+  st_mass: 0.54,
+  st_logg: 4.7,
+  st_age: 4,
+  last_updated: '2026-01-01',
+};
+
+function Harness({ planet = KEPLER }: { planet?: Planet }) {
+  const [open, setOpen] = useState(false);
+
+  return (
+    <>
+      <button onClick={() => setOpen(true)}>{TRIGGER_LABEL}</button>
+      {open && <PlanetModal planet={planet} onClose={() => setOpen(false)} />}
+    </>
+  );
+}
+
+async function openModal(planet?: Planet) {
+  const user = userEvent.setup();
+  render(<Harness planet={planet} />);
+  const trigger = screen.getByRole('button', { name: TRIGGER_LABEL });
+  await user.click(trigger);
+
+  return { user, trigger, dialog: screen.getByRole('dialog') };
+}
+
+describe('PlanetModal accessibility (#6)', () => {
+  it('is a modal dialog named after the planet it describes', async () => {
+    const { dialog } = await openModal();
+
+    expect(dialog).toHaveAttribute('aria-modal', 'true');
+    expect(dialog).toHaveAccessibleName('Kepler-186 f');
+  });
+
+  it('moves focus into the dialog and back to the trigger on close', async () => {
+    const { user, trigger, dialog } = await openModal();
+    expect(dialog).toHaveFocus();
+
+    await user.keyboard('{Escape}');
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(trigger).toHaveFocus();
+  });
+
+  it('gives the close control a spoken name rather than a bare glyph', async () => {
+    const { user, trigger, dialog } = await openModal();
+
+    await user.click(within(dialog).getByRole('button', { name: 'Close' }));
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(trigger).toHaveFocus();
+  });
+
+  it('keeps Tab inside the dialog', async () => {
+    const { user, dialog } = await openModal();
+
+    for (let i = 0; i < 4; i++) {
+      await user.tab();
+      expect(dialog).toContainElement(document.activeElement as HTMLElement);
+    }
+  });
+
+  // The emoji stands in for planet imagery; announcing "ringed planet" says nothing about this planet.
+  it('hides the decorative planet glyph from assistive tech', async () => {
+    const { dialog } = await openModal();
+
+    expect(within(dialog).getByText('🪐')).toHaveAttribute('aria-hidden', 'true');
+  });
+});
+
+describe('PlanetModal content', () => {
+  it('reports the statistics NASA supplied, formatted as the planet page formats them', async () => {
+    const { dialog } = await openModal();
+
+    expect(within(dialog).getByText('178.5 parsecs')).toBeInTheDocument();
+    expect(within(dialog).getByText('1.17 × Earth')).toBeInTheDocument();
+    expect(within(dialog).getByText('1.71 × Earth')).toBeInTheDocument();
+    expect(within(dialog).getByText('188 K')).toBeInTheDocument();
+    expect(within(dialog).getByText('Orbits Kepler-186')).toBeInTheDocument();
+  });
+
+  it('falls back to N/A for the nulls the archive actually sends', async () => {
+    const { dialog } = await openModal({
+      ...KEPLER,
+      hostname: null,
+      sy_dist: null,
+      pl_rade: null,
+      pl_eqt: null,
+      disc_year: null,
+    });
+
+    expect(within(dialog).getAllByText('N/A')).toHaveLength(4);
+    expect(within(dialog).getByText('Orbits Unknown')).toBeInTheDocument();
+  });
+
+  // The unit used to sit outside the fallback, so an unknown distance read "N/A parsecs".
+  it('drops the unit with the value rather than labelling an unknown', async () => {
+    const { dialog } = await openModal({ ...KEPLER, sy_dist: null });
+
+    expect(within(dialog).queryByText(/N\/A\s*parsecs/)).not.toBeInTheDocument();
+  });
+
+  // A measured zero is data, not a missing field.
+  it('keeps a zero reading instead of reporting it as unknown', async () => {
+    const { dialog } = await openModal({ ...KEPLER, pl_eqt: 0 });
+
+    expect(within(dialog).getByText('0 K')).toBeInTheDocument();
+  });
+});
+
+describe('PlanetModal full profile link (#68)', () => {
+  it('offers the planet page as the next step out of the quick look', async () => {
+    const { dialog } = await openModal();
+
+    expect(within(dialog).getByRole('link', { name: 'View full profile' })).toHaveAttribute(
+      'href',
+      '/planet/Kepler-186%20f',
+    );
+  });
+
+  it('is a link rather than a button, so middle-click and copy-link work', async () => {
+    const { dialog } = await openModal();
+
+    expect(within(dialog).getByRole('link', { name: 'View full profile' }).tagName).toBe('A');
+  });
+
+  // The dialog had one focus stop before this link; the trap has to keep cycling both.
+  it('is reachable by Tab inside the focus trap', async () => {
+    const { user, dialog } = await openModal();
+    const close = within(dialog).getByRole('button', { name: 'Close' });
+    const fullProfile = within(dialog).getByRole('link', { name: 'View full profile' });
+
+    await user.tab();
+    expect(close).toHaveFocus();
+
+    await user.tab();
+    expect(fullProfile).toHaveFocus();
+
+    await user.tab();
+    expect(close).toHaveFocus();
+  });
+});
diff --git a/exoplanethub.com/components/explore/PlanetModal.tsx b/exoplanethub.com/components/explore/PlanetModal.tsx
index a5a739b..8c00480 100644
--- a/exoplanethub.com/components/explore/PlanetModal.tsx
+++ b/exoplanethub.com/components/explore/PlanetModal.tsx
@@ -1,7 +1,10 @@
 'use client';
+import Link from 'next/link';
 import { PlanetSummary } from '@/lib/mockPlanets';
+import { planetKeyStats } from '@/lib/planetStats';
+import { planetUrl } from '@/lib/planetUrl';
+import ModalDialog from '@/components/ui/ModalDialog';
 import styles from './PlanetModal.module.css';
-import { useEffect } from 'react';
 
 interface PlanetModalProps {
   planet: PlanetSummary;
@@ -9,62 +12,33 @@ interface PlanetModalProps {
 }
 
 export default function PlanetModal({ planet, onClose }: PlanetModalProps) {
-  useEffect(() => {
-    const handleEscape = (e: KeyboardEvent) => {
-      if (e.key === 'Escape') onClose();
-    };
-    document.addEventListener('keydown', handleEscape);
-    document.body.style.overflow = 'hidden';
-    
-    return () => {
-      document.removeEventListener('keydown', handleEscape);
-      document.body.style.overflow = 'unset';
-    };
-  }, [onClose]);
-
   return (
-    <div className={styles.overlay} onClick={onClose}>
-      <div className={styles.modal} onClick={(e) => e.stopPropagation()}>
-        <div className={styles.header}>
-          <button className={styles.closeBtn} onClick={onClose}>×</button>
-          <div className={styles.planetIcon}>🪐</div>
-        </div>
-        
-        <div className={styles.content}>
-          <h2 className={styles.name}>{planet.pl_name}</h2>
-          <p className={styles.star}>Orbits {planet.hostname || 'Unknown'}</p>
-          
-          <div className={styles.section}>
-            <h3 className={styles.sectionTitle}>Key Statistics</h3>
-            <div className={styles.statsGrid}>
-              <div className={styles.statItem}>
-                <span className={styles.statLabel}>Distance</span>
-                <span className={styles.statValue}>{planet.sy_dist ? planet.sy_dist.toFixed(2) : 'N/A'} parsecs</span>
-              </div>
-              <div className={styles.statItem}>
-                <span className={styles.statLabel}>Radius</span>
-                <span className={styles.statValue}>{planet.pl_rade ? planet.pl_rade.toFixed(2) : 'N/A'}× Earth</span>
-              </div>
-              <div className={styles.statItem}>
-                <span className={styles.statLabel}>Mass</span>
-                <span className={styles.statValue}>{planet.pl_bmasse ? planet.pl_bmasse.toFixed(2) : 'N/A'}× Earth</span>
-              </div>
-              <div className={styles.statItem}>
-                <span className={styles.statLabel}>Temperature</span>
-                <span className={styles.statValue}>{planet.pl_eqt ? planet.pl_eqt.toFixed(0) : 'N/A'}K</span>
-              </div>
-              <div className={styles.statItem}>
-                <span className={styles.statLabel}>Discovered</span>
-                <span className={styles.statValue}>{planet.disc_year || 'N/A'}</span>
-              </div>
-              <div className={styles.statItem}>
-                <span className={styles.statLabel}>Detection Method</span>
-                <span className={styles.statValue}>{planet.discoverymethod || 'N/A'}</span>
+    <ModalDialog onClose={onClose} labelledBy="planet-modal-title" className={styles.modal}>
+      <div className={styles.header}>
+        <button className={styles.closeBtn} onClick={onClose} aria-label="Close">×</button>
+        <div className={styles.planetIcon} aria-hidden="true">🪐</div>
+      </div>
+
+      <div className={styles.content}>
+        <h2 id="planet-modal-title" className={styles.name}>{planet.pl_name}</h2>
+        <p className={styles.star}>Orbits {planet.hostname || 'Unknown'}</p>
+
+        <div className={styles.section}>
+          <h3 className={styles.sectionTitle}>Key Statistics</h3>
+          <div className={styles.statsGrid}>
+            {planetKeyStats(planet).map(({ label, value }) => (
+              <div key={label} className={styles.statItem}>
+                <span className={styles.statLabel}>{label}</span>
+                <span className={styles.statValue}>{value ?? 'N/A'}</span>
               </div>
-            </div>
+            ))}
           </div>
         </div>
+
+        <Link className={styles.fullProfile} href={planetUrl(planet.pl_name)}>
+          View full profile
+        </Link>
       </div>
-    </div>
+    </ModalDialog>
   );
 }
diff --git a/exoplanethub.com/components/explore/PlanetTable.module.css b/exoplanethub.com/components/explore/PlanetTable.module.css
index fdd9130..d7506e7 100644
--- a/exoplanethub.com/components/explore/PlanetTable.module.css
+++ b/exoplanethub.com/components/explore/PlanetTable.module.css
@@ -1,35 +1,3 @@
-.controls {
-  display: flex;
-  gap: 16px;
-  margin-bottom: 24px;
-  flex-wrap: wrap;
-}
-
-.searchInput {
-  flex: 1;
-  min-width: 250px;
-  background: var(--color-surface);
-  border: 1px solid var(--color-border);
-  border-radius: 999px;
-  padding: 12px 20px;
-  color: var(--color-text);
-  font-size: 14px;
-}
-
-.searchInput::placeholder {
-  color: var(--color-text-muted);
-}
-
-.select {
-  background: var(--color-surface);
-  border: 1px solid var(--color-border);
-  border-radius: 999px;
-  padding: 12px 20px;
-  color: var(--color-text);
-  font-size: 14px;
-  cursor: pointer;
-}
-
 .tableContainer {
   background: var(--color-surface);
   border: 1px solid var(--color-border);
@@ -54,15 +22,10 @@
   color: var(--color-text-muted);
   text-transform: uppercase;
   letter-spacing: 0.5px;
-  cursor: pointer;
   user-select: none;
   white-space: nowrap;
 }
 
-.table th:hover {
-  color: var(--color-primary);
-}
-
 .table td {
   padding: 16px;
   border-top: 1px solid var(--color-border);
@@ -84,18 +47,47 @@
   color: var(--color-text);
 }
 
-.esiHeaderContent {
+.nameCell {
   display: inline-flex;
   align-items: center;
   gap: 8px;
 }
 
-.table th.esiHeader {
-  cursor: default;
+.quickView {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+  width: 28px;
+  height: 28px;
+  padding: 0;
+  border: none;
+  border-radius: 50%;
+  background: none;
+  color: var(--color-text-muted);
+  cursor: pointer;
+  transition: background 0.2s, color 0.2s;
 }
 
-.table th.esiHeader:hover {
-  color: var(--color-text-muted);
+.quickViewIcon {
+  width: 16px;
+  height: 16px;
+}
+
+.quickView:hover {
+  background: var(--color-border);
+  color: var(--color-text);
+}
+
+.quickView:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
+
+.headerContent {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
 }
 
 .sortButton {
@@ -153,42 +145,6 @@
   font-size: 10px;
 }
 
-.pagination {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 24px;
-  margin-top: 24px;
-  padding: 16px;
-}
-
-.paginationBtn {
-  background: var(--color-surface);
-  border: 1px solid var(--color-border);
-  border-radius: 8px;
-  padding: 8px 16px;
-  color: var(--color-text);
-  font-size: 14px;
-  cursor: pointer;
-  transition: all 0.2s;
-}
-
-.paginationBtn:hover:not(:disabled) {
-  background: var(--color-primary);
-  color: var(--color-primary-contrast);
-  border-color: var(--color-primary);
-}
-
-.paginationBtn:disabled {
-  opacity: 0.5;
-  cursor: not-allowed;
-}
-
-.pageInfo {
-  color: var(--color-text-muted);
-  font-size: 14px;
-}
-
 @media (max-width: 768px) {
   .table {
     min-width: 700px;
diff --git a/exoplanethub.com/components/explore/PlanetTable.test.tsx b/exoplanethub.com/components/explore/PlanetTable.test.tsx
index 7ce913d..d2851ec 100644
--- a/exoplanethub.com/components/explore/PlanetTable.test.tsx
+++ b/exoplanethub.com/components/explore/PlanetTable.test.tsx
@@ -2,7 +2,9 @@ import { render, screen, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { describe, expect, it, vi } from 'vitest';
 import type { Planet } from '@/lib/mockPlanets';
+import type { SortKey, SortOrder } from '@/lib/planetFilters';
 import PlanetTable from '@/components/explore/PlanetTable';
+import { usePagination } from '@/lib/usePagination';
 import { getESIBand } from '@/components/explore/esiBands';
 
 function makePlanet(overrides: Partial<Planet> & Pick<Planet, 'pl_name'>): Planet {
@@ -36,35 +38,76 @@ const ALPHA = makePlanet({ pl_name: 'Alpha b', hostname: 'Ross 128', disc_year:
 const BETA = makePlanet({ pl_name: 'Beta c', hostname: 'Kepler-186', disc_year: 2021, discoverymethod: 'Radial Velocity' });
 const GAMMA = makePlanet({ pl_name: 'Gamma d', hostname: 'Wolf 359', disc_year: 2008 });
 
-function renderTable(props: Partial<React.ComponentProps<typeof PlanetTable>> = {}) {
-  const onPageChange = vi.fn();
-  const onPlanetClick = vi.fn();
-
-  render(
+type TableProps = React.ComponentProps<typeof PlanetTable>;
+type HarnessProps = Omit<Partial<TableProps>, 'pagination'> & { itemsPerPage?: number };
+
+// Driven by the real hook rather than a stub, so paging here exercises the contract the table is given.
+function TableHarness({
+  itemsPerPage = 10,
+  planets = [ALPHA, BETA, GAMMA],
+  sortKey = 'disc_year',
+  sortOrder = 'desc',
+  onPlanetClick = () => {},
+  onSort = () => {},
+}: HarnessProps) {
+  const pagination = usePagination(planets.length, itemsPerPage);
+
+  return (
     <PlanetTable
-      planets={[ALPHA, BETA, GAMMA]}
-      page={1}
-      itemsPerPage={10}
-      onPageChange={onPageChange}
+      planets={planets}
+      pagination={pagination}
+      sortKey={sortKey}
+      sortOrder={sortOrder}
       onPlanetClick={onPlanetClick}
-      {...props}
+      onSort={onSort}
     />
   );
+}
+
+function renderTable(props: HarnessProps = {}) {
+  const onPlanetClick = vi.fn();
+  const onSort = vi.fn();
+
+  const withDefaults = (overrides: HarnessProps) => (
+    <TableHarness onPlanetClick={onPlanetClick} onSort={onSort} {...props} {...overrides} />
+  );
+
+  const { rerender } = render(withDefaults({}));
 
-  return { onPageChange, onPlanetClick };
+  return {
+    onPlanetClick,
+    onSort,
+    sortBy: (sortKey: SortKey, sortOrder: SortOrder) => rerender(withDefaults({ sortKey, sortOrder })),
+  };
 }
 
+// Reads the name link rather than the whole cell, which also holds the quick-view control.
 function renderedNames() {
   return screen
     .getAllByRole('row')
     .slice(1)
-    .map((row) => within(row).getAllByRole('cell')[0].textContent);
+    .map((row) => within(row).getByRole('link').textContent);
 }
 
-// Sort activation lives on the <th> itself today and moves to an inner button once #6 lands.
 function sortControl(name: RegExp) {
-  const header = screen.getByRole('columnheader', { name });
-  return within(header).queryByRole('button') ?? header;
+  return within(screen.getByRole('columnheader', { name })).getByRole('button', { name });
+}
+
+const SORTABLE_COLUMNS: [RegExp, SortKey][] = [
+  [/planet/i, 'pl_name'],
+  [/method/i, 'discoverymethod'],
+  [/radius/i, 'pl_rade'],
+  [/distance/i, 'sy_dist'],
+  [/discovered/i, 'disc_year'],
+  [/esi/i, 'esi'],
+];
+
+function nameLink(name: string) {
+  return screen.getByRole('link', { name });
+}
+
+function quickViewButton(name: string) {
+  return screen.getByRole('button', { name: `Quick view: ${name}` });
 }
 
 function esiHeader() {
@@ -96,22 +139,20 @@ describe('PlanetTable rendering', () => {
     expect(renderedNames()).toEqual(expect.arrayContaining(['Alpha b', 'Beta c', 'Gamma d']));
   });
 
-  it('formats radius and distance to two decimal places', () => {
+  it('rounds radius and distance to the figures the planet page shows', () => {
     renderTable({ planets: [ALPHA] });
 
     const cells = within(screen.getAllByRole('row')[1]).getAllByRole('cell');
-    expect(cells[3]).toHaveTextContent('1.23× Earth');
+    expect(cells[3]).toHaveTextContent('1.234 × Earth');
     expect(cells[4]).toHaveTextContent('12.35 pc');
   });
 
-  it('falls back to N/A for missing values', () => {
-    renderTable({ planets: [makePlanet({ pl_name: 'Sparse b', hostname: '', pl_rade: 0, sy_dist: 0, discoverymethod: '' })] });
+  it('falls back to N/A for blank text the archive sends', () => {
+    renderTable({ planets: [makePlanet({ pl_name: 'Sparse b', hostname: '', discoverymethod: '' })] });
 
     const cells = within(screen.getAllByRole('row')[1]).getAllByRole('cell');
     expect(cells[1]).toHaveTextContent('N/A');
     expect(cells[2]).toHaveTextContent('N/A');
-    expect(cells[3]).toHaveTextContent('N/A× Earth');
-    expect(cells[4]).toHaveTextContent('N/A pc');
   });
 
   // NASA omits pl_eqt on 72% of rows and pl_rade on 25%; the sync stores those as null.
@@ -121,67 +162,36 @@ describe('PlanetTable rendering', () => {
     const cells = within(screen.getAllByRole('row')[1]).getAllByRole('cell');
     expect(cells[1]).toHaveTextContent('N/A');
     expect(cells[2]).toHaveTextContent('N/A');
-    expect(cells[3]).toHaveTextContent('N/A× Earth');
-    expect(cells[4]).toHaveTextContent('N/A pc');
+    expect(cells[3]).toHaveTextContent('N/A');
+    expect(cells[4]).toHaveTextContent('N/A');
   });
-});
 
-describe('PlanetTable sorting', () => {
-  it('sorts by discovery year descending before any interaction', () => {
-    renderTable();
+  // A falsy check used to call a measured zero missing, contradicting the page.
+  it('keeps a zero reading rather than reporting it as unknown', () => {
+    renderTable({ planets: [makePlanet({ pl_name: 'Zero b', pl_rade: 0, sy_dist: 0 })] });
 
-    expect(renderedNames()).toEqual(['Beta c', 'Alpha b', 'Gamma d']);
+    const cells = within(screen.getAllByRole('row')[1]).getAllByRole('cell');
+    expect(cells[3]).toHaveTextContent('0 × Earth');
+    expect(cells[4]).toHaveTextContent('0 pc');
   });
+});
 
-  it('reorders rows when a new sort column is chosen, starting descending', async () => {
-    const user = userEvent.setup();
-    renderTable();
-
-    await user.click(sortControl(/planet/i));
+describe('PlanetTable sorting', () => {
+  // Ordering belongs to ExploreClient so both views share it; the table renders what it is handed.
+  it('renders the rows in the order it was handed rather than ordering them itself', () => {
+    renderTable({ planets: [GAMMA, ALPHA, BETA], sortKey: 'pl_name', sortOrder: 'asc' });
 
-    expect(renderedNames()).toEqual(['Gamma d', 'Beta c', 'Alpha b']);
+    expect(renderedNames()).toEqual(['Gamma d', 'Alpha b', 'Beta c']);
   });
 
-  it('toggles direction when the active sort column is clicked again', async () => {
+  // The owner of the sort state decides the next direction; the table only reports which column was asked for.
+  it('asks its owner to sort by the column whose header was activated', async () => {
     const user = userEvent.setup();
-    renderTable();
+    const { onSort } = renderTable();
 
-    await user.click(sortControl(/planet/i));
     await user.click(sortControl(/planet/i));
 
-    expect(renderedNames()).toEqual(['Alpha b', 'Beta c', 'Gamma d']);
-  });
-
-  it('sorts planets with no measurement last in both directions', async () => {
-    const user = userEvent.setup();
-    renderTable({
-      planets: [
-        makePlanet({ pl_name: 'Unmeasured', pl_rade: null }),
-        makePlanet({ pl_name: 'Small', pl_rade: 1 }),
-        makePlanet({ pl_name: 'Large', pl_rade: 9 }),
-      ],
-    });
-
-    await user.click(sortControl(/radius/i));
-    expect(renderedNames()).toEqual(['Large', 'Small', 'Unmeasured']);
-
-    await user.click(sortControl(/radius/i));
-    expect(renderedNames()).toEqual(['Small', 'Large', 'Unmeasured']);
-  });
-
-  it('sorts numerically rather than lexicographically', async () => {
-    const user = userEvent.setup();
-    renderTable({
-      planets: [
-        makePlanet({ pl_name: 'Nine', sy_dist: 9 }),
-        makePlanet({ pl_name: 'Eighty', sy_dist: 80 }),
-        makePlanet({ pl_name: 'Hundred', sy_dist: 100 }),
-      ],
-    });
-
-    await user.click(sortControl(/distance/i));
-
-    expect(renderedNames()).toEqual(['Hundred', 'Eighty', 'Nine']);
+    expect(onSort).toHaveBeenCalledWith('pl_name');
   });
 });
 
@@ -207,60 +217,47 @@ describe('PlanetTable ESI column', () => {
     expect(esiCell(1)).not.toHaveTextContent('Not scored');
   });
 
-  it('sorts unscored planets last in both directions, with a real 0 ranked among the scored', async () => {
-    const user = userEvent.setup();
-    renderTable({ planets: [UNSCORED, MIDDLING, ZERO, SCORED] });
-
-    await user.click(esiSortButton());
-    expect(renderedNames()).toEqual(['Scored', 'Middling', 'Zero', 'Unscored']);
-
-    await user.click(esiSortButton());
-    expect(renderedNames()).toEqual(['Zero', 'Middling', 'Scored', 'Unscored']);
-  });
-
-  it('reports its sort state through aria-sort as the direction toggles', async () => {
-    const user = userEvent.setup();
-    renderTable();
+  it('reports its sort state through aria-sort in both directions', () => {
+    const { sortBy } = renderTable();
 
     expect(esiHeader()).toHaveAttribute('aria-sort', 'none');
 
-    await user.click(esiSortButton());
+    sortBy('esi', 'desc');
     expect(esiHeader()).toHaveAttribute('aria-sort', 'descending');
 
-    await user.click(esiSortButton());
+    sortBy('esi', 'asc');
     expect(esiHeader()).toHaveAttribute('aria-sort', 'ascending');
   });
 
-  it('drops back to aria-sort="none" once another column takes over', async () => {
-    const user = userEvent.setup();
-    renderTable();
-    await user.click(esiSortButton());
+  it('drops back to aria-sort="none" once another column takes over', () => {
+    const { sortBy } = renderTable();
+    sortBy('esi', 'desc');
 
-    await user.click(sortControl(/planet/i));
+    sortBy('pl_name', 'desc');
 
     expect(esiHeader()).toHaveAttribute('aria-sort', 'none');
   });
 
   it('sorts from the keyboard, because the control is a real button', async () => {
     const user = userEvent.setup();
-    renderTable({ planets: [UNSCORED, MIDDLING, SCORED] });
+    const { onSort } = renderTable({ planets: [UNSCORED, MIDDLING, SCORED] });
 
     esiSortButton().focus();
     await user.keyboard('{Enter}');
 
-    expect(renderedNames()).toEqual(['Scored', 'Middling', 'Unscored']);
+    expect(onSort).toHaveBeenCalledWith('esi');
   });
 
   it('opens the explainer from the info button without sorting', async () => {
     const user = userEvent.setup();
-    renderTable({ planets: [UNSCORED, MIDDLING, SCORED] });
+    const { onSort } = renderTable({ planets: [UNSCORED, MIDDLING, SCORED] });
     const orderBeforeClick = renderedNames();
 
     await user.click(esiInfoButton());
 
     expect(screen.getByRole('dialog')).toBeInTheDocument();
     expect(renderedNames()).toEqual(orderBeforeClick);
-    expect(esiHeader()).toHaveAttribute('aria-sort', 'none');
+    expect(onSort).not.toHaveBeenCalled();
   });
 
   it('does not select a planet when the header info button is used', async () => {
@@ -273,84 +270,172 @@ describe('PlanetTable ESI column', () => {
   });
 });
 
-describe('PlanetTable filtering', () => {
-  it('filters by planet name, case insensitively', async () => {
-    const user = userEvent.setup();
-    renderTable();
-
-    await user.type(screen.getByPlaceholderText(/search exoplanets/i), 'beta');
+describe('PlanetTable pagination', () => {
+  it('shows only the current page of rows', () => {
+    renderTable({ itemsPerPage: 2 });
 
-    expect(renderedNames()).toEqual(['Beta c']);
+    expect(renderedNames()).toEqual(['Alpha b', 'Beta c']);
   });
 
-  it('filters by host star name', async () => {
+  it('advances the rows when the shared control pages forward', async () => {
     const user = userEvent.setup();
-    renderTable();
+    renderTable({ itemsPerPage: 2 });
 
-    await user.type(screen.getByPlaceholderText(/search exoplanets/i), 'Wolf');
+    await user.click(screen.getByRole('button', { name: /next/i }));
 
     expect(renderedNames()).toEqual(['Gamma d']);
   });
 
-  it('offers each discovery method as a filter and applies it', async () => {
+  // The page count belongs to usePagination alone; the table must report it, never recompute it.
+  it('reports the page count it was given rather than deriving one from the rows', () => {
+    render(
+      <PlanetTable
+        planets={[ALPHA, BETA, GAMMA]}
+        pagination={{ page: 2, totalPages: 7, goTo: () => {}, pageItems: (items) => items.slice(0, 1) }}
+        onPlanetClick={() => {}}
+        sortKey="disc_year"
+        sortOrder="desc"
+        onSort={() => {}}
+      />,
+    );
+
+    expect(screen.getByText(/page 2 of 7/i)).toBeInTheDocument();
+  });
+});
+
+describe('PlanetTable selection', () => {
+  it('reports the planet behind the clicked row', async () => {
     const user = userEvent.setup();
-    renderTable();
+    const { onPlanetClick } = renderTable();
 
-    await user.selectOptions(screen.getByRole('combobox'), 'Radial Velocity');
+    await user.click(screen.getByText('Ross 128'));
 
-    expect(renderedNames()).toEqual(['Beta c']);
+    expect(onPlanetClick).toHaveBeenCalledWith(ALPHA);
   });
 });
 
-describe('PlanetTable pagination', () => {
-  it('shows only the current page and reports the unpaginated total', () => {
-    renderTable({ itemsPerPage: 2 });
+describe('PlanetTable planet links (#68)', () => {
+  it('links each name to its planet page, encoding names that need it', () => {
+    renderTable();
 
-    expect(renderedNames()).toEqual(['Beta c', 'Alpha b']);
-    expect(screen.getByText(/page 1 of 2 \(3 planets\)/i)).toBeInTheDocument();
+    expect(nameLink('Alpha b')).toHaveAttribute('href', '/planet/Alpha%20b');
   });
 
-  it('disables Previous on the first page and advances via Next', async () => {
-    const user = userEvent.setup();
-    const { onPageChange } = renderTable({ itemsPerPage: 2 });
-
-    expect(screen.getByRole('button', { name: /previous/i })).toBeDisabled();
-    await user.click(screen.getByRole('button', { name: /next/i }));
+  it('renders a real anchor, so middle-click and copy-link work', () => {
+    renderTable({ planets: [ALPHA] });
 
-    expect(onPageChange).toHaveBeenCalledWith(2);
+    expect(nameLink('Alpha b').tagName).toBe('A');
   });
-});
 
-describe('PlanetTable selection', () => {
-  it('reports the planet behind the clicked row', async () => {
+  // Decision 5: the name navigates, so it must not also fire the row's modal handler.
+  it('does not open the modal when the name link is clicked', async () => {
     const user = userEvent.setup();
     const { onPlanetClick } = renderTable();
 
-    await user.click(screen.getByText('Alpha b'));
+    await user.click(nameLink('Alpha b'));
 
-    expect(onPlanetClick).toHaveBeenCalledWith(ALPHA);
+    expect(onPlanetClick).not.toHaveBeenCalled();
+  });
+
+  it('gives every row both a navigation and a quick-look control, labelled apart', () => {
+    renderTable();
+
+    for (const name of ['Alpha b', 'Beta c', 'Gamma d']) {
+      expect(nameLink(name)).toBeInTheDocument();
+      expect(quickViewButton(name)).toBeInTheDocument();
+    }
+  });
+
+  // One icon-sized control per row would be unlabelled without this; the name disambiguates it.
+  it('names the quick-look control after its planet rather than repeating one generic label', () => {
+    renderTable();
+
+    expect(quickViewButton('Alpha b')).toHaveAccessibleName('Quick view: Alpha b');
+    expect(screen.getAllByRole('button', { name: /^Quick view: / })).toHaveLength(3);
+  });
+
+  it('keeps the quick-look control out of the accessible name of the row', () => {
+    renderTable({ planets: [ALPHA] });
+    const cell = within(screen.getAllByRole('row')[1]).getAllByRole('cell')[0];
+
+    expect(within(cell).getByRole('button')).toHaveTextContent('');
+    expect(cell.textContent).toBe('Alpha b');
+  });
+
+  it('leaves the quick-look icon out of the control\u2019s accessible name', () => {
+    renderTable({ planets: [ALPHA] });
+    const icon = quickViewButton('Alpha b').querySelector('svg');
+
+    expect(icon).toHaveAttribute('aria-hidden', 'true');
+    expect(quickViewButton('Alpha b')).toHaveAccessibleName('Quick view: Alpha b');
   });
 });
 
 describe('PlanetTable accessibility (#6)', () => {
-  // Encodes the open keyboard barrier: both turn red the moment sort headers and rows become operable, forcing these markers out.
-  it.fails('exposes each sort header as a keyboard-activatable control reporting aria-sort', async () => {
+  it('exposes every sortable header as a keyboard-activatable control, not a click-only cell', async () => {
     const user = userEvent.setup();
-    renderTable();
-    const header = screen.getByRole('columnheader', { name: /planet/i });
+    const { onSort } = renderTable();
+
+    for (const [column, key] of SORTABLE_COLUMNS) {
+      sortControl(column).focus();
+      await user.keyboard('{Enter}');
 
-    await user.click(within(header).getByRole('button'));
+      expect(onSort).toHaveBeenLastCalledWith(key);
+    }
+  });
+
+  it('reports the active column through aria-sort, whichever column it is', () => {
+    const { sortBy } = renderTable();
 
-    expect(header).toHaveAttribute('aria-sort', 'descending');
+    for (const [column, key] of SORTABLE_COLUMNS) {
+      sortBy(key, 'desc');
+
+      expect(screen.getByRole('columnheader', { name: column })).toHaveAttribute('aria-sort', 'descending');
+    }
   });
 
-  it.fails('opens a planet row from the keyboard', async () => {
+  it('leaves the unsortable column free of a sort control and of aria-sort', () => {
+    renderTable();
+    const header = screen.getByRole('columnheader', { name: /star/i });
+
+    expect(within(header).queryByRole('button')).not.toBeInTheDocument();
+    expect(header).not.toHaveAttribute('aria-sort');
+  });
+
+  it('opens a planet from the keyboard, naming it so the target is announced', async () => {
     const user = userEvent.setup();
     const { onPlanetClick } = renderTable();
 
-    screen.getAllByRole('row')[1].focus();
+    quickViewButton('Beta c').focus();
     await user.keyboard('{Enter}');
 
     expect(onPlanetClick).toHaveBeenCalledWith(BETA);
   });
+
+  it('keeps the row a row, so table navigation still works', () => {
+    renderTable();
+
+    expect(screen.getAllByRole('row')).toHaveLength(4);
+    expect(screen.getAllByRole('row')[1]).not.toHaveAttribute('role');
+  });
+
+  it('reports the planet once when its trigger is clicked, not twice via the row', async () => {
+    const user = userEvent.setup();
+    const { onPlanetClick } = renderTable();
+
+    await user.click(quickViewButton('Alpha b'));
+
+    expect(onPlanetClick).toHaveBeenCalledTimes(1);
+    expect(onPlanetClick).toHaveBeenCalledWith(ALPHA);
+  });
+
+  it('still opens a planet when the row is clicked away from its trigger', async () => {
+    const user = userEvent.setup();
+    const { onPlanetClick } = renderTable();
+
+    await user.click(screen.getByText('Ross 128'));
+
+    expect(onPlanetClick).toHaveBeenCalledTimes(1);
+    expect(onPlanetClick).toHaveBeenCalledWith(ALPHA);
+  });
 });
diff --git a/exoplanethub.com/components/explore/PlanetTable.tsx b/exoplanethub.com/components/explore/PlanetTable.tsx
index 1d1e54d..0d7cfbb 100644
--- a/exoplanethub.com/components/explore/PlanetTable.tsx
+++ b/exoplanethub.com/components/explore/PlanetTable.tsx
@@ -1,36 +1,64 @@
 'use client';
-import { useState, useMemo } from 'react';
+import { ReactNode } from 'react';
 import { PlanetSummary } from '@/lib/mockPlanets';
+import PlanetNameLink from '@/components/planet/PlanetNameLink';
+import { SortKey, SortOrder } from '@/lib/planetFilters';
+import { measurement } from '@/lib/planetStats';
+import { Pagination } from '@/lib/usePagination';
 import ESIInfoButton from './ESIInfoButton';
+import PaginationControls from './PaginationControls';
 import { getESIBand } from './esiBands';
 import styles from './PlanetTable.module.css';
 
 interface PlanetTableProps {
   planets: PlanetSummary[];
-  page: number;
-  itemsPerPage: number;
-  onPageChange: (page: number) => void;
+  pagination: Pagination;
   onPlanetClick: (planet: PlanetSummary) => void;
+  sortKey: SortKey;
+  sortOrder: SortOrder;
+  onSort: (key: SortKey) => void;
 }
 
-type SortKey = 'pl_name' | 'sy_dist' | 'pl_rade' | 'discoverymethod' | 'disc_year' | 'esi';
-type SortOrder = 'asc' | 'desc';
-type SortValue = PlanetSummary[SortKey];
+function SortableHeader({ label, column, sortKey, sortOrder, onSort, children }: {
+  label: string;
+  column: SortKey;
+  sortKey: SortKey;
+  sortOrder: SortOrder;
+  onSort: (key: SortKey) => void;
+  children?: ReactNode;
+}) {
+  const active = sortKey === column;
 
-// Unmeasured planets sort last in both directions: null coerces to 0 under <, which would
-// otherwise rank every planet NASA has no value for ahead of the real measurements.
-function compareSortValues(a: SortValue, b: SortValue, order: SortOrder): number {
-  if (a == null || b == null) return a == null && b == null ? 0 : a == null ? 1 : -1;
-
-  const direction = order === 'asc' ? 1 : -1;
-
-  if (typeof a === 'string' && typeof b === 'string') {
-    const left = a.toLowerCase();
-    const right = b.toLowerCase();
-    return left === right ? 0 : (left < right ? -1 : 1) * direction;
-  }
+  return (
+    <th aria-sort={active ? (sortOrder === 'asc' ? 'ascending' : 'descending') : 'none'}>
+      <span className={styles.headerContent}>
+        <button className={styles.sortButton} onClick={() => onSort(column)}>
+          {label}
+          {active && <span className={styles.sortIcon} aria-hidden="true">{sortOrder === 'asc' ? '▲' : '▼'}</span>}
+        </button>
+        {children}
+      </span>
+    </th>
+  );
+}
 
-  return (Number(a) - Number(b)) * direction;
+function EyeIcon() {
+  return (
+    <svg
+      className={styles.quickViewIcon}
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      aria-hidden="true"
+      focusable="false"
+    >
+      <path d="M1.5 12S5.5 5.5 12 5.5 22.5 12 22.5 12 18.5 18.5 12 18.5 1.5 12 1.5 12Z" />
+      <circle cx="12" cy="12" r="3.25" />
+    </svg>
+  );
 }
 
 function ESIScore({ score }: { score: number | undefined }) {
@@ -53,109 +81,54 @@ function ESIScore({ score }: { score: number | undefined }) {
   );
 }
 
-export default function PlanetTable({ planets, page, itemsPerPage, onPageChange, onPlanetClick }: PlanetTableProps) {
-  const [search, setSearch] = useState('');
-  const [typeFilter, setTypeFilter] = useState('all');
-  const [sortKey, setSortKey] = useState<SortKey>('disc_year');
-  const [sortOrder, setSortOrder] = useState<SortOrder>('desc');
-
-  const handleSort = (key: SortKey) => {
-    if (sortKey === key) {
-      setSortOrder(sortOrder === 'asc' ? 'desc' : 'asc');
-    } else {
-      setSortKey(key);
-      setSortOrder('desc');
-    }
-  };
-
-  const filteredAndSorted = useMemo(() => {
-    let result = [...planets];
+export default function PlanetTable({ planets, pagination, onPlanetClick, sortKey, sortOrder, onSort }: PlanetTableProps) {
+  const { pageItems } = pagination;
 
-    if (search) {
-      result = result.filter(p => 
-        p.pl_name.toLowerCase().includes(search.toLowerCase()) ||
-        (p.hostname && p.hostname.toLowerCase().includes(search.toLowerCase()))
-      );
-    }
+  const sortProps = { sortKey, sortOrder, onSort };
 
-    if (typeFilter !== 'all') {
-      result = result.filter(p => p.discoverymethod === typeFilter);
-    }
-
-    result.sort((a, b) => compareSortValues(a[sortKey], b[sortKey], sortOrder));
-
-    return result;
-  }, [planets, search, typeFilter, sortKey, sortOrder]);
-
-  const esiAriaSort = sortKey !== 'esi' ? 'none' : sortOrder === 'asc' ? 'ascending' : 'descending';
-
-  const paginatedPlanets = filteredAndSorted.slice((page - 1) * itemsPerPage, page * itemsPerPage);
-  const totalPages = Math.ceil(filteredAndSorted.length / itemsPerPage);
-
-  const methods = planets.map(p => p.discoverymethod).filter((m): m is string => Boolean(m));
-  const types = ['all', ...Array.from(new Set(methods))];
+  const paginatedPlanets = pageItems(planets);
 
   return (
     <>
-      <div className={styles.controls}>
-        <input
-          type="text"
-          placeholder="Search exoplanets..."
-          value={search}
-          onChange={(e) => setSearch(e.target.value)}
-          className={styles.searchInput}
-        />
-        <select
-          value={typeFilter}
-          onChange={(e) => setTypeFilter(e.target.value)}
-          className={styles.select}
-        >
-          {types.map(type => (
-            <option key={type} value={type}>
-              {type === 'all' ? 'All Types' : type}
-            </option>
-          ))}
-        </select>
-      </div>
-
       <div className={styles.tableContainer} role="region" aria-label="Exoplanet results" tabIndex={0}>
         <table className={styles.table}>
           <thead>
             <tr>
-              <th onClick={() => handleSort('pl_name')}>
-                Planet {sortKey === 'pl_name' && <span className={styles.sortIcon}>{sortOrder === 'asc' ? '▲' : '▼'}</span>}
-              </th>
+              <SortableHeader label="Planet" column="pl_name" {...sortProps} />
               <th>Star</th>
-              <th onClick={() => handleSort('discoverymethod')}>
-                Method {sortKey === 'discoverymethod' && <span className={styles.sortIcon}>{sortOrder === 'asc' ? '▲' : '▼'}</span>}
-              </th>
-              <th onClick={() => handleSort('pl_rade')}>
-                Radius {sortKey === 'pl_rade' && <span className={styles.sortIcon}>{sortOrder === 'asc' ? '▲' : '▼'}</span>}
-              </th>
-              <th onClick={() => handleSort('sy_dist')}>
-                Distance {sortKey === 'sy_dist' && <span className={styles.sortIcon}>{sortOrder === 'asc' ? '▲' : '▼'}</span>}
-              </th>
-              <th onClick={() => handleSort('disc_year')}>
-                Discovered {sortKey === 'disc_year' && <span className={styles.sortIcon}>{sortOrder === 'asc' ? '▲' : '▼'}</span>}
-              </th>
-              <th className={styles.esiHeader} aria-sort={esiAriaSort}>
-                <span className={styles.esiHeaderContent}>
-                  <button className={styles.sortButton} onClick={() => handleSort('esi')}>
-                    ESI {sortKey === 'esi' && <span className={styles.sortIcon} aria-hidden="true">{sortOrder === 'asc' ? '▲' : '▼'}</span>}
-                  </button>
-                  <ESIInfoButton />
-                </span>
-              </th>
+              <SortableHeader label="Method" column="discoverymethod" {...sortProps} />
+              <SortableHeader label="Radius" column="pl_rade" {...sortProps} />
+              <SortableHeader label="Distance" column="sy_dist" {...sortProps} />
+              <SortableHeader label="Discovered" column="disc_year" {...sortProps} />
+              <SortableHeader label="ESI" column="esi" {...sortProps}>
+                <ESIInfoButton />
+              </SortableHeader>
             </tr>
           </thead>
           <tbody>
             {paginatedPlanets.map((planet) => (
+              // A mouse-only convenience: the row keeps its row semantics, so the cell's two controls carry the keyboard.
               <tr key={planet.pl_name} onClick={() => onPlanetClick(planet)}>
-                <td className={styles.planetName}>{planet.pl_name}</td>
+                <td className={styles.planetName}>
+                  <span className={styles.nameCell}>
+                    <PlanetNameLink name={planet.pl_name} onClick={(e) => e.stopPropagation()} />
+                    <button
+                      className={styles.quickView}
+                      aria-label={`Quick view: ${planet.pl_name}`}
+                      title="Quick view"
+                      onClick={(e) => {
+                        e.stopPropagation();
+                        onPlanetClick(planet);
+                      }}
+                    >
+                      <EyeIcon />
+                    </button>
+                  </span>
+                </td>
                 <td>{planet.hostname || 'N/A'}</td>
                 <td>{planet.discoverymethod || 'N/A'}</td>
-                <td>{planet.pl_rade ? planet.pl_rade.toFixed(2) : 'N/A'}× Earth</td>
-                <td>{planet.sy_dist ? planet.sy_dist.toFixed(2) : 'N/A'} pc</td>
+                <td>{measurement(planet.pl_rade, '× Earth') ?? 'N/A'}</td>
+                <td>{measurement(planet.sy_dist, 'pc') ?? 'N/A'}</td>
                 <td>{planet.disc_year || 'N/A'}</td>
                 <td className={styles.esiCell}><ESIScore score={planet.esi} /></td>
               </tr>
@@ -164,25 +137,7 @@ export default function PlanetTable({ planets, page, itemsPerPage, onPageChange,
         </table>
       </div>
 
-      <div className={styles.pagination}>
-        <button 
-          onClick={() => onPageChange(Math.max(1, page - 1))} 
-          disabled={page === 1}
-          className={styles.paginationBtn}
-        >
-          Previous
-        </button>
-        <span className={styles.pageInfo}>
-          Page {page} of {totalPages} ({filteredAndSorted.length} planets)
-        </span>
-        <button 
-          onClick={() => onPageChange(Math.min(totalPages, page + 1))} 
-          disabled={page === totalPages}
-          className={styles.paginationBtn}
-        >
-          Next
-        </button>
-      </div>
+      <PaginationControls pagination={pagination} />
     </>
   );
 }
diff --git a/exoplanethub.com/components/explore/RangeFilter.module.css b/exoplanethub.com/components/explore/RangeFilter.module.css
new file mode 100644
index 0000000..f7fc16d
--- /dev/null
+++ b/exoplanethub.com/components/explore/RangeFilter.module.css
@@ -0,0 +1,132 @@
+.group {
+  border: 1px solid var(--color-border);
+  border-radius: 12px;
+  padding: 10px 14px 12px;
+  min-width: 240px;
+  flex: 1;
+}
+
+.legend {
+  color: var(--color-text);
+  font-size: 13px;
+  font-weight: 600;
+  padding: 0 6px;
+}
+
+.unit {
+  color: var(--color-text-muted);
+  font-weight: 400;
+}
+
+.bounds {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.boundLabel {
+  color: var(--color-text-muted);
+  font-size: 12px;
+}
+
+.number {
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  padding: 6px 8px;
+  color: var(--color-text);
+  font-size: 14px;
+  min-width: 0;
+  flex: 1;
+}
+
+.number:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
+
+.track {
+  position: relative;
+  height: 26px;
+  margin-top: 6px;
+}
+
+.track::before {
+  content: '';
+  position: absolute;
+  top: 11px;
+  left: 0;
+  right: 0;
+  height: 4px;
+  border-radius: 999px;
+  background: var(--color-border);
+}
+
+/* Both thumbs sit on one track, so the inputs overlap and only their thumbs may take the pointer. */
+.thumb {
+  position: absolute;
+  left: 0;
+  width: 100%;
+  height: 26px;
+  margin: 0;
+  background: none;
+  pointer-events: none;
+  appearance: none;
+  -webkit-appearance: none;
+}
+
+.thumb::-webkit-slider-runnable-track {
+  background: transparent;
+  height: 26px;
+}
+
+.thumb::-moz-range-track {
+  background: transparent;
+  height: 26px;
+}
+
+.thumb::-webkit-slider-thumb {
+  pointer-events: auto;
+  appearance: none;
+  -webkit-appearance: none;
+  width: 16px;
+  height: 16px;
+  margin-top: 5px;
+  border: 2px solid var(--color-background);
+  border-radius: 50%;
+  background: var(--color-primary);
+  cursor: pointer;
+}
+
+.thumb::-moz-range-thumb {
+  pointer-events: auto;
+  width: 16px;
+  height: 16px;
+  border: 2px solid var(--color-background);
+  border-radius: 50%;
+  background: var(--color-primary);
+  cursor: pointer;
+}
+
+/* The UA ring is browser-specific and barely visible on a dark track, so the thumb carries its own. */
+.thumb:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+  border-radius: 999px;
+}
+
+.thumb:focus-visible::-webkit-slider-thumb {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
+
+.thumb:focus-visible::-moz-range-thumb {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
+
+.note {
+  color: var(--color-text-muted);
+  font-size: 12px;
+  margin-top: 8px;
+}
diff --git a/exoplanethub.com/components/explore/RangeFilter.tsx b/exoplanethub.com/components/explore/RangeFilter.tsx
new file mode 100644
index 0000000..105bad2
--- /dev/null
+++ b/exoplanethub.com/components/explore/RangeFilter.tsx
@@ -0,0 +1,145 @@
+'use client';
+import { useId, useMemo } from 'react';
+import { Range, isRangeActive, parseBound } from '@/lib/planetFilters';
+import { logScale, toSignificantDigits } from './logScale';
+import styles from './RangeFilter.module.css';
+
+// A dragged thumb parks at its neighbour rather than crossing it. Typed bounds are taken
+// literally instead, so the number inputs still accept a crossed pair and match nothing.
+function withUncrossedBound(range: Range, edge: 'min' | 'max', next: number): Range {
+  return edge === 'min'
+    ? { ...range, min: range.max === null ? next : Math.min(next, range.max) }
+    : { ...range, max: range.min === null ? next : Math.max(next, range.min) };
+}
+
+interface RangeFilterProps {
+  label: string;
+  unit: string;
+  missingNote: string;
+  extent: Range;
+  value: Range;
+  onChange: (next: Range) => void;
+}
+
+export default function RangeFilter({
+  label,
+  unit,
+  missingNote,
+  extent,
+  value,
+  onChange,
+}: RangeFilterProps) {
+  const ids = useId();
+  const scale = useMemo(() => logScale(extent), [extent]);
+
+  const noteId = `${ids}-note`;
+  const describedBy = isRangeActive(value) ? noteId : undefined;
+
+  // parseBound also guards the URL, where a non-numeric bound invalidates the whole range; a
+  // type="number" input can only hand back '' or a number, so undefined here just means unset.
+  const setBound = (edge: 'min' | 'max', raw: string) =>
+    onChange({ ...value, [edge]: parseBound(raw) ?? null });
+
+  const extentText = {
+    min: scale ? String(toSignificantDigits(scale.min)) : '',
+    max: scale ? String(toSignificantDigits(scale.max)) : '',
+  };
+
+  // Crossed bounds match nothing, and thumbs drawn from them read as the range they swap into.
+  const crossed = value.min !== null && value.max !== null && value.min > value.max;
+
+  const thumbs =
+    scale && !crossed
+      ? {
+          steps: scale.steps,
+          toValue: scale.toValue,
+          lower: scale.toPosition(value.min ?? scale.min),
+          upper: scale.toPosition(value.max ?? scale.max),
+        }
+      : null;
+
+  // Both thumbs stack at the top of the track, and only the lower one has anywhere to go, so it
+  // has to out-paint the upper to be draggable at all.
+  const raiseLowerThumb = thumbs !== null && thumbs.lower === thumbs.steps;
+
+  return (
+    <fieldset className={styles.group}>
+      <legend className={styles.legend}>
+        {label} <span className={styles.unit}>({unit})</span>
+      </legend>
+
+      <div className={styles.bounds}>
+        <label className={styles.boundLabel} htmlFor={`${ids}-min`}>
+          Min
+        </label>
+        <input
+          id={`${ids}-min`}
+          type="number"
+          className={styles.number}
+          value={value.min ?? ''}
+          placeholder={extentText.min}
+          aria-describedby={describedBy}
+          onChange={(event) => setBound('min', event.target.value)}
+        />
+        <label className={styles.boundLabel} htmlFor={`${ids}-max`}>
+          Max
+        </label>
+        <input
+          id={`${ids}-max`}
+          type="number"
+          className={styles.number}
+          value={value.max ?? ''}
+          placeholder={extentText.max}
+          aria-describedby={describedBy}
+          onChange={(event) => setBound('max', event.target.value)}
+        />
+      </div>
+
+      {scale && (
+        <div className={styles.track}>
+          {thumbs && (
+            <>
+              <input
+                type="range"
+                className={styles.thumb}
+                style={raiseLowerThumb ? { zIndex: 1 } : undefined}
+                aria-label={`${label} lower bound`}
+                aria-valuetext={`${value.min ?? extentText.min} ${unit}`}
+                aria-describedby={describedBy}
+                min={0}
+                max={thumbs.steps}
+                value={thumbs.lower}
+                onChange={(event) =>
+                  onChange(
+                    withUncrossedBound(value, 'min', thumbs.toValue(Number(event.target.value)))
+                  )
+                }
+              />
+              <input
+                type="range"
+                className={styles.thumb}
+                aria-label={`${label} upper bound`}
+                aria-valuetext={`${value.max ?? extentText.max} ${unit}`}
+                aria-describedby={describedBy}
+                min={0}
+                max={thumbs.steps}
+                value={thumbs.upper}
+                onChange={(event) =>
+                  onChange(
+                    withUncrossedBound(value, 'max', thumbs.toValue(Number(event.target.value)))
+                  )
+                }
+              />
+            </>
+          )}
+        </div>
+      )}
+
+      {describedBy && (
+        <p className={styles.note} id={noteId}>
+          {missingNote}
+        </p>
+      )}
+    </fieldset>
+  );
+}
diff --git a/exoplanethub.com/components/explore/ResultsCount.module.css b/exoplanethub.com/components/explore/ResultsCount.module.css
new file mode 100644
index 0000000..6722ee9
--- /dev/null
+++ b/exoplanethub.com/components/explore/ResultsCount.module.css
@@ -0,0 +1,16 @@
+.count {
+  color: var(--color-text-muted);
+  font-size: 14px;
+  margin-bottom: 12px;
+}
+
+.announcement {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  margin: -1px;
+  padding: 0;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+}
diff --git a/exoplanethub.com/components/explore/ResultsCount.test.tsx b/exoplanethub.com/components/explore/ResultsCount.test.tsx
new file mode 100644
index 0000000..8986178
--- /dev/null
+++ b/exoplanethub.com/components/explore/ResultsCount.test.tsx
@@ -0,0 +1,52 @@
+import { act, render, screen } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import ResultsCount from './ResultsCount';
+
+function visibleText() {
+  return screen.getByText(/^\d+ of \d+ planets$/i);
+}
+
+function announcement() {
+  return screen.getByRole('status');
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe('ResultsCount', () => {
+  it('shows how much of the archive survived the filters', () => {
+    render(<ResultsCount visible={12} total={6000} />);
+
+    expect(visibleText()).toBeInTheDocument();
+    expect(visibleText()).toHaveTextContent('12 of 6000 planets');
+  });
+
+  it('keeps the seen number from being read twice by hiding it from the announcement', () => {
+    render(<ResultsCount visible={12} total={6000} />);
+
+    expect(visibleText()).toHaveAttribute('aria-hidden', 'true');
+  });
+
+  it('announces the first count without waiting, so the page opens complete', () => {
+    render(<ResultsCount visible={12} total={6000} />);
+
+    expect(announcement()).toHaveTextContent('Showing 12 of 6000 planets');
+  });
+
+  it('holds the announcement back while the count is still moving', () => {
+    vi.useFakeTimers();
+    const { rerender } = render(<ResultsCount visible={12} total={6000} />);
+
+    rerender(<ResultsCount visible={9} total={6000} />);
+    act(() => vi.advanceTimersByTime(200));
+    rerender(<ResultsCount visible={4} total={6000} />);
+
+    expect(visibleText()).toHaveTextContent('4 of 6000 planets');
+    expect(announcement()).toHaveTextContent('Showing 12 of 6000 planets');
+
+    act(() => vi.advanceTimersByTime(1000));
+
+    expect(announcement()).toHaveTextContent('Showing 4 of 6000 planets');
+  });
+});
diff --git a/exoplanethub.com/components/explore/ResultsCount.tsx b/exoplanethub.com/components/explore/ResultsCount.tsx
new file mode 100644
index 0000000..bebe75b
--- /dev/null
+++ b/exoplanethub.com/components/explore/ResultsCount.tsx
@@ -0,0 +1,27 @@
+'use client';
+import { useEffect, useState } from 'react';
+import styles from './ResultsCount.module.css';
+
+const ANNOUNCE_DELAY_MS = 500;
+
+export default function ResultsCount({ visible, total }: { visible: number; total: number }) {
+  const summary = `${visible} of ${total} planets`;
+  const [announced, setAnnounced] = useState(summary);
+
+  // Re-running on every count is the debounce: filtering is instant, so announcing it per keystroke
+  // would talk over a visitor still typing. The seen number never waits; only the spoken one does.
+  useEffect(() => {
+    const timer = setTimeout(() => setAnnounced(summary), ANNOUNCE_DELAY_MS);
+
+    return () => clearTimeout(timer);
+  }, [summary]);
+
+  return (
+    <p className={styles.count}>
+      <span aria-hidden="true">{summary}</span>
+      <span className={styles.announcement} role="status">
+        Showing {announced}
+      </span>
+    </p>
+  );
+}
diff --git a/exoplanethub.com/components/explore/esiBands.test.ts b/exoplanethub.com/components/explore/esiBands.test.ts
index 8a9d716..0023f59 100644
--- a/exoplanethub.com/components/explore/esiBands.test.ts
+++ b/exoplanethub.com/components/explore/esiBands.test.ts
@@ -12,6 +12,7 @@ describe('ESI_BANDS', () => {
 
     expect(boundaries).toEqual([...boundaries].sort((a, b) => b - a));
     expect(boundaries[boundaries.length - 1]).toBe(0);
+    expect(ESI_BANDS.map((band) => band.tier)).toEqual([1, 2, 3, 4]);
   });
 
   it('styles every band with custom properties the theme actually defines', () => {
diff --git a/exoplanethub.com/components/explore/esiBands.ts b/exoplanethub.com/components/explore/esiBands.ts
index 46e04b7..4f7d0ce 100644
--- a/exoplanethub.com/components/explore/esiBands.ts
+++ b/exoplanethub.com/components/explore/esiBands.ts
@@ -1,17 +1,21 @@
+export type ESIBandTier = 1 | 2 | 3 | 4;
+
 export interface ESIBand {
   minScore: number;
   range: string;
   label: string;
   description: string;
+  // Selects the theme's esiBand<tier> colour pair, for renderers that cannot resolve a custom property.
+  tier: ESIBandTier;
   style: { background: string; color: string };
 }
 
 const BAND_DEFINITIONS = [
-  { minScore: 85, label: 'Highly Earth-like', description: 'Close to Earth in size, temperature, and mass' },
-  { minScore: 70, label: 'Good similarity', description: 'Broadly Earth-like across the measured properties' },
-  { minScore: 50, label: 'Moderate similarity', description: 'Some properties resemble Earth, others differ sharply' },
-  { minScore: 0, label: 'Low similarity', description: 'Little resemblance to Earth in the measured properties' },
-];
+  { minScore: 85, tier: 1, label: 'Highly Earth-like', description: 'Close to Earth in size, temperature, and mass' },
+  { minScore: 70, tier: 2, label: 'Good similarity', description: 'Broadly Earth-like across the measured properties' },
+  { minScore: 50, tier: 3, label: 'Moderate similarity', description: 'Some properties resemble Earth, others differ sharply' },
+  { minScore: 0, tier: 4, label: 'Low similarity', description: 'Little resemblance to Earth in the measured properties' },
+] as const;
 
 const MAX_SCORE = 100;
 
@@ -26,8 +30,8 @@ export const ESI_BANDS: readonly ESIBand[] = BAND_DEFINITIONS.map((band, index)
   ...band,
   range: describeRange(index),
   style: {
-    background: `var(--color-esi-band-${index + 1})`,
-    color: `var(--color-esi-band-${index + 1}-text)`,
+    background: `var(--color-esi-band-${band.tier})`,
+    color: `var(--color-esi-band-${band.tier}-text)`,
   },
 }));
 
diff --git a/exoplanethub.com/components/explore/logScale.test.ts b/exoplanethub.com/components/explore/logScale.test.ts
new file mode 100644
index 0000000..e72c443
--- /dev/null
+++ b/exoplanethub.com/components/explore/logScale.test.ts
@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+import { logScale, toSignificantDigits } from '@/components/explore/logScale';
+
+const DECADES = logScale({ min: 1, max: 1000 })!;
+
+describe('logScale availability', () => {
+  it.each([
+    ['nothing was measured', { min: null, max: null }],
+    ['only a floor is known', { min: 1, max: null }],
+    ['only a ceiling is known', { min: null, max: 1000 }],
+    ['every planet shares one value, leaving no span', { min: 5, max: 5 }],
+    ['the extent is inverted', { min: 10, max: 1 }],
+    ['a bad record puts zero at the bottom, which has no logarithm', { min: 0, max: 100 }],
+    ['a bad record puts a negative at the bottom', { min: -3, max: 100 }],
+  ])('draws no track when %s', (_label, extent) => {
+    expect(logScale(extent)).toBeNull();
+  });
+});
+
+describe('logScale mapping', () => {
+  it('puts the extent at the two ends of the track', () => {
+    expect(DECADES.toPosition(1)).toBe(0);
+    expect(DECADES.toPosition(1000)).toBe(DECADES.steps);
+  });
+
+  it('gives every decade an equal share of the track, which is the point of the log scale', () => {
+    expect(DECADES.toValue(DECADES.steps / 3)).toBeCloseTo(10, 5);
+    expect(DECADES.toValue((DECADES.steps * 2) / 3)).toBeCloseTo(100, 5);
+  });
+
+  it('gives the shortest orbits a reachable share of the track a linear one would crush', () => {
+    const periods = logScale({ min: 0.09, max: 8000000 })!;
+    const linear = Math.round((periods.steps * (1 - 0.09)) / (8000000 - 0.09));
+
+    expect(linear).toBe(0);
+    expect(periods.toPosition(1)).toBeGreaterThan(periods.steps / 10);
+  });
+
+  it('returns the extent itself at the ends, so the planets defining it are never rounded out', () => {
+    const awkward = logScale({ min: 0.09126, max: 77.342 })!;
+
+    expect(awkward.toValue(0)).toBe(0.09126);
+    expect(awkward.toValue(awkward.steps)).toBe(77.342);
+  });
+
+  it('rounds interior values to bounds a visitor could have typed', () => {
+    expect(String(logScale({ min: 0.09, max: 8000000 })!.toValue(400))).not.toMatch(/\d{6}\./);
+  });
+
+  it.each([1.5, 12, 480, 999])('round-trips %s to within the precision it keeps', (value) => {
+    const restored = DECADES.toValue(DECADES.toPosition(value));
+
+    expect(Math.abs(restored - value) / value).toBeLessThan(0.005);
+  });
+
+  it.each([
+    ['below the extent', 0.001, 0],
+    ['above the extent', 5000, DECADES.steps],
+  ])('clamps a value from the URL that sits %s onto the track', (_label, value, expected) => {
+    expect(DECADES.toPosition(value)).toBe(expected);
+  });
+
+  it('clamps a position past either end rather than inventing a value off the track', () => {
+    expect(DECADES.toValue(-50)).toBe(1);
+    expect(DECADES.toValue(DECADES.steps + 50)).toBe(1000);
+  });
+});
+
+describe('toSignificantDigits', () => {
+  it.each([
+    [0.0912345, 0.0912],
+    [1234567, 1230000],
+    [1, 1],
+  ])('rounds %s to %s', (value, expected) => {
+    expect(toSignificantDigits(value)).toBe(expected);
+  });
+
+  it('stays plain enough for a URL rather than switching to exponent notation', () => {
+    expect(String(toSignificantDigits(8123456))).toBe('8120000');
+  });
+});
diff --git a/exoplanethub.com/components/explore/logScale.ts b/exoplanethub.com/components/explore/logScale.ts
new file mode 100644
index 0000000..7f7e8e1
--- /dev/null
+++ b/exoplanethub.com/components/explore/logScale.ts
@@ -0,0 +1,45 @@
+import { Range } from '@/lib/planetFilters';
+
+const STEPS = 1000;
+const SIGNIFICANT_DIGITS = 3;
+
+export interface LogScale {
+  steps: number;
+  min: number;
+  max: number;
+  toPosition(value: number): number;
+  toValue(position: number): number;
+}
+
+function clamp(value: number, low: number, high: number): number {
+  return Math.min(high, Math.max(low, value));
+}
+
+export function toSignificantDigits(value: number): number {
+  return Number(value.toPrecision(SIGNIFICANT_DIGITS));
+}
+
+// These quantities span up to eight orders of magnitude, so a linear track spends every pixel on
+// the largest planets. Null means no track is possible and the number inputs stand alone.
+export function logScale({ min, max }: Range): LogScale | null {
+  if (min === null || max === null || min <= 0 || max <= min) return null;
+
+  const base = Math.log10(min);
+  const span = Math.log10(max) - base;
+
+  return {
+    steps: STEPS,
+    min,
+    max,
+    toPosition: (value) => Math.round((STEPS * (Math.log10(clamp(value, min, max)) - base)) / span),
+
+    // The ends return the extent itself: rounding a computed endpoint could land just inside the
+    // track and silently drop the very planet that defines it.
+    toValue: (position) => {
+      if (position <= 0) return min;
+      if (position >= STEPS) return max;
+
+      return toSignificantDigits(10 ** (base + (position / STEPS) * span));
+    },
+  };
+}
diff --git a/exoplanethub.com/components/home/LatestDiscoveries.test.tsx b/exoplanethub.com/components/home/LatestDiscoveries.test.tsx
new file mode 100644
index 0000000..396642d
--- /dev/null
+++ b/exoplanethub.com/components/home/LatestDiscoveries.test.tsx
@@ -0,0 +1,59 @@
+import { render, screen, within } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { LatestDiscovery } from '@/lib/latestDiscoveries';
+import { DiscoveryList } from '@/components/home/LatestDiscoveries';
+
+const { fetchLatestDiscoveries } = vi.hoisted(() => ({ fetchLatestDiscoveries: vi.fn() }));
+
+vi.mock('next/server', () => ({ connection: async () => {} }));
+vi.mock('@/lib/latestDiscoveries', () => ({ fetchLatestDiscoveries }));
+
+const KEPLER: LatestDiscovery = {
+  pl_name: 'Kepler-452 b',
+  hostname: 'Kepler-452',
+  disc_year: 2015,
+  discoverymethod: 'Transit',
+};
+
+async function renderList(planets: LatestDiscovery[]) {
+  fetchLatestDiscoveries.mockResolvedValue({ status: 'ok', planets });
+  render(await DiscoveryList());
+}
+
+beforeEach(() => {
+  fetchLatestDiscoveries.mockReset();
+});
+
+describe('LatestDiscoveries planet links (#68)', () => {
+  it('links each name to its planet page, encoding names that need it', async () => {
+    await renderList([KEPLER]);
+
+    expect(screen.getByRole('link', { name: 'Kepler-452 b' })).toHaveAttribute(
+      'href',
+      '/planet/Kepler-452%20b',
+    );
+  });
+
+  it('keeps the name a heading, so the feed still reads as a list of named worlds', async () => {
+    await renderList([KEPLER]);
+
+    const heading = screen.getByRole('heading', { name: 'Kepler-452 b' });
+    expect(within(heading).getByRole('link')).toBeInTheDocument();
+  });
+
+  // The names simply become links here; the table's two-control pattern must not spread.
+  it('gives each entry one control and no quick-look button', async () => {
+    await renderList([KEPLER, { ...KEPLER, pl_name: 'Ross 128 b', hostname: 'Ross 128' }]);
+
+    expect(screen.getAllByRole('link')).toHaveLength(2);
+    expect(screen.queryByRole('button')).not.toBeInTheDocument();
+  });
+
+  it('links nothing when the feed is unavailable', async () => {
+    fetchLatestDiscoveries.mockResolvedValue({ status: 'unavailable' });
+    render(await DiscoveryList());
+
+    expect(screen.queryByRole('link')).not.toBeInTheDocument();
+    expect(screen.getByText(/unavailable right now/i)).toBeInTheDocument();
+  });
+});
diff --git a/exoplanethub.com/components/home/LatestDiscoveries.tsx b/exoplanethub.com/components/home/LatestDiscoveries.tsx
index 4ae196c..a02c53e 100644
--- a/exoplanethub.com/components/home/LatestDiscoveries.tsx
+++ b/exoplanethub.com/components/home/LatestDiscoveries.tsx
@@ -1,6 +1,7 @@
 import { Suspense } from 'react';
 import { connection } from 'next/server';
 import { fetchLatestDiscoveries } from '@/lib/latestDiscoveries';
+import PlanetNameLink from '@/components/planet/PlanetNameLink';
 import styles from './LatestDiscoveries.module.css';
 
 const HEADING_ID = 'latest-discoveries-heading';
@@ -22,7 +23,8 @@ export default function LatestDiscoveries() {
   );
 }
 
-async function DiscoveryList() {
+// Exported for its test only: rendering it directly skips the Suspense boundary above.
+export async function DiscoveryList() {
   // Defers this subtree to request time so a failed query costs one response, not a cached page.
   await connection();
   const result = await fetchLatestDiscoveries();
@@ -43,7 +45,9 @@ async function DiscoveryList() {
     <ol role="list" className={styles.list}>
       {result.planets.map((planet) => (
         <li key={planet.pl_name} className={styles.item}>
-          <h3 className={styles.name}>{planet.pl_name}</h3>
+          <h3 className={styles.name}>
+            <PlanetNameLink name={planet.pl_name} />
+          </h3>
           <dl className={styles.facts}>
             <Fact label="Host star" value={planet.hostname} />
             <Fact label="Discovered" value={planet.disc_year} />
diff --git a/exoplanethub.com/components/layout/NavBar.test.tsx b/exoplanethub.com/components/layout/NavBar.test.tsx
new file mode 100644
index 0000000..3c87004
--- /dev/null
+++ b/exoplanethub.com/components/layout/NavBar.test.tsx
@@ -0,0 +1,38 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it } from 'vitest';
+import NavBar from '@/components/layout/NavBar';
+
+function menuButton() {
+  return screen.getByRole('button', { name: 'Toggle menu' });
+}
+
+describe('NavBar accessibility (#6)', () => {
+  it('reports whether the menu it controls is open', async () => {
+    const user = userEvent.setup();
+    render(<NavBar />);
+
+    expect(menuButton()).toHaveAttribute('aria-expanded', 'false');
+
+    await user.click(menuButton());
+
+    expect(menuButton()).toHaveAttribute('aria-expanded', 'true');
+  });
+
+  it('points at the element it expands, so the link list can be found from the button', () => {
+    render(<NavBar />);
+    const controlled = menuButton().getAttribute('aria-controls');
+
+    expect(controlled).toBeTruthy();
+    expect(document.getElementById(controlled as string)).toContainElement(
+      screen.getByRole('link', { name: 'Explore' })
+    );
+  });
+
+  it('hides the decorative logo glyph from assistive tech', () => {
+    render(<NavBar />);
+
+    expect(screen.getByText('🪐')).toHaveAttribute('aria-hidden', 'true');
+    expect(screen.getByRole('link', { name: 'ExoplanetHub' })).toBeInTheDocument();
+  });
+});
diff --git a/exoplanethub.com/components/layout/NavBar.tsx b/exoplanethub.com/components/layout/NavBar.tsx
index 1a77ec2..8eb3c4b 100644
--- a/exoplanethub.com/components/layout/NavBar.tsx
+++ b/exoplanethub.com/components/layout/NavBar.tsx
@@ -10,7 +10,7 @@ export default function NavBar() {
     <nav className={styles.nav}>
       <div className={styles.container}>
         <Link href="/" className={styles.logo} onClick={() => setIsOpen(false)}>
-          <span className={styles.logoIcon}>🪐</span>
+          <span className={styles.logoIcon} aria-hidden="true">🪐</span>
           <span className={styles.logoText}>ExoplanetHub</span>
         </Link>
         
@@ -18,16 +18,18 @@ export default function NavBar() {
           className={`${styles.hamburger} ${isOpen ? styles.open : ''}`}
           onClick={() => setIsOpen(!isOpen)}
           aria-label="Toggle menu"
+          aria-expanded={isOpen}
+          aria-controls="nav-links"
         >
           <span></span>
           <span></span>
           <span></span>
         </button>
 
-        <div className={`${styles.links} ${isOpen ? styles.showMobile : ''}`}>
-          <a href="/explore" className={styles.link} onClick={() => setIsOpen(false)}>Explore</a>
-          <a href="/about" className={styles.link} onClick={() => setIsOpen(false)}>About</a>
-          <a href="/contact" className={styles.link} onClick={() => setIsOpen(false)}>Contact</a>
+        <div id="nav-links" className={`${styles.links} ${isOpen ? styles.showMobile : ''}`}>
+          <Link href="/explore" className={styles.link} onClick={() => setIsOpen(false)}>Explore</Link>
+          <Link href="/about" className={styles.link} onClick={() => setIsOpen(false)}>About</Link>
+          <Link href="/contact" className={styles.link} onClick={() => setIsOpen(false)}>Contact</Link>
         </div>
       </div>
     </nav>
diff --git a/exoplanethub.com/components/planet/PlanetNameLink.module.css b/exoplanethub.com/components/planet/PlanetNameLink.module.css
new file mode 100644
index 0000000..5399e0f
--- /dev/null
+++ b/exoplanethub.com/components/planet/PlanetNameLink.module.css
@@ -0,0 +1,15 @@
+/* Underlined at rest, not on hover: on touch there is no hover, so a colour-only link is invisible. */
+.link {
+  color: var(--color-primary);
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+
+.link:hover {
+  color: var(--color-accent);
+}
+
+.link:focus-visible {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 2px;
+}
diff --git a/exoplanethub.com/components/planet/PlanetNameLink.tsx b/exoplanethub.com/components/planet/PlanetNameLink.tsx
new file mode 100644
index 0000000..84587b2
--- /dev/null
+++ b/exoplanethub.com/components/planet/PlanetNameLink.tsx
@@ -0,0 +1,17 @@
+import { MouseEventHandler } from 'react';
+import Link from 'next/link';
+import { planetUrl } from '@/lib/planetUrl';
+import styles from './PlanetNameLink.module.css';
+
+interface PlanetNameLinkProps {
+  name: string;
+  onClick?: MouseEventHandler<HTMLAnchorElement>;
+}
+
+export default function PlanetNameLink({ name, onClick }: PlanetNameLinkProps) {
+  return (
+    <Link className={styles.link} href={planetUrl(name)} onClick={onClick}>
+      {name}
+    </Link>
+  );
+}
diff --git a/exoplanethub.com/components/ui/ModalDialog.module.css b/exoplanethub.com/components/ui/ModalDialog.module.css
new file mode 100644
index 0000000..f15b5ae
--- /dev/null
+++ b/exoplanethub.com/components/ui/ModalDialog.module.css
@@ -0,0 +1,37 @@
+.overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.8);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+  padding: 24px;
+  animation: fadeIn 0.2s;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+.dialog {
+  position: relative;
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: 16px;
+  max-width: 700px;
+  width: 100%;
+  max-height: 90vh;
+  animation: slideUp 0.3s;
+}
+
+/* Focused programmatically on open; the dialog border is the visible boundary, not a focus ring. */
+.dialog:focus {
+  outline: none;
+}
+
+@keyframes slideUp {
+  from { transform: translateY(20px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
diff --git a/exoplanethub.com/components/ui/ModalDialog.test.tsx b/exoplanethub.com/components/ui/ModalDialog.test.tsx
new file mode 100644
index 0000000..97f30fe
--- /dev/null
+++ b/exoplanethub.com/components/ui/ModalDialog.test.tsx
@@ -0,0 +1,157 @@
+import { useState } from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it } from 'vitest';
+import ModalDialog from '@/components/ui/ModalDialog';
+
+const TRIGGER_LABEL = 'Open';
+
+function Harness({ children }: { children?: React.ReactNode }) {
+  const [open, setOpen] = useState(false);
+
+  return (
+    <>
+      <button onClick={() => setOpen(true)}>{TRIGGER_LABEL}</button>
+      <button>Outside</button>
+      {open && (
+        <ModalDialog onClose={() => setOpen(false)} labelledBy="dialog-title">
+          <h2 id="dialog-title">Dialog heading</h2>
+          {children ?? <button onClick={() => setOpen(false)}>Close</button>}
+        </ModalDialog>
+      )}
+    </>
+  );
+}
+
+async function openDialog(children?: React.ReactNode) {
+  const user = userEvent.setup();
+  render(<Harness>{children}</Harness>);
+  const trigger = screen.getByRole('button', { name: TRIGGER_LABEL });
+  await user.click(trigger);
+
+  return { user, trigger, dialog: screen.getByRole('dialog') };
+}
+
+describe('ModalDialog semantics', () => {
+  it('marks itself modal and takes its name from the heading it is pointed at', async () => {
+    const { dialog } = await openDialog();
+
+    expect(dialog).toHaveAttribute('aria-modal', 'true');
+    expect(dialog).toHaveAccessibleName('Dialog heading');
+  });
+
+  it('moves focus into the dialog on open', async () => {
+    const { dialog } = await openDialog();
+
+    expect(dialog).toHaveFocus();
+  });
+
+  it('returns focus to the triggering control on close', async () => {
+    const { user, trigger } = await openDialog();
+
+    await user.click(screen.getByRole('button', { name: 'Close' }));
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(trigger).toHaveFocus();
+  });
+
+  it('closes on Escape', async () => {
+    const { user, trigger } = await openDialog();
+
+    await user.keyboard('{Escape}');
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(trigger).toHaveFocus();
+  });
+
+  it('closes when the overlay behind it is clicked', async () => {
+    const { user, dialog } = await openDialog();
+
+    await user.click(dialog.parentElement as HTMLElement);
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  it('stays open when the dialog itself is clicked', async () => {
+    const { user, dialog } = await openDialog();
+
+    await user.click(screen.getByText('Dialog heading'));
+
+    expect(dialog).toBeInTheDocument();
+  });
+});
+
+describe('ModalDialog focus trap', () => {
+  it('keeps Tab inside the dialog, so aria-modal holds for keyboard users', async () => {
+    const { user, dialog } = await openDialog();
+
+    for (let i = 0; i < 6; i++) {
+      await user.tab();
+      expect(dialog).toContainElement(document.activeElement as HTMLElement);
+    }
+  });
+
+  it('wraps backwards from the dialog to its last stop', async () => {
+    const { user, dialog } = await openDialog(
+      <>
+        <button>First</button>
+        <button>Last</button>
+      </>
+    );
+
+    await user.tab({ shift: true });
+
+    expect(dialog).toContainElement(document.activeElement as HTMLElement);
+    expect(screen.getByRole('button', { name: 'Last' })).toHaveFocus();
+  });
+
+  // A trap that only recognises links, buttons and [tabindex] treats the link as the last
+  // stop and pins focus there, so the fields below it become unreachable rather than leaking.
+  it('cycles through form controls, not just buttons and links', async () => {
+    const { user } = await openDialog(
+      <>
+        <a href="https://example.com">Reference</a>
+        <input aria-label="Search" />
+        <select aria-label="Kind">
+          <option>One</option>
+        </select>
+        <textarea aria-label="Notes" />
+      </>
+    );
+    const stops = [
+      screen.getByRole('link', { name: 'Reference' }),
+      screen.getByRole('textbox', { name: 'Search' }),
+      screen.getByRole('combobox', { name: 'Kind' }),
+      screen.getByRole('textbox', { name: 'Notes' }),
+    ];
+
+    const visited: Element[] = [];
+    for (let i = 0; i < stops.length + 1; i++) {
+      await user.tab();
+      visited.push(document.activeElement as Element);
+    }
+
+    expect(visited).toEqual([...stops, stops[0]]);
+  });
+
+  it('holds focus in a dialog that has nothing focusable in it', async () => {
+    const { user, dialog } = await openDialog(<p>Nothing to focus in here.</p>);
+
+    await user.tab();
+    expect(dialog).toHaveFocus();
+
+    await user.tab({ shift: true });
+    expect(dialog).toHaveFocus();
+  });
+});
+
+describe('ModalDialog page locking', () => {
+  it('locks page scrolling while open and releases it on close', async () => {
+    const { user } = await openDialog();
+    expect(document.body.style.overflow).toBe('hidden');
+
+    await user.keyboard('{Escape}');
+
+    expect(document.body.style.overflow).toBe('unset');
+  });
+});
diff --git a/exoplanethub.com/components/ui/ModalDialog.tsx b/exoplanethub.com/components/ui/ModalDialog.tsx
new file mode 100644
index 0000000..acc1bf9
--- /dev/null
+++ b/exoplanethub.com/components/ui/ModalDialog.tsx
@@ -0,0 +1,92 @@
+'use client';
+import { ReactNode, useEffect, useRef } from 'react';
+import { createPortal } from 'react-dom';
+import styles from './ModalDialog.module.css';
+
+interface ModalDialogProps {
+  onClose: () => void;
+  labelledBy: string;
+  className?: string;
+  children: ReactNode;
+}
+
+const FOCUSABLE = [
+  'a[href]',
+  'button:not([disabled])',
+  'input:not([disabled])',
+  'select:not([disabled])',
+  'textarea:not([disabled])',
+  '[tabindex]:not([tabindex="-1"])',
+].join(', ');
+
+export default function ModalDialog({ onClose, labelledBy, className, children }: ModalDialogProps) {
+  const dialogRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const trigger = document.activeElement as HTMLElement | null;
+    dialogRef.current?.focus();
+    return () => trigger?.focus();
+  }, []);
+
+  useEffect(() => {
+    // aria-modal only claims the rest of the page is inert; Tab has to be contained to make it true.
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') {
+        onClose();
+        return;
+      }
+      if (e.key !== 'Tab' || !dialogRef.current) return;
+
+      const stops = Array.from(dialogRef.current.querySelectorAll<HTMLElement>(FOCUSABLE));
+      if (stops.length === 0) {
+        e.preventDefault(); // Nowhere to move to, but Tab still must not walk out of the dialog.
+        return;
+      }
+
+      const first = stops[0];
+      const last = stops[stops.length - 1];
+      const leavingBackwards = e.shiftKey && (document.activeElement === first || document.activeElement === dialogRef.current);
+      const leavingForwards = !e.shiftKey && document.activeElement === last;
+
+      if (leavingBackwards) {
+        e.preventDefault();
+        last.focus();
+      } else if (leavingForwards) {
+        e.preventDefault();
+        first.focus();
+      }
+    };
+
+    document.addEventListener('keydown', handleKeyDown);
+    document.body.style.overflow = 'hidden';
+
+    return () => {
+      document.removeEventListener('keydown', handleKeyDown);
+      document.body.style.overflow = 'unset';
+    };
+  }, [onClose]);
+
+  // Portalled so a transformed ancestor cannot become this fixed overlay's containing block and clip it.
+  return createPortal(
+    <div
+      className={styles.overlay}
+      onClick={(e) => {
+        e.stopPropagation(); // Portalled events still bubble the React tree, into whatever rendered the trigger.
+        onClose();
+      }}
+    >
+      <div
+        ref={dialogRef}
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={labelledBy}
+        tabIndex={-1}
+        className={className ? `${styles.dialog} ${className}` : styles.dialog}
+        onClick={(e) => e.stopPropagation()}
+      >
+        {children}
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/exoplanethub.com/lib/dynamo.ts b/exoplanethub.com/lib/dynamo.ts
index fd3cdc9..7d52a03 100644
--- a/exoplanethub.com/lib/dynamo.ts
+++ b/exoplanethub.com/lib/dynamo.ts
@@ -1,6 +1,11 @@
 import 'server-only';
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import {
+  DynamoDBDocumentClient,
+  ScanCommand,
+  type ScanCommandOutput,
+} from '@aws-sdk/lib-dynamodb';
+import type { Planet } from '@/lib/mockPlanets';
 
 // Omitting credentials entirely lets the SDK default provider chain (IAM role, SSO) take over.
 const credentials =
@@ -19,3 +24,30 @@ export const documentClient = DynamoDBDocumentClient.from(
 );
 
 export const planetsTableName = process.env.EXOPLANETS_DATABASE_TABLE || 'exoplanets-dev';
+
+// Aliasing every projected name keeps the field list free to grow without hitting a DynamoDB reserved word.
+export async function scanAllPlanets<Field extends keyof Planet>(
+  fields: readonly [Field, ...Field[]]
+): Promise<Pick<Planet, Field>[]> {
+  const expressionAttributeNames = Object.fromEntries(fields.map((field) => [`#${field}`, field]));
+  const projectionExpression = fields.map((field) => `#${field}`).join(', ');
+
+  const planets: Pick<Planet, Field>[] = [];
+  let cursor: ScanCommandOutput['LastEvaluatedKey'];
+
+  do {
+    const page: ScanCommandOutput = await documentClient.send(
+      new ScanCommand({
+        TableName: planetsTableName,
+        ExpressionAttributeNames: expressionAttributeNames,
+        ProjectionExpression: projectionExpression,
+        ExclusiveStartKey: cursor,
+      })
+    );
+
+    planets.push(...((page.Items ?? []) as Pick<Planet, Field>[]));
+    cursor = page.LastEvaluatedKey;
+  } while (cursor);
+
+  return planets;
+}
diff --git a/exoplanethub.com/lib/earthComparison.test.ts b/exoplanethub.com/lib/earthComparison.test.ts
new file mode 100644
index 0000000..d5c4dc7
--- /dev/null
+++ b/exoplanethub.com/lib/earthComparison.test.ts
@@ -0,0 +1,170 @@
+import { describe, expect, it } from 'vitest';
+import { earthComparisons } from '@/lib/earthComparison';
+import type { Planet } from '@/lib/mockPlanets';
+
+const UNMEASURED: Planet = {
+  pl_name: 'Kepler-452 b',
+  hostname: null,
+  sy_snum: null,
+  sy_pnum: null,
+  sy_dist: null,
+  discoverymethod: null,
+  disc_year: null,
+  disc_facility: null,
+  pl_orbper: null,
+  pl_orbsmax: null,
+  pl_rade: null,
+  pl_bmasse: null,
+  pl_dens: null,
+  pl_eqt: null,
+  pl_insol: null,
+  st_teff: null,
+  st_rad: null,
+  st_mass: null,
+  st_logg: null,
+  st_age: null,
+  last_updated: '2026-08-30T06:00:00Z',
+};
+
+function comparisonsOf(planet: Partial<Planet>) {
+  return earthComparisons({ ...UNMEASURED, ...planet });
+}
+
+function detailOf(aspect: string, planet: Partial<Planet>): string | undefined {
+  return comparisonsOf(planet).find((comparison) => comparison.aspect === aspect)?.detail;
+}
+
+describe('earthComparisons selection', () => {
+  it('offers nothing at all for a planet with no measured fields', () => {
+    expect(comparisonsOf({})).toEqual([]);
+  });
+
+  it('keeps a measured aspect and drops the unmeasured ones rather than half-writing them', () => {
+    expect(comparisonsOf({ pl_rade: 1.63 })).toEqual([
+      { aspect: 'Size', detail: "About 1.6 times Earth's width." },
+    ]);
+  });
+
+  it('orders the aspects from the planet itself outwards to its orbit', () => {
+    const planet = { pl_rade: 1.63, pl_bmasse: 5, pl_eqt: 265, pl_insol: 1.1, pl_orbper: 384.8 };
+
+    expect(comparisonsOf(planet).map((comparison) => comparison.aspect)).toEqual([
+      'Size',
+      'Mass',
+      'Temperature',
+      'Starlight',
+      'Year',
+    ]);
+  });
+
+  it.each([
+    ['pl_rade', 'Size'],
+    ['pl_bmasse', 'Mass'],
+    ['pl_eqt', 'Temperature'],
+    ['pl_insol', 'Starlight'],
+    ['pl_orbper', 'Year'],
+  ])('drops %s when it is null', (field, aspect) => {
+    expect(detailOf(aspect, { [field]: null })).toBeUndefined();
+  });
+
+  // A ratio, a kelvin and a period are all positive; anything else is a corrupt row, not a fact.
+  it.each([0, -1, Number.NaN, Number.POSITIVE_INFINITY])(
+    'treats the stored value %s as unmeasured rather than comparing it',
+    (corrupt) => {
+      const planet = {
+        pl_rade: corrupt,
+        pl_bmasse: corrupt,
+        pl_eqt: corrupt,
+        pl_insol: corrupt,
+        pl_orbper: corrupt,
+      };
+
+      expect(comparisonsOf(planet)).toEqual([]);
+    }
+  );
+});
+
+describe('proportions of Earth', () => {
+  it.each([
+    [1.63, "About 1.6 times Earth's width."],
+    [11.2, "About 11 times Earth's width."],
+    [0.85, "About 85% of Earth's width."],
+  ])('states a radius of %s in the register people use', (pl_rade, detail) => {
+    expect(detailOf('Size', { pl_rade })).toBe(detail);
+  });
+
+  it('says almost exactly rather than "1 times" when a planet matches Earth', () => {
+    expect(detailOf('Size', { pl_rade: 1.02 })).toBe("Almost exactly Earth's width.");
+  });
+
+  it('never rounds a proportion up to a flat 100% of Earth', () => {
+    expect(detailOf('Mass', { pl_bmasse: 0.9951 })).toBe("Almost exactly Earth's mass.");
+  });
+
+  it('measures mass against Earth too', () => {
+    expect(detailOf('Mass', { pl_bmasse: 5 })).toBe("About 5 times Earth's mass.");
+  });
+
+  it('frames starlight as what Earth gets from the Sun, not as a bare number', () => {
+    expect(detailOf('Starlight', { pl_insol: 1.1 })).toBe(
+      'About 1.1 times the starlight Earth gets from the Sun.'
+    );
+  });
+
+  it('keeps a scorched planet on the number the archive holds', () => {
+    expect(detailOf('Starlight', { pl_insol: 3247 })).toBe(
+      'About 3,247 times the starlight Earth gets from the Sun.'
+    );
+  });
+
+  it('keeps a faintly lit planet legible instead of collapsing it to 0%', () => {
+    expect(detailOf('Starlight', { pl_insol: 0.0004 })).toBe(
+      'About 0.04% of the starlight Earth gets from the Sun.'
+    );
+  });
+});
+
+describe('temperature', () => {
+  it('converts to everyday units and names the basis of the comparison', () => {
+    expect(detailOf('Temperature', { pl_eqt: 265 })).toBe(
+      'About -8 °C (17 °F) from starlight alone, against -18 °C (-1 °F) for Earth measured the same way.'
+    );
+  });
+
+  it('reads a planet just below freezing as 0 °C, never as -0 °C', () => {
+    expect(detailOf('Temperature', { pl_eqt: 273.1 })).toContain('About 0 °C');
+  });
+
+  it('groups the digits of a scorching planet', () => {
+    expect(detailOf('Temperature', { pl_eqt: 2000 })).toContain('About 1,727 °C');
+  });
+});
+
+describe('year length', () => {
+  it('counts a short orbit in Earth days', () => {
+    expect(detailOf('Year', { pl_orbper: 11.186 })).toBe('A year here lasts about 11 Earth days.');
+  });
+
+  it('counts an orbit shorter than a day in hours', () => {
+    expect(detailOf('Year', { pl_orbper: 0.75 })).toBe('A year here lasts about 18 hours.');
+  });
+
+  it('keeps a day count the archive holds instead of rounding 267 up to 270', () => {
+    expect(detailOf('Year', { pl_orbper: 267.29 })).toBe('A year here lasts about 267 Earth days.');
+  });
+
+  it('keeps an orbit just under an Earth year shorter than one', () => {
+    expect(detailOf('Year', { pl_orbper: 365 })).toBe('A year here lasts about 365 Earth days.');
+  });
+
+  it('counts a long orbit in Earth years rather than hundreds of days', () => {
+    expect(detailOf('Year', { pl_orbper: 4332.6 })).toBe('A year here lasts about 12 Earth years.');
+  });
+
+  it.each([
+    [1, 'A year here lasts about 1 Earth day.'],
+    [365.25, 'A year here lasts about 1 Earth year.'],
+  ])('says "%s day" in the singular where the count is one', (pl_orbper, detail) => {
+    expect(detailOf('Year', { pl_orbper })).toBe(detail);
+  });
+});
diff --git a/exoplanethub.com/lib/earthComparison.ts b/exoplanethub.com/lib/earthComparison.ts
new file mode 100644
index 0000000..c002d13
--- /dev/null
+++ b/exoplanethub.com/lib/earthComparison.ts
@@ -0,0 +1,86 @@
+import type { Planet } from '@/lib/mockPlanets';
+
+export interface EarthComparison {
+  aspect: string;
+  detail: string;
+}
+
+// pl_eqt excludes atmosphere, so Earth's airless 255 K is the honest baseline; the sync's compute_esi
+// uses 288 K as a similarity kernel reference, which is a different job.
+const EARTH_EQUILIBRIUM_TEMPERATURE_K = 255;
+
+const KELVIN_AT_ZERO_CELSIUS = 273.15;
+const DAYS_PER_EARTH_YEAR = 365.25;
+const HOURS_PER_DAY = 24;
+
+// Pinned locale so a sentence reads identically wherever the page is rendered or cached.
+const WHOLE = new Intl.NumberFormat('en-US', { maximumFractionDigits: 0 });
+const FEW = new Intl.NumberFormat('en-US', { maximumSignificantDigits: 2 });
+const PROPORTION = new Intl.NumberFormat('en-US', { style: 'percent', maximumSignificantDigits: 2 });
+
+// Two significant digits would round a 267-day orbit to 270, a number the archive never held and one
+// the Planet section contradicts further down the same page.
+function amount(value: number): string {
+  return (value >= 10 ? WHOLE : FEW).format(value);
+}
+
+// Ratios, kelvin and orbital periods are positive by definition, so a stored zero or negative is a
+// corrupt row rather than a measurement, and reads as unknown.
+function isComparable(value: number | null | undefined): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+
+// Below Earth reads as a percentage and above it as a multiple, which is how people say it.
+function proportionOfEarth(ratio: number | null, subject: string): string | null {
+  if (!isComparable(ratio)) return null;
+
+  const multiple = amount(ratio);
+  if (multiple === '1') return `Almost exactly ${subject}.`;
+
+  return `About ${ratio < 1 ? `${PROPORTION.format(ratio)} of` : `${multiple} times`} ${subject}.`;
+}
+
+function everydayDegrees(kelvin: number): string {
+  const celsius = kelvin - KELVIN_AT_ZERO_CELSIUS;
+  return `${round(celsius)} °C (${round(celsius * 1.8 + 32)} °F)`;
+}
+
+// Rounding a temperature just below zero yields -0, which reads as a typo.
+function round(degrees: number): string {
+  return WHOLE.format(Object.is(Math.round(degrees), -0) ? 0 : degrees);
+}
+
+function temperature(kelvin: number | null): string | null {
+  if (!isComparable(kelvin)) return null;
+
+  return `About ${everydayDegrees(kelvin)} from starlight alone, against ${everydayDegrees(
+    EARTH_EQUILIBRIUM_TEMPERATURE_K
+  )} for Earth measured the same way.`;
+}
+
+function orbitLasting(value: number, unit: string): string {
+  const count = amount(value);
+  return `A year here lasts about ${count} ${unit}${count === '1' ? '' : 's'}.`;
+}
+
+function yearLength(days: number | null): string | null {
+  if (!isComparable(days)) return null;
+  if (days < 1) return orbitLasting(days * HOURS_PER_DAY, 'hour');
+  if (days < DAYS_PER_EARTH_YEAR) return orbitLasting(days, 'Earth day');
+  return orbitLasting(days / DAYS_PER_EARTH_YEAR, 'Earth year');
+}
+
+export function earthComparisons(planet: Planet): EarthComparison[] {
+  const comparisons = [
+    { aspect: 'Size', detail: proportionOfEarth(planet.pl_rade, "Earth's width") },
+    { aspect: 'Mass', detail: proportionOfEarth(planet.pl_bmasse, "Earth's mass") },
+    { aspect: 'Temperature', detail: temperature(planet.pl_eqt) },
+    {
+      aspect: 'Starlight',
+      detail: proportionOfEarth(planet.pl_insol, 'the starlight Earth gets from the Sun'),
+    },
+    { aspect: 'Year', detail: yearLength(planet.pl_orbper) },
+  ];
+
+  return comparisons.filter((comparison): comparison is EarthComparison => comparison.detail !== null);
+}
diff --git a/exoplanethub.com/lib/mockPlanets.ts b/exoplanethub.com/lib/mockPlanets.ts
index d048a1b..7a96085 100644
--- a/exoplanethub.com/lib/mockPlanets.ts
+++ b/exoplanethub.com/lib/mockPlanets.ts
@@ -33,9 +33,11 @@ export const PLANET_SUMMARY_FIELDS = [
   'sy_dist',
   'discoverymethod',
   'disc_year',
+  'pl_orbper',
   'pl_rade',
   'pl_bmasse',
   'pl_eqt',
+  'st_teff',
   'esi',
 ] as const;
 
diff --git a/exoplanethub.com/lib/planetDetail.test.ts b/exoplanethub.com/lib/planetDetail.test.ts
new file mode 100644
index 0000000..81b13a6
--- /dev/null
+++ b/exoplanethub.com/lib/planetDetail.test.ts
@@ -0,0 +1,122 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Planet } from '@/lib/mockPlanets';
+
+const { send } = vi.hoisted(() => ({ send: vi.fn() }));
+
+vi.mock('@aws-sdk/client-dynamodb', () => ({
+  DynamoDBClient: class {},
+}));
+
+vi.mock('@aws-sdk/lib-dynamodb', () => ({
+  DynamoDBDocumentClient: { from: () => ({ send }) },
+  GetCommand: class {
+    constructor(readonly input: Record<string, unknown>) {}
+  },
+}));
+
+// The page renders fields the summary projection omits, so the fixture is a whole stored item.
+const KEPLER_452B: Planet = {
+  pl_name: 'Kepler-452 b',
+  hostname: 'Kepler-452',
+  sy_snum: 1,
+  sy_pnum: 1,
+  sy_dist: 551.7,
+  discoverymethod: 'Transit',
+  disc_year: 2015,
+  disc_facility: 'Kepler',
+  pl_orbper: 384.843,
+  pl_orbsmax: 1.046,
+  pl_rade: 1.63,
+  pl_bmasse: null,
+  pl_dens: null,
+  pl_eqt: 265,
+  pl_insol: 1.1,
+  st_teff: 5757,
+  st_rad: 1.11,
+  st_mass: 1.04,
+  st_logg: 4.32,
+  st_age: 6,
+  last_updated: '2026-08-30T06:00:00Z',
+  esi: 0.83,
+};
+
+// Re-evaluates the module graph, so a table name captured at import still reflects env set in the test body.
+async function importDetailWithCurrentEnv() {
+  vi.resetModules();
+  return (await import('@/lib/planetDetail')).getPlanetDetail;
+}
+
+function getInputs() {
+  return send.mock.calls.map(([command]) => command.input as Record<string, unknown>);
+}
+
+beforeEach(() => {
+  send.mockReset();
+  delete process.env.EXOPLANETS_DATABASE_TABLE;
+});
+
+describe('getPlanetDetail', () => {
+  it('returns the stored item with the fields the summary projection leaves out', async () => {
+    send.mockResolvedValue({ Item: KEPLER_452B });
+    const getPlanetDetail = await importDetailWithCurrentEnv();
+
+    await expect(getPlanetDetail('Kepler-452 b')).resolves.toEqual(KEPLER_452B);
+  });
+
+  it('returns null when no planet carries that name', async () => {
+    send.mockResolvedValue({});
+    const getPlanetDetail = await importDetailWithCurrentEnv();
+
+    await expect(getPlanetDetail('Definitely Not A Planet b')).resolves.toBeNull();
+  });
+
+  it('looks the planet up by its exact name, spaces and all', async () => {
+    send.mockResolvedValue({ Item: KEPLER_452B });
+    const getPlanetDetail = await importDetailWithCurrentEnv();
+
+    await getPlanetDetail('Kepler-452 b');
+
+    expect(getInputs()[0].Key).toEqual({ pl_name: 'Kepler-452 b' });
+  });
+
+  it('costs one read, not a scan', async () => {
+    send.mockResolvedValue({ Item: KEPLER_452B });
+    const getPlanetDetail = await importDetailWithCurrentEnv();
+
+    await getPlanetDetail('Kepler-452 b');
+
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(getInputs()[0].ProjectionExpression).toBeUndefined();
+  });
+
+  it('reads the table named by EXOPLANETS_DATABASE_TABLE', async () => {
+    process.env.EXOPLANETS_DATABASE_TABLE = 'exoplanets-prod';
+    send.mockResolvedValue({});
+    const getPlanetDetail = await importDetailWithCurrentEnv();
+
+    await getPlanetDetail('Kepler-452 b');
+
+    expect(getInputs()[0].TableName).toBe('exoplanets-prod');
+  });
+
+  it('falls back to the dev table when the variable is unset', async () => {
+    send.mockResolvedValue({});
+    const getPlanetDetail = await importDetailWithCurrentEnv();
+
+    await getPlanetDetail('Kepler-452 b');
+
+    expect(getInputs()[0].TableName).toBe('exoplanets-dev');
+  });
+});
+
+describe('getPlanetDetail failure handling', () => {
+  it('propagates a read failure instead of reporting it as a missing planet', async () => {
+    send.mockRejectedValue(new Error('ProvisionedThroughputExceededException'));
+    const getPlanetDetail = await importDetailWithCurrentEnv();
+
+    await expect(getPlanetDetail('Kepler-452 b')).rejects.toThrow(
+      'ProvisionedThroughputExceededException'
+    );
+  });
+});
diff --git a/exoplanethub.com/lib/planetDetail.ts b/exoplanethub.com/lib/planetDetail.ts
new file mode 100644
index 0000000..07d71d3
--- /dev/null
+++ b/exoplanethub.com/lib/planetDetail.ts
@@ -0,0 +1,18 @@
+import 'server-only';
+import { cache } from 'react';
+import { GetCommand } from '@aws-sdk/lib-dynamodb';
+import { documentClient, planetsTableName } from '@/lib/dynamo';
+import type { Planet } from '@/lib/mockPlanets';
+
+// cache() shares one GetItem between generateMetadata and the page it titles.
+// A read failure throws instead of resolving null, so only a genuine miss can become a cached 404.
+export const getPlanetDetail = cache(async (planetName: string): Promise<Planet | null> => {
+  const { Item } = await documentClient.send(
+    new GetCommand({
+      TableName: planetsTableName,
+      Key: { pl_name: planetName },
+    })
+  );
+
+  return (Item as Planet | undefined) ?? null;
+});
diff --git a/exoplanethub.com/lib/planetFilters.test.ts b/exoplanethub.com/lib/planetFilters.test.ts
new file mode 100644
index 0000000..1fc5e59
--- /dev/null
+++ b/exoplanethub.com/lib/planetFilters.test.ts
@@ -0,0 +1,658 @@
+import { describe, expect, it } from 'vitest';
+import type { PlanetSummary } from '@/lib/mockPlanets';
+import {
+  DEFAULT_FILTERS,
+  FilterState,
+  Range,
+  RangeKey,
+  applyFilters,
+  discoveryMethods,
+  cleared,
+  isFiltered,
+  measuredExtent,
+  parseFilters,
+  serializeFilters,
+  sortPlanets,
+  withMethod,
+  withRange,
+  withStarClass,
+  withSort,
+} from '@/lib/planetFilters';
+
+function makePlanet(overrides: Partial<PlanetSummary> & Pick<PlanetSummary, 'pl_name'>): PlanetSummary {
+  return {
+    hostname: 'Host',
+    sy_dist: 10,
+    discoverymethod: 'Transit',
+    disc_year: 2000,
+    pl_orbper: 10,
+    pl_rade: 1,
+    pl_bmasse: 1,
+    pl_eqt: 1,
+    st_teff: 5800,
+    ...overrides,
+  };
+}
+
+function parse(query: string): FilterState {
+  return parseFilters(new URLSearchParams(query));
+}
+
+const ALPHA = makePlanet({ pl_name: 'Alpha b', hostname: 'Ross 128' });
+const BETA = makePlanet({ pl_name: 'Beta c', hostname: 'Kepler-186', discoverymethod: 'Radial Velocity' });
+const GAMMA = makePlanet({ pl_name: 'Gamma d', hostname: null });
+
+describe('parseFilters', () => {
+  it('reads an empty query string as the default view', () => {
+    expect(parse('')).toEqual(DEFAULT_FILTERS);
+  });
+
+  it('reads search, method and sort', () => {
+    expect(parse('q=kepler&method=Transit&sort=pl_rade.asc')).toEqual({
+      ...DEFAULT_FILTERS,
+      q: 'kepler',
+      methods: ['Transit'],
+      sortKey: 'pl_rade',
+      sortOrder: 'asc',
+    });
+  });
+
+  it.each([
+    ['an unknown sort key', 'sort=nonsense.asc'],
+    ['an unknown direction', 'sort=pl_rade.sideways'],
+    ['a sort with no direction', 'sort=pl_rade'],
+    ['an empty sort', 'sort='],
+    ['a sort key that is a planet field but not sortable', 'sort=pl_eqt.asc'],
+  ])('falls back to the default sort for %s', (_label, query) => {
+    expect(parse(query)).toMatchObject({ sortKey: 'disc_year', sortOrder: 'desc' });
+  });
+
+  it('treats an empty or absent value as an inactive filter', () => {
+    expect(parse('q=&method=')).toMatchObject({ q: '', methods: [] });
+  });
+
+  it('reads a comma-separated method list', () => {
+    expect(parse('method=Radial%20Velocity,Transit')).toMatchObject({
+      methods: ['Radial Velocity', 'Transit'],
+    });
+  });
+
+  it('normalises the order the URL gave, so one set of methods has exactly one URL', () => {
+    expect(serializeFilters(parse('method=Transit,Astrometry'))).toBe('method=Astrometry%2CTransit');
+    expect(serializeFilters(parse('method=Astrometry,Transit'))).toBe('method=Astrometry%2CTransit');
+  });
+
+  it.each([
+    ['empty entries', 'method=Transit,,Imaging', ['Transit', 'Imaging']],
+    ['padding around each name', 'method=%20Transit%20,%20Imaging%20', ['Transit', 'Imaging']],
+    ['a repeated method', 'method=Transit,Imaging,Transit', ['Transit', 'Imaging']],
+    ['a list of nothing but separators', 'method=,,', []],
+  ])('drops %s rather than filtering on them', (_label, query, expected) => {
+    expect(parse(query)).toMatchObject({ methods: expected });
+  });
+
+  it('ignores params it does not recognise', () => {
+    expect(parse('bogus=1&q=kepler')).toEqual({ ...DEFAULT_FILTERS, q: 'kepler' });
+  });
+
+  it('reads each range in its own real units', () => {
+    expect(parse('radius=0.5..2&mass=..10&period=1..365').ranges).toEqual({
+      radius: { min: 0.5, max: 2 },
+      mass: { min: null, max: 10 },
+      period: { min: 1, max: 365 },
+    });
+  });
+
+  it.each([
+    ['no lower bound', 'radius=..2', { min: null, max: 2 }],
+    ['no upper bound', 'radius=0.5..', { min: 0.5, max: null }],
+    ['a negative bound, which no planet can match rather than being an error', 'radius=-1..2', { min: -1, max: 2 }],
+    ['bounds the visitor entered backwards', 'radius=10..1', { min: 10, max: 1 }],
+  ])('reads a range with %s', (_label, query, expected) => {
+    expect(parse(query).ranges.radius).toEqual(expected);
+  });
+
+  it.each([
+    ['a bound that is not a number', 'radius=small..2'],
+    ['no separator at all', 'radius=2'],
+    ['more bounds than a range has ends', 'radius=1..2..3'],
+    ['an infinite bound', 'radius=1..Infinity'],
+    ['an empty value', 'radius='],
+    ['a separator with nothing either side', 'radius=..'],
+  ])('leaves the range inactive for %s', (_label, query) => {
+    expect(parse(query).ranges.radius).toEqual({ min: null, max: null });
+  });
+
+  // Number(' ') is 0, which would quietly become a floor no planet falls below.
+  it('reads a blank bound as an omitted end rather than as zero', () => {
+    expect(parse('radius= ..2').ranges.radius).toEqual({ min: null, max: 2 });
+  });
+});
+
+describe('serializeFilters', () => {
+  it('writes nothing for the default view, so a pristine /explore carries no query string', () => {
+    expect(serializeFilters(DEFAULT_FILTERS)).toBe('');
+  });
+
+  it('omits the default sort while keeping the other filters', () => {
+    expect(serializeFilters({ ...DEFAULT_FILTERS, q: 'kepler' })).toBe('q=kepler');
+  });
+
+  it('writes a sort that differs from the default only in direction', () => {
+    expect(serializeFilters({ ...DEFAULT_FILTERS, sortOrder: 'asc' })).toBe('sort=disc_year.asc');
+  });
+
+  it('omits a search that is only whitespace', () => {
+    expect(serializeFilters({ ...DEFAULT_FILTERS, q: '   ' })).toBe('');
+  });
+
+  it('writes the search the filter actually applies, not the padding around it', () => {
+    expect(serializeFilters({ ...DEFAULT_FILTERS, q: '  wolf  ' })).toBe('q=wolf');
+  });
+
+  it('writes a range as the bounds a visitor would recognise, not slider positions', () => {
+    expect(serializeFilters(withRange(DEFAULT_FILTERS, 'period', { min: 1, max: 365 }))).toBe(
+      'period=1..365'
+    );
+  });
+
+  it.each([
+    ['no lower bound', { min: null, max: 2 }, 'radius=..2'],
+    ['no upper bound', { min: 0.5, max: null }, 'radius=0.5..'],
+  ])('keeps the separator for a range with %s, so the omitted end stays readable', (_label, range, expected) => {
+    expect(serializeFilters(withRange(DEFAULT_FILTERS, 'radius', range))).toBe(expected);
+  });
+
+  it('leaves an unbounded range out of the URL entirely', () => {
+    expect(serializeFilters(withRange(DEFAULT_FILTERS, 'radius', { min: null, max: null }))).toBe('');
+  });
+
+  it.each([
+    ['the default view', DEFAULT_FILTERS],
+    ['a search', { ...DEFAULT_FILTERS, q: 'kepler 186' }],
+    ['a method', { ...DEFAULT_FILTERS, methods: ['Radial Velocity'] }],
+    ['several methods', { ...DEFAULT_FILTERS, methods: ['Imaging', 'Radial Velocity', 'Transit'] }],
+    ['a star class', { ...DEFAULT_FILTERS, starClasses: ['G' as const] }],
+    ['several star classes', { ...DEFAULT_FILTERS, starClasses: ['B' as const, 'G' as const, 'M' as const] }],
+    ['a non-default sort', { ...DEFAULT_FILTERS, sortKey: 'esi' as const, sortOrder: 'asc' as const }],
+    ['a range bounded at both ends', withRange(DEFAULT_FILTERS, 'radius', { min: 0.5, max: 2 })],
+    ['a range open at the top', withRange(DEFAULT_FILTERS, 'mass', { min: 10, max: null })],
+    ['a range open at the bottom', withRange(DEFAULT_FILTERS, 'period', { min: null, max: 365 })],
+    ['a fractional bound', withRange(DEFAULT_FILTERS, 'radius', { min: 0.0912, max: null })],
+    ['the longest periods in the archive', withRange(DEFAULT_FILTERS, 'period', { min: 8000000, max: null })],
+    [
+      'every filter at once',
+      {
+        ...withRange(withRange(DEFAULT_FILTERS, 'radius', { min: 0.5, max: 2 }), 'period', { min: null, max: 365 }),
+        q: 'wolf',
+        methods: ['Transit'],
+        starClasses: ['G' as const, 'M' as const],
+        sortKey: 'sy_dist' as const,
+        sortOrder: 'asc' as const,
+      },
+    ],
+  ])('round-trips %s through the URL', (_label, state) => {
+    expect(parse(serializeFilters(state))).toEqual(state);
+  });
+});
+
+describe('withRange', () => {
+  it('leaves the other ranges and filters alone', () => {
+    const state = withRange({ ...DEFAULT_FILTERS, q: 'wolf' }, 'radius', { min: 1, max: 2 });
+
+    expect(withRange(state, 'mass', { min: 5, max: null })).toEqual({
+      ...DEFAULT_FILTERS,
+      q: 'wolf',
+      ranges: {
+        radius: { min: 1, max: 2 },
+        mass: { min: 5, max: null },
+        period: { min: null, max: null },
+      },
+    });
+  });
+});
+
+describe('withSort', () => {
+  it('starts a newly chosen column descending', () => {
+    expect(withSort({ ...DEFAULT_FILTERS, sortOrder: 'asc' }, 'pl_rade')).toMatchObject({
+      sortKey: 'pl_rade',
+      sortOrder: 'desc',
+    });
+  });
+
+  it('flips direction when the active column is chosen again', () => {
+    const descending = withSort(DEFAULT_FILTERS, 'pl_rade');
+
+    expect(withSort(descending, 'pl_rade')).toMatchObject({ sortKey: 'pl_rade', sortOrder: 'asc' });
+    expect(withSort(withSort(descending, 'pl_rade'), 'pl_rade')).toMatchObject({ sortOrder: 'desc' });
+  });
+
+  it('leaves the other filters alone', () => {
+    expect(withSort({ ...DEFAULT_FILTERS, q: 'wolf', methods: ['Transit'] }, 'esi')).toMatchObject({
+      q: 'wolf',
+      methods: ['Transit'],
+    });
+  });
+});
+
+describe('withMethod', () => {
+  it('adds and removes one method without disturbing the others', () => {
+    const one = withMethod(DEFAULT_FILTERS, 'Transit', true);
+
+    expect(withMethod(one, 'Imaging', true).methods).toEqual(['Transit', 'Imaging']);
+    expect(withMethod(withMethod(one, 'Imaging', true), 'Transit', false).methods).toEqual(['Imaging']);
+  });
+
+  it('orders the selection so click order cannot produce two URLs for one set', () => {
+    const clickedInOrder = withMethod(withMethod(DEFAULT_FILTERS, 'Imaging', true), 'Transit', true);
+    const clickedInReverse = withMethod(withMethod(DEFAULT_FILTERS, 'Transit', true), 'Imaging', true);
+
+    expect(serializeFilters(clickedInOrder)).toBe(serializeFilters(clickedInReverse));
+  });
+
+  it('never selects the same method twice', () => {
+    expect(withMethod(withMethod(DEFAULT_FILTERS, 'Transit', true), 'Transit', true).methods).toEqual(['Transit']);
+  });
+
+  it('deselecting a method that was never selected is a no-op', () => {
+    expect(withMethod(DEFAULT_FILTERS, 'Transit', false).methods).toEqual([]);
+  });
+
+  it('leaves the other filters alone', () => {
+    const state = withMethod({ ...DEFAULT_FILTERS, q: 'wolf', sortKey: 'esi' }, 'Transit', true);
+
+    expect(state).toMatchObject({ q: 'wolf', sortKey: 'esi' });
+  });
+});
+
+describe('applyFilters', () => {
+  const planets = [ALPHA, BETA, GAMMA];
+
+  function names(state: Partial<FilterState>) {
+    return applyFilters(planets, { ...DEFAULT_FILTERS, ...state }).map((planet) => planet.pl_name);
+  }
+
+  it('hands back the original list when no filter is active, so downstream memos stay stable', () => {
+    expect(applyFilters(planets, DEFAULT_FILTERS)).toBe(planets);
+  });
+
+  it('matches planet names case insensitively', () => {
+    expect(names({ q: 'BETA' })).toEqual(['Beta c']);
+  });
+
+  it('matches host star names', () => {
+    expect(names({ q: 'ross' })).toEqual(['Alpha b']);
+  });
+
+  it('matches on a substring, not just a prefix', () => {
+    expect(names({ q: '186' })).toEqual(['Beta c']);
+  });
+
+  it('does not trip over a planet whose host star is unknown', () => {
+    expect(names({ q: 'gamma' })).toEqual(['Gamma d']);
+  });
+
+  it('ignores surrounding whitespace rather than matching zero planets', () => {
+    expect(names({ q: '  beta  ' })).toEqual(['Beta c']);
+  });
+
+  it('filters by discovery method', () => {
+    expect(names({ methods: ['Radial Velocity'] })).toEqual(['Beta c']);
+  });
+
+  it('takes the union of several methods rather than the intersection', () => {
+    expect(names({ methods: ['Radial Velocity', 'Transit'] })).toEqual(['Alpha b', 'Beta c', 'Gamma d']);
+  });
+
+  it('still returns the methods it recognises when the URL also names one the data lacks', () => {
+    expect(names({ methods: ['Astrometry', 'Radial Velocity'] })).toEqual(['Beta c']);
+  });
+
+  it('leaves out planets the archive gives no method for', () => {
+    const unknown = makePlanet({ pl_name: 'Nameless', discoverymethod: null });
+
+    expect(applyFilters([ALPHA, unknown], { ...DEFAULT_FILTERS, methods: ['Transit'] })).toEqual([ALPHA]);
+  });
+
+  it('requires a planet to satisfy every active filter', () => {
+    expect(names({ q: 'beta', methods: ['Transit'] })).toEqual([]);
+  });
+});
+
+describe('applyFilters over ranges', () => {
+  const SMALL = makePlanet({ pl_name: 'Small', pl_rade: 0.5, pl_bmasse: 0.2, pl_orbper: 0.09 });
+  const EARTHY = makePlanet({ pl_name: 'Earthy', pl_rade: 1, pl_bmasse: 1, pl_orbper: 365 });
+  const GIANT = makePlanet({ pl_name: 'Giant', pl_rade: 12, pl_bmasse: 300, pl_orbper: 8000000 });
+  const planets = [SMALL, EARTHY, GIANT];
+
+  function inRange(key: RangeKey, range: Range, list = planets) {
+    return applyFilters(list, withRange(DEFAULT_FILTERS, key, range)).map((planet) => planet.pl_name);
+  }
+
+  it.each([
+    ['radius', 'pl_rade' as const],
+    ['mass', 'pl_bmasse' as const],
+    ['period', 'pl_orbper' as const],
+  ])('reads %s off the planet field it names', (key, field) => {
+    const only = makePlanet({ pl_name: 'Only', [field]: 42 });
+
+    expect(inRange(key as RangeKey, { min: 41, max: 43 }, [only, makePlanet({ pl_name: 'Other', [field]: 1 })])).toEqual(['Only']);
+  });
+
+  it('keeps planets sitting exactly on either bound', () => {
+    expect(inRange('radius', { min: 0.5, max: 1 })).toEqual(['Small', 'Earthy']);
+  });
+
+  it('treats an omitted upper bound as no ceiling, so the longest orbits stay in', () => {
+    expect(inRange('period', { min: 365, max: null })).toEqual(['Earthy', 'Giant']);
+  });
+
+  it('treats an omitted lower bound as no floor', () => {
+    expect(inRange('mass', { min: null, max: 1 })).toEqual(['Small', 'Earthy']);
+  });
+
+  it('matches nothing when the bounds are the wrong way round, rather than silently widening', () => {
+    expect(inRange('radius', { min: 10, max: 1 })).toEqual([]);
+  });
+
+  it('applies every active range at once', () => {
+    const state = withRange(withRange(DEFAULT_FILTERS, 'radius', { min: 0.4, max: 2 }), 'period', {
+      min: 100,
+      max: null,
+    });
+
+    expect(applyFilters(planets, state).map((planet) => planet.pl_name)).toEqual(['Earthy']);
+  });
+
+  it('narrows a range against the search box rather than replacing it', () => {
+    const state = { ...withRange(DEFAULT_FILTERS, 'radius', { min: 0.4, max: 20 }), q: 'giant' };
+
+    expect(applyFilters(planets, state).map((planet) => planet.pl_name)).toEqual(['Giant']);
+  });
+});
+
+describe('applyFilters over planets the archive never measured', () => {
+  const MEASURED = makePlanet({ pl_name: 'Measured', pl_bmasse: 5 });
+  const UNMEASURED = makePlanet({ pl_name: 'Unmeasured', pl_bmasse: null });
+  const planets = [MEASURED, UNMEASURED];
+
+  it('keeps an unmeasured planet while the range that would judge it is inactive', () => {
+    expect(applyFilters(planets, DEFAULT_FILTERS)).toBe(planets);
+  });
+
+  it.each([
+    ['both ends', { min: 1, max: 10 }],
+    ['only a floor', { min: 1, max: null }],
+    ['only a ceiling', { min: null, max: 10 }],
+  ])('hides an unmeasured planet once the range sets %s', (_label, range) => {
+    expect(applyFilters(planets, withRange(DEFAULT_FILTERS, 'mass', range)).map((p) => p.pl_name)).toEqual([
+      'Measured',
+    ]);
+  });
+
+  it('hides it for the range that asks about it and no other', () => {
+    const state = withRange(DEFAULT_FILTERS, 'radius', { min: 0, max: 100 });
+
+    expect(applyFilters(planets, state).map((planet) => planet.pl_name)).toEqual([
+      'Measured',
+      'Unmeasured',
+    ]);
+  });
+});
+
+describe('measuredExtent', () => {
+  it('spans the smallest and largest measurement present', () => {
+    const planets = [
+      makePlanet({ pl_name: 'A', pl_orbper: 365 }),
+      makePlanet({ pl_name: 'B', pl_orbper: 0.09 }),
+      makePlanet({ pl_name: 'C', pl_orbper: 8000000 }),
+    ];
+
+    expect(measuredExtent(planets, 'period')).toEqual({ min: 0.09, max: 8000000 });
+  });
+
+  it('skips the planets the archive left blank', () => {
+    const planets = [
+      makePlanet({ pl_name: 'A', pl_bmasse: null }),
+      makePlanet({ pl_name: 'B', pl_bmasse: 3 }),
+    ];
+
+    expect(measuredExtent(planets, 'mass')).toEqual({ min: 3, max: 3 });
+  });
+
+  it('reports no extent at all when nothing was measured, so no track can be drawn', () => {
+    expect(measuredExtent([makePlanet({ pl_name: 'A', pl_rade: null })], 'radius')).toEqual({
+      min: null,
+      max: null,
+    });
+  });
+
+  it('reports no extent for an empty archive', () => {
+    expect(measuredExtent([], 'radius')).toEqual({ min: null, max: null });
+  });
+});
+
+describe('sortPlanets', () => {
+  function ordered(planets: PlanetSummary[], sortKey: FilterState['sortKey'], sortOrder: FilterState['sortOrder']) {
+    return sortPlanets(planets, { ...DEFAULT_FILTERS, sortKey, sortOrder }).map((planet) => planet.pl_name);
+  }
+
+  const BY_YEAR = [
+    makePlanet({ pl_name: 'Older', disc_year: 2008 }),
+    makePlanet({ pl_name: 'Newer', disc_year: 2021 }),
+  ];
+
+  it('orders by the key and direction it is given', () => {
+    expect(ordered(BY_YEAR, 'disc_year', 'desc')).toEqual(['Newer', 'Older']);
+    expect(ordered(BY_YEAR, 'disc_year', 'asc')).toEqual(['Older', 'Newer']);
+  });
+
+  it('compares names case insensitively', () => {
+    const planets = [makePlanet({ pl_name: 'beta' }), makePlanet({ pl_name: 'Alpha' })];
+
+    expect(ordered(planets, 'pl_name', 'asc')).toEqual(['Alpha', 'beta']);
+  });
+
+  it('ranks planets the archive never measured last in both directions', () => {
+    const planets = [
+      makePlanet({ pl_name: 'Unmeasured', pl_rade: null }),
+      makePlanet({ pl_name: 'Small', pl_rade: 1 }),
+      makePlanet({ pl_name: 'Large', pl_rade: 9 }),
+    ];
+
+    expect(ordered(planets, 'pl_rade', 'desc')).toEqual(['Large', 'Small', 'Unmeasured']);
+    expect(ordered(planets, 'pl_rade', 'asc')).toEqual(['Small', 'Large', 'Unmeasured']);
+  });
+
+  it('compares numbers numerically rather than lexicographically', () => {
+    const planets = [
+      makePlanet({ pl_name: 'Nine', pl_rade: 9 }),
+      makePlanet({ pl_name: 'Eighty', pl_rade: 80 }),
+    ];
+
+    expect(ordered(planets, 'pl_rade', 'asc')).toEqual(['Nine', 'Eighty']);
+  });
+
+  it('ranks an unscored planet last but a real zero among the scored', () => {
+    const planets = [
+      makePlanet({ pl_name: 'Unscored' }),
+      makePlanet({ pl_name: 'Middling', esi: 55 }),
+      makePlanet({ pl_name: 'Zero', esi: 0 }),
+      makePlanet({ pl_name: 'Scored', esi: 92 }),
+    ];
+
+    expect(ordered(planets, 'esi', 'desc')).toEqual(['Scored', 'Middling', 'Zero', 'Unscored']);
+    expect(ordered(planets, 'esi', 'asc')).toEqual(['Zero', 'Middling', 'Scored', 'Unscored']);
+  });
+
+  it('leaves the list it was handed untouched', () => {
+    const planets = [BETA, ALPHA];
+
+    sortPlanets(planets, { ...DEFAULT_FILTERS, sortKey: 'pl_name', sortOrder: 'asc' });
+
+    expect(planets.map((planet) => planet.pl_name)).toEqual(['Beta c', 'Alpha b']);
+  });
+});
+
+describe('discoveryMethods', () => {
+  it('lists each method present in the data once, in a stable alphabetical order', () => {
+    expect(discoveryMethods([BETA, ALPHA, BETA])).toEqual(['Radial Velocity', 'Transit']);
+  });
+
+  it('leaves out planets the archive gives no method for', () => {
+    expect(discoveryMethods([makePlanet({ pl_name: 'Unknown', discoverymethod: null })])).toEqual([]);
+  });
+});
+
+describe('parseFilters over ?star=', () => {
+  it('reads a comma-separated class list', () => {
+    expect(parse('star=G,M')).toMatchObject({ starClasses: ['G', 'M'] });
+  });
+
+  it('orders the URL it writes by temperature, not alphabetically', () => {
+    expect(serializeFilters(parse('star=M,B,G'))).toBe('star=B%2CG%2CM');
+  });
+
+  it('gives one set of classes exactly one URL however the visitor assembled it', () => {
+    expect(serializeFilters(parse('star=M,G'))).toBe(serializeFilters(parse('star=G,M')));
+  });
+
+  it.each([
+    ['a class that does not exist', 'star=Q', []],
+    ['the lowercase form of a real class', 'star=g', []],
+    ['a spectral subtype', 'star=G2V', []],
+    ['an unclassified band the URL invented', 'star=L,T', []],
+    ['junk mixed in with a real class', 'star=Q,G,,%20', ['G']],
+    ['a repeated class', 'star=G,M,G', ['G', 'M']],
+    ['nothing but separators', 'star=,,', []],
+  ])('ignores %s rather than erroring', (_label, query, expected) => {
+    expect(parse(query)).toMatchObject({ starClasses: expected });
+  });
+
+  it('leaves an empty star list out of the URL entirely', () => {
+    expect(serializeFilters({ ...DEFAULT_FILTERS, starClasses: [] })).toBe('');
+  });
+});
+
+describe('withStarClass', () => {
+  it('adds and removes one class without disturbing the others', () => {
+    const one = withStarClass(DEFAULT_FILTERS, 'G', true);
+
+    expect(withStarClass(one, 'M', true).starClasses).toEqual(['G', 'M']);
+    expect(withStarClass(withStarClass(one, 'M', true), 'G', false).starClasses).toEqual(['M']);
+  });
+
+  it('orders the selection so click order cannot produce two URLs for one set', () => {
+    const hotFirst = withStarClass(withStarClass(DEFAULT_FILTERS, 'G', true), 'M', true);
+    const coolFirst = withStarClass(withStarClass(DEFAULT_FILTERS, 'M', true), 'G', true);
+
+    expect(serializeFilters(hotFirst)).toBe(serializeFilters(coolFirst));
+    expect(serializeFilters(hotFirst)).toBe('star=G%2CM');
+  });
+
+  it('never selects the same class twice', () => {
+    expect(withStarClass(withStarClass(DEFAULT_FILTERS, 'G', true), 'G', true).starClasses).toEqual(['G']);
+  });
+
+  it('deselecting a class that was never selected is a no-op', () => {
+    expect(withStarClass(DEFAULT_FILTERS, 'G', false).starClasses).toEqual([]);
+  });
+
+  it('leaves the other filters alone', () => {
+    expect(withStarClass({ ...DEFAULT_FILTERS, q: 'wolf', methods: ['Transit'] }, 'M', true)).toMatchObject({
+      q: 'wolf',
+      methods: ['Transit'],
+      starClasses: ['M'],
+    });
+  });
+});
+
+describe('applyFilters over star type', () => {
+  const SUNLIKE = makePlanet({ pl_name: 'Sunlike b', st_teff: 5800 });
+  const RED = makePlanet({ pl_name: 'Red c', st_teff: 3000 });
+  const BLUE = makePlanet({ pl_name: 'Blue d', st_teff: 12000 });
+  const BROWN = makePlanet({ pl_name: 'Brown e', st_teff: 1200 });
+  const UNMEASURED = makePlanet({ pl_name: 'Unmeasured f', st_teff: null });
+  const ALL = [SUNLIKE, RED, BLUE, BROWN, UNMEASURED];
+
+  function starNames(starClasses: FilterState['starClasses']) {
+    return applyFilters(ALL, { ...DEFAULT_FILTERS, starClasses }).map((planet) => planet.pl_name);
+  }
+
+  it('keeps only the planets whose host falls in the chosen class', () => {
+    expect(starNames(['G'])).toEqual(['Sunlike b']);
+  });
+
+  it('takes the union of several classes rather than the intersection', () => {
+    expect(starNames(['B', 'M'])).toEqual(['Red c', 'Blue d']);
+  });
+
+  it('returns every planet, unclassified hosts included, while the filter is inactive', () => {
+    expect(starNames([])).toHaveLength(ALL.length);
+  });
+
+  it.each([
+    ['a host cooler than the M band', 'Brown e'],
+    ['a host the archive never measured', 'Unmeasured f'],
+  ])('hides %s while any class is chosen', (_label, hidden) => {
+    expect(starNames(['G', 'M'])).not.toContain(hidden);
+    expect(starNames(['O', 'B', 'A', 'F', 'G', 'K', 'M'])).not.toContain(hidden);
+  });
+
+  it('narrows rather than widens when combined with another filter', () => {
+    expect(applyFilters(ALL, { ...DEFAULT_FILTERS, starClasses: ['G'], q: 'red' })).toEqual([]);
+  });
+});
+
+describe('isFiltered', () => {
+  it('reports the default view as unfiltered', () => {
+    expect(isFiltered(DEFAULT_FILTERS)).toBe(false);
+  });
+
+  it.each([
+    ['a search', { q: 'kepler' }],
+    ['a method', { methods: ['Transit'] }],
+    ['a star class', { starClasses: ['G' as const] }],
+    ['a range', { ranges: { ...DEFAULT_FILTERS.ranges, radius: { min: 1, max: null } } }],
+  ])('reports %s as filtered', (_label, active) => {
+    expect(isFiltered({ ...DEFAULT_FILTERS, ...active })).toBe(true);
+  });
+
+  // Sort reorders the page; it never hides a planet, so it alone leaves nothing to clear.
+  it('does not count sort as a filter', () => {
+    expect(isFiltered({ ...DEFAULT_FILTERS, sortKey: 'esi', sortOrder: 'asc' })).toBe(false);
+  });
+
+  it('does not count a search of nothing but whitespace', () => {
+    expect(isFiltered({ ...DEFAULT_FILTERS, q: '   ' })).toBe(false);
+  });
+});
+
+describe('cleared', () => {
+  const EVERYTHING: FilterState = {
+    ...DEFAULT_FILTERS,
+    q: 'kepler',
+    methods: ['Transit'],
+    starClasses: ['G'],
+    ranges: { ...DEFAULT_FILTERS.ranges, radius: { min: 1, max: 2 } },
+    sortKey: 'pl_rade',
+    sortOrder: 'asc',
+  };
+
+  it('drops every filter isFiltered counts', () => {
+    expect(isFiltered(cleared(EVERYTHING))).toBe(false);
+  });
+
+  // The same rule as isFiltered, in the same module, so the two can never disagree about sort.
+  it('keeps the sort, which isFiltered does not count as a filter', () => {
+    expect(cleared(EVERYTHING)).toMatchObject({ sortKey: 'pl_rade', sortOrder: 'asc' });
+  });
+
+  it('leaves the state it was handed alone', () => {
+    const before = structuredClone(EVERYTHING);
+
+    cleared(EVERYTHING);
+
+    expect(EVERYTHING).toEqual(before);
+  });
+});
diff --git a/exoplanethub.com/lib/planetFilters.ts b/exoplanethub.com/lib/planetFilters.ts
new file mode 100644
index 0000000..3669f89
--- /dev/null
+++ b/exoplanethub.com/lib/planetFilters.ts
@@ -0,0 +1,290 @@
+import { PlanetSummary } from '@/lib/mockPlanets';
+import { StarClass, STAR_CLASSES, isStarClass, starClassOf } from '@/lib/starBands';
+
+export const SORT_KEYS = [
+  'pl_name',
+  'discoverymethod',
+  'pl_rade',
+  'sy_dist',
+  'disc_year',
+  'esi',
+] as const satisfies readonly (keyof PlanetSummary)[];
+
+export type SortKey = (typeof SORT_KEYS)[number];
+export type SortOrder = 'asc' | 'desc';
+
+export const RANGE_FIELDS = {
+  radius: 'pl_rade',
+  mass: 'pl_bmasse',
+  period: 'pl_orbper',
+} as const satisfies Record<string, keyof PlanetSummary>;
+
+export type RangeKey = keyof typeof RANGE_FIELDS;
+
+export const RANGE_KEYS = Object.keys(RANGE_FIELDS) as RangeKey[];
+
+export interface Range {
+  min: number | null;
+  max: number | null;
+}
+
+export type RangeFilters = Record<RangeKey, Range>;
+
+export interface FilterState {
+  q: string;
+  methods: string[];
+  starClasses: StarClass[];
+  ranges: RangeFilters;
+  sortKey: SortKey;
+  sortOrder: SortOrder;
+}
+
+const DEFAULT_SORT_KEY: SortKey = 'disc_year';
+const DEFAULT_SORT_ORDER: SortOrder = 'desc';
+const RANGE_SEPARATOR = '..';
+const LIST_SEPARATOR = ',';
+const UNBOUNDED: Range = { min: null, max: null };
+
+function rangesFrom(read: (key: RangeKey) => Range): RangeFilters {
+  return Object.fromEntries(RANGE_KEYS.map((key) => [key, read(key)])) as RangeFilters;
+}
+
+export const DEFAULT_FILTERS: FilterState = {
+  q: '',
+  methods: [],
+  starClasses: [],
+  ranges: rangesFrom(() => UNBOUNDED),
+  sortKey: DEFAULT_SORT_KEY,
+  sortOrder: DEFAULT_SORT_ORDER,
+};
+
+export function isRangeActive(range: Range): boolean {
+  return range.min !== null || range.max !== null;
+}
+
+function isSortKey(value: string | undefined): value is SortKey {
+  return SORT_KEYS.includes(value as SortKey);
+}
+
+function isSortOrder(value: string | undefined): value is SortOrder {
+  return value === 'asc' || value === 'desc';
+}
+
+function parseSort(raw: string | null): Pick<FilterState, 'sortKey' | 'sortOrder'> {
+  const [key, order] = raw?.split('.') ?? [];
+
+  return isSortKey(key) && isSortOrder(order)
+    ? { sortKey: key, sortOrder: order }
+    : { sortKey: DEFAULT_SORT_KEY, sortOrder: DEFAULT_SORT_ORDER };
+}
+
+// `undefined` is a bound that failed to parse; `null` is one the URL or the visitor left empty.
+export function parseBound(raw: string): number | null | undefined {
+  if (raw.trim() === '') return null;
+
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : undefined;
+}
+
+function parseList(raw: string | null): string[] {
+  const named = raw?.split(LIST_SEPARATOR).map((value) => value.trim()) ?? [];
+
+  return Array.from(new Set(named.filter(Boolean)));
+}
+
+function parseRange(raw: string | null): Range {
+  const [minRaw, maxRaw, ...rest] = raw?.split(RANGE_SEPARATOR) ?? [];
+  if (maxRaw === undefined || rest.length > 0) return UNBOUNDED;
+
+  const min = parseBound(minRaw);
+  const max = parseBound(maxRaw);
+
+  return min === undefined || max === undefined ? UNBOUNDED : { min, max };
+}
+
+function serializeRange(range: Range): string {
+  return isRangeActive(range) ? `${range.min ?? ''}${RANGE_SEPARATOR}${range.max ?? ''}` : '';
+}
+
+export function parseFilters(params: URLSearchParams): FilterState {
+  return {
+    q: params.get('q') ?? '',
+    methods: parseList(params.get('method')),
+    starClasses: parseList(params.get('star')).filter(isStarClass),
+    ranges: rangesFrom((key) => parseRange(params.get(key))),
+    ...parseSort(params.get('sort')),
+  };
+}
+
+const bySpectralOrder = (a: StarClass, b: StarClass) =>
+  STAR_CLASSES.indexOf(a) - STAR_CLASSES.indexOf(b);
+
+export function serializeFilters(state: FilterState): string {
+  const params = new URLSearchParams();
+
+  const q = state.q.trim();
+
+  if (q) params.set('q', q);
+
+  // The one place a selection is ordered, so a set has exactly one URL however it was assembled.
+  if (state.methods.length > 0) params.set('method', [...state.methods].sort().join(LIST_SEPARATOR));
+  if (state.starClasses.length > 0) {
+    params.set('star', [...state.starClasses].sort(bySpectralOrder).join(LIST_SEPARATOR));
+  }
+
+  for (const key of RANGE_KEYS) {
+    const range = serializeRange(state.ranges[key]);
+    if (range) params.set(key, range);
+  }
+
+  if (state.sortKey !== DEFAULT_SORT_KEY || state.sortOrder !== DEFAULT_SORT_ORDER) {
+    params.set('sort', `${state.sortKey}.${state.sortOrder}`);
+  }
+
+  return params.toString();
+}
+
+export function withSort(state: FilterState, key: SortKey): FilterState {
+  if (state.sortKey !== key) return { ...state, sortKey: key, sortOrder: 'desc' };
+
+  return { ...state, sortOrder: state.sortOrder === 'asc' ? 'desc' : 'asc' };
+}
+
+export function withRange(state: FilterState, key: RangeKey, range: Range): FilterState {
+  return { ...state, ranges: { ...state.ranges, [key]: range } };
+}
+
+function toggled<T extends string>(values: readonly T[], value: T, selected: boolean): T[] {
+  const rest = values.filter((current) => current !== value);
+
+  return selected ? [...rest, value] : rest;
+}
+
+export function withMethod(state: FilterState, method: string, selected: boolean): FilterState {
+  return { ...state, methods: toggled(state.methods, method, selected) };
+}
+
+export function withStarClass(
+  state: FilterState,
+  starClass: StarClass,
+  selected: boolean
+): FilterState {
+  return { ...state, starClasses: toggled(state.starClasses, starClass, selected) };
+}
+
+function matchesText(planet: PlanetSummary, needle: string): boolean {
+  return (
+    planet.pl_name.toLowerCase().includes(needle) ||
+    (planet.hostname?.toLowerCase().includes(needle) ?? false)
+  );
+}
+
+// An unmeasured quantity can satisfy no bound, so those planets drop out — but only while the
+// range that asked about them is active, which is why the predicate exists only then.
+function matchesRange(value: number | null, range: Range): boolean {
+  return (
+    value !== null &&
+    (range.min === null || value >= range.min) &&
+    (range.max === null || value <= range.max)
+  );
+}
+
+type PlanetPredicate = (planet: PlanetSummary) => boolean;
+
+function activePredicates(state: FilterState): PlanetPredicate[] {
+  const predicates: PlanetPredicate[] = [];
+  const needle = state.q.trim().toLowerCase();
+
+  if (needle) predicates.push((planet) => matchesText(planet, needle));
+
+  if (state.methods.length > 0) {
+    const chosen = new Set(state.methods);
+    predicates.push((planet) => planet.discoverymethod !== null && chosen.has(planet.discoverymethod));
+  }
+
+  if (state.starClasses.length > 0) {
+    const chosen = new Set<StarClass>(state.starClasses);
+    predicates.push((planet) => {
+      const starClass = starClassOf(planet.st_teff);
+      return starClass !== null && chosen.has(starClass);
+    });
+  }
+
+  for (const key of RANGE_KEYS) {
+    const range = state.ranges[key];
+    const field = RANGE_FIELDS[key];
+
+    if (isRangeActive(range)) predicates.push((planet) => matchesRange(planet[field], range));
+  }
+
+  return predicates;
+}
+
+// Derived from the predicates themselves, so a filter added later cannot forget to count here.
+export function isFiltered(state: FilterState): boolean {
+  return activePredicates(state).length > 0;
+}
+
+// Sort is not a filter — `activePredicates` never registers it — so clearing must leave it standing.
+export function cleared(state: FilterState): FilterState {
+  return { ...DEFAULT_FILTERS, sortKey: state.sortKey, sortOrder: state.sortOrder };
+}
+
+export function applyFilters(planets: PlanetSummary[], state: FilterState): PlanetSummary[] {
+  const predicates = activePredicates(state);
+  if (predicates.length === 0) return planets;
+
+  return planets.filter((planet) => predicates.every((matches) => matches(planet)));
+}
+
+type SortValue = PlanetSummary[SortKey];
+
+// Unmeasured planets sort last in both directions: null coerces to 0 under <, which would
+// otherwise rank every planet NASA has no value for ahead of the real measurements.
+function compareSortValues(a: SortValue, b: SortValue, order: SortOrder): number {
+  if (a == null || b == null) return a == null && b == null ? 0 : a == null ? 1 : -1;
+
+  const direction = order === 'asc' ? 1 : -1;
+
+  if (typeof a === 'string' && typeof b === 'string') {
+    const left = a.toLowerCase();
+    const right = b.toLowerCase();
+    return left === right ? 0 : (left < right ? -1 : 1) * direction;
+  }
+
+  return (Number(a) - Number(b)) * direction;
+}
+
+// Ordering the whole result set here rather than inside a view is what keeps grid page N and
+// table page N holding the same planets, which is the promise a shared URL makes.
+export function sortPlanets(planets: PlanetSummary[], state: FilterState): PlanetSummary[] {
+  const { sortKey, sortOrder } = state;
+
+  return [...planets].sort((a, b) => compareSortValues(a[sortKey], b[sortKey], sortOrder));
+}
+
+export function discoveryMethods(planets: PlanetSummary[]): string[] {
+  const present = planets
+    .map((planet) => planet.discoverymethod)
+    .filter((method): method is string => Boolean(method));
+
+  return Array.from(new Set(present)).sort();
+}
+
+// The track a slider spans, not a filter: bounds come from what the archive actually measured,
+// since hardcoding them would cut the long-period tail off the end.
+export function measuredExtent(planets: PlanetSummary[], key: RangeKey): Range {
+  const field = RANGE_FIELDS[key];
+  let min: number | null = null;
+  let max: number | null = null;
+
+  for (const planet of planets) {
+    const value = planet[field];
+    if (value === null || !Number.isFinite(value)) continue;
+
+    if (min === null || value < min) min = value;
+    if (max === null || value > max) max = value;
+  }
+
+  return { min, max };
+}
diff --git a/exoplanethub.com/lib/planetMetadata.test.ts b/exoplanethub.com/lib/planetMetadata.test.ts
new file mode 100644
index 0000000..20d267a
--- /dev/null
+++ b/exoplanethub.com/lib/planetMetadata.test.ts
@@ -0,0 +1,157 @@
+import { describe, expect, it } from 'vitest';
+import type { Planet } from '@/lib/mockPlanets';
+import { planetMetadata } from '@/lib/planetMetadata';
+import { SHARE_IMAGE_SIZE } from '@/lib/shareImage';
+
+const NAME_ONLY: Planet = {
+  pl_name: 'Kepler-452 b',
+  hostname: null,
+  sy_snum: null,
+  sy_pnum: null,
+  sy_dist: null,
+  discoverymethod: null,
+  disc_year: null,
+  disc_facility: null,
+  pl_orbper: null,
+  pl_orbsmax: null,
+  pl_rade: null,
+  pl_bmasse: null,
+  pl_dens: null,
+  pl_eqt: null,
+  pl_insol: null,
+  st_teff: null,
+  st_rad: null,
+  st_mass: null,
+  st_logg: null,
+  st_age: null,
+  last_updated: '2026-08-30T06:00:00Z',
+};
+
+const KEPLER_452B: Planet = {
+  ...NAME_ONLY,
+  sy_dist: 551.7,
+  pl_orbper: 384.843,
+  pl_rade: 1.63,
+};
+
+function describedAs(planet: Partial<Planet>): string {
+  return String(planetMetadata({ ...NAME_ONLY, ...planet }).description);
+}
+
+function shareImageOf(planet: Planet) {
+  const images = planetMetadata(planet).openGraph?.images;
+  if (!Array.isArray(images)) throw new Error('expected planetMetadata to name one share image');
+
+  return images[0] as { url: string; alt: string; width: number; height: number };
+}
+
+describe('planetMetadata titles', () => {
+  it('names the planet before the site, so a tab strip stays readable', () => {
+    expect(planetMetadata(KEPLER_452B).title).toBe(
+      'Kepler-452 b — Exoplanet Profile | ExoplanetHub'
+    );
+  });
+
+  it('leaves the site name to og:site_name rather than repeating it in the card title', () => {
+    const { openGraph, twitter } = planetMetadata(KEPLER_452B);
+
+    expect(openGraph?.title).toBe('Kepler-452 b — Exoplanet Profile');
+    expect(twitter?.title).toBe('Kepler-452 b — Exoplanet Profile');
+  });
+});
+
+describe('planetMetadata description', () => {
+  it('carries the stats that make a shared link worth opening', () => {
+    expect(describedAs(KEPLER_452B)).toBe(
+      "Kepler-452 b — 1.63× Earth's radius, 384.8-day orbit, 1,799 light-years away."
+    );
+  });
+
+  it('closes the list cleanly when only some stats were measured', () => {
+    expect(describedAs({ pl_rade: 1.63, sy_dist: 551.7 })).toBe(
+      "Kepler-452 b — 1.63× Earth's radius, 1,799 light-years away."
+    );
+  });
+
+  it('still reads as a sentence when a single stat survives', () => {
+    expect(describedAs({ pl_orbper: 384.843 })).toBe('Kepler-452 b — 384.8-day orbit.');
+  });
+
+  it('falls back to a plain claim rather than an empty clause', () => {
+    expect(describedAs({})).toBe(
+      "Kepler-452 b — a confirmed exoplanet in NASA's Exoplanet Archive."
+    );
+  });
+
+  it.each([
+    ['a dangling comma', /,\s*\./],
+    ['a dangling dash', /—\s*\./],
+    ['undefined', /undefined/],
+    ['NaN', /NaN/],
+    ['null', /null/],
+  ])('never leaks %s into a preview, whatever the archive withheld', (_case, leak) => {
+    const partials: Partial<Planet>[] = [
+      {},
+      { pl_rade: 1.63 },
+      { pl_orbper: 384.843 },
+      { sy_dist: 551.7 },
+      { pl_rade: NaN, pl_orbper: Infinity, sy_dist: NaN },
+      KEPLER_452B,
+    ];
+
+    for (const planet of partials) expect(describedAs(planet)).not.toMatch(leak);
+  });
+});
+
+describe('planetMetadata link preview', () => {
+  it('points the canonical and og:url at the encoded planet page', () => {
+    const { alternates, openGraph } = planetMetadata(KEPLER_452B);
+
+    expect(alternates?.canonical).toBe('/planet/Kepler-452%20b');
+    expect(openGraph).toMatchObject({ url: '/planet/Kepler-452%20b', siteName: 'ExoplanetHub' });
+  });
+
+  it('asks for the wide card the per-planet image will fill', () => {
+    expect(planetMetadata(KEPLER_452B).twitter).toMatchObject({ card: 'summary_large_image' });
+  });
+
+  it('names the planet in the image alt a screen reader announces for a shared link', () => {
+    expect(shareImageOf(KEPLER_452B).alt).toContain('Kepler-452 b');
+  });
+
+  it('points the card at the planet it belongs to, at the size that route draws', () => {
+    const image = shareImageOf(KEPLER_452B);
+
+    expect(image.url).toBe('/planet/Kepler-452%20b/opengraph-image');
+    expect(image).toMatchObject(SHARE_IMAGE_SIZE);
+  });
+
+  it('gives the card the same sentence as the meta description', () => {
+    const { description, openGraph, twitter } = planetMetadata(KEPLER_452B);
+
+    expect(openGraph?.description).toBe(description);
+    expect(twitter?.description).toBe(description);
+  });
+});
+
+describe('planetMetadata for a planet we do not hold', () => {
+  it('titles the 404 instead of inheriting the site-wide title', () => {
+    expect(planetMetadata(null).title).toBe('Planet not found | ExoplanetHub');
+  });
+
+  it('keeps every guessed name out of the index', () => {
+    expect(planetMetadata(null).robots).toMatchObject({ index: false });
+  });
+
+  it('claims no canonical URL for an address that holds nothing', () => {
+    const missing = planetMetadata(null);
+
+    expect(missing.alternates).toBeUndefined();
+    expect(missing.openGraph).toBeUndefined();
+  });
+
+  // Leaving openGraph unset is what lets the file convention answer with the branded card.
+  it('names no share image, so the unfurl falls back to the branded card', () => {
+    expect(planetMetadata(null).openGraph?.images).toBeUndefined();
+  });
+});
diff --git a/exoplanethub.com/lib/planetMetadata.ts b/exoplanethub.com/lib/planetMetadata.ts
new file mode 100644
index 0000000..3268e10
--- /dev/null
+++ b/exoplanethub.com/lib/planetMetadata.ts
@@ -0,0 +1,49 @@
+import type { Metadata } from 'next';
+import type { Planet } from '@/lib/mockPlanets';
+import { planetHighlights } from '@/lib/planetStats';
+import { planetUrl } from '@/lib/planetUrl';
+import { SHARE_IMAGE_SIZE, shareImageAlt, shareImageUrl } from '@/lib/shareImage';
+
+const SITE_NAME = 'ExoplanetHub';
+
+// The archive stores planets it has barely measured, and a preview of bare commas reads as a broken page.
+const UNMEASURED = "a confirmed exoplanet in NASA's Exoplanet Archive";
+
+const MISSING_PLANET: Metadata = {
+  title: `Planet not found | ${SITE_NAME}`,
+  description:
+    "That planet is not in our copy of NASA's Exoplanet Archive. Search ExoplanetHub by name to " +
+    'find confirmed exoplanets.',
+  robots: { index: false },
+};
+
+function previewSentence(planet: Planet): string {
+  const highlights = planetHighlights(planet);
+  return `${planet.pl_name} — ${highlights.length > 0 ? highlights.join(', ') : UNMEASURED}.`;
+}
+
+export function planetMetadata(planet: Planet | null): Metadata {
+  if (planet === null) return MISSING_PLANET;
+
+  const title = `${planet.pl_name} — Exoplanet Profile`;
+  const description = previewSentence(planet);
+  const url = planetUrl(planet.pl_name);
+
+  return {
+    title: `${title} | ${SITE_NAME}`,
+    description,
+    alternates: { canonical: url },
+    // Set here, not left to the file convention, whose alt is one constant for every planet.
+    openGraph: {
+      type: 'website',
+      siteName: SITE_NAME,
+      title,
+      description,
+      url,
+      images: [
+        { url: shareImageUrl(planet.pl_name), ...SHARE_IMAGE_SIZE, alt: shareImageAlt(planet.pl_name) },
+      ],
+    },
+    twitter: { card: 'summary_large_image', title, description },
+  };
+}
diff --git a/exoplanethub.com/lib/planetStats.test.ts b/exoplanethub.com/lib/planetStats.test.ts
new file mode 100644
index 0000000..bc178e7
--- /dev/null
+++ b/exoplanethub.com/lib/planetStats.test.ts
@@ -0,0 +1,254 @@
+import { describe, expect, it } from 'vitest';
+import type { Planet } from '@/lib/mockPlanets';
+import {
+  planetHighlights,
+  planetKeyStats,
+  planetStatSections,
+  type PlanetStat,
+} from '@/lib/planetStats';
+
+const UNMEASURED: Planet = {
+  pl_name: 'Kepler-452 b',
+  hostname: null,
+  sy_snum: null,
+  sy_pnum: null,
+  sy_dist: null,
+  discoverymethod: null,
+  disc_year: null,
+  disc_facility: null,
+  pl_orbper: null,
+  pl_orbsmax: null,
+  pl_rade: null,
+  pl_bmasse: null,
+  pl_dens: null,
+  pl_eqt: null,
+  pl_insol: null,
+  st_teff: null,
+  st_rad: null,
+  st_mass: null,
+  st_logg: null,
+  st_age: null,
+  last_updated: '2026-08-30T06:00:00Z',
+};
+
+function statsOf(planet: Partial<Planet>): PlanetStat[] {
+  return planetStatSections({ ...UNMEASURED, ...planet }).flatMap((section) => section.stats);
+}
+
+function valueOf(label: string, planet: Partial<Planet>): string | null {
+  const stat = statsOf(planet).find((candidate) => candidate.label === label);
+  if (!stat) throw new Error(`No stat labelled "${label}"`);
+  return stat.value;
+}
+
+describe('planetStatSections structure', () => {
+  it('groups the archive fields into Planet, Star, System and Discovery, in that order', () => {
+    expect(planetStatSections(UNMEASURED).map((section) => section.title)).toEqual([
+      'Planet',
+      'Star',
+      'System',
+      'Discovery',
+    ]);
+  });
+
+  it('gives every section an id distinct enough to key a heading', () => {
+    const ids = planetStatSections(UNMEASURED).map((section) => section.id);
+
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  it('labels every stat uniquely within its own section', () => {
+    for (const section of planetStatSections(UNMEASURED)) {
+      const labels = section.stats.map((stat) => stat.label);
+      expect(new Set(labels).size).toBe(labels.length);
+    }
+  });
+
+  // Surface gravity in log-cgs means nothing to a lay reader; the spec cuts it deliberately.
+  it('leaves surface gravity out even when the archive has it', () => {
+    const values = statsOf({ st_logg: 4.32 }).map((stat) => stat.value);
+
+    expect(values.some((value) => value?.includes('4.32'))).toBe(false);
+  });
+});
+
+describe('planetStatSections values', () => {
+  it.each([
+    ['Radius', { pl_rade: 1.63 }, '1.63 × Earth'],
+    ['Mass', { pl_bmasse: 5 }, '5 × Earth'],
+    ['Density', { pl_dens: 5.51 }, '5.51 g/cm³'],
+    ['Equilibrium temperature', { pl_eqt: 265 }, '265 K'],
+    ['Starlight received', { pl_insol: 1.1 }, '1.1 × Earth'],
+    ['Orbital period', { pl_orbper: 384.843 }, '384.8 days'],
+    ['Average distance from its star', { pl_orbsmax: 1.046 }, '1.046 AU'],
+    ['Surface temperature', { st_teff: 5757 }, '5,757 K'],
+    ['Age', { st_age: 6 }, '6 billion years'],
+  ])('renders %s with its unit', (label, planet, expected) => {
+    expect(valueOf(label, planet)).toBe(expected);
+  });
+
+  it('names the host star as the archive spells it', () => {
+    expect(valueOf('Host star', { hostname: 'Kepler-452' })).toBe('Kepler-452');
+  });
+
+  it('reads the spectral class off the star temperature rather than storing one', () => {
+    expect(valueOf('Spectral class', { st_teff: 5757 })).toBe('G — sun-like');
+  });
+
+  // Parsecs are the archive's unit and light-years are the reader's; the page owes both.
+  it('gives distance in light-years first and parsecs alongside', () => {
+    expect(valueOf('Distance from Earth', { sy_dist: 551.7 })).toBe(
+      '1,799 light-years (551.7 parsecs)'
+    );
+  });
+
+  it.each([
+    ['Year', { disc_year: 2015 }, '2015'],
+    ['Stars in system', { sy_snum: 1 }, '1'],
+    ['Known planets', { sy_pnum: 5 }, '5'],
+  ])('prints %s exactly, without grouping separators', (label, planet, expected) => {
+    expect(valueOf(label, planet)).toBe(expected);
+  });
+
+  it('keeps short-period orbits legible instead of rounding them to zero', () => {
+    expect(valueOf('Orbital period', { pl_orbper: 0.0007365474 })).toBe('0.0007365 days');
+  });
+});
+
+describe('planetStatSections unknowns', () => {
+  it('reports every field of a name-only planet as unknown, dropping none of them', () => {
+    const stats = statsOf({});
+
+    expect(stats).toHaveLength(19);
+    expect(stats.every((stat) => stat.value === null)).toBe(true);
+  });
+
+  it.each([
+    ['a blank host name', { hostname: '  ' }, 'Host star'],
+    ['a blank discovery method', { discoverymethod: '' }, 'Method'],
+  ])('treats %s as unknown rather than an empty row', (_case, planet, label) => {
+    expect(valueOf(label, planet)).toBeNull();
+  });
+
+  // A corrupt row must not reach the page as "NaN K".
+  it.each([
+    ['NaN', NaN],
+    ['Infinity', Infinity],
+  ])('reports %s as unknown rather than formatting it', (_case, corrupt) => {
+    expect(valueOf('Equilibrium temperature', { pl_eqt: corrupt })).toBeNull();
+    expect(valueOf('Distance from Earth', { sy_dist: corrupt })).toBeNull();
+    expect(valueOf('Year', { disc_year: corrupt })).toBeNull();
+  });
+
+  it('leaves the spectral class unknown for a star too cool to classify', () => {
+    expect(valueOf('Spectral class', { st_teff: 1200 })).toBeNull();
+  });
+
+  it('keeps a measured zero rather than reading it as missing', () => {
+    expect(valueOf('Starlight received', { pl_insol: 0 })).toBe('0 × Earth');
+  });
+});
+
+describe('planetHighlights', () => {
+  function highlightsOf(planet: Partial<Planet>): string[] {
+    return planetHighlights({ ...UNMEASURED, ...planet });
+  }
+
+  it('leads with size, orbit and distance, in that order', () => {
+    expect(highlightsOf({ pl_rade: 1.63, pl_orbper: 384.843, sy_dist: 551.7 })).toEqual([
+      "1.63\u00d7 Earth's radius",
+      '384.8-day orbit',
+      '1,799 light-years away',
+    ]);
+  });
+
+  // A preview that rounded differently would contradict the stat table on the page it links to.
+  it.each([
+    ['Radius', { pl_rade: 1.63 }, '1.63 \u00d7 Earth', "1.63\u00d7 Earth's radius"],
+    ['Orbital period', { pl_orbper: 384.843 }, '384.8 days', '384.8-day orbit'],
+  ])('rounds %s to the figure the section already shows', (label, planet, sectionValue, phrase) => {
+    expect(valueOf(label, planet)).toBe(sectionValue);
+    expect(highlightsOf(planet)).toEqual([phrase]);
+  });
+
+  it('converts distance to the same light-years the System section shows', () => {
+    expect(valueOf('Distance from Earth', { sy_dist: 551.7 })).toBe(
+      '1,799 light-years (551.7 parsecs)'
+    );
+    expect(highlightsOf({ sy_dist: 551.7 })).toEqual(['1,799 light-years away']);
+  });
+
+  it('drops the fields the archive never measured instead of naming them', () => {
+    expect(highlightsOf({ pl_orbper: 384.843 })).toEqual(['384.8-day orbit']);
+  });
+
+  it('returns nothing at all for a planet the archive only names', () => {
+    expect(highlightsOf({})).toEqual([]);
+  });
+
+  it.each([
+    ['NaN', NaN],
+    ['Infinity', Infinity],
+  ])('skips a %s radius rather than quoting it', (_case, corrupt) => {
+    expect(highlightsOf({ pl_rade: corrupt })).toEqual([]);
+  });
+});
+
+const QUICK_LOOK: Planet = {
+  ...UNMEASURED,
+  sy_dist: 551.7,
+  pl_rade: 1.63,
+  pl_bmasse: 5,
+  pl_eqt: 265,
+  disc_year: 2015,
+  discoverymethod: 'Transit',
+};
+
+function keyStatOf(label: string, planet: Planet = QUICK_LOOK): string | null {
+  const stat = planetKeyStats(planet).find((candidate) => candidate.label === label);
+  if (!stat) throw new Error(`No quick-look stat labelled "${label}"`);
+  return stat.value;
+}
+
+describe('planetKeyStats', () => {
+  it('carries the six fields the quick look has room for, in reading order', () => {
+    expect(planetKeyStats(QUICK_LOOK).map((stat) => stat.label)).toEqual([
+      'Distance',
+      'Radius',
+      'Mass',
+      'Temperature',
+      'Discovered',
+      'Detection Method',
+    ]);
+  });
+
+  // The quick look links straight to the page, so one field must never show two numbers.
+  it.each([
+    ['Radius', 'Radius'],
+    ['Mass', 'Mass'],
+    ['Temperature', 'Equilibrium temperature'],
+    ['Discovered', 'Year'],
+    ['Detection Method', 'Method'],
+  ])('renders %s exactly as the page section renders it', (quickLabel, sectionLabel) => {
+    expect(keyStatOf(quickLabel)).toBe(valueOf(sectionLabel, QUICK_LOOK));
+  });
+
+  it('quotes the same parsec figure the page prints beside light-years', () => {
+    expect(valueOf('Distance from Earth', QUICK_LOOK)).toContain(keyStatOf('Distance'));
+  });
+
+  it('reports every field of a name-only planet as unknown', () => {
+    expect(planetKeyStats(UNMEASURED).every((stat) => stat.value === null)).toBe(true);
+  });
+
+  it('keeps a measured zero, which a falsy check would have called unknown', () => {
+    expect(keyStatOf('Temperature', { ...QUICK_LOOK, pl_eqt: 0 })).toBe('0 K');
+  });
+
+  it.each([
+    ['NaN', NaN],
+    ['Infinity', Infinity],
+  ])('reports a %s distance as unknown rather than quoting it', (_case, corrupt) => {
+    expect(keyStatOf('Distance', { ...QUICK_LOOK, sy_dist: corrupt })).toBeNull();
+  });
+});
diff --git a/exoplanethub.com/lib/planetStats.ts b/exoplanethub.com/lib/planetStats.ts
new file mode 100644
index 0000000..7c1d9c7
--- /dev/null
+++ b/exoplanethub.com/lib/planetStats.ts
@@ -0,0 +1,133 @@
+import type { Planet, PlanetSummary } from '@/lib/mockPlanets';
+import { starBandOf } from '@/lib/starBands';
+
+export interface PlanetStat {
+  label: string;
+  value: string | null;
+}
+
+export interface PlanetStatSection {
+  id: string;
+  title: string;
+  stats: PlanetStat[];
+}
+
+const LIGHT_YEARS_PER_PARSEC = 3.26156;
+
+// Pinned locale so a value reads identically wherever the page is rendered or cached.
+const NUMBER = new Intl.NumberFormat('en-US', { maximumSignificantDigits: 4 });
+
+// The stored item is only a claim that a field is a number; a corrupt row must read as
+// unknown rather than render NaN.
+function isMeasured(value: number | null | undefined): value is number {
+  return typeof value === 'number' && Number.isFinite(value);
+}
+
+export function measurement(value: number | null, unit: string): string | null {
+  return isMeasured(value) ? `${NUMBER.format(value)} ${unit}` : null;
+}
+
+// Years and counts are exact, so grouping separators would misread them as quantities.
+function exact(value: number | null): string | null {
+  return isMeasured(value) ? String(value) : null;
+}
+
+function text(value: string | null): string | null {
+  return value !== null && value.trim() !== '' ? value : null;
+}
+
+function lightYearsFrom(parsecs: number): number {
+  return parsecs * LIGHT_YEARS_PER_PARSEC;
+}
+
+function distanceFromEarth(parsecs: number | null): string | null {
+  if (!isMeasured(parsecs)) return null;
+
+  const lightYears = NUMBER.format(lightYearsFrom(parsecs));
+  return `${lightYears} light-years (${NUMBER.format(parsecs)} parsecs)`;
+}
+
+function spectralClass(starTemperature: number | null): string | null {
+  return starBandOf(starTemperature)?.label ?? null;
+}
+
+function highlight(value: number | null, phrase: (amount: string) => string): string | null {
+  return isMeasured(value) ? phrase(NUMBER.format(value)) : null;
+}
+
+export function lightYearsAway(parsecs: number | null): string | null {
+  return isMeasured(parsecs) ? `${NUMBER.format(lightYearsFrom(parsecs))} light-years away` : null;
+}
+
+export function discoveredIn(year: number | null): string | null {
+  return isMeasured(year) ? `Discovered in ${year}` : null;
+}
+
+// Same numbers as the sections below, so a link preview can never quote a figure the page contradicts.
+export function planetHighlights(planet: Planet): string[] {
+  return [
+    highlight(planet.pl_rade, (radius) => `${radius}× Earth's radius`),
+    highlight(planet.pl_orbper, (days) => `${days}-day orbit`),
+    lightYearsAway(planet.sy_dist),
+  ].filter((phrase): phrase is string => phrase !== null);
+}
+
+// Shares the section formatters so the quick look cannot round a field differently from the page it links to.
+export function planetKeyStats(planet: PlanetSummary): PlanetStat[] {
+  return [
+    { label: 'Distance', value: measurement(planet.sy_dist, 'parsecs') },
+    { label: 'Radius', value: measurement(planet.pl_rade, '× Earth') },
+    { label: 'Mass', value: measurement(planet.pl_bmasse, '× Earth') },
+    { label: 'Temperature', value: measurement(planet.pl_eqt, 'K') },
+    { label: 'Discovered', value: exact(planet.disc_year) },
+    { label: 'Detection Method', value: text(planet.discoverymethod) },
+  ];
+}
+
+export function planetStatSections(planet: Planet): PlanetStatSection[] {
+  return [
+    {
+      id: 'planet',
+      title: 'Planet',
+      stats: [
+        { label: 'Radius', value: measurement(planet.pl_rade, '× Earth') },
+        { label: 'Mass', value: measurement(planet.pl_bmasse, '× Earth') },
+        { label: 'Density', value: measurement(planet.pl_dens, 'g/cm³') },
+        { label: 'Equilibrium temperature', value: measurement(planet.pl_eqt, 'K') },
+        { label: 'Starlight received', value: measurement(planet.pl_insol, '× Earth') },
+        { label: 'Orbital period', value: measurement(planet.pl_orbper, 'days') },
+        { label: 'Average distance from its star', value: measurement(planet.pl_orbsmax, 'AU') },
+      ],
+    },
+    {
+      id: 'star',
+      title: 'Star',
+      stats: [
+        { label: 'Host star', value: text(planet.hostname) },
+        { label: 'Spectral class', value: spectralClass(planet.st_teff) },
+        { label: 'Surface temperature', value: measurement(planet.st_teff, 'K') },
+        { label: 'Radius', value: measurement(planet.st_rad, '× Sun') },
+        { label: 'Mass', value: measurement(planet.st_mass, '× Sun') },
+        { label: 'Age', value: measurement(planet.st_age, 'billion years') },
+      ],
+    },
+    {
+      id: 'system',
+      title: 'System',
+      stats: [
+        { label: 'Distance from Earth', value: distanceFromEarth(planet.sy_dist) },
+        { label: 'Stars in system', value: exact(planet.sy_snum) },
+        { label: 'Known planets', value: exact(planet.sy_pnum) },
+      ],
+    },
+    {
+      id: 'discovery',
+      title: 'Discovery',
+      stats: [
+        { label: 'Year', value: exact(planet.disc_year) },
+        { label: 'Method', value: text(planet.discoverymethod) },
+        { label: 'Facility', value: text(planet.disc_facility) },
+      ],
+    },
+  ];
+}
diff --git a/exoplanethub.com/lib/planetUrl.test.ts b/exoplanethub.com/lib/planetUrl.test.ts
new file mode 100644
index 0000000..2e8fc52
--- /dev/null
+++ b/exoplanethub.com/lib/planetUrl.test.ts
@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+import { planetNameFromParam, planetUrl } from '@/lib/planetUrl';
+
+// Archive names carry every character class the URL layer has to survive.
+const ARCHIVE_NAMES = [
+  'Kepler-452 b',
+  'HD 189733 b',
+  'PSR B1257+12 c',
+  'Kepler-16 (AB) b',
+  '1RXS J160929.1-210524 b',
+  '2MASS J04414489+2301513 b',
+];
+
+function routeSegmentOf(url: string) {
+  return url.slice('/planet/'.length);
+}
+
+describe('planetUrl', () => {
+  it('addresses the planet page by its exact encoded name', () => {
+    expect(planetUrl('Kepler-452 b')).toBe('/planet/Kepler-452%20b');
+  });
+
+  it('escapes the plus sign that a designation may carry', () => {
+    expect(planetUrl('PSR B1257+12 c')).toBe('/planet/PSR%20B1257%2B12%20c');
+  });
+
+  it('escapes a slash rather than splitting the name across path segments', () => {
+    expect(routeSegmentOf(planetUrl('A/B c'))).not.toContain('/');
+  });
+});
+
+describe('planetUrl and planetNameFromParam round trip', () => {
+  it.each(ARCHIVE_NAMES)('recovers %s exactly', (name) => {
+    expect(planetNameFromParam(routeSegmentOf(planetUrl(name)))).toBe(name);
+  });
+
+  it.each(ARCHIVE_NAMES)('recovers %s from an already-decoded segment', (name) => {
+    expect(planetNameFromParam(name)).toBe(name);
+  });
+});
+
+describe('planetNameFromParam rejections', () => {
+  it.each([
+    ['%ZZ', 'a malformed escape sequence'],
+    ['%E0%A4%A', 'a truncated escape sequence'],
+    ['', 'an empty segment'],
+    ['%20%20', 'a whitespace-only segment'],
+  ])('returns null for %s — %s', (param) => {
+    expect(planetNameFromParam(param)).toBeNull();
+  });
+
+  // The segment reaches the not-found page as displayed text, so an essay is not a name.
+  it('rejects a segment longer than any designation, keeping prose out of the lookup', () => {
+    expect(planetNameFromParam('K'.repeat(80))).toHaveLength(80);
+    expect(planetNameFromParam('K'.repeat(81))).toBeNull();
+    expect(planetNameFromParam(encodeURIComponent('Your account is locked. '.repeat(10)))).toBeNull();
+  });
+});
diff --git a/exoplanethub.com/lib/planetUrl.ts b/exoplanethub.com/lib/planetUrl.ts
new file mode 100644
index 0000000..4680d95
--- /dev/null
+++ b/exoplanethub.com/lib/planetUrl.ts
@@ -0,0 +1,24 @@
+const PLANET_PATH = '/planet';
+
+// No archive designation comes close to this; a longer segment is someone's prose, not a name.
+const MAX_NAME_LENGTH = 80;
+
+export function planetUrl(planetName: string): string {
+  return `${PLANET_PATH}/${encodeURIComponent(planetName)}`;
+}
+
+// Tolerates the segment arriving encoded or already decoded: no archive name contains a
+// literal '%', so decoding twice is a no-op rather than a corruption.
+export function planetNameFromParam(param: string): string | null {
+  let planetName: string;
+
+  try {
+    planetName = decodeURIComponent(param);
+  } catch {
+    return null;
+  }
+
+  if (planetName.trim() === '' || planetName.length > MAX_NAME_LENGTH) return null;
+
+  return planetName;
+}
diff --git a/exoplanethub.com/lib/shareImage.ts b/exoplanethub.com/lib/shareImage.ts
new file mode 100644
index 0000000..2412f56
--- /dev/null
+++ b/exoplanethub.com/lib/shareImage.ts
@@ -0,0 +1,11 @@
+import { planetUrl } from '@/lib/planetUrl';
+
+export const SHARE_IMAGE_SIZE = { width: 1200, height: 630 } as const;
+
+export function shareImageUrl(planetName: string): string {
+  return `${planetUrl(planetName)}/opengraph-image`;
+}
+
+export function shareImageAlt(planetName: string): string {
+  return `${planetName} — ExoplanetHub planet card`;
+}
diff --git a/exoplanethub.com/lib/site.test.ts b/exoplanethub.com/lib/site.test.ts
new file mode 100644
index 0000000..9016e1c
--- /dev/null
+++ b/exoplanethub.com/lib/site.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { SITE_ORIGIN } from '@/lib/site';
+import { planetUrl } from '@/lib/planetUrl';
+
+describe('SITE_ORIGIN', () => {
+  it('names the host the site is served from, so canonicals do not redirect', () => {
+    const { protocol, host } = new URL(SITE_ORIGIN);
+
+    expect(protocol).toBe('https:');
+    expect(host).toBe('www.exoplanethub.com');
+  });
+
+  it('joins with a rooted path without doubling the slash', () => {
+    expect(`${SITE_ORIGIN}${planetUrl('Kepler-452 b')}`).toBe(
+      'https://www.exoplanethub.com/planet/Kepler-452%20b',
+    );
+  });
+});
diff --git a/exoplanethub.com/lib/site.ts b/exoplanethub.com/lib/site.ts
new file mode 100644
index 0000000..25448cb
--- /dev/null
+++ b/exoplanethub.com/lib/site.ts
@@ -0,0 +1,2 @@
+// www, not the apex: the apex 307s, and a canonical that redirects never self-references its page.
+export const SITE_ORIGIN = 'https://www.exoplanethub.com';
diff --git a/exoplanethub.com/lib/starBands.test.ts b/exoplanethub.com/lib/starBands.test.ts
new file mode 100644
index 0000000..f60a565
--- /dev/null
+++ b/exoplanethub.com/lib/starBands.test.ts
@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest';
+import { STAR_BANDS, STAR_CLASSES, isStarClass, starBandOf, starClassOf } from '@/lib/starBands';
+
+describe('starClassOf band edges', () => {
+  // Every edge from the spec's table. Half-open with the lower bound inclusive, so the edge
+  // itself belongs to the hotter class and anything under it falls to the next one down.
+  it.each([
+    [33000, 'O', 'B'],
+    [10000, 'B', 'A'],
+    [7300, 'A', 'F'],
+    [6000, 'F', 'G'],
+    [5300, 'G', 'K'],
+    [3900, 'K', 'M'],
+  ])('puts %i K in %s and just under it in %s', (edge, hotter, cooler) => {
+    expect(starClassOf(edge)).toBe(hotter);
+    expect(starClassOf(edge - 1)).toBe(cooler);
+  });
+
+  it('classifies the coolest edge as M but leaves anything under it unclassified', () => {
+    expect(starClassOf(2300)).toBe('M');
+    expect(starClassOf(2299)).toBeNull();
+  });
+
+  it.each([
+    ['a brown dwarf host', 1500],
+    ['absolute zero', 0],
+  ])('leaves %s unclassified rather than extending M downward', (_label, teff) => {
+    expect(starClassOf(teff)).toBeNull();
+  });
+
+  it('leaves a star the archive never measured unclassified', () => {
+    expect(starClassOf(null)).toBeNull();
+  });
+
+  it.each([NaN, Infinity, -Infinity])('leaves the non-finite value %p unclassified', (teff) => {
+    expect(starClassOf(teff)).toBeNull();
+  });
+
+  it('classifies a star hotter than any band edge as O', () => {
+    expect(starClassOf(60000)).toBe('O');
+  });
+
+  it('classifies the Sun as G, the class its label claims', () => {
+    expect(starClassOf(5772)).toBe('G');
+  });
+});
+
+describe('starBandOf', () => {
+  it('hands back the whole band so a caller needs no second lookup to label it', () => {
+    expect(starBandOf(5772)).toEqual({ starClass: 'G', minTeff: 5300, label: 'G — sun-like' });
+  });
+
+  it.each([null, NaN, 2299])('leaves %p without a band', (teff) => {
+    expect(starBandOf(teff)).toBeNull();
+  });
+
+  it('agrees with starClassOf across every band', () => {
+    for (const band of STAR_BANDS) expect(starBandOf(band.minTeff)?.starClass).toBe(starClassOf(band.minTeff));
+  });
+});
+
+describe('star band table', () => {
+  it('runs hottest to coolest, the order the lookup and the URL both rely on', () => {
+    expect(STAR_CLASSES).toEqual(['O', 'B', 'A', 'F', 'G', 'K', 'M']);
+    expect(STAR_BANDS.map((band) => band.minTeff)).toEqual([33000, 10000, 7300, 6000, 5300, 3900, 2300]);
+  });
+
+  it('labels every class in plain language, not just the letter', () => {
+    expect(STAR_BANDS.map((band) => band.label)).toEqual([
+      'O — blue',
+      'B — blue-white',
+      'A — white',
+      'F — yellow-white',
+      'G — sun-like',
+      'K — orange dwarf',
+      'M — red dwarf',
+    ]);
+  });
+
+  it('recognises exactly the seven classes it bands', () => {
+    for (const starClass of STAR_CLASSES) expect(isStarClass(starClass)).toBe(true);
+    expect(isStarClass('L')).toBe(false);
+    expect(isStarClass('m')).toBe(false);
+    expect(isStarClass('')).toBe(false);
+  });
+});
diff --git a/exoplanethub.com/lib/starBands.ts b/exoplanethub.com/lib/starBands.ts
new file mode 100644
index 0000000..c908034
--- /dev/null
+++ b/exoplanethub.com/lib/starBands.ts
@@ -0,0 +1,39 @@
+// Class edges from the Pecaut & Mamajek (2013) dwarf calibration, hottest first so a lookup is
+// the first band a temperature reaches. Half-open, lower bound inclusive, in kelvin.
+const BANDS = [
+  { starClass: 'O', minTeff: 33000, label: 'O — blue' },
+  { starClass: 'B', minTeff: 10000, label: 'B — blue-white' },
+  { starClass: 'A', minTeff: 7300, label: 'A — white' },
+  { starClass: 'F', minTeff: 6000, label: 'F — yellow-white' },
+  { starClass: 'G', minTeff: 5300, label: 'G — sun-like' },
+  { starClass: 'K', minTeff: 3900, label: 'K — orange dwarf' },
+  { starClass: 'M', minTeff: 2300, label: 'M — red dwarf' },
+] as const;
+
+export type StarClass = (typeof BANDS)[number]['starClass'];
+
+export interface StarBand {
+  starClass: StarClass;
+  minTeff: number;
+  label: string;
+}
+
+export const STAR_BANDS: readonly StarBand[] = BANDS;
+
+export const STAR_CLASSES: readonly StarClass[] = BANDS.map((band) => band.starClass);
+
+export function isStarClass(value: string): value is StarClass {
+  return STAR_CLASSES.includes(value as StarClass);
+}
+
+// Cooler than M, or never measured, is unclassified rather than M: calling a brown dwarf a red
+// dwarf is exactly the quiet wrongness a curious visitor would catch.
+export function starBandOf(teff: number | null): StarBand | null {
+  if (teff === null || !Number.isFinite(teff)) return null;
+
+  return BANDS.find((band) => teff >= band.minTeff) ?? null;
+}
+
+export function starClassOf(teff: number | null): StarClass | null {
+  return starBandOf(teff)?.starClass ?? null;
+}
diff --git a/exoplanethub.com/lib/theme.test.ts b/exoplanethub.com/lib/theme.test.ts
index f93c032..90c32b6 100644
--- a/exoplanethub.com/lib/theme.test.ts
+++ b/exoplanethub.com/lib/theme.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import themeConfig from '@/theme/theme.json';
-import { generateCSSVariables, getTheme, type ThemeName } from '@/lib/theme';
+import { generateCSSVariables, getTheme, SITE_THEME, type ThemeName } from '@/lib/theme';
 
 const THEME_NAMES: ThemeName[] = ['nautilus', 'cosmicDawn', 'starlight'];
 const BAND_NUMBERS = [1, 2, 3, 4] as const;
@@ -23,8 +23,8 @@ function contrastRatio(a: string, b: string): number {
 
 describe('getTheme', () => {
   it('defaults to the theme theme.json declares as default', () => {
-    expect(themeConfig.defaultTheme).toBe('nautilus');
-    expect(getTheme()).toBe(getTheme('nautilus'));
+    expect(SITE_THEME).toBe(themeConfig.defaultTheme);
+    expect(getTheme()).toBe(getTheme(SITE_THEME));
   });
 
   it('exposes every theme named in the ThemeName union', () => {
diff --git a/exoplanethub.com/lib/theme.ts b/exoplanethub.com/lib/theme.ts
index 2a1d335..cbf5fbe 100644
--- a/exoplanethub.com/lib/theme.ts
+++ b/exoplanethub.com/lib/theme.ts
@@ -2,7 +2,10 @@ import themeConfig from '@/theme/theme.json';
 
 export type ThemeName = 'nautilus' | 'cosmicDawn' | 'starlight';
 
-export function getTheme(themeName: ThemeName = 'nautilus') {
+// The OG card is rendered outside the DOM, so it resolves these colours itself and must not drift.
+export const SITE_THEME: ThemeName = 'nautilus';
+
+export function getTheme(themeName: ThemeName = SITE_THEME) {
   return themeConfig.themes[themeName];
 }
 
diff --git a/exoplanethub.com/lib/useFilterParams.test.tsx b/exoplanethub.com/lib/useFilterParams.test.tsx
new file mode 100644
index 0000000..87d7d64
--- /dev/null
+++ b/exoplanethub.com/lib/useFilterParams.test.tsx
@@ -0,0 +1,260 @@
+import { useState } from 'react';
+import { fireEvent, render, screen } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { DEFAULT_FILTERS, type FilterState } from '@/lib/planetFilters';
+import { useFilterParams } from '@/lib/useFilterParams';
+
+const replace = vi.fn();
+let query = '';
+
+// Stable, as the real useRouter is: a fresh object each render hides missing effect deps.
+const router = { replace };
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => router,
+  usePathname: () => '/explore',
+  useSearchParams: () => new URLSearchParams(query),
+}));
+
+const seen: FilterState[] = [];
+
+function Harness() {
+  const [filters, update] = useFilterParams();
+  const [, bump] = useState(0);
+  seen.push(filters);
+
+  return (
+    <>
+      <button onClick={() => bump((n) => n + 1)}>rerender</button>
+      <output data-testid="state">{`${filters.q}|${filters.methods.join(',') || '-'}|${filters.sortKey}.${filters.sortOrder}`}</output>
+      <button onClick={() => update({ ...filters, q: 'wolf' })}>search wolf</button>
+      <button onClick={() => update({ ...filters, q: 'ross' })}>search ross</button>
+      <button onClick={() => update({ ...filters, q: 'wolf 3' })}>search wolf 3</button>
+      <button onClick={() => update({ ...filters, sortKey: 'pl_rade', sortOrder: 'asc' })}>sort radius</button>
+      <button onClick={() => update(DEFAULT_FILTERS)}>reset</button>
+    </>
+  );
+}
+
+function mountAt(initialQuery: string) {
+  query = initialQuery;
+  const { rerender } = render(<Harness />);
+
+  return {
+    navigateTo(next: string) {
+      query = next;
+      rerender(<Harness />);
+    },
+  };
+}
+
+function state() {
+  return screen.getByTestId('state').textContent;
+}
+
+function press(name: string) {
+  fireEvent.click(screen.getByRole('button', { name }));
+}
+
+function flushDebounce() {
+  vi.advanceTimersByTime(1000);
+}
+
+// Long enough for a queued write to dispatch, but not for the navigation it starts to commit.
+function dispatchWrite() {
+  vi.advanceTimersByTime(300);
+}
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  replace.mockClear();
+  seen.length = 0;
+  query = '';
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe('useFilterParams', () => {
+  it('starts from the filters already in the URL', () => {
+    mountAt('q=kepler&sort=pl_rade.asc');
+
+    expect(state()).toBe('kepler|-|pl_rade.asc');
+  });
+
+  it('reflects a change immediately, so typing is never held up by the URL write', () => {
+    mountAt('');
+
+    press('search wolf');
+
+    expect(state()).toBe('wolf|-|disc_year.desc');
+    expect(replace).not.toHaveBeenCalled();
+  });
+
+  it('writes the URL once the changes stop', () => {
+    mountAt('');
+
+    press('search wolf');
+    flushDebounce();
+
+    expect(replace).toHaveBeenCalledExactlyOnceWith('/explore?q=wolf', { scroll: false });
+  });
+
+  it('holds the write open while changes keep arriving', () => {
+    mountAt('');
+
+    press('search wolf');
+    vi.advanceTimersByTime(200);
+    press('search ross');
+    vi.advanceTimersByTime(200);
+    expect(replace).not.toHaveBeenCalled();
+
+    flushDebounce();
+
+    expect(replace).toHaveBeenCalledExactlyOnceWith('/explore?q=ross', { scroll: false });
+  });
+
+  it('hands back the same filter object until the filters actually change, so callers can memoise on it', () => {
+    mountAt('q=kepler');
+    const first = seen.at(-1);
+
+    press('rerender');
+
+    expect(seen.at(-1)).toBe(first);
+  });
+
+  it('collapses a burst of changes into a single write, so Back does not step through keystrokes', () => {
+    mountAt('');
+
+    press('search wolf');
+    press('search ross');
+    press('sort radius');
+    flushDebounce();
+
+    expect(replace).toHaveBeenCalledExactlyOnceWith('/explore?q=ross&sort=pl_rade.asc', { scroll: false });
+  });
+
+  it('drops the query string entirely when the filters return to their defaults', () => {
+    mountAt('q=kepler');
+
+    press('reset');
+    flushDebounce();
+
+    expect(replace).toHaveBeenCalledExactlyOnceWith('/explore', { scroll: false });
+  });
+
+  it('adopts filters the URL gained elsewhere, which is what Back and Forward do', () => {
+    const { navigateTo } = mountAt('q=kepler');
+
+    navigateTo('sort=esi.desc');
+
+    expect(state()).toBe('|-|esi.desc');
+  });
+
+  it('abandons a pending write when the URL moves underneath it', () => {
+    const { navigateTo } = mountAt('');
+
+    press('search wolf');
+    navigateTo('q=kepler');
+    flushDebounce();
+
+    expect(state()).toBe('kepler|-|disc_year.desc');
+    expect(replace).not.toHaveBeenCalled();
+  });
+
+  it('does not fight the URL it just wrote', () => {
+    const { navigateTo } = mountAt('');
+
+    press('search wolf');
+    flushDebounce();
+    navigateTo('q=wolf');
+
+    expect(state()).toBe('wolf|-|disc_year.desc');
+    expect(replace).toHaveBeenCalledOnce();
+  });
+
+  // A statically prerendered /explore renders with no params and only sees them after hydration.
+  it('picks up params that arrive after the first render without writing them back', () => {
+    const { navigateTo } = mountAt('');
+
+    navigateTo('q=kepler&sort=esi.asc');
+    flushDebounce();
+
+    expect(state()).toBe('kepler|-|esi.asc');
+    expect(replace).not.toHaveBeenCalled();
+  });
+
+  // router.replace commits asynchronously, so every keystroke in that window used to be dropped:
+  // the edit died with the arriving URL and its queued write was cancelled along with it.
+  it('keeps typing that arrives while a write of its own is still in flight', () => {
+    const { navigateTo } = mountAt('');
+
+    press('search wolf');
+    dispatchWrite();
+    press('search wolf 3');
+    navigateTo('q=wolf');
+
+    expect(state()).toBe('wolf 3|-|disc_year.desc');
+
+    flushDebounce();
+
+    expect(replace).toHaveBeenLastCalledWith('/explore?q=wolf+3', { scroll: false });
+  });
+
+  // Typing fast enough leaves more than one write outstanding; each must be recognised as ours.
+  it('keeps the edit while several of its own writes land in turn', () => {
+    const { navigateTo } = mountAt('');
+
+    press('search wolf');
+    dispatchWrite();
+    press('search ross');
+    dispatchWrite();
+    press('search wolf 3');
+
+    navigateTo('q=wolf');
+    expect(state()).toBe('wolf 3|-|disc_year.desc');
+    navigateTo('q=ross');
+    expect(state()).toBe('wolf 3|-|disc_year.desc');
+
+    flushDebounce();
+
+    expect(replace).toHaveBeenLastCalledWith('/explore?q=wolf+3', { scroll: false });
+  });
+
+  // A write can be dispatched and then overtaken, leaving a URL this hook asked for but never
+  // saw. Arriving there later is someone else's navigation and must not keep the edit alive.
+  it('does not claim a Back as its own just because it once asked for that URL', () => {
+    const { navigateTo } = mountAt('');
+
+    press('search wolf');
+    dispatchWrite();
+    navigateTo('sort=esi.desc');
+    press('search wolf 3');
+    navigateTo('q=wolf');
+
+    expect(state()).toBe('wolf|-|disc_year.desc');
+  });
+
+  it('still yields to a Back that arrives while typing continues', () => {
+    const { navigateTo } = mountAt('');
+
+    press('search wolf');
+    dispatchWrite();
+    press('search wolf 3');
+    navigateTo('sort=esi.desc');
+
+    expect(state()).toBe('|-|esi.desc');
+
+    flushDebounce();
+
+    expect(replace).toHaveBeenCalledExactlyOnceWith('/explore?q=wolf', { scroll: false });
+  });
+
+  it('ignores params it does not own, leaving the filters at their defaults', () => {
+    mountAt('utm_source=newsletter');
+
+    expect(state()).toBe('|-|disc_year.desc');
+    expect(replace).not.toHaveBeenCalled();
+  });
+});
diff --git a/exoplanethub.com/lib/useFilterParams.ts b/exoplanethub.com/lib/useFilterParams.ts
new file mode 100644
index 0000000..be4e12f
--- /dev/null
+++ b/exoplanethub.com/lib/useFilterParams.ts
@@ -0,0 +1,50 @@
+'use client';
+import { useEffect, useMemo, useState } from 'react';
+import { usePathname, useRouter, useSearchParams } from 'next/navigation';
+import { FilterState, parseFilters, serializeFilters } from '@/lib/planetFilters';
+
+const WRITE_DELAY_MS = 300;
+
+export function useFilterParams(): [FilterState, (next: FilterState) => void] {
+  const router = useRouter();
+  const pathname = usePathname();
+  const query = useSearchParams().toString();
+
+  const [unwritten, setUnwritten] = useState<FilterState | null>(null);
+  const [lastQuery, setLastQuery] = useState(query);
+  const [dispatched, setDispatched] = useState<string[]>([]);
+
+  let edit = unwritten;
+  if (query !== lastQuery) {
+    setLastQuery(query);
+    const landed = dispatched.indexOf(query);
+
+    // Only a query this hook never dispatched is someone else steering, and only that may
+    // drop a half-typed edit: Back/Forward, or params arriving after hydration.
+    if (landed === -1) {
+      setDispatched([]);
+      setUnwritten(null);
+      edit = null;
+    } else {
+      setDispatched(dispatched.slice(landed + 1));
+    }
+  }
+
+  // Memoised so the filter object stays referentially stable, keeping callers' memos alive.
+  const fromUrl = useMemo(() => parseFilters(new URLSearchParams(query)), [query]);
+
+  // Re-running on every edit is the debounce: the cleanup drops the write the last edit queued.
+  useEffect(() => {
+    if (unwritten === null) return;
+
+    const serialized = serializeFilters(unwritten);
+    const timer = setTimeout(() => {
+      setDispatched((queued) => [...queued, serialized]);
+      router.replace(serialized ? `${pathname}?${serialized}` : pathname, { scroll: false });
+    }, WRITE_DELAY_MS);
+
+    return () => clearTimeout(timer);
+  }, [unwritten, pathname, router]);
+
+  return [edit ?? fromUrl, setUnwritten];
+}
diff --git a/exoplanethub.com/lib/usePagination.test.tsx b/exoplanethub.com/lib/usePagination.test.tsx
new file mode 100644
index 0000000..2798d39
--- /dev/null
+++ b/exoplanethub.com/lib/usePagination.test.tsx
@@ -0,0 +1,144 @@
+import { useState } from 'react';
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import { usePagination } from '@/lib/usePagination';
+
+const PER_PAGE = 10;
+
+function Harness({ initialCount }: { initialCount: number }) {
+  const [count, setCount] = useState(initialCount);
+  const { page, totalPages, goTo, pageItems } = usePagination(count, PER_PAGE);
+  const items = Array.from({ length: count }, (_, index) => index);
+
+  return (
+    <>
+      <output data-testid="state">{`${page} of ${totalPages}`}</output>
+      <output data-testid="items">{pageItems(items).join(',')}</output>
+      <button onClick={() => goTo(page + 1)}>next</button>
+      <button onClick={() => goTo(page - 1)}>previous</button>
+      <button onClick={() => goTo(99)}>jump past the end</button>
+      <button onClick={() => setCount(15)}>narrow</button>
+    </>
+  );
+}
+
+function mount(initialCount: number) {
+  render(<Harness initialCount={initialCount} />);
+}
+
+function state() {
+  return screen.getByTestId('state').textContent;
+}
+
+function press(name: string) {
+  fireEvent.click(screen.getByRole('button', { name }));
+}
+
+function items() {
+  return screen.getByTestId('items').textContent;
+}
+
+describe('usePagination', () => {
+  it('starts on the first page', () => {
+    mount(100);
+
+    expect(state()).toBe('1 of 10');
+  });
+
+  it('keeps a single page for an empty set, so there is always a page to show', () => {
+    mount(0);
+
+    expect(state()).toBe('1 of 1');
+  });
+
+  it('counts a partial last page', () => {
+    mount(101);
+
+    expect(state()).toBe('1 of 11');
+  });
+
+  it('moves between pages', () => {
+    mount(100);
+
+    press('next');
+    press('next');
+    expect(state()).toBe('3 of 10');
+
+    press('previous');
+    expect(state()).toBe('2 of 10');
+  });
+
+  it('refuses to leave the last page', () => {
+    mount(100);
+
+    press('jump past the end');
+
+    expect(state()).toBe('10 of 10');
+  });
+
+  it('refuses to go before the first page', () => {
+    mount(100);
+
+    press('previous');
+
+    expect(state()).toBe('1 of 10');
+  });
+
+  // The result set can shrink without anyone paging, so the clamp has to survive that too.
+  it('pulls back to the last page when the set shrinks underneath it', () => {
+    mount(100);
+
+    press('next');
+    press('next');
+    press('narrow');
+
+    expect(state()).toBe('2 of 2');
+  });
+
+  // The bug this hook exists to prevent: a caller stepping back from a page the clamp is hiding.
+  it('steps back from the page the clamp put it on, not the one it asked for', () => {
+    mount(100);
+
+    press('next');
+    press('next');
+    press('narrow');
+    press('previous');
+
+    expect(state()).toBe('1 of 2');
+  });
+
+  it('cuts the slice for the current page', () => {
+    mount(100);
+
+    expect(items()).toBe('0,1,2,3,4,5,6,7,8,9');
+
+    press('next');
+    expect(items()).toBe('10,11,12,13,14,15,16,17,18,19');
+  });
+
+  it('cuts a short final page rather than running past the end', () => {
+    mount(15);
+
+    press('next');
+
+    expect(items()).toBe('10,11,12,13,14');
+  });
+
+  // Slice and page count read the same clamp, so a hidden page can never keep serving its old rows.
+  it('cuts the slice for the clamped page when the set shrinks underneath it', () => {
+    mount(100);
+
+    press('next');
+    press('next');
+    press('narrow');
+
+    expect(state()).toBe('2 of 2');
+    expect(items()).toBe('10,11,12,13,14');
+  });
+
+  it('cuts nothing for an empty set', () => {
+    mount(0);
+
+    expect(items()).toBe('');
+  });
+});
diff --git a/exoplanethub.com/lib/usePagination.ts b/exoplanethub.com/lib/usePagination.ts
new file mode 100644
index 0000000..8734206
--- /dev/null
+++ b/exoplanethub.com/lib/usePagination.ts
@@ -0,0 +1,23 @@
+'use client';
+import { useState } from 'react';
+
+export interface Pagination {
+  page: number;
+  totalPages: number;
+  goTo: (page: number) => void;
+  pageItems: <T>(items: T[]) => T[];
+}
+
+export function usePagination(itemCount: number, itemsPerPage: number): Pagination {
+  const [requested, setRequested] = useState(1);
+  const totalPages = Math.max(1, Math.ceil(itemCount / itemsPerPage));
+  const page = Math.min(Math.max(1, requested), totalPages);
+
+  // Page count, clamp and slice bounds leave this hook already applied, so no caller can disagree with it.
+  return {
+    page,
+    totalPages,
+    goTo: setRequested,
+    pageItems: (items) => items.slice((page - 1) * itemsPerPage, page * itemsPerPage),
+  };
+}
diff --git a/exoplanethub.com/pnpm-lock.yaml b/exoplanethub.com/pnpm-lock.yaml
index d7615ce..06a2207 100644
--- a/exoplanethub.com/pnpm-lock.yaml
+++ b/exoplanethub.com/pnpm-lock.yaml
@@ -10,13 +10,13 @@ importers:
     dependencies:
       '@aws-sdk/client-dynamodb':
         specifier: ^3.1120.0
-        version: 3.1120.0
+        version: 3.1124.0
       '@aws-sdk/lib-dynamodb':
         specifier: ^3.1120.0
-        version: 3.1120.0(@aws-sdk/client-dynamodb@3.1120.0)
+        version: 3.1124.0(@aws-sdk/client-dynamodb@3.1124.0)
       next:
         specifier: 16.3.3
-        version: 16.3.3(@babel/core@7.28.5)(@types/node@25.0.3)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
+        version: 16.3.3(@babel/core@7.29.7)(@types/node@25.9.5)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
       react:
         specifier: 19.2.8
         version: 19.2.8
@@ -29,31 +29,31 @@ importers:
     devDependencies:
       '@testing-library/jest-dom':
         specifier: ^7.0.1
-        version: 7.0.1(@testing-library/dom@10.4.1)(vitest@4.1.11(@types/node@25.0.3)(jsdom@30.0.1)(vite@8.2.2(@types/node@25.0.3)))
+        version: 7.0.1(@testing-library/dom@10.4.1)(vitest@4.1.11(@types/node@25.9.5)(jsdom@30.0.1)(vite@8.2.2(@types/node@25.9.5)))
       '@testing-library/react':
         specifier: ^16.3.3
-        version: 16.3.3(@testing-library/dom@10.4.1)(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
+        version: 16.3.3(@testing-library/dom@10.4.1)(@types/react-dom@19.2.5(@types/react@19.2.18))(@types/react@19.2.18)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
       '@testing-library/user-event':
         specifier: ^14.6.6
-        version: 14.6.6(@testing-library/dom@10.4.1)
+        version: 14.6.7(@testing-library/dom@10.4.1)
       '@types/node':
         specifier: ^25.0.3
-        version: 25.0.3
+        version: 25.9.5
       '@types/react':
         specifier: ^19.2.7
-        version: 19.2.7
+        version: 19.2.18
       '@types/react-dom':
         specifier: ^19.2.3
-        version: 19.2.3(@types/react@19.2.7)
+        version: 19.2.5(@types/react@19.2.18)
       '@vitejs/plugin-react':
         specifier: ^6.1.0
-        version: 6.1.0(vite@8.2.2(@types/node@25.0.3))
+        version: 6.1.1(vite@8.2.2(@types/node@25.9.5))
       eslint:
         specifier: ^9.39.2
-        version: 9.39.2
+        version: 9.39.5
       eslint-config-next:
         specifier: 16.3.3
-        version: 16.3.3(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2)(typescript@5.9.3)
+        version: 16.3.3(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5)(typescript@5.9.3)
       jsdom:
         specifier: ^30.0.1
         version: 30.0.1
@@ -62,7 +62,7 @@ importers:
         version: 5.9.3
       vitest:
         specifier: ^4.1.11
-        version: 4.1.11(@types/node@25.0.3)(jsdom@30.0.1)(vite@8.2.2(@types/node@25.0.3))
+        version: 4.1.11(@types/node@25.9.5)(jsdom@30.0.1)(vite@8.2.2(@types/node@25.9.5))
 
 packages:
 
@@ -77,8 +77,8 @@ packages:
     resolution: {integrity: sha512-93Z1N+BQNXysodoicpOIyNh2drHfz/CTf9nnT0FEx72GJcIiwgydD7tGAr78j41LsYn3hlRn+LdGPuBLn1Bl8Q==}
     engines: {node: ^22.13.0 || >=24.0.0}
 
-  '@aws-sdk/client-dynamodb@3.1120.0':
-    resolution: {integrity: sha512-SjMCaA8fHtskSUlVJMvQCpGM0cRUI4W/Tcxj+5WQJkOidRn0WmFgY51v33eB0S1PLm9kucIeIy/txLNcZ/TCvA==}
+  '@aws-sdk/client-dynamodb@3.1124.0':
+    resolution: {integrity: sha512-SRINKKaG79aG3q/6etfXux9q1KH3TLu9UzCoCuChC34zWpcH5ZEcHbA8/LhDxZEqcEJAp0sRIkkQZeCppqD/DA==}
     engines: {node: '>=20.0.0'}
 
   '@aws-sdk/core@3.977.9':
@@ -101,8 +101,8 @@ packages:
     resolution: {integrity: sha512-Jb59xfEISoN5mmbnA+HYqdtrSX3CgCtJoof+V5D8/TgUI56W63GEEd5Y58WijU3Ou6+WEgaLD1feVzaRXV5IDQ==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/credential-provider-node@3.972.81':
-    resolution: {integrity: sha512-Rml+WitoFvXmv6JZ18U/xGdGDGGvB/mOin0ya0lTnTrdC0Z1lrVxTYh7iNklZBcvcRMrs4DoEf6xy1KWyrLQQw==}
+  '@aws-sdk/credential-provider-node@3.972.82':
+    resolution: {integrity: sha512-znDkEOGXB8W3kG1LJUKP3foBZY/9qLM0eil/DxWXSp37XsdsRLQHE/d/OaCGGVgKpA6znR38h/+INk8do1FjiA==}
     engines: {node: '>=20.0.0'}
 
   '@aws-sdk/credential-provider-process@3.972.70':
@@ -125,11 +125,11 @@ packages:
     resolution: {integrity: sha512-8q1ICxcDjHId3bBryuu/j+1L9y5/3uQnwzLDt5j2ElcjZSoWmFtymdJy7OjLrluSMe0Z4mq5bcH4fxBXvlEHfw==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/lib-dynamodb@3.1120.0':
-    resolution: {integrity: sha512-P43Ix7XS/RYM7k9HsocaTasiVn3tTrc6gwWzUaM+SvHcLFt1pTME6tETykg9K3HTTH/InuG5h3aLb2eDZweXoQ==}
+  '@aws-sdk/lib-dynamodb@3.1124.0':
+    resolution: {integrity: sha512-QVsLB49nTaZjgUtMzldqiQDqEA9hGD74SE+UsUIT/SqhwK2bZ55XqbaiS48IoDp8iLGWbMr1Ot1sDgpBotn3yA==}
     engines: {node: '>=20.0.0'}
     peerDependencies:
-      '@aws-sdk/client-dynamodb': ^3.1120.0
+      '@aws-sdk/client-dynamodb': ^3.1124.0
 
   '@aws-sdk/middleware-endpoint-discovery@3.972.30':
     resolution: {integrity: sha512-0hmD7/NG2NoVOVHvUb6rtY5POQYr+/9gdHvrYhIBA1zmCqKOBd5Gz3dL+iZ15FHOJbs/5kLplGoePc8PHTlzYA==}
@@ -165,58 +165,58 @@ packages:
     resolution: {integrity: sha512-sl4Bm6yiMNYrZKkqqDFWN0UfnWhlS8ivKxrYl+6t0gCLrqr8y3B2IqZZbFRkfaVVp7C/baApyh71P+LeE1A2sQ==}
     engines: {node: '>=18.0.0'}
 
-  '@babel/code-frame@7.27.1':
-    resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==}
+  '@babel/code-frame@7.29.7':
+    resolution: {integrity: sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/compat-data@7.28.5':
-    resolution: {integrity: sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA==}
+  '@babel/compat-data@7.29.7':
+    resolution: {integrity: sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/core@7.28.5':
-    resolution: {integrity: sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==}
+  '@babel/core@7.29.7':
+    resolution: {integrity: sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/generator@7.28.5':
-    resolution: {integrity: sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ==}
+  '@babel/generator@7.29.8':
+    resolution: {integrity: sha512-gZbepsdh3WDtgZKWL+vTPh71LSBrm/Y4/QDZBVCcYfmeTEEuoOYwlSy+G1StfJg+/Zy550u/3TATbm7qDbbMtg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-compilation-targets@7.27.2':
-    resolution: {integrity: sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==}
+  '@babel/helper-compilation-targets@7.29.7':
+    resolution: {integrity: sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-globals@7.28.0':
-    resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==}
+  '@babel/helper-globals@7.29.7':
+    resolution: {integrity: sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-module-imports@7.27.1':
-    resolution: {integrity: sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==}
+  '@babel/helper-module-imports@7.29.7':
+    resolution: {integrity: sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-module-transforms@7.28.3':
-    resolution: {integrity: sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==}
+  '@babel/helper-module-transforms@7.29.7':
+    resolution: {integrity: sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
 
-  '@babel/helper-string-parser@7.27.1':
-    resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
+  '@babel/helper-string-parser@7.29.7':
+    resolution: {integrity: sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-validator-identifier@7.28.5':
-    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
+  '@babel/helper-validator-identifier@7.29.7':
+    resolution: {integrity: sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-validator-option@7.27.1':
-    resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==}
+  '@babel/helper-validator-option@7.29.7':
+    resolution: {integrity: sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helpers@7.28.4':
-    resolution: {integrity: sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==}
+  '@babel/helpers@7.29.7':
+    resolution: {integrity: sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/parser@7.28.5':
-    resolution: {integrity: sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==}
+  '@babel/parser@7.29.8':
+    resolution: {integrity: sha512-E8lTAYNB1KW+FH+VGJuZM1ioAx2E6oVlvQFRrf5P8ZZmsiJXYAD9vTFV7yyEURNzgh1dFqMZuO6tUwcARbqFCA==}
     engines: {node: '>=6.0.0'}
     hasBin: true
 
@@ -224,16 +224,16 @@ packages:
     resolution: {integrity: sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/template@7.27.2':
-    resolution: {integrity: sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==}
+  '@babel/template@7.29.7':
+    resolution: {integrity: sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/traverse@7.28.5':
-    resolution: {integrity: sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==}
+  '@babel/traverse@7.29.8':
+    resolution: {integrity: sha512-I5z7H3bf/41ktsNVLtpN0wAa336HkqIHQ5BuPLEhTkt1jVSyZpeNKIzTgEWmlxjdg81R0IgUCcaE+Ok3NvrfZg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/types@7.28.5':
-    resolution: {integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==}
+  '@babel/types@7.29.8':
+    resolution: {integrity: sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==}
     engines: {node: '>=6.9.0'}
 
   '@bramus/specificity@2.4.2':
@@ -251,8 +251,8 @@ packages:
       '@csstools/css-parser-algorithms': ^4.0.0
       '@csstools/css-tokenizer': ^4.0.0
 
-  '@csstools/css-color-parser@4.2.1':
-    resolution: {integrity: sha512-YpAJZhaHplYQkG8ib+/Fx5Y0eF2lVWi3tIvMJA6i39TLyUNp2439cifzW8VMjhlqrBjHzK5hVGugRRm2zTKI/A==}
+  '@csstools/css-color-parser@4.2.2':
+    resolution: {integrity: sha512-3QKjR/vxyjcSXBLgb6lP0S3MGdvwbmqSsvLPbYdVORqPDc8FX1HAJ0Spk38bxaRXgvENTA47tlhhbb5Z2e8hEg==}
     engines: {node: '>=20.19.0'}
     peerDependencies:
       '@csstools/css-parser-algorithms': ^4.0.0
@@ -264,8 +264,8 @@ packages:
     peerDependencies:
       '@csstools/css-tokenizer': ^4.0.0
 
-  '@csstools/css-syntax-patches-for-csstree@1.1.9':
-    resolution: {integrity: sha512-iGGw4OsAYsS6pD29MdJ2bX/nJx65a04ZZiw6x+VwWlP2DdXf6f++Zmuv/OzALpdyfVhjbduIIF2cXM7HWBIe9A==}
+  '@csstools/css-syntax-patches-for-csstree@1.1.12':
+    resolution: {integrity: sha512-3vLQK+dXxhBMR2Wx99PTCifE+vHtW2ndZWyla8yK813ev6oGhyn8Lja8jCyGAWTJ+LEYZK7EVtJxrDj8ztevJw==}
     peerDependencies:
       css-tree: ^3.2.1
     peerDependenciesMeta:
@@ -276,20 +276,20 @@ packages:
     resolution: {integrity: sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==}
     engines: {node: '>=20.19.0'}
 
-  '@emnapi/core@1.7.1':
-    resolution: {integrity: sha512-o1uhUASyo921r2XtHYOHy7gdkGLge8ghBEQHMWmyJFoXlpU58kIrhhN3w26lpQb6dspetweapMn2CSNwQ8I4wg==}
+  '@emnapi/core@1.10.0':
+    resolution: {integrity: sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==}
+
+  '@emnapi/runtime@1.10.0':
+    resolution: {integrity: sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==}
 
   '@emnapi/runtime@1.11.3':
     resolution: {integrity: sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==}
 
-  '@emnapi/runtime@1.7.1':
-    resolution: {integrity: sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==}
-
-  '@emnapi/wasi-threads@1.1.0':
-    resolution: {integrity: sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==}
+  '@emnapi/wasi-threads@1.2.1':
+    resolution: {integrity: sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==}
 
-  '@eslint-community/eslint-utils@4.9.0':
-    resolution: {integrity: sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==}
+  '@eslint-community/eslint-utils@4.10.1':
+    resolution: {integrity: sha512-cuadcxVFE8sDK6iWJbs8Sn0av2Nrh2QSGQhVlBW9AaAHqHwjWsZHT8LJ4hFGPh7ASBV2deFdM7H/DPjulmh8rg==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
@@ -304,8 +304,8 @@ packages:
     resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==}
     engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
 
-  '@eslint/config-array@0.21.1':
-    resolution: {integrity: sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==}
+  '@eslint/config-array@0.21.2':
+    resolution: {integrity: sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@eslint/config-helpers@0.4.2':
@@ -316,12 +316,12 @@ packages:
     resolution: {integrity: sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@eslint/eslintrc@3.3.3':
-    resolution: {integrity: sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==}
+  '@eslint/eslintrc@3.3.7':
+    resolution: {integrity: sha512-F42g89Qd5oAWtp0k0nnSrjziAKza7w8SVT4mStc18LZMaRb4J1HQAHLCalEtDCxrTuksx7NU9qsmeLwpOfPqWw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@eslint/js@9.39.2':
-    resolution: {integrity: sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==}
+  '@eslint/js@9.39.5':
+    resolution: {integrity: sha512-QywQuszQh77pIXCsq998c8hbhSTI/azTty1Z6N53dmAudKHhy573j3yvRLsX2BSp8YpLtoCEG8E9DJe+8zUh4A==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@eslint/object-schema@2.1.7':
@@ -341,12 +341,16 @@ packages:
       '@noble/hashes':
         optional: true
 
-  '@humanfs/core@0.19.1':
-    resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
+  '@humanfs/core@0.19.2':
+    resolution: {integrity: sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanfs/node@0.16.8':
+    resolution: {integrity: sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==}
     engines: {node: '>=18.18.0'}
 
-  '@humanfs/node@0.16.7':
-    resolution: {integrity: sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==}
+  '@humanfs/types@0.15.0':
+    resolution: {integrity: sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==}
     engines: {node: '>=18.18.0'}
 
   '@humanwhocodes/module-importer@1.0.1':
@@ -513,14 +517,18 @@ packages:
     resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
     engines: {node: '>=6.0.0'}
 
-  '@jridgewell/sourcemap-codec@1.5.5':
-    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+  '@jridgewell/sourcemap-codec@1.6.0':
+    resolution: {integrity: sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==}
 
   '@jridgewell/trace-mapping@0.3.31':
     resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
 
-  '@napi-rs/wasm-runtime@0.2.12':
-    resolution: {integrity: sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==}
+  '@napi-rs/wasm-runtime@1.2.3':
+    resolution: {integrity: sha512-UMduMbqO5s5zF2NkNacMT/yK5Y5QiKvWr2+50bzIIxFDwVJ2h49b+oyjaCGPhJxd2/gC2x39EHv/gHVuu36x2Q==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=23.5.0}
+    peerDependencies:
+      '@emnapi/core': ^1.7.1 || ^2.0.0-alpha.4
+      '@emnapi/runtime': ^1.7.1 || ^2.0.0-alpha.4
 
   '@next/env@16.3.3':
     resolution: {integrity: sha512-U2eYQRwXj+dsqxV79zFqExDdatnNY/ZWc2nsJU1p/OgT7fd3dXwlF6OjYaFQCfMoeTA19PWq+wVmYgimVA+V+g==}
@@ -592,95 +600,95 @@ packages:
     resolution: {integrity: sha512-nn5ozdjYQpUCZlWGuxcJY/KpxkWQs4DcbMCmKojjyrYDEAGy4Ce19NN4v5MduafTwJlbKc99UA8YhSVqq9yPZA==}
     engines: {node: '>=12.4.0'}
 
-  '@oxc-project/types@0.147.0':
-    resolution: {integrity: sha512-IJ3s6ltHLp45S0bh7phkX+gJO7A1Wuz2EaqpAhb8WjqDwbzMiWKHhyyT42tskaWjEYXtHtVCPpnBJVT9+dcRLg==}
+  '@oxc-project/types@0.148.0':
+    resolution: {integrity: sha512-Nm4s/jB+4FpFsPhWGEC4h7rzksesmtnMXomo6rCMcg/b8zLQuOziRgkCS1fxDCXOlJB/6Q8oABOZ/OP6RIPj9A==}
 
-  '@rolldown/binding-android-arm-eabi@1.2.6':
-    resolution: {integrity: sha512-b+jTcARdTiFLI6jB4a5XjTm0RWd6KcRfQj/I2356fxUZemiho9zQLxo0RtCuMDAyKcLo6cEltkgbQp6d1+sjjQ==}
+  '@rolldown/binding-android-arm-eabi@1.2.7':
+    resolution: {integrity: sha512-EypzgnYCwyVY4NDHKzGmNJT5b+XaQEBniHxsMdeIQLB/tcCzZnhqrzHpZFbX9iaxx+5RiB8caATBtfvZP7zVxQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [android]
 
-  '@rolldown/binding-android-arm64@1.2.6':
-    resolution: {integrity: sha512-lkWU8ZJaRk9q3CIEY1Tc7vIFALp3Xw5NfGJo2hQg5oIqNgxWi1zI+IiDEK3r70BF5Dzol1tcXsnzsRc8NLhG+Q==}
+  '@rolldown/binding-android-arm64@1.2.7':
+    resolution: {integrity: sha512-l17HE9EweWaqJZhuUuNBN/FzM62xw+DECVnJyvMsxn8vJFAGLy5QfLDoYAcronkAN8VxKZHezDpulHDPx95vFw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [android]
 
-  '@rolldown/binding-darwin-arm64@1.2.6':
-    resolution: {integrity: sha512-dgR56NYnvAszm7Ob1B2/Vn0e8bUQYZH2UjVaMMtMVOCKFSfjhfLmuA/9+O+F+ajUdG6B/bSssrKW6JJYASa8jA==}
+  '@rolldown/binding-darwin-arm64@1.2.7':
+    resolution: {integrity: sha512-8ED8ELFvHXc6OCETIn4gXObPiaR6bckM/ipXtbzlPVDRMBfEGjCKgO90F9YtfdpDatVx/ZQw7aZ1vUMf/+T3Mw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [darwin]
 
-  '@rolldown/binding-darwin-x64@1.2.6':
-    resolution: {integrity: sha512-vpVxFvUCFioJqug7OTvqptkc4yb8UX0AwfDmJpaR/0sWz+BUmqSVAf7c8JkUgnN8YLspb4a/N6NhTyMAmdyQ7Q==}
+  '@rolldown/binding-darwin-x64@1.2.7':
+    resolution: {integrity: sha512-/WPripjtiAIZ2tWY7ddijORT0Ujg87wxWW/qcoFVCKAWVDPhtY0xr7Dj0M3GyNGz60jGwTElhro/mkF9dT7dDQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [darwin]
 
-  '@rolldown/binding-freebsd-x64@1.2.6':
-    resolution: {integrity: sha512-h1wG6Y6K3JlRswxsI64qQJqBAy4vrLuHgRbc8CZMGSWTOFRY6ghMApM1NKzB2I0n5xV1fjkE18SuVl2QpLeNpA==}
+  '@rolldown/binding-freebsd-x64@1.2.7':
+    resolution: {integrity: sha512-14DI4NcqpvbICxSnGLx3PmtDaWqRP/KGSGb6C+JLLVPeZRl6dKdHba3pGsqT3vpdTqhEYIPG0MMQ8c0xYqoJxA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [freebsd]
 
-  '@rolldown/binding-linux-arm-gnueabihf@1.2.6':
-    resolution: {integrity: sha512-tbCiqub0q2MVWJKgF5PoAlNWCtQydiOYSLIkd8sByqK/6MMYLJRcSXSYodqYtd0O+Fw7QaVmKKlS4oL94YRZ0w==}
+  '@rolldown/binding-linux-arm-gnueabihf@1.2.7':
+    resolution: {integrity: sha512-bxrWIRvHWQvbJwi+VIie/kDJmQxcNE6xxWwZdqF/ExVAigtHkv54WTLQPb+QsZdnFy18fg7JPfWGL0RH6vwIlQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [linux]
 
-  '@rolldown/binding-linux-arm64-gnu@1.2.6':
-    resolution: {integrity: sha512-oxK9+baEBPhZG5HB4URY+uU04zJWeZlH6Tb9rB5DK4DF9XR1uXNLXt5Q5ZsugTKayNCNLhkcwz/ye74hRI98dg==}
+  '@rolldown/binding-linux-arm64-gnu@1.2.7':
+    resolution: {integrity: sha512-toOY2BChBZyuxU7OYX6Tn389di4IzAqPTycVcci0O7FSfBqzRB3RZn+K5Is6ANf4tmgRd/K1yZTsNTXbkXsnLg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
 
-  '@rolldown/binding-linux-arm64-musl@1.2.6':
-    resolution: {integrity: sha512-muWCk27FVBEZtv0MsK8gnfSmgczA8KQ0uRVJbTABKhkRfQc38aUrcb7fhi3BNiyseFmgcRsoMfQsSNJ+DbZdSw==}
+  '@rolldown/binding-linux-arm64-musl@1.2.7':
+    resolution: {integrity: sha512-lAIXTH/aiLRLxsTgQvfhjo4K1ydWIp00+V0voOr9beb/9ZmkUFrSIb03dXNFRgMNvkE6oGsF10ioQ6UsI+vS5Q==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
 
-  '@rolldown/binding-linux-ppc64-gnu@1.2.6':
-    resolution: {integrity: sha512-eWDoSfU7Co2qj3vgB3Dt4lj1mG6CoWbcJQkRMP3XJplyCMtuaq3LHvPFjS9QIPvMGWVadJC04Xiy0IdcVPtnwQ==}
+  '@rolldown/binding-linux-ppc64-gnu@1.2.7':
+    resolution: {integrity: sha512-kdnwS28Pkenp/mZMRwjXXXwxQ7pIsm+bF919LUK93BOyhcLsrVKdP2p9fxpiPNPAbNuch8ypQt0pm2P2LYCAGg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [ppc64]
     os: [linux]
 
-  '@rolldown/binding-linux-s390x-gnu@1.2.6':
-    resolution: {integrity: sha512-2bWNjRSIayvupRKxXUY2tWG9fYdoUlTqWywHRvE8Eq3GvuQ+f2HeIkve697fIt+IQs/PV8yFsdWuhp1aJ1PdnA==}
+  '@rolldown/binding-linux-s390x-gnu@1.2.7':
+    resolution: {integrity: sha512-516OdsyLdr5E65paF3yBF55t8mfm9+gmtCsK3xI7XKXIT7EfRlHhxL8K/NR6Hu8BWSgF5+1w74lTL0+nxcc8Qw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [s390x]
     os: [linux]
 
-  '@rolldown/binding-linux-x64-gnu@1.2.6':
-    resolution: {integrity: sha512-KekI0gS0wLxe1UBSQSjenBVwou/JkcQPDzBPICGZjxUv9k3RteHDPBQaiOicZUFKRIH2wKEimGwVpnJsbPzu7w==}
+  '@rolldown/binding-linux-x64-gnu@1.2.7':
+    resolution: {integrity: sha512-r8/z8n7GFaYRln3xmP1Cxy0HH/HLM0uBUPkEuSVEfKGDA89M0FsZRZJRSwe/tJjRx+fpH/gjorfhB8tmEbSFLA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
 
-  '@rolldown/binding-linux-x64-musl@1.2.6':
-    resolution: {integrity: sha512-TvtPnfVr+HtyGiDmPK4VWmlNm7QhNNAcK5Q9A7aOXsI8545yCyaoMaicXrFZ72JzeYjaUVk7yT243zT0jzjFKQ==}
+  '@rolldown/binding-linux-x64-musl@1.2.7':
+    resolution: {integrity: sha512-pAsE8iiDxUg1xBqdhrTfg45AVDVpirjz00sblEYClGNNcMnDb+e8beQgqIAw6LvauX/APvgxUnwrgun/YYGBhw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
 
-  '@rolldown/binding-openharmony-arm64@1.2.6':
-    resolution: {integrity: sha512-iOo0VEay2XFhaCcH0sps5XIimkSuOnNaZrf6+ZkoSOQBJPKNU48RkmJv0/lSpipexu5P+ouFgafe5IGr/DiQfg==}
+  '@rolldown/binding-openharmony-arm64@1.2.7':
+    resolution: {integrity: sha512-lTcIYmmnQQA8Or/2DatS6oSqcdLHvendjS+zLu+FwgToynWMRSmQdpM65fTANJgIS4mjbMOo5KT2lnT9SAb96w==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [openharmony]
 
-  '@rolldown/binding-win32-arm64-msvc@1.2.6':
-    resolution: {integrity: sha512-y5NTmmasMS455JlOCO4ZM9krIchv3Mvm1crL1iUPGOPgEzSkves9n0SdC5Sjz6+qWDFhd8/JpfWMH8NSWNHe+A==}
+  '@rolldown/binding-win32-arm64-msvc@1.2.7':
+    resolution: {integrity: sha512-e3Gu3WxbNk/UqQhxqU7YIYO+9ZBvWNz3U+h/qRFosscMFzdRPbXYSaSWgSnklv2fz1TgzBTcti2z35c/7irsHw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [win32]
 
-  '@rolldown/binding-win32-x64-msvc@1.2.6':
-    resolution: {integrity: sha512-np8iZSLfXlAD4kWhiyq/u0Yt8oZDtRQ8lGhQaCXo2rl37KNjeU0GjJuwr4P3oeZ++ROfofsKNBqR5LTO8aXyWQ==}
+  '@rolldown/binding-win32-x64-msvc@1.2.7':
+    resolution: {integrity: sha512-W/jg5qoRSqjsEv0+dZi4e687mcHqmVuU0P4fK6qS/xjetW2Gmc1W8j//z5nAeNcC8Ttm0hV46IjcYeuVwYhuiw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [win32]
@@ -703,8 +711,8 @@ packages:
     resolution: {integrity: sha512-nZyWTmSpJEXl6VtWVMBJve/7x12DZu6sIX1z1a+ZMaHlQQRs9Zpu6NbTe/gmxYXVRpkjxyDYpZ5gx2IM6f/Wkw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/node-http-handler@4.11.3':
-    resolution: {integrity: sha512-2jY1tSpERfPfWqyBV2pH+iGFaghVsIJszJNsT7hxtQYhVJpWDyc0LqOWI+nXOxOAHaEfZ4PXXtp1wW1TGpHhkA==}
+  '@smithy/node-http-handler@4.12.0':
+    resolution: {integrity: sha512-0mq1pHadfyXCYCqm2cNpbjNIT+fbaUpNxewZb/YNr2L0IrEVMOb8gM/Fl4K6XvHCW3uSNDFwPl/+iKm0bx9jYg==}
     engines: {node: '>=18.0.0'}
 
   '@smithy/signature-v4@5.7.3':
@@ -750,14 +758,14 @@ packages:
       '@types/react-dom':
         optional: true
 
-  '@testing-library/user-event@14.6.6':
-    resolution: {integrity: sha512-Jbs9FpkkIDw8FgSc6kOVsOv8JuuqGAL7J4X1oot77JxAoDlkNn2GRkd0aYRVuQ+pVQAiHWVkE4rX/dkF5fBiCw==}
+  '@testing-library/user-event@14.6.7':
+    resolution: {integrity: sha512-MPCpX8bxe8zS+JmmTwLp8jd0dy1rAm60Te/SL8JrQM3qvQJcBOs1d7IefJMyZzqM3EWBrDn/LWDt1BCGu4ASfg==}
     engines: {node: '>=12', npm: '>=6'}
     peerDependencies:
       '@testing-library/dom': '>=7.21.4'
 
-  '@tybys/wasm-util@0.10.1':
-    resolution: {integrity: sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==}
+  '@tybys/wasm-util@0.10.3':
+    resolution: {integrity: sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==}
 
   '@types/aria-query@5.0.4':
     resolution: {integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==}
@@ -768,8 +776,8 @@ packages:
   '@types/deep-eql@4.0.2':
     resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
 
-  '@types/estree@1.0.8':
-    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+  '@types/estree@1.0.9':
+    resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
 
   '@types/json-schema@7.0.15':
     resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
@@ -777,173 +785,188 @@ packages:
   '@types/json5@0.0.29':
     resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==}
 
-  '@types/node@25.0.3':
-    resolution: {integrity: sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA==}
+  '@types/node@25.9.5':
+    resolution: {integrity: sha512-OScDchr2fwuUmWdf4kZ9h7PcJiYDVInhJizG/biAq3cAvqwYktuy/TYGGdZNMtNTFUP7rnb0NU4TUdm82kt4Rg==}
 
-  '@types/react-dom@19.2.3':
-    resolution: {integrity: sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==}
+  '@types/react-dom@19.2.5':
+    resolution: {integrity: sha512-fMPwH9v7r/pp43yUd2/Mbiex5KouJwwR3dzHkhLREUC6764VyDsqxhAxv6OFEYR1RhjOyD1naqba8ECDBe7ZQg==}
     peerDependencies:
       '@types/react': ^19.2.0
 
-  '@types/react@19.2.7':
-    resolution: {integrity: sha512-MWtvHrGZLFttgeEj28VXHxpmwYbor/ATPYbBfSFZEIRK0ecCFLl2Qo55z52Hss+UV9CRN7trSeq1zbgx7YDWWg==}
+  '@types/react@19.2.18':
+    resolution: {integrity: sha512-AnzbBERsrLKtk2XSfTbYRLjQPdy116Sty4q+T+Bp3IC4l6jNBvreVPAHmpq9qhXQM7CXZPjLVmGMw9sy+hxQ3w==}
 
-  '@typescript-eslint/eslint-plugin@8.50.0':
-    resolution: {integrity: sha512-O7QnmOXYKVtPrfYzMolrCTfkezCJS9+ljLdKW/+DCvRsc3UAz+sbH6Xcsv7p30+0OwUbeWfUDAQE0vpabZ3QLg==}
+  '@typescript-eslint/eslint-plugin@8.69.0':
+    resolution: {integrity: sha512-t5jQTKPIgVW1PE6dR6H6Qz5gm8zjMlX5/2gRaOGd9eO6V7J+tQc6iWKukEe7dY8u9HyYasQ0yfF0/FSSTEO2gA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^8.50.0
-      eslint: ^8.57.0 || ^9.0.0
-      typescript: '>=4.8.4 <6.0.0'
+      '@typescript-eslint/parser': ^8.69.0
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/parser@8.50.0':
-    resolution: {integrity: sha512-6/cmF2piao+f6wSxUsJLZjck7OQsYyRtcOZS02k7XINSNlz93v6emM8WutDQSXnroG2xwYlEVHJI+cPA7CPM3Q==}
+  '@typescript-eslint/parser@8.69.0':
+    resolution: {integrity: sha512-l4b0DhWioGg6Gt2ebGlvfkFMOjRsauxtsnDRwUSRX1qHq3HdTfQHV8wW9zEXeciai6HfeaKOedQn2Zoofx3WBw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^8.57.0 || ^9.0.0
-      typescript: '>=4.8.4 <6.0.0'
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/project-service@8.50.0':
-    resolution: {integrity: sha512-Cg/nQcL1BcoTijEWyx4mkVC56r8dj44bFDvBdygifuS20f3OZCHmFbjF34DPSi07kwlFvqfv/xOLnJ5DquxSGQ==}
+  '@typescript-eslint/project-service@8.69.0':
+    resolution: {integrity: sha512-yi4obFrHMmnsesWehHbkg9zMA7Jt8cXT+mKM08G999pH1yT6nqgsHx7MYm0uY1wAj8CqiBXYRJ7WAT0QdQHQXg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      typescript: '>=4.8.4 <6.0.0'
+      typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/scope-manager@8.50.0':
-    resolution: {integrity: sha512-xCwfuCZjhIqy7+HKxBLrDVT5q/iq7XBVBXLn57RTIIpelLtEIZHXAF/Upa3+gaCpeV1NNS5Z9A+ID6jn50VD4A==}
+  '@typescript-eslint/scope-manager@8.69.0':
+    resolution: {integrity: sha512-ewfspqWvSxKSOaplqAUNbaSFO0eB6w1EtQ+esfYFRm3614Ty4uNtExkcbgd6nWsXphbqKyf9ZYdbZdv2xEoWEQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@typescript-eslint/tsconfig-utils@8.50.0':
-    resolution: {integrity: sha512-vxd3G/ybKTSlm31MOA96gqvrRGv9RJ7LGtZCn2Vrc5htA0zCDvcMqUkifcjrWNNKXHUU3WCkYOzzVSFBd0wa2w==}
+  '@typescript-eslint/tsconfig-utils@8.69.0':
+    resolution: {integrity: sha512-xNqK7YTDZsLniQMV/4rpFR8Z5JlqeRvVjuG1YgF/mdPVH84HSD19L8CczMA0qg2RfwEV231GHH3VnToJDo4MfQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      typescript: '>=4.8.4 <6.0.0'
+      typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/type-utils@8.50.0':
-    resolution: {integrity: sha512-7OciHT2lKCewR0mFoBrvZJ4AXTMe/sYOe87289WAViOocEmDjjv8MvIOT2XESuKj9jp8u3SZYUSh89QA4S1kQw==}
+  '@typescript-eslint/type-utils@8.69.0':
+    resolution: {integrity: sha512-ZfoJAVg3JZndQEpEl9petVlxau3lRuElc4HRMuAlLCf8to04/iHz692RUSNmXKDjEuJmIL+KZ2/BsOcBc16dsA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^8.57.0 || ^9.0.0
-      typescript: '>=4.8.4 <6.0.0'
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/types@8.50.0':
-    resolution: {integrity: sha512-iX1mgmGrXdANhhITbpp2QQM2fGehBse9LbTf0sidWK6yg/NE+uhV5dfU1g6EYPlcReYmkE9QLPq/2irKAmtS9w==}
+  '@typescript-eslint/types@8.69.0':
+    resolution: {integrity: sha512-K3VrubUPhlo9VDBS6QdI8YB5j7ClpqLRdefcz6PFrhnwicehBweqQ9Evhl4l+FYz0HdDmMqIiSX0aldGRYtDCA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@typescript-eslint/typescript-estree@8.50.0':
-    resolution: {integrity: sha512-W7SVAGBR/IX7zm1t70Yujpbk+zdPq/u4soeFSknWFdXIFuWsBGBOUu/Tn/I6KHSKvSh91OiMuaSnYp3mtPt5IQ==}
+  '@typescript-eslint/typescript-estree@8.69.0':
+    resolution: {integrity: sha512-AdFkgqck3Vudb/kWnxlyafU/4aBhHrbQ9locP2N4psXTy5mOBg0SHJumnLvx7r6g1gV4DKvUFwV2nJZBoqOD8w==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      typescript: '>=4.8.4 <6.0.0'
+      typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/utils@8.50.0':
-    resolution: {integrity: sha512-87KgUXET09CRjGCi2Ejxy3PULXna63/bMYv72tCAlDJC3Yqwln0HiFJ3VJMst2+mEtNtZu5oFvX4qJGjKsnAgg==}
+  '@typescript-eslint/utils@8.69.0':
+    resolution: {integrity: sha512-tUbx60BBqQa31kXF5MCsOOLL5E/WzUuxIn7YpAvq+eaUlqvk8/NXnXMBNAdLCr0icjkzem7iUA5QqWHe/hJ1aw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^8.57.0 || ^9.0.0
-      typescript: '>=4.8.4 <6.0.0'
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/visitor-keys@8.50.0':
-    resolution: {integrity: sha512-Xzmnb58+Db78gT/CCj/PVCvK+zxbnsw6F+O1oheYszJbBSdEjVhQi3C/Xttzxgi/GLmpvOggRs1RFpiJ8+c34Q==}
+  '@typescript-eslint/visitor-keys@8.69.0':
+    resolution: {integrity: sha512-+rmdgPA+EXkNgKYvHvFfhrs35utXbwaC5PGpDquSXcoXQDKUA5UjV0LmTucG/4JXkM31BTu4TilHtrN8IVBe8w==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@unrs/resolver-binding-android-arm-eabi@1.11.1':
-    resolution: {integrity: sha512-ppLRUgHVaGRWUx0R0Ut06Mjo9gBaBkg3v/8AxusGLhsIotbBLuRk51rAzqLC8gq6NyyAojEXglNjzf6R948DNw==}
+  '@unrs/resolver-binding-android-arm-eabi@1.12.2':
+    resolution: {integrity: sha512-g5T90pqg1bo/7mytQx6F4iBNC0Wsh9cu+z9veDbFjc7HjpesJFWD7QMS0NGStXM075+7dJPPVvBbpZlnrdpi/w==}
     cpu: [arm]
     os: [android]
 
-  '@unrs/resolver-binding-android-arm64@1.11.1':
-    resolution: {integrity: sha512-lCxkVtb4wp1v+EoN+HjIG9cIIzPkX5OtM03pQYkG+U5O/wL53LC4QbIeazgiKqluGeVEeBlZahHalCaBvU1a2g==}
+  '@unrs/resolver-binding-android-arm64@1.12.2':
+    resolution: {integrity: sha512-YGCRZv/9GLhwmz6mYDeTsm/92BAyR28l6c2ReweVW5pWgfsitWLY8upvfRlGdoyD8HjeTHSYJWyZGD4KJA/nFQ==}
     cpu: [arm64]
     os: [android]
 
-  '@unrs/resolver-binding-darwin-arm64@1.11.1':
-    resolution: {integrity: sha512-gPVA1UjRu1Y/IsB/dQEsp2V1pm44Of6+LWvbLc9SDk1c2KhhDRDBUkQCYVWe6f26uJb3fOK8saWMgtX8IrMk3g==}
+  '@unrs/resolver-binding-darwin-arm64@1.12.2':
+    resolution: {integrity: sha512-u9DiNT1auQMO20A9SyTuG3wUgQWB9Z7KjAg0uFuCDR1FsAY8A0CG2S6JpHS1xwm/w1G08bjXZDcyOCjv1WAm2w==}
     cpu: [arm64]
     os: [darwin]
 
-  '@unrs/resolver-binding-darwin-x64@1.11.1':
-    resolution: {integrity: sha512-cFzP7rWKd3lZaCsDze07QX1SC24lO8mPty9vdP+YVa3MGdVgPmFc59317b2ioXtgCMKGiCLxJ4HQs62oz6GfRQ==}
+  '@unrs/resolver-binding-darwin-x64@1.12.2':
+    resolution: {integrity: sha512-f7rPLi/T1HVKZu/u6t87lroib16n8vrSzcyxI7lg4BGO9UF26KhQL44sd9eOUgrTYhvRXtWOIZT5PejdPyJfUA==}
     cpu: [x64]
     os: [darwin]
 
-  '@unrs/resolver-binding-freebsd-x64@1.11.1':
-    resolution: {integrity: sha512-fqtGgak3zX4DCB6PFpsH5+Kmt/8CIi4Bry4rb1ho6Av2QHTREM+47y282Uqiu3ZRF5IQioJQ5qWRV6jduA+iGw==}
+  '@unrs/resolver-binding-freebsd-x64@1.12.2':
+    resolution: {integrity: sha512-BpcOjWCJub6nRZUS2zA20pmLvjtqAtGejETaIyRLiZiQf++cbrjltLA5NN/xaXfqeOBOSlMFbemIl5/S5tljmg==}
     cpu: [x64]
     os: [freebsd]
 
-  '@unrs/resolver-binding-linux-arm-gnueabihf@1.11.1':
-    resolution: {integrity: sha512-u92mvlcYtp9MRKmP+ZvMmtPN34+/3lMHlyMj7wXJDeXxuM0Vgzz0+PPJNsro1m3IZPYChIkn944wW8TYgGKFHw==}
+  '@unrs/resolver-binding-linux-arm-gnueabihf@1.12.2':
+    resolution: {integrity: sha512-vZTDvdSISZjJx66OzJqtsOhzifbqRjbmI1Mnu49fQDwog5GtDI4QidRiEAYbZCRj9C8YZEW+3ZjqsyS9GR4k2A==}
     cpu: [arm]
     os: [linux]
 
-  '@unrs/resolver-binding-linux-arm-musleabihf@1.11.1':
-    resolution: {integrity: sha512-cINaoY2z7LVCrfHkIcmvj7osTOtm6VVT16b5oQdS4beibX2SYBwgYLmqhBjA1t51CarSaBuX5YNsWLjsqfW5Cw==}
+  '@unrs/resolver-binding-linux-arm-musleabihf@1.12.2':
+    resolution: {integrity: sha512-BiPI+IrIlwcW4nLLMM21+B1dFPzd55yAVgVGrdgDjNef+ch03GdxrcyaIz8X9SsQirh/kCQ7mviyWlMxdh2D7g==}
     cpu: [arm]
     os: [linux]
 
-  '@unrs/resolver-binding-linux-arm64-gnu@1.11.1':
-    resolution: {integrity: sha512-34gw7PjDGB9JgePJEmhEqBhWvCiiWCuXsL9hYphDF7crW7UgI05gyBAi6MF58uGcMOiOqSJ2ybEeCvHcq0BCmQ==}
+  '@unrs/resolver-binding-linux-arm64-gnu@1.12.2':
+    resolution: {integrity: sha512-zJc0H99FEPoFfSrNpa91HYfxzfAJCr502oxNK1cfdC9hlaFI43RT+JFCann9JUgZmLzzntChHyn13Sgn9ljHNg==}
     cpu: [arm64]
     os: [linux]
 
-  '@unrs/resolver-binding-linux-arm64-musl@1.11.1':
-    resolution: {integrity: sha512-RyMIx6Uf53hhOtJDIamSbTskA99sPHS96wxVE/bJtePJJtpdKGXO1wY90oRdXuYOGOTuqjT8ACccMc4K6QmT3w==}
+  '@unrs/resolver-binding-linux-arm64-musl@1.12.2':
+    resolution: {integrity: sha512-KQ3Lki6l+Pz1k/eBipN41ES+YUK30beLGb9YqcB1O542cyLCNE6GaxrfcY3T6EezmGGk84wb5XyO9loTM9tkcA==}
     cpu: [arm64]
     os: [linux]
 
-  '@unrs/resolver-binding-linux-ppc64-gnu@1.11.1':
-    resolution: {integrity: sha512-D8Vae74A4/a+mZH0FbOkFJL9DSK2R6TFPC9M+jCWYia/q2einCubX10pecpDiTmkJVUH+y8K3BZClycD8nCShA==}
+  '@unrs/resolver-binding-linux-loong64-gnu@1.12.2':
+    resolution: {integrity: sha512-3SJGEh1DborhG6pyxvhPzCT4bbSIVihsvgJc13P1bHG7KLdNDaF9T3gsTwFc7Jw/5Y5/iWOjkEx7Zy0NvCGX3Q==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-loong64-musl@1.12.2':
+    resolution: {integrity: sha512-jiuG/Obbel7uw1PwHNFfrkiKhLAF6mnyZ6aWlOAVN9WqKm8v0OFGnciJIHu8+CMvXLQ8AD51LPzAoUfT21D5Ew==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-ppc64-gnu@1.12.2':
+    resolution: {integrity: sha512-q7xRvVpmcfeL+LlZg8Pbbo6QaTZwDU5BaGZbwfhkEsXJn3Was8xYfE0RBH266xZt0rM6B7i8xAYIvjthuUIWHg==}
     cpu: [ppc64]
     os: [linux]
 
-  '@unrs/resolver-binding-linux-riscv64-gnu@1.11.1':
-    resolution: {integrity: sha512-frxL4OrzOWVVsOc96+V3aqTIQl1O2TjgExV4EKgRY09AJ9leZpEg8Ak9phadbuX0BA4k8U5qtvMSQQGGmaJqcQ==}
+  '@unrs/resolver-binding-linux-riscv64-gnu@1.12.2':
+    resolution: {integrity: sha512-0CVdx6lcnT3Q9inOH8tsMIOJ6ImndllMjqJHg8RLVdB7Vq4SfkEXl9mCSsVNuNA4MCYycRicCUxPCabVHJRr6A==}
     cpu: [riscv64]
     os: [linux]
 
-  '@unrs/resolver-binding-linux-riscv64-musl@1.11.1':
-    resolution: {integrity: sha512-mJ5vuDaIZ+l/acv01sHoXfpnyrNKOk/3aDoEdLO/Xtn9HuZlDD6jKxHlkN8ZhWyLJsRBxfv9GYM2utQ1SChKew==}
+  '@unrs/resolver-binding-linux-riscv64-musl@1.12.2':
+    resolution: {integrity: sha512-iOwlRo9vnp6R6ohHQS11n0NnfdXx/omhkocmIfaPRpQhKZ+3BDMkkdRVh53qjkFkpPddf+FETA28NwGN7l5l+w==}
     cpu: [riscv64]
     os: [linux]
 
-  '@unrs/resolver-binding-linux-s390x-gnu@1.11.1':
-    resolution: {integrity: sha512-kELo8ebBVtb9sA7rMe1Cph4QHreByhaZ2QEADd9NzIQsYNQpt9UkM9iqr2lhGr5afh885d/cB5QeTXSbZHTYPg==}
+  '@unrs/resolver-binding-linux-s390x-gnu@1.12.2':
+    resolution: {integrity: sha512-HYJtLfXq94q8iZNFT1lknx258wlkkWhZeUXJRqzKBBUJ00CvZ+N33zgbCqimLjsyw5Va6uUxhVa12mI+kaveEw==}
     cpu: [s390x]
     os: [linux]
 
-  '@unrs/resolver-binding-linux-x64-gnu@1.11.1':
-    resolution: {integrity: sha512-C3ZAHugKgovV5YvAMsxhq0gtXuwESUKc5MhEtjBpLoHPLYM+iuwSj3lflFwK3DPm68660rZ7G8BMcwSro7hD5w==}
+  '@unrs/resolver-binding-linux-x64-gnu@1.12.2':
+    resolution: {integrity: sha512-mPsUhunKKDih5O96Y6enDQyHc1SqBPlY1E/SfMWDM3EdJ95Z9CArPeCVwCCqbP45ljvivdEk8Fxn+SIb1rDAJQ==}
     cpu: [x64]
     os: [linux]
 
-  '@unrs/resolver-binding-linux-x64-musl@1.11.1':
-    resolution: {integrity: sha512-rV0YSoyhK2nZ4vEswT/QwqzqQXw5I6CjoaYMOX0TqBlWhojUf8P94mvI7nuJTeaCkkds3QE4+zS8Ko+GdXuZtA==}
+  '@unrs/resolver-binding-linux-x64-musl@1.12.2':
+    resolution: {integrity: sha512-azrt6+5ydLd8Vt210AAFis/lZevSfPw93EJRIJG+xPu4WCJ8K0kppCTpMyLPcKT7H15M4Jnt2tMp5bOvCkRC6A==}
     cpu: [x64]
     os: [linux]
 
-  '@unrs/resolver-binding-wasm32-wasi@1.11.1':
-    resolution: {integrity: sha512-5u4RkfxJm+Ng7IWgkzi3qrFOvLvQYnPBmjmZQ8+szTK/b31fQCnleNl1GgEt7nIsZRIf5PLhPwT0WM+q45x/UQ==}
+  '@unrs/resolver-binding-openharmony-arm64@1.12.2':
+    resolution: {integrity: sha512-YZ9hP4O0X9PQb8eO980qmLNGH4zT3I9+SZTdt0Pr0YyuGQhYKoOZkV02VzrzyOZJ5xIJ3UFIenKkUkGg8GjgWQ==}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@unrs/resolver-binding-wasm32-wasi@1.12.2':
+    resolution: {integrity: sha512-tYFDIkMxSflfEc/h92ZWNsZlHSwgimbNHSO3PL2JWQHfCuC2q316jMyYU9TIWZsFK2bQwyK5VAdYgn8ygPj69A==}
     engines: {node: '>=14.0.0'}
     cpu: [wasm32]
 
-  '@unrs/resolver-binding-win32-arm64-msvc@1.11.1':
-    resolution: {integrity: sha512-nRcz5Il4ln0kMhfL8S3hLkxI85BXs3o8EYoattsJNdsX4YUU89iOkVn7g0VHSRxFuVMdM4Q1jEpIId1Ihim/Uw==}
+  '@unrs/resolver-binding-win32-arm64-msvc@1.12.2':
+    resolution: {integrity: sha512-qzNyg3xL0VPQmCaUh+N5jSitce6k+uCBfMDesWRnlULOZaqUkaJ0ybdT+UqlAWJoQjuqfIU/0Ptx9bteN4D82g==}
     cpu: [arm64]
     os: [win32]
 
-  '@unrs/resolver-binding-win32-ia32-msvc@1.11.1':
-    resolution: {integrity: sha512-DCEI6t5i1NmAZp6pFonpD5m7i6aFrpofcp4LA2i8IIq60Jyo28hamKBxNrZcyOwVOZkgsRp9O2sXWBWP8MnvIQ==}
+  '@unrs/resolver-binding-win32-ia32-msvc@1.12.2':
+    resolution: {integrity: sha512-WD9sY00OfpHVGfsnHZoA8jVT+esS/Bg8z8jzxp5BnDCjjwsuKsPQrzswwpFy4J1AUJbXPRfkpcX0mXrzeXW79g==}
     cpu: [ia32]
     os: [win32]
 
-  '@unrs/resolver-binding-win32-x64-msvc@1.11.1':
-    resolution: {integrity: sha512-lrW200hZdbfRtztbygyaq/6jP6AKE8qQN2KvPcJ+x7wiD038YtnYtZ82IMNJ69GJibV7bwL3y9FgK+5w/pYt6g==}
+  '@unrs/resolver-binding-win32-x64-msvc@1.12.2':
+    resolution: {integrity: sha512-nAB74NfSNKknqQ1RrYj6uz8FcXEomu/MATJZxh/x+BArzN2U3JbOYC0APYzUIGhVY3m5hRxA8VPNdPBoG8txlA==}
     cpu: [x64]
     os: [win32]
 
-  '@vitejs/plugin-react@6.1.0':
-    resolution: {integrity: sha512-qd2BzUBehkov86WFhg0JkEFEYyCLG9uPCe6qWTY/kRlss9OvJrOF2UbIWT7p+8IzZHkEu0DNGHc4HSv+JdDLsw==}
+  '@vitejs/plugin-react@6.1.1':
+    resolution: {integrity: sha512-yxLaQV9gkhS8ezJqCM6+ndU7mDY6gqAg75NQ+0IjwEI8IYOmQCgkRwHKVSfWXW076DsqMo0Dk+0FK1U+M5RgFw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     peerDependencies:
       '@rolldown/plugin-babel': ^0.1.7 || ^0.2.0
@@ -992,13 +1015,13 @@ packages:
     peerDependencies:
       acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
 
-  acorn@8.15.0:
-    resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==}
+  acorn@8.18.0:
+    resolution: {integrity: sha512-lGq+9yr1/GuAWaVYIHRjvvySG5/4VfKIvC8EWxStPdcDh/Ka7FG3twP6v4d5BkravUilhIAsG4Qj83t02LWUPQ==}
     engines: {node: '>=0.4.0'}
     hasBin: true
 
-  ajv@6.12.6:
-    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
+  ajv@6.15.0:
+    resolution: {integrity: sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==}
 
   ansi-regex@5.0.1:
     resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
@@ -1069,8 +1092,8 @@ packages:
     resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
     engines: {node: '>= 0.4'}
 
-  axe-core@4.11.0:
-    resolution: {integrity: sha512-ilYanEU8vxxBexpJd8cWM4ElSQq4QctCLKih0TSfjIfCQTeyH/6zVrmIJfLPrKTKJRbiG+cfnZbQIjAlJmF1jQ==}
+  axe-core@4.13.0:
+    resolution: {integrity: sha512-UzGt8zg7Ny8djbYMhxl2zuEevVa7r2gJjYY5Lwr1xM7+XU2nd6CkIWFTVcCIbAP63vSz71NaVyyuSk9lHKcy0A==}
     engines: {node: '>=4'}
 
   axobject-query@4.1.0:
@@ -1080,33 +1103,34 @@ packages:
   balanced-match@1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
 
+  balanced-match@4.0.4:
+    resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==}
+    engines: {node: 18 || 20 || >=22}
+
   baseline-browser-mapping@2.11.20:
     resolution: {integrity: sha512-H0ulySigv6icDJ1F7SjtdCD6PrhTpdYCmP0CactWy1+ekh0AFd0o1Wn5T8b+hnTmdBx19u9yhL6wvCylXMY7zw==}
     engines: {node: '>=6.0.0'}
     hasBin: true
 
-  baseline-browser-mapping@2.9.9:
-    resolution: {integrity: sha512-V8fbOCSeOFvlDj7LLChUcqbZrdKD9RU/VR260piF1790vT0mfLSwGc/Qzxv3IqiTukOpNtItePa0HBpMAj7MDg==}
-    hasBin: true
-
   bidi-js@1.0.3:
     resolution: {integrity: sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==}
 
-  bowser@2.13.1:
-    resolution: {integrity: sha512-OHawaAbjwx6rqICCKgSG0SAnT05bzd7ppyKLVUITZpANBaaMFBAsaNkto3LoQ31tyFP5kNujE8Cdx85G9VzOkw==}
+  bowser@2.14.1:
+    resolution: {integrity: sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg==}
 
-  brace-expansion@1.1.12:
-    resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==}
+  brace-expansion@1.1.18:
+    resolution: {integrity: sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==}
 
-  brace-expansion@2.0.2:
-    resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==}
+  brace-expansion@5.0.9:
+    resolution: {integrity: sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==}
+    engines: {node: 20 || >=22}
 
   braces@3.0.3:
     resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
     engines: {node: '>=8'}
 
-  browserslist@4.28.1:
-    resolution: {integrity: sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==}
+  browserslist@4.28.8:
+    resolution: {integrity: sha512-V2NpofLblG64mfOtSgDhOJESZEGogzDMBv/q+W6oc4LXWP/q75eOXoOaaOu1EOadB9U4Bwx/e0yzbvwKH8zalA==}
     engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
     hasBin: true
 
@@ -1114,8 +1138,8 @@ packages:
     resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
     engines: {node: '>= 0.4'}
 
-  call-bind@1.0.8:
-    resolution: {integrity: sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==}
+  call-bind@1.0.9:
+    resolution: {integrity: sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==}
     engines: {node: '>= 0.4'}
 
   call-bound@1.0.4:
@@ -1126,8 +1150,8 @@ packages:
     resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
     engines: {node: '>=6'}
 
-  caniuse-lite@1.0.30001760:
-    resolution: {integrity: sha512-7AAMPcueWELt1p3mi13HR/LHH0TJLT11cnwDJEs3xA4+CK/PLKeO9Kl1oru24htkyUKtkGCvAx4ohB0Ttry8Dw==}
+  caniuse-lite@1.0.30001810:
+    resolution: {integrity: sha512-TITQPUkaz+aVk5GL6NhOdwk1aEaNTSDPsGFWrTuhKGtjTF70jL/Oht2W4c6rXUe5fu7Ie19VIahAXHIIiWWNeg==}
 
   chai@6.2.2:
     resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
@@ -1239,8 +1263,8 @@ packages:
     resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
     engines: {node: '>= 0.4'}
 
-  electron-to-chromium@1.5.267:
-    resolution: {integrity: sha512-0Drusm6MVRXSOJpGbaSVgcQsuB4hEkMpHXaVstcPmhu5LIedxs1xNK/nIxmQIU/RPC0+1/o0AVZfBTkTNJOdUw==}
+  electron-to-chromium@1.5.420:
+    resolution: {integrity: sha512-2yD6XreGusOfNV+dUcvipJEXc3n/n7fgr7996aszTG+YY5E4mqM4tOq/3uhP129cazL9YHbVWSpc79ePotWtPA==}
 
   emoji-regex@9.2.2:
     resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
@@ -1249,8 +1273,12 @@ packages:
     resolution: {integrity: sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==}
     engines: {node: '>=20.19.0'}
 
-  es-abstract@1.24.1:
-    resolution: {integrity: sha512-zHXBLhP+QehSSbsS9Pt23Gg964240DPd6QCf8WpkqEXxQ7fhdZzYsocOr5u7apWonsS5EjZDmTF+/slGMyasvw==}
+  es-abstract-get@1.0.0:
+    resolution: {integrity: sha512-6PMWXpdhshVvFp+FoWYs1EvG1Nj0tvk0dZM+XcK0xMEM1czRVcP6ohqPWHy6qPagSpC8j4+p89WXlT+xXJs/fg==}
+    engines: {node: '>= 0.4'}
+
+  es-abstract@1.24.2:
+    resolution: {integrity: sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==}
     engines: {node: '>= 0.4'}
 
   es-define-property@1.0.1:
@@ -1261,15 +1289,15 @@ packages:
     resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
     engines: {node: '>= 0.4'}
 
-  es-iterator-helpers@1.2.2:
-    resolution: {integrity: sha512-BrUQ0cPTB/IwXj23HtwHjS9n7O4h9FX94b4xc5zlTHxeLgTAdzYUDyy6KdExAl9lbN5rtfe44xpjpmj9grxs5w==}
+  es-iterator-helpers@1.4.0:
+    resolution: {integrity: sha512-c/A0P0oxkACDc+cKWw8evLXK83oBKgn0qPOqCYT4x9uolpCIJAcYvJC9QYKNDRPsTeGyCrQ326jrvgZWdCdK5Q==}
     engines: {node: '>= 0.4'}
 
   es-module-lexer@2.3.2:
     resolution: {integrity: sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==}
 
-  es-object-atoms@1.1.1:
-    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
+  es-object-atoms@1.1.2:
+    resolution: {integrity: sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==}
     engines: {node: '>= 0.4'}
 
   es-set-tostringtag@2.1.0:
@@ -1280,8 +1308,8 @@ packages:
     resolution: {integrity: sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==}
     engines: {node: '>= 0.4'}
 
-  es-to-primitive@1.3.0:
-    resolution: {integrity: sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==}
+  es-to-primitive@1.3.4:
+    resolution: {integrity: sha512-yPDz7wqpg1/mmHLmS3tcfTfbw5f1eryXvyghYBffGdERwe+mV7ZcWzTR8LR17Kvqt3qfPurjlonmnq3MKXIOXw==}
     engines: {node: '>= 0.4'}
 
   escalade@3.2.0:
@@ -1301,8 +1329,8 @@ packages:
       typescript:
         optional: true
 
-  eslint-import-resolver-node@0.3.9:
-    resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==}
+  eslint-import-resolver-node@0.3.10:
+    resolution: {integrity: sha512-tRrKqFyCaKict5hOd244sL6EQFNycnMQnBe+j8uqGNXYzsImGbGUU4ibtoaBmv5FLwJwcFJNeg1GeVjQfbMrDQ==}
 
   eslint-import-resolver-typescript@3.10.1:
     resolution: {integrity: sha512-A1rHYb06zjMGAxdLSkN2fXPBwuSaQ0iO5M/hdyS0Ajj1VBaRp0sPD3dn1FhME3c/JluGFbwSxyCfqdSbtQLAHQ==}
@@ -1317,8 +1345,8 @@ packages:
       eslint-plugin-import-x:
         optional: true
 
-  eslint-module-utils@2.12.1:
-    resolution: {integrity: sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw==}
+  eslint-module-utils@2.14.0:
+    resolution: {integrity: sha512-W2WCRZ9Dqntd+2u8jJcVMV2PKulc6RdLgUUoh/yQr3uB6lo/ZOeGx11sv60/8S4QFFKNslAlWhr9u0Ef7ZW6Ig==}
     engines: {node: '>=4'}
     peerDependencies:
       '@typescript-eslint/parser': '*'
@@ -1354,11 +1382,11 @@ packages:
     peerDependencies:
       eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9
 
-  eslint-plugin-react-hooks@7.0.1:
-    resolution: {integrity: sha512-O0d0m04evaNzEPoSW+59Mezf8Qt0InfgGIBJnpC0h3NH/WjUAR7BIKUfysC6todmtiZ/A0oUVS8Gce0WhBrHsA==}
+  eslint-plugin-react-hooks@7.1.1:
+    resolution: {integrity: sha512-f2I7Gw6JbvCexzIInuSbZpfdQ44D7iqdWX01FKLvrPgqxoE7oMj8clOfto8U6vYiz4yd5oKu39rRSVOe1zRu0g==}
     engines: {node: '>=18'}
     peerDependencies:
-      eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0
+      eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 || ^10.0.0
 
   eslint-plugin-react@7.37.5:
     resolution: {integrity: sha512-Qteup0SqU15kdocexFNAJMvCJEfa2xUKNV4CC1xsVMrIIqEy3SQ/rqyxCWNzfrd3/ldy6HMlD2e0JDVpDg2qIA==}
@@ -1378,9 +1406,14 @@ packages:
     resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  eslint@9.39.2:
-    resolution: {integrity: sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==}
+  eslint-visitor-keys@5.0.1:
+    resolution: {integrity: sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  eslint@9.39.5:
+    resolution: {integrity: sha512-DgZS62aPLXKlnxILS/AYCoRvHaZeXceIzlXPkkGGzJWSow1aEk0lbTlxUSlyjC8jcaKxAdOnTDz+o1JFSBsyjw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    deprecated: This version is no longer supported. Please see https://eslint.org/version-support for other options.
     hasBin: true
     peerDependencies:
       jiti: '*'
@@ -1392,8 +1425,8 @@ packages:
     resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  esquery@1.6.0:
-    resolution: {integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==}
+  esquery@1.7.0:
+    resolution: {integrity: sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==}
     engines: {node: '>=0.10'}
 
   esrecurse@4.3.0:
@@ -1428,8 +1461,8 @@ packages:
   fast-levenshtein@2.0.6:
     resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
 
-  fastq@1.19.1:
-    resolution: {integrity: sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==}
+  fastq@1.20.3:
+    resolution: {integrity: sha512-XKv5nnLs6nLF71NgiKJLIZFLkPyIEuOselLG7ujZnGrRfQK8HpvY+WqKhAJUAdLomwVHErVS4LfxFlPq0/FTAw==}
 
   fdir@6.5.0:
     resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
@@ -1456,8 +1489,8 @@ packages:
     resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
     engines: {node: '>=16'}
 
-  flatted@3.3.3:
-    resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==}
+  flatted@3.4.4:
+    resolution: {integrity: sha512-5+ybhBZANEJxaH3X5evAFatUxLfEHSr7n6kYJ+1Qd0mUqr4eu9gIf6GDbWHf8RJijHrjjO8G+la14SlL2SeS1Q==}
 
   for-each@0.3.5:
     resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==}
@@ -1471,8 +1504,8 @@ packages:
   function-bind@1.1.2:
     resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
 
-  function.prototype.name@1.1.8:
-    resolution: {integrity: sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==}
+  function.prototype.name@1.2.0:
+    resolution: {integrity: sha512-jObKIik1P2QjPHP5nz5BaOtUlfgS0fWo8IUByNXkM+o+02sJOi94em77GwJKQSJ3gfPHdgzLNrHc1uokV4P/ew==}
     engines: {node: '>= 0.4'}
 
   functions-have-names@1.2.3:
@@ -1498,8 +1531,8 @@ packages:
     resolution: {integrity: sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==}
     engines: {node: '>= 0.4'}
 
-  get-tsconfig@4.13.0:
-    resolution: {integrity: sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==}
+  get-tsconfig@4.14.3:
+    resolution: {integrity: sha512-++QEw4DIY7WGoukz+/+A/8dGYPT9l9yIadnmSgZ8Rjr3YVSVDipQSO9CdnJo9ePqFqUUqh+wk9uIaoiAwsiPkA==}
 
   glob-parent@5.1.2:
     resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
@@ -1548,8 +1581,8 @@ packages:
     resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
     engines: {node: '>= 0.4'}
 
-  hasown@2.0.2:
-    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+  hasown@2.0.4:
+    resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==}
     engines: {node: '>= 0.4'}
 
   hermes-estree@0.25.1:
@@ -1566,8 +1599,8 @@ packages:
     resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
     engines: {node: '>= 4'}
 
-  ignore@7.0.5:
-    resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==}
+  ignore@7.0.8:
+    resolution: {integrity: sha512-YYNsSlXBjMk92SKnkwvB5LOVSa6OznlFUGcsvrFgNJbJCd0M1XKeFVRc8ZByeCqz32FivYNHJVooLmdqrmvp/Q==}
     engines: {node: '>= 4'}
 
   import-fresh@3.3.1:
@@ -1609,8 +1642,8 @@ packages:
     resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
     engines: {node: '>= 0.4'}
 
-  is-core-module@2.16.1:
-    resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==}
+  is-core-module@2.16.2:
+    resolution: {integrity: sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==}
     engines: {node: '>= 0.4'}
 
   is-data-view@1.0.2:
@@ -1621,6 +1654,10 @@ packages:
     resolution: {integrity: sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==}
     engines: {node: '>= 0.4'}
 
+  is-document.all@1.0.0:
+    resolution: {integrity: sha512-+XSoyS05OdBbhFuELhgTCpFNHkpBOJqtsZfUFFpe5QTw+9Sjbh8zitxhQkYAo6wV7e1Vb8cAPvpCk9jGam/82g==}
+    engines: {node: '>= 0.4'}
+
   is-extglob@2.1.1:
     resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
     engines: {node: '>=0.10.0'}
@@ -1705,8 +1742,8 @@ packages:
   js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
-  js-yaml@4.1.1:
-    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
+  js-yaml@4.3.2:
+    resolution: {integrity: sha512-SFNOvSJ+Dgf/9An904Yx+CgSlIPCkIpao4qo51lpee25TIRejdH3rhR4EZMGoNx3/TP3O+wzWuiTFl4sqbltzA==}
     hasBin: true
 
   jsdom@30.0.1:
@@ -1873,12 +1910,12 @@ packages:
     resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==}
     engines: {node: '>=4'}
 
-  minimatch@3.1.2:
-    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+  minimatch@10.2.6:
+    resolution: {integrity: sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==}
+    engines: {node: 18 || 20 || >=22}
 
-  minimatch@9.0.5:
-    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
-    engines: {node: '>=16 || 14 >=14.17'}
+  minimatch@3.1.5:
+    resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==}
 
   minimist@1.2.8:
     resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
@@ -1923,8 +1960,13 @@ packages:
       sass:
         optional: true
 
-  node-releases@2.0.27:
-    resolution: {integrity: sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==}
+  node-exports-info@1.6.2:
+    resolution: {integrity: sha512-kXs9Go0cah0qHVV2v389IXQLdLCeE1xfFtjOAF+iobu0OIoG1pje8At2vMHyaPMiPMnG/LWP50twML21eMcAag==}
+    engines: {node: '>= 0.4'}
+
+  node-releases@2.0.54:
+    resolution: {integrity: sha512-YHs7BmmcsdAI5Ozuf8JZo6PT0mv2GIWC9vMfvUC3dp65M8hn7Ux8CPL+2oBI7juNuj9d0ndhTcznq2ODBps9cQ==}
+    engines: {node: '>=18'}
 
   object-assign@4.1.1:
     resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
@@ -1969,8 +2011,8 @@ packages:
     resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
     engines: {node: '>= 0.8.0'}
 
-  own-keys@1.0.1:
-    resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
+  own-keys@1.0.2:
+    resolution: {integrity: sha512-19YVAg7T+WTrxggPukVq7DjTv6+PJ867TmhCvBsYwmbFCsZd344rq2Ld1p0wo8f8Qrrhgp82c6FJRqdXWtSEhg==}
     engines: {node: '>= 0.4'}
 
   p-limit@3.1.0:
@@ -2005,14 +2047,10 @@ packages:
   picocolors@1.1.1:
     resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
 
-  picomatch@2.3.1:
-    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+  picomatch@2.3.2:
+    resolution: {integrity: sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==}
     engines: {node: '>=8.6'}
 
-  picomatch@4.0.3:
-    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
-    engines: {node: '>=12'}
-
   picomatch@4.0.7:
     resolution: {integrity: sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==}
     engines: {node: '>=12'}
@@ -2085,29 +2123,25 @@ packages:
   resolve-pkg-maps@1.0.0:
     resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
 
-  resolve@1.22.11:
-    resolution: {integrity: sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==}
+  resolve@2.0.0-next.7:
+    resolution: {integrity: sha512-tqt+NBWwyaMgw3zDsnygx4CByWjQEJHOPMdslYhppaQSJUtL/D4JO9CcBBlhPoI8lz9oJIDXkwXfhF4aWqP8xQ==}
     engines: {node: '>= 0.4'}
     hasBin: true
 
-  resolve@2.0.0-next.5:
-    resolution: {integrity: sha512-U7WjGVG9sH8tvjW5SmGbQuui75FiyjAX72HX15DwBBwF9dNiQZRQAg9nnPhYy+TUnE0+VcrttuvNI8oSxZcocA==}
-    hasBin: true
-
   reusify@1.1.0:
     resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
     engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
 
-  rolldown@1.2.6:
-    resolution: {integrity: sha512-vMM4q3aixf46GiF1Kok8jDPFsEpXgFWGjUHXNkNHNm+Y2adXAG2dbX91jkti3i0ZRsOlcmbuzAz1poObSHCmUA==}
+  rolldown@1.2.7:
+    resolution: {integrity: sha512-g0EtLvBjTUB7jhyV0S/TCup3v/XSVl45vUIGbOGU4QPiyjTenCe4mKuFvW9fEgYmS2Fo42AUssRmNuMziXdrig==}
     engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
 
   run-parallel@1.2.0:
     resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
 
-  safe-array-concat@1.1.3:
-    resolution: {integrity: sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==}
+  safe-array-concat@1.1.4:
+    resolution: {integrity: sha512-wtZlHyOje6OZTGqAoaDKxFkgRtkF9CnHAVnCHKfuj200wAgL+bSJhdsCD2l0Qx/2ekEXjPWcyKkfGb5CPboslg==}
     engines: {node: '>=0.4'}
 
   safe-push-apply@1.0.0:
@@ -2129,11 +2163,6 @@ packages:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
 
-  semver@7.7.3:
-    resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==}
-    engines: {node: '>=10'}
-    hasBin: true
-
   semver@7.8.5:
     resolution: {integrity: sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==}
     engines: {node: '>=10'}
@@ -2171,8 +2200,8 @@ packages:
     resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
     engines: {node: '>=8'}
 
-  side-channel-list@1.0.0:
-    resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==}
+  side-channel-list@1.0.1:
+    resolution: {integrity: sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==}
     engines: {node: '>= 0.4'}
 
   side-channel-map@1.0.1:
@@ -2183,8 +2212,8 @@ packages:
     resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==}
     engines: {node: '>= 0.4'}
 
-  side-channel@1.1.0:
-    resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==}
+  side-channel@1.1.1:
+    resolution: {integrity: sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==}
     engines: {node: '>= 0.4'}
 
   siginfo@2.0.0:
@@ -2211,19 +2240,19 @@ packages:
     resolution: {integrity: sha512-o7+c9bW6zpAdJHTtujeePODAhkuicdAryFsfVKwA+wGw89wJ4GTY484WTucM9hLtDEOpOvI+aHnzqnC5lHp4Rg==}
     engines: {node: '>= 0.4'}
 
-  string.prototype.matchall@4.0.12:
-    resolution: {integrity: sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA==}
+  string.prototype.matchall@4.1.0:
+    resolution: {integrity: sha512-tHNHTxInrYLCga9O9YGxWA3G9/nnzQw8UGAyqGx3Ar1pSTTzIuM4woFSq4SowkXCjJIwq5sIiQvEfRI9tCH1qQ==}
     engines: {node: '>= 0.4'}
 
   string.prototype.repeat@1.0.0:
     resolution: {integrity: sha512-0u/TldDbKD8bFCQ/4f5+mNRrXwZ8hg2w7ZR8wa16e8z9XpePWl3eGEcUD0OXpEH/VJH/2G3gjUtR3ZOiBe2S/w==}
 
-  string.prototype.trim@1.2.10:
-    resolution: {integrity: sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==}
+  string.prototype.trim@1.2.11:
+    resolution: {integrity: sha512-PwvK7BU+CMTJGYQCTZb5RWXIML92lftJLhQz1tBzgKiqGxJaMlBAa48POXaNAC2s4y8jr3EFqrkF9+44neS46w==}
     engines: {node: '>= 0.4'}
 
-  string.prototype.trimend@1.0.9:
-    resolution: {integrity: sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==}
+  string.prototype.trimend@1.0.10:
+    resolution: {integrity: sha512-2+3aDAOmPTmuFwjDnmJG2ctEkQKVki7vOSqaxkv42Mowj1V6PnvuwFCRrR5lChUux1TBskPjfkeTOhqczDMxTw==}
     engines: {node: '>= 0.4'}
 
   string.prototype.trimstart@1.0.8:
@@ -2273,10 +2302,6 @@ packages:
     resolution: {integrity: sha512-QKAl9m8gWWGHV8jZcPeym6j+XULi6tOf1mT83WYJ4Lk2ytW/uwAWkrP0uFsdoYMdueVJ0qs26wZ+23xeB4ibNQ==}
     engines: {node: '>=18'}
 
-  tinyglobby@0.2.15:
-    resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
-    engines: {node: '>=12.0.0'}
-
   tinyglobby@0.2.17:
     resolution: {integrity: sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==}
     engines: {node: '>=12.0.0'}
@@ -2304,8 +2329,8 @@ packages:
     resolution: {integrity: sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==}
     engines: {node: '>=20'}
 
-  ts-api-utils@2.1.0:
-    resolution: {integrity: sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ==}
+  ts-api-utils@2.5.0:
+    resolution: {integrity: sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==}
     engines: {node: '>=18.12'}
     peerDependencies:
       typescript: '>=4.8.4'
@@ -2332,16 +2357,16 @@ packages:
     resolution: {integrity: sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==}
     engines: {node: '>= 0.4'}
 
-  typed-array-length@1.0.7:
-    resolution: {integrity: sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==}
+  typed-array-length@1.0.8:
+    resolution: {integrity: sha512-phPGCwqr2+Qo0fwniCE8e4pKnGu/yFb5nD5Y8bf0EEeiI5GklnACYA9GFy/DrAeRrKHXvHn+1SUsOWgJp6RO+g==}
     engines: {node: '>= 0.4'}
 
-  typescript-eslint@8.50.0:
-    resolution: {integrity: sha512-Q1/6yNUmCpH94fbgMUMg2/BSAr/6U7GBk61kZTv1/asghQOWOjTlp9K8mixS5NcJmm2creY+UFfGeW/+OcA64A==}
+  typescript-eslint@8.69.0:
+    resolution: {integrity: sha512-B3MltX0VqjUBNEe3b3sSuiRbfa6XrfHFtBiPamjT5AsW/dfq+y+bc0wyuS9DxAS1LyzCxRp2+rxzpLUvqM2BvA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^8.57.0 || ^9.0.0
-      typescript: '>=4.8.4 <6.0.0'
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.1.0'
 
   typescript@5.9.3:
     resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
@@ -2352,18 +2377,18 @@ packages:
     resolution: {integrity: sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==}
     engines: {node: '>= 0.4'}
 
-  undici-types@7.16.0:
-    resolution: {integrity: sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==}
+  undici-types@7.24.6:
+    resolution: {integrity: sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==}
 
-  undici@8.10.0:
-    resolution: {integrity: sha512-HvltHd7avK13QIw/oLe4qoOLyoVSoafqJ2jYOrtMRBkbYT31eiBQ8O0ehRKZiEZCMEyLFQNIADpgCWC5fALvYQ==}
+  undici@8.10.1:
+    resolution: {integrity: sha512-YQ3WlbqjYMmNpdvDH64jAgLjxuAR9+649calDWhbshYaeQGO2bR4nI94ORJmwI3J9YhoKQnpyGOK+0zlWS5N5Q==}
     engines: {node: '>=22.19.0'}
 
-  unrs-resolver@1.11.1:
-    resolution: {integrity: sha512-bSjt9pjaEBnNiGgc9rUiHGKv5l4/TGzDmYw3RhnkJGtLhbnnA/5qJj7x3dNDCRx/PJxu774LlH8lCOlB4hEfKg==}
+  unrs-resolver@1.12.2:
+    resolution: {integrity: sha512-dmlRxBJJayXjqTwC+JtF1HhJmgf3ftQ3YejFcZrf4+KKtJv0qDsK1pjqaaVjG7wJ5NJ6UVP1OqRMQ71Z4C3rxQ==}
 
-  update-browserslist-db@1.2.3:
-    resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==}
+  update-browserslist-db@1.3.2:
+    resolution: {integrity: sha512-UQ+MSxlhRm1bzjhU+DcuXfjFO1FzNtqhK5+9Yvlp90ItDLk5vT932A0rFu619nf7RVS+Y/VeaUW1jaRDqZ8VJw==}
     hasBin: true
     peerDependencies:
       browserslist: '>= 4.21.0'
@@ -2487,8 +2512,8 @@ packages:
     resolution: {integrity: sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==}
     engines: {node: '>= 0.4'}
 
-  which-typed-array@1.1.19:
-    resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==}
+  which-typed-array@1.1.22:
+    resolution: {integrity: sha512-fvO4ExWMFsqyhG3AiPAObMuY1lxaqgYcxbc49CNdWDDECOJNgQyvsOWVwbZc+qf3rzRtxojBK+CMEv0Ld5CYpw==}
     engines: {node: '>= 0.4'}
 
   which@2.0.2:
@@ -2525,8 +2550,8 @@ packages:
     peerDependencies:
       zod: ^3.25.0 || ^4.0.0
 
-  zod@4.2.1:
-    resolution: {integrity: sha512-0wZ1IRqGGhMP76gLqz8EyfBXKk0J2qo2+H3fi4mcUP/KtTocoX08nmIAHl1Z2kJIZbZee8KOpBCSNPRgauucjw==}
+  zod@4.5.4:
+    resolution: {integrity: sha512-sC95tT5iHHH9gtpj6A81kh+NEaRAUFN+qlUPDUbRfOMvNf5QCBqsb3WgvnpVtK5Y+4UfA6KqufotuTvMGiTlsA==}
 
 snapshots:
 
@@ -2535,7 +2560,7 @@ snapshots:
   '@asamuzakjp/css-color@6.0.7':
     dependencies:
       '@csstools/css-calc': 3.3.0(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
-      '@csstools/css-color-parser': 4.2.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-color-parser': 4.2.2(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
       '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
       '@csstools/css-tokenizer': 4.0.0
       lru-cache: 11.5.2
@@ -2547,16 +2572,16 @@ snapshots:
       is-potential-custom-element-name: 1.0.1
       lru-cache: 11.5.2
 
-  '@aws-sdk/client-dynamodb@3.1120.0':
+  '@aws-sdk/client-dynamodb@3.1124.0':
     dependencies:
       '@aws-sdk/core': 3.977.9
-      '@aws-sdk/credential-provider-node': 3.972.81
+      '@aws-sdk/credential-provider-node': 3.972.82
       '@aws-sdk/dynamodb-codec': 3.973.44
       '@aws-sdk/middleware-endpoint-discovery': 3.972.30
       '@aws-sdk/types': 3.974.5
       '@smithy/core': 3.33.3
       '@smithy/fetch-http-handler': 5.7.2
-      '@smithy/node-http-handler': 4.11.3
+      '@smithy/node-http-handler': 4.12.0
       '@smithy/types': 4.17.2
       tslib: 2.8.1
 
@@ -2568,7 +2593,7 @@ snapshots:
       '@smithy/core': 3.33.3
       '@smithy/signature-v4': 5.7.3
       '@smithy/types': 4.17.2
-      bowser: 2.13.1
+      bowser: 2.14.1
       tslib: 2.8.1
 
   '@aws-sdk/credential-provider-env@3.972.70':
@@ -2585,7 +2610,7 @@ snapshots:
       '@aws-sdk/types': 3.974.5
       '@smithy/core': 3.33.3
       '@smithy/fetch-http-handler': 5.7.2
-      '@smithy/node-http-handler': 4.11.3
+      '@smithy/node-http-handler': 4.12.0
       '@smithy/types': 4.17.2
       tslib: 2.8.1
 
@@ -2614,7 +2639,7 @@ snapshots:
       '@smithy/types': 4.17.2
       tslib: 2.8.1
 
-  '@aws-sdk/credential-provider-node@3.972.81':
+  '@aws-sdk/credential-provider-node@3.972.82':
     dependencies:
       '@aws-sdk/credential-provider-env': 3.972.70
       '@aws-sdk/credential-provider-http': 3.972.72
@@ -2667,11 +2692,11 @@ snapshots:
       mnemonist: 0.38.3
       tslib: 2.8.1
 
-  '@aws-sdk/lib-dynamodb@3.1120.0(@aws-sdk/client-dynamodb@3.1120.0)':
+  '@aws-sdk/lib-dynamodb@3.1124.0(@aws-sdk/client-dynamodb@3.1124.0)':
     dependencies:
-      '@aws-sdk/client-dynamodb': 3.1120.0
+      '@aws-sdk/client-dynamodb': 3.1124.0
       '@aws-sdk/core': 3.977.9
-      '@aws-sdk/util-dynamodb': 3.996.9(@aws-sdk/client-dynamodb@3.1120.0)
+      '@aws-sdk/util-dynamodb': 3.996.9(@aws-sdk/client-dynamodb@3.1124.0)
       '@smithy/core': 3.33.3
       '@smithy/types': 4.17.2
       tslib: 2.8.1
@@ -2691,7 +2716,7 @@ snapshots:
       '@aws-sdk/types': 3.974.5
       '@smithy/core': 3.33.3
       '@smithy/fetch-http-handler': 5.7.2
-      '@smithy/node-http-handler': 4.11.3
+      '@smithy/node-http-handler': 4.12.0
       '@smithy/types': 4.17.2
       tslib: 2.8.1
 
@@ -2716,9 +2741,9 @@ snapshots:
       '@smithy/types': 4.17.2
       tslib: 2.8.1
 
-  '@aws-sdk/util-dynamodb@3.996.9(@aws-sdk/client-dynamodb@3.1120.0)':
+  '@aws-sdk/util-dynamodb@3.996.9(@aws-sdk/client-dynamodb@3.1124.0)':
     dependencies:
-      '@aws-sdk/client-dynamodb': 3.1120.0
+      '@aws-sdk/client-dynamodb': 3.1124.0
       tslib: 2.8.1
 
   '@aws-sdk/xml-builder@3.972.40':
@@ -2728,25 +2753,25 @@ snapshots:
 
   '@aws/lambda-invoke-store@0.3.0': {}
 
-  '@babel/code-frame@7.27.1':
+  '@babel/code-frame@7.29.7':
     dependencies:
-      '@babel/helper-validator-identifier': 7.28.5
+      '@babel/helper-validator-identifier': 7.29.7
       js-tokens: 4.0.0
       picocolors: 1.1.1
 
-  '@babel/compat-data@7.28.5': {}
+  '@babel/compat-data@7.29.7': {}
 
-  '@babel/core@7.28.5':
+  '@babel/core@7.29.7':
     dependencies:
-      '@babel/code-frame': 7.27.1
-      '@babel/generator': 7.28.5
-      '@babel/helper-compilation-targets': 7.27.2
-      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.5)
-      '@babel/helpers': 7.28.4
-      '@babel/parser': 7.28.5
-      '@babel/template': 7.27.2
-      '@babel/traverse': 7.28.5
-      '@babel/types': 7.28.5
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.8
+      '@babel/helper-compilation-targets': 7.29.7
+      '@babel/helper-module-transforms': 7.29.7(@babel/core@7.29.7)
+      '@babel/helpers': 7.29.7
+      '@babel/parser': 7.29.8
+      '@babel/template': 7.29.7
+      '@babel/traverse': 7.29.8
+      '@babel/types': 7.29.8
       '@jridgewell/remapping': 2.3.5
       convert-source-map: 2.0.0
       debug: 4.4.3
@@ -2756,79 +2781,79 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/generator@7.28.5':
+  '@babel/generator@7.29.8':
     dependencies:
-      '@babel/parser': 7.28.5
-      '@babel/types': 7.28.5
+      '@babel/parser': 7.29.8
+      '@babel/types': 7.29.8
       '@jridgewell/gen-mapping': 0.3.13
       '@jridgewell/trace-mapping': 0.3.31
       jsesc: 3.1.0
 
-  '@babel/helper-compilation-targets@7.27.2':
+  '@babel/helper-compilation-targets@7.29.7':
     dependencies:
-      '@babel/compat-data': 7.28.5
-      '@babel/helper-validator-option': 7.27.1
-      browserslist: 4.28.1
+      '@babel/compat-data': 7.29.7
+      '@babel/helper-validator-option': 7.29.7
+      browserslist: 4.28.8
       lru-cache: 5.1.1
       semver: 6.3.1
 
-  '@babel/helper-globals@7.28.0': {}
+  '@babel/helper-globals@7.29.7': {}
 
-  '@babel/helper-module-imports@7.27.1':
+  '@babel/helper-module-imports@7.29.7':
     dependencies:
-      '@babel/traverse': 7.28.5
-      '@babel/types': 7.28.5
+      '@babel/traverse': 7.29.8
+      '@babel/types': 7.29.8
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-module-transforms@7.28.3(@babel/core@7.28.5)':
+  '@babel/helper-module-transforms@7.29.7(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.28.5
-      '@babel/helper-module-imports': 7.27.1
-      '@babel/helper-validator-identifier': 7.28.5
-      '@babel/traverse': 7.28.5
+      '@babel/core': 7.29.7
+      '@babel/helper-module-imports': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+      '@babel/traverse': 7.29.8
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-string-parser@7.27.1': {}
+  '@babel/helper-string-parser@7.29.7': {}
 
-  '@babel/helper-validator-identifier@7.28.5': {}
+  '@babel/helper-validator-identifier@7.29.7': {}
 
-  '@babel/helper-validator-option@7.27.1': {}
+  '@babel/helper-validator-option@7.29.7': {}
 
-  '@babel/helpers@7.28.4':
+  '@babel/helpers@7.29.7':
     dependencies:
-      '@babel/template': 7.27.2
-      '@babel/types': 7.28.5
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.8
 
-  '@babel/parser@7.28.5':
+  '@babel/parser@7.29.8':
     dependencies:
-      '@babel/types': 7.28.5
+      '@babel/types': 7.29.8
 
   '@babel/runtime@7.29.7': {}
 
-  '@babel/template@7.27.2':
+  '@babel/template@7.29.7':
     dependencies:
-      '@babel/code-frame': 7.27.1
-      '@babel/parser': 7.28.5
-      '@babel/types': 7.28.5
+      '@babel/code-frame': 7.29.7
+      '@babel/parser': 7.29.8
+      '@babel/types': 7.29.8
 
-  '@babel/traverse@7.28.5':
+  '@babel/traverse@7.29.8':
     dependencies:
-      '@babel/code-frame': 7.27.1
-      '@babel/generator': 7.28.5
-      '@babel/helper-globals': 7.28.0
-      '@babel/parser': 7.28.5
-      '@babel/template': 7.27.2
-      '@babel/types': 7.28.5
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.8
+      '@babel/helper-globals': 7.29.7
+      '@babel/parser': 7.29.8
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.8
       debug: 4.4.3
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/types@7.28.5':
+  '@babel/types@7.29.8':
     dependencies:
-      '@babel/helper-string-parser': 7.27.1
-      '@babel/helper-validator-identifier': 7.28.5
+      '@babel/helper-string-parser': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
 
   '@bramus/specificity@2.4.2':
     dependencies:
@@ -2841,7 +2866,7 @@ snapshots:
       '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
       '@csstools/css-tokenizer': 4.0.0
 
-  '@csstools/css-color-parser@4.2.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)':
+  '@csstools/css-color-parser@4.2.2(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)':
     dependencies:
       '@csstools/color-helpers': 6.1.1
       '@csstools/css-calc': 3.3.0(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
@@ -2852,50 +2877,50 @@ snapshots:
     dependencies:
       '@csstools/css-tokenizer': 4.0.0
 
-  '@csstools/css-syntax-patches-for-csstree@1.1.9(css-tree@3.2.1)':
+  '@csstools/css-syntax-patches-for-csstree@1.1.12(css-tree@3.2.1)':
     optionalDependencies:
       css-tree: 3.2.1
 
   '@csstools/css-tokenizer@4.0.0': {}
 
-  '@emnapi/core@1.7.1':
+  '@emnapi/core@1.10.0':
     dependencies:
-      '@emnapi/wasi-threads': 1.1.0
+      '@emnapi/wasi-threads': 1.2.1
       tslib: 2.8.1
     optional: true
 
-  '@emnapi/runtime@1.11.3':
+  '@emnapi/runtime@1.10.0':
     dependencies:
       tslib: 2.8.1
     optional: true
 
-  '@emnapi/runtime@1.7.1':
+  '@emnapi/runtime@1.11.3':
     dependencies:
       tslib: 2.8.1
     optional: true
 
-  '@emnapi/wasi-threads@1.1.0':
+  '@emnapi/wasi-threads@1.2.1':
     dependencies:
       tslib: 2.8.1
     optional: true
 
-  '@eslint-community/eslint-utils@4.9.0(eslint@9.39.2)':
+  '@eslint-community/eslint-utils@4.10.1(eslint@9.39.5)':
     dependencies:
-      eslint: 9.39.2
+      eslint: 9.39.5
       eslint-visitor-keys: 3.4.3
 
-  '@eslint-community/eslint-utils@4.9.1(eslint@9.39.2)':
+  '@eslint-community/eslint-utils@4.9.1(eslint@9.39.5)':
     dependencies:
-      eslint: 9.39.2
+      eslint: 9.39.5
       eslint-visitor-keys: 3.4.3
 
   '@eslint-community/regexpp@4.12.2': {}
 
-  '@eslint/config-array@0.21.1':
+  '@eslint/config-array@0.21.2':
     dependencies:
       '@eslint/object-schema': 2.1.7
       debug: 4.4.3
-      minimatch: 3.1.2
+      minimatch: 3.1.5
     transitivePeerDependencies:
       - supports-color
 
@@ -2907,21 +2932,21 @@ snapshots:
     dependencies:
       '@types/json-schema': 7.0.15
 
-  '@eslint/eslintrc@3.3.3':
+  '@eslint/eslintrc@3.3.7':
     dependencies:
-      ajv: 6.12.6
+      ajv: 6.15.0
       debug: 4.4.3
       espree: 10.4.0
       globals: 14.0.0
       ignore: 5.3.2
       import-fresh: 3.3.1
-      js-yaml: 4.1.1
-      minimatch: 3.1.2
+      js-yaml: 4.3.2
+      minimatch: 3.1.5
       strip-json-comments: 3.1.1
     transitivePeerDependencies:
       - supports-color
 
-  '@eslint/js@9.39.2': {}
+  '@eslint/js@9.39.5': {}
 
   '@eslint/object-schema@2.1.7': {}
 
@@ -2932,13 +2957,18 @@ snapshots:
 
   '@exodus/bytes@1.15.1': {}
 
-  '@humanfs/core@0.19.1': {}
+  '@humanfs/core@0.19.2':
+    dependencies:
+      '@humanfs/types': 0.15.0
 
-  '@humanfs/node@0.16.7':
+  '@humanfs/node@0.16.8':
     dependencies:
-      '@humanfs/core': 0.19.1
+      '@humanfs/core': 0.19.2
+      '@humanfs/types': 0.15.0
       '@humanwhocodes/retry': 0.4.3
 
+  '@humanfs/types@0.15.0': {}
+
   '@humanwhocodes/module-importer@1.0.1': {}
 
   '@humanwhocodes/retry@0.4.3': {}
@@ -3052,7 +3082,7 @@ snapshots:
 
   '@jridgewell/gen-mapping@0.3.13':
     dependencies:
-      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/sourcemap-codec': 1.6.0
       '@jridgewell/trace-mapping': 0.3.31
 
   '@jridgewell/remapping@2.3.5':
@@ -3062,25 +3092,25 @@ snapshots:
 
   '@jridgewell/resolve-uri@3.1.2': {}
 
-  '@jridgewell/sourcemap-codec@1.5.5': {}
+  '@jridgewell/sourcemap-codec@1.6.0': {}
 
   '@jridgewell/trace-mapping@0.3.31':
     dependencies:
       '@jridgewell/resolve-uri': 3.1.2
-      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/sourcemap-codec': 1.6.0
 
-  '@napi-rs/wasm-runtime@0.2.12':
+  '@napi-rs/wasm-runtime@1.2.3(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)':
     dependencies:
-      '@emnapi/core': 1.7.1
-      '@emnapi/runtime': 1.7.1
-      '@tybys/wasm-util': 0.10.1
+      '@emnapi/core': 1.10.0
+      '@emnapi/runtime': 1.10.0
+      '@tybys/wasm-util': 0.10.3
     optional: true
 
   '@next/env@16.3.3': {}
 
-  '@next/eslint-plugin-next@16.3.3(eslint@9.39.2)':
+  '@next/eslint-plugin-next@16.3.3(eslint@9.39.5)':
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.2)
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.5)
       fast-glob: 3.3.1
     transitivePeerDependencies:
       - eslint
@@ -3119,55 +3149,55 @@ snapshots:
   '@nodelib/fs.walk@1.2.8':
     dependencies:
       '@nodelib/fs.scandir': 2.1.5
-      fastq: 1.19.1
+      fastq: 1.20.3
 
   '@nolyfill/is-core-module@1.0.39': {}
 
-  '@oxc-project/types@0.147.0': {}
+  '@oxc-project/types@0.148.0': {}
 
-  '@rolldown/binding-android-arm-eabi@1.2.6':
+  '@rolldown/binding-android-arm-eabi@1.2.7':
     optional: true
 
-  '@rolldown/binding-android-arm64@1.2.6':
+  '@rolldown/binding-android-arm64@1.2.7':
     optional: true
 
-  '@rolldown/binding-darwin-arm64@1.2.6':
+  '@rolldown/binding-darwin-arm64@1.2.7':
     optional: true
 
-  '@rolldown/binding-darwin-x64@1.2.6':
+  '@rolldown/binding-darwin-x64@1.2.7':
     optional: true
 
-  '@rolldown/binding-freebsd-x64@1.2.6':
+  '@rolldown/binding-freebsd-x64@1.2.7':
     optional: true
 
-  '@rolldown/binding-linux-arm-gnueabihf@1.2.6':
+  '@rolldown/binding-linux-arm-gnueabihf@1.2.7':
     optional: true
 
-  '@rolldown/binding-linux-arm64-gnu@1.2.6':
+  '@rolldown/binding-linux-arm64-gnu@1.2.7':
     optional: true
 
-  '@rolldown/binding-linux-arm64-musl@1.2.6':
+  '@rolldown/binding-linux-arm64-musl@1.2.7':
     optional: true
 
-  '@rolldown/binding-linux-ppc64-gnu@1.2.6':
+  '@rolldown/binding-linux-ppc64-gnu@1.2.7':
     optional: true
 
-  '@rolldown/binding-linux-s390x-gnu@1.2.6':
+  '@rolldown/binding-linux-s390x-gnu@1.2.7':
     optional: true
 
-  '@rolldown/binding-linux-x64-gnu@1.2.6':
+  '@rolldown/binding-linux-x64-gnu@1.2.7':
     optional: true
 
-  '@rolldown/binding-linux-x64-musl@1.2.6':
+  '@rolldown/binding-linux-x64-musl@1.2.7':
     optional: true
 
-  '@rolldown/binding-openharmony-arm64@1.2.6':
+  '@rolldown/binding-openharmony-arm64@1.2.7':
     optional: true
 
-  '@rolldown/binding-win32-arm64-msvc@1.2.6':
+  '@rolldown/binding-win32-arm64-msvc@1.2.7':
     optional: true
 
-  '@rolldown/binding-win32-x64-msvc@1.2.6':
+  '@rolldown/binding-win32-x64-msvc@1.2.7':
     optional: true
 
   '@rolldown/pluginutils@1.0.1': {}
@@ -3191,7 +3221,7 @@ snapshots:
       '@smithy/types': 4.17.2
       tslib: 2.8.1
 
-  '@smithy/node-http-handler@4.11.3':
+  '@smithy/node-http-handler@4.12.0':
     dependencies:
       '@smithy/core': 3.33.3
       '@smithy/types': 4.17.2
@@ -3215,7 +3245,7 @@ snapshots:
 
   '@testing-library/dom@10.4.1':
     dependencies:
-      '@babel/code-frame': 7.27.1
+      '@babel/code-frame': 7.29.7
       '@babel/runtime': 7.29.7
       '@types/aria-query': 5.0.4
       aria-query: 5.3.0
@@ -3224,7 +3254,7 @@ snapshots:
       picocolors: 1.1.1
       pretty-format: 27.5.1
 
-  '@testing-library/jest-dom@7.0.1(@testing-library/dom@10.4.1)(vitest@4.1.11(@types/node@25.0.3)(jsdom@30.0.1)(vite@8.2.2(@types/node@25.0.3)))':
+  '@testing-library/jest-dom@7.0.1(@testing-library/dom@10.4.1)(vitest@4.1.11(@types/node@25.9.5)(jsdom@30.0.1)(vite@8.2.2(@types/node@25.9.5)))':
     dependencies:
       '@adobe/css-tools': 4.5.0
       '@testing-library/dom': 10.4.1
@@ -3234,23 +3264,23 @@ snapshots:
       picocolors: 1.1.1
       redent: 3.0.0
     optionalDependencies:
-      vitest: 4.1.11(@types/node@25.0.3)(jsdom@30.0.1)(vite@8.2.2(@types/node@25.0.3))
+      vitest: 4.1.11(@types/node@25.9.5)(jsdom@30.0.1)(vite@8.2.2(@types/node@25.9.5))
 
-  '@testing-library/react@16.3.3(@testing-library/dom@10.4.1)(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)':
+  '@testing-library/react@16.3.3(@testing-library/dom@10.4.1)(@types/react-dom@19.2.5(@types/react@19.2.18))(@types/react@19.2.18)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)':
     dependencies:
       '@babel/runtime': 7.29.7
       '@testing-library/dom': 10.4.1
       react: 19.2.8
       react-dom: 19.2.8(react@19.2.8)
     optionalDependencies:
-      '@types/react': 19.2.7
-      '@types/react-dom': 19.2.3(@types/react@19.2.7)
+      '@types/react': 19.2.18
+      '@types/react-dom': 19.2.5(@types/react@19.2.18)
 
-  '@testing-library/user-event@14.6.6(@testing-library/dom@10.4.1)':
+  '@testing-library/user-event@14.6.7(@testing-library/dom@10.4.1)':
     dependencies:
       '@testing-library/dom': 10.4.1
 
-  '@tybys/wasm-util@0.10.1':
+  '@tybys/wasm-util@0.10.3':
     dependencies:
       tslib: 2.8.1
     optional: true
@@ -3264,178 +3294,189 @@ snapshots:
 
   '@types/deep-eql@4.0.2': {}
 
-  '@types/estree@1.0.8': {}
+  '@types/estree@1.0.9': {}
 
   '@types/json-schema@7.0.15': {}
 
   '@types/json5@0.0.29': {}
 
-  '@types/node@25.0.3':
+  '@types/node@25.9.5':
     dependencies:
-      undici-types: 7.16.0
+      undici-types: 7.24.6
 
-  '@types/react-dom@19.2.3(@types/react@19.2.7)':
+  '@types/react-dom@19.2.5(@types/react@19.2.18)':
     dependencies:
-      '@types/react': 19.2.7
+      '@types/react': 19.2.18
 
-  '@types/react@19.2.7':
+  '@types/react@19.2.18':
     dependencies:
       csstype: 3.2.3
 
-  '@typescript-eslint/eslint-plugin@8.50.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2)(typescript@5.9.3)':
+  '@typescript-eslint/eslint-plugin@8.69.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5)(typescript@5.9.3)':
     dependencies:
       '@eslint-community/regexpp': 4.12.2
-      '@typescript-eslint/parser': 8.50.0(eslint@9.39.2)(typescript@5.9.3)
-      '@typescript-eslint/scope-manager': 8.50.0
-      '@typescript-eslint/type-utils': 8.50.0(eslint@9.39.2)(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.50.0(eslint@9.39.2)(typescript@5.9.3)
-      '@typescript-eslint/visitor-keys': 8.50.0
-      eslint: 9.39.2
-      ignore: 7.0.5
+      '@typescript-eslint/parser': 8.69.0(eslint@9.39.5)(typescript@5.9.3)
+      '@typescript-eslint/scope-manager': 8.69.0
+      '@typescript-eslint/type-utils': 8.69.0(eslint@9.39.5)(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.69.0(eslint@9.39.5)(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.69.0
+      eslint: 9.39.5
+      ignore: 7.0.8
       natural-compare: 1.4.0
-      ts-api-utils: 2.1.0(typescript@5.9.3)
+      ts-api-utils: 2.5.0(typescript@5.9.3)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3)':
+  '@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/scope-manager': 8.50.0
-      '@typescript-eslint/types': 8.50.0
-      '@typescript-eslint/typescript-estree': 8.50.0(typescript@5.9.3)
-      '@typescript-eslint/visitor-keys': 8.50.0
+      '@typescript-eslint/scope-manager': 8.69.0
+      '@typescript-eslint/types': 8.69.0
+      '@typescript-eslint/typescript-estree': 8.69.0(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.69.0
       debug: 4.4.3
-      eslint: 9.39.2
+      eslint: 9.39.5
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/project-service@8.50.0(typescript@5.9.3)':
+  '@typescript-eslint/project-service@8.69.0(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/tsconfig-utils': 8.50.0(typescript@5.9.3)
-      '@typescript-eslint/types': 8.50.0
+      '@typescript-eslint/tsconfig-utils': 8.69.0(typescript@5.9.3)
+      '@typescript-eslint/types': 8.69.0
       debug: 4.4.3
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/scope-manager@8.50.0':
+  '@typescript-eslint/scope-manager@8.69.0':
     dependencies:
-      '@typescript-eslint/types': 8.50.0
-      '@typescript-eslint/visitor-keys': 8.50.0
+      '@typescript-eslint/types': 8.69.0
+      '@typescript-eslint/visitor-keys': 8.69.0
 
-  '@typescript-eslint/tsconfig-utils@8.50.0(typescript@5.9.3)':
+  '@typescript-eslint/tsconfig-utils@8.69.0(typescript@5.9.3)':
     dependencies:
       typescript: 5.9.3
 
-  '@typescript-eslint/type-utils@8.50.0(eslint@9.39.2)(typescript@5.9.3)':
+  '@typescript-eslint/type-utils@8.69.0(eslint@9.39.5)(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/types': 8.50.0
-      '@typescript-eslint/typescript-estree': 8.50.0(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.50.0(eslint@9.39.2)(typescript@5.9.3)
+      '@typescript-eslint/types': 8.69.0
+      '@typescript-eslint/typescript-estree': 8.69.0(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.69.0(eslint@9.39.5)(typescript@5.9.3)
       debug: 4.4.3
-      eslint: 9.39.2
-      ts-api-utils: 2.1.0(typescript@5.9.3)
+      eslint: 9.39.5
+      ts-api-utils: 2.5.0(typescript@5.9.3)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/types@8.50.0': {}
+  '@typescript-eslint/types@8.69.0': {}
 
-  '@typescript-eslint/typescript-estree@8.50.0(typescript@5.9.3)':
+  '@typescript-eslint/typescript-estree@8.69.0(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/project-service': 8.50.0(typescript@5.9.3)
-      '@typescript-eslint/tsconfig-utils': 8.50.0(typescript@5.9.3)
-      '@typescript-eslint/types': 8.50.0
-      '@typescript-eslint/visitor-keys': 8.50.0
+      '@typescript-eslint/project-service': 8.69.0(typescript@5.9.3)
+      '@typescript-eslint/tsconfig-utils': 8.69.0(typescript@5.9.3)
+      '@typescript-eslint/types': 8.69.0
+      '@typescript-eslint/visitor-keys': 8.69.0
       debug: 4.4.3
-      minimatch: 9.0.5
-      semver: 7.7.3
-      tinyglobby: 0.2.15
-      ts-api-utils: 2.1.0(typescript@5.9.3)
+      minimatch: 10.2.6
+      semver: 7.8.5
+      tinyglobby: 0.2.17
+      ts-api-utils: 2.5.0(typescript@5.9.3)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/utils@8.50.0(eslint@9.39.2)(typescript@5.9.3)':
+  '@typescript-eslint/utils@8.69.0(eslint@9.39.5)(typescript@5.9.3)':
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.2)
-      '@typescript-eslint/scope-manager': 8.50.0
-      '@typescript-eslint/types': 8.50.0
-      '@typescript-eslint/typescript-estree': 8.50.0(typescript@5.9.3)
-      eslint: 9.39.2
+      '@eslint-community/eslint-utils': 4.10.1(eslint@9.39.5)
+      '@typescript-eslint/scope-manager': 8.69.0
+      '@typescript-eslint/types': 8.69.0
+      '@typescript-eslint/typescript-estree': 8.69.0(typescript@5.9.3)
+      eslint: 9.39.5
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/visitor-keys@8.50.0':
+  '@typescript-eslint/visitor-keys@8.69.0':
     dependencies:
-      '@typescript-eslint/types': 8.50.0
-      eslint-visitor-keys: 4.2.1
+      '@typescript-eslint/types': 8.69.0
+      eslint-visitor-keys: 5.0.1
+
+  '@unrs/resolver-binding-android-arm-eabi@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-android-arm64@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-darwin-arm64@1.12.2':
+    optional: true
 
-  '@unrs/resolver-binding-android-arm-eabi@1.11.1':
+  '@unrs/resolver-binding-darwin-x64@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-android-arm64@1.11.1':
+  '@unrs/resolver-binding-freebsd-x64@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-darwin-arm64@1.11.1':
+  '@unrs/resolver-binding-linux-arm-gnueabihf@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-darwin-x64@1.11.1':
+  '@unrs/resolver-binding-linux-arm-musleabihf@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-freebsd-x64@1.11.1':
+  '@unrs/resolver-binding-linux-arm64-gnu@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-linux-arm-gnueabihf@1.11.1':
+  '@unrs/resolver-binding-linux-arm64-musl@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-linux-arm-musleabihf@1.11.1':
+  '@unrs/resolver-binding-linux-loong64-gnu@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-linux-arm64-gnu@1.11.1':
+  '@unrs/resolver-binding-linux-loong64-musl@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-linux-arm64-musl@1.11.1':
+  '@unrs/resolver-binding-linux-ppc64-gnu@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-linux-ppc64-gnu@1.11.1':
+  '@unrs/resolver-binding-linux-riscv64-gnu@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-linux-riscv64-gnu@1.11.1':
+  '@unrs/resolver-binding-linux-riscv64-musl@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-linux-riscv64-musl@1.11.1':
+  '@unrs/resolver-binding-linux-s390x-gnu@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-linux-s390x-gnu@1.11.1':
+  '@unrs/resolver-binding-linux-x64-gnu@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-linux-x64-gnu@1.11.1':
+  '@unrs/resolver-binding-linux-x64-musl@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-linux-x64-musl@1.11.1':
+  '@unrs/resolver-binding-openharmony-arm64@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-wasm32-wasi@1.11.1':
+  '@unrs/resolver-binding-wasm32-wasi@1.12.2':
     dependencies:
-      '@napi-rs/wasm-runtime': 0.2.12
+      '@emnapi/core': 1.10.0
+      '@emnapi/runtime': 1.10.0
+      '@napi-rs/wasm-runtime': 1.2.3(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
     optional: true
 
-  '@unrs/resolver-binding-win32-arm64-msvc@1.11.1':
+  '@unrs/resolver-binding-win32-arm64-msvc@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-win32-ia32-msvc@1.11.1':
+  '@unrs/resolver-binding-win32-ia32-msvc@1.12.2':
     optional: true
 
-  '@unrs/resolver-binding-win32-x64-msvc@1.11.1':
+  '@unrs/resolver-binding-win32-x64-msvc@1.12.2':
     optional: true
 
-  '@vitejs/plugin-react@6.1.0(vite@8.2.2(@types/node@25.0.3))':
+  '@vitejs/plugin-react@6.1.1(vite@8.2.2(@types/node@25.9.5))':
     dependencies:
       '@rolldown/pluginutils': 1.0.1
-      vite: 8.2.2(@types/node@25.0.3)
+      vite: 8.2.2(@types/node@25.9.5)
 
   '@vitest/expect@4.1.11':
     dependencies:
@@ -3446,13 +3487,13 @@ snapshots:
       chai: 6.2.2
       tinyrainbow: 3.1.1
 
-  '@vitest/mocker@4.1.11(vite@8.2.2(@types/node@25.0.3))':
+  '@vitest/mocker@4.1.11(vite@8.2.2(@types/node@25.9.5))':
     dependencies:
       '@vitest/spy': 4.1.11
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
-      vite: 8.2.2(@types/node@25.0.3)
+      vite: 8.2.2(@types/node@25.9.5)
 
   '@vitest/pretty-format@4.1.11':
     dependencies:
@@ -3478,13 +3519,13 @@ snapshots:
       convert-source-map: 2.0.0
       tinyrainbow: 3.1.1
 
-  acorn-jsx@5.3.2(acorn@8.15.0):
+  acorn-jsx@5.3.2(acorn@8.18.0):
     dependencies:
-      acorn: 8.15.0
+      acorn: 8.18.0
 
-  acorn@8.15.0: {}
+  acorn@8.18.0: {}
 
-  ajv@6.12.6:
+  ajv@6.15.0:
     dependencies:
       fast-deep-equal: 3.1.3
       fast-json-stable-stringify: 2.1.0
@@ -3514,62 +3555,62 @@ snapshots:
 
   array-includes@3.1.9:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-abstract: 1.24.1
-      es-object-atoms: 1.1.1
+      es-abstract: 1.24.2
+      es-object-atoms: 1.1.2
       get-intrinsic: 1.3.0
       is-string: 1.1.1
       math-intrinsics: 1.1.0
 
   array.prototype.findlast@1.2.5:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       es-shim-unscopables: 1.1.0
 
   array.prototype.findlastindex@1.2.6:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       es-shim-unscopables: 1.1.0
 
   array.prototype.flat@1.3.3:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
       es-shim-unscopables: 1.1.0
 
   array.prototype.flatmap@1.3.3:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
       es-shim-unscopables: 1.1.0
 
   array.prototype.tosorted@1.1.4:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
       es-errors: 1.3.0
       es-shim-unscopables: 1.1.0
 
   arraybuffer.prototype.slice@1.0.4:
     dependencies:
       array-buffer-byte-length: 1.0.2
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
       es-errors: 1.3.0
       get-intrinsic: 1.3.0
       is-array-buffer: 3.0.5
@@ -3584,49 +3625,49 @@ snapshots:
     dependencies:
       possible-typed-array-names: 1.1.0
 
-  axe-core@4.11.0: {}
+  axe-core@4.13.0: {}
 
   axobject-query@4.1.0: {}
 
   balanced-match@1.0.2: {}
 
-  baseline-browser-mapping@2.11.20: {}
+  balanced-match@4.0.4: {}
 
-  baseline-browser-mapping@2.9.9: {}
+  baseline-browser-mapping@2.11.20: {}
 
   bidi-js@1.0.3:
     dependencies:
       require-from-string: 2.0.2
 
-  bowser@2.13.1: {}
+  bowser@2.14.1: {}
 
-  brace-expansion@1.1.12:
+  brace-expansion@1.1.18:
     dependencies:
       balanced-match: 1.0.2
       concat-map: 0.0.1
 
-  brace-expansion@2.0.2:
+  brace-expansion@5.0.9:
     dependencies:
-      balanced-match: 1.0.2
+      balanced-match: 4.0.4
 
   braces@3.0.3:
     dependencies:
       fill-range: 7.1.1
 
-  browserslist@4.28.1:
+  browserslist@4.28.8:
     dependencies:
-      baseline-browser-mapping: 2.9.9
-      caniuse-lite: 1.0.30001760
-      electron-to-chromium: 1.5.267
-      node-releases: 2.0.27
-      update-browserslist-db: 1.2.3(browserslist@4.28.1)
+      baseline-browser-mapping: 2.11.20
+      caniuse-lite: 1.0.30001810
+      electron-to-chromium: 1.5.420
+      node-releases: 2.0.54
+      update-browserslist-db: 1.3.2(browserslist@4.28.8)
 
   call-bind-apply-helpers@1.0.2:
     dependencies:
       es-errors: 1.3.0
       function-bind: 1.1.2
 
-  call-bind@1.0.8:
+  call-bind@1.0.9:
     dependencies:
       call-bind-apply-helpers: 1.0.2
       es-define-property: 1.0.1
@@ -3640,7 +3681,7 @@ snapshots:
 
   callsites@3.1.0: {}
 
-  caniuse-lite@1.0.30001760: {}
+  caniuse-lite@1.0.30001810: {}
 
   chai@6.2.2: {}
 
@@ -3745,28 +3786,35 @@ snapshots:
       es-errors: 1.3.0
       gopd: 1.2.0
 
-  electron-to-chromium@1.5.267: {}
+  electron-to-chromium@1.5.420: {}
 
   emoji-regex@9.2.2: {}
 
   entities@8.0.0: {}
 
-  es-abstract@1.24.1:
+  es-abstract-get@1.0.0:
+    dependencies:
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.2
+      is-callable: 1.2.7
+      object-inspect: 1.13.4
+
+  es-abstract@1.24.2:
     dependencies:
       array-buffer-byte-length: 1.0.2
       arraybuffer.prototype.slice: 1.0.4
       available-typed-arrays: 1.0.7
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       data-view-buffer: 1.0.2
       data-view-byte-length: 1.0.2
       data-view-byte-offset: 1.0.1
       es-define-property: 1.0.1
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       es-set-tostringtag: 2.1.0
-      es-to-primitive: 1.3.0
-      function.prototype.name: 1.1.8
+      es-to-primitive: 1.3.4
+      function.prototype.name: 1.2.0
       get-intrinsic: 1.3.0
       get-proto: 1.0.1
       get-symbol-description: 1.1.0
@@ -3775,7 +3823,7 @@ snapshots:
       has-property-descriptors: 1.0.2
       has-proto: 1.2.0
       has-symbols: 1.1.0
-      hasown: 2.0.2
+      hasown: 2.0.4
       internal-slot: 1.1.0
       is-array-buffer: 3.0.5
       is-callable: 1.2.7
@@ -3791,33 +3839,33 @@ snapshots:
       object-inspect: 1.13.4
       object-keys: 1.1.1
       object.assign: 4.1.7
-      own-keys: 1.0.1
+      own-keys: 1.0.2
       regexp.prototype.flags: 1.5.4
-      safe-array-concat: 1.1.3
+      safe-array-concat: 1.1.4
       safe-push-apply: 1.0.0
       safe-regex-test: 1.1.0
       set-proto: 1.0.0
       stop-iteration-iterator: 1.1.0
-      string.prototype.trim: 1.2.10
-      string.prototype.trimend: 1.0.9
+      string.prototype.trim: 1.2.11
+      string.prototype.trimend: 1.0.10
       string.prototype.trimstart: 1.0.8
       typed-array-buffer: 1.0.3
       typed-array-byte-length: 1.0.3
       typed-array-byte-offset: 1.0.4
-      typed-array-length: 1.0.7
+      typed-array-length: 1.0.8
       unbox-primitive: 1.1.0
-      which-typed-array: 1.1.19
+      which-typed-array: 1.1.22
 
   es-define-property@1.0.1: {}
 
   es-errors@1.3.0: {}
 
-  es-iterator-helpers@1.2.2:
+  es-iterator-helpers@1.4.0:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
       es-errors: 1.3.0
       es-set-tostringtag: 2.1.0
       function-bind: 1.1.2
@@ -3829,11 +3877,11 @@ snapshots:
       has-symbols: 1.1.0
       internal-slot: 1.1.0
       iterator.prototype: 1.1.5
-      safe-array-concat: 1.1.3
+      math-intrinsics: 1.1.0
 
   es-module-lexer@2.3.2: {}
 
-  es-object-atoms@1.1.1:
+  es-object-atoms@1.1.2:
     dependencies:
       es-errors: 1.3.0
 
@@ -3842,14 +3890,17 @@ snapshots:
       es-errors: 1.3.0
       get-intrinsic: 1.3.0
       has-tostringtag: 1.0.2
-      hasown: 2.0.2
+      hasown: 2.0.4
 
   es-shim-unscopables@1.1.0:
     dependencies:
-      hasown: 2.0.2
+      hasown: 2.0.4
 
-  es-to-primitive@1.3.0:
+  es-to-primitive@1.3.4:
     dependencies:
+      es-abstract-get: 1.0.0
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
       is-callable: 1.2.7
       is-date-object: 1.1.0
       is-symbol: 1.1.1
@@ -3858,18 +3909,18 @@ snapshots:
 
   escape-string-regexp@4.0.0: {}
 
-  eslint-config-next@16.3.3(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2)(typescript@5.9.3):
+  eslint-config-next@16.3.3(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5)(typescript@5.9.3):
     dependencies:
-      '@next/eslint-plugin-next': 16.3.3(eslint@9.39.2)
-      eslint: 9.39.2
-      eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2))(eslint@9.39.2)
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2))(eslint@9.39.2))(eslint@9.39.2)
-      eslint-plugin-jsx-a11y: 6.10.2(eslint@9.39.2)
-      eslint-plugin-react: 7.37.5(eslint@9.39.2)
-      eslint-plugin-react-hooks: 7.0.1(eslint@9.39.2)
+      '@next/eslint-plugin-next': 16.3.3(eslint@9.39.5)
+      eslint: 9.39.5
+      eslint-import-resolver-node: 0.3.10
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5))(eslint@9.39.5)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5))(eslint@9.39.5))(eslint@9.39.5)
+      eslint-plugin-jsx-a11y: 6.10.2(eslint@9.39.5)
+      eslint-plugin-react: 7.37.5(eslint@9.39.5)
+      eslint-plugin-react-hooks: 7.1.1(eslint@9.39.5)
       globals: 16.4.0
-      typescript-eslint: 8.50.0(eslint@9.39.2)(typescript@5.9.3)
+      typescript-eslint: 8.69.0(eslint@9.39.5)(typescript@5.9.3)
     optionalDependencies:
       typescript: 5.9.3
     transitivePeerDependencies:
@@ -3878,41 +3929,41 @@ snapshots:
       - eslint-plugin-import-x
       - supports-color
 
-  eslint-import-resolver-node@0.3.9:
+  eslint-import-resolver-node@0.3.10:
     dependencies:
       debug: 3.2.7
-      is-core-module: 2.16.1
-      resolve: 1.22.11
+      is-core-module: 2.16.2
+      resolve: 2.0.0-next.7
     transitivePeerDependencies:
       - supports-color
 
-  eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2))(eslint@9.39.2):
+  eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5))(eslint@9.39.5):
     dependencies:
       '@nolyfill/is-core-module': 1.0.39
       debug: 4.4.3
-      eslint: 9.39.2
-      get-tsconfig: 4.13.0
+      eslint: 9.39.5
+      get-tsconfig: 4.14.3
       is-bun-module: 2.0.0
       stable-hash: 0.0.5
-      tinyglobby: 0.2.15
-      unrs-resolver: 1.11.1
+      tinyglobby: 0.2.17
+      unrs-resolver: 1.12.2
     optionalDependencies:
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2))(eslint@9.39.2))(eslint@9.39.2)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5))(eslint@9.39.5))(eslint@9.39.5)
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2))(eslint@9.39.2))(eslint@9.39.2):
+  eslint-module-utils@2.14.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5))(eslint@9.39.5))(eslint@9.39.5):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
-      '@typescript-eslint/parser': 8.50.0(eslint@9.39.2)(typescript@5.9.3)
-      eslint: 9.39.2
-      eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2))(eslint@9.39.2)
+      '@typescript-eslint/parser': 8.69.0(eslint@9.39.5)(typescript@5.9.3)
+      eslint: 9.39.5
+      eslint-import-resolver-node: 0.3.10
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5))(eslint@9.39.5)
     transitivePeerDependencies:
       - supports-color
 
-  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2))(eslint@9.39.2))(eslint@9.39.2):
+  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5))(eslint@9.39.5))(eslint@9.39.5):
     dependencies:
       '@rtsao/scc': 1.1.0
       array-includes: 3.1.9
@@ -3921,76 +3972,76 @@ snapshots:
       array.prototype.flatmap: 1.3.3
       debug: 3.2.7
       doctrine: 2.1.0
-      eslint: 9.39.2
-      eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2))(eslint@9.39.2))(eslint@9.39.2)
-      hasown: 2.0.2
-      is-core-module: 2.16.1
+      eslint: 9.39.5
+      eslint-import-resolver-node: 0.3.10
+      eslint-module-utils: 2.14.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5))(eslint@9.39.5))(eslint@9.39.5)
+      hasown: 2.0.4
+      is-core-module: 2.16.2
       is-glob: 4.0.3
-      minimatch: 3.1.2
+      minimatch: 3.1.5
       object.fromentries: 2.0.8
       object.groupby: 1.0.3
       object.values: 1.2.1
       semver: 6.3.1
-      string.prototype.trimend: 1.0.9
+      string.prototype.trimend: 1.0.10
       tsconfig-paths: 3.15.0
     optionalDependencies:
-      '@typescript-eslint/parser': 8.50.0(eslint@9.39.2)(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.69.0(eslint@9.39.5)(typescript@5.9.3)
     transitivePeerDependencies:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
       - supports-color
 
-  eslint-plugin-jsx-a11y@6.10.2(eslint@9.39.2):
+  eslint-plugin-jsx-a11y@6.10.2(eslint@9.39.5):
     dependencies:
       aria-query: 5.3.2
       array-includes: 3.1.9
       array.prototype.flatmap: 1.3.3
       ast-types-flow: 0.0.8
-      axe-core: 4.11.0
+      axe-core: 4.13.0
       axobject-query: 4.1.0
       damerau-levenshtein: 1.0.8
       emoji-regex: 9.2.2
-      eslint: 9.39.2
-      hasown: 2.0.2
+      eslint: 9.39.5
+      hasown: 2.0.4
       jsx-ast-utils: 3.3.5
       language-tags: 1.0.9
-      minimatch: 3.1.2
+      minimatch: 3.1.5
       object.fromentries: 2.0.8
       safe-regex-test: 1.1.0
       string.prototype.includes: 2.0.1
 
-  eslint-plugin-react-hooks@7.0.1(eslint@9.39.2):
+  eslint-plugin-react-hooks@7.1.1(eslint@9.39.5):
     dependencies:
-      '@babel/core': 7.28.5
-      '@babel/parser': 7.28.5
-      eslint: 9.39.2
+      '@babel/core': 7.29.7
+      '@babel/parser': 7.29.8
+      eslint: 9.39.5
       hermes-parser: 0.25.1
-      zod: 4.2.1
-      zod-validation-error: 4.0.2(zod@4.2.1)
+      zod: 4.5.4
+      zod-validation-error: 4.0.2(zod@4.5.4)
     transitivePeerDependencies:
       - supports-color
 
-  eslint-plugin-react@7.37.5(eslint@9.39.2):
+  eslint-plugin-react@7.37.5(eslint@9.39.5):
     dependencies:
       array-includes: 3.1.9
       array.prototype.findlast: 1.2.5
       array.prototype.flatmap: 1.3.3
       array.prototype.tosorted: 1.1.4
       doctrine: 2.1.0
-      es-iterator-helpers: 1.2.2
-      eslint: 9.39.2
+      es-iterator-helpers: 1.4.0
+      eslint: 9.39.5
       estraverse: 5.3.0
-      hasown: 2.0.2
+      hasown: 2.0.4
       jsx-ast-utils: 3.3.5
-      minimatch: 3.1.2
+      minimatch: 3.1.5
       object.entries: 1.1.9
       object.fromentries: 2.0.8
       object.values: 1.2.1
       prop-types: 15.8.1
-      resolve: 2.0.0-next.5
+      resolve: 2.0.0-next.7
       semver: 6.3.1
-      string.prototype.matchall: 4.0.12
+      string.prototype.matchall: 4.1.0
       string.prototype.repeat: 1.0.0
 
   eslint-scope@8.4.0:
@@ -4002,21 +4053,23 @@ snapshots:
 
   eslint-visitor-keys@4.2.1: {}
 
-  eslint@9.39.2:
+  eslint-visitor-keys@5.0.1: {}
+
+  eslint@9.39.5:
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.2)
+      '@eslint-community/eslint-utils': 4.10.1(eslint@9.39.5)
       '@eslint-community/regexpp': 4.12.2
-      '@eslint/config-array': 0.21.1
+      '@eslint/config-array': 0.21.2
       '@eslint/config-helpers': 0.4.2
       '@eslint/core': 0.17.0
-      '@eslint/eslintrc': 3.3.3
-      '@eslint/js': 9.39.2
+      '@eslint/eslintrc': 3.3.7
+      '@eslint/js': 9.39.5
       '@eslint/plugin-kit': 0.4.1
-      '@humanfs/node': 0.16.7
+      '@humanfs/node': 0.16.8
       '@humanwhocodes/module-importer': 1.0.1
       '@humanwhocodes/retry': 0.4.3
-      '@types/estree': 1.0.8
-      ajv: 6.12.6
+      '@types/estree': 1.0.9
+      ajv: 6.15.0
       chalk: 4.1.2
       cross-spawn: 7.0.6
       debug: 4.4.3
@@ -4024,7 +4077,7 @@ snapshots:
       eslint-scope: 8.4.0
       eslint-visitor-keys: 4.2.1
       espree: 10.4.0
-      esquery: 1.6.0
+      esquery: 1.7.0
       esutils: 2.0.3
       fast-deep-equal: 3.1.3
       file-entry-cache: 8.0.0
@@ -4035,7 +4088,7 @@ snapshots:
       is-glob: 4.0.3
       json-stable-stringify-without-jsonify: 1.0.1
       lodash.merge: 4.6.2
-      minimatch: 3.1.2
+      minimatch: 3.1.5
       natural-compare: 1.4.0
       optionator: 0.9.4
     transitivePeerDependencies:
@@ -4043,11 +4096,11 @@ snapshots:
 
   espree@10.4.0:
     dependencies:
-      acorn: 8.15.0
-      acorn-jsx: 5.3.2(acorn@8.15.0)
+      acorn: 8.18.0
+      acorn-jsx: 5.3.2(acorn@8.18.0)
       eslint-visitor-keys: 4.2.1
 
-  esquery@1.6.0:
+  esquery@1.7.0:
     dependencies:
       estraverse: 5.3.0
 
@@ -4059,7 +4112,7 @@ snapshots:
 
   estree-walker@3.0.3:
     dependencies:
-      '@types/estree': 1.0.8
+      '@types/estree': 1.0.9
 
   esutils@2.0.3: {}
 
@@ -4079,14 +4132,10 @@ snapshots:
 
   fast-levenshtein@2.0.6: {}
 
-  fastq@1.19.1:
+  fastq@1.20.3:
     dependencies:
       reusify: 1.1.0
 
-  fdir@6.5.0(picomatch@4.0.3):
-    optionalDependencies:
-      picomatch: 4.0.3
-
   fdir@6.5.0(picomatch@4.0.7):
     optionalDependencies:
       picomatch: 4.0.7
@@ -4106,10 +4155,10 @@ snapshots:
 
   flat-cache@4.0.1:
     dependencies:
-      flatted: 3.3.3
+      flatted: 3.4.4
       keyv: 4.5.4
 
-  flatted@3.3.3: {}
+  flatted@3.4.4: {}
 
   for-each@0.3.5:
     dependencies:
@@ -4120,14 +4169,17 @@ snapshots:
 
   function-bind@1.1.2: {}
 
-  function.prototype.name@1.1.8:
+  function.prototype.name@1.2.0:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
-      define-properties: 1.2.1
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
       functions-have-names: 1.2.3
-      hasown: 2.0.2
+      has-property-descriptors: 1.0.2
+      hasown: 2.0.4
       is-callable: 1.2.7
+      is-document.all: 1.0.0
 
   functions-have-names@1.2.3: {}
 
@@ -4140,18 +4192,18 @@ snapshots:
       call-bind-apply-helpers: 1.0.2
       es-define-property: 1.0.1
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       function-bind: 1.1.2
       get-proto: 1.0.1
       gopd: 1.2.0
       has-symbols: 1.1.0
-      hasown: 2.0.2
+      hasown: 2.0.4
       math-intrinsics: 1.1.0
 
   get-proto@1.0.1:
     dependencies:
       dunder-proto: 1.0.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
   get-symbol-description@1.1.0:
     dependencies:
@@ -4159,7 +4211,7 @@ snapshots:
       es-errors: 1.3.0
       get-intrinsic: 1.3.0
 
-  get-tsconfig@4.13.0:
+  get-tsconfig@4.14.3:
     dependencies:
       resolve-pkg-maps: 1.0.0
 
@@ -4200,7 +4252,7 @@ snapshots:
     dependencies:
       has-symbols: 1.1.0
 
-  hasown@2.0.2:
+  hasown@2.0.4:
     dependencies:
       function-bind: 1.1.2
 
@@ -4218,7 +4270,7 @@ snapshots:
 
   ignore@5.3.2: {}
 
-  ignore@7.0.5: {}
+  ignore@7.0.8: {}
 
   import-fresh@3.3.1:
     dependencies:
@@ -4232,12 +4284,12 @@ snapshots:
   internal-slot@1.1.0:
     dependencies:
       es-errors: 1.3.0
-      hasown: 2.0.2
-      side-channel: 1.1.0
+      hasown: 2.0.4
+      side-channel: 1.1.1
 
   is-array-buffer@3.0.5:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       get-intrinsic: 1.3.0
 
@@ -4260,13 +4312,13 @@ snapshots:
 
   is-bun-module@2.0.0:
     dependencies:
-      semver: 7.7.3
+      semver: 7.8.5
 
   is-callable@1.2.7: {}
 
-  is-core-module@2.16.1:
+  is-core-module@2.16.2:
     dependencies:
-      hasown: 2.0.2
+      hasown: 2.0.4
 
   is-data-view@1.0.2:
     dependencies:
@@ -4279,6 +4331,10 @@ snapshots:
       call-bound: 1.0.4
       has-tostringtag: 1.0.2
 
+  is-document.all@1.0.0:
+    dependencies:
+      call-bound: 1.0.4
+
   is-extglob@2.1.1: {}
 
   is-finalizationregistry@1.1.1:
@@ -4315,7 +4371,7 @@ snapshots:
       call-bound: 1.0.4
       gopd: 1.2.0
       has-tostringtag: 1.0.2
-      hasown: 2.0.2
+      hasown: 2.0.4
 
   is-set@2.0.3: {}
 
@@ -4336,7 +4392,7 @@ snapshots:
 
   is-typed-array@1.1.15:
     dependencies:
-      which-typed-array: 1.1.19
+      which-typed-array: 1.1.22
 
   is-weakmap@2.0.2: {}
 
@@ -4356,7 +4412,7 @@ snapshots:
   iterator.prototype@1.1.5:
     dependencies:
       define-data-property: 1.1.4
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       get-intrinsic: 1.3.0
       get-proto: 1.0.1
       has-symbols: 1.1.0
@@ -4364,7 +4420,7 @@ snapshots:
 
   js-tokens@4.0.0: {}
 
-  js-yaml@4.1.1:
+  js-yaml@4.3.2:
     dependencies:
       argparse: 2.0.1
 
@@ -4373,7 +4429,7 @@ snapshots:
       '@asamuzakjp/css-color': 6.0.7
       '@asamuzakjp/dom-selector': 8.3.2
       '@bramus/specificity': 2.4.2
-      '@csstools/css-syntax-patches-for-csstree': 1.1.9(css-tree@3.2.1)
+      '@csstools/css-syntax-patches-for-csstree': 1.1.12(css-tree@3.2.1)
       '@exodus/bytes': 1.15.1
       css-tree: 3.2.1
       data-urls: 7.0.0
@@ -4385,7 +4441,7 @@ snapshots:
       saxes: 6.0.0
       symbol-tree: 3.2.4
       tough-cookie: 6.0.2
-      undici: 8.10.0
+      undici: 8.10.1
       w3c-xmlserializer: 5.0.0
       webidl-conversions: 8.0.1
       whatwg-mimetype: 5.0.0
@@ -4499,7 +4555,7 @@ snapshots:
 
   magic-string@0.30.21:
     dependencies:
-      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/sourcemap-codec': 1.6.0
 
   math-intrinsics@1.1.0: {}
 
@@ -4510,17 +4566,17 @@ snapshots:
   micromatch@4.0.8:
     dependencies:
       braces: 3.0.3
-      picomatch: 2.3.1
+      picomatch: 2.3.2
 
   min-indent@1.0.1: {}
 
-  minimatch@3.1.2:
+  minimatch@10.2.6:
     dependencies:
-      brace-expansion: 1.1.12
+      brace-expansion: 5.0.9
 
-  minimatch@9.0.5:
+  minimatch@3.1.5:
     dependencies:
-      brace-expansion: 2.0.2
+      brace-expansion: 1.1.18
 
   minimist@1.2.8: {}
 
@@ -4536,16 +4592,16 @@ snapshots:
 
   natural-compare@1.4.0: {}
 
-  next@16.3.3(@babel/core@7.28.5)(@types/node@25.0.3)(react-dom@19.2.8(react@19.2.8))(react@19.2.8):
+  next@16.3.3(@babel/core@7.29.7)(@types/node@25.9.5)(react-dom@19.2.8(react@19.2.8))(react@19.2.8):
     dependencies:
       '@next/env': 16.3.3
       '@swc/helpers': 0.5.23
       baseline-browser-mapping: 2.11.20
-      caniuse-lite: 1.0.30001760
+      caniuse-lite: 1.0.30001810
       postcss: 8.5.23
       react: 19.2.8
       react-dom: 19.2.8(react@19.2.8)
-      styled-jsx: 5.1.6(@babel/core@7.28.5)(react@19.2.8)
+      styled-jsx: 5.1.6(@babel/core@7.29.7)(react@19.2.8)
     optionalDependencies:
       '@next/swc-darwin-arm64': 16.3.3
       '@next/swc-darwin-x64': 16.3.3
@@ -4555,13 +4611,20 @@ snapshots:
       '@next/swc-linux-x64-musl': 16.3.3
       '@next/swc-win32-arm64-msvc': 16.3.3
       '@next/swc-win32-x64-msvc': 16.3.3
-      sharp: 0.35.4(@types/node@25.0.3)
+      sharp: 0.35.4(@types/node@25.9.5)
     transitivePeerDependencies:
       - '@babel/core'
       - '@types/node'
       - babel-plugin-macros
 
-  node-releases@2.0.27: {}
+  node-exports-info@1.6.2:
+    dependencies:
+      array.prototype.flatmap: 1.3.3
+      es-errors: 1.3.0
+      object.entries: 1.1.9
+      semver: 6.3.1
+
+  node-releases@2.0.54: {}
 
   object-assign@4.1.1: {}
 
@@ -4571,39 +4634,39 @@ snapshots:
 
   object.assign@4.1.7:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       has-symbols: 1.1.0
       object-keys: 1.1.1
 
   object.entries@1.1.9:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
   object.fromentries@2.0.8:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.1
-      es-object-atoms: 1.1.1
+      es-abstract: 1.24.2
+      es-object-atoms: 1.1.2
 
   object.groupby@1.0.3:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
 
   object.values@1.2.1:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
   obliterator@1.6.1: {}
 
@@ -4618,8 +4681,9 @@ snapshots:
       type-check: 0.4.0
       word-wrap: 1.2.5
 
-  own-keys@1.0.1:
+  own-keys@1.0.2:
     dependencies:
+      call-bound: 1.0.4
       get-intrinsic: 1.3.0
       object-keys: 1.1.1
       safe-push-apply: 1.0.0
@@ -4650,9 +4714,7 @@ snapshots:
 
   picocolors@1.1.1: {}
 
-  picomatch@2.3.1: {}
-
-  picomatch@4.0.3: {}
+  picomatch@2.3.2: {}
 
   picomatch@4.0.7: {}
 
@@ -4706,18 +4768,18 @@ snapshots:
 
   reflect.getprototypeof@1.0.10:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       get-intrinsic: 1.3.0
       get-proto: 1.0.1
       which-builtin-type: 1.2.1
 
   regexp.prototype.flags@1.5.4:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
       es-errors: 1.3.0
       get-proto: 1.0.1
@@ -4730,48 +4792,45 @@ snapshots:
 
   resolve-pkg-maps@1.0.0: {}
 
-  resolve@1.22.11:
+  resolve@2.0.0-next.7:
     dependencies:
-      is-core-module: 2.16.1
-      path-parse: 1.0.7
-      supports-preserve-symlinks-flag: 1.0.0
-
-  resolve@2.0.0-next.5:
-    dependencies:
-      is-core-module: 2.16.1
+      es-errors: 1.3.0
+      is-core-module: 2.16.2
+      node-exports-info: 1.6.2
+      object-keys: 1.1.1
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
   reusify@1.1.0: {}
 
-  rolldown@1.2.6:
+  rolldown@1.2.7:
     dependencies:
-      '@oxc-project/types': 0.147.0
+      '@oxc-project/types': 0.148.0
       '@rolldown/pluginutils': 1.0.1
     optionalDependencies:
-      '@rolldown/binding-android-arm-eabi': 1.2.6
-      '@rolldown/binding-android-arm64': 1.2.6
-      '@rolldown/binding-darwin-arm64': 1.2.6
-      '@rolldown/binding-darwin-x64': 1.2.6
-      '@rolldown/binding-freebsd-x64': 1.2.6
-      '@rolldown/binding-linux-arm-gnueabihf': 1.2.6
-      '@rolldown/binding-linux-arm64-gnu': 1.2.6
-      '@rolldown/binding-linux-arm64-musl': 1.2.6
-      '@rolldown/binding-linux-ppc64-gnu': 1.2.6
-      '@rolldown/binding-linux-s390x-gnu': 1.2.6
-      '@rolldown/binding-linux-x64-gnu': 1.2.6
-      '@rolldown/binding-linux-x64-musl': 1.2.6
-      '@rolldown/binding-openharmony-arm64': 1.2.6
-      '@rolldown/binding-win32-arm64-msvc': 1.2.6
-      '@rolldown/binding-win32-x64-msvc': 1.2.6
+      '@rolldown/binding-android-arm-eabi': 1.2.7
+      '@rolldown/binding-android-arm64': 1.2.7
+      '@rolldown/binding-darwin-arm64': 1.2.7
+      '@rolldown/binding-darwin-x64': 1.2.7
+      '@rolldown/binding-freebsd-x64': 1.2.7
+      '@rolldown/binding-linux-arm-gnueabihf': 1.2.7
+      '@rolldown/binding-linux-arm64-gnu': 1.2.7
+      '@rolldown/binding-linux-arm64-musl': 1.2.7
+      '@rolldown/binding-linux-ppc64-gnu': 1.2.7
+      '@rolldown/binding-linux-s390x-gnu': 1.2.7
+      '@rolldown/binding-linux-x64-gnu': 1.2.7
+      '@rolldown/binding-linux-x64-musl': 1.2.7
+      '@rolldown/binding-openharmony-arm64': 1.2.7
+      '@rolldown/binding-win32-arm64-msvc': 1.2.7
+      '@rolldown/binding-win32-x64-msvc': 1.2.7
 
   run-parallel@1.2.0:
     dependencies:
       queue-microtask: 1.2.3
 
-  safe-array-concat@1.1.3:
+  safe-array-concat@1.1.4:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       get-intrinsic: 1.3.0
       has-symbols: 1.1.0
@@ -4796,10 +4855,7 @@ snapshots:
 
   semver@6.3.1: {}
 
-  semver@7.7.3: {}
-
-  semver@7.8.5:
-    optional: true
+  semver@7.8.5: {}
 
   server-only@0.0.1: {}
 
@@ -4823,9 +4879,9 @@ snapshots:
     dependencies:
       dunder-proto: 1.0.1
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
-  sharp@0.35.4(@types/node@25.0.3):
+  sharp@0.35.4(@types/node@25.9.5):
     dependencies:
       '@img/colour': 1.1.0
       detect-libc: 2.1.2
@@ -4856,7 +4912,7 @@ snapshots:
       '@img/sharp-win32-arm64': 0.35.4
       '@img/sharp-win32-ia32': 0.35.4
       '@img/sharp-win32-x64': 0.35.4
-      '@types/node': 25.0.3
+      '@types/node': 25.9.5
     optional: true
 
   shebang-command@2.0.0:
@@ -4865,7 +4921,7 @@ snapshots:
 
   shebang-regex@3.0.0: {}
 
-  side-channel-list@1.0.0:
+  side-channel-list@1.0.1:
     dependencies:
       es-errors: 1.3.0
       object-inspect: 1.13.4
@@ -4885,11 +4941,11 @@ snapshots:
       object-inspect: 1.13.4
       side-channel-map: 1.0.1
 
-  side-channel@1.1.0:
+  side-channel@1.1.1:
     dependencies:
       es-errors: 1.3.0
       object-inspect: 1.13.4
-      side-channel-list: 1.0.0
+      side-channel-list: 1.0.1
       side-channel-map: 1.0.1
       side-channel-weakmap: 1.0.2
 
@@ -4910,53 +4966,54 @@ snapshots:
 
   string.prototype.includes@2.0.1:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
 
-  string.prototype.matchall@4.0.12:
+  string.prototype.matchall@4.1.0:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       get-intrinsic: 1.3.0
       gopd: 1.2.0
       has-symbols: 1.1.0
       internal-slot: 1.1.0
       regexp.prototype.flags: 1.5.4
       set-function-name: 2.0.2
-      side-channel: 1.1.0
+      side-channel: 1.1.1
 
   string.prototype.repeat@1.0.0:
     dependencies:
       define-properties: 1.2.1
-      es-abstract: 1.24.1
+      es-abstract: 1.24.2
 
-  string.prototype.trim@1.2.10:
+  string.prototype.trim@1.2.11:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-data-property: 1.1.4
       define-properties: 1.2.1
-      es-abstract: 1.24.1
-      es-object-atoms: 1.1.1
+      es-abstract: 1.24.2
+      es-object-atoms: 1.1.2
       has-property-descriptors: 1.0.2
+      safe-regex-test: 1.1.0
 
-  string.prototype.trimend@1.0.9:
+  string.prototype.trimend@1.0.10:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
   string.prototype.trimstart@1.0.8:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
   strip-bom@3.0.0: {}
 
@@ -4966,12 +5023,12 @@ snapshots:
 
   strip-json-comments@3.1.1: {}
 
-  styled-jsx@5.1.6(@babel/core@7.28.5)(react@19.2.8):
+  styled-jsx@5.1.6(@babel/core@7.29.7)(react@19.2.8):
     dependencies:
       client-only: 0.0.1
       react: 19.2.8
     optionalDependencies:
-      '@babel/core': 7.28.5
+      '@babel/core': 7.29.7
 
   supports-color@7.2.0:
     dependencies:
@@ -4985,11 +5042,6 @@ snapshots:
 
   tinyexec@1.3.0: {}
 
-  tinyglobby@0.2.15:
-    dependencies:
-      fdir: 6.5.0(picomatch@4.0.3)
-      picomatch: 4.0.3
-
   tinyglobby@0.2.17:
     dependencies:
       fdir: 6.5.0(picomatch@4.0.7)
@@ -5015,7 +5067,7 @@ snapshots:
     dependencies:
       punycode: 2.3.1
 
-  ts-api-utils@2.1.0(typescript@5.9.3):
+  ts-api-utils@2.5.0(typescript@5.9.3):
     dependencies:
       typescript: 5.9.3
 
@@ -5040,7 +5092,7 @@ snapshots:
 
   typed-array-byte-length@1.0.3:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       for-each: 0.3.5
       gopd: 1.2.0
       has-proto: 1.2.0
@@ -5049,29 +5101,29 @@ snapshots:
   typed-array-byte-offset@1.0.4:
     dependencies:
       available-typed-arrays: 1.0.7
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       for-each: 0.3.5
       gopd: 1.2.0
       has-proto: 1.2.0
       is-typed-array: 1.1.15
       reflect.getprototypeof: 1.0.10
 
-  typed-array-length@1.0.7:
+  typed-array-length@1.0.8:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       for-each: 0.3.5
       gopd: 1.2.0
       is-typed-array: 1.1.15
       possible-typed-array-names: 1.1.0
       reflect.getprototypeof: 1.0.10
 
-  typescript-eslint@8.50.0(eslint@9.39.2)(typescript@5.9.3):
+  typescript-eslint@8.69.0(eslint@9.39.5)(typescript@5.9.3):
     dependencies:
-      '@typescript-eslint/eslint-plugin': 8.50.0(@typescript-eslint/parser@8.50.0(eslint@9.39.2)(typescript@5.9.3))(eslint@9.39.2)(typescript@5.9.3)
-      '@typescript-eslint/parser': 8.50.0(eslint@9.39.2)(typescript@5.9.3)
-      '@typescript-eslint/typescript-estree': 8.50.0(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.50.0(eslint@9.39.2)(typescript@5.9.3)
-      eslint: 9.39.2
+      '@typescript-eslint/eslint-plugin': 8.69.0(@typescript-eslint/parser@8.69.0(eslint@9.39.5)(typescript@5.9.3))(eslint@9.39.5)(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.69.0(eslint@9.39.5)(typescript@5.9.3)
+      '@typescript-eslint/typescript-estree': 8.69.0(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.69.0(eslint@9.39.5)(typescript@5.9.3)
+      eslint: 9.39.5
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
@@ -5085,37 +5137,40 @@ snapshots:
       has-symbols: 1.1.0
       which-boxed-primitive: 1.1.1
 
-  undici-types@7.16.0: {}
+  undici-types@7.24.6: {}
 
-  undici@8.10.0: {}
+  undici@8.10.1: {}
 
-  unrs-resolver@1.11.1:
+  unrs-resolver@1.12.2:
     dependencies:
       napi-postinstall: 0.3.4
     optionalDependencies:
-      '@unrs/resolver-binding-android-arm-eabi': 1.11.1
-      '@unrs/resolver-binding-android-arm64': 1.11.1
-      '@unrs/resolver-binding-darwin-arm64': 1.11.1
-      '@unrs/resolver-binding-darwin-x64': 1.11.1
-      '@unrs/resolver-binding-freebsd-x64': 1.11.1
-      '@unrs/resolver-binding-linux-arm-gnueabihf': 1.11.1
-      '@unrs/resolver-binding-linux-arm-musleabihf': 1.11.1
-      '@unrs/resolver-binding-linux-arm64-gnu': 1.11.1
-      '@unrs/resolver-binding-linux-arm64-musl': 1.11.1
-      '@unrs/resolver-binding-linux-ppc64-gnu': 1.11.1
-      '@unrs/resolver-binding-linux-riscv64-gnu': 1.11.1
-      '@unrs/resolver-binding-linux-riscv64-musl': 1.11.1
-      '@unrs/resolver-binding-linux-s390x-gnu': 1.11.1
-      '@unrs/resolver-binding-linux-x64-gnu': 1.11.1
-      '@unrs/resolver-binding-linux-x64-musl': 1.11.1
-      '@unrs/resolver-binding-wasm32-wasi': 1.11.1
-      '@unrs/resolver-binding-win32-arm64-msvc': 1.11.1
-      '@unrs/resolver-binding-win32-ia32-msvc': 1.11.1
-      '@unrs/resolver-binding-win32-x64-msvc': 1.11.1
-
-  update-browserslist-db@1.2.3(browserslist@4.28.1):
-    dependencies:
-      browserslist: 4.28.1
+      '@unrs/resolver-binding-android-arm-eabi': 1.12.2
+      '@unrs/resolver-binding-android-arm64': 1.12.2
+      '@unrs/resolver-binding-darwin-arm64': 1.12.2
+      '@unrs/resolver-binding-darwin-x64': 1.12.2
+      '@unrs/resolver-binding-freebsd-x64': 1.12.2
+      '@unrs/resolver-binding-linux-arm-gnueabihf': 1.12.2
+      '@unrs/resolver-binding-linux-arm-musleabihf': 1.12.2
+      '@unrs/resolver-binding-linux-arm64-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-arm64-musl': 1.12.2
+      '@unrs/resolver-binding-linux-loong64-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-loong64-musl': 1.12.2
+      '@unrs/resolver-binding-linux-ppc64-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-riscv64-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-riscv64-musl': 1.12.2
+      '@unrs/resolver-binding-linux-s390x-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-x64-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-x64-musl': 1.12.2
+      '@unrs/resolver-binding-openharmony-arm64': 1.12.2
+      '@unrs/resolver-binding-wasm32-wasi': 1.12.2
+      '@unrs/resolver-binding-win32-arm64-msvc': 1.12.2
+      '@unrs/resolver-binding-win32-ia32-msvc': 1.12.2
+      '@unrs/resolver-binding-win32-x64-msvc': 1.12.2
+
+  update-browserslist-db@1.3.2(browserslist@4.28.8):
+    dependencies:
+      browserslist: 4.28.8
       escalade: 3.2.0
       picocolors: 1.1.1
 
@@ -5123,21 +5178,21 @@ snapshots:
     dependencies:
       punycode: 2.3.1
 
-  vite@8.2.2(@types/node@25.0.3):
+  vite@8.2.2(@types/node@25.9.5):
     dependencies:
       lightningcss: 1.33.0
       picomatch: 4.0.7
       postcss: 8.5.26
-      rolldown: 1.2.6
+      rolldown: 1.2.7
       tinyglobby: 0.2.17
     optionalDependencies:
-      '@types/node': 25.0.3
+      '@types/node': 25.9.5
       fsevents: 2.3.3
 
-  vitest@4.1.11(@types/node@25.0.3)(jsdom@30.0.1)(vite@8.2.2(@types/node@25.0.3)):
+  vitest@4.1.11(@types/node@25.9.5)(jsdom@30.0.1)(vite@8.2.2(@types/node@25.9.5)):
     dependencies:
       '@vitest/expect': 4.1.11
-      '@vitest/mocker': 4.1.11(vite@8.2.2(@types/node@25.0.3))
+      '@vitest/mocker': 4.1.11(vite@8.2.2(@types/node@25.9.5))
       '@vitest/pretty-format': 4.1.11
       '@vitest/runner': 4.1.11
       '@vitest/snapshot': 4.1.11
@@ -5148,16 +5203,16 @@ snapshots:
       magic-string: 0.30.21
       obug: 2.1.4
       pathe: 2.0.3
-      picomatch: 4.0.3
+      picomatch: 4.0.7
       std-env: 4.2.0
       tinybench: 2.9.0
       tinyexec: 1.3.0
-      tinyglobby: 0.2.15
+      tinyglobby: 0.2.17
       tinyrainbow: 3.1.1
-      vite: 8.2.2(@types/node@25.0.3)
+      vite: 8.2.2(@types/node@25.9.5)
       why-is-node-running: 2.3.0
     optionalDependencies:
-      '@types/node': 25.0.3
+      '@types/node': 25.9.5
       jsdom: 30.0.1
     transitivePeerDependencies:
       - msw
@@ -5197,7 +5252,7 @@ snapshots:
   which-builtin-type@1.2.1:
     dependencies:
       call-bound: 1.0.4
-      function.prototype.name: 1.1.8
+      function.prototype.name: 1.2.0
       has-tostringtag: 1.0.2
       is-async-function: 2.1.1
       is-date-object: 1.1.0
@@ -5208,7 +5263,7 @@ snapshots:
       isarray: 2.0.5
       which-boxed-primitive: 1.1.1
       which-collection: 1.0.2
-      which-typed-array: 1.1.19
+      which-typed-array: 1.1.22
 
   which-collection@1.0.2:
     dependencies:
@@ -5217,10 +5272,10 @@ snapshots:
       is-weakmap: 2.0.2
       is-weakset: 2.0.4
 
-  which-typed-array@1.1.19:
+  which-typed-array@1.1.22:
     dependencies:
       available-typed-arrays: 1.0.7
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       for-each: 0.3.5
       get-proto: 1.0.1
@@ -5246,8 +5301,8 @@ snapshots:
 
   yocto-queue@0.1.0: {}
 
-  zod-validation-error@4.0.2(zod@4.2.1):
+  zod-validation-error@4.0.2(zod@4.5.4):
     dependencies:
-      zod: 4.2.1
+      zod: 4.5.4
 
-  zod@4.2.1: {}
+  zod@4.5.4: {}