feat(admissions): add the cut-off history, map and postcode check

Completes the last-distance-offered feature against the mockup: the
year-by-year record, the same numbers drawn over real streets, and the
reader's own address measured against them.

Serving the history
  The first cut deliberately served only the latest year, because a plain
  series would draw a trend line straight through gaps that are absences of
  publication, not of a cut-off. That reasoning is answered rather than
  abandoned: cutoffYearRows classifies every year in the span, and the chart
  breaks the line rather than interpolating across it.

  A missing year is not one fact but three. It may be unpublished; it may be
  a year the school was not oversubscribed; or there may be no record at all.
  Collapsing them into "no data" throws away the reassuring case and hides
  the important caveat, so each is stated in words in the table.

  The claim is held to what the data supports. fact_admissions.oversubscribed
  compares FIRST PREFERENCES against places, which does not establish that
  every applicant was offered one — so the copy says "places available on
  first preferences" and a test asserts the stronger claim never appears.

The trend summary is not a verdict
  It names both endpoints and their years and lets the reader conclude. It is
  withheld below four published points, and a swing under a tenth of the
  earlier figure is reported as "broadly the same" rather than dressed up as
  a direction.

The postcode check
  This is the only place on the site that answers a question about a family
  rather than a school, so most of the care went into what it refuses to say.
  postcodes.io returns a centroid covering roughly fifteen addresses, which
  against a 500 m cut-off is a fifth of the whole distance — so a margin
  inside 100 m returns "too close to call" rather than a place a family does
  not have. Unpublished years count as unknown, never as a pass. The limits
  are stated before the check is used, not revealed with the answer.

  The postcode is geocoded in the browser and never stored.

Both templates
  Banded and selective secondaries are exactly where this matters most, so
  the detail is shared. The primary page gives it a third tab; the secondary
  page is one flat panel by design and renders it inline.

Absence is explained rather than reported. A selective school's missing
figure is explained by how it admits; a consistently undersubscribed school
reads as good news.

Also makes the batch loader's test double honour ORDER BY. It was a no-op,
so "latest row per URN" was really "first row in the fixture" and the test
would have passed with the sort reversed or removed.

Verified: 214 frontend tests, 54 backend, 45/53 e2e green against staging
(the 8 cut-off journeys skip until the DAG runs). Rendered offline against
the real compiled CSS in both themes and at 390px; every new surface clears
WCAG AA, measured on composited pixels.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WDvkyqqHABm4bmth2kjAxE

backend/app.py

@@ -633,6 +633,7 @@ async def get_school_details(request: Request, urn: int):
         "admissions": supplementary.get("admissions"),
         "admissions_history": supplementary.get("admissions_history") or [],
         "admission_distance": supplementary.get("admission_distance"),
+        "admission_distance_history": supplementary.get("admission_distance_history") or [],
         "sen_detail": supplementary.get("sen_detail"),
         "phonics": supplementary.get("phonics"),
         "deprivation": supplementary.get("deprivation"),

backend/data_loader.py

@@ -771,6 +771,7 @@ def _empty_supplementary() -> dict:
         "admissions": None,
         "admissions_history": [],
         "admission_distance": None,
+        "admission_distance_history": [],
         "sen_detail": None,
         "phonics": None,
         "deprivation": None,
@@ -849,25 +850,29 @@ def get_supplementary_data_batch(db: Session, urns: list[int]) -> dict:
             result[urn]["admissions"] = rows_for_urn[-1] if rows_for_urn else None
     _safe(_admissions)
 
-    # Last distance offered — latest year per URN.
+    # Last distance offered — all years per URN, oldest first, with the latest
+    # also exposed on its own.
     #
-    # Only the most recent year is served. Coverage is ragged (a school may
-    # have 2021 and 2026 but nothing between), so a history array would invite
-    # a trend line drawn through gaps that are absences of publication rather
-    # than absences of a cut-off.
+    # The history was deliberately withheld at first: coverage is ragged (a
+    # school may have 2021 and 2026 and nothing between), and a plain series
+    # would draw a trend line straight through gaps that are absences of
+    # publication rather than absences of a cut-off. It is served now because
+    # the client distinguishes those gaps explicitly — see cutoffYearRows in
+    # lastDistanceOffered.ts, which classifies every year in the range and
+    # breaks the line rather than interpolating across it.
     def _admission_distance():
         rows = (
             db.query(FactAdmissionDistance)
             .filter(FactAdmissionDistance.urn.in_(urns))
-            .order_by(FactAdmissionDistance.urn, FactAdmissionDistance.year.desc())
+            .order_by(FactAdmissionDistance.urn, FactAdmissionDistance.year.asc())
             .all()
         )
-        seen = set()
+        history: dict = {urn: [] for urn in urns}
         for d in rows:
-            if d.urn in seen:
-                continue
-            seen.add(d.urn)
-            result[d.urn]["admission_distance"] = _admission_distance_dict(d)
+            history[d.urn].append(_admission_distance_dict(d))
+        for urn, rows_for_urn in history.items():
+            result[urn]["admission_distance_history"] = rows_for_urn
+            result[urn]["admission_distance"] = rows_for_urn[-1] if rows_for_urn else None
     _safe(_admission_distance)
 
     # Deprivation — one row per URN.

backend/tests/test_supplementary_batch.py

@@ -8,8 +8,31 @@ from backend import data_loader
 from backend.data_loader import get_supplementary_data_batch
 
 
+def _sort_key(criterion):
+    """(column name, descending) for a SQLAlchemy order_by argument.
+
+    A bare column (Model.year) arrives as an InstrumentedAttribute carrying
+    .key; Model.year.desc() wraps it in a UnaryExpression whose column sits on
+    .element.
+    """
+    name = getattr(criterion, "key", None)
+    if name is not None:
+        return name, False
+    element = getattr(criterion, "element", None)
+    name = getattr(element, "key", None)
+    return name, "DESC" in str(criterion).upper()
+
+
 class _FakeQuery:
-    """Records that a query ran and serves canned rows filtered by an in-list."""
+    """Records that a query ran and serves canned rows filtered by an in-list.
+
+    order_by is honoured rather than ignored. The batch loader picks a row per
+    URN by position — first for "latest Ofsted", last for "latest cut-off
+    distance" — which is only correct because the database returned them
+    sorted. A double that drops the ORDER BY makes those picks depend on
+    fixture insertion order instead, so the test would pass with the sort
+    reversed or removed and prove nothing about the query.
+    """
 
     def __init__(self, recorder, model_name, rows):
         self._rec = recorder
@@ -19,7 +42,20 @@ class _FakeQuery:
     def filter(self, *args, **kwargs):
         return self
 
-    def order_by(self, *args, **kwargs):
+    def order_by(self, *criteria):
+        for crit in reversed(criteria):  # reversed = stable multi-key sort
+            name, descending = _sort_key(crit)
+            if not name:
+                continue
+            values = [getattr(r, name, None) for r in self._rows]
+            # Only sort on plainly comparable values. Some fixtures stand dates
+            # up as namespace objects, which raise on <; leaving those in their
+            # given order matches what the real query would produce for them.
+            if not all(isinstance(v, (int, float, str)) for v in values):
+                continue
+            self._rows = sorted(
+                self._rows, key=lambda r: getattr(r, name), reverse=descending
+            )
         return self
 
     def all(self):
@@ -115,8 +151,10 @@ def test_one_query_per_table_and_latest_row_per_urn():
     assert out[1]["admissions"]["year"] == 202627
     assert out[2]["admissions_history"] == [{**out[2]["admissions_history"][0]}]
 
-    # Cut-off distance: latest year only, per URN. Coverage is ragged, so
-    # serving anything but the newest would show a parent a stale figure.
+    # Cut-off distance: full history oldest-first, with the newest year also
+    # exposed on its own. The fixture rows are deliberately out of order, so
+    # this only passes if the query's ORDER BY is doing the work.
+    assert [r["year"] for r in out[1]["admission_distance_history"]] == [2024, 2025, 2026]
     assert out[1]["admission_distance"]["year"] == 2026
     assert out[1]["admission_distance"]["distance_m"] == 529.47
     # route_count travels with the figure — the page needs it to say the
@@ -133,3 +171,4 @@ def test_single_wrapper_matches_batch(monkeypatch):
     assert single["ofsted"]["overall_effectiveness"] == 2
     assert single["admissions_history"] == []
     assert single["admission_distance"] is None
+    assert single["admission_distance_history"] == []