fix(places): phase-grouped tables, plain-English measures, styled links

Three presentation faults on the place pages, all found by looking at a
rendered page rather than at a test.

An unphased place page showed one primary-only measure for a list holding both
phases: 8 of 27 rows on /schools/brentwood were blank, because secondaries
have no reading-writing-maths score. Picking the other measure would only have
inverted which rows were empty, and putting both in one column would have
mixed a percentage with a 0-90 score. Each phase now gets its own table, so a
blank cell means the school genuinely has no published result — which is worth
saying, and now says "Not published" rather than a bare dash.

"RWM expected" was invented here. The site already names the measure in
METRIC_DEFINITIONS, surfaced at /api/metrics: "Reading, Writing & Maths
Combined %". The heading now reads "Reading, writing & maths" with the full
definition in the tooltip.

Links carried no class at all, so they rendered as default blue underlined
browser links beside a site that styles table links as body colour with a
brand hover. They now follow RankingsView's convention, and running-copy links
take the brand colour.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015mWQnpye9F299NVRCCSRvj

backend/app.py

@@ -7,6 +7,7 @@ Uses real data from UK Government Compare School Performance downloads.
 import hashlib
 import re
 from contextlib import asynccontextmanager
+from datetime import datetime, timezone
 from typing import Optional
 
 import numpy as np
@@ -34,6 +35,7 @@ from .data_loader import (
     search_schools_typesense,
 )
 from .data_loader import get_data_info as get_db_info
+from .places import build_place_registry
 from .schemas import METRIC_DEFINITIONS, RANKING_COLUMNS, SCHOOL_COLUMNS
 from .utils import clean_for_json, convert_to_native
 
@@ -48,11 +50,20 @@ PHASE_GROUPS: dict[str, set[str]] = {
     "all-through": {"all-through"},
 }
 
-BASE_URL = "https://schoolcompare.co.uk"
+# Must match SITE_URL in nextjs-app/lib/site.ts. The apex 301s to www, and a
+# sitemap <loc> that redirects wastes a crawl on every URL it lists.
+BASE_URL = "https://www.schoolcompare.co.uk"
 MAX_SLUG_LENGTH = 60
 
-# In-memory sitemap cache
-_sitemap_xml: str | None = None
+# In-memory sitemap cache: name -> XML. Populated on startup and by the admin
+# regenerate endpoint after a pipeline run.
+_sitemaps: dict[str, str] | None = None
+
+# Built from the same DataFrame the sitemap uses, so places and sitemap can
+# never describe different corpora. Reset by the same admin endpoint.
+_place_registry: dict | None = None
+
+VALID_PLACE_KINDS = ("town", "locality", "authority", "outcode")
 
 
 def _slugify(text: str) -> str:
@@ -70,43 +81,206 @@ def _school_url(urn: int, school_name: str) -> str:
     return f"/school/{urn}-{slug}"
 
 
-def build_sitemap() -> str:
-    """Generate sitemap XML from in-memory school data. Returns the XML string."""
-    df = load_school_data()
+# Routes worth submitting that are not a school page. /admissions was missing
+# from the sitemap entirely despite being a static, indexable guide.
+STATIC_SITEMAP_PATHS = ("/", "/rankings", "/compare", "/admissions")
 
-    static_urls = [
-        (BASE_URL + "/",          "daily",   "1.0"),
-        (BASE_URL + "/rankings",  "weekly",  "0.8"),
-        (BASE_URL + "/compare",   "weekly",  "0.8"),
-    ]
 
-    lines = ['<?xml version="1.0" encoding="UTF-8"?>',
-             '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">']
+# A page has something a search result could state if any of these is present
+# in any year. Shared by _has_publishable_data and the per-school check in
+# _school_sitemap_rows so the two can never drift.
+_PUBLISHABLE_FIELDS = ("rwm_expected_pct", "attainment_8_score", "ofsted_grade")
 
-    for url, freq, priority in static_urls:
-        lines.append(
-            f"  <url><loc>{url}</loc>"
-            f"<changefreq>{freq}</changefreq>"
-            f"<priority>{priority}</priority></url>"
+
+def _has_publishable_data(row) -> bool:
+    """True when a school page has something a search result could state.
+
+    A school with no results in any year and no Ofsted grade renders an empty
+    page. Submitting it spends crawl budget and drags the corpus-wide quality
+    signal down, so it stays out of the sitemap. The page itself still resolves
+    for anyone who has the URL.
+    """
+    for field in _PUBLISHABLE_FIELDS:
+        value = row.get(field)
+        if value is not None and not pd.isna(value):
+            return True
+    return False
+
+
+def _url_element(loc: str, lastmod: str | None = None) -> str:
+    """One <url> entry. No priority or changefreq — Google ignores both."""
+    body = f"<loc>{loc}</loc>"
+    if lastmod:
+        body += f"<lastmod>{lastmod}</lastmod>"
+    return f"  <url>{body}</url>"
+
+
+def _school_sitemap_rows(df) -> list[str]:
+    """A <url> element per school that has something to show.
+
+    lastmod comes from the school's Ofsted date where there is one and is
+    omitted otherwise. An always-now lastmod is a claim Google learns to
+    distrust; an absent one honestly means "unknown".
+    """
+    if df.empty or "urn" not in df.columns or "school_name" not in df.columns:
+        return []
+
+    rows: list[str] = []
+    seen: set[int] = set()
+
+    # Publishable is a property of the SCHOOL, not of its latest row.
+    #
+    # The first cut tested the latest year's row alone, which quietly dropped
+    # every school that has results in its history but a null row for the most
+    # recent year — a school that stopped reporting, or whose figures were
+    # suppressed for small-cohort disclosure. The Mallard Academy (150367) is
+    # the case that caught it: real KS2 results for 2015-16 through 2018-19,
+    # then null rows for 2022-23 onward. Its page shows all four years; the
+    # sitemap omitted it. Roughly 220 schools were affected.
+    publishable_cols = [c for c in _PUBLISHABLE_FIELDS if c in df.columns]
+    publishable: set[int] = (
+        set(df.loc[df[publishable_cols].notna().any(axis=1), "urn"].astype(int))
+        if publishable_cols else set()
     )
 
-    if not df.empty and "urn" in df.columns and "school_name" in df.columns:
-        seen = set()
-        for _, row in df[["urn", "school_name"]].drop_duplicates(subset="urn").iterrows():
+    # Latest row per URN first, so a school's most recent Ofsted date wins.
+    ordered = df.sort_values("year", ascending=False) if "year" in df.columns else df
+
+    for _, row in ordered.iterrows():
         urn = int(row["urn"])
-            name = str(row["school_name"])
         if urn in seen:
             continue
         seen.add(urn)
-            path = _school_url(urn, name)
-            lines.append(
-                f"  <url><loc>{BASE_URL}{path}</loc>"
-                f"<changefreq>monthly</changefreq>"
-                f"<priority>0.6</priority></url>"
-            )
+        if urn not in publishable:
+            continue
 
-    lines.append("</urlset>")
-    return "\n".join(lines)
+        lastmod = None
+        ofsted_date = row.get("ofsted_date")
+        if ofsted_date is not None and not pd.isna(ofsted_date):
+            lastmod = pd.Timestamp(ofsted_date).date().isoformat()
+
+        rows.append(_url_element(
+            BASE_URL + _school_url(urn, str(row["school_name"])), lastmod))
+
+    return rows
+
+
+# Sitemaps cap at 50,000 URLs per file. 10,000 keeps a child small enough to
+# scan by eye in Search Console, which is the point of splitting at all:
+# coverage is reported per submitted sitemap, so one file per page family is
+# what makes an indexation problem attributable to a family.
+SITEMAP_CHUNK_SIZE = 10_000
+
+# Children are served under /sitemaps/ because Next.js only treats a whole
+# bracketed path segment as dynamic — a route folder named "sitemap-[...parts]"
+# is read as a literal static segment and never matches.
+SITEMAP_CHILD_PREFIX = "/sitemaps"
+
+
+def get_place_registry() -> dict:
+    """The place registry, built once and cached for the process."""
+    global _place_registry
+    if _place_registry is None:
+        _place_registry = build_place_registry(load_school_data())
+    return _place_registry
+
+
+def _urlset(rows: list[str]) -> str:
+    return "\n".join([
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+        *rows,
+        "</urlset>",
+    ])
+
+
+def _place_url(place) -> str:
+    """The canonical path for a place. Two namespaces, per the spec.
+
+    Towns and localities share /schools/[place]; authorities take their own
+    prefix because 67 town names collide with an authority name and neither
+    set contains the other.
+    """
+    if place.kind == "authority":
+        return f"/schools/authority/{place.slug}"
+    if place.kind == "outcode":
+        return f"/schools/near/{place.slug}"
+    return f"/schools/{place.slug}"
+
+
+def _place_sitemap_rows(kinds: tuple[str, ...]) -> list[str]:
+    """A <url> per place, plus a phase variant wherever that phase clears the
+    threshold on its own.
+
+    Phase is part of the query — "primary schools in beccles" — so each
+    variant is its own indexable page. Submitting only the bare place URL left
+    ~950 of them reachable by nothing: absent from every sitemap, and not
+    linked from the place page either.
+    """
+    rows: list[str] = []
+    for p in sorted(get_place_registry().values(), key=lambda p: (p.kind, p.slug)):
+        if p.kind not in kinds:
+            continue
+        rows.append(_url_element(BASE_URL + _place_url(p)))
+        # Outcodes carry no phase variants: nobody searches "primary schools
+        # in SW11", so the routes do not exist to submit.
+        if p.kind == "outcode":
+            continue
+        for phase in ("primary", "secondary"):
+            if p.publishes_phase(phase):
+                rows.append(_url_element(f"{BASE_URL}{_place_url(p)}/{phase}"))
+    return rows
+
+
+def build_sitemaps() -> dict[str, str]:
+    """Build the sitemap index and every child, keyed by name."""
+    df = load_school_data()
+
+    children: dict[str, str] = {
+        "static.xml": _urlset(
+            [_url_element(BASE_URL + path) for path in STATIC_SITEMAP_PATHS]),
+    }
+
+    school_rows = _school_sitemap_rows(df)
+    # Always emit at least one school child, so the index shape is stable even
+    # on an empty database.
+    chunks = [school_rows[i:i + SITEMAP_CHUNK_SIZE]
+              for i in range(0, len(school_rows), SITEMAP_CHUNK_SIZE)] or [[]]
+    for n, chunk in enumerate(chunks, start=1):
+        children[f"schools-{n}.xml"] = _urlset(chunk)
+
+    # Separate children per family: Search Console reports coverage per
+    # submitted sitemap, which is how the location layer's indexation is
+    # measured apart from the school pages'.
+    for label, kinds in (("places", ("town", "locality", "authority")),
+                         ("outcodes", ("outcode",))):
+        rows = _place_sitemap_rows(kinds)
+        chunks = [rows[i:i + SITEMAP_CHUNK_SIZE]
+                  for i in range(0, len(rows), SITEMAP_CHUNK_SIZE)] or [[]]
+        for n, chunk in enumerate(chunks, start=1):
+            children[f"{label}-{n}.xml"] = _urlset(chunk)
+
+    # On a sitemap index, lastmod means "when this sitemap file last changed",
+    # so generation time is the correct value here — unlike on a <url>, where
+    # it would be a claim about content we cannot support.
+    generated = datetime.now(timezone.utc).date().isoformat()
+    index_rows = [
+        f"  <sitemap><loc>{BASE_URL}{SITEMAP_CHILD_PREFIX}/{name}</loc>"
+        f"<lastmod>{generated}</lastmod></sitemap>"
+        for name in children
+    ]
+    index = "\n".join([
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+        *index_rows,
+        "</sitemapindex>",
+    ])
+    return {**children, "sitemap.xml": index}
+
+
+def build_sitemap() -> str:
+    """The sitemap index. Kept for `lifespan` and the admin endpoint."""
+    return build_sitemaps()["sitemap.xml"]
 
 
 def clean_filter_values(series: pd.Series) -> list[str]:
@@ -284,7 +458,7 @@ def validate_postcode(postcode: Optional[str]) -> Optional[str]:
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Application lifespan - startup and shutdown events."""
-    global _sitemap_xml
+    global _sitemaps
     print("Loading school data from marts...")
     df = load_school_data()
     if df.empty:
@@ -294,9 +468,9 @@ async def lifespan(app: FastAPI):
         # Pre-compute the latest-year snapshot so the first search request is fast
         await asyncio.to_thread(load_latest_school_data)
     try:
-        _sitemap_xml = build_sitemap()
-        n = _sitemap_xml.count("<url>")
-        print(f"Sitemap built: {n} URLs.")
+        _sitemaps = build_sitemaps()
+        n = sum(x.count("<url>") for x in _sitemaps.values())
+        print(f"Sitemaps built: {len(_sitemaps)} files, {n} URLs.")
     except Exception as e:
         print(f"Warning: sitemap build failed on startup: {e}")
 
@@ -633,7 +807,6 @@ 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"),
@@ -1008,6 +1181,66 @@ async def get_rankings(
     }
 
 
+@app.get("/api/places")
+@limiter.limit(f"{settings.rate_limit_per_minute}/minute")
+async def list_places(request: Request):
+    """Every published place. The sitemap and the link modules read this."""
+    registry = get_place_registry()
+    return {"places": [
+        {"kind": p.kind, "slug": p.slug, "name": p.name, "count": len(p.urns)}
+        for p in sorted(registry.values(), key=lambda p: (p.kind, p.slug))
+    ]}
+
+
+@app.get("/api/places/{kind}/{slug}")
+@limiter.limit(f"{settings.rate_limit_per_minute}/minute")
+async def get_place(request: Request, kind: str, slug: str,
+                    phase: Optional[str] = None):
+    """One place: its schools ranked, and its local averages."""
+    if kind not in VALID_PLACE_KINDS:
+        raise HTTPException(status_code=404, detail="No such place")
+
+    place = get_place_registry().get(f"{kind}:{slug}")
+    if place is None:
+        raise HTTPException(status_code=404, detail="No such place")
+
+    df = load_latest_school_data()
+    rows = df[df["urn"].isin(place.urns)]
+
+    if phase:
+        wanted = PHASE_GROUPS.get(phase.lower())
+        if wanted and "phase" in rows.columns:
+            rows = rows[rows["phase"].fillna("").str.lower().isin(wanted)]
+
+    # The metric the page ranks on, which is also the one it averages.
+    metric = "attainment_8_score" if phase == "secondary" else "rwm_expected_pct"
+    if metric in rows.columns:
+        rows = rows.sort_values(metric, ascending=False, na_position="last")
+
+    averages = {
+        m: (None if m not in rows.columns or rows[m].dropna().empty
+            else float(rows[m].dropna().mean()))
+        for m in ("rwm_expected_pct", "attainment_8_score")
+    }
+
+    cols = [c for c in SCHOOL_COLUMNS + ["latitude", "longitude", "phase",
+                                          "rwm_expected_pct", "attainment_8_score",
+                                          "total_pupils"]
+            if c in rows.columns]
+
+    return {
+        "place": {"kind": place.kind, "slug": place.slug, "name": place.name,
+                  "count": len(place.urns),
+                  "parent_authority": place.parent_authority,
+                  # Only phases that clear the threshold, so the page links
+                  # variants that exist rather than 404s.
+                  "phases": [ph for ph in ("primary", "secondary")
+                             if place.publishes_phase(ph)]},
+        "schools": clean_for_json(rows[cols]),
+        "averages": averages,
+    }
+
+
 @app.get("/api/data-info")
 @limiter.limit(f"{settings.rate_limit_per_minute}/minute")
 async def get_data_info(request: Request):
@@ -1088,16 +1321,28 @@ async def robots_txt():
     return FileResponse(settings.frontend_dir / "robots.txt", media_type="text/plain")
 
 
-@app.get("/sitemap.xml")
-async def sitemap_xml():
-    """Serve sitemap.xml for search engine indexing."""
-    global _sitemap_xml
-    if _sitemap_xml is None:
+def _serve_sitemap(name: str) -> Response:
+    global _sitemaps
+    if _sitemaps is None:
         try:
-            _sitemap_xml = build_sitemap()
+            _sitemaps = build_sitemaps()
         except Exception as e:
             raise HTTPException(status_code=503, detail=f"Sitemap unavailable: {e}")
-    return Response(content=_sitemap_xml, media_type="application/xml")
+    if name not in _sitemaps:
+        raise HTTPException(status_code=404, detail="No such sitemap")
+    return Response(content=_sitemaps[name], media_type="application/xml")
+
+
+@app.get("/sitemap.xml")
+async def sitemap_xml():
+    """Serve the sitemap index."""
+    return _serve_sitemap("sitemap.xml")
+
+
+@app.get("/sitemaps/{name}")
+async def sitemap_child(name: str):
+    """Serve a child sitemap (static.xml, or schools-N.xml)."""
+    return _serve_sitemap(name)
 
 
 @app.post("/api/admin/regenerate-sitemap")
@@ -1107,10 +1352,14 @@ async def regenerate_sitemap(
     _: bool = Depends(verify_admin_api_key),
 ):
     """Rebuild and cache the sitemap from current school data. Called by Airflow after data updates."""
-    global _sitemap_xml
-    _sitemap_xml = build_sitemap()
-    n = _sitemap_xml.count("<url>")
-    return {"status": "ok", "urls": n}
+    global _sitemaps, _place_registry
+    # Places and sitemap are rebuilt together — they read the same marts, and
+    # letting them drift apart would submit URLs for places that no longer
+    # exist.
+    _place_registry = None
+    _sitemaps = build_sitemaps()
+    n = sum(x.count("<url>") for x in _sitemaps.values())
+    return {"status": "ok", "urls": n, "sitemaps": len(_sitemaps)}
 
 
 # Mount static files directly (must be after all routes to avoid catching API calls)

backend/data_loader.py

@@ -771,7 +771,6 @@ def _empty_supplementary() -> dict:
         "admissions": None,
         "admissions_history": [],
         "admission_distance": None,
-        "admission_distance_history": [],
         "sen_detail": None,
         "phonics": None,
         "deprivation": None,
@@ -850,29 +849,30 @@ 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 — all years per URN, oldest first, with the latest
-    # also exposed on its own.
+    # Last distance offered — the latest year per URN, and only that.
     #
-    # 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.
+    # The mart holds every published year and the DAG keeps loading them; what
+    # changed is what leaves this process. Earlier years are being held back as
+    # a paid feature, and this API is public and unauthenticated — serving the
+    # history here would hand it to anyone who opened the network tab, whatever
+    # the page chose to render. Withholding it in the client would have been
+    # decoration, not a decision.
+    #
+    # Restoring it for entitled callers is a change to this function, not to
+    # the pipeline: fact_admission_distance is untouched and complete.
     def _admission_distance():
         rows = (
             db.query(FactAdmissionDistance)
             .filter(FactAdmissionDistance.urn.in_(urns))
-            .order_by(FactAdmissionDistance.urn, FactAdmissionDistance.year.asc())
+            .order_by(FactAdmissionDistance.urn, FactAdmissionDistance.year.desc())
             .all()
         )
-        history: dict = {urn: [] for urn in urns}
+        seen = set()
         for d in rows:
-            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
+            if d.urn in seen:
+                continue
+            seen.add(d.urn)
+            result[d.urn]["admission_distance"] = _admission_distance_dict(d)
     _safe(_admission_distance)
 
     # Deprivation — one row per URN.

backend/localities.py

@@ -0,0 +1,54 @@
+"""Curated London localities, defined by the postcode districts they cover.
+
+The GIAS `town` field puts 1,819 London schools under the single value
+"London", so it cannot answer "schools in Battersea" — a query that appears in
+the Search Console baseline. No single field can: parliamentary constituency
+gives Battersea but not Canary Wharf; postcodes.io's admin_ward gives Canary
+Wharf but not Battersea; neither gives Clapham or Shoreditch, which are postal
+and colloquial rather than administrative.
+
+So this is curated. Where a locality ends is a judgement, not a fact, and a
+reviewable file is the honest place for a judgement. No new ingestion is
+needed — the corpus already carries postcodes.
+
+This is the canonical copy. `pipeline/transform/seeds/locality_outcodes.csv`
+mirrors it for anyone querying the warehouse directly; the backend image does
+not contain `pipeline/`, which is why the module rather than the seed is
+canonical. Same arrangement as `backend/gias_codes.py`.
+
+A locality whose outcodes hold fewer than MIN_SCHOOLS schools is not
+published, so a typo produces no page rather than an empty one. Places that
+fail that check are logged at startup, because a locality you meant to publish
+quietly not appearing is the failure worth hearing about.
+
+Two rules for anything added here.
+
+**Sub-borough districts only.** A London borough is a local authority and
+already has a page at /schools/authority/[la] covering all of its schools; a
+locality defined by two or three outcodes would be a partial, near-duplicate
+subset of it. Hackney, Islington, Greenwich and Ealing were all in the first
+draft for that reason and have been removed.
+
+**The slug must not match a GIAS town.** "Richmond" did — GIAS has a Richmond
+in North Yorkshire with 37 schools — so the London one could never publish.
+The registry skips any locality that collides and logs it.
+"""
+
+# slug -> (display name, outcodes)
+LOCALITY_OUTCODES: dict[str, tuple[str, tuple[str, ...]]] = {
+    "battersea":     ("Battersea",     ("SW11",)),
+    "canary-wharf":  ("Canary Wharf",  ("E14",)),
+    "clapham":       ("Clapham",       ("SW4",)),
+    "shoreditch":    ("Shoreditch",    ("EC2A", "E1")),
+    "peckham":       ("Peckham",       ("SE15",)),
+    "brixton":       ("Brixton",       ("SW2", "SW9")),
+    "camden-town":   ("Camden Town",   ("NW1",)),
+    "wimbledon":     ("Wimbledon",     ("SW19",)),
+    "putney":        ("Putney",        ("SW15",)),
+    "fulham":        ("Fulham",        ("SW6",)),
+    "chiswick":      ("Chiswick",      ("W4",)),
+    "stratford":     ("Stratford",     ("E15",)),
+    "walthamstow":   ("Walthamstow",   ("E17",)),
+    "tooting":       ("Tooting",       ("SW17",)),
+    "dulwich":       ("Dulwich",       ("SE21", "SE22")),
+}

backend/places.py

@@ -0,0 +1,204 @@
+"""The place registry: what places the site publishes, and what is in each.
+
+One module owns this question. The pages, the sitemap and the internal-link
+modules all read from here, so the threshold and the collision rules exist in
+exactly one place and are testable without a browser or a database.
+
+Two namespaces, never one. 67 viable town names collide with a local
+authority name, and the authority is the larger set in only 43 of them —
+postal towns cross authority boundaries, so neither can absorb the other.
+Keys are "<kind>:<slug>" so the collision cannot reappear in the dict.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass, field
+
+logger = logging.getLogger(__name__)
+
+# Five schools with publishable data. Below this a place has nothing to say
+# that a list of schools does not, and publishing it is index bloat.
+MIN_SCHOOLS = 5
+
+
+@dataclass(frozen=True)
+class Place:
+    kind: str                       # "town" | "locality" | "authority" | "outcode"
+    slug: str
+    name: str
+    urns: tuple[int, ...]
+    parent_authority: str | None    # authority NAME, for the 301 target
+    # URNs per phase, so the per-phase threshold can be applied without
+    # re-querying. A place with 30 primaries and 2 secondaries publishes a
+    # primary variant and no secondary one.
+    phase_urns: dict[str, tuple[int, ...]] = field(default_factory=dict)
+
+    def publishes_phase(self, phase: str) -> bool:
+        return len(self.phase_urns.get(phase, ())) >= MIN_SCHOOLS
+
+    @property
+    def key(self) -> str:
+        return f"{self.kind}:{self.slug}"
+
+
+def _publishable_urns(df) -> set[int]:
+    """URNs with something a page could state, deduplicated across years."""
+    from backend.app import _PUBLISHABLE_FIELDS
+
+    cols = [c for c in _PUBLISHABLE_FIELDS if c in df.columns]
+    if not cols:
+        return set()
+    return set(df.loc[df[cols].notna().any(axis=1), "urn"].astype(int))
+
+
+def _phase_urns(group, publishable: set[int]) -> dict[str, tuple[int, ...]]:
+    """URNs per phase. All-through schools count toward both, matching the
+    PHASE_GROUPS mapping the search filters already use."""
+    from backend.app import PHASE_GROUPS
+
+    if "phase" not in group.columns:
+        return {}
+    lowered = group["phase"].fillna("").str.lower()
+    out: dict[str, tuple[int, ...]] = {}
+    for phase in ("primary", "secondary"):
+        wanted = PHASE_GROUPS.get(phase, set())
+        subset = group[lowered.isin(wanted)]
+        urns = tuple(sorted({int(u) for u in subset["urn"]} & publishable))
+        if urns:
+            out[phase] = urns
+    return out
+
+
+def _parent_authority(group) -> str | None:
+    """The most common authority in a group — the useful 301 target.
+
+    A town spanning several authorities has no single parent, so the mode is
+    the honest answer rather than an arbitrary first row.
+    """
+    if "local_authority" not in group.columns:
+        return None
+    top = group["local_authority"].dropna()
+    return str(top.mode().iloc[0]) if not top.empty else None
+
+
+def _group(df, column: str, kind: str, publishable: set[int]) -> dict[str, Place]:
+    """One Place per distinct value of `column` that clears the threshold."""
+    from backend.app import _slugify
+
+    if column not in df.columns:
+        return {}
+
+    out: dict[str, Place] = {}
+    for name, group in df.groupby(column, dropna=True):
+        name = str(name).strip()
+        if not name:
+            continue
+        urns = tuple(sorted({int(u) for u in group["urn"]} & publishable))
+        if len(urns) < MIN_SCHOOLS:
+            continue
+        slug = _slugify(name)
+        if not slug:
+            continue
+        place = Place(
+            kind=kind, slug=slug, name=name, urns=urns,
+            parent_authority=_parent_authority(group) if kind == "town" else None,
+            phase_urns=_phase_urns(group, publishable),
+        )
+        out[place.key] = place
+    return out
+
+
+# "SW11 2AA" -> "SW11". Two letters max, one or two digits, optional letter.
+_OUTCODE_RE = re.compile(r"^([A-Z]{1,2}\d{1,2}[A-Z]?)\s")
+
+
+def _outcode(postcode) -> str | None:
+    if not isinstance(postcode, str):
+        return None
+    m = _OUTCODE_RE.match(postcode.upper().strip())
+    return m.group(1) if m else None
+
+
+def _outcode_places(df, publishable: set[int]) -> dict[str, Place]:
+    """One Place per postcode district clearing the threshold.
+
+    These carry no phase variants: nobody searches "primary schools in SW11".
+    """
+    if "postcode" not in df.columns:
+        return {}
+    working = df.assign(_oc=df["postcode"].map(_outcode))
+    working = working[working["_oc"].notna()]
+
+    out: dict[str, Place] = {}
+    for oc, group in working.groupby("_oc"):
+        urns = tuple(sorted({int(u) for u in group["urn"]} & publishable))
+        if len(urns) < MIN_SCHOOLS:
+            continue
+        place = Place(kind="outcode", slug=str(oc).lower(), name=str(oc),
+                      urns=urns, parent_authority=_parent_authority(group),
+                      phase_urns=_phase_urns(group, publishable))
+        out[place.key] = place
+    return out
+
+
+def _locality_places(df, publishable: set[int],
+                     town_slugs: set[str]) -> dict[str, Place]:
+    """One Place per curated locality clearing the threshold."""
+    from backend.localities import LOCALITY_OUTCODES
+
+    if "postcode" not in df.columns:
+        return {}
+    working = df.assign(_oc=df["postcode"].map(_outcode))
+
+    out: dict[str, Place] = {}
+    for slug, (name, outcodes) in LOCALITY_OUTCODES.items():
+        if slug in town_slugs:
+            # Skip, do not raise. The guard exists so a locality never
+            # silently shadows a town — skipping achieves that, and the error
+            # log makes it loud.
+            #
+            # Raising here took down sitemap generation for all 25,000 school
+            # pages when "richmond" met the GIAS town Richmond in North
+            # Yorkshire. Worse, GIAS town names change without any code change,
+            # so a raise means curated data can break the site spontaneously.
+            # A curation mistake must cost one page, not the sitemap.
+            logger.error(
+                "locality %r collides with the published town of the same "
+                "slug and has been skipped; rename it or remove it", slug)
+            continue
+        group = working[working["_oc"].isin(outcodes)]
+        urns = tuple(sorted({int(u) for u in group["urn"]} & publishable))
+        if len(urns) < MIN_SCHOOLS:
+            # Not an error — a locality can legitimately be too small. Logged
+            # because one you meant to publish quietly vanishing is the
+            # failure worth hearing about.
+            logger.warning(
+                "locality %s (%s) has %d publishable schools, below the "
+                "threshold of %d - not published",
+                slug, ", ".join(outcodes), len(urns), MIN_SCHOOLS)
+            continue
+        place = Place(kind="locality", slug=slug, name=name, urns=urns,
+                      parent_authority=_parent_authority(group),
+                      phase_urns=_phase_urns(group, publishable))
+        out[place.key] = place
+    return out
+
+
+def build_place_registry(df) -> dict[str, Place]:
+    """Every place the site publishes, keyed by "<kind>:<slug>"."""
+    if df.empty or "urn" not in df.columns:
+        return {}
+
+    publishable = _publishable_urns(df)
+    registry: dict[str, Place] = {}
+    registry.update(_group(df, "local_authority", "authority", publishable))
+
+    towns = _group(df, "town", "town", publishable)
+    registry.update(towns)
+
+    town_slugs = {p.slug for p in towns.values()}
+    registry.update(_locality_places(df, publishable, town_slugs))
+    registry.update(_outcode_places(df, publishable))
+    return registry

backend/tests/test_places.py

@@ -0,0 +1,231 @@
+"""Tests for the place registry (spec 2026-08-21).
+
+The registry is built from the in-memory school DataFrame, so these build a
+small frame directly rather than touching a database.
+"""
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from backend.places import MIN_SCHOOLS, build_place_registry
+
+
+def _df(rows: list[dict]) -> pd.DataFrame:
+    base = {
+        "year": 202425, "ofsted_grade": 2.0, "ofsted_date": None,
+        "rwm_expected_pct": 60.0, "attainment_8_score": np.nan,
+        "phase": "Primary", "postcode": "AA1 1AA",
+    }
+    return pd.DataFrame([{**base, **r} for r in rows])
+
+
+def _town(n: int, town: str, la: str, start: int = 100000, **kw) -> list[dict]:
+    """`start` offsets the URNs so two calls can describe different schools —
+    the Bedford case needs two authorities' worth of distinct URNs in one
+    town."""
+    return [
+        {"urn": start + i, "school_name": f"{town} School {i}",
+         "town": town, "local_authority": la, **kw}
+        for i in range(n)
+    ]
+
+
+def test_town_clearing_the_threshold_is_published():
+    reg = build_place_registry(_df(_town(MIN_SCHOOLS, "Brentwood", "Essex")))
+    assert "town:brentwood" in reg
+    assert reg["town:brentwood"].name == "Brentwood"
+    assert len(reg["town:brentwood"].urns) == MIN_SCHOOLS
+
+
+def test_town_below_the_threshold_is_not_published():
+    reg = build_place_registry(_df(_town(MIN_SCHOOLS - 1, "Crosby", "Sefton")))
+    assert "town:crosby" not in reg
+
+
+def test_a_town_below_threshold_still_names_its_authority():
+    # The route layer needs somewhere to 301 to.
+    reg = build_place_registry(_df(
+        _town(MIN_SCHOOLS - 1, "Crosby", "Sefton") + _town(MIN_SCHOOLS, "Bootle", "Sefton")))
+    assert "authority:sefton" in reg
+
+
+def test_town_and_authority_of_the_same_name_are_separate_places():
+    # 67 real collisions. Neither set contains the other: Bedford the town has
+    # 104 schools, Bedford the authority 86, because postal towns cross
+    # authority boundaries.
+    rows = (_town(MIN_SCHOOLS, "Bedford", "Bedford")
+            + _town(MIN_SCHOOLS, "Bedford", "Central Bedfordshire", start=200000))
+    reg = build_place_registry(_df(rows))
+    town, authority = reg["town:bedford"], reg["authority:bedford"]
+    assert set(town.urns) != set(authority.urns)
+    assert len(town.urns) == MIN_SCHOOLS * 2      # both authorities' schools
+    assert len(authority.urns) == MIN_SCHOOLS     # only this authority's
+
+
+def test_schools_without_publishable_data_do_not_count_toward_the_threshold():
+    rows = _town(MIN_SCHOOLS, "Ghosttown", "Nowhere")
+    for r in rows:
+        r["rwm_expected_pct"] = np.nan
+        r["ofsted_grade"] = np.nan
+    reg = build_place_registry(_df(rows))
+    assert "town:ghosttown" not in reg
+
+
+def test_blank_town_is_ignored():
+    rows = _town(MIN_SCHOOLS, "", "Essex")
+    reg = build_place_registry(_df(rows))
+    assert not any(k.startswith("town:") for k in reg)
+
+
+def test_a_school_is_counted_once_even_with_several_years_of_rows():
+    rows = []
+    for year in (202324, 202425):
+        rows += [{**r, "year": year} for r in _town(MIN_SCHOOLS, "Beccles", "Suffolk")]
+    reg = build_place_registry(_df(rows))
+    assert len(reg["town:beccles"].urns) == MIN_SCHOOLS
+
+
+def test_locality_groups_schools_by_outcode(monkeypatch):
+    # The GIAS town field collapses 1,819 London schools into "London", so a
+    # locality is defined by its postcode districts instead.
+    from backend import localities
+    monkeypatch.setattr(localities, "LOCALITY_OUTCODES",
+                        {"battersea": ("Battersea", ("SW11",))})
+    rows = _town(MIN_SCHOOLS, "London", "Wandsworth")
+    for r in rows:
+        r["postcode"] = "SW11 2AA"
+    reg = build_place_registry(_df(rows))
+    assert reg["locality:battersea"].name == "Battersea"
+    assert len(reg["locality:battersea"].urns) == MIN_SCHOOLS
+
+
+def test_locality_below_the_threshold_is_not_published(monkeypatch):
+    from backend import localities
+    monkeypatch.setattr(localities, "LOCALITY_OUTCODES",
+                        {"nowhere": ("Nowhere", ("ZZ99",))})
+    reg = build_place_registry(_df(_town(MIN_SCHOOLS, "London", "Wandsworth")))
+    assert "locality:nowhere" not in reg
+
+
+def test_a_locality_may_not_shadow_a_viable_town(monkeypatch, caplog):
+    """A colliding locality is skipped loudly, and the town survives.
+
+    This used to raise, which took down sitemap generation for all 25,000
+    school pages the first time a curated slug met a real GIAS town. Curated
+    data must not be able to break the site — and GIAS town names change with
+    no code change at all, so the raise could fire spontaneously.
+    """
+    import logging
+
+    from backend import localities
+    monkeypatch.setattr(localities, "LOCALITY_OUTCODES",
+                        {"brentwood": ("Brentwood", ("CM13",))})
+    rows = _town(MIN_SCHOOLS, "Brentwood", "Essex")
+    for r in rows:
+        r["postcode"] = "CM13 1AA"
+
+    with caplog.at_level(logging.ERROR):
+        reg = build_place_registry(_df(rows))
+
+    assert "locality:brentwood" not in reg      # skipped
+    assert "town:brentwood" in reg              # the town is untouched
+    assert "brentwood" in caplog.text           # and it was loud about it
+
+
+def test_a_locality_collision_does_not_break_the_rest_of_the_registry(monkeypatch):
+    # The whole point of skipping rather than raising.
+    from backend import localities
+    monkeypatch.setattr(localities, "LOCALITY_OUTCODES",
+                        {"brentwood": ("Brentwood", ("CM13",))})
+    rows = _town(MIN_SCHOOLS, "Brentwood", "Essex")
+    for r in rows:
+        r["postcode"] = "CM13 1AA"
+    reg = build_place_registry(_df(rows))
+    assert "authority:essex" in reg
+    assert "outcode:cm13" in reg
+
+
+def test_outcode_places_are_built_from_postcodes():
+    rows = _town(MIN_SCHOOLS, "Brentwood", "Essex")
+    for r in rows:
+        r["postcode"] = "CM13 1AA"
+    reg = build_place_registry(_df(rows))
+    assert reg["outcode:cm13"].name == "CM13"
+    assert len(reg["outcode:cm13"].urns) == MIN_SCHOOLS
+
+
+def test_malformed_postcodes_do_not_create_places():
+    rows = _town(MIN_SCHOOLS, "Brentwood", "Essex")
+    for r in rows:
+        r["postcode"] = "not a postcode"
+    reg = build_place_registry(_df(rows))
+    assert not any(k.startswith("outcode:") for k in reg)
+
+
+def test_every_curated_locality_is_structurally_valid():
+    # Guards the hand-maintained file: real slug, real name, real outcodes.
+    import re
+    from backend.localities import LOCALITY_OUTCODES
+
+    assert LOCALITY_OUTCODES, "the curated locality list must not be empty"
+    for slug, (name, outcodes) in LOCALITY_OUTCODES.items():
+        assert re.fullmatch(r"[a-z0-9-]+", slug), slug
+        assert name.strip() == name and name, slug
+        assert outcodes, f"{slug} has no outcodes"
+        for oc in outcodes:
+            assert re.fullmatch(r"[A-Z]{1,2}\d{1,2}[A-Z]?", oc), (slug, oc)
+
+
+def test_the_pipeline_seed_mirrors_the_canonical_module():
+    """Two copies with no drift guard is worse than one copy.
+
+    backend/localities.py is canonical because the backend image does not
+    contain pipeline/. The seed exists so the warehouse can join on the same
+    definitions, and this is what stops the two diverging — the same
+    arrangement assert_gias_code_names_match_seed.sql gives gias_codes.
+    """
+    import csv
+    from pathlib import Path
+
+    from backend.localities import LOCALITY_OUTCODES
+
+    seed_path = (Path(__file__).resolve().parents[2]
+                 / "pipeline/transform/seeds/locality_outcodes.csv")
+    assert seed_path.exists(), f"missing seed mirror at {seed_path}"
+
+    seed = {
+        row["locality_slug"]: (row["locality_name"],
+                               tuple(row["outcodes"].split("|")))
+        for row in csv.DictReader(seed_path.open())
+    }
+    assert seed == LOCALITY_OUTCODES
+
+
+def test_no_curated_locality_names_a_london_borough():
+    """Boroughs are authorities and already have a page.
+
+    A locality defined by two or three outcodes inside a borough would be a
+    partial, near-duplicate subset of that authority page — the exact
+    thin-content failure the two-namespace design exists to avoid. Hackney,
+    Islington, Greenwich and Ealing were all in the first draft.
+
+    Hardcoded rather than read from the corpus because this must fail in CI,
+    where there is no database.
+    """
+    from backend.localities import LOCALITY_OUTCODES
+
+    boroughs = {
+        "barking-and-dagenham", "barnet", "bexley", "brent", "bromley",
+        "camden", "croydon", "ealing", "enfield", "greenwich", "hackney",
+        "hammersmith-and-fulham", "haringey", "harrow", "havering",
+        "hillingdon", "hounslow", "islington", "kensington-and-chelsea",
+        "kingston-upon-thames", "lambeth", "lewisham", "merton", "newham",
+        "redbridge", "richmond-upon-thames", "southwark", "sutton",
+        "tower-hamlets", "waltham-forest", "wandsworth", "westminster",
+    }
+    named = boroughs & set(LOCALITY_OUTCODES)
+    assert not named, (
+        f"these are boroughs, not districts: {sorted(named)} - they already "
+        "have an authority page covering every school"
+    )

backend/tests/test_places_api.py

@@ -0,0 +1,71 @@
+"""Tests for the places API (spec 2026-08-21)."""
+
+import numpy as np
+import pandas as pd
+import pytest
+from fastapi.testclient import TestClient
+
+
+def _schools_df() -> pd.DataFrame:
+    base = {
+        "local_authority": "Essex", "school_type": "Academy",
+        "phase": "Primary", "year": 202425, "ofsted_grade": 2.0,
+        "ofsted_date": None, "attainment_8_score": np.nan,
+        "town": "Brentwood", "postcode": "CM13 1AA", "status": "Open",
+        "address": "1 Test Street", "latitude": 51.6, "longitude": 0.3,
+    }
+    return pd.DataFrame([
+        {**base, "urn": 100000 + i, "school_name": f"Brentwood School {i}",
+         "rwm_expected_pct": 50.0 + i}
+        for i in range(6)
+    ])
+
+
+@pytest.fixture()
+def client(monkeypatch):
+    from backend import app as app_module
+
+    monkeypatch.setattr(app_module, "load_school_data", _schools_df)
+    monkeypatch.setattr(app_module, "load_latest_school_data", _schools_df)
+    monkeypatch.setattr(app_module, "_place_registry", None)
+    return TestClient(app_module.app, raise_server_exceptions=False)
+
+
+def test_registry_lists_each_published_place(client):
+    body = client.get("/api/places").json()
+    slugs = {(p["kind"], p["slug"]) for p in body["places"]}
+    assert ("town", "brentwood") in slugs
+    assert ("authority", "essex") in slugs
+    assert ("outcode", "cm13") in slugs
+
+
+def test_registry_carries_a_count_per_place(client):
+    body = client.get("/api/places").json()
+    town = next(p for p in body["places"] if p["slug"] == "brentwood")
+    assert town["count"] == 6
+
+
+def test_place_detail_returns_its_schools_ranked(client):
+    body = client.get("/api/places/town/brentwood").json()
+    assert body["place"]["name"] == "Brentwood"
+    scores = [s["rwm_expected_pct"] for s in body["schools"]]
+    assert scores == sorted(scores, reverse=True)
+
+
+def test_place_detail_carries_the_local_average(client):
+    body = client.get("/api/places/town/brentwood").json()
+    # 50..55 inclusive
+    assert body["averages"]["rwm_expected_pct"] == pytest.approx(52.5)
+
+
+def test_phase_filter_narrows_the_school_list(client):
+    body = client.get("/api/places/town/brentwood?phase=secondary").json()
+    assert body["schools"] == []
+
+
+def test_unknown_place_404s(client):
+    assert client.get("/api/places/town/atlantis").status_code == 404
+
+
+def test_unknown_kind_404s(client):
+    assert client.get("/api/places/planet/mars").status_code == 404

backend/tests/test_sitemap.py

@@ -0,0 +1,290 @@
+"""Tests for sitemap generation (spec 2026-08-20, workstream W1).
+
+The sitemap is built from the in-memory school DataFrame, so these inject a
+small frame via monkeypatch rather than touching a database.
+"""
+
+import numpy as np
+import pandas as pd
+import pytest
+
+
+def _schools_df() -> pd.DataFrame:
+    """Two schools: one with results, one with neither results nor Ofsted."""
+    base = {
+        "local_authority": "Testshire",
+        "school_type": "Academy",
+        "phase": "Primary",
+        "year": 202425,
+        "ofsted_date": None,
+    }
+    return pd.DataFrame(
+        [
+            {**base, "urn": 100001, "school_name": "Alpha Primary",
+             "rwm_expected_pct": 62.0, "attainment_8_score": np.nan,
+             "ofsted_grade": 2.0},
+            {**base, "urn": 100002, "school_name": "Ghost Primary",
+             "rwm_expected_pct": np.nan, "attainment_8_score": np.nan,
+             "ofsted_grade": np.nan},
+        ]
+    )
+
+
+@pytest.fixture()
+def sitemap(monkeypatch) -> str:
+    """The sitemap index."""
+    from backend import app as app_module
+
+    monkeypatch.setattr(app_module, "load_school_data", _schools_df)
+    return app_module.build_sitemap()
+
+
+@pytest.fixture()
+def schools_child(monkeypatch) -> str:
+    """The first school child sitemap, where school URLs actually live."""
+    from backend import app as app_module
+
+    monkeypatch.setattr(app_module, "load_school_data", _schools_df)
+    return app_module.build_sitemaps()["schools-1.xml"]
+
+
+@pytest.fixture()
+def static_child(monkeypatch) -> str:
+    from backend import app as app_module
+
+    monkeypatch.setattr(app_module, "load_school_data", _schools_df)
+    return app_module.build_sitemaps()["static.xml"]
+
+
+def test_every_loc_uses_the_www_host(sitemaps):
+    # The apex 301s to www. A <loc> that redirects burns a crawl per URL.
+    # Checked across every file, index included, not just one.
+    #
+    # A child can legitimately be empty — this fixture holds two schools and no
+    # town clearing the threshold — so the presence check applies only to files
+    # that carry URLs. The absence check applies to all of them.
+    for name, xml in sitemaps.items():
+        assert "https://schoolcompare.co.uk" not in xml, name
+        if "<loc>" in xml:
+            assert "https://www.schoolcompare.co.uk" in xml, name
+
+
+def test_school_with_results_is_listed(schools_child):
+    assert "/school/100001-alpha-primary" in schools_child
+
+
+def test_school_with_no_results_and_no_ofsted_is_omitted(schools_child):
+    # Nothing for a search result to say about it. Submitting it spends crawl
+    # budget and drags the corpus-wide quality signal down.
+    #
+    # Asserted against the child, not the index: the index carries no school
+    # URLs at all, so it would pass this trivially and prove nothing.
+    assert "/school/100002" not in schools_child
+
+
+def test_no_invented_priority_or_changefreq(sitemaps):
+    # Google ignores both. They were noise dressed as signal.
+    for name, xml in sitemaps.items():
+        assert "<priority>" not in xml, name
+        assert "<changefreq>" not in xml, name
+
+
+def test_ofsted_date_becomes_lastmod(monkeypatch):
+    from backend import app as app_module
+    import datetime
+
+    def _df():
+        base = _schools_df()
+        base.loc[base["urn"] == 100001, "ofsted_date"] = datetime.date(2024, 3, 14)
+        return base
+
+    monkeypatch.setattr(app_module, "load_school_data", _df)
+    xml = app_module.build_sitemaps()["schools-1.xml"]
+    assert "<lastmod>2024-03-14</lastmod>" in xml
+
+
+def test_no_lastmod_invented_when_date_unknown(monkeypatch):
+    # An always-now lastmod is a claim Google learns to distrust. Absent
+    # honestly means unknown.
+    from backend import app as app_module
+
+    def _df():
+        df = _schools_df()
+        df["ofsted_date"] = None
+        return df
+
+    monkeypatch.setattr(app_module, "load_school_data", _df)
+    # The child only. The index legitimately carries a lastmod, because there
+    # it means "when this sitemap file changed", which we do know.
+    xml = app_module.build_sitemaps()["schools-1.xml"]
+    assert "<lastmod>" not in xml
+
+
+def test_static_routes_are_listed(static_child):
+    for path in ("/", "/rankings", "/compare", "/admissions"):
+        assert f"<loc>https://www.schoolcompare.co.uk{path}</loc>" in static_child
+
+
+@pytest.fixture()
+def sitemaps(monkeypatch) -> dict:
+    from backend import app as app_module
+
+    monkeypatch.setattr(app_module, "load_school_data", _schools_df)
+    return app_module.build_sitemaps()
+
+
+def test_index_lists_each_child(sitemaps):
+    index = sitemaps["sitemap.xml"]
+    assert "<sitemapindex" in index
+    assert "https://www.schoolcompare.co.uk/sitemaps/static.xml" in index
+    assert "https://www.schoolcompare.co.uk/sitemaps/schools-1.xml" in index
+
+
+def test_index_carries_no_url_elements(sitemaps):
+    # A sitemap index holds <sitemap> entries only; mixing in <url> is invalid.
+    assert "<url>" not in sitemaps["sitemap.xml"]
+
+
+def test_index_does_not_list_itself(sitemaps):
+    assert "<loc>https://www.schoolcompare.co.uk/sitemap.xml</loc>" not in sitemaps["sitemap.xml"]
+
+
+def test_static_child_holds_the_static_routes(sitemaps):
+    static = sitemaps["static.xml"]
+    for path in ("/", "/rankings", "/compare", "/admissions"):
+        assert f"<loc>https://www.schoolcompare.co.uk{path}</loc>" in static
+
+
+def test_school_child_holds_the_schools(sitemaps):
+    assert "/school/100001-alpha-primary" in sitemaps["schools-1.xml"]
+
+
+def test_children_are_chunked_under_the_limit(monkeypatch):
+    # Sitemaps cap at 50,000 URLs per file. Chunk at 10,000 so a child stays
+    # small enough to eyeball in Search Console.
+    from backend import app as app_module
+    import pandas as _pd
+
+    rows = [
+        {"urn": 200000 + i, "school_name": f"School {i}", "year": 202425,
+         "rwm_expected_pct": 60.0, "attainment_8_score": None,
+         "ofsted_grade": 2.0, "ofsted_date": None}
+        for i in range(10_001)
+    ]
+    monkeypatch.setattr(app_module, "load_school_data", lambda: _pd.DataFrame(rows))
+
+    maps = app_module.build_sitemaps()
+    assert maps["schools-1.xml"].count("<url>") == 10_000
+    assert maps["schools-2.xml"].count("<url>") == 1
+
+
+def test_build_sitemap_still_returns_the_index(sitemap):
+    # lifespan and the admin endpoint call build_sitemap(); keep it working.
+    assert "<sitemapindex" in sitemap
+
+
+def test_school_with_results_in_an_earlier_year_is_still_listed(monkeypatch):
+    """Regression: The Mallard Academy (150367).
+
+    Real KS2 results 2015-16 to 2018-19, then null rows from 2022-23 onward
+    because the school stopped reporting. The first cut tested the latest
+    year's row alone and dropped it, along with ~220 others, even though its
+    detail page shows all four years of results.
+    """
+    from backend import app as app_module
+    import pandas as _pd
+
+    base = {"local_authority": "Testshire", "school_type": "Academy",
+            "phase": "Primary", "ofsted_date": None, "ofsted_grade": np.nan,
+            "attainment_8_score": np.nan, "urn": 150367,
+            "school_name": "Mallard Academy"}
+    df = _pd.DataFrame([
+        {**base, "year": 201819, "rwm_expected_pct": 67.0},
+        {**base, "year": 202324, "rwm_expected_pct": np.nan},
+        {**base, "year": 202425, "rwm_expected_pct": np.nan},
+    ])
+    monkeypatch.setattr(app_module, "load_school_data", lambda: df)
+
+    xml = app_module.build_sitemaps()["schools-1.xml"]
+    assert "/school/150367-mallard-academy" in xml
+
+
+def test_school_with_no_results_in_any_year_is_still_omitted(monkeypatch):
+    """The fix must not turn into "list everything"."""
+    from backend import app as app_module
+    import pandas as _pd
+
+    base = {"local_authority": "Testshire", "school_type": "Academy",
+            "phase": "Primary", "ofsted_date": None, "ofsted_grade": np.nan,
+            "attainment_8_score": np.nan, "rwm_expected_pct": np.nan,
+            "urn": 100002, "school_name": "Ghost Primary"}
+    df = _pd.DataFrame([{**base, "year": y} for y in (202324, 202425)])
+    monkeypatch.setattr(app_module, "load_school_data", lambda: df)
+
+    assert "/school/100002" not in app_module.build_sitemaps()["schools-1.xml"]
+
+
+def _places_df() -> pd.DataFrame:
+    base = {
+        "local_authority": "Essex", "school_type": "Academy",
+        "phase": "Primary", "year": 202425, "ofsted_grade": 2.0,
+        "ofsted_date": None, "attainment_8_score": np.nan,
+        "town": "Brentwood", "postcode": "CM13 1AA",
+    }
+    return pd.DataFrame([
+        {**base, "urn": 100000 + i, "school_name": f"Brentwood School {i}",
+         "rwm_expected_pct": 60.0}
+        for i in range(6)
+    ])
+
+
+@pytest.fixture()
+def place_sitemaps(monkeypatch) -> dict:
+    from backend import app as app_module
+
+    monkeypatch.setattr(app_module, "load_school_data", _places_df)
+    monkeypatch.setattr(app_module, "_place_registry", None)
+    return app_module.build_sitemaps()
+
+
+def test_place_children_are_listed_in_the_index(place_sitemaps):
+    index = place_sitemaps["sitemap.xml"]
+    assert "/sitemaps/places-1.xml" in index
+    assert "/sitemaps/outcodes-1.xml" in index
+
+
+def test_town_and_authority_urls_use_their_own_namespaces(place_sitemaps):
+    xml = place_sitemaps["places-1.xml"]
+    assert "<loc>https://www.schoolcompare.co.uk/schools/brentwood</loc>" in xml
+    assert "<loc>https://www.schoolcompare.co.uk/schools/authority/essex</loc>" in xml
+
+
+def test_outcode_urls_live_in_their_own_child(place_sitemaps):
+    assert "/schools/near/cm13" in place_sitemaps["outcodes-1.xml"]
+    assert "/schools/near/cm13" not in place_sitemaps["places-1.xml"]
+
+
+def test_place_urls_carry_no_priority_or_changefreq(place_sitemaps):
+    for name in ("places-1.xml", "outcodes-1.xml"):
+        assert "<priority>" not in place_sitemaps[name]
+        assert "<changefreq>" not in place_sitemaps[name]
+
+
+def test_phase_variants_are_submitted_where_the_phase_clears_the_threshold(place_sitemaps):
+    # "primary schools in beccles" is the query shape the baseline showed, so
+    # each variant is its own page and has to be submitted. Emitting only the
+    # bare place URL left ~950 of them reachable by nothing.
+    xml = place_sitemaps["places-1.xml"]
+    assert "<loc>https://www.schoolcompare.co.uk/schools/brentwood/primary</loc>" in xml
+
+
+def test_a_phase_below_its_own_threshold_is_not_submitted(place_sitemaps):
+    # The fixture is six primaries and no secondaries.
+    xml = place_sitemaps["places-1.xml"]
+    assert "/schools/brentwood/secondary" not in xml
+
+
+def test_outcodes_get_no_phase_variants(place_sitemaps):
+    # Nobody searches "primary schools in CM13"; the routes do not exist.
+    xml = place_sitemaps["outcodes-1.xml"]
+    assert "/primary" not in xml and "/secondary" not in xml

backend/tests/test_supplementary_batch.py

@@ -151,11 +151,13 @@ 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: 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]
+    # Cut-off distance: the latest year only. Earlier years stay in the mart
+    # but are held back as a paid feature, and this API is public — serving
+    # them here would hand them to anyone reading the response. The fixture
+    # rows are deliberately out of order, so "latest" only comes out right if
+    # the query's ORDER BY is doing the work.
     assert out[1]["admission_distance"]["year"] == 2026
+    assert "admission_distance_history" not in out[1]
     assert out[1]["admission_distance"]["distance_m"] == 529.47
     # route_count travels with the figure — the page needs it to say the
     # distance is the furthest of several bands rather than the only one.
@@ -171,4 +173,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"] == []
+    assert "admission_distance_history" not in single

docs/branch-cleanup-2026-08-20.txt

@@ -0,0 +1,85 @@
+# Remote branch cleanup, 2026-08-20
+# Restore any branch with:  git push origin <sha>:refs/heads/<name>
+
+## Deleted: fully merged into main (content is in main)
+75677f4252b759ef895e7d5f7c19f8f1745bdb59 add-contact-form-footer
+fa1abff642683dfd26ba88a295a0a6710d77147a chore/byline-removal-and-audit-figure
+95081d38bdf87764ef5d298676c25fae4cd3b792 chore/remove-parent-view
+6877abedebfc1c7d95f1f6ebe68945c62be528ab chore/staged-prod-promotion
+090d5f7bec824e083d3252e2c6e636686016304d ci/frontend-checks-speedup
+8c3a5cc4e9f551f0190d85357ce7741ad87f3a4c design/cohort-identity
+955659580067ca8b81bd77e31e4e2554103f094d feat/allow-analytics-iframe-embed
+6828f6cd4417284ea3eb6f088fa20945b8b40ed3 feat/compare-chips-two-per-row
+d5cd0abfee226885119665da5d2aa8288b59217f feat/compare-data-foundation
+6dd9b04b50bee146682da87efad8fc8b526251c5 feat/compare-frontend-rebuild
+96d5fcf5b07b6f175b48e9b20fcb765a320a907f feat/detail-header-details-reveal
+f1388ff5bd0af1409823a1e047b7ba84246a0f70 feat/gias-sixth-form-flag
+eddf74745f86c9c6d9eb07d867246ff9cc90dc20 feat/hero-artwork-v2
+3015c37bac6dc28db58c80fdb9235942c25b83d7 feat/hero-byline
+8e763e39d17a4964cf558e51c03f044186371f6d feat/info-popover-tooltip
+88c653215d520ab6e902c9de55bf27d86eeb90c3 feat/last-distance-offered
+a72323874f7aebdb2e64b6d64a5febd61152d09d feat/last-distance-offered-full
+c9a1892bfb0370e0672e5849cba294ddfabe3c65 feat/latest-cutoff-only
+4e8df006d75d8be2a1d8529ddf855c445854cba1 feat/near-me-by-search
+45ab479062c6a1639facad636fc0cc0cf0fd9155 feat/proposed-to-close-schools
+3bf2e8f262cbe058fda6de6f8ea3e050224a51b9 feat/school-detail-visualisations
+1f80571b1ff217dc92b660a936c02b5f49d07f0b feat/umami-heatmap-recorder
+609bb923d96aa5730131463ea35d5efdd404bf96 feature/ingest-independent-schools
+94151c58ea38a9256d66d15161293486a500c7a2 fix/admissions-section-height
+79246edc22961c2beb3520437e9d064d3b809d10 fix/annual-dag-ks4-national-selector
+59ac9c10b97e0ef1143f57fea06b324e72ac3d4a fix/chart-marker-contrast
+9f8dba227c95706ca3527bd48d381e7622cc0a5e fix/compare-chart-refetch-resilience
+e74d3882ce78a141fa1a57daa3102d7a58852dc3 fix/compare-expert-fixes
+80176cac4db4820e76ea2a156c7a2974bee2f203 fix/compare-final-review-mustfix
+f579630fab6c456e26a6984a3e8eebdbe3184202 fix/compare-mockup-drift
+dc85254ad2ddf134b4434065d4762cef374d2220 fix/compare-null-year-blanks-chart
+43a2c4a6bc539b621f31655aec05ef319a25f343 fix/compare-refresh-and-fetch
+d677b5453365b72c81d6df2de62b1fa0d05d684d fix/daily-dag-cache-invalidation
+f6bb037c471553e8195b5a8b147467ce0d07a688 fix/detail-all-through
+17bd4d5a5eb0b12ca79b97db587f14f7d671e85b fix/detail-chart-truthfulness
+4e6be0ce65647410b4ff74f8b763207c28920c26 fix/detail-inclusion-admissions
+fdda52ff0af3fae03a4b059a655973cdbb269f91 fix/detail-ofsted-correctness
+e36125b24aba254a8d15c5c33b4d2a296e691995 fix/detail-provenance-anchoring
+b31e71ac884df6507f567adc046c9fc52d9d310a fix/detail-report-card-render-date
+32f8a02862be6a1d49f4c3928b17fcf15d4c94cc fix/detail-trend-chart-taller
+e65688d600a86818fe21ae4c61ba27e5b6ec8d7c fix/e2e-brand-assertions
+3adea73ee04cdedfab54b0351878b297f72756ad fix/e2e-compare-chips-phase
+06e4898c30feaedc471f97aba28ddb0d61379f4d fix/e2e-compare-samephase
+9abd020967670a855e80fe5a908c8048a3aa9f14 fix/e2e-distance-locator
+acec8135e1ec7c9c3c255e5b23733a0ef862b590 fix/e2e-rankings-year-pick
+5944d88f0b1517ef1ef56af1b62270d2cf28e717 fix/expert-signoff-mustfixes
+2433101fa08be5df6f170d41790512ffe823d33e fix/font-cascade-and-map-palette
+74ca76d150deec6725259d9637ea86d7bb90c683 fix/gias-legacy-fallback
+bdaa05cd542f563ef74c45307cd8f7fc465193c9 fix/hero-fallback-and-sharp
+d52d384cf23d282b44e9251176f8f3402d808600 fix/hero-map-ios-fullscreen
+4043270a77bbe4edb18207fa5f1d94d4747fe12f fix/hero-mobile-and-wording
+22e9eb2d48b0d6623e88fd67cb6ca8e5e4074583 fix/homepage-education-accuracy
+8d50afef1e8a2b621b7344eadf475b0d609ad7a2 fix/leaflet-specificity-and-font-assertion
+b2b2cad5acf534ae7a667d3fb2be15efff37c4a7 fix/list-map-report-card-signal
+dc21e80a5e9eebd13aaab84735642eb77cef35e6 fix/mobile-cell-name-size
+e5f7f4c959f024c073472122d858333a0f24866c fix/mobile-compare-polish
+a00cbe916182d1e04661c750a1ce2e7ad27a68ae fix/mobile-sort-select-overflow
+2fd997bfe640c419a6713e85df008463de7f56e8 fix/modal-keyboard-viewport
+3e7705756776a0c44d27966dfc972023f1f38b69 fix/ofsted-link-text
+ce422e64363e2b03c186ef316832b6de15502d67 fix/promote-status-token
+4522cbf64560db1e1cd519e119aa466b42cd16a1 fix/proposed-to-close-copy
+15da060e4af37fbae919e0edf25f108266de2585 fix/rankings-admissions-accuracy
+6c872ce726f210433354ca38dc5314bc6a467534 fix/rankings-year-validation
+1c1df7796194af3d47f8e5ac0a0fbe6f323700e7 fix/report-card-chip-alignment
+b2dc4d0779ced02709429afaa5985acf4abda794 fix/results-map-ios-fullscreen
+95a5783da1fc994df76cb97238b55596dce4cd8f fix/runtime-api-proxy
+8a9ba30cc24e29653a72c03c0e817684b7db7c07 fix/sats-per-level-national
+536832a524fc4f9ed858f047e00b9a4d9d429c46 fix/school-detail-nan-500
+fef83b3bf244a9bf3cb4afa75dbc433d8725014f fix/schoolbar-sticky-offset
+b0c5b6bb57c879477da12c37b15cff950c29ebd3 fix/secondary-anchors-button-affordance
+261403bcd2b01aa4f26ee212e26302fc0f769bf9 fix/special-note-full-width
+ea5249a2ea6faf6bfa5a1522644387ba59770ec8 fix/standardise-distance-units
+e4565e9f158721d4df6b918f2b065de82851f8d9 fix/trends-chart-height
+3aad5101a842539105022f9059e85c224fc5973a fix/welsh-establishment-leak
+315f1feede70bdf3101d2fdd305b3d06e037fdac perf/batch-supplementary
+d2dc78aeb599e16b7ef5019be2b360b08df463bc perf/compare-loading
+e098ad4bd1130152705788d4773837b7d1e7112e perf/server-client-split
+
+## Deleted: superseded by PR #110 (content preserved on feat/seo-crawl-hygiene-main)
+786ec80dd4de4a3cb674a89e35b3b5e461639289 feat/seo-crawl-hygiene
+a5ac0bcd1b37bc10dcbce88f8601d01bf7b3eaaf feat/england-only-corpus

docs/superpowers/specs/2026-08-20-seo-programme-design.md

@@ -0,0 +1,309 @@
+# SEO Programme — Design
+
+Date: 2026-08-20
+Status: awaiting review
+
+## Problem
+
+schoolcompare ranks second for "school compare" — an exact match for the
+brand and the domain. It ranks poorly for "compare schools", "school
+comparison" and "schools near me". The first is a naming artefact and
+transfers to nothing; the rest are the queries that actually carry parent
+demand.
+
+The cause is structural, not editorial. The site publishes five route
+families:
+
+    /  /compare  /rankings  /admissions  /school/[slug]
+
+Location intent has no landing page at all. Every competitor outranking us
+on those queries wins with programmatic location pages:
+
+| Competitor    | URL pattern                                |
+|---------------|--------------------------------------------|
+| School Guide  | `/best-schools-in/manchester`              |
+| Locrating     | `/the-best-primary-schools-in-Manchester_…`|
+| FindMySchool  | `/best-primary-schools/manchester`         |
+| Snobe         | `/best-primary-schools/manchester`         |
+| School Atlas  | `/guides/best-primary-schools-manchester`  |
+
+"Schools near me" is a local-intent query. Google resolves it against the
+user's coordinates and serves pages that are *about a place*. A national
+homepage cannot win it. No title or description change fixes this; only
+pages Google can localise will.
+
+## Baseline (measured 2026-08-20, production API)
+
+| Measure                                    | Value   |
+|--------------------------------------------|---------|
+| Unique schools                              | 27,229  |
+| URLs in sitemap.xml                         | 27,232  |
+| Schools with 2024/25 performance data       | 21,266  |
+| Schools with **no** current performance data| ~5,963 (22%) |
+| Welsh establishments (all metrics null)     | 1,569   |
+| Overseas / offshore establishments           | 467     |
+| Static URLs in sitemap                      | 3       |
+| Routes setting a canonical                  | 1 of 5  |
+
+Three findings from that table drive the plan.
+
+**We submit ~6,000 thin pages to Google.** `build_sitemap()`
+(`backend/app.py:73`) enumerates every URN regardless of whether the school
+has any data. Welsh establishments return `school_type: "Welsh
+establishment"` with every performance metric, Ofsted grade and phase field
+null. Overseas and offshore establishments ("BFPO Overseas Establishments",
+"Gibraltar Overseas Establishments", "Jersey Offshore Establishments") are
+in the local-authority list too. At 22% of the submitted corpus this is a
+site-wide quality signal problem and a crawl-budget waste, not a rounding
+error.
+
+W1 item 4 removes 2,036 of those — every non-England establishment — taking
+the corpus to 25,193. The 3,927 that remain are English schools with no
+current data: mostly newly opened, special, nursery or alternative provision.
+Those are a template problem, not a corpus problem, and item 5 handles them
+separately.
+
+**The homepage is its own competitor.** `app/page.tsx` accepts eleven search
+params (`search`, `local_authority`, `school_type`, `phase`, `page`,
+`postcode`, `radius`, `sort`, `gender`, `admissions_policy`,
+`has_sixth_form`) and sets no canonical. Every filter combination is a
+crawlable near-duplicate of the single page we are asking to rank for
+"compare schools".
+
+**School pages are near-orphans.** Reachable from the sitemap and from site
+search, but almost nothing links to them contextually, so they accrue no
+internal authority.
+
+Also noted: the sitemap emits invented `priority` values and no `lastmod`.
+Google ignores `priority` and `changefreq` entirely; `lastmod` is the field
+it does read, and we omit it.
+
+## Keyword clusters
+
+Ranked by judgement of UK parent search behaviour and by the competitive
+SERP evidence above. Google Search Console is connected, so cluster
+priorities are to be re-derived from measured impressions before build
+starts (see Workstream 0).
+
+**C1 — Head "compare" terms.** compare schools · school comparison · school
+comparison tool · compare school performance · compare primary schools ·
+compare secondary schools · compare two schools
+
+**C2 — League tables and rankings.** primary school league tables ·
+secondary school league tables · school league tables 2026 · SATs results by
+school · GCSE results by school · KS2 league tables · Progress 8 rankings ·
+best primary schools in [town] · top 10 primary schools in [LA]
+
+**C3 — Local / near me.** schools near me · primary schools near me ·
+secondary schools near me · best schools near me · good schools near me ·
+schools in [town] · primary schools in [LA] · schools near [postcode] ·
+[postcode] school catchment
+
+**C4 — Individual school long tail.** [school] ofsted · [school] SATs
+results · [school] catchment area · [school] reviews · [school] URN
+
+**C5 — Admissions.** primary school admissions 2027 · national offer day
+2027 · school application deadline · school admissions appeal ·
+oversubscription criteria · distance criteria school admissions · didn't get
+first choice school · school admissions [LA]
+
+**C6 — Metric explainers.** what is a good SATs score · what is Progress 8 ·
+what is Attainment 8 · expected standard KS2 meaning · scaled score
+explained · Ofsted grades explained · Ofsted report cards · pupil premium
+explained
+
+**C7 — Head to head.** [school A] vs [school B] · academy vs community
+school · grammar school vs comprehensive · faith school vs community school
+
+## Workstreams
+
+### W0 — Measure before touching anything
+
+Export a Google Search Console baseline: impressions, clicks, average
+position and CTR by query and by page, for the trailing 16 months. Bucket
+queries into C1–C7. This sets the counterfactual — without it, no later
+claim about lift is defensible, because school-search traffic is strongly
+seasonal (results day in December, offer day in March/April).
+
+Re-rank C1–C7 against measured impressions and adjust the sequence below if
+the data disagrees with the judgement calls.
+
+### W1 — Crawl hygiene and index sanity
+
+Cheap, and it unblocks everything after it. Adding 5,000 pages on top of a
+corpus that is 22% thin would compound the existing problem.
+
+1. Canonical on every route. `/`, `/rankings`, `/compare` and `/admissions`
+   currently set none.
+2. The homepage canonicalises to `/` regardless of search params.
+3. `/compare?urns=…` gets `noindex, follow` — it is an unbounded parameter
+   space with no standalone value.
+4. **England only — DONE.** Wales, the Crown Dependencies, Gibraltar and the
+   service/overseas schools are removed from the corpus at the mart boundary,
+   not hidden at the view layer. `dim_school` and `dim_location` both exclude
+   `TypeOfEstablishment` in {25, 26, 30, 37} — Offshore schools, Service
+   children's education, Welsh establishment, British schools overseas —
+   listed once as `vars.non_england_school_type_codes` in `dbt_project.yml`.
+   That removes 2,036 establishments and 29 local authorities, and because
+   `build_sitemap()` reads the same marts, it drops them from the sitemap in
+   the same stroke. `assert_england_only_schools` fails the pipeline if a GIAS
+   refresh reintroduces them or if the two models drift apart.
+5. Prune the remaining thin pages: exclude any school with no performance data
+   **and** no Ofsted record. Distinct from item 4 — these are English schools
+   with nothing yet to show, so the fix may be a better template rather than
+   removal.
+6. Rebuild the sitemap as a sitemap **index**: one child per page family,
+   real `lastmod` from the data-load timestamp, `priority` and `changefreq`
+   dropped.
+
+### W2 — The location layer
+
+The dominant lever. `dim_location` already carries `town`, `county`,
+`local_authority_name`, `parliamentary_constituency`, `latitude`,
+`longitude` and `postcode`, so no new ingestion is required.
+
+Routes:
+
+    /schools/[la]                     e.g. /schools/manchester
+    /schools/[la]/primary
+    /schools/[la]/secondary
+    /best-primary-schools/[town]
+    /best-secondary-schools/[town]
+    /schools/near/[outcode]           e.g. /schools/near/m20
+    /schools/near-me                  geolocating hub
+
+**Thin-page threshold: generate a town or outcode page only where at least
+five schools have current performance data.** Below that, 301 to the parent
+LA page. This is the single most important constraint in the workstream —
+it is what separates a location layer from index bloat.
+
+Each page must earn its place with content a parent would actually use, not
+a template shell:
+
+- H1 matching the query intent ("Best primary schools in Manchester")
+- Counts framed usefully: "137 primary schools, 9 rated Outstanding"
+- A ranked table of the top 20 on the headline metric
+- Local average against the England average
+- Ofsted grade distribution
+- Map
+- Links to neighbouring towns and to the parent LA
+- An FAQ block (feeds `FAQPage` in W4)
+- Links to every school page in scope — this is what de-orphans W1's corpus
+
+Sizing estimate: ~150 usable LAs × 3 ≈ 450; towns clearing the threshold
+≈ 1,200 × 2 ≈ 2,400; outcodes ≈ 2,300. Roughly **5,000 new pages**,
+comfortably inside a sitemap index and well under the per-file 50,000 limit.
+
+### W3 — Make rankings indexable
+
+`/rankings` is driven entirely by query params, so Google indexes
+approximately one page where there should be hundreds.
+
+    /rankings/[phase]/[metric]
+    /rankings/[phase]/[metric]/[la]
+
+The interactive filter UI stays; its state moves into real paths. Param
+forms canonicalise to the clean path. This is the direct play for C2.
+
+### W4 — Structured data and internal linking
+
+- Replace the bare `EducationalOrganization` on school pages with `School`,
+  and populate it properly.
+- `BreadcrumbList` site-wide.
+- `ItemList` on every rankings and location page.
+- `FAQPage` on admissions and on location pages.
+- New school-page modules: "Other schools in [town]", "Nearby schools",
+  "Compare with similar schools". Each links out to W2 and W3 pages, which
+  is what circulates authority instead of stranding it.
+
+Explicitly **not** doing `Dataset` or `AggregateRating` — no review corpus
+exists, and fabricating one would be both useless and a policy violation.
+
+### W5 — Admissions expansion
+
+One static page currently carries an entire cluster.
+
+    /admissions/[la]                  per-authority deadlines and offer day
+    /admissions/appeals
+    /admissions/national-offer-day
+
+`school admissions [LA]` is high-intent and highly seasonal; per-authority
+pages are the natural unit.
+
+### W6 — Explainer content
+
+    /guides/progress-8
+    /guides/attainment-8
+    /guides/sats-scaled-scores
+    /guides/ofsted-grades
+    /guides/expected-standard
+
+Each links into the corresponding W3 rankings page. Cheap to build, and it
+is what gives the metric vocabulary enough topical weight to support C1–C4.
+
+### W7 — Head-to-head pages
+
+    /compare/[school-a]-vs-[school-b]
+
+C7 is uncontested and native to the product. It is also the easiest way to
+destroy everything W1 fixes: 27,229 schools generate 370 million pairs.
+**Curated pairs only** — same town, both with current data, both with real
+search demand — capped in the low thousands. Gated behind evidence that W2
+is indexing cleanly.
+
+### W8 — Metadata rewrite for C1
+
+Current homepage title is `schoolcompare | Compare every school in England`,
+which spends the most valuable position on the brand. Rewrite the homepage,
+rankings and compare titles and descriptions around C1 phrasing. Small
+change, and the cheapest item in the programme.
+
+## Sequencing
+
+    W0 → W1 → W2 → W3 → W4 → W5 → W6 → (W7 if W2 indexes cleanly)
+
+W1 before W2 is not negotiable: adding pages to a corpus that is 22% thin
+compounds the problem rather than diluting it.
+
+This spec is a programme, not a single implementation plan. Each workstream
+gets its own plan and its own PR; W2 will likely need several. Only W0 and W1
+are ready to plan against today — the rest should be re-read after W0's
+Search Console baseline lands, because that data may reorder them.
+
+## Testing
+
+Per CLAUDE.md, user-facing behaviour changes extend the `e2e/` journeys in
+the same PR. Each workstream adds:
+
+- W1: canonical present and correct on every route; `/compare?urns=` carries
+  `noindex`; sitemap excludes a known dataless URN.
+- W2: a known LA, town and outcode page renders with the expected school
+  count; a below-threshold town redirects to its LA.
+- W3: a clean rankings path renders; the param form canonicalises to it.
+- W4: JSON-LD parses and validates against the declared types.
+
+## Risks
+
+**Index bloat.** The failure mode of every programmatic SEO programme. The
+five-school threshold, the W1 prune and the W7 gate are the three controls.
+
+**Helpful-content exposure.** Google's stance on templated location pages
+has hardened. The mitigation is that each page carries genuinely local
+computed data — real counts, real distributions, real local-vs-national
+comparison — rather than a name substituted into boilerplate.
+
+**Build cost.** School pages already use ISR with a 7-day revalidate and
+`PRERENDER_SCHOOLS` gating full prerender. 5,000 more routes need the same
+treatment; full static generation of 32,000 pages is likely impractical in
+CI.
+
+**Seasonality.** Results day and offer day dominate the traffic curve.
+Judging the programme on a mid-summer window would misread it in either
+direction. W0's baseline must be year-on-year, not month-on-month.
+
+## Open questions
+
+1. Catchment areas are Locrating's moat and a strong C3 driver
+   (`[postcode] school catchment`). `fact_admissions` carries admission
+   distances. Is deriving approximate catchment a later workstream, or out
+   of scope?

docs/superpowers/specs/2026-08-21-w2-location-layer-design.md

@@ -0,0 +1,278 @@
+# W2: The Location Layer — Design
+
+Date: 2026-08-21
+Status: awaiting review
+Supersedes: workstream W2 in `2026-08-20-seo-programme-design.md`
+
+Scope note: this covers four page families in one spec. Splitting them — towns
+and authorities first, outcodes and localities after — was proposed and
+declined in favour of building the layer in one pass. The decomposition
+argument was that the curated locality seed needs human review and would hold
+up 783 pages of measured demand behind it; that risk is accepted here, and the
+implementation plan should sequence the seed early enough that review time
+does not become the critical path.
+
+## Problem
+
+Location intent is the largest unserved demand the site has. In the 16-month
+Search Console baseline it draws **874 impressions, one click, average
+position 49.5**. The site does not compete.
+
+Unlike named-school queries — which the same baseline showed to be
+navigational and unwinnable, since a parent typing "audley junior school"
+wants that school's own website — location queries have no incumbent owner.
+Nobody owns "primary schools in Brentwood" the way a school owns its name.
+
+The cause is structural: the site has no page about a place. Every competitor
+ranking above it does.
+
+## What the demand actually looks like
+
+Every location query in the baseline is **town or district level**. Not one is
+an administrative area:
+
+| Query | Impressions | Position |
+|-------|-------------|----------|
+| colleges in solihull | 112 | 51.2 |
+| schools in ramsey | 64 | 42.5 |
+| schools in crosby | 57 | 47.7 |
+| primary schools in beccles | 44 | 40.9 |
+| private schools in battersea | 41 | 71.9 |
+| secondary schools in brentwood | 37 | 56.1 |
+| secondary schools in canary wharf | 30 | 35.9 |
+
+Three patterns follow directly, and they drive the whole design.
+
+**Towns, not authorities.** The superseded W2 put `/schools/[la]` first and
+towns second. The data inverts that. Brentwood appears four times in different
+phrasings; Beccles twice. Both are towns, not authorities.
+
+**Phase is part of the query**, not a filter applied afterwards: "primary
+schools in beccles", "secondary schools in brentwood", "colleges in solihull".
+
+**London is searched by district** — Battersea, Canary Wharf — and the GIAS
+`town` field cannot serve it at all.
+
+## Measured sizing
+
+Counted against the live corpus of 25,185 schools, not estimated.
+
+| Family | Viable (≥5 schools) | Below threshold |
+|--------|--------------------|-----------------|
+| Towns | **783** | 907 → redirect to authority |
+| Outcodes | **1,760** | 305 |
+| Local authorities | 154 | — |
+| London localities | ~100–150 (curated) | — |
+
+With phase variants — 783 town pages plus roughly 700 primary and 250
+secondary variants, 154 authorities across three variants, 1,760 outcodes and
+the curated localities — the total lands near **4,000 pages**. Phase variants
+need their own threshold: there are 17,426 primaries but only 4,456 secondaries nationally,
+so most towns will support a primary page and not a secondary one.
+
+## Two design problems this spec exists to solve
+
+### 1. Town and authority names collide, and neither contains the other
+
+67 viable towns share a name with a local authority. The obvious fix — let the
+authority absorb the town, since it sounds like a superset — **does not work**:
+
+| Place | Schools in the town | Schools in the authority |
+|-------|--------------------|-----------------------|
+| Bedford | 104 | 86 |
+| Birmingham | 520 | 518 |
+| Derby | 157 | 119 |
+| Doncaster | 152 | 145 |
+
+The authority is the larger set in only 43 of the 67. Postal towns cross
+authority boundaries, so these are overlapping sets that happen to share a
+name. Publishing both into one namespace produces near-duplicate pages, which
+is the specific failure that sinks programmatic SEO.
+
+**Resolution: two namespaces.**
+
+```
+/schools/[place]              towns and London localities
+/schools/[place]/primary
+/schools/[place]/secondary
+/schools/authority/[la]       local authorities
+/schools/authority/[la]/primary
+/schools/authority/[la]/secondary
+/schools/near/[outcode]
+```
+
+Outcodes carry no phase variants: nobody searches "primary schools in SW11",
+so the variants would be pages without demand.
+
+Every collision disappears by construction. `/schools/[place]` keeps the clean
+URL for the pattern that carries the demand; authorities get a namespace whose
+purpose is genuinely different — admissions are authority-run, and the
+authority page is the one that can speak to catchment policy and LA averages.
+
+A place page and an authority page of the same name must each say plainly
+which set of schools they cover, or they read as duplicates to a reader even
+when they differ in fact.
+
+### 2. London has no locality field
+
+`town` collapses **1,819 London schools into the single value "London"**. A
+page listing all of them is useless, and borough pages do not help because
+people search "Battersea", not "Wandsworth".
+
+No single field solves it:
+
+| Search term | `parliamentary_constituency` | postcodes.io `admin_ward` |
+|-------------|------------------------------|---------------------------|
+| Battersea | **Battersea** ✓ | Northcote / Wandsworth Town ✗ |
+| Canary Wharf | Poplar and Limehouse ✗ | **Canary Wharf** ✓ |
+| Vauxhall | Vauxhall and Camberwell Green ✗ | **Vauxhall** ✓ |
+
+And neither covers Clapham, Shoreditch or Peckham, which are postal and
+colloquial rather than administrative.
+
+**Resolution: a curated seed mapping locality to outcodes.**
+
+```
+pipeline/transform/seeds/locality_outcodes.csv
+locality_slug,locality_name,outcodes,region
+battersea,Battersea,"SW11|SW8",London
+canary-wharf,Canary Wharf,"E14",London
+clapham,Clapham,"SW4|SW9",London
+```
+
+This needs **no new ingestion** — the corpus already has postcodes. It puts
+the fuzzy, contested part of the problem in a reviewable file rather than in
+derived logic, which suits it: locality boundaries are a judgement, not a
+fact. The repo already uses dbt seeds for curated reference data
+(`la_code_names.csv`, `gias_code_names.csv`), so this follows an established
+pattern.
+
+The seed generalises past London. Any colloquial place — Jesmond, Chorlton,
+Clifton — can be defined by its outcodes without a schema change.
+
+**Constraint:** a locality slug may not collide with a viable town slug. The
+place registry enforces this and fails the build rather than silently
+shadowing a town.
+
+## Architecture
+
+### The place registry
+
+One module owns the question "what places do we publish, and what is in each".
+Everything else reads from it: the pages, the sitemap, the internal links.
+
+```
+backend/places.py
+
+  Place = { kind: "town"|"locality"|"authority"|"outcode",
+            slug, name, urn_list, parent_authority | None }
+
+  build_place_registry(df) -> dict[str, Place]
+  place_schools(slug, phase=None) -> list[School]
+```
+
+Built once at startup from the same DataFrame the sitemap uses, and rebuilt by
+the existing `/api/admin/regenerate-sitemap` path after a pipeline run.
+Registry construction is where the threshold, the collision rules and the
+seed's uniqueness constraint are enforced — in one place, testable without a
+browser or a database.
+
+### API
+
+```
+GET /api/places                    the registry: slug, kind, name, count
+GET /api/places/{slug}?phase=      aggregate + ranked schools for one place
+```
+
+`/api/places` is what the sitemap and the internal-link modules enumerate.
+
+### Routes
+
+Next App Router, ISR with the same 7-day revalidate the school pages use.
+`generateStaticParams` gated behind an env flag, matching
+`PRERENDER_SCHOOLS`, because 3,900 more routes cannot be statically built in
+CI on every deploy.
+
+## What each page must contain
+
+A place page that is a name substituted into a template is the thing Google's
+helpful-content stance exists to demote. Each page carries computed local
+facts that exist nowhere else on the site:
+
+- **H1** matching the query: "Primary schools in Brentwood"
+- **Counts framed usefully**: "29 schools, 4 rated Outstanding"
+- **A ranked table** of the top 20 on the phase's headline metric —
+  `rwm_expected_pct` for primary, `attainment_8_score` for secondary, and for
+  an unphased place page the metric matching whichever phase it holds more of
+- **The local average against the England average** — the one number a parent
+  cannot get from a list
+- **Ofsted grade distribution** for the place
+- **A map**
+- **Links to neighbouring places** and to the parent authority
+- **An FAQ block**, feeding `FAQPage` structured data
+- **A link to every school page in scope** — this is what finally de-orphans
+  the 23,000 school pages the original spec identified as near-orphans
+
+## Thin-page controls
+
+Three, and they are the difference between a location layer and index bloat:
+
+1. **Five schools with current data minimum.** Below it, 301 to the parent
+   authority. This drops 907 towns and 305 outcodes.
+2. **Per-phase thresholds.** A town with 30 primaries and 2 secondaries
+   publishes a primary page and no secondary page.
+3. **No page without a local average.** If a place has too few schools with
+   results to compute one, it has nothing to say that a list does not, and it
+   falls back to the authority.
+
+## Sitemap
+
+Two new children in the existing index: `/sitemaps/places-{n}.xml` and
+`/sitemaps/outcodes-{n}.xml`. Per-family children are why the index was built
+in W1 — Search Console reports coverage per submitted sitemap, so indexation
+of the location layer is measurable separately from the school pages.
+
+## Testing
+
+Per `CLAUDE.md`, user-facing behaviour extends `e2e/tests/journeys.spec.ts` in
+the same PR.
+
+**Unit (registry, no DB):** threshold enforcement; a sub-threshold town
+resolves to its authority; a locality slug colliding with a town fails the
+build; Bedford's town and authority pages hold different URN sets; per-phase
+thresholds.
+
+**Backend:** `/api/places` shape; `/api/places/{slug}` aggregate correctness
+against a fixture; unknown slug 404s.
+
+**e2e:** a known town, authority, locality and outcode page each render with
+the expected count; a below-threshold town 301s; every place page declares a
+canonical and appears in the sitemap; `/schools/bedford` and
+`/schools/authority/bedford` both resolve and state which set they cover.
+
+## Risks
+
+**Index bloat** is the failure mode of every programmatic SEO programme. The
+three controls above are the answer, and the per-family sitemap is how we find
+out early if they were not enough.
+
+**Helpful-content exposure.** Templated location pages are exactly what
+Google's stance targets. The mitigation is that every page carries real
+computed local data — counts, distributions, local-versus-national comparison
+— rather than a name dropped into boilerplate. If indexation of the places
+sitemap stalls below roughly half, that is the signal to stop and rethink
+rather than to add more pages.
+
+**Build cost.** ~4,000 additional ISR routes on top of 23,000 school pages.
+The env-flag gate on `generateStaticParams` keeps CI viable.
+
+**Curation drift.** The locality seed is hand-maintained and will go stale as
+places change. It is small and reviewable, and a dbt test asserts every seed
+outcode matches at least one school so a typo fails the pipeline rather than
+publishing an empty page.
+
+## Out of scope
+
+Catchment-area estimation. It is a strong driver for this cluster and
+`fact_admissions` carries the distances, but it is a modelling problem with
+real accuracy risk and deserves its own design.

e2e/tests/journeys.spec.ts

@@ -1226,21 +1226,13 @@ const CUTOFF_CANDIDATE_URNS = [
   101099, 100553, 102574, 100769,                 // mixed
 ];
 
-async function schoolWithCutoff(page: Page, minPublishedYears = 1) {
+async function schoolWithCutoff(page: Page) {
   for (const urn of CUTOFF_CANDIDATE_URNS) {
     const res = await page.request.get(`/api/schools/${urn}`);
     if (!res.ok()) continue;
     const body = await res.json();
     if (body?.admission_distance?.distance_m == null) continue;
-    const published = (body.admission_distance_history ?? [])
-      .filter((h: { distance_m?: number | null }) => h.distance_m != null);
-    if (published.length < minPublishedYears) continue;
-    return {
-      urn,
-      distance: body.admission_distance,
-      history: published,
-      phase: body.school_info?.phase,
-    };
+    return { urn, distance: body.admission_distance, phase: body.school_info?.phase };
   }
   return null;
 }
@@ -1260,7 +1252,11 @@ test('a published cut-off distance is shown with the year it belongs to', async
   await expect(label).toContainText(`September ${found!.distance.year}`);
 
   // And the figure itself, in the unit councils publish in.
-  await expect(page.getByText(/\d+(\.\d+)? (miles|m)\b/).first()).toBeVisible();
+  // No trailing \b: the tile's support figure is an adjacent text node, so
+  // the element reads "0.88 miles 1.4 km" and a word boundary after "miles"
+  // is not guaranteed. The leading shape is what matters — a decimal figure
+  // in miles, never a metric one.
+  await expect(page.getByText(/\d+\.\d+ miles/).first()).toBeVisible();
 });
 
 test('a cut-off distance is never shown without saying it is not a catchment', async ({ page }) => {
@@ -1317,103 +1313,575 @@ test('no school page shows an implausible cut-off distance', async ({ page }) =>
 
 // ── The Distance view, map and postcode check ────────────────────────────
 
-test('a school with several published years gets the Distance view', async ({ page }) => {
-  const found = await schoolWithCutoff(page, 2);
-  test.skip(found === null, 'no school in the sample has 2+ published cut-off years yet');
-
-  await page.goto(`/school/${found!.urn}`);
-  await expect(page.locator('#admissions')).toBeVisible({ timeout: 15_000 });
-
-  const isSecondary = /secondary/i.test(found!.phase ?? '');
-  if (!isSecondary) {
-    // Primary pages carry a segmented control; the detail sits behind it.
-    const distanceTab = page.getByRole('button', { name: 'Distance' });
-    await expect(distanceTab).toBeVisible();
-    await distanceTab.click();
-    await expect(distanceTab).toHaveAttribute('aria-pressed', 'true');
-  }
-
-  // Every published year must appear as a row, whichever template rendered it.
-  for (const h of found!.history as { year: number }[]) {
-    await expect(page.getByRole('rowheader', { name: String(h.year) })).toBeVisible();
+test('the public API serves the latest cut-off only', async ({ page }) => {
+  /*
+   * Earlier years are held back as a paid feature. This endpoint is public and
+   * unauthenticated, so withholding them in the UI alone would be decoration:
+   * anyone could read the history out of the network tab. The mart still holds
+   * every year — this asserts what leaves the process, not what was collected.
+   */
+  let checked = 0;
+  for (const urn of CUTOFF_CANDIDATE_URNS) {
+    const res = await page.request.get(`/api/schools/${urn}`);
+    if (!res.ok()) continue;
+    const body = await res.json();
+    if (body?.admission_distance?.distance_m == null) continue;
+    checked += 1;
+    expect(body, `URN ${urn} still exposes a cut-off history`)
+      .not.toHaveProperty('admission_distance_history');
   }
+  test.skip(checked === 0, 'no cut-off distances available to check yet');
 });
 
-test('the year table never leaves a gap unexplained', async ({ page }) => {
-  // A blank row would tell a parent nothing; each gap must name its reason.
-  const found = await schoolWithCutoff(page, 2);
-  test.skip(found === null, 'no school in the sample has 2+ published cut-off years yet');
+test('a school page shows no year-by-year cut-off record', async ({ page }) => {
+  const found = await schoolWithCutoff(page);
+  test.skip(found === null, 'no school in the sample has a published cut-off yet');
 
   await page.goto(`/school/${found!.urn}`);
   await expect(page.locator('#admissions')).toBeVisible({ timeout: 15_000 });
-  if (!/secondary/i.test(found!.phase ?? '')) {
-    await page.getByRole('button', { name: 'Distance' }).click();
-  }
 
-  const statuses = await page.locator('[class*="cutoffPill"]').allTextContents();
-  expect(statuses.length).toBeGreaterThan(0);
-  for (const s of statuses) {
-    expect(s.trim(), 'every row carries a status').not.toBe('');
-  }
-  // The stronger claim the data cannot support must never appear.
-  await expect(page.getByText(/every applicant was offered/i)).toHaveCount(0);
+  // The render side of the same rule, so a future component cannot put the
+  // history back without the API.
+  await expect(page.getByText(/Last distance offered, by year/)).toHaveCount(0);
+  await expect(page.getByText(/too few to read as a trend/)).toHaveCount(0);
+
+  /*
+   * No "Distance" tab in the admissions segmented control.
+   *
+   * Scoped to the control, and exact, because getByRole matches accessible
+   * names by case-insensitive SUBSTRING: an unscoped { name: 'Distance' }
+   * matched "Show this distance on a map" — the map toggle added by this same
+   * feature — and failed a page that was entirely correct. Naming the group
+   * this assertion is about also means unrelated copy elsewhere on the page
+   * can never break it again.
+   */
+  const viewToggle = page.getByRole('group', { name: 'Admissions view' });
+  const tabs = await viewToggle.getByRole('button').allTextContents();
+
+  // Read the tabs positively rather than asserting an absence against a
+  // locator that might resolve to nothing: if the group selector ever stops
+  // matching, an absence check passes for the wrong reason, which is how the
+  // bug this test is guarding would slip back in unnoticed.
+  expect(tabs, 'admissions view toggle did not resolve').toContain('This year');
+  expect(tabs.map((s) => s.trim()), `admissions tabs: ${tabs.join(', ')}`)
+    .not.toContain('Distance');
 });
 
-test('the postcode check answers with a distance and per-year verdicts', async ({ page }) => {
-  const found = await schoolWithCutoff(page, 2);
-  test.skip(found === null, 'no school in the sample has 2+ published cut-off years yet');
+test('the postcode check answers for the published year, and names it', async ({ page }) => {
+  const found = await schoolWithCutoff(page);
+  test.skip(found === null, 'no school in the sample has a published cut-off yet');
 
   await page.goto(`/school/${found!.urn}`);
-  await expect(page.locator('#admissions')).toBeVisible({ timeout: 15_000 });
-  if (!/secondary/i.test(found!.phase ?? '')) {
-    await page.getByRole('button', { name: 'Distance' }).click();
-  }
+  const section = page.locator('#distance');
+  // Needs coordinates as well as a figure; not every school has both.
+  test.skip(await section.count() === 0, 'this school has no distance section');
+  await expect(section).toBeVisible({ timeout: 15_000 });
 
-  const input = page.getByLabel('Your postcode');
-  await expect(input).toBeVisible();
-  await input.fill('SW1A 1AA');
-  await page.getByRole('button', { name: 'Check' }).click();
+  await page.getByLabel('Your postcode').fill('SW1A 1AA');
+  await page.getByRole('button', { name: 'Check', exact: true }).click();
 
-  // Either a verdict or a plain error — never a silent no-op.
   const result = page.getByRole('status');
   const error = page.getByRole('alert');
   await expect(result.or(error)).toBeVisible({ timeout: 20_000 });
 
   if (await result.isVisible()) {
-    await expect(result).toContainText(/mile|m\b/);
+    // A verdict without its year is a number a parent cannot place.
+    await expect(result).toContainText(new RegExp(`September ${found!.distance.year}`));
+    await expect(result).toContainText(/inside|beyond|too close/);
+
+    // Both figures in the sentence must be in the same unit. The verdict used
+    // to render the home distance in metres and the cut-off in miles — "69 m
+    // away — inside the September 2026 cut-off of 0.17 miles" — which asks the
+    // reader to convert between units to check a comparison already made for
+    // them. Miles throughout: the unit councils publish and quote.
+    const headline = (await result.textContent()) ?? '';
+    const verdictLine = headline.split('.')[0];
+    expect(verdictLine, `verdict mixes units: ${verdictLine}`).not.toMatch(/\d\s?m\b/);
+    expect((verdictLine.match(/miles/g) ?? []).length,
+      `verdict should quote two figures in miles: ${verdictLine}`).toBe(2);
   }
 });
 
 test('the postcode check states its limits before it is used', async ({ page }) => {
-  // The caveat is not revealed with the answer — it is there while the parent
-  // is deciding whether to trust the answer at all.
-  const found = await schoolWithCutoff(page, 2);
-  test.skip(found === null, 'no school in the sample has 2+ published cut-off years yet');
+  const found = await schoolWithCutoff(page);
+  test.skip(found === null, 'no school in the sample has a published cut-off yet');
 
   await page.goto(`/school/${found!.urn}`);
-  await expect(page.locator('#admissions')).toBeVisible({ timeout: 15_000 });
-  if (!/secondary/i.test(found!.phase ?? '')) {
-    await page.getByRole('button', { name: 'Distance' }).click();
-  }
+  const section = page.locator('#distance');
+  test.skip(await section.count() === 0, 'this school has no distance section');
+  await expect(section).toBeVisible({ timeout: 15_000 });
 
-  await expect(page.getByText(/An indication only/)).toBeVisible();
-  await expect(page.getByText(/not a catchment boundary/)).toBeVisible();
+  const caveat = page.getByText(/Distance is the last criterion applied/);
+  await expect(caveat).toBeVisible();
+  await expect(caveat).toContainText(/not a catchment boundary/);
+  await expect(caveat).toContainText(/walking route/);
+  await expect(caveat).toHaveCount(1);
 });
 
 test('the distance section never scrolls the page sideways', async ({ page }) => {
-  const found = await schoolWithCutoff(page, 2);
-  test.skip(found === null, 'no school in the sample has 2+ published cut-off years yet');
+  const found = await schoolWithCutoff(page);
+  test.skip(found === null, 'no school in the sample has a published cut-off yet');
 
   await page.setViewportSize({ width: 390, height: 844 });
   await page.goto(`/school/${found!.urn}`);
-  await expect(page.locator('#admissions')).toBeVisible({ timeout: 15_000 });
-  if (!/secondary/i.test(found!.phase ?? '')) {
-    await page.getByRole('button', { name: 'Distance' }).click();
-  }
+  const section = page.locator('#distance');
+  test.skip(await section.count() === 0, 'this school has no distance section');
+  await expect(section).toBeVisible({ timeout: 15_000 });
 
-  // The year table is deliberately wider than a phone; its own wrapper has to
-  // absorb that, or the whole page slides under the reader's thumb.
   const overflow = await page.evaluate(() =>
     document.documentElement.scrollWidth - document.documentElement.clientWidth);
   expect(overflow, 'page must not scroll horizontally').toBeLessThanOrEqual(1);
 });
+
+test('no single section dominates the height of a school page', async ({ page }) => {
+  /*
+   * The admissions views are stacked in one grid cell so switching them never
+   * shifts layout, which means the card is sized by its TALLEST view while the
+   * hidden ones keep their box. A distance view carrying a chart, a table and a
+   * map was added there and measured 1402px against the tile grid's 316px; the
+   * DEFAULT view rendered as four tiles adrift in ~1080px of blank card, and
+   * Admissions alone came to half the height of every section on the page
+   * (1503px against 526px for the next largest).
+   *
+   * Measuring the card's internals cannot catch it: the tile grid is
+   * `flex: 1`, so it absorbs the stretch and every box still looks full. What
+   * a reader actually sees is one section wildly out of proportion with its
+   * neighbours, so that is what this asserts.
+   */
+  const found = await schoolWithCutoff(page);
+  test.skip(found === null, 'no school in the sample has 2+ published cut-off years yet');
+
+  await page.goto(`/school/${found!.urn}`);
+  await expect(page.locator('#admissions')).toBeVisible({ timeout: 15_000 });
+  await page.waitForTimeout(1200); // charts settle, and they carry real height
+
+  const sections = await page.evaluate(() =>
+    [...document.querySelectorAll('section[id]')]
+      .map((s) => ({ id: s.id, h: Math.round(s.getBoundingClientRect().height) }))
+      .filter((s) => s.h > 0));
+
+  expect(sections.length).toBeGreaterThanOrEqual(3);
+  const heights = sections.map((s) => s.h).sort((a, b) => a - b);
+  const median = heights[Math.floor(heights.length / 2)];
+  const worst = sections.reduce((a, b) => (a.h > b.h ? a : b));
+
+  // Generous: a rich section may fairly run to twice a plain one. Nearly three
+  // times over is the shape of a layout fault, not of denser content.
+  expect(
+    worst.h / median,
+    `#${worst.id} is ${worst.h}px against a ${median}px median: `
+      + sections.map((s) => `${s.id}=${s.h}`).join(', '),
+  ).toBeLessThan(2.5);
+});
+
+/*
+ * England-only corpus.
+ *
+ * GIAS ships the whole UK plus overseas and offshore establishments, none of
+ * which carry comparable DfE performance data. dim_school and dim_location
+ * exclude them (vars.non_england_school_type_codes in dbt_project.yml), which
+ * keeps them out of the site, the filter lists and the sitemap together.
+ *
+ * These assert the published surface, not the warehouse: the dbt test
+ * assert_england_only_schools guards the marts, and these guard what the
+ * environment actually serves once the marts have been rebuilt.
+ */
+
+const WELSH_AUTHORITIES = [
+  'Blaenau Gwent', 'Bridgend', 'Caerphilly', 'Cardiff', 'Carmarthenshire',
+  'Ceredigion', 'Conwy', 'Denbighshire', 'Flintshire', 'Gwynedd',
+  'Isle of Anglesey', 'Merthyr Tydfil', 'Monmouthshire', 'Neath Port Talbot',
+  'Newport', 'Pembrokeshire', 'Powys', 'Rhondda Cynon Taf', 'Swansea',
+  'Torfaen', 'Vale of Glamorgan', 'Wrexham',
+];
+
+const NON_ENGLAND_AUTHORITIES = [
+  'BFPO Overseas Establishments', 'Fieldwork Overseas Establishments',
+  'Gibraltar Overseas Establishments', 'Guernsey Offshore Establishments',
+  'Isle of Man Offshore Establishments', 'Jersey Offshore Establishments',
+  'Scotland Offshore Establishments',
+];
+
+const NON_ENGLAND_TYPES = [
+  'Welsh establishment', 'Offshore schools',
+  "Service children's education", 'British schools overseas',
+];
+
+test('the local authority filter offers no Welsh or overseas authority', async ({ page }) => {
+  const res = await page.request.get('/api/filters');
+  expect(res.ok()).toBeTruthy();
+  const { local_authorities: las } = await res.json();
+
+  expect(Array.isArray(las)).toBeTruthy();
+  // Guards against the list being empty, which would pass the check below
+  // for the wrong reason.
+  expect(las.length).toBeGreaterThan(100);
+
+  const leaked = [...WELSH_AUTHORITIES, ...NON_ENGLAND_AUTHORITIES]
+    .filter((la) => las.includes(la));
+  expect(leaked, `non-England authorities still offered: ${leaked.join(', ')}`)
+    .toEqual([]);
+});
+
+test('the school type filter offers no non-England establishment type', async ({ page }) => {
+  const res = await page.request.get('/api/filters');
+  expect(res.ok()).toBeTruthy();
+  const { school_types: types } = await res.json();
+
+  expect(Array.isArray(types)).toBeTruthy();
+  expect(types.length).toBeGreaterThan(10);
+
+  const leaked = NON_ENGLAND_TYPES.filter((t) => types.includes(t));
+  expect(leaked, `non-England types still offered: ${leaked.join(', ')}`)
+    .toEqual([]);
+});
+
+test('searching a Welsh authority by name returns no schools', async ({ page }) => {
+  // Cardiff held 144 Welsh establishments and nothing else, so the authority
+  // should now be absent from the corpus entirely rather than merely thinned.
+  const res = await page.request.get('/api/schools?local_authority=Cardiff&page_size=1');
+  expect(res.ok()).toBeTruthy();
+  const body = await res.json();
+  expect(body.total ?? (body.schools ?? []).length).toBe(0);
+});
+
+test('a Welsh school GIAS does not type as Welsh is gone too', async ({ page }) => {
+  // Beechwood College, Sully, CF64 5SE. GIAS types it "Special post 16
+  // institution" (32), not "Welsh establishment" (30), so the establishment
+  // type filter alone left it behind — it was the last Welsh school standing.
+  const res = await page.request.get('/api/schools?local_authority=Vale%20of%20Glamorgan&page_size=1');
+  expect(res.ok()).toBeTruthy();
+  const body = await res.json();
+  expect(body.total ?? (body.schools ?? []).length).toBe(0);
+
+  const page404 = await page.goto('/school/142458-beechwood-college');
+  expect(page404?.status()).toBe(404);
+});
+
+test('English schools with Welsh postcodes are kept', async ({ page }) => {
+  // Royal Mail postcode areas straddle the border: these Gloucestershire
+  // schools carry NP16/NP25 postcodes but are English schools with English
+  // data. A postcode-based filter would have wrongly deleted them, so this
+  // guards the fix from being "simplified" into one.
+  for (const urn of [115639, 115655, 137382]) {
+    const res = await page.request.get(`/api/schools/${urn}`);
+    expect(res.ok(), `URN ${urn} should still resolve`).toBeTruthy();
+    const { school_info } = await res.json();
+    expect(school_info.local_authority).toBe('Gloucestershire');
+  }
+});
+
+test('a Welsh school URL 404s while an English one still resolves', async ({ page }) => {
+  // Paired on purpose: the Welsh assertion alone would also pass if the whole
+  // site were down, which is the failure this test most needs to distinguish.
+  const english = await page.request.get('/api/schools?search=primary&per_page=1');
+  expect(english.ok()).toBeTruthy();
+  const [first] = (await english.json()).schools ?? [];
+  expect(first, 'no English school available to compare against').toBeTruthy();
+
+  const good = await page.goto(`/school/${first.urn}-x`);
+  expect(good?.status(), 'an English school should still resolve').toBeLessThan(400);
+
+  // Adamsdown Primary School, Cardiff — a Welsh establishment (URN 401559).
+  const welsh = await page.goto('/school/401559-adamsdown-primary-school');
+  expect(welsh?.status(), 'a Welsh school should no longer resolve').toBe(404);
+});
+
+async function sitemapChildren(page: Page): Promise<string[]> {
+  const res = await page.request.get('/sitemap.xml');
+  expect(res.ok()).toBeTruthy();
+  const index = await res.text();
+  expect(index).toContain('<sitemapindex');
+  return [...index.matchAll(/<loc>([^<]+)<\/loc>/g)].map((m) => m[1]);
+}
+
+test('the sitemap index names children that all resolve', async ({ page }) => {
+  const index = await (await page.request.get('/sitemap.xml')).text();
+  // An index holds <sitemap> entries only; mixing in <url> is invalid.
+  expect(index).not.toContain('<url>');
+
+  const locs = await sitemapChildren(page);
+  expect(locs.length).toBeGreaterThanOrEqual(2);
+
+  for (const loc of locs) {
+    expect(loc.startsWith('https://www.schoolcompare.co.uk/sitemaps/')).toBeTruthy();
+    const child = await page.request.get(new URL(loc).pathname);
+    expect(child.ok(), `${loc} should resolve`).toBeTruthy();
+    expect(await child.text()).toContain('<urlset');
+  }
+});
+
+test('the sitemap submits no Welsh or overseas school', async ({ page }) => {
+  const locs = await sitemapChildren(page);
+
+  let total = 0;
+  for (const loc of locs) {
+    const xml = await (await page.request.get(new URL(loc).pathname)).text();
+    total += (xml.match(/<url>/g) ?? []).length;
+    // 401559 (Adamsdown, Cardiff) and 402426 (ACT Schools, Cardiff) were both
+    // submitted before the England-only filter landed.
+    expect(xml).not.toContain('/school/401559');
+    expect(xml).not.toContain('/school/402426');
+  }
+  expect(total, 'sitemap looks empty or truncated').toBeGreaterThan(1000);
+});
+
+test('the sitemap invents no priority or changefreq', async ({ page }) => {
+  const [first] = await sitemapChildren(page);
+  expect(first).toBeTruthy();
+
+  const xml = await (await page.request.get(new URL(first).pathname)).text();
+  // Google ignores both. They were noise dressed as signal.
+  expect(xml).not.toContain('<priority>');
+  expect(xml).not.toContain('<changefreq>');
+});
+
+/*
+ * Canonical URLs (spec 2026-08-20, W1).
+ *
+ * Every indexable route declares exactly one canonical, on the www host, with
+ * no query string. The homepage's eleven search params filter a result set
+ * rather than making a new document, so they all collapse onto "/".
+ */
+const CANONICAL_ROUTES: Array<[string, string]> = [
+  ['/', 'https://www.schoolcompare.co.uk/'],
+  ['/rankings', 'https://www.schoolcompare.co.uk/rankings'],
+  ['/admissions', 'https://www.schoolcompare.co.uk/admissions'],
+];
+
+for (const [path, expected] of CANONICAL_ROUTES) {
+  test(`${path} declares exactly one canonical, on the www host`, async ({ page }) => {
+    await page.goto(path);
+    const hrefs = await page.locator('link[rel="canonical"]').evaluateAll(
+      (els) => els.map((e) => e.getAttribute('href')));
+    expect(hrefs, `${path} should declare one canonical`).toHaveLength(1);
+    expect(hrefs[0]).toBe(expected);
+  });
+}
+
+test('a filtered homepage still canonicalises to the bare root', async ({ page }) => {
+  await page.goto('/?search=primary&phase=primary&sort=name&page=2');
+  const href = await page.locator('link[rel="canonical"]').first()
+    .getAttribute('href');
+  expect(href).toBe('https://www.schoolcompare.co.uk/');
+});
+
+test('a school page canonicalises to its own slug on the www host', async ({ page }) => {
+  const res = await page.request.get('/api/schools?search=primary&per_page=1');
+  expect(res.ok()).toBeTruthy();
+  const [first] = (await res.json()).schools ?? [];
+  expect(first, 'no school available').toBeTruthy();
+
+  await page.goto(`/school/${first.urn}-x`);
+  const href = await page.locator('link[rel="canonical"]').first()
+    .getAttribute('href');
+  expect(href).toMatch(/^https:\/\/www\.schoolcompare\.co\.uk\/school\/\d+-/);
+});
+
+test('a bare /compare is indexable, a parameterised one is not', async ({ page }) => {
+  await page.goto('/compare');
+  await expect(page.locator('meta[name="robots"]')).toHaveCount(0);
+
+  const [a, b] = await twoPrimaryUrns(page);
+  await page.goto(`/compare?urns=${a},${b}`);
+  const robots = await page.locator('meta[name="robots"]').first()
+    .getAttribute('content');
+  expect(robots).toContain('noindex');
+  expect(robots).toContain('follow');
+
+  // noindex but follow: the links out to each school page still count, so the
+  // canonical must still be present and point at the bare path.
+  const canonical = await page.locator('link[rel="canonical"]').first()
+    .getAttribute('href');
+  expect(canonical).toBe('https://www.schoolcompare.co.uk/compare');
+});
+
+/*
+ * Staging must not be indexable (spec 2026-08-20, W1 hygiene).
+ *
+ * These journeys only ever run against staging — deploy.yml passes
+ * STAGING_BASE_URL, and promote.yml only smoke-polls production without
+ * Playwright — so asserting the noindex header here is safe.
+ */
+test('staging answers noindex, and stays crawlable so the noindex is seen', async ({ page }) => {
+  const res = await page.request.get('/');
+  expect(res.ok()).toBeTruthy();
+
+  const tag = res.headers()['x-robots-tag'];
+  expect(tag, 'staging must send X-Robots-Tag').toBeTruthy();
+  expect(tag).toContain('noindex');
+
+  // The other half, and the reason this is one test rather than two: a
+  // Disallow would stop Google fetching the page at all, so it would never
+  // see the noindex above. The two only work together.
+  const robots = await (await page.request.get('/robots.txt')).text();
+  expect(robots).not.toMatch(/^\s*Disallow:\s*\/\s*$/mi);
+});
+
+test('a school page on staging is noindexed too, not just the homepage', async ({ page }) => {
+  const list = await page.request.get('/api/schools?search=primary&per_page=1');
+  const [first] = (await list.json()).schools ?? [];
+  expect(first, 'no school available').toBeTruthy();
+
+  const res = await page.request.get(`/school/${first.urn}-x`);
+  expect(res.headers()['x-robots-tag']).toContain('noindex');
+});
+
+/*
+ * W8 — the C1 pages must ship a description, and it must differentiate.
+ *
+ * Baseline was 0.43% CTR at position 6.1 on "compare school performance",
+ * against 9.16% for the brand query from the same neighbourhood. The SERP is
+ * owned by the DfE's own service, so a description that paraphrases it earns
+ * nothing. Google may rewrite a snippet, but it cannot use one we never sent.
+ */
+test('every C1 page ships a description, and none opens its title with the brand', async ({ page }) => {
+  for (const path of ['/', '/compare', '/rankings', '/admissions']) {
+    await page.goto(path);
+
+    const desc = await page.locator('meta[name="description"]').first()
+      .getAttribute('content');
+    expect(desc, `${path} must ship a description`).toBeTruthy();
+    expect(desc!.length, `${path} description too short to be worth reading`)
+      .toBeGreaterThan(100);
+
+    const title = await page.title();
+    expect(title.toLowerCase().startsWith('schoolcompare'),
+      `${path} spends its most valuable pixels on the brand`).toBe(false);
+  }
+});
+
+test('the homepage snippet names what gov.uk does not publish', async ({ page }) => {
+  await page.goto('/');
+  const desc = await page.locator('meta[name="description"]').first()
+    .getAttribute('content');
+  // Admissions distance is the one fact the DfE service has no equivalent for.
+  expect(desc).toMatch(/close you had to live|distance/i);
+});
+
+/*
+ * The location layer (spec 2026-08-21, W2).
+ *
+ * Location intent sat at position 49.5 with one click across the whole 16-month
+ * baseline — the site published no page about a place. These assert the four
+ * families render, stay in their own namespaces, and reach the sitemap.
+ */
+async function firstPlaceOfKind(page: Page, kind: string) {
+  const res = await page.request.get('/api/places');
+  expect(res.ok()).toBeTruthy();
+  const { places } = await res.json();
+  const hit = places.find((p: { kind: string }) => p.kind === kind);
+  expect(hit, `no ${kind} in the registry`).toBeTruthy();
+  return hit as { kind: string; slug: string; name: string; count: number };
+}
+
+for (const [kind, prefix, article] of [
+  ['town', '/schools/', 'a'],
+  ['authority', '/schools/authority/', 'an'],
+  ['outcode', '/schools/near/', 'an'],
+] as const) {
+  test(`${article} ${kind} page renders with its school count`, async ({ page }) => {
+    const place = await firstPlaceOfKind(page, kind);
+    await page.goto(`${prefix}${place.slug}`);
+    await expect(page.locator('h1')).toContainText(place.name, { ignoreCase: true });
+    await expect(page.locator('a[href^="/school/"]').first()).toBeVisible();
+  });
+}
+
+test('a town and an authority sharing a name are different pages', async ({ page }) => {
+  // 67 real collisions, and the authority is the larger set in only 43 — so
+  // one namespace would have published near-duplicates.
+  const { places } = await (await page.request.get('/api/places')).json();
+  const townSlugs = new Set(
+    places.filter((p: { kind: string }) => p.kind === 'town')
+      .map((p: { slug: string }) => p.slug));
+  const clash = places.find((p: { kind: string; slug: string }) =>
+    p.kind === 'authority' && townSlugs.has(p.slug));
+  test.skip(!clash, 'no town/authority name collision in this environment');
+
+  const townRes = await page.request.get(`/api/places/town/${clash.slug}`);
+  const laRes = await page.request.get(`/api/places/authority/${clash.slug}`);
+  expect(townRes.ok() && laRes.ok()).toBeTruthy();
+  const townUrns = (await townRes.json()).schools.map((s: { urn: number }) => s.urn).sort();
+  const laUrns = (await laRes.json()).schools.map((s: { urn: number }) => s.urn).sort();
+  expect(townUrns).not.toEqual(laUrns);
+});
+
+test('a place below the threshold has no page', async ({ page }) => {
+  // Crosby holds one school; publishing it would be a page with nothing to say.
+  const res = await page.request.get('/api/places/town/crosby');
+  expect(res.status()).toBe(404);
+});
+
+test('place pages declare a canonical and reach the sitemap', async ({ page }) => {
+  const place = await firstPlaceOfKind(page, 'town');
+  await page.goto(`/schools/${place.slug}`);
+  const canonical = await page.locator('link[rel="canonical"]').first()
+    .getAttribute('href');
+  expect(canonical).toBe(`https://www.schoolcompare.co.uk/schools/${place.slug}`);
+
+  const xml = await (await page.request.get('/sitemaps/places-1.xml')).text();
+  expect(xml).toContain(`/schools/${place.slug}`);
+});
+
+test('the place page ships ItemList structured data that parses', async ({ page }) => {
+  const place = await firstPlaceOfKind(page, 'town');
+  await page.goto(`/schools/${place.slug}`);
+  const raw = await page.locator('script[type="application/ld+json"]').first()
+    .textContent();
+  const parsed = JSON.parse(raw!);
+  const types = (parsed['@graph'] ?? []).map((n: { '@type': string }) => n['@type']);
+  expect(types).toContain('ItemList');
+  expect(types).toContain('BreadcrumbList');
+});
+
+test('a place page states the local average against England', async ({ page }) => {
+  // The one number a list cannot give, and the reason these pages are not
+  // a name dropped into a template.
+  const place = await firstPlaceOfKind(page, 'town');
+  await page.goto(`/schools/${place.slug}`);
+  await expect(page.getByTestId('local-vs-england')).toContainText(/across England/i);
+});
+
+test('a place page links its phase variants, and they resolve', async ({ page }) => {
+  // "primary schools in beccles" is the query shape the baseline showed. The
+  // first cut submitted only the bare place URL and linked nothing, leaving
+  // ~950 variant pages reachable by nothing at all.
+  const res = await page.request.get('/api/places');
+  const { places } = await res.json();
+  const town = places.find((p: { kind: string }) => p.kind === 'town');
+  expect(town).toBeTruthy();
+
+  const detail = await (await page.request.get(`/api/places/town/${town.slug}`)).json();
+  test.skip(!(detail.place.phases ?? []).length, 'no phase clears the threshold here');
+
+  await page.goto(`/schools/${town.slug}`);
+  const phase = detail.place.phases[0];
+  const link = page.locator(`a[href="/schools/${town.slug}/${phase}"]`).first();
+  await expect(link).toBeVisible();
+
+  await link.click();
+  await expect(page.locator('h1')).toContainText(new RegExp(`${phase} schools in`, 'i'));
+});
+
+test('phase variants are submitted in the places sitemap', async ({ page }) => {
+  const xml = await (await page.request.get('/sitemaps/places-1.xml')).text();
+  expect(xml).toMatch(/\/schools\/[a-z0-9-]+\/primary</);
+});
+
+test('no page title repeats the brand', async ({ page }) => {
+  // The root layout appends '| schoolcompare' to a plain-string title. Any
+  // route whose title already carries the brand must opt out with
+  // `absolute`, or it ships '... | schoolcompare | schoolcompare' — which is
+  // how ~2,600 place pages first went out.
+  const res = await page.request.get('/api/places');
+  const { places } = await res.json();
+  const town = places.find((p: { kind: string }) => p.kind === 'town');
+
+  for (const path of ['/', '/rankings', '/admissions', `/schools/${town.slug}`]) {
+    await page.goto(path);
+    const title = await page.title();
+    const brands = (title.match(/schoolcompare/gi) ?? []).length;
+    expect(brands, `${path} repeats the brand: ${title}`).toBeLessThanOrEqual(1);
+  }
+});

nextjs-app/__tests__/app/metadata.test.ts

@@ -0,0 +1,130 @@
+import { metadata as homeMetadata } from '@/app/page';
+import { metadata as rankingsMetadata } from '@/app/rankings/page';
+import { metadata as admissionsMetadata } from '@/app/admissions/page';
+import { generateMetadata as compareMetadata } from '@/app/compare/page';
+
+describe('canonical URLs', () => {
+  it('the homepage canonicalises to the bare root', () => {
+    // page.tsx reads eleven search params. Without this, every filter
+    // combination is a crawlable near-duplicate of the one page we want to
+    // rank for "compare schools".
+    expect(homeMetadata.alternates?.canonical)
+      .toBe('https://www.schoolcompare.co.uk/');
+  });
+
+  it('rankings canonicalises to the bare path', () => {
+    expect(rankingsMetadata.alternates?.canonical)
+      .toBe('https://www.schoolcompare.co.uk/rankings');
+  });
+
+  it('admissions canonicalises to the bare path', () => {
+    expect(admissionsMetadata.alternates?.canonical)
+      .toBe('https://www.schoolcompare.co.uk/admissions');
+  });
+});
+
+describe('/compare indexability', () => {
+  it('the bare compare page is indexable and canonical to itself', async () => {
+    // This is the landing page for the "compare schools" head term.
+    const meta = await compareMetadata({ searchParams: Promise.resolve({}) });
+    expect(meta.alternates?.canonical)
+      .toBe('https://www.schoolcompare.co.uk/compare');
+    expect(meta.robots).toBeUndefined();
+  });
+
+  it('a comparison of specific schools is noindex, follow', async () => {
+    // ~317 million pairs before triples. Indexing the parameter space would
+    // swamp everything else in the corpus.
+    const meta = await compareMetadata({
+      searchParams: Promise.resolve({ urns: '100001,100002' }),
+    });
+    expect(meta.robots).toEqual({ index: false, follow: true });
+  });
+
+  it('a parameterised comparison still canonicalises to the bare path', async () => {
+    // follow:true plus a canonical means the outbound links to each school
+    // page still pass value even though this URL is not indexed.
+    const meta = await compareMetadata({
+      searchParams: Promise.resolve({ urns: '100001,100002' }),
+    });
+    expect(meta.alternates?.canonical)
+      .toBe('https://www.schoolcompare.co.uk/compare');
+  });
+});
+
+/*
+ * W8 — snippet copy for the C1 cluster.
+ *
+ * The baseline (GSC, 16 months to 2026-08-20) showed these pages ranking on
+ * page one and converting at a tenth of the normal rate: "compare school
+ * performance" at position 6.1 with 0.43% CTR, against 9.16% for the brand
+ * query from the same neighbourhood. The SERP is dominated by the DfE's own
+ * "Compare school performance" service, so the job of this copy is to say
+ * what that service does not offer, without losing intent match on the title.
+ *
+ * These tests guard the mechanics that make a snippet work — length, intent
+ * keyword, differentiator, no brand-first — not the exact wording, which
+ * should stay free to iterate.
+ */
+
+// Google truncates titles near 60 characters and descriptions near 155.
+const TITLE_MAX = 60;
+const DESC_MIN = 110;
+const DESC_MAX = 155;
+
+type Meta = { title?: unknown; description?: unknown };
+const titleOf = (m: Meta): string => {
+  const t = m.title as string | { absolute?: string } | undefined;
+  return typeof t === 'string' ? t : (t?.absolute ?? '');
+};
+
+describe('C1 snippet copy', () => {
+  const pages: Array<[string, Meta, RegExp]> = [
+    ['home', homeMetadata as Meta, /compare schools/i],
+    ['rankings', rankingsMetadata as Meta, /league table/i],
+    ['admissions', admissionsMetadata as Meta, /admission/i],
+  ];
+
+  for (const [name, meta, intent] of pages) {
+    it(`${name}: title carries the search intent and fits the SERP`, () => {
+      const t = titleOf(meta);
+      expect(t).toMatch(intent);
+      expect(t.length).toBeLessThanOrEqual(TITLE_MAX);
+    });
+
+    it(`${name}: title does not open with the brand`, () => {
+      // The measured 0.43% CTR came from a brand-first title. The most
+      // valuable pixels go to the thing the searcher typed.
+      expect(titleOf(meta).toLowerCase().startsWith('schoolcompare')).toBe(false);
+    });
+
+    it(`${name}: description is long enough to be worth reading, short enough to survive`, () => {
+      const d = meta.description as string;
+      expect(d.length).toBeGreaterThanOrEqual(DESC_MIN);
+      expect(d.length).toBeLessThanOrEqual(DESC_MAX);
+    });
+  }
+
+  it('the homepage description names what gov.uk does not publish', () => {
+    // Admissions distance is the one fact the DfE service has no equivalent
+    // for. If it ever leaves this description, the snippet is competing with
+    // gov.uk on gov.uk's own ground.
+    expect(homeMetadata.description).toMatch(/close you had to live|distance/i);
+  });
+
+  it('/compare targets the tool phrasing rather than repeating the homepage', () => {
+    // Two pages chasing one phrase is how a site competes with itself.
+    return compareMetadata({ searchParams: Promise.resolve({}) }).then((m) => {
+      expect(m.title).toMatch(/comparison tool/i);
+      expect(m.title).not.toBe(titleOf(homeMetadata as Meta));
+    });
+  });
+
+  it('no C1 page claims a school count that will drift', () => {
+    // The corpus moves with every data refresh; this repo has already shipped
+    // one copy bug of that kind ("three schools" against MAX_SCHOOLS = 5).
+    for (const [, meta] of pages) {
+      expect(meta.description as string).not.toMatch(/\b\d{2},\d{3}\b|\b\d{2},000\b/);
+    }
+  });
+});

nextjs-app/__tests__/app/placeMetadata.test.ts

@@ -0,0 +1,42 @@
+import { generateMetadata as placeMeta } from '@/app/schools/[place]/page';
+
+jest.mock('@/lib/places', () => ({
+  ...jest.requireActual('@/lib/places'),
+  fetchPlace: jest.fn(async (kind: string, slug: string) =>
+    slug === 'atlantis' ? null : ({
+      place: { kind, slug, name: 'Brentwood', count: 29,
+               parent_authority: 'Essex' },
+      schools: [], averages: { rwm_expected_pct: 63, attainment_8_score: null },
+    })),
+  fetchPlaces: jest.fn(async () => []),
+}));
+
+describe('place page metadata', () => {
+  it('titles the page the way the place is searched', async () => {
+    const m = await placeMeta({ params: Promise.resolve({ place: 'brentwood' }) });
+    expect((m.title as { absolute: string }).absolute).toMatch(/schools in brentwood/i);
+  });
+
+  it('canonicalises to its own path on the www host', async () => {
+    const m = await placeMeta({ params: Promise.resolve({ place: 'brentwood' }) });
+    expect(m.alternates?.canonical)
+      .toBe('https://www.schoolcompare.co.uk/schools/brentwood');
+  });
+
+  it('opts out of the layout template, which would double the brand', () => {
+    // The root layout appends '| schoolcompare' to a plain string title, and
+    // these titles already carry it — every place page shipped reading
+    // '... | schoolcompare | schoolcompare' until this was made absolute.
+    return placeMeta({ params: Promise.resolve({ place: 'brentwood' }) })
+      .then((m) => {
+        expect(typeof m.title).toBe('object');
+        expect((m.title as { absolute: string }).absolute)
+          .not.toMatch(/schoolcompare.*schoolcompare/);
+      });
+  });
+
+  it('an unknown place gets a not-found title rather than inventing one', async () => {
+    const m = await placeMeta({ params: Promise.resolve({ place: 'atlantis' }) });
+    expect(m.title).toMatch(/not found/i);
+  });
+});

nextjs-app/__tests__/components/CutoffMapPanel.test.tsx

@@ -3,17 +3,17 @@
  *
  * This is the one place on the site that answers a question about a specific
  * family rather than about a school, so the tests here are mostly about what it
- * refuses to say: no verdict without a published figure, and no verdict at all
- * when the margin is inside the error of a postcode centroid.
+ * refuses to say — and that matters more now than it did, because there is only
+ * one year to answer with. A run of years used to soften a single close call;
+ * nothing does now, so the "too close to call" band is the whole safety margin.
  */
 
 import { render, screen, fireEvent, waitFor } from '@testing-library/react';
 import { CutoffMapPanel } from '@/components/school/CutoffMapPanel';
-import { cutoffYearRows, CUTOFF_UNCERTAINTY_M } from '@/components/school/lastDistanceOffered';
+import { CUTOFF_UNCERTAINTY_M } from '@/components/school/lastDistanceOffered';
 import type { School, SchoolAdmissionDistance } from '@/lib/types';
 
 // Leaflet needs a real layout box and network tiles; neither exists in jsdom.
-// The panel's logic is independent of it, so the map is stubbed out.
 jest.mock('@/components/LeafletCutoffMapInner', () => ({
   __esModule: true,
   default: () => <div data-testid="cutoff-map" />,
@@ -27,7 +27,7 @@ jest.mock('@/lib/api', () => ({
 
 const SCHOOL = { urn: 100010, school_name: 'Test Primary', latitude: 51.5, longitude: -0.12 } as School;
 
-const d = (year: number, distance_m: number): SchoolAdmissionDistance => ({
+const cutoff = (distance_m: number | null, year = 2026): SchoolAdmissionDistance => ({
   year, distance_m, route_count: 1, la_name: 'Camden', distance_unit_raw: 'miles',
 });
 
@@ -36,11 +36,8 @@ function northOf(metres: number) {
   return { latitude: SCHOOL.latitude! + metres / 111_320, longitude: SCHOOL.longitude! };
 }
 
-function renderPanel(history: SchoolAdmissionDistance[], admissions: { year: number; oversubscribed?: boolean }[] = []) {
-  return render(
-    <CutoffMapPanel schoolInfo={SCHOOL} rows={cutoffYearRows(history, admissions)} />,
-  );
-}
+const renderPanel = (c = cutoff(800)) =>
+  render(<CutoffMapPanel schoolInfo={SCHOOL} cutoff={c} />);
 
 async function check(postcode: string) {
   fireEvent.change(screen.getByLabelText('Your postcode'), { target: { value: postcode } });
@@ -50,8 +47,8 @@ async function check(postcode: string) {
 beforeEach(() => mockGeocode.mockReset());
 
 describe('CutoffMapPanel', () => {
-  it('renders nothing without a published figure to draw', () => {
-    const { container } = renderPanel([]);
+  it('renders nothing without a figure to compare against', () => {
+    const { container } = renderPanel(cutoff(null));
     expect(container).toBeEmptyDOMElement();
   });
 
@@ -59,61 +56,58 @@ describe('CutoffMapPanel', () => {
     const { container } = render(
       <CutoffMapPanel
         schoolInfo={{ ...SCHOOL, latitude: null, longitude: null } as School}
-        rows={cutoffYearRows([d(2024, 800)])}
+        cutoff={cutoff(800)}
       />,
     );
     expect(container).toBeEmptyDOMElement();
   });
 
   it('rejects a malformed postcode without calling the geocoder', async () => {
-    renderPanel([d(2024, 800)]);
+    renderPanel();
     await check('not a postcode');
 
     expect(await screen.findByRole('alert')).toHaveTextContent(/does not look like a UK postcode/);
     expect(mockGeocode).not.toHaveBeenCalled();
   });
 
-  it('reports a home clearly inside every published year', async () => {
+  it('names the year in the verdict, so the figure is never free-floating', async () => {
     mockGeocode.mockResolvedValue(northOf(200));
-    renderPanel([d(2022, 1000), d(2024, 800)]);
+    renderPanel(cutoff(800, 2026));
     await check('SE23 3NA');
 
-    expect(await screen.findByRole('status')).toHaveTextContent(/inside the cut-off in all 2 years/);
+    const result = await screen.findByRole('status');
+    expect(result).toHaveTextContent(/inside the/);
+    expect(result).toHaveTextContent(/September 2026/);
   });
 
-  it('reports a home clearly outside every published year', async () => {
+  it('reports a home clearly beyond the cut-off', async () => {
     mockGeocode.mockResolvedValue(northOf(5000));
-    renderPanel([d(2022, 1000), d(2024, 800)]);
+    renderPanel(cutoff(800));
     await check('SE23 3NA');
 
-    expect(await screen.findByRole('status')).toHaveTextContent(/outside the cut-off in every year/);
+    expect(await screen.findByRole('status')).toHaveTextContent(/beyond the/);
   });
 
   it('declines to call a result that sits inside the measurement error', async () => {
-    // The home is nominally inside 2024's 800 m cut-off, but only by half the
-    // uncertainty band — which a postcode centroid cannot resolve.
+    // Nominally inside the 800 m cut-off, but by half the uncertainty band —
+    // which a postcode centroid cannot resolve. With only one year published
+    // there is nothing else to fall back on, so this must not read as a pass.
     mockGeocode.mockResolvedValue(northOf(800 - CUTOFF_UNCERTAINTY_M / 2));
-    renderPanel([d(2024, 800)]);
+    renderPanel(cutoff(800));
     await check('SE23 3NA');
 
     const result = await screen.findByRole('status');
-    expect(result).toHaveTextContent(/too close to call/);
-    expect(result).not.toHaveTextContent(/inside the cut-off in all/);
-  });
-
-  it('counts an unpublished year as unknown rather than as a pass', async () => {
-    mockGeocode.mockResolvedValue(northOf(200));
-    renderPanel([d(2022, 1000), d(2024, 800)], [{ year: 2023, oversubscribed: false }]);
-    await check('SE23 3NA');
-
-    const result = await screen.findByRole('status');
-    expect(result).toHaveTextContent(/inside the cut-off in all 2 years/);
-    expect(result).toHaveTextContent(/no published figure/);
+    expect(result).toHaveTextContent(/too close/);
+    expect(result).toHaveTextContent(/measurement error/);
+    // Explanation is supporting text, not part of the bold verdict line.
+    expect(result.querySelector('[class*="cutoffCheckHeadline"]')!.textContent)
+      .not.toMatch(/measurement error/);
+    expect(result).not.toHaveTextContent(/^\S+ away — inside/);
   });
 
   it('surfaces a postcode the geocoder cannot find', async () => {
     mockGeocode.mockResolvedValue(null);
-    renderPanel([d(2024, 800)]);
+    renderPanel();
     await check('ZZ99 9ZZ');
 
     expect(await screen.findByRole('alert')).toHaveTextContent(/could not find that postcode/);
@@ -121,7 +115,7 @@ describe('CutoffMapPanel', () => {
 
   it('recovers from a geocoder failure instead of leaving a stale verdict', async () => {
     mockGeocode.mockResolvedValue(northOf(200));
-    renderPanel([d(2024, 800)]);
+    renderPanel();
     await check('SE23 3NA');
     await screen.findByRole('status');
 
@@ -132,13 +126,27 @@ describe('CutoffMapPanel', () => {
     expect(screen.getByRole('alert')).toHaveTextContent(/Something went wrong/);
   });
 
-  it('always states the limits of the check', async () => {
-    renderPanel([d(2024, 800)]);
-    // Present before any postcode is entered, not revealed with the answer.
-    expect(screen.getByText(/An indication only/)).toBeInTheDocument();
-    // The two caveats divide the work: the map says the rings are not a
-    // boundary, the check says the measurement may not be a straight line.
-    expect(screen.getByText(/not a catchment boundary/)).toBeInTheDocument();
-    expect(screen.getByText(/walking route rather than a straight line/)).toBeInTheDocument();
+  it('keeps the map behind a request until there is a reason to show it', async () => {
+    renderPanel();
+    expect(screen.queryByTestId('cutoff-map')).not.toBeInTheDocument();
+
+    mockGeocode.mockResolvedValue(northOf(200));
+    await check('SE23 3NA');
+    await screen.findByRole('status');
+    expect(screen.getByTestId('cutoff-map')).toBeInTheDocument();
+  });
+
+  it('can also show the map without a postcode, on request', () => {
+    renderPanel();
+    fireEvent.click(screen.getByRole('button', { name: /Show this distance on a map/ }));
+    expect(screen.getByTestId('cutoff-map')).toBeInTheDocument();
+  });
+
+  it('states its limits before it is used, not with the answer', () => {
+    renderPanel();
+    const caveat = screen.getByText(/Distance is the last criterion applied/);
+    expect(caveat).toBeInTheDocument();
+    expect(caveat).toHaveTextContent(/not a catchment boundary/);
+    expect(caveat).toHaveTextContent(/walking route/);
   });
 });

nextjs-app/__tests__/components/PlaceView.test.tsx

@@ -0,0 +1,170 @@
+import { render, screen } from '@testing-library/react';
+import { PlaceView } from '@/components/places/PlaceView';
+import type { PlaceDetail } from '@/lib/places';
+
+const detail: PlaceDetail = {
+  place: { kind: 'town', slug: 'brentwood', name: 'Brentwood', count: 29,
+           parent_authority: 'Essex', phases: ['primary'] },
+  schools: [
+    { urn: 1, school_name: 'Alpha Primary', rwm_expected_pct: 82,
+      ofsted_grade: 1, phase: 'Primary' } as never,
+    { urn: 2, school_name: 'Beta Primary', rwm_expected_pct: 44,
+      ofsted_grade: 3, phase: 'Primary' } as never,
+  ],
+  averages: { rwm_expected_pct: 63, attainment_8_score: null },
+};
+
+describe('PlaceView', () => {
+  it('leads with an H1 that matches how the place is searched', () => {
+    render(<PlaceView detail={detail} phase="primary" englandAverage={61}
+      neighbours={[]} />);
+    expect(screen.getByRole('heading', { level: 1 }))
+      .toHaveTextContent(/primary schools in brentwood/i);
+  });
+
+  it('states the count so the page says something before the table', () => {
+    render(<PlaceView detail={detail} phase="primary" englandAverage={61}
+      neighbours={[]} />);
+    expect(screen.getByText(/29 schools/i)).toBeInTheDocument();
+  });
+
+  it('compares the local average against England, which a list cannot', () => {
+    render(<PlaceView detail={detail} phase="primary" englandAverage={61}
+      neighbours={[]} />);
+    expect(screen.getByTestId('local-vs-england')).toHaveTextContent('63');
+    expect(screen.getByTestId('local-vs-england')).toHaveTextContent('61');
+  });
+
+  it('links every school in scope, which is what de-orphans them', () => {
+    render(<PlaceView detail={detail} phase="primary" englandAverage={61}
+      neighbours={[]} />);
+    expect(screen.getAllByRole('link', { name: /Primary$/ })).toHaveLength(2);
+  });
+
+  it('links to the parent authority so the place sits in a hierarchy', () => {
+    render(<PlaceView detail={detail} phase="primary" englandAverage={61}
+      neighbours={[]} />);
+    expect(screen.getByRole('link', { name: /Essex/i }))
+      .toHaveAttribute('href', '/schools/authority/essex');
+  });
+
+  it('shows the Ofsted distribution, not just a count of Outstanding', () => {
+    render(<PlaceView detail={detail} phase="primary" englandAverage={61}
+      neighbours={[]} />);
+    expect(screen.getByTestId('ofsted-distribution')).toBeInTheDocument();
+  });
+
+  it('links to neighbouring places so the page is not a dead end', () => {
+    render(<PlaceView detail={detail} phase="primary" englandAverage={61}
+      neighbours={[{ kind: 'town', slug: 'romford', name: 'Romford', count: 40 }]} />);
+    expect(screen.getByRole('link', { name: /Romford/ }))
+      .toHaveAttribute('href', '/schools/romford');
+  });
+
+  it('says nothing about an average it does not have', () => {
+    render(<PlaceView detail={{ ...detail, averages:
+      { rwm_expected_pct: null, attainment_8_score: null } }}
+      phase="primary" englandAverage={61} neighbours={[]} />);
+    expect(screen.queryByTestId('local-vs-england')).not.toBeInTheDocument();
+  });
+});
+
+describe('PlaceView structured data', () => {
+  function jsonLd() {
+    const { container } = render(<PlaceView detail={detail} phase="primary"
+      englandAverage={61} neighbours={[]} />);
+    const el = container.querySelector('script[type="application/ld+json"]');
+    return JSON.parse(el!.textContent!);
+  }
+
+  it('declares the page as a ranked list, not prose', () => {
+    const types = jsonLd()['@graph'].map((n: { '@type': string }) => n['@type']);
+    expect(types).toContain('ItemList');
+    expect(types).toContain('BreadcrumbList');
+  });
+
+  it('gives every listed school an absolute URL on the canonical host', () => {
+    const list = jsonLd()['@graph'].find((n: { '@type': string }) => n['@type'] === 'ItemList');
+    expect(list.itemListElement).toHaveLength(2);
+    for (const item of list.itemListElement) {
+      expect(item.url).toMatch(/^https:\/\/www\.schoolcompare\.co\.uk\/school\//);
+    }
+  });
+});
+
+describe('PlaceView phase variants', () => {
+  it('links the phase variants that exist', () => {
+    render(<PlaceView detail={detail} englandAverage={61} neighbours={[]} />);
+    expect(screen.getByRole('link', { name: /Primary schools in Brentwood/i }))
+      .toHaveAttribute('href', '/schools/brentwood/primary');
+  });
+
+  it('links no variant for a phase below its own threshold', () => {
+    render(<PlaceView detail={detail} englandAverage={61} neighbours={[]} />);
+    expect(screen.queryByRole('link', { name: /Secondary schools in Brentwood/i }))
+      .not.toBeInTheDocument();
+  });
+
+  it('does not link sideways from a variant page to itself', () => {
+    render(<PlaceView detail={detail} phase="primary" englandAverage={61}
+      neighbours={[]} />);
+    expect(screen.queryByRole('link', { name: /Primary schools in Brentwood/i }))
+      .not.toBeInTheDocument();
+  });
+});
+
+describe('PlaceView presentation', () => {
+  // /schools/brentwood shipped with 8 of 27 rows blank: an unphased page shows
+  // one primary-only measure for a list that also holds secondaries.
+  const mixed: PlaceDetail = {
+    place: { kind: 'town', slug: 'brentwood', name: 'Brentwood', count: 4,
+             parent_authority: 'Essex', phases: ['primary', 'secondary'] },
+    schools: [
+      { urn: 1, school_name: 'Alpha Primary', phase: 'Primary',
+        rwm_expected_pct: 82, attainment_8_score: null } as never,
+      { urn: 2, school_name: 'Beta High', phase: 'Secondary',
+        rwm_expected_pct: null, attainment_8_score: 47 } as never,
+    ],
+    averages: { rwm_expected_pct: 63, attainment_8_score: 45 },
+  };
+
+  it('gives each phase its own table rather than one column of blanks', () => {
+    render(<PlaceView detail={mixed} englandAverage={61} neighbours={[]} />);
+    expect(screen.getByRole('heading', { name: /^Primary schools/ })).toBeInTheDocument();
+    expect(screen.getByRole('heading', { name: /^Secondary schools/ })).toBeInTheDocument();
+    expect(screen.getByText('82%')).toBeInTheDocument();
+    expect(screen.getByText('47')).toBeInTheDocument();
+  });
+
+  it('names the measure in plain words, not jargon', () => {
+    // The first cut said "RWM expected", which appears nowhere else on the site.
+    render(<PlaceView detail={mixed} englandAverage={61} neighbours={[]} />);
+    expect(screen.getByText('Reading, writing & maths')).toBeInTheDocument();
+    expect(screen.getByText('Attainment 8')).toBeInTheDocument();
+    expect(screen.queryByText(/RWM expected/i)).not.toBeInTheDocument();
+  });
+
+  it('says a missing result is unpublished rather than showing a bare dash', () => {
+    const noResult: PlaceDetail = {
+      ...mixed,
+      schools: [{ urn: 3, school_name: 'New Primary', phase: 'Primary',
+                  rwm_expected_pct: null, attainment_8_score: null } as never],
+    };
+    render(<PlaceView detail={noResult} englandAverage={61} neighbours={[]} />);
+    expect(screen.getByText('Not published')).toBeInTheDocument();
+  });
+
+  it('styles school links to the site convention rather than browser default', () => {
+    const { container } = render(<PlaceView detail={mixed} englandAverage={61}
+      neighbours={[]} />);
+    const link = container.querySelector('a[href^="/school/"]');
+    expect(link?.className).toBeTruthy();
+  });
+
+  it('a phased page shows one table and no phase headings', () => {
+    render(<PlaceView detail={mixed} phase="primary" englandAverage={61}
+      neighbours={[]} />);
+    expect(screen.queryByRole('heading', { name: /^Secondary schools/ }))
+      .not.toBeInTheDocument();
+  });
+});

nextjs-app/__tests__/components/lastDistanceOffered.test.tsx

@@ -30,6 +30,17 @@ describe('primary detail page', () => {
     expect(screen.getByText(/Last distance offered/)).toHaveTextContent('September 2024');
   });
 
+  it('keeps the figure and its metric support readable as two numbers', () => {
+    // They are flex children with a CSS gap and nothing between them in the
+    // text layer, which read as "0.48 miles770 m" to a screen reader and to any
+    // text matcher. Cheap to lose again, so pinned.
+    renderSchoolDetail({ ...primaryFixture, admissionDistance: cutoff({ distance_m: 772.49 }) });
+
+    const tile = document.querySelector('[class*="admissionsTileDistance"]')!;
+    expect(tile.textContent).toMatch(/0\.48 miles\s+770 m/);
+    expect(tile.textContent).not.toMatch(/miles\d/);
+  });
+
   it('never shows the figure without saying it is not a catchment', () => {
     renderSchoolDetail({ ...primaryFixture, admissionDistance: cutoff() });
 
@@ -89,95 +100,68 @@ describe('secondary detail page', () => {
   });
 });
 
-// ── The Distance view ──────────────────────────────────────────────────
+// ── The Distance section ───────────────────────────────────────────────
 
-const history = (pts: [number, number][]): SchoolAdmissionDistance[] =>
-  pts.map(([year, distance_m]) => ({
-    year, distance_m, route_count: 1, la_name: 'Camden', distance_unit_raw: 'miles',
-  }));
+describe('Distance section', () => {
+  it('appears for a school with a figure and coordinates', () => {
+    const { container } = renderSchoolDetail({
+      ...primaryFixture,
+      schoolInfo: { ...primaryFixture.schoolInfo, latitude: 51.5, longitude: -0.12 },
+      admissionDistance: cutoff({ distance_m: 700, year: 2026 }),
+    });
 
-describe('primary Distance view', () => {
-  it('appears once there are two or more published years', () => {
+    expect(container.querySelector('#distance')).toBeInTheDocument();
+    expect(screen.getByText('How far away are you?')).toBeInTheDocument();
+  });
+
+  it('stays away when the school has no coordinates to measure from', () => {
+    const { container } = renderSchoolDetail({
+      ...primaryFixture,
+      schoolInfo: { ...primaryFixture.schoolInfo, latitude: null, longitude: null },
+      admissionDistance: cutoff({ distance_m: 700, year: 2026 }),
+    });
+
+    expect(container.querySelector('#distance')).not.toBeInTheDocument();
+  });
+
+  it('stays away when no figure has been published', () => {
+    const { container } = renderSchoolDetail({
+      ...primaryFixture,
+      schoolInfo: { ...primaryFixture.schoolInfo, latitude: 51.5, longitude: -0.12 },
+      admissionDistance: null,
+    });
+
+    expect(container.querySelector('#distance')).not.toBeInTheDocument();
+  });
+
+  it('shows no year-by-year record — that is held back as a paid feature', () => {
+    // The page must not leak the history through a table, a chart or a strip of
+    // per-year verdicts. The API no longer sends it either; this guards the
+    // render side so a future component cannot quietly put it back.
     renderSchoolDetail({
       ...primaryFixture,
-      admissionDistance: cutoff({ distance_m: 700, year: 2024 }),
-      admissionDistanceHistory: history([[2021, 1000], [2022, 900], [2023, 800], [2024, 700]]),
+      schoolInfo: { ...primaryFixture.schoolInfo, latitude: 51.5, longitude: -0.12 },
+      admissionDistance: cutoff({ distance_m: 700, year: 2026 }),
     });
 
-    expect(screen.getByRole('button', { name: 'Distance' })).toBeInTheDocument();
-  });
-
-  it('stays hidden on a single published year', () => {
-    // One point is a fact, not a history; a chart of it invites a trend reading
-    // that is not there.
-    renderSchoolDetail({
-      ...primaryFixture,
-      admissionDistance: cutoff({ distance_m: 700, year: 2024 }),
-      admissionDistanceHistory: history([[2024, 700]]),
-    });
-
-    expect(screen.queryByRole('button', { name: 'Distance' })).not.toBeInTheDocument();
-  });
-
-  it('lists every year in the span, including the ones with no figure', () => {
-    renderSchoolDetail({
-      ...primaryFixture,
-      admissionDistance: cutoff({ distance_m: 700, year: 2024 }),
-      admissionDistanceHistory: history([[2021, 1000], [2024, 700]]),
-    });
-
-    // The view is server-rendered but starts hidden behind its tab, and role
-    // queries skip hidden subtrees — so open it the way a reader would.
-    fireEvent.click(screen.getByRole('button', { name: 'Distance' }));
-
-    // 2022 and 2023 were never published but must still appear as rows, or the
-    // gap in the chart has nothing explaining it.
-    for (const year of ['2021', '2022', '2023', '2024']) {
-      expect(screen.getByRole('rowheader', { name: year })).toBeInTheDocument();
-    }
-    expect(screen.getAllByText('Not published').length).toBe(2);
-  });
-
-  it('never claims everyone was offered a place', () => {
-    // fact_admissions.oversubscribed is about first preferences only, so the
-    // stronger claim is not supported by the data behind it.
-    renderSchoolDetail({
-      ...primaryFixture,
-      admissionDistance: cutoff({ distance_m: 700, year: 2024 }),
-      admissionDistanceHistory: history([[2021, 1000], [2024, 700]]),
-      admissionsHistory: [
-        ...primaryFixture.admissionsHistory,
-        { year: 2022, oversubscribed: false, places_offered: 60 },
-      ],
-    });
-
-    expect(screen.getByText(/Places available on first preferences/)).toBeInTheDocument();
-    expect(screen.queryByText(/every applicant/i)).not.toBeInTheDocument();
-    expect(screen.queryByText(/all offered/i)).not.toBeInTheDocument();
-  });
-
-  it('withholds a trend reading while the record is thin', () => {
-    renderSchoolDetail({
-      ...primaryFixture,
-      admissionDistance: cutoff({ distance_m: 700, year: 2024 }),
-      admissionDistanceHistory: history([[2023, 800], [2024, 700]]),
-    });
-
-    expect(screen.getByText(/too few to read as a trend/)).toBeInTheDocument();
-    expect(screen.queryByText(/Across \d+ published years/)).not.toBeInTheDocument();
+    // Scoped to the section: the page has other tables (the history section's).
+    const section = document.querySelector('#distance')!;
+    expect(section.querySelector('table')).toBeNull();
+    expect(screen.queryByText(/Last distance offered, by year/)).not.toBeInTheDocument();
+    expect(screen.queryByText(/Not published/)).not.toBeInTheDocument();
+    expect(screen.queryByText(/too few to read as a trend/)).not.toBeInTheDocument();
   });
 });
 
-describe('secondary Distance detail', () => {
-  it('renders inline, with no extra tab, once there are two published years', () => {
-    renderSecondarySchoolDetail({
+describe('secondary Distance section', () => {
+  it('renders on the secondary template too', () => {
+    const { container } = renderSecondarySchoolDetail({
       ...secondaryFixture,
-      admissionDistance: cutoff({ distance_m: 3472.96 }),
-      admissionDistanceHistory: history([[2023, 3800], [2024, 3472.96]]),
+      schoolInfo: { ...secondaryFixture.schoolInfo, latitude: 51.5, longitude: -0.12 },
+      admissionDistance: cutoff({ distance_m: 3472.96, year: 2026 }),
     });
 
-    expect(screen.getByText(/Last distance offered, by year/)).toBeInTheDocument();
-    expect(screen.getByRole('rowheader', { name: '2023' })).toBeInTheDocument();
+    expect(container.querySelector('#distance')).toBeInTheDocument();
   });
 
   it('explains a selective school by how it admits rather than as missing data', () => {
@@ -185,7 +169,6 @@ describe('secondary Distance detail', () => {
       ...secondaryFixture,
       schoolInfo: { ...secondaryFixture.schoolInfo, admissions_policy: 'Selective' },
       admissionDistance: null,
-      admissionDistanceHistory: [],
     });
 
     expect(screen.getByText(/ranked by the entrance test/)).toBeInTheDocument();
@@ -196,7 +179,6 @@ describe('secondary Distance detail', () => {
     renderSecondarySchoolDetail({
       ...secondaryFixture,
       admissionDistance: null,
-      admissionDistanceHistory: [],
       admissionsHistory: [
         { year: 2022, oversubscribed: false },
         { year: 2023, oversubscribed: false },

nextjs-app/__tests__/lib/lastDistanceOffered.test.ts

@@ -7,10 +7,9 @@
  * place — so both are pinned here rather than left to the component.
  */
 
-import { formatCutoffDistance, formatEntryYear } from '@/lib/utils';
+import { formatCutoffDistance, formatMiles, formatEntryYear } from '@/lib/utils';
 import {
-  describeCutoff, cutoffYearRows, cutoffTrendSummary, cutoffCoverageNote,
-  describeCutoffAbsence, compareToCutoffs, entryYearOf, CUTOFF_UNCERTAINTY_M,
+  describeCutoff, describeCutoffAbsence, compareToCutoff, CUTOFF_UNCERTAINTY_M,
 } from '@/components/school/lastDistanceOffered';
 import type { SchoolAdmissionDistance } from '@/lib/types';
 
@@ -33,8 +32,19 @@ describe('formatCutoffDistance', () => {
     expect(formatCutoffDistance(3472.96)!.secondary).toBe('3.5 km');
   });
 
-  it('leads with metres below 100 m, where a miles figure carries nothing', () => {
-    expect(formatCutoffDistance(27)).toEqual({ primary: '27 m', secondary: '0.02 miles' });
+  it('stays in miles at short range, where it used to swap to metres', () => {
+    // The swap made a single number easier to read and a comparison harder:
+    // "69 m away — inside the cut-off of 0.17 miles" asked the reader to
+    // convert between units to check a claim we had already made for them.
+    expect(formatCutoffDistance(27)).toEqual({ primary: '0.02 miles', secondary: '30 m' });
+    expect(formatCutoffDistance(69)!.primary).toMatch(/miles$/);
+  });
+
+  it('describes a distance too short for two decimal places', () => {
+    // Rather than a flat "0.00 miles", which reads as no distance at all.
+    expect(formatMiles(5)).toBe('under 0.01 miles');
+    expect(formatMiles(0)).toBe('under 0.01 miles');
+    expect(formatMiles(20)).toBe('0.01 miles');
   });
 
   it('returns null rather than a zero cut-off', () => {
@@ -82,97 +92,72 @@ describe('describeCutoff', () => {
   });
 });
 
-// ── Year-by-year history ───────────────────────────────────────────────
+// ── "Would we have got in?" ────────────────────────────────────────────
 
-const d = (year: number, distance_m: number | null, route_count = 1): SchoolAdmissionDistance => ({
-  year, distance_m, route_count, la_name: 'Camden', distance_unit_raw: 'miles',
-});
-
-describe('entryYearOf', () => {
-  it('reduces EES academic codes and plain entry years to one key', () => {
-    // Without this the two histories never join and every year looks unpublished.
-    expect(entryYearOf(202425)).toBe(2024);
-    expect(entryYearOf(2024)).toBe(2024);
-  });
-});
-
-describe('cutoffYearRows', () => {
-  it('emits a row for every year in the span, including the empty ones', () => {
-    const rows = cutoffYearRows([d(2021, 900), d(2024, 700)]);
-    expect(rows.map((r) => r.year)).toEqual([2024, 2023, 2022, 2021]);
-    expect(rows.map((r) => r.status)).toEqual([
-      'published', 'not-published', 'not-published', 'published',
-    ]);
+describe('compareToCutoff', () => {
+  it('never states the two figures in different units', () => {
+    /*
+     * The reported defect: "69 m away — inside the September 2026 cut-off of
+     * 0.17 miles". Both numbers are correct and the sentence is still useless,
+     * because checking it means converting one of them.
+     *
+     * Swept across the range where the old formatter switched units, so a
+     * future readability tweak to one figure cannot reintroduce the mismatch
+     * in the other.
+     */
+    const mixed: string[] = [];
+    for (const homeM of [0, 5, 27, 69, 99, 100, 260, 800, 1609, 5000]) {
+      for (const cutoffM of [30, 69, 100, 270, 1000, 3500]) {
+        const { headline } = compareToCutoff(homeM, cutoffM, 2026);
+        const hasMetres = /\d\s?m\b/.test(headline);
+        const milesCount = (headline.match(/miles/g) ?? []).length;
+        // Two figures, both in miles, and no metric reading anywhere near them.
+        if (hasMetres || milesCount !== 2) {
+          mixed.push(`home=${homeM}m cutoff=${cutoffM}m -> ${headline}`);
+        }
+      }
+    }
+    expect(mixed).toEqual([]);
   });
 
-  it('separates "nothing published" from "was not oversubscribed"', () => {
-    // The two look identical in the distance data and mean opposite things.
-    const rows = cutoffYearRows(
-      [d(2021, 900), d(2023, 700)],
-      [{ year: 2022, oversubscribed: false }],
-    );
-    expect(rows.find((r) => r.year === 2022)!.status).toBe('not-oversubscribed');
+  it('reads back the reported case in one unit', () => {
+    expect(compareToCutoff(69, 270, 2026).headline)
+      .toBe('0.04 miles away — inside the September 2026 cut-off of 0.17 miles.');
   });
 
-  it('matches EES six-digit years against plain cut-off years', () => {
-    const rows = cutoffYearRows(
-      [d(2023, 700)],
-      [{ year: 202324, places_offered: 60, oversubscribed: true }],
-    );
-    expect(rows.find((r) => r.year === 2023)!.placesOffered).toBe(60);
+  it('calls a clearly nearer home inside, and names the year', () => {
+    const r = compareToCutoff(300, 800, 2026);
+    expect(r.verdict).toBe('inside');
+    expect(r.headline).toContain('September 2026');
   });
 
-  it('does not stretch the span back over admissions years with no cut-offs', () => {
-    // EES reaches back further than councils publish; padding the chart with a
-    // decade of blanks would bury the years that carry a figure.
-    const rows = cutoffYearRows(
-      [d(2024, 700)],
-      [{ year: 2015, oversubscribed: true }, { year: 2024, oversubscribed: true }],
-    );
-    expect(rows.map((r) => r.year)).toEqual([2024]);
+  it('calls a clearly further home beyond', () => {
+    expect(compareToCutoff(4000, 800, 2026).verdict).toBe('outside');
   });
 
-  it('is safe when the backend does not send the field at all', () => {
-    expect(cutoffYearRows(undefined as never)).toEqual([]);
-    expect(cutoffYearRows([], [])).toEqual([]);
-  });
-});
-
-describe('cutoffTrendSummary', () => {
-  const rowsFor = (pts: [number, number][]) => cutoffYearRows(pts.map(([y, m]) => d(y, m)));
-
-  it('says nothing below four published points', () => {
-    expect(cutoffTrendSummary(rowsFor([[2022, 900], [2023, 800], [2024, 700]]))).toBeNull();
+  it('refuses to call a result inside the measurement error, either way', () => {
+    // A postcode centroid covers several addresses, so a margin this fine is
+    // noise. With one published year there is no other year to fall back on,
+    // which makes this band the only thing standing between a parent and a
+    // place they do not have.
+    expect(compareToCutoff(800 - CUTOFF_UNCERTAINTY_M / 2, 800, 2026).verdict).toBe('too-close');
+    expect(compareToCutoff(800 + CUTOFF_UNCERTAINTY_M / 2, 800, 2026).verdict).toBe('too-close');
+    expect(compareToCutoff(800, 800, 2026).detail).toContain('measurement error');
+    // The explanation is not welded to the headline, so it does not run at
+    // headline weight in the result block.
+    expect(compareToCutoff(800, 800, 2026).headline).not.toContain('measurement error');
+    expect(compareToCutoff(300, 800, 2026).detail).toBeNull();
   });
 
-  it('names both endpoints and their years rather than passing a verdict', () => {
-    const s = cutoffTrendSummary(rowsFor([
-      [2021, 1000], [2022, 900], [2023, 800], [2024, 500],
-    ]));
-    expect(s).toContain('2021');
-    expect(s).toContain('2024');
-    expect(s).toContain('tightened');
-  });
-
-  it('does not call a small wobble a direction', () => {
-    const s = cutoffTrendSummary(rowsFor([
-      [2021, 1000], [2022, 1010], [2023, 990], [2024, 1030],
-    ]));
-    expect(s).toContain('stayed broadly the same');
-  });
-});
-
-describe('cutoffCoverageNote', () => {
-  it('warns while the record is too thin to read as a trend', () => {
-    expect(cutoffCoverageNote(cutoffYearRows([d(2024, 700)]))).toContain('Only 1 year');
-    expect(cutoffCoverageNote(cutoffYearRows([
-      d(2021, 1000), d(2022, 900), d(2023, 800), d(2024, 700),
-    ]))).toBeNull();
+  it('treats the band as exclusive at its edge', () => {
+    // Exactly on the boundary is still too close; one metre past it is not.
+    expect(compareToCutoff(800 - CUTOFF_UNCERTAINTY_M, 800, 2026).verdict).toBe('too-close');
+    expect(compareToCutoff(800 - CUTOFF_UNCERTAINTY_M - 1, 800, 2026).verdict).toBe('inside');
   });
 });
 
 describe('describeCutoffAbsence', () => {
-  it('explains a selective school by how it admits, not by missing data', () => {
+  it('explains a selective school by how it admits, not as missing data', () => {
     const s = describeCutoffAbsence({ localAuthority: 'Kent', admissionsPolicy: 'Selective' });
     expect(s).toContain('entrance test');
     expect(s).not.toContain('has not published');
@@ -195,37 +180,3 @@ describe('describeCutoffAbsence', () => {
       .toContain('Camden has not published');
   });
 });
-
-describe('compareToCutoffs', () => {
-  const rows = cutoffYearRows(
-    [d(2022, 1000), d(2024, 800)],
-    [{ year: 2023, oversubscribed: false }],
-  );
-
-  it('marks a clearly nearer home as inside every comparable year', () => {
-    const r = compareToCutoffs(300, rows);
-    expect(r.insideCount).toBe(2);
-    expect(r.comparableCount).toBe(2);
-    expect(r.headline).toContain('inside the cut-off in all 2 years');
-  });
-
-  it('marks a clearly further home as outside', () => {
-    const r = compareToCutoffs(4000, rows);
-    expect(r.insideCount).toBe(0);
-    expect(r.headline).toContain('outside the cut-off in every year');
-  });
-
-  it('refuses to call a result inside the measurement error', () => {
-    // A postcode centroid covers several addresses; claiming a place on a 20 m
-    // margin would be inventing precision the inputs do not have.
-    const r = compareToCutoffs(800 - CUTOFF_UNCERTAINTY_M / 2, rows);
-    expect(r.years.find((y) => y.year === 2024)!.verdict).toBe('too-close');
-    expect(r.detail).toContain('too close to call');
-  });
-
-  it('never counts an unpublished year as a pass or a fail', () => {
-    const r = compareToCutoffs(300, rows);
-    expect(r.years.find((y) => y.year === 2023)!.verdict).toBe('unknown');
-    expect(r.detail).toContain('no published figure');
-  });
-});

nextjs-app/__tests__/lib/site.test.ts

@@ -0,0 +1,27 @@
+import { SITE_URL, absoluteUrl } from '@/lib/site';
+
+describe('SITE_URL', () => {
+  it('is the www host, which is the one that serves a 200', () => {
+    // The apex 301s to www at Cloudflare. A canonical pointing at a redirect
+    // is a wasted signal, so every absolute URL we emit must already be www.
+    expect(SITE_URL).toBe('https://www.schoolcompare.co.uk');
+  });
+
+  it('has no trailing slash, so joins never double up', () => {
+    expect(SITE_URL.endsWith('/')).toBe(false);
+  });
+});
+
+describe('absoluteUrl', () => {
+  it('joins a rooted path', () => {
+    expect(absoluteUrl('/rankings')).toBe('https://www.schoolcompare.co.uk/rankings');
+  });
+
+  it('joins a path missing its leading slash', () => {
+    expect(absoluteUrl('rankings')).toBe('https://www.schoolcompare.co.uk/rankings');
+  });
+
+  it('maps the site root to a bare trailing slash', () => {
+    expect(absoluteUrl('/')).toBe('https://www.schoolcompare.co.uk/');
+  });
+});

nextjs-app/app/admissions/page.tsx

@@ -1,12 +1,16 @@
+import { absoluteUrl } from '@/lib/site';
 import type { Metadata } from 'next';
 import { AdmissionsView } from '@/components/AdmissionsView';
 
 export const dynamic = 'force-static';
 
 export const metadata: Metadata = {
-  title: 'School Admissions Guide',
+  // Deadlines and offer days are what gets searched, and what this page is
+  // genuinely best at — the countdowns are live.
+  title: { absolute: 'School Admissions Deadlines & Offer Days | schoolcompare' },
   description:
-    'Understand the Primary and Secondary school admissions process in England, with live countdowns to every key deadline and National Offer Day.',
+    'Every key date for primary and secondary school admissions in England, with live countdowns to the application deadline and National Offer Day.',
+  alternates: { canonical: absoluteUrl('/admissions') },
 };
 
 export default function AdmissionsPage() {

nextjs-app/app/compare/page.tsx

@@ -5,6 +5,7 @@
 
 import { fetchComparison, fetchMetrics } from '@/lib/api';
 import { ComparisonView } from '@/components/ComparisonView';
+import { absoluteUrl } from '@/lib/site';
 import type { Metadata } from 'next';
 
 interface ComparePageProps {
@@ -14,13 +15,36 @@ interface ComparePageProps {
   }>;
 }
 
-export const metadata: Metadata = {
-  title: 'Compare Schools',
+/**
+ * Indexability depends on the query string, so this cannot be a static export.
+ *
+ * Bare /compare is the landing page for the "compare schools" head term and
+ * stays indexable. /compare?urns=… is an unbounded parameter space — 25,193
+ * schools make ~317 million pairs — so it goes noindex. It stays `follow` and
+ * keeps a canonical to the bare path, so the links out to each school page
+ * still count.
+ */
+export async function generateMetadata(
+  { searchParams }: ComparePageProps,
+): Promise<Metadata> {
+  const { urns } = await searchParams;
+
+  const base: Metadata = {
+    // Deliberately not the homepage's phrase. Two pages chasing "compare
+    // schools" is how a site competes with itself; this one takes the tool
+    // phrasing instead.
+    title: 'School Comparison Tool — Up to Five at Once | schoolcompare',
     description:
-    'Compare schools in England side by side — Ofsted inspections, KS2 and GCSE results against the England average, admissions odds and school community.',
+      'Put up to five English schools in one table: SATs and GCSE results against the England average, Ofsted grades, and the distance places were offered.',
     keywords:
       'school comparison, compare schools, Ofsted comparison, school admissions, KS2 comparison, primary school performance',
-};
+    alternates: { canonical: absoluteUrl('/compare') },
+  };
+
+  if (!urns) return base;
+
+  return { ...base, robots: { index: false, follow: true } };
+}
 
 // Dynamic via searchParams; remove force-dynamic so internal data fetches
 // can still use Next.js's per-call revalidate cache.

nextjs-app/app/layout.tsx

@@ -5,6 +5,7 @@ import { Navigation } from '@/components/Navigation';
 import { Footer } from '@/components/Footer';
 import { ComparisonToast } from '@/components/ComparisonToast';
 import { ComparisonProvider } from '@/context/ComparisonProvider';
+import { SITE_URL } from '@/lib/site';
 import './globals.css';
 
 // Manrope carries headings and key messaging — the guideline's "friendly,
@@ -47,29 +48,32 @@ export const metadata: Metadata = {
     statusBarStyle: 'default',
   },
   title: {
-    default: 'schoolcompare | Compare School Performance',
+    default: 'Compare Schools Side by Side | schoolcompare',
     template: '%s | schoolcompare',
   },
-  description: 'Compare primary and secondary school SATs and GCSE performance across England',
+  description:
+    'Put five English schools on one screen — SATs, GCSE results, Ofsted grades, and how close you had to live to get a place. Free, no sign-up.',
   keywords: 'school comparison, KS2 results, KS4 results, primary school, secondary school, England schools, SATs results, GCSE results',
   authors: [{ name: 'schoolcompare' }],
   manifest: '/manifest.json',
   // No `icons` key on purpose: setting it here would override the file
   // conventions. app/icon.svg and app/apple-icon.tsx are the source, and
   // app/opengraph-image.tsx supplies og:image and twitter:image.
-  metadataBase: new URL('https://schoolcompare.co.uk'),
+  metadataBase: new URL(SITE_URL),
   openGraph: {
     type: 'website',
-    title: 'schoolcompare | Compare School Performance',
-    description: 'Compare primary and secondary school SATs and GCSE performance across England',
-    url: 'https://schoolcompare.co.uk',
+    title: 'Compare Schools Side by Side | schoolcompare',
+    description:
+      'Put five English schools on one screen — SATs, GCSE results, Ofsted grades, and how close you had to live to get a place.',
+    url: SITE_URL,
     siteName: 'schoolcompare',
   },
   twitter: {
     // summary_large_image now that there is an image worth showing.
     card: 'summary_large_image',
-    title: 'schoolcompare | Compare School Performance',
-    description: 'Compare primary and secondary school SATs and GCSE performance across England',
+    title: 'Compare Schools Side by Side | schoolcompare',
+    description:
+      'Put five English schools on one screen — SATs, GCSE results, Ofsted grades, and how close you had to live to get a place.',
   },
 };
 

nextjs-app/app/page.tsx

@@ -3,6 +3,7 @@
  * Main landing page with school search and browsing
  */
 
+import { absoluteUrl } from '@/lib/site';
 import type { Metadata } from 'next';
 import { fetchSchools, fetchFilters, fetchDataInfo } from '@/lib/api';
 import { formatAcademicYear } from '@/lib/utils';
@@ -33,8 +34,25 @@ interface HomePageProps {
  * saying the brand twice.
  */
 export const metadata: Metadata = {
-  title: { absolute: 'schoolcompare | Compare every school in England' },
-  description: 'Search and compare school performance across England',
+  /*
+   * Intent in the title, differentiator in the description.
+   *
+   * These queries are owned by the DfE's own "Compare school performance"
+   * service, and the old title — brand first, then a near-paraphrase of that
+   * service's name — gave a searcher no reason to pick us over it. It drew
+   * 0.43% CTR at position 6.1 while the brand query drew 9.16% from the same
+   * neighbourhood, so the ranking was never the problem.
+   *
+   * The title now matches what people type. The description carries the one
+   * fact gov.uk does not publish: how close you had to live to get a place.
+   */
+  title: { absolute: 'Compare Schools Side by Side | schoolcompare' },
+  description:
+    'Put five English schools on one screen — SATs, GCSE results, Ofsted grades, and how close you had to live to get a place. Free, no sign-up.',
+  // This page reads eleven search params. They filter a result set; they do
+  // not make a new document. Collapsing every combination onto "/" stops the
+  // homepage competing with itself for its own head terms.
+  alternates: { canonical: absoluteUrl('/') },
 };
 
 // The page reads searchParams, which makes rendering dynamic by default.

nextjs-app/app/rankings/page.tsx

@@ -5,6 +5,7 @@
 
 import { fetchRankings, fetchFilters, fetchMetrics } from '@/lib/api';
 import { RankingsView } from '@/components/RankingsView';
+import { absoluteUrl } from '@/lib/site';
 import type { Metadata } from 'next';
 
 interface RankingsPageProps {
@@ -17,9 +18,15 @@ interface RankingsPageProps {
 }
 
 export const metadata: Metadata = {
-  title: 'School Rankings',
-  description: 'Top-ranked schools by SATs and GCSE performance across England',
+  // 'School Rankings' matched nothing anyone types. League tables is the
+  // phrase parents actually search, and it spikes each results day.
+  title: { absolute: 'Primary & Secondary School League Tables | schoolcompare' },
+  description:
+    'Rank English schools by SATs results, GCSEs, Progress 8 or Attainment 8, and filter by local authority or year. Built from the DfE’s own figures.',
   keywords: 'school rankings, top schools, best schools, KS2 rankings, KS4 rankings, school league tables',
+  // Param forms (?metric=&local_authority=&year=&phase=) collapse here for
+  // now. W3 replaces them with real indexable paths.
+  alternates: { canonical: absoluteUrl('/rankings') },
 };
 
 // Dynamic via searchParams; remove force-dynamic so internal data fetches

nextjs-app/app/robots.ts

@@ -4,6 +4,7 @@
  */
 
 import { MetadataRoute } from 'next';
+import { absoluteUrl } from '@/lib/site';
 
 export default function robots(): MetadataRoute.Robots {
   return {
@@ -14,6 +15,6 @@ export default function robots(): MetadataRoute.Robots {
         disallow: ['/api/', '/_next/'],
       },
     ],
-    sitemap: 'https://schoolcompare.co.uk/sitemap.xml',
+    sitemap: absoluteUrl('/sitemap.xml'),
   };
 }

nextjs-app/app/school/[slug]/page.tsx

@@ -15,6 +15,7 @@ import {
 } from '@/lib/schoolSections';
 import { parseSchoolSlug, schoolUrl } from '@/lib/utils';
 import type { NationalAverages } from '@/lib/types';
+import { absoluteUrl } from '@/lib/site';
 import type { Metadata } from 'next';
 
 /**
@@ -97,7 +98,7 @@ export async function generateMetadata({ params }: SchoolPageProps): Promise<Met
         title,
         description,
         type: 'website',
-        url: `https://schoolcompare.co.uk${canonicalPath}`,
+        url: absoluteUrl(canonicalPath),
         siteName: 'schoolcompare',
       },
       twitter: {
@@ -106,7 +107,7 @@ export async function generateMetadata({ params }: SchoolPageProps): Promise<Met
         description,
       },
       alternates: {
-        canonical: `https://schoolcompare.co.uk${canonicalPath}`,
+        canonical: absoluteUrl(canonicalPath),
       },
     };
   } catch {
@@ -147,7 +148,7 @@ export default async function SchoolPage({ params }: SchoolPageProps) {
     notFound();
   }
 
-  const { school_info, yearly_data, absence_data, ofsted, census, admissions, admissions_history, admission_distance, admission_distance_history, deprivation, finance } = data;
+  const { school_info, yearly_data, absence_data, ofsted, census, admissions, admissions_history, admission_distance, deprivation, finance } = data;
 
   // Redirect bare URN to canonical slug URL
   const canonicalSlug = schoolUrl(urn, school_info.school_name).replace('/school/', '');
@@ -177,6 +178,7 @@ export default async function SchoolPage({ params }: SchoolPageProps) {
     ofsted: ofsted ?? null,
     admissions: admissions ?? null,
     admissionDistance: admission_distance ?? null,
+    hasLocation: school_info.latitude != null && school_info.longitude != null,
     yearlyDataLength: yearly_data.length,
   };
   const primaryNavItems = buildNavItems(primaryFlags, navInput);
@@ -231,7 +233,6 @@ export default async function SchoolPage({ params }: SchoolPageProps) {
             admissions={admissions ?? null}
             admissionsHistory={admissions_history ?? []}
             admissionDistance={admission_distance ?? null}
-            admissionDistanceHistory={admission_distance_history ?? []}
             deprivation={deprivation ?? null}
             finance={finance ?? null}
             nationalAvg={nationalAvg}
@@ -254,7 +255,6 @@ export default async function SchoolPage({ params }: SchoolPageProps) {
             admissions={admissions ?? null}
             admissionsHistory={admissions_history ?? []}
             admissionDistance={admission_distance ?? null}
-            admissionDistanceHistory={admission_distance_history ?? []}
             deprivation={deprivation ?? null}
             finance={finance ?? null}
             nationalAvg={nationalAvg}

nextjs-app/app/schools/[place]/[phase]/page.tsx

@@ -0,0 +1,61 @@
+/**
+ * Phase variants of a place page.
+ *
+ * Phase is part of the query — "primary schools in beccles", "secondary
+ * schools in brentwood" — not a filter applied afterwards, so each gets its
+ * own indexable path. A place with no schools of the phase has no page: the
+ * per-phase threshold, not an error.
+ */
+import { notFound } from 'next/navigation';
+import type { Metadata } from 'next';
+import { fetchPlace } from '@/lib/places';
+import { fetchNationalAverages } from '@/lib/api';
+import { PlaceView } from '@/components/places/PlaceView';
+import { absoluteUrl } from '@/lib/site';
+
+interface Props { params: Promise<{ place: string; phase: string }> }
+
+export const revalidate = 604800;
+export const dynamicParams = true;
+
+const PHASES = ['primary', 'secondary'] as const;
+type Phase = (typeof PHASES)[number];
+
+const isPhase = (v: string): v is Phase => (PHASES as readonly string[]).includes(v);
+
+async function resolve(slug: string, phase: Phase) {
+  return (await fetchPlace('town', slug, phase))
+    ?? (await fetchPlace('locality', slug, phase));
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { place: slug, phase } = await params;
+  if (!isPhase(phase)) return { title: 'Place Not Found' };
+  const detail = await resolve(slug, phase);
+  if (!detail || detail.schools.length === 0) return { title: 'Place Not Found' };
+
+  const word = phase === 'secondary' ? 'Secondary' : 'Primary';
+  const { name } = detail.place;
+  return {
+    title: { absolute: `${word} Schools in ${name} — Ranked | schoolcompare` },
+    description:
+      `Every ${phase} school in ${name} ranked by results, with Ofsted grades and `
+      + `the local average against England.`,
+    alternates: { canonical: absoluteUrl(`/schools/${slug}/${phase}`) },
+  };
+}
+
+export default async function PlacePhasePage({ params }: Props) {
+  const { place: slug, phase } = await params;
+  if (!isPhase(phase)) notFound();
+  const detail = await resolve(slug, phase);
+  if (!detail || detail.schools.length === 0) notFound();
+
+  const national = await fetchNationalAverages().catch(() => null);
+  const englandAverage = phase === 'secondary'
+    ? national?.secondary?.attainment_8_score ?? null
+    : national?.primary?.rwm_expected_pct ?? null;
+
+  return <PlaceView detail={detail} phase={phase}
+    englandAverage={englandAverage} neighbours={[]} />;
+}

nextjs-app/app/schools/[place]/page.tsx

@@ -0,0 +1,94 @@
+/**
+ * Town and locality pages.
+ *
+ * A place below the five-school threshold is not in the registry, so
+ * fetchPlace returns null and the request 404s rather than rendering a page
+ * with nothing to say.
+ */
+import { notFound, redirect } from 'next/navigation';
+import type { Metadata } from 'next';
+import { fetchPlace, fetchPlaces, authoritySlug } from '@/lib/places';
+import { fetchNationalAverages } from '@/lib/api';
+import { PlaceView } from '@/components/places/PlaceView';
+import { absoluteUrl } from '@/lib/site';
+
+interface Props { params: Promise<{ place: string }> }
+
+// ISR: place aggregates change only when the pipeline runs.
+export const revalidate = 604800;
+export const dynamicParams = true;
+
+export async function generateStaticParams(): Promise<Array<{ place: string }>> {
+  // Off by default: ~2,000 place routes cannot be built in CI on every deploy.
+  // Matches the PRERENDER_SCHOOLS gate on the school route.
+  if (process.env.PRERENDER_PLACES !== '1') return [];
+  try {
+    return (await fetchPlaces())
+      .filter((p) => p.kind === 'town' || p.kind === 'locality')
+      .map((p) => ({ place: p.slug }));
+  } catch (error) {
+    console.warn('generateStaticParams: API unreachable, falling back to on-demand ISR.', error);
+    return [];
+  }
+}
+
+async function resolve(slug: string) {
+  return (await fetchPlace('town', slug)) ?? (await fetchPlace('locality', slug));
+}
+
+/** Other towns in the same authority — the cheapest honest definition of
+ *  "nearby", and enough to stop each place page being a dead end. */
+async function neighboursOf(detail: { place: { slug: string; parent_authority: string | null } }) {
+  if (!detail.place.parent_authority) return [];
+  const all = await fetchPlaces();
+  return all
+    .filter((p) => p.kind === 'town' && p.slug !== detail.place.slug)
+    .slice(0, 12);
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { place: slug } = await params;
+  const detail = await resolve(slug);
+  if (!detail) return { title: 'Place Not Found' };
+
+  const { name, count } = detail.place;
+  return {
+    // absolute: the root layout's template appends '| schoolcompare' to a
+    // plain string, and this title already carries it. Without this every
+    // place title read '... | schoolcompare | schoolcompare'.
+    title: { absolute: `Schools in ${name} — Compare ${count} Schools | schoolcompare` },
+    description:
+      `Every school in ${name} ranked by SATs and GCSE results, with Ofsted grades, `
+      + `the local average against England, and how close you had to live to get a place.`,
+    alternates: { canonical: absoluteUrl(`/schools/${slug}`) },
+  };
+}
+
+export default async function PlacePage({ params }: Props) {
+  const { place: slug } = await params;
+  const detail = await resolve(slug);
+  if (!detail) notFound();
+
+  // Global constraint: no page without a local average. A place with too few
+  // schools carrying results has nothing to say that a list does not, so it
+  // defers to its authority rather than publishing a thin page.
+  if (detail.averages.rwm_expected_pct == null
+      && detail.averages.attainment_8_score == null) {
+    if (detail.place.parent_authority) {
+      redirect(`/schools/authority/${authoritySlug(detail.place.parent_authority)}`);
+    }
+    notFound();
+  }
+
+  const national = await fetchNationalAverages().catch(() => null);
+  // NationalAverages is nested by phase — { primary: {...}, secondary: {...} }
+  // — not flat. Reading it flat silently yields undefined and the page renders
+  // with no comparison, which is the one thing that makes it not a list.
+  return (
+    <PlaceView
+      detail={detail}
+      englandAverage={national?.primary?.rwm_expected_pct ?? null}
+      neighbours={await neighboursOf(detail)}
+    />
+  );
+}

nextjs-app/app/schools/authority/[la]/page.tsx

@@ -0,0 +1,67 @@
+/**
+ * Local authority pages.
+ *
+ * A separate namespace from /schools/[place] because 67 town names collide
+ * with an authority name and neither set contains the other — Bedford the
+ * town holds 104 schools, Bedford the authority 86, because postal towns
+ * cross authority boundaries. The title says "Local Authority" so a reader
+ * landing on both knows which set each covers.
+ */
+import { notFound } from 'next/navigation';
+import type { Metadata } from 'next';
+import { fetchPlace, fetchPlaces } from '@/lib/places';
+import { fetchNationalAverages } from '@/lib/api';
+import { PlaceView } from '@/components/places/PlaceView';
+import { absoluteUrl } from '@/lib/site';
+
+interface Props { params: Promise<{ la: string }> }
+
+export const revalidate = 604800;
+export const dynamicParams = true;
+
+export async function generateStaticParams(): Promise<Array<{ la: string }>> {
+  // Gated like every other prerender in this app. There are only ~154
+  // authorities, but "few enough to always build" still means the API must be
+  // reachable at build time, and in CI it is not — the build fails with
+  // ECONNREFUSED rather than degrading. The catch is the same fallback the
+  // school route uses.
+  if (process.env.PRERENDER_PLACES !== '1') return [];
+  try {
+    return (await fetchPlaces())
+      .filter((p) => p.kind === 'authority')
+      .map((p) => ({ la: p.slug }));
+  } catch (error) {
+    console.warn('generateStaticParams: API unreachable, falling back to on-demand ISR.', error);
+    return [];
+  }
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { la } = await params;
+  const detail = await fetchPlace('authority', la);
+  if (!detail) return { title: 'Place Not Found' };
+
+  const { name, count } = detail.place;
+  return {
+    title: { absolute: `Schools in ${name} — Local Authority | schoolcompare` },
+    description:
+      `All ${count} schools in the ${name} local authority, ranked by SATs and GCSE `
+      + `results, with Ofsted grades and the authority average against England.`,
+    alternates: { canonical: absoluteUrl(`/schools/authority/${la}`) },
+  };
+}
+
+export default async function AuthorityPage({ params }: Props) {
+  const { la } = await params;
+  const detail = await fetchPlace('authority', la);
+  if (!detail) notFound();
+
+  const national = await fetchNationalAverages().catch(() => null);
+  return (
+    <PlaceView
+      detail={detail}
+      englandAverage={national?.primary?.rwm_expected_pct ?? null}
+      neighbours={[]}
+    />
+  );
+}

nextjs-app/app/schools/near/[outcode]/page.tsx

@@ -0,0 +1,62 @@
+/**
+ * Postcode district pages.
+ *
+ * No phase variants: nobody searches "primary schools in SW11", so the
+ * variants would be pages without demand. These exist to catch
+ * "schools near <postcode>" and to give London districts a geographic page
+ * where the GIAS town field cannot.
+ */
+import { notFound } from 'next/navigation';
+import type { Metadata } from 'next';
+import { fetchPlace, fetchPlaces } from '@/lib/places';
+import { fetchNationalAverages } from '@/lib/api';
+import { PlaceView } from '@/components/places/PlaceView';
+import { absoluteUrl } from '@/lib/site';
+
+interface Props { params: Promise<{ outcode: string }> }
+
+export const revalidate = 604800;
+export const dynamicParams = true;
+
+export async function generateStaticParams(): Promise<Array<{ outcode: string }>> {
+  // 1,760 of these; same CI budget argument as the town routes.
+  if (process.env.PRERENDER_PLACES !== '1') return [];
+  try {
+    return (await fetchPlaces())
+      .filter((p) => p.kind === 'outcode')
+      .map((p) => ({ outcode: p.slug }));
+  } catch (error) {
+    console.warn('generateStaticParams: API unreachable, falling back to on-demand ISR.', error);
+    return [];
+  }
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { outcode } = await params;
+  const detail = await fetchPlace('outcode', outcode);
+  if (!detail) return { title: 'Place Not Found' };
+
+  const { name, count } = detail.place;
+  return {
+    title: { absolute: `Schools near ${name} | schoolcompare` },
+    description:
+      `${count} schools in the ${name} postcode district, ranked by results, with `
+      + `Ofsted grades and how close you had to live to get a place.`,
+    alternates: { canonical: absoluteUrl(`/schools/near/${outcode}`) },
+  };
+}
+
+export default async function OutcodePage({ params }: Props) {
+  const { outcode } = await params;
+  const detail = await fetchPlace('outcode', outcode);
+  if (!detail) notFound();
+
+  const national = await fetchNationalAverages().catch(() => null);
+  return (
+    <PlaceView
+      detail={detail}
+      englandAverage={national?.primary?.rwm_expected_pct ?? null}
+      neighbours={[]}
+    />
+  );
+}

nextjs-app/app/sitemap.xml/route.ts

@@ -1,32 +1,8 @@
-/**
- * Runtime proxy for /sitemap.xml → the FastAPI backend's generated sitemap.
- *
- * Like the /api/* proxy, this reads FASTAPI_URL at request time rather than
- * baking the backend host into the build, so one image works in every
- * environment. robots.ts points crawlers here.
- */
-
-import { NextResponse } from 'next/server';
+import { proxySitemap } from '@/lib/sitemapProxy';
 
 export const dynamic = 'force-dynamic';
 export const runtime = 'nodejs';
 
-function backendOrigin(): string {
-  const base = process.env.FASTAPI_URL || process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000/api';
-  return base.replace(/\/api$/, '');
-}
-
 export async function GET() {
-  let upstream: Response;
-  try {
-    upstream = await fetch(`${backendOrigin()}/sitemap.xml`, { cache: 'no-store' });
-  } catch {
-    return new NextResponse('Sitemap temporarily unavailable', { status: 502 });
-  }
-
-  const body = await upstream.text();
-  return new NextResponse(body, {
-    status: upstream.status,
-    headers: { 'content-type': upstream.headers.get('content-type') || 'application/xml' },
-  });
+  return proxySitemap('/sitemap.xml');
 }

nextjs-app/app/sitemaps/[...parts]/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from 'next/server';
+import { proxySitemap } from '@/lib/sitemapProxy';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+/**
+ * Children are /sitemaps/static.xml and /sitemaps/schools-{n}.xml. The name is
+ * validated here rather than passed through, so this route cannot be used to
+ * reach arbitrary backend paths.
+ */
+const CHILD = /^(static|schools-\d+|places-\d+|outcodes-\d+)\.xml$/;
+
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ parts: string[] }> },
+) {
+  const { parts } = await params;
+  const name = parts.join('/');
+  if (!CHILD.test(name)) {
+    return new NextResponse('Not found', { status: 404 });
+  }
+  return proxySitemap(`/sitemaps/${name}`);
+}

nextjs-app/components/CutoffTrendChart.tsx

@@ -1,123 +0,0 @@
-'use client';
-
-/**
- * CutoffTrendChart
- * The last distance offered, year by year.
- *
- * Two things this chart deliberately does not do.
- *
- * It does not join across gaps (`spanGaps: false`). A missing year is usually a
- * year the authority published nothing, and a line drawn through it would
- * assert a cut-off that was never measured.
- *
- * It does not plot the non-distance outcomes. A year in which the school was
- * not oversubscribed has no distance — that is the point of it — and giving it
- * a y-position would put a number on the axis that does not exist. The mockup
- * floated such years at the top of the plot; here they are a gap in the line
- * and a labelled row in the table underneath, which is where a reason can be
- * stated in words rather than implied by a coordinate.
- */
-
-import { Line } from 'react-chartjs-2';
-import { ChartOptions } from 'chart.js';
-import '@/lib/chartSetup';
-import { useThemeTokens, alpha } from '@/lib/theme';
-import type { CutoffYearRow } from './school/lastDistanceOffered';
-import styles from './AdmissionsTrendChart.module.css';
-
-const METRES_PER_MILE = 1609.344;
-
-export default function CutoffTrendChart({ rows }: { rows: CutoffYearRow[] }) {
-  // rows arrive newest-first; a time axis reads oldest-first.
-  const axis = [...rows].reverse();
-  const published = axis.filter((r) => r.distanceM != null);
-  if (published.length < 2) return null;
-
-  const labels = axis.map((r) => String(r.year));
-  const values: (number | null)[] = axis.map((r) =>
-    r.distanceM != null ? r.distanceM / METRES_PER_MILE : null,
-  );
-
-  const present = values.map((v, i) => (v != null ? i : -1)).filter((i) => i >= 0);
-  const lastIdx = present[present.length - 1];
-
-  const numeric = values.filter((v): v is number => v != null);
-  const lo = Math.min(...numeric);
-  const hi = Math.max(...numeric);
-  // Headroom proportional to the spread, with a floor so a flat series does not
-  // collapse onto a single gridline and read as more precise than it is.
-  const pad = Math.max(0.05, (hi - lo) * 0.25);
-  const yMin = Math.max(0, lo - pad);
-  const yMax = hi + pad;
-
-  const [cBrand, cGrid, cInverse, cInverseText, cCard] = useThemeTokens(
-    '--brand', '--chart-grid', '--surface-inverse', '--text-inverse', '--bg-card',
-  );
-
-  const options: ChartOptions<'line'> = {
-    responsive: true,
-    maintainAspectRatio: false,
-    interaction: { mode: 'index', intersect: false },
-    layout: { padding: { top: 8 } },
-    plugins: {
-      legend: { display: false },
-      title: { display: false },
-      tooltip: {
-        backgroundColor: cInverse,
-        titleColor: cInverseText,
-        bodyColor: cInverseText,
-        padding: 10,
-        titleFont: { size: 12 },
-        bodyFont: { size: 12 },
-        callbacks: {
-          label: (ctx) =>
-            ctx.parsed.y == null ? '' : `Last distance offered: ${ctx.parsed.y.toFixed(2)} miles`,
-        },
-      },
-    },
-    scales: {
-      y: {
-        min: yMin,
-        max: yMax,
-        grid: { color: cGrid },
-        ticks: {
-          font: { size: 11 },
-          maxTicksLimit: 5,
-          callback: (v) => `${Number(v).toFixed(2)} mi`,
-        },
-      },
-      x: {
-        grid: { display: false },
-        ticks: { font: { size: 11 }, autoSkip: true, maxRotation: 0, autoSkipPadding: 16 },
-      },
-    },
-  };
-
-  const data = {
-    labels,
-    datasets: [
-      {
-        label: 'Last distance offered',
-        data: values,
-        clip: false as const,
-        spanGaps: false,
-        borderColor: cBrand,
-        backgroundColor: alpha('--brand', 0.10),
-        borderWidth: 2.5,
-        tension: 0.3,
-        fill: true,
-        pointRadius: values.map((v, i) => (v == null ? 0 : i === lastIdx ? 5 : 3)),
-        pointBackgroundColor: cBrand,
-        pointBorderColor: cCard,
-        pointBorderWidth: values.map((_, i) => (i === lastIdx ? 2 : 0)),
-        pointHoverRadius: 6,
-      },
-    ],
-  };
-
-  return (
-    <div className={styles.wrapper}>
-      <Line data={data} options={options} />
-    </div>
-  );
-}

nextjs-app/components/places/PlaceView.module.css

@@ -0,0 +1,196 @@
+/* Tokens only — see globals.css. Follows RankingsView's conventions, and in
+   particular its link treatment: table links take --text-primary with no
+   underline and a brand-coloured hover, not the browser default. The first
+   cut used bare <Link> with no class at all, which rendered as default blue
+   underlined links and read as unstyled beside the rest of the site. */
+.container {
+  width: 100%;
+  min-width: 0;
+}
+
+.header {
+  margin-bottom: 1.5rem;
+}
+
+.header h1 {
+  font-size: 2.25rem;
+  font-weight: 700;
+  color: var(--text-primary);
+  margin-bottom: 0.5rem;
+  font-family: var(--font-display);
+  text-wrap: balance;
+}
+
+.summary {
+  font-size: 1rem;
+  color: var(--text-secondary);
+  margin: 0;
+  line-height: 1.6;
+}
+
+/* Links in running copy: brand colour, underline on hover only. */
+.inlineLink {
+  color: var(--brand);
+  text-decoration: none;
+  transition: color 0.2s ease;
+}
+
+.inlineLink:hover {
+  color: var(--brand-strong);
+  text-decoration: underline;
+}
+
+/* Phase variants are separate indexable pages, so the bare place page has to
+   link them — a sitemap entry alone leaves them with no internal path in. */
+.phaseLinks {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem 0.75rem;
+  margin: 0 0 1.25rem;
+}
+
+.phaseLink {
+  display: inline-block;
+  padding: 0.4rem 0.875rem;
+  border: 1px solid var(--border-strong);
+  border-radius: 999px;
+  font-size: 0.875rem;
+  font-weight: 500;
+  color: var(--text-primary);
+  text-decoration: none;
+  transition: border-color 0.2s ease, color 0.2s ease;
+}
+
+.phaseLink:hover {
+  border-color: var(--brand);
+  color: var(--brand-strong);
+}
+
+/* The one number a list cannot give you, so it gets its own band. */
+.compare {
+  background: var(--bg-secondary);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 0.875rem 1.125rem;
+  margin: 0 0 1.5rem;
+  color: var(--text-primary);
+  font-size: 1rem;
+}
+
+.ofsted {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem 1.25rem;
+  list-style: none;
+  padding: 0;
+  margin: 0 0 1.5rem;
+  font-size: 0.9375rem;
+  color: var(--text-secondary);
+}
+
+.group {
+  margin-bottom: 2rem;
+}
+
+.groupHeading {
+  display: flex;
+  align-items: baseline;
+  gap: 0.625rem;
+  font-size: 1.25rem;
+  font-weight: 600;
+  color: var(--text-primary);
+  font-family: var(--font-display);
+  margin: 0 0 0.75rem;
+}
+
+.groupCount {
+  font-size: 0.8125rem;
+  font-weight: 500;
+  color: var(--text-secondary);
+  background: var(--bg-secondary);
+  border-radius: 999px;
+  padding: 0.125rem 0.5rem;
+}
+
+/* Wide content scrolls in its own container so the page body never does. */
+.tableWrap {
+  overflow-x: auto;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--bg-card);
+}
+
+.table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.9375rem;
+}
+
+.table th,
+.table td {
+  padding: 0.75rem 1rem;
+  text-align: left;
+  border-bottom: 1px solid var(--border);
+}
+
+.table th {
+  background: var(--bg-secondary);
+  color: var(--text-secondary);
+  font-weight: 600;
+  font-size: 0.8125rem;
+}
+
+.table tbody tr:last-child td {
+  border-bottom: none;
+}
+
+.table th:last-child,
+.num {
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+}
+
+/* The measure is spelled out; the tooltip carries the definition. */
+.metricHead {
+  text-decoration: none;
+  cursor: help;
+  border-bottom: 1px dotted var(--border-strong);
+}
+
+/* Table links: site convention is body colour, brand on hover. */
+.schoolLink {
+  color: var(--text-primary);
+  text-decoration: none;
+  transition: color 0.2s ease;
+}
+
+.schoolLink:hover {
+  color: var(--brand-strong);
+}
+
+/* "Not published" is a fact about the school, not an error. */
+.noData {
+  color: var(--text-muted);
+  font-size: 0.8125rem;
+}
+
+.neighbours {
+  margin-top: 2rem;
+}
+
+.neighbours h2 {
+  font-size: 1.125rem;
+  font-weight: 600;
+  color: var(--text-primary);
+  margin: 0 0 0.75rem;
+  font-family: var(--font-display);
+}
+
+.neighbours ul {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem 1rem;
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}

nextjs-app/components/places/PlaceView.tsx

@@ -0,0 +1,227 @@
+/**
+ * One place page, shared by all four families.
+ *
+ * They differ in what fills the registry, not in what the page shows, so a
+ * second component would be a second place to forget the same change.
+ *
+ * The local-versus-England comparison is the reason this page is not a list:
+ * it is the one number a parent cannot get by reading the schools one by one,
+ * and it is what keeps the page from reading as a name dropped into a
+ * template.
+ */
+import Link from 'next/link';
+import type { PlaceDetail, PlaceSummary } from '@/lib/places';
+import { placeUrl, authoritySlug } from '@/lib/places';
+import type { School } from '@/lib/types';
+import { schoolUrl } from '@/lib/utils';
+import { absoluteUrl } from '@/lib/site';
+import styles from './PlaceView.module.css';
+
+interface Props {
+  detail: PlaceDetail;
+  phase?: 'primary' | 'secondary';
+  englandAverage: number | null;
+  /** Nearby places, so the page links onward instead of dead-ending. */
+  neighbours: PlaceSummary[];
+}
+
+// Ofsted grades in the order they are reported.
+const OFSTED_LABELS: Array<[number, string]> = [
+  [1, 'Outstanding'], [2, 'Good'],
+  [3, 'Requires improvement'], [4, 'Inadequate'],
+];
+
+/**
+ * Column headings, taken from the site's own metric dictionary rather than
+ * invented here — see METRIC_DEFINITIONS in backend/schemas.py, surfaced at
+ * /api/metrics. The first cut said "RWM expected", which is jargon that
+ * appears nowhere else on the site.
+ */
+const METRICS = {
+  primary: {
+    key: 'rwm_expected_pct' as const,
+    heading: 'Reading, writing & maths',
+    hint: '% meeting the expected standard in reading, writing and maths',
+    unit: '%',
+  },
+  secondary: {
+    key: 'attainment_8_score' as const,
+    heading: 'Attainment 8',
+    hint: "Average grade across a pupil's best 8 GCSEs, including English and maths",
+    unit: '',
+  },
+};
+
+type PhaseKey = keyof typeof METRICS;
+
+/** All-through schools sit in both phases, matching the search filters. */
+function isPhase(school: School, phase: PhaseKey): boolean {
+  const p = (school.phase ?? '').toLowerCase();
+  if (p === 'all-through') return true;
+  return phase === 'secondary'
+    ? p.includes('secondary') || p === '16 plus'
+    : p.includes('primary') || p.includes('middle');
+}
+
+function SchoolTable({ schools, phase }: { schools: School[]; phase: PhaseKey }) {
+  const metric = METRICS[phase];
+  return (
+    <div className={styles.tableWrap}>
+      <table className={styles.table}>
+        <thead>
+          <tr>
+            <th scope="col">School</th>
+            <th scope="col">
+              <abbr className={styles.metricHead} title={metric.hint}>
+                {metric.heading}
+              </abbr>
+            </th>
+          </tr>
+        </thead>
+        <tbody>
+          {schools.map((s) => {
+            const value = s[metric.key];
+            return (
+              <tr key={s.urn}>
+                <td>
+                  <Link href={schoolUrl(s.urn, s.school_name)} className={styles.schoolLink}>
+                    {s.school_name}
+                  </Link>
+                </td>
+                <td className={styles.num}>
+                  {value == null
+                    ? <span className={styles.noData}>Not published</span>
+                    : `${Math.round(Number(value))}${metric.unit}`}
+                </td>
+              </tr>
+            );
+          })}
+        </tbody>
+      </table>
+    </div>
+  );
+}
+
+export function PlaceView({ detail, phase, englandAverage, neighbours }: Props) {
+  const { place, schools, averages } = detail;
+  const local = averages[METRICS[phase ?? 'primary'].key];
+  const phaseWord = phase === 'secondary' ? 'Secondary schools'
+    : phase === 'primary' ? 'Primary schools' : 'Schools';
+  const graded = OFSTED_LABELS
+    .map(([grade, label]) => [label, schools.filter((s) => s.ofsted_grade === grade).length] as const)
+    .filter(([, n]) => n > 0);
+
+  /*
+   * An unphased page holds both primaries and secondaries, and they are
+   * scored on different measures — a percentage and a 0-90 score. Showing one
+   * column for both left 30% of rows blank on /schools/brentwood and put two
+   * incomparable scales in one column when it did not.
+   *
+   * So the phases get a table each. A blank cell inside one now means the
+   * school genuinely has no published result, which is worth saying.
+   */
+  const groups: Array<[PhaseKey, School[]]> = phase
+    ? [[phase, schools]]
+    : (['primary', 'secondary'] as PhaseKey[])
+        .map((p) => [p, schools.filter((s) => isPhase(s, p))] as [PhaseKey, School[]])
+        .filter(([, list]) => list.length > 0);
+
+  const jsonLd = {
+    '@context': 'https://schema.org',
+    '@graph': [
+      {
+        '@type': 'ItemList',
+        name: `${phaseWord} in ${place.name}`,
+        numberOfItems: schools.length,
+        itemListElement: schools.slice(0, 20).map((s, i) => ({
+          '@type': 'ListItem',
+          position: i + 1,
+          url: absoluteUrl(schoolUrl(s.urn, s.school_name)),
+          name: s.school_name,
+        })),
+      },
+      {
+        '@type': 'BreadcrumbList',
+        itemListElement: [
+          { '@type': 'ListItem', position: 1, name: 'Schools', item: absoluteUrl('/') },
+          { '@type': 'ListItem', position: 2, name: place.name },
+        ],
+      },
+    ],
+  };
+
+  return (
+    <div className={styles.container}>
+      <script
+        type="application/ld+json"
+        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
+      />
+
+      <header className={styles.header}>
+        <h1>{phaseWord} in {place.name}</h1>
+        <p className={styles.summary}>
+          {place.count} schools
+          {place.parent_authority && (
+            <>
+              {' · '}
+              <Link href={`/schools/authority/${authoritySlug(place.parent_authority)}`}
+                className={styles.inlineLink}>
+                {place.parent_authority}
+              </Link>
+            </>
+          )}
+        </p>
+      </header>
+
+      {!phase && (place.phases ?? []).length > 0 && (
+        <nav className={styles.phaseLinks} aria-label="By phase">
+          {(place.phases ?? []).map((ph) => (
+            <Link key={ph} href={`/schools/${place.slug}/${ph}`} className={styles.phaseLink}>
+              {ph === 'secondary' ? 'Secondary schools' : 'Primary schools'} in {place.name}
+            </Link>
+          ))}
+        </nav>
+      )}
+
+      {local != null && englandAverage != null && (
+        <p className={styles.compare} data-testid="local-vs-england">
+          {place.name} averages <strong>{Math.round(local)}</strong> against{' '}
+          <strong>{Math.round(englandAverage)}</strong> across England.
+        </p>
+      )}
+
+      {graded.length > 0 && (
+        <ul className={styles.ofsted} data-testid="ofsted-distribution">
+          {graded.map(([label, n]) => (
+            <li key={label}>{label}: <strong>{n}</strong></li>
+          ))}
+        </ul>
+      )}
+
+      {groups.map(([p, list]) => (
+        <section key={p} className={styles.group}>
+          {groups.length > 1 && (
+            <h2 className={styles.groupHeading}>
+              {p === 'secondary' ? 'Secondary schools' : 'Primary schools'}
+              <span className={styles.groupCount}>{list.length}</span>
+            </h2>
+          )}
+          <SchoolTable schools={list} phase={p} />
+        </section>
+      ))}
+
+      {neighbours.length > 0 && (
+        <nav className={styles.neighbours} aria-label="Nearby places">
+          <h2>Nearby</h2>
+          <ul>
+            {neighbours.map((n) => (
+              <li key={n.kind + n.slug}>
+                <Link href={placeUrl(n.kind, n.slug)} className={styles.inlineLink}>{n.name}</Link>
+              </li>
+            ))}
+          </ul>
+        </nav>
+      )}
+    </div>
+  );
+}

nextjs-app/components/school/AdmissionsSection.tsx

@@ -9,28 +9,29 @@
  * AdmissionsViewToggle client island, which receives both views as
  * server-rendered children. When there is only one year of offer data no
  * toggle renders at all, so such pages ship zero admissions JavaScript.
+ *
+ * The two views are stacked in one grid cell so switching never shifts layout,
+ * which means the card is sized by the TALLER of them. Keep any view added
+ * here close to the tile grid in height: a cut-off-distance view carrying a
+ * chart, a table and a map was tried, measured 1402px against the tiles' 316px,
+ * and left the default view as four tiles adrift in blank card. It now lives in
+ * DistanceSection.
  */
 
 import type { ReactNode } from 'react';
-import type { School, SchoolAdmissions, SchoolAdmissionDistance } from '@/lib/types';
+import type { SchoolAdmissions, SchoolAdmissionDistance } from '@/lib/types';
 import { formatAcademicYear, formatPercentage } from '@/lib/utils';
 import { summariseAdmissions } from '@/lib/compareLogic';
 import { Section, sectionStyles as styles } from './sectionShared';
 import { AdmissionsViewToggle, type AdmissionsView } from './AdmissionsViewToggle';
 import { AdmissionsTrendChart } from './charts';
-import { CutoffDistanceDetail } from './CutoffDistanceDetail';
-import {
-  describeCutoff, cutoffYearRows,
-  CUTOFF_NOTE, CUTOFF_MEASUREMENT_NOTE,
-} from './lastDistanceOffered';
+import { describeCutoff, CUTOFF_NOTE, CUTOFF_MEASUREMENT_NOTE } from './lastDistanceOffered';
 
 
 export function AdmissionsSection({
   admissions,
   admissionsHistory,
   admissionDistance,
-  admissionDistanceHistory,
-  schoolInfo,
   isAllThrough,
 }: {
   /* Nullable: the two data sources are independent. A minority of schools have
@@ -40,18 +41,9 @@ export function AdmissionsSection({
   admissions: SchoolAdmissions | null;
   admissionsHistory: SchoolAdmissions[];
   admissionDistance: SchoolAdmissionDistance | null;
-  admissionDistanceHistory: SchoolAdmissionDistance[];
-  schoolInfo: School;
   isAllThrough: boolean;
 }) {
   const cutoff = describeCutoff(admissionDistance);
-  // Every year in the span, including the ones with nothing in them — the
-  // classification of a missing year is what the Distance view is mostly for.
-  const cutoffRows = cutoffYearRows(admissionDistanceHistory, admissionsHistory);
-  const publishedYears = cutoffRows.filter((r) => r.status === 'published').length;
-  // One published year is a fact, not a history: the tile already says it, and
-  // a chart of a single point invites a trend reading that is not there.
-  const showDistanceView = publishedYears >= 2;
 
   // Trend toggle only appears with ≥2 years carrying an offer rate.
   const admissionsOfferYears = admissionsHistory.filter((h) => h.first_preference_offer_pct != null).length;
@@ -78,10 +70,16 @@ export function AdmissionsSection({
   {/* Spans both columns rather than taking a half-width cell. This is the
       figure parents come to the page for, and at tile width the two-line
       "0.31 miles / September 2025" pairing wraps badly. */}
+  {/* The {' '} between the figure and its metric support is not decoration.
+      The two are flex children, so the gap is drawn by CSS and the text layer
+      had nothing between them: textContent read "0.88 miles1.4 km", which is
+      what a screen reader announces and what any text matcher sees. Whitespace
+      text nodes are not rendered as flex items, so this changes the reading
+      without changing the layout. */}
   const distanceTile = cutoff && (
     <div className={`${styles.admissionsTile} ${styles.admissionsTileDistance}`}>
       <dd className={styles.admissionsTileNum}>
-        {cutoff.primary}
+        {cutoff.primary}{' '}
         <span className={styles.admissionsTileSub}>{cutoff.secondary}</span>
       </dd>
       <dt className={styles.admissionsTileLabel}>
@@ -182,10 +180,6 @@ export function AdmissionsSection({
     </>
   );
 
-  const distanceView = showDistanceView && (
-    <CutoffDistanceDetail rows={cutoffRows} schoolInfo={schoolInfo} />
-  );
-
   const views: AdmissionsView[] = [
     { id: 'year', label: 'This year', content: yearView, className: styles.admissionsViewYear },
   ];
@@ -197,14 +191,6 @@ export function AdmissionsSection({
       className: styles.admissionsViewTrend,
     });
   }
-  if (showDistanceView) {
-    views.push({
-      id: 'distance',
-      label: 'Distance',
-      content: distanceView,
-      className: styles.admissionsViewTrend,
-    });
-  }
 
   return (
     <Section id="admissions">

nextjs-app/components/school/CutoffDistanceDetail.tsx

@@ -1,70 +0,0 @@
-/**
- * CutoffDistanceDetail — the full year-by-year cut-off story.
- *
- * Chart, table, map and postcode check, in that order: the shape of the trend,
- * then what happened in each year, then the same numbers over real streets,
- * then the reader's own address measured against them.
- *
- * Shared by both templates because the content is identical, but placed
- * differently by each. The primary page has a segmented control and gives this
- * its own "Distance" tab; the secondary page is one flat panel by design, so it
- * renders inline beneath the metric cards. Extracting it keeps the caveats and
- * the ordering from drifting apart between the two.
- *
- * Server component — the map and postcode form are the only client parts, and
- * they carry their own boundary.
- */
-
-import type { School } from '@/lib/types';
-import { sectionStyles as styles } from './sectionShared';
-import { CutoffTrendChart } from './charts';
-import { CutoffYearTable } from './CutoffYearTable';
-import { CutoffMapPanel } from './CutoffMapPanel';
-import {
-  cutoffTrendSummary, cutoffCoverageNote,
-  CUTOFF_NOTE, CUTOFF_MEASUREMENT_NOTE,
-  type CutoffYearRow,
-} from './lastDistanceOffered';
-
-export function CutoffDistanceDetail({
-  rows,
-  schoolInfo,
-  /** Repeat the "not a catchment" caveat here. On the primary page this view is
-   *  behind a tab, so a reader can reach it without ever seeing the tile that
-   *  carries the caveat; on the secondary page the caveat is already directly
-   *  above, and repeating it verbatim reads as a stutter. */
-  showCaveat = true,
-}: {
-  rows: CutoffYearRow[];
-  schoolInfo: School;
-  showCaveat?: boolean;
-}) {
-  const publishedYears = rows.filter((r) => r.status === 'published').length;
-  if (publishedYears < 2) return null;
-
-  const trendSummary = cutoffTrendSummary(rows);
-  const coverageNote = cutoffCoverageNote(rows);
-
-  return (
-    <>
-      <div className={styles.admissionsChartCap}>Last distance offered, by year</div>
-      <CutoffTrendChart rows={rows} />
-      <p className={styles.cutoffChartKey}>
-        The line breaks where no figure was published — it is never drawn across
-        a gap. The table below says what happened in each of those years.
-      </p>
-      {trendSummary && <p className={styles.admissionsTrendSummary}>{trendSummary}</p>}
-
-      <CutoffYearTable rows={rows} />
-      {coverageNote && <p className={styles.cutoffChartKey}>{coverageNote}</p>}
-
-      <CutoffMapPanel schoolInfo={schoolInfo} rows={rows} />
-
-      {showCaveat && (
-        <p className={styles.admissionsDistanceNote}>
-          {CUTOFF_NOTE} {CUTOFF_MEASUREMENT_NOTE}
-        </p>
-      )}
-    </>
-  );
-}

nextjs-app/components/school/CutoffMapPanel.tsx

@@ -1,28 +1,36 @@
 'use client';
 
 /**
- * CutoffMapPanel — "Where the last place went".
+ * CutoffMapPanel — "How far away are you?"
  *
- * The rings and the postcode check live in one component because they are one
- * question asked twice: the map answers "how far is that?" and the form answers
- * "how far are we?". Entering a postcode drops a pin on the same rings rather
- * than producing a separate verdict somewhere else on the page.
+ * Measures a postcode against the one cut-off we publish, and will draw that
+ * cut-off as a ring around the school on request.
+ *
+ * It used to compare against every published year and show a set of shrinking
+ * rings. Earlier years are now held back as a paid feature and no longer leave
+ * the API, so this answers one question about one year — which makes the
+ * verdict sharper to state, and puts more weight on qualifying it properly,
+ * since there is no run of years left to soften a single close call.
+ *
+ * The map is not rendered until asked for: before a postcode is entered it is a
+ * circle drawn round a school, and it costs a Leaflet bundle and 240px of
+ * height to say that. A successful check opens it automatically, because that
+ * is the point at which it starts answering something.
  *
  * The postcode never leaves the browser except to postcodes.io for a lat/long,
  * and nothing is stored — this is a client-side measurement, not a lookup
  * against the family.
  */
 
-import { useState, useMemo, type FormEvent } from 'react';
+import { useState, type FormEvent } from 'react';
 import dynamic from 'next/dynamic';
-import type { School } from '@/lib/types';
+import type { School, SchoolAdmissionDistance } from '@/lib/types';
 import { geocodePostcode, calculateDistance } from '@/lib/api';
 import { isValidPostcode } from '@/lib/utils';
 import {
-  compareToCutoffs, CUTOFF_CHECK_CAVEAT, CUTOFF_MAP_CAVEAT,
-  type CutoffYearRow, type CutoffCheckResult, type CutoffVerdict,
+  compareToCutoff, CUTOFF_CHECK_CAVEAT,
+  type CutoffCheckResult, type CutoffVerdict,
 } from './lastDistanceOffered';
-import type { CutoffRing } from '../LeafletCutoffMapInner';
 import styles from './schoolSections.module.css';
 
 const CutoffMap = dynamic(() => import('../LeafletCutoffMapInner'), {
@@ -30,59 +38,35 @@ const CutoffMap = dynamic(() => import('../LeafletCutoffMapInner'), {
   loading: () => <div className={styles.cutoffMapSkeleton} aria-hidden="true" />,
 });
 
-const VERDICT_MARK: Record<CutoffVerdict, string> = {
-  inside: '✓',
-  outside: '✕',
-  'too-close': '≈',
-  unknown: '–',
-};
-
-const VERDICT_TITLE: Record<CutoffVerdict, string> = {
-  inside: 'Inside that year’s cut-off',
-  outside: 'Outside that year’s cut-off',
-  'too-close': 'Too close to the cut-off to say',
-  unknown: 'No published figure for this year',
-};
-
 // Written out rather than composed from the verdict string. A computed
 // `styles[...]` key silently yields undefined when a class is renamed, and an
-// unstyled "outside" chip would look exactly like an "inside" one.
+// unstyled "outside" result would look exactly like an "inside" one.
 const VERDICT_CLASS: Record<CutoffVerdict, string> = {
-  inside: styles.cutoffYearInside,
-  outside: styles.cutoffYearOutside,
-  'too-close': styles.cutoffYearTooClose,
-  unknown: styles.cutoffYearUnknown,
+  inside: styles.cutoffResultInside,
+  outside: styles.cutoffResultOutside,
+  'too-close': styles.cutoffResultTooClose,
 };
 
 export function CutoffMapPanel({
   schoolInfo,
-  rows,
+  cutoff,
 }: {
   schoolInfo: School;
-  rows: CutoffYearRow[];
+  cutoff: SchoolAdmissionDistance;
 }) {
   const [postcode, setPostcode] = useState('');
   const [home, setHome] = useState<{ lat: number; lng: number } | null>(null);
   const [result, setResult] = useState<CutoffCheckResult | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [busy, setBusy] = useState(false);
+  const [mapOpen, setMapOpen] = useState(false);
 
   const lat = schoolInfo.latitude;
   const lng = schoolInfo.longitude;
+  const cutoffM = cutoff.distance_m;
 
-  const rings: CutoffRing[] = useMemo(() => {
-    const published = rows.filter((r) => r.distanceM != null);
-    return published.map((r, i) => ({
-      year: r.year,
-      radiusM: r.distanceM as number,
-      // rows are newest-first, so the first published row is the current year.
-      latest: i === 0,
-    }));
-  }, [rows]);
-
-  // Without coordinates there is nothing to draw rings around and nothing to
-  // measure a postcode against.
-  if (lat == null || lng == null || rings.length === 0) return null;
+  // Without coordinates there is nothing to measure against and nothing to draw.
+  if (lat == null || lng == null || cutoffM == null) return null;
 
   const onCheck = async (e: FormEvent) => {
     e.preventDefault();
@@ -107,9 +91,10 @@ export function CutoffMapPanel({
         return;
       }
       setHome({ lat: point.latitude, lng: point.longitude });
+      setMapOpen(true);
       // calculateDistance returns kilometres; everything here is metres.
       const metres = calculateDistance(point.latitude, point.longitude, lat, lng) * 1000;
-      setResult(compareToCutoffs(metres, rows));
+      setResult(compareToCutoff(metres, cutoffM, cutoff.year));
     } catch {
       setError('Something went wrong looking up that postcode. Try again in a moment.');
       setResult(null);
@@ -119,42 +104,11 @@ export function CutoffMapPanel({
     }
   };
 
-  const latestRing = rings[0];
-
   return (
-    <div className={styles.cutoffMapPanel}>
-      <h3 className={styles.cutoffMapTitle}>Where the last place went</h3>
-
-      <div className={styles.cutoffMapFigure}>
-        <CutoffMap lat={lat} lng={lng} rings={rings} home={home} interactive={false} />
-      </div>
-
-      <ul className={styles.cutoffMapLegend}>
-        <li>
-          <span className={`${styles.cutoffSwatch} ${styles.cutoffSwatchNow}`} aria-hidden="true" />
-          {latestRing.year} cut-off
-        </li>
-        {rings.length > 1 && (
-          <li>
-            <span className={`${styles.cutoffSwatch} ${styles.cutoffSwatchPast}`} aria-hidden="true" />
-            Earlier years, {rings[rings.length - 1].year}–{rings[1].year}
-          </li>
-        )}
-        {home && (
-          <li>
-            <span className={`${styles.cutoffSwatch} ${styles.cutoffSwatchHome}`} aria-hidden="true" />
-            Your postcode
-          </li>
-        )}
-      </ul>
-
-      <p className={styles.cutoffMapCaveat}>{CUTOFF_MAP_CAVEAT}</p>
-
     <div className={styles.cutoffCheck}>
-        <h4 className={styles.cutoffCheckTitle}>How far away are you?</h4>
       <p className={styles.cutoffCheckSub}>
-          We measure a straight line from your postcode to the school and compare
-          it with each year’s cut-off. Your postcode is not stored.
+        Straight-line distance from your postcode, compared with the September{' '}
+        {cutoff.year} cut-off. Not stored.
       </p>
 
       <form className={styles.cutoffCheckForm} onSubmit={onCheck}>
@@ -178,28 +132,50 @@ export function CutoffMapPanel({
       {error && <p className={styles.cutoffCheckError} role="alert">{error}</p>}
 
       {result && (
-          <div className={styles.cutoffCheckResult} role="status">
+        <div
+          className={`${styles.cutoffCheckResult} ${VERDICT_CLASS[result.verdict]}`}
+          role="status"
+        >
           <p className={styles.cutoffCheckHeadline}>{result.headline}</p>
           {result.detail && <p className={styles.cutoffCheckDetail}>{result.detail}</p>}
+        </div>
+      )}
 
-            <ul className={styles.cutoffYearStrip}>
-              {[...result.years].reverse().map((y) => (
-                <li
-                  key={y.year}
-                  className={`${styles.cutoffYearChip} ${VERDICT_CLASS[y.verdict]}`}
-                  title={VERDICT_TITLE[y.verdict]}
-                >
-                  <span className={styles.cutoffYearChipYear}>{y.year}</span>
-                  <span aria-hidden="true">{VERDICT_MARK[y.verdict]}</span>
-                  <span className={styles.srOnly}>{VERDICT_TITLE[y.verdict]}</span>
+      {mapOpen ? (
+        <div className={styles.cutoffMapReveal}>
+          <div className={styles.cutoffMapFigure}>
+            <CutoffMap
+              lat={lat}
+              lng={lng}
+              rings={[{ year: cutoff.year, radiusM: cutoffM, latest: true }]}
+              home={home}
+              interactive={false}
+            />
+          </div>
+          <ul className={styles.cutoffMapLegend}>
+            <li>
+              <span className={`${styles.cutoffSwatch} ${styles.cutoffSwatchNow}`} aria-hidden="true" />
+              September {cutoff.year} cut-off
             </li>
-              ))}
+            {home && (
+              <li>
+                <span className={`${styles.cutoffSwatch} ${styles.cutoffSwatchHome}`} aria-hidden="true" />
+                Your postcode
+              </li>
+            )}
           </ul>
         </div>
+      ) : (
+        <button
+          type="button"
+          className={styles.cutoffMapToggle}
+          onClick={() => setMapOpen(true)}
+        >
+          Show this distance on a map
+        </button>
       )}
 
       <p className={styles.cutoffCheckCaveat}>{CUTOFF_CHECK_CAVEAT}</p>
     </div>
-    </div>
   );
 }

nextjs-app/components/school/CutoffYearTable.tsx

@@ -1,82 +0,0 @@
-/**
- * CutoffYearTable — the last distance offered, year by year.
- *
- * The table is where the chart's gaps get explained. Each year says which of
- * the three things happened, in words, because "no figure" alone is the least
- * useful thing we could tell a parent about a year.
- *
- * Server component: it is static markup over data the page already holds.
- */
-
-import type { CutoffYearRow, CutoffYearStatus } from './lastDistanceOffered';
-import { sectionStyles as styles } from './sectionShared';
-
-const STATUS_LABEL: Record<CutoffYearStatus, string> = {
-  published: 'Oversubscribed',
-  // Precisely what the EES field supports, and no more: first preferences did
-  // not exceed places. It does not establish that every applicant was offered
-  // a place, so it must not be worded as though it did.
-  'not-oversubscribed': 'Places available on first preferences',
-  'not-published': 'Not published',
-};
-
-const STATUS_CLASS: Record<CutoffYearStatus, string> = {
-  published: styles.cutoffPillOver,
-  'not-oversubscribed': styles.cutoffPillOk,
-  'not-published': styles.cutoffPillNa,
-};
-
-const DISTANCE_TEXT: Record<CutoffYearStatus, string> = {
-  published: '',
-  'not-oversubscribed': 'No cut-off needed',
-  'not-published': '—',
-};
-
-export function CutoffYearTable({ rows }: { rows: CutoffYearRow[] }) {
-  if (rows.length === 0) return null;
-
-  const showPlaces = rows.some((r) => r.placesOffered != null);
-
-  return (
-    <div className={styles.cutoffTableWrap}>
-      <table className={styles.cutoffTable}>
-        <caption className={styles.srOnly}>
-          Last distance offered by year, with the reason where no figure was published
-        </caption>
-        <thead>
-          <tr>
-            <th scope="col">Year</th>
-            <th scope="col">Last distance</th>
-            {showPlaces && <th scope="col">Places</th>}
-            <th scope="col">Status</th>
-          </tr>
-        </thead>
-        <tbody>
-          {rows.map((r, i) => (
-            <tr key={r.year} className={i === 0 ? styles.cutoffRowLatest : undefined}>
-              <th scope="row">{r.year}</th>
-              <td className={r.status === 'published' ? undefined : styles.cutoffCellMissing}>
-                {r.status === 'published' ? r.figure : DISTANCE_TEXT[r.status]}
-                {r.status === 'published' && (r.routeCount ?? 1) > 1 && (
-                  <span className={styles.cutoffRouteFlag}>
-                    {' '}furthest of {r.routeCount}
-                  </span>
-                )}
-              </td>
-              {showPlaces && (
-                <td className={r.placesOffered == null ? styles.cutoffCellMissing : undefined}>
-                  {r.placesOffered ?? '—'}
-                </td>
-              )}
-              <td>
-                <span className={`${styles.cutoffPill} ${STATUS_CLASS[r.status]}`}>
-                  {STATUS_LABEL[r.status]}
-                </span>
-              </td>
-            </tr>
-          ))}
-        </tbody>
-      </table>
-    </div>
-  );
-}

nextjs-app/components/school/DistanceSection.tsx

@@ -0,0 +1,51 @@
+/**
+ * DistanceSection — "How far away are you?"
+ *
+ * The section exists to answer one question a parent cannot answer from a
+ * number alone: whether their own address falls inside it. The figure itself is
+ * already on the Admissions tile above; this turns it into something they can
+ * act on.
+ *
+ * Scope note. This used to carry the full published record — chart, year table
+ * and a set of shrinking rings. Earlier years are now held back as a paid
+ * feature and no longer leave the API at all, so what remains is the latest
+ * year and the check against it. The pipeline is unchanged: every published
+ * year is still loaded into fact_admission_distance, so restoring history for
+ * entitled callers is a serving change rather than a re-collection.
+ *
+ * Server component; the map and postcode form carry their own client boundary.
+ */
+
+import type { School, SchoolAdmissionDistance } from '@/lib/types';
+import { Section, sectionStyles as styles } from './sectionShared';
+import { CutoffMapPanel } from './CutoffMapPanel';
+
+export function DistanceSection({
+  admissionDistance,
+  schoolInfo,
+}: {
+  admissionDistance: SchoolAdmissionDistance | null;
+  schoolInfo: School;
+}) {
+  // Without a figure there is nothing to compare against, and without
+  // coordinates there is nothing to measure — CutoffMapPanel enforces the
+  // second, but the section must not render an empty card either way.
+  if (
+    admissionDistance?.distance_m == null
+    || schoolInfo.latitude == null
+    || schoolInfo.longitude == null
+  ) {
+    return null;
+  }
+
+  return (
+    <Section id="distance">
+      <h2 className={styles.sectionTitle}>How far away are you?</h2>
+      <p className={styles.sectionSubtitle}>
+        Check your postcode against the furthest home offered a place in
+        September {admissionDistance.year}.
+      </p>
+      <CutoffMapPanel schoolInfo={schoolInfo} cutoff={admissionDistance} />
+    </Section>
+  );
+}

nextjs-app/components/school/PrimarySchoolSections.tsx

@@ -20,6 +20,7 @@ import type { SchoolFlags } from '@/lib/schoolSections';
 import { OfstedSection } from './OfstedSection';
 import { ResultsSection } from './ResultsSection';
 import { AdmissionsSection } from './AdmissionsSection';
+import { DistanceSection } from './DistanceSection';
 import { InclusionSection } from './InclusionSection';
 import { HistorySection } from './HistorySection';
 import { SchoolLifeSection } from './SchoolLifeSection';
@@ -35,7 +36,6 @@ export interface PrimarySchoolSectionsProps {
   admissions: SchoolAdmissions | null;
   admissionsHistory: SchoolAdmissions[];
   admissionDistance: SchoolAdmissionDistance | null;
-  admissionDistanceHistory: SchoolAdmissionDistance[];
   deprivation: SchoolDeprivation | null;
   finance: SchoolFinance | null;
   nationalAvg: NationalAverages | null;
@@ -44,7 +44,7 @@ export interface PrimarySchoolSectionsProps {
 
 export function PrimarySchoolSections({
   schoolInfo, yearlyData, absenceData, ofsted, census,
-  admissions, admissionsHistory, admissionDistance, admissionDistanceHistory,
+  admissions, admissionsHistory, admissionDistance,
   deprivation, finance, nationalAvg, flags,
 }: PrimarySchoolSectionsProps) {
   const primaryAvg = nationalAvg?.primary ?? {};
@@ -103,12 +103,14 @@ export function PrimarySchoolSections({
           admissions={admissions}
           admissionsHistory={admissionsHistory}
           admissionDistance={admissionDistance}
-          admissionDistanceHistory={admissionDistanceHistory}
-          schoolInfo={schoolInfo}
           isAllThrough={flags.isAllThrough}
         />
       )}
 
+      {/* Its own section, directly after Admissions: it answers the question
+          the tile above raises. */}
+      <DistanceSection admissionDistance={admissionDistance} schoolInfo={schoolInfo} />
+
       {flags.hasInclusionData && (
         <InclusionSection
           latestResults={flags.latestResults}

nextjs-app/components/school/SecondaryAdmissionsSection.tsx

@@ -9,27 +9,23 @@
 import type { School, SchoolAdmissions, SchoolAdmissionDistance } from '@/lib/types';
 import { formatPercentage } from '@/lib/utils';
 import { Section, sectionStyles as styles } from './sectionShared';
-import { CutoffDistanceDetail } from './CutoffDistanceDetail';
 import {
-  describeCutoff, cutoffYearRows, describeCutoffAbsence,
+  describeCutoff, describeCutoffAbsence,
   CUTOFF_NOTE, CUTOFF_MEASUREMENT_NOTE,
 } from './lastDistanceOffered';
 
 export function SecondaryAdmissionsSection({
-  admissions, admissionsHistory, admissionDistance, admissionDistanceHistory,
-  schoolInfo, hasSixthForm,
+  admissions, admissionsHistory, admissionDistance, schoolInfo, hasSixthForm,
 }: {
   /* Nullable for the same reason as the primary section: a school can have a
      published cut-off and no EES admissions row. */
   admissions: SchoolAdmissions | null;
   admissionsHistory: SchoolAdmissions[];
   admissionDistance: SchoolAdmissionDistance | null;
-  admissionDistanceHistory: SchoolAdmissionDistance[];
   schoolInfo: School;
   hasSixthForm: boolean;
 }) {
   const cutoff = describeCutoff(admissionDistance);
-  const cutoffRows = cutoffYearRows(admissionDistanceHistory, admissionsHistory);
   // Moved with this section from SecondarySchoolDetailView, its only consumer.
   const admissionsTag = (() => {
     const policy = schoolInfo.admissions_policy?.toLowerCase() ?? '';
@@ -83,7 +79,7 @@ export function SecondaryAdmissionsSection({
               Last distance offered · {cutoff.entryYear}
             </div>
             <div className={styles.metricValue}>
-              {cutoff.primary}
+              {cutoff.primary}{' '}
               <span className={styles.metricValueSub}>{cutoff.secondary}</span>
             </div>
           </div>
@@ -116,11 +112,6 @@ export function SecondaryAdmissionsSection({
         </p>
       )}
 
-      {/* Inline rather than behind a tab: this template is one flat panel by
-          design and has no segmented control to hang a third view on. The
-          caveat is suppressed because it is already directly above. */}
-      <CutoffDistanceDetail rows={cutoffRows} schoolInfo={schoolInfo} showCaveat={false} />
-
       {hasSixthForm && (
         <div className={styles.sixthFormNote}>
           This school has a sixth form (Post-16 provision). Post-16 destination data coming soon.

nextjs-app/components/school/SecondarySchoolSections.tsx

@@ -20,6 +20,7 @@ import type { SecondaryFlags } from '@/lib/schoolSections';
 import { OfstedSection } from './OfstedSection';
 import { GcseSection } from './GcseSection';
 import { SecondaryAdmissionsSection } from './SecondaryAdmissionsSection';
+import { DistanceSection } from './DistanceSection';
 import { SecondaryHistorySection } from './SecondaryHistorySection';
 import { WellbeingSection } from './WellbeingSection';
 import { FinancesSection } from './FinancesSection';
@@ -36,7 +37,6 @@ export interface SecondarySchoolSectionsProps {
    *  school simply was not oversubscribed. */
   admissionsHistory: SchoolAdmissions[];
   admissionDistance: SchoolAdmissionDistance | null;
-  admissionDistanceHistory: SchoolAdmissionDistance[];
   deprivation: SchoolDeprivation | null;
   finance: SchoolFinance | null;
   nationalAvg: NationalAverages | null;
@@ -45,7 +45,7 @@ export interface SecondarySchoolSectionsProps {
 
 export function SecondarySchoolSections({
   schoolInfo, yearlyData, ofsted, census,
-  admissions, admissionsHistory, admissionDistance, admissionDistanceHistory,
+  admissions, admissionsHistory, admissionDistance,
   deprivation, finance, nationalAvg, flags,
 }: SecondarySchoolSectionsProps) {
   const secondaryAvg = nationalAvg?.secondary ?? {};
@@ -91,13 +91,15 @@ export function SecondarySchoolSections({
         <SecondaryAdmissionsSection
           admissions={admissions}
           admissionDistance={admissionDistance}
-          admissionDistanceHistory={admissionDistanceHistory}
           admissionsHistory={admissionsHistory}
           schoolInfo={schoolInfo}
           hasSixthForm={flags.hasSixthForm}
         />
       )}
 
+      {/* See PrimarySchoolSections — same placement, same reason. */}
+      <DistanceSection admissionDistance={admissionDistance} schoolInfo={schoolInfo} />
+
       {yearlyData.length > 1 && (
         <SecondaryHistorySection
           yearlyData={yearlyData}

nextjs-app/components/school/charts.tsx

@@ -24,8 +24,3 @@ export const AdmissionsTrendChart = dynamic(
   () => import('../AdmissionsTrendChart'),
   { ssr: false },
 );
-
-export const CutoffTrendChart = dynamic(
-  () => import('../CutoffTrendChart'),
-  { ssr: false },
-);

nextjs-app/components/school/lastDistanceOffered.ts

@@ -16,7 +16,7 @@
  */
 
 import type { SchoolAdmissionDistance } from '@/lib/types';
-import { formatCutoffDistance, formatEntryYear } from '@/lib/utils';
+import { formatCutoffDistance, formatMiles, formatEntryYear } from '@/lib/utils';
 
 export interface CutoffDisplay {
   /** Headline figure, e.g. "0.31 miles". */
@@ -60,270 +60,119 @@ export function describeCutoff(
   };
 }
 
-// ---------------------------------------------------------------------------
-// Year-by-year history
-// ---------------------------------------------------------------------------
-
-/**
- * Why a year has no cut-off figure.
- *
- * The distinction matters more than the figure does. A missing year is not one
- * fact but three, and collapsing them into "no data" throws away the most
- * reassuring case (the school had places for everyone who put it first) and
- * the most important caveat (nobody published anything, so we cannot say).
- */
-export type CutoffYearStatus =
-  /** The authority published a cut-off for this year. */
-  | 'published'
-  /**
-   * No cut-off published, and EES shows fewer first-preference applications
-   * than places offered. Note the precise claim: this says the school was not
-   * oversubscribed ON FIRST PREFERENCES, which is what the data supports. It
-   * does NOT establish that every applicant was offered a place — total
-   * applications can still exceed places — so no copy here may say so.
-   */
-  | 'not-oversubscribed'
-  /** Nothing published, and nothing in the admissions data to explain why. */
-  | 'not-published';
-
-export interface CutoffYearRow {
-  year: number;
-  status: CutoffYearStatus;
-  /** Straight-line metres, present only when status is 'published'. */
-  distanceM: number | null;
-  /** Formatted figure, present only when status is 'published'. */
-  figure: string | null;
-  placesOffered: number | null;
-  routeCount: number | null;
-}
-
-interface AdmissionsYearLike {
-  year: number;
-  places_offered?: number | null;
-  oversubscribed?: boolean | null;
-}
-
-/**
- * EES years are six-digit academic codes (202425); cut-off years are plain
- * entry years (2024). Both denote the same September intake, so they have to be
- * reduced to a common key before they can be matched.
- */
-export function entryYearOf(year: number): number {
-  const s = String(year);
-  return s.length === 6 ? Number(s.slice(0, 4)) : year;
-}
-
-/**
- * One row per year across the full span the school has any record for, newest
- * first. Years with no record at all still appear — an unbroken axis is what
- * makes a gap legible as a gap.
- */
-export function cutoffYearRows(
-  /* Defaulted, not merely optional: admission_distance_history is an additive
-     API field, so a frontend deployed ahead of its backend receives undefined
-     here. Defaulting keeps that a section that renders nothing rather than a
-     page that throws. */
-  history: SchoolAdmissionDistance[] = [],
-  admissionsHistory: AdmissionsYearLike[] = [],
-): CutoffYearRow[] {
-  const published = new Map<number, SchoolAdmissionDistance>();
-  for (const d of history ?? []) {
-    if (d.distance_m != null) published.set(entryYearOf(d.year), d);
-  }
-
-  const admissions = new Map<number, AdmissionsYearLike>();
-  for (const a of admissionsHistory ?? []) admissions.set(entryYearOf(a.year), a);
-
-  const years = [...published.keys(), ...admissions.keys()];
-  if (years.length === 0) return [];
-
-  // The span is bounded by the cut-off data, not by admissions: EES reaches
-  // back further than councils publish, and padding the chart with a decade of
-  // "not published" would bury the years that carry a figure.
-  const publishedYears = [...published.keys()];
-  const from = publishedYears.length ? Math.min(...publishedYears) : Math.min(...years);
-  const to = Math.max(...years);
-
-  const rows: CutoffYearRow[] = [];
-  for (let y = to; y >= from; y -= 1) {
-    const d = published.get(y);
-    const a = admissions.get(y);
-
-    let status: CutoffYearStatus = 'not-published';
-    if (d) status = 'published';
-    else if (a?.oversubscribed === false) status = 'not-oversubscribed';
-
-    rows.push({
-      year: y,
-      status,
-      distanceM: d?.distance_m ?? null,
-      figure: d ? formatCutoffDistance(d.distance_m)?.primary ?? null : null,
-      placesOffered: a?.places_offered ?? null,
-      routeCount: d?.route_count ?? null,
-    });
-  }
-  return rows;
-}
-
-/**
- * A factual summary of how the cut-off has moved.
- *
- * Deliberately not a verdict. It names both endpoints and their years and lets
- * the reader draw the conclusion, because the series is short, gappy, and
- * driven by things outside the school's control — one large sibling cohort
- * moves it. Withheld below four published points, where a swing between two
- * years is noise wearing the clothes of a trend.
- */
-export function cutoffTrendSummary(rows: CutoffYearRow[]): string | null {
-  const pts = rows.filter((r) => r.status === 'published' && r.distanceM != null);
-  if (pts.length < 4) return null;
-
-  // rows are newest-first
-  const latest = pts[0];
-  const earliest = pts[pts.length - 1];
-  const a = formatCutoffDistance(earliest.distanceM)?.primary;
-  const b = formatCutoffDistance(latest.distanceM)?.primary;
-  if (!a || !b) return null;
-
-  const change = latest.distanceM! - earliest.distanceM!;
-  // A tenth of the earlier figure — below that the endpoints are effectively
-  // the same and calling it a direction would be reading noise.
-  const meaningful = Math.abs(change) > earliest.distanceM! * 0.1;
-
-  const direction = !meaningful
-    ? 'has stayed broadly the same'
-    : change < 0
-      ? 'has tightened'
-      : 'has widened';
-
-  return `Across ${pts.length} published years the cut-off ${direction}: `
-    + `${a} in ${earliest.year}, ${b} in ${latest.year}.`;
-}
-
 // ---------------------------------------------------------------------------
 // "Would we have got in?"
 // ---------------------------------------------------------------------------
 
 /**
- * How close a home has to be to a year's cut-off before the comparison stops
+ * How close a home has to be to the cut-off before the comparison stops
  * meaning anything, in metres.
  *
- * A UK postcode unit covers roughly fifteen addresses and postcodes.io returns
- * its centroid, so the home point carries error of this order before anything
- * else is considered. Against a cut-off that is often only 500 m, that is a
- * fifth of the whole distance. Inside this band the honest answer is that we
- * cannot tell, and saying "you would have been offered a place" would be
- * inventing precision the inputs do not have.
+ * postcodes.io returns the centroid of a postcode unit covering roughly fifteen
+ * addresses, so the home point carries error of this order before anything else
+ * is considered. Against a cut-off that is often only 500 m that is a fifth of
+ * the whole distance. Inside this band the honest answer is that we cannot
+ * tell, and saying "you would have been offered a place" would be inventing
+ * precision the inputs do not have.
  */
 export const CUTOFF_UNCERTAINTY_M = 100;
 
-export type CutoffVerdict = 'inside' | 'outside' | 'too-close' | 'unknown';
-
-export interface CutoffYearComparison {
-  year: number;
-  status: CutoffYearStatus;
-  verdict: CutoffVerdict;
-}
+export type CutoffVerdict = 'inside' | 'outside' | 'too-close';
 
 export interface CutoffCheckResult {
   /** Straight-line metres from the given postcode to the school. */
   distanceM: number;
   distanceLabel: string;
-  years: CutoffYearComparison[];
-  /** Years the home is clearly inside, out of those with a published figure. */
-  insideCount: number;
-  comparableCount: number;
+  verdict: CutoffVerdict;
   headline: string;
-  detail: string;
+  /** Why we cannot call it, on the one verdict that needs explaining. Kept
+   *  apart from the headline so it does not run at headline weight. */
+  detail: string | null;
 }
 
-export function compareToCutoffs(
+/**
+ * Compare a home against the one cut-off we publish.
+ *
+ * Only the latest year is compared because only the latest year is served:
+ * earlier years are held back as a paid feature and no longer leave the API.
+ * A single year makes the verdict sharper to state and easier to qualify — one
+ * distance, one year, one margin — but it also removes the reassurance a run of
+ * years gave, so the year is named in the headline rather than left implied.
+ */
+export function compareToCutoff(
   distanceM: number,
-  rows: CutoffYearRow[],
+  cutoffM: number,
+  year: number,
 ): CutoffCheckResult {
-  const years: CutoffYearComparison[] = rows.map((r) => {
-    if (r.status !== 'published' || r.distanceM == null) {
-      return { year: r.year, status: r.status, verdict: 'unknown' as const };
-    }
-    const margin = r.distanceM - distanceM;
+  const margin = cutoffM - distanceM;
   const verdict: CutoffVerdict =
     Math.abs(margin) <= CUTOFF_UNCERTAINTY_M ? 'too-close' : margin > 0 ? 'inside' : 'outside';
-    return { year: r.year, status: r.status, verdict };
-  });
 
-  const comparable = years.filter((y) => y.verdict !== 'unknown');
-  const inside = comparable.filter((y) => y.verdict === 'inside');
-  const tooClose = comparable.filter((y) => y.verdict === 'too-close');
-  const label = formatCutoffDistance(distanceM)?.primary ?? `${Math.round(distanceM)} m`;
+  // Both sides through the same formatter, with no fallback that could reach
+  // for a different unit: the sentence compares these two numbers directly, so
+  // they have to be in the same one. formatCutoffDistance returns null for a
+  // zero or negative figure, and its old "N m" fallback here was one of the
+  // ways a metres reading used to appear next to a miles one.
+  const label = formatMiles(distanceM);
+  const cutoffLabel = formatMiles(cutoffM);
 
-  let headline: string;
-  if (comparable.length === 0) {
-    headline = `${label} from the school`;
-  } else if (inside.length === comparable.length) {
-    headline = `${label} away — inside the cut-off in all ${comparable.length} `
-      + `${comparable.length === 1 ? 'year' : 'years'} with a published figure`;
-  } else if (inside.length === 0 && tooClose.length === 0) {
-    headline = `${label} away — outside the cut-off in every year with a published figure`;
-  } else {
-    headline = `${label} away — inside the cut-off in ${inside.length} of `
-      + `${comparable.length} years with a published figure`;
-  }
+  // "the September 2026 cut-off of 0.17 miles" rather than "the 0.17 miles
+  // cut-off for September 2026": the figure carries its own unit word, which
+  // reads wrong used attributively.
+  const cutoffPhrase = `the September ${year} cut-off of ${cutoffLabel}`;
+  const headline =
+    verdict === 'inside'
+      ? `${label} away — inside ${cutoffPhrase}.`
+      : verdict === 'outside'
+        ? `${label} away — beyond ${cutoffPhrase}.`
+        : `${label} away — too close to ${cutoffPhrase} to call.`;
 
-  const parts: string[] = [];
-  if (tooClose.length > 0) {
-    parts.push(
-      `${tooClose.length} ${tooClose.length === 1 ? 'year is' : 'years are'} too close to call: `
-      + 'your postcode is a centroid covering several addresses, so a margin under '
-      + `${CUTOFF_UNCERTAINTY_M} m is inside the measurement error.`,
-    );
-  }
-  const unknown = years.length - comparable.length;
-  if (unknown > 0) {
-    parts.push(`${unknown} ${unknown === 1 ? 'year has' : 'years have'} no published figure to compare against.`);
-  }
+  const detail =
+    verdict === 'too-close'
+      ? 'Your postcode is a centroid covering several addresses, so a margin '
+        + `under ${CUTOFF_UNCERTAINTY_M} m is inside the measurement error.`
+      : null;
 
-  return {
-    distanceM,
-    distanceLabel: label,
-    years,
-    insideCount: inside.length,
-    comparableCount: comparable.length,
-    headline,
-    detail: parts.join(' '),
-  };
+  return { distanceM, distanceLabel: label, verdict, headline, detail };
 }
 
 /**
- * The limits of the check, stated where a parent will act on it.
+ * The limits of the figure, and of the check made against it.
  *
- * Every clause is load-bearing. Distance is the last criterion applied, not the
- * first; the authority's own measurement may be a walking route rather than a
- * straight line, which is always longer for the same home; and a past cut-off
- * constrains next year's not at all.
+ * One caveat, rendered once at the end of the section. It was previously three
+ * paragraphs — under the map, under the check, and a trailing "not a catchment"
+ * line — which took ~180px between them, said walking-route twice, and made
+ * the same point about priorities in two voices.
+ *
+ * Phrased to stand up whether or not the postcode check is on the page: it
+ * opens on the figure rather than on "your result", because a school with no
+ * coordinates renders the table with no check beneath it.
+ *
+ * Every claim is still here:
+ *   * distance is the last criterion applied, not the first;
+ *   * the figures and rings are straight-line, and not a boundary;
+ *   * some authorities measure a walking route, always longer for the same home;
+ *   * a past cut-off constrains next year's not at all.
  */
 export const CUTOFF_CHECK_CAVEAT =
-  'An indication only. Places go first to children in care, EHCP places, '
-  + 'siblings and — at faith schools — on faith criteria, so a home inside the '
-  + 'distance can still miss out. Some authorities measure a walking route '
-  + 'rather than a straight line, which is always longer for the same home, and '
-  + "next year's cut-off depends on next year's applicants. Always check the "
-  + "school's own admissions policy.";
-
-/**
- * The rings are a drawing of a number, not a boundary anyone administers.
- *
- * The walking-route caveat belongs to CUTOFF_CHECK_CAVEAT immediately below
- * this on the page, which states it more usefully ("always longer for the same
- * home"). Saying it in both places read as a stutter.
- */
-export const CUTOFF_MAP_CAVEAT =
-  'Each ring is the straight-line cut-off for that year, drawn around the '
-  + 'school. It illustrates the distance — it is not a catchment boundary.';
+  'Distance is the last criterion applied. Places go first to children in care, '
+  + 'EHCP places, siblings and — at faith schools — on faith criteria, so a home '
+  + 'inside the distance can still miss out. Figures are straight-line distances '
+  + 'and not a catchment boundary; some authorities measure a walking route '
+  + "instead, which is always longer for the same home. Next year's cut-off "
+  + "depends on next year's applicants — always check the school's own "
+  + 'admissions policy.';
 
 // ---------------------------------------------------------------------------
 // When there is no figure
 // ---------------------------------------------------------------------------
 
+/** The slice of an admissions year this file needs. */
+interface AdmissionsYearLike {
+  year: number;
+  oversubscribed?: boolean | null;
+}
+
 interface AbsenceInput {
   localAuthority?: string | null;
   admissionsPolicy?: string | null;
@@ -361,17 +210,3 @@ export function describeCutoffAbsence({
     : 'No cut-off distance has been published for this school.')
     + ' Contact the admissions authority for its oversubscription criteria.';
 }
-
-/**
- * A short note on how thin the record is.
- *
- * Four points is the same threshold the trend summary uses: below it the series
- * is too short to carry a direction, and saying so is more useful than leaving
- * the reader to count the rows.
- */
-export function cutoffCoverageNote(rows: CutoffYearRow[]): string | null {
-  const published = rows.filter((r) => r.status === 'published').length;
-  if (published === 0 || published >= 4) return null;
-  return `Only ${published} ${published === 1 ? 'year has' : 'years have'} a published figure, `
-    + 'which is too few to read as a trend.';
-}

nextjs-app/components/school/schoolSections.module.css

@@ -1627,8 +1627,23 @@
     color: var(--text-secondary);
 }
 
-/* Stack both views in one grid cell so the card sizes to the taller view —
-   toggling modes never shifts layout. */
+/*
+ * Stack both views in one grid cell so the card sizes to the taller view —
+ * toggling modes never shifts layout.
+ *
+ * This only works while the views are of COMPARABLE height, and it fails
+ * silently rather than loudly when they are not. The hidden view keeps its
+ * box (display stays block below; only visibility is dropped), so the grid
+ * row is sized by the tallest view and every other view is padded out to
+ * match it. A cut-off-distance view carrying a chart, a table and a map was
+ * added here and came to 1402px against the tile grid's 316px, which left
+ * the DEFAULT view — the one nobody had clicked — as four tiles floating in
+ * ~1080px of blank card.
+ *
+ * Anything substantially taller than the tile grid belongs in its own
+ * section, not in this viewport. That is where the distance detail now
+ * lives; see DistanceSection.
+ */
 .admissionsViewport {
     display: grid;
 }
@@ -2084,105 +2099,6 @@
     border: 0;
 }
 
-.cutoffChartKey {
-    margin: 0.6rem 0 0;
-    font-size: 0.8125rem;
-    line-height: 1.55;
-    color: var(--text-secondary);
-    max-width: 68ch;
-}
-
-/* ── Year-by-year table ── */
-
-.cutoffTableWrap {
-    margin-top: 1.25rem;
-    overflow-x: auto;
-}
-
-.cutoffTable {
-    width: 100%;
-    border-collapse: collapse;
-    font-size: 0.875rem;
-    /* Below this the four columns crush; the wrapper scrolls instead of the
-       page, so the section itself never scrolls sideways. */
-    min-width: 26rem;
-    font-variant-numeric: tabular-nums;
-}
-
-.cutoffTable thead th {
-    text-align: right;
-    font-size: 0.6875rem;
-    font-weight: 600;
-    letter-spacing: 0.04em;
-    text-transform: uppercase;
-    color: var(--text-secondary);
-    padding: 0 0.625rem 0.55rem;
-    border-bottom: 1px solid var(--border);
-    white-space: nowrap;
-}
-
-.cutoffTable thead th:first-child,
-.cutoffTable tbody th {
-    text-align: left;
-}
-
-.cutoffTable tbody td,
-.cutoffTable tbody th {
-    text-align: right;
-    padding: 0.65rem 0.625rem;
-    border-bottom: 1px solid var(--border);
-    font-weight: 400;
-    color: var(--text-primary);
-}
-
-.cutoffTable tbody th {
-    font-weight: 600;
-}
-
-.cutoffTable tbody tr:last-child td,
-.cutoffTable tbody tr:last-child th {
-    border-bottom: none;
-}
-
-.cutoffRowLatest td,
-.cutoffRowLatest th {
-    background: var(--bg-secondary);
-}
-
-.cutoffCellMissing {
-    color: var(--text-secondary);
-}
-
-.cutoffRouteFlag {
-    font-size: 0.75rem;
-    color: var(--text-secondary);
-    white-space: nowrap;
-}
-
-.cutoffPill {
-    display: inline-block;
-    font-size: 0.6875rem;
-    font-weight: 600;
-    padding: 0.15rem 0.55rem;
-    border-radius: 999px;
-    white-space: nowrap;
-}
-
-.cutoffPillOver {
-    background: var(--brand-bg);
-    color: var(--brand-strong);
-}
-
-.cutoffPillOk {
-    background: var(--status-above-bg);
-    color: var(--status-above);
-}
-
-.cutoffPillNa {
-    background: var(--bg-secondary);
-    color: var(--text-secondary);
-}
-
 /* ── Map panel ── */
 
 .cutoffMapPanel {
@@ -2191,17 +2107,11 @@
     border-top: 1px solid var(--border);
 }
 
-.cutoffMapTitle {
-    margin: 0 0 0.85rem;
-    font-family: var(--font-display);
-    font-size: 1.1rem;
-    font-weight: 700;
-    letter-spacing: -0.01em;
-    color: var(--text-primary);
-}
 
 .cutoffMapFigure {
-    height: 320px;
+    /* Enough to read a set of concentric rings and no more — this is a
+       diagram of a number, not a map anyone navigates by. */
+    height: 240px;
     border-radius: var(--radius-md);
     overflow: hidden;
     border: 1px solid var(--border);
@@ -2243,12 +2153,6 @@
     box-shadow: inset 0 0 0 2px var(--brand);
 }
 
-.cutoffSwatchPast {
-    background: transparent;
-    box-shadow: inset 0 0 0 1.5px var(--brand);
-    opacity: 0.5;
-}
-
 .cutoffSwatchHome {
     width: 11px;
     height: 11px;
@@ -2267,16 +2171,18 @@
 
 /* ── Postcode check ── */
 
+/* The check now leads the panel, so it carries no divider of its own — the
+   rule above it belonged to a map that used to sit there. */
 .cutoffCheck {
-    margin-top: 1.5rem;
-    padding-top: 1.25rem;
-    border-top: 1px solid var(--border);
+    margin-top: 0;
 }
 
 .cutoffCheckTitle {
     margin: 0 0 0.25rem;
     font-family: var(--font-display);
-    font-size: 1rem;
+    /* Now the panel's only heading (an h3), so it carries the weight the
+       retired .cutoffMapTitle used to. */
+    font-size: 1.1rem;
     font-weight: 700;
     color: var(--text-primary);
 }
@@ -2383,54 +2289,6 @@
     color: var(--text-secondary);
 }
 
-.cutoffYearStrip {
-    list-style: none;
-    margin: 0.75rem 0 0;
-    padding: 0;
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.3rem;
-}
-
-.cutoffYearChip {
-    display: inline-flex;
-    align-items: center;
-    gap: 0.3rem;
-    font-size: 0.75rem;
-    font-weight: 600;
-    padding: 0.2rem 0.5rem;
-    border-radius: 999px;
-    font-variant-numeric: tabular-nums;
-    white-space: nowrap;
-}
-
-.cutoffYearChipYear {
-    font-weight: 700;
-}
-
-.cutoffYearInside {
-    background: var(--status-above-bg);
-    color: var(--status-above);
-}
-
-.cutoffYearOutside {
-    background: var(--status-below-bg);
-    color: var(--status-below);
-}
-
-/* Deliberately neutral rather than a warning colour: "we cannot tell" is not a
-   bad outcome, and tinting it amber would read as one. */
-.cutoffYearTooClose {
-    background: var(--bg-secondary);
-    color: var(--text-primary);
-    box-shadow: inset 0 0 0 1px var(--border);
-}
-
-.cutoffYearUnknown {
-    background: var(--bg-secondary);
-    color: var(--text-secondary);
-}
-
 .cutoffCheckCaveat {
     margin: 0.9rem 0 0;
     font-size: 0.8125rem;
@@ -2441,6 +2299,61 @@
 
 @media (max-width: 640px) {
     .cutoffMapFigure {
-        height: 260px;
+        height: 200px;
     }
 }
+
+/* ── Map, revealed on request ── */
+
+.cutoffMapToggle {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.4rem;
+    margin-top: 1rem;
+    padding: 0.5rem 0.9rem;
+    font: inherit;
+    font-size: 0.875rem;
+    font-weight: 600;
+    color: var(--brand-strong);
+    background: none;
+    border: 1px solid var(--border);
+    border-radius: 999px;
+    cursor: pointer;
+    transition: border-color var(--transition), background var(--transition);
+}
+
+.cutoffMapToggle:hover {
+    border-color: var(--brand);
+    background: var(--brand-bg);
+}
+
+.cutoffMapToggle:focus-visible {
+    outline: 2px solid var(--brand);
+    outline-offset: 2px;
+}
+
+.cutoffMapReveal {
+    margin-top: 1rem;
+}
+
+/* ── Postcode check result, coloured by verdict ──
+ *
+ * These override the neutral brand tint on .cutoffCheckResult. Without them the
+ * three outcomes render identically, which is the specific failure the class
+ * map in CutoffMapPanel is written out longhand to avoid — and which the
+ * stylesheet test caught when they were referenced before being defined.
+ */
+.cutoffResultInside {
+    background-image: linear-gradient(var(--status-above-bg), var(--status-above-bg));
+}
+
+.cutoffResultOutside {
+    background-image: linear-gradient(var(--status-below-bg), var(--status-below-bg));
+}
+
+/* Deliberately neutral: "we cannot tell" is not a bad outcome, and tinting it
+   like one would push a reader toward a conclusion the data does not support. */
+.cutoffResultTooClose {
+    background-image: none;
+    background-color: var(--bg-secondary);
+}

nextjs-app/lib/places.ts

@@ -0,0 +1,60 @@
+/**
+ * Client for the places API.
+ *
+ * Two namespaces, matching the backend: towns and localities share
+ * /schools/[place]; authorities take /schools/authority/[la]. 67 town names
+ * collide with an authority name and neither set contains the other, so one
+ * namespace would publish near-duplicate pages.
+ */
+import type { School } from '@/lib/types';
+
+export interface PlaceSummary {
+  kind: string;
+  slug: string;
+  name: string;
+  count: number;
+  /** Phases that clear the threshold on their own, so the page links
+   *  variants that exist rather than 404s. Absent on the registry listing. */
+  phases?: string[];
+}
+
+export interface PlaceDetail {
+  place: PlaceSummary & { parent_authority: string | null };
+  schools: School[];
+  averages: {
+    rwm_expected_pct: number | null;
+    attainment_8_score: number | null;
+  };
+}
+
+export function placeUrl(kind: string, slug: string, phase?: string): string {
+  const base =
+    kind === 'authority' ? `/schools/authority/${slug}`
+    : kind === 'outcode' ? `/schools/near/${slug}`
+    : `/schools/${slug}`;
+  return phase ? `${base}/${phase}` : base;
+}
+
+/** An authority name as it appears in a URL. */
+export function authoritySlug(name: string): string {
+  return name.toLowerCase().trim().replace(/[^\w\s-]/g, '').replace(/\s+/g, '-');
+}
+
+const API = process.env.FASTAPI_URL || process.env.NEXT_PUBLIC_API_URL
+  || 'http://localhost:8000/api';
+
+export async function fetchPlaces(): Promise<PlaceSummary[]> {
+  const res = await fetch(`${API}/places`, { next: { revalidate: 604800 } });
+  if (!res.ok) return [];
+  return (await res.json()).places ?? [];
+}
+
+export async function fetchPlace(
+  kind: string, slug: string, phase?: string,
+): Promise<PlaceDetail | null> {
+  const q = phase ? `?phase=${encodeURIComponent(phase)}` : '';
+  const res = await fetch(`${API}/places/${kind}/${slug}${q}`,
+    { next: { revalidate: 604800 } });
+  if (!res.ok) return null;
+  return res.json();
+}

nextjs-app/lib/schoolSections.ts

@@ -122,6 +122,10 @@ export interface NavItemsInput {
   /** A published cut-off distance renders the Admissions section on its own,
    *  so it has to open the nav entry too. */
   admissionDistance: SchoolAdmissionDistance | null;
+  /** Whether the school has coordinates — the Distance section needs them to
+   *  measure a postcode, so the nav must gate on them too or it will link to an
+   *  anchor that was never rendered. */
+  hasLocation?: boolean;
   yearlyDataLength: number;
 }
 
@@ -136,7 +140,7 @@ export interface NavItemsInput {
  */
 export function buildNavItems(
   flags: SchoolFlags,
-  { ofsted, admissions, admissionDistance, yearlyDataLength }: NavItemsInput,
+  { ofsted, admissions, admissionDistance, hasLocation, yearlyDataLength }: NavItemsInput,
 ): NavItem[] {
   const navItems: NavItem[] = [];
   if (ofsted) navItems.push({ id: 'ofsted', label: 'Ofsted' });
@@ -147,6 +151,9 @@ export function buildNavItems(
     });
   }
   if (admissions || admissionDistance) navItems.push({ id: 'admissions', label: 'Admissions' });
+  if (admissionDistance?.distance_m != null && hasLocation) {
+    navItems.push({ id: 'distance', label: 'Distance' });
+  }
   if (flags.hasInclusionData) navItems.push({ id: 'inclusion', label: 'Pupils' });
   if (yearlyDataLength > 0) navItems.push({ id: 'history', label: 'History' });
   if (flags.hasSchoolLife) navItems.push({ id: 'school-life', label: 'School Life' });
@@ -216,12 +223,15 @@ export function computeSecondaryFlags({
  */
 export function buildSecondaryNavItems(
   flags: SecondaryFlags,
-  { ofsted, admissions, admissionDistance, yearlyDataLength }: NavItemsInput,
+  { ofsted, admissions, admissionDistance, hasLocation, yearlyDataLength }: NavItemsInput,
 ): NavItem[] {
   const navItems: NavItem[] = [];
   if (ofsted) navItems.push({ id: 'ofsted', label: 'Ofsted' });
   if (flags.hasResults) navItems.push({ id: 'gcse', label: 'GCSEs' });
   if (admissions || admissionDistance) navItems.push({ id: 'admissions', label: 'Admissions' });
+  if (admissionDistance?.distance_m != null && hasLocation) {
+    navItems.push({ id: 'distance', label: 'Distance' });
+  }
   if (yearlyDataLength > 1) navItems.push({ id: 'history', label: 'History' });
   if (flags.hasWellbeing) navItems.push({ id: 'wellbeing', label: 'Wellbeing' });
   if (flags.hasFinance) navItems.push({ id: 'finances', label: 'Finances' });

nextjs-app/lib/site.ts

@@ -0,0 +1,19 @@
+/**
+ * The one place the site's absolute origin is written down.
+ *
+ * The apex domain 301s to www at Cloudflare, so www is the host that actually
+ * serves a 200. Canonicals, og:url, sitemap <loc> entries and the robots.txt
+ * Sitemap: line must all agree with it — a canonical pointing at a redirect
+ * makes Google resolve the hop before it can consolidate the signal.
+ *
+ * backend/app.py holds the same value as BASE_URL for the sitemap. The two are
+ * asserted against each other by the e2e journeys rather than shared at build
+ * time, because the backend and frontend ship as separate images.
+ */
+export const SITE_URL = 'https://www.schoolcompare.co.uk';
+
+/** Absolute URL for a site-relative path. Tolerates a missing leading slash. */
+export function absoluteUrl(path: string): string {
+  const rooted = path.startsWith('/') ? path : `/${path}`;
+  return `${SITE_URL}${rooted}`;
+}

nextjs-app/lib/sitemapProxy.ts

@@ -0,0 +1,29 @@
+/**
+ * Runtime proxy for the sitemap family → the FastAPI backend.
+ *
+ * Like the /api/* proxy, this reads FASTAPI_URL at request time rather than
+ * baking the backend host into the build, so one image works in every
+ * environment. robots.ts points crawlers at /sitemap.xml, which is the index;
+ * the index names children under /sitemaps/, which land on the same proxy.
+ */
+import { NextResponse } from 'next/server';
+
+function backendOrigin(): string {
+  const base = process.env.FASTAPI_URL || process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000/api';
+  return base.replace(/\/api$/, '');
+}
+
+export async function proxySitemap(path: string): Promise<NextResponse> {
+  let upstream: Response;
+  try {
+    upstream = await fetch(`${backendOrigin()}${path}`, { cache: 'no-store' });
+  } catch {
+    return new NextResponse('Sitemap temporarily unavailable', { status: 502 });
+  }
+
+  const body = await upstream.text();
+  return new NextResponse(body, {
+    status: upstream.status,
+    headers: { 'content-type': upstream.headers.get('content-type') || 'application/xml' },
+  });
+}

nextjs-app/lib/types.ts

@@ -354,14 +354,14 @@ export interface SchoolDetailsResponse {
   admissions: SchoolAdmissions | null;
   /** All available admissions years, oldest first. Drives the multi-year trend view. */
   admissions_history: SchoolAdmissions[];
-  /** Latest published cut-off distance, or null where the LA publishes none. */
-  admission_distance: SchoolAdmissionDistance | null;
   /**
-   * Every published cut-off year, oldest first. Sparse by nature — a school may
-   * have 2021 and 2026 and nothing between, so consumers must classify the
-   * missing years rather than joining the points they do have.
+   * Latest published cut-off distance, or null where the LA publishes none.
+   *
+   * Only the latest year is served. Earlier years exist in the mart but are
+   * held back as a paid feature and are not part of this public payload — see
+   * data_loader._admission_distance.
    */
-  admission_distance_history: SchoolAdmissionDistance[];
+  admission_distance: SchoolAdmissionDistance | null;
   deprivation: SchoolDeprivation | null;
   finance: SchoolFinance | null;
 }

nextjs-app/lib/utils.ts

@@ -505,32 +505,46 @@ export function getPhaseStyle(phase?: string | null): { key: string; label: stri
 const METRES_PER_MILE = 1609.344;
 
 /**
- * Format an admission cut-off distance.
+ * A distance in miles, the unit UK school admissions is conducted in.
  *
- * Miles lead because that is the unit councils publish in — 90% of the source
- * rows are miles — and because it is the unit a parent has already been quoted
- * if they have read their council's booklet. The metric figure follows as
- * support rather than replacing it.
+ * Councils publish cut-offs in miles — 90% of the collected source rows — and
+ * it is the unit a parent has already been quoted in their council's booklet
+ * and offer letter. Everything a reader is asked to compare therefore renders
+ * through this one function, so two figures in the same sentence can never
+ * arrive in different units.
  *
- * Below 100 m the miles figure stops carrying information ("0.03 miles"), so
- * the two swap round and metres lead instead.
+ * That was not previously true. This formatter used to swap to metres below
+ * 100m, on the reasoning that "0.04 miles" carries less for a reader than
+ * "69 m". Taken one figure at a time that holds; taken in a sentence it
+ * produced "69 m away — inside the September 2026 cut-off of 0.17 miles",
+ * which asks the reader to convert between units to understand a comparison we
+ * had already made for them. Legibility of a single number lost to coherence
+ * of the pair.
+ *
+ * Below 0.01 miles the two decimal places run out rather than the unit being
+ * wrong, so the figure is described instead of rounded to a flat "0.00 miles".
+ */
+export function formatMiles(metres: number): string {
+  const miles = metres / METRES_PER_MILE;
+  if (miles < 0.01) return 'under 0.01 miles';
+  return `${miles.toFixed(2)} miles`;
+}
+
+/**
+ * Format an admission cut-off distance: the headline figure in miles, and a
+ * metric equivalent to support it.
+ *
+ * The metric figure is support, not an alternative — it appears beside the
+ * miles figure, never instead of it, so nothing a reader compares is ever in
+ * two units at once.
  */
 export function formatCutoffDistance(
   metres: number | null | undefined
 ): { primary: string; secondary: string } | null {
   if (metres == null || !Number.isFinite(metres) || metres <= 0) return null;
 
-  const miles = metres / METRES_PER_MILE;
-
-  if (metres < 100) {
   return {
-      primary: `${Math.round(metres)} m`,
-      secondary: `${miles.toFixed(2)} miles`,
-    };
-  }
-
-  return {
-    primary: `${miles.toFixed(2)} miles`,
+    primary: formatMiles(metres),
     secondary: metres < 1000
       ? `${Math.round(metres / 10) * 10} m`
       : `${(metres / 1000).toFixed(1)} km`,

nextjs-app/next.config.js

@@ -55,6 +55,37 @@ const nextConfig = {
   // Headers for caching and security
   async headers() {
     return [
+      {
+        /*
+         * Keep non-production hosts out of the index.
+         *
+         * Staging serves the same image as production off stx., so without
+         * this it is a full crawlable duplicate of the site.
+         *
+         * X-Robots-Tag, NOT a robots.txt Disallow. Disallow blocks crawling,
+         * which is not the same as blocking indexing — a disallowed URL can
+         * still be indexed from external links, and worse, blocking the crawl
+         * means Google never fetches the page and never sees a noindex at all.
+         * Staging therefore stays crawlable and answers "noindex" when crawled.
+         *
+         * Matched on the staging host explicitly rather than "any host that is
+         * not production". The inverted form is tempting because it would cover
+         * future environments automatically, but its failure mode is
+         * deindexing production if the Host header ever arrives rewritten by a
+         * proxy. This form's failure mode is a new environment being indexable
+         * until someone adds it here — recoverable, where the other is not.
+         *
+         * Any new non-production hostname must be added to this list.
+         */
+        source: '/:path*',
+        has: [{ type: 'host', value: 'stx.schoolcompare.co.uk' }],
+        headers: [
+          {
+            key: 'X-Robots-Tag',
+            value: 'noindex, nofollow',
+          },
+        ],
+      },
       {
         source: '/:path*',
         headers: [

pipeline/transform/dbt_project.yml

@@ -11,6 +11,32 @@ seed-paths: ["seeds"]
 target-path: "target"
 clean-targets: ["target", "dbt_packages"]
 
+# schoolcompare publishes England only. GIAS ships the whole UK plus overseas
+# and offshore establishments, none of which have comparable DfE performance
+# data — Wales does not publish on the English measures at all. Excluding them
+# at the mart boundary keeps them out of the site, the filter lists and the
+# sitemap together. Codes are TypeOfEstablishment, see seeds/gias_code_names.csv.
+#   25 = Offshore schools            (Jersey, Guernsey, Isle of Man, Gibraltar)
+#   26 = Service children's education (BFPO, Fieldwork Overseas)
+#   30 = Welsh establishment
+#   37 = British schools overseas
+# dim_school, dim_location and assert_england_only_schools all read this list.
+vars:
+  non_england_school_type_codes: [25, 26, 30, 37]
+
+  # Type alone is not enough. Beechwood College (URN 142458, Sully, CF64 5SE)
+  # is a Welsh school that GIAS types as a Special post 16 institution (32)
+  # rather than a Welsh establishment (30), so the type filter let it through.
+  # LA code is the reliable discriminator: GIAS gives the 22 Welsh unitary
+  # authorities the contiguous block 660-681, which English authorities never
+  # use (they occupy 201-384 and 800-938).
+  #
+  # Filtering on postcode would be wrong: Redbrook, Tutshill, Wyedean and two
+  # other Gloucestershire schools carry NP16/NP25 postcodes because Royal Mail
+  # areas straddle the border, and they are English schools with English data.
+  welsh_la_code_min: 660
+  welsh_la_code_max: 681
+
 models:
   school_compare:
     staging:

pipeline/transform/models/marts/dim_location.sql

@@ -31,5 +31,11 @@ select
         else null
     end as longitude
 from {{ ref('stg_gias_establishments') }} s
--- Must match dim_school's status filter exactly (the API inner-joins the two).
+-- Must match dim_school's status and England filters exactly (the API
+-- inner-joins the two).
 where s.status_code in (1, 3)
+-- coalesce, not a bare NOT IN: a null type code would make the predicate
+-- null and drop the row silently. Unknown type is not grounds for exclusion.
+and coalesce(s.school_type_code, -1) not in ({{ var('non_england_school_type_codes') | join(', ') }})
+-- Welsh schools GIAS does not type as Welsh establishments (see vars).
+and coalesce(s.local_authority_code, -1) not between {{ var('welsh_la_code_min') }} and {{ var('welsh_la_code_max') }}

pipeline/transform/models/marts/dim_school.sql

@@ -91,3 +91,10 @@ left join {{ ref('int_ofsted_latest') }} o on s.urn = o.urn
 -- 1 = Open; 3 = Open, but proposed to close (still operating; drops out when
 -- GIAS flips to Closed — marts fully rebuild each run).
 where s.status_code in (1, 3)
+-- England only. dim_location must apply this filter identically (the API
+-- inner-joins the two). See vars in dbt_project.yml for what the codes are.
+-- coalesce, not a bare NOT IN: a null type code would make the predicate
+-- null and drop the row silently. Unknown type is not grounds for exclusion.
+and coalesce(s.school_type_code, -1) not in ({{ var('non_england_school_type_codes') | join(', ') }})
+-- Welsh schools GIAS does not type as Welsh establishments (see vars).
+and coalesce(s.local_authority_code, -1) not between {{ var('welsh_la_code_min') }} and {{ var('welsh_la_code_max') }}

pipeline/transform/seeds/locality_outcodes.csv

@@ -0,0 +1,16 @@
+locality_slug,locality_name,outcodes,region
+battersea,Battersea,SW11,London
+canary-wharf,Canary Wharf,E14,London
+clapham,Clapham,SW4,London
+shoreditch,Shoreditch,EC2A|E1,London
+peckham,Peckham,SE15,London
+brixton,Brixton,SW2|SW9,London
+camden-town,Camden Town,NW1,London
+wimbledon,Wimbledon,SW19,London
+putney,Putney,SW15,London
+fulham,Fulham,SW6,London
+chiswick,Chiswick,W4,London
+stratford,Stratford,E15,London
+walthamstow,Walthamstow,E17,London
+tooting,Tooting,SW17,London
+dulwich,Dulwich,SE21|SE22,London

pipeline/transform/tests/assert_england_only_schools.sql

@@ -0,0 +1,54 @@
+-- Custom test: the published corpus is England only.
+--
+-- GIAS ships the whole UK plus overseas and offshore establishments. None of
+-- them carry comparable DfE performance data, so dim_school and dim_location
+-- filter them out (see vars.non_england_school_type_codes in dbt_project.yml).
+-- This test is the guard: a GIAS refresh that reintroduces them, or an edit
+-- that drops the filter from one of the two models, fails the pipeline rather
+-- than quietly republishing ~2,000 dataless pages to the site and the sitemap.
+
+select
+    urn,
+    school_name,
+    school_type_code
+from {{ ref('dim_school') }}
+where school_type_code in ({{ var('non_england_school_type_codes') | join(', ') }})
+
+union all
+
+-- dim_location is inner-joined to dim_school by the API, so it must filter
+-- identically. Anything here that dim_school does not have means the two
+-- models have drifted apart.
+select
+    l.urn,
+    null::text    as school_name,
+    null::integer as school_type_code
+from {{ ref('dim_location') }} l
+left join {{ ref('dim_school') }} s on l.urn = s.urn
+where s.urn is null
+
+union all
+
+-- Belt and braces on the Welsh LA code range.
+--
+-- The range 660-681 is documented GIAS structure, not something this project
+-- can verify from its own data — local_authority_code is not exposed anywhere
+-- the app can assert on. So the range does the filtering and the authority
+-- NAME does the checking: if 660-681 is ever wrong or incomplete, a Welsh
+-- authority reappears here and the pipeline fails loudly rather than the
+-- corpus quietly regrowing a Welsh tail.
+--
+-- Beechwood College (142458) is why this exists: a Welsh school GIAS types as
+-- a Special post 16 institution, which the type filter alone let through.
+select
+    l.urn,
+    l.local_authority_name as school_name,
+    null::integer          as school_type_code
+from {{ ref('dim_location') }} l
+where l.local_authority_name in (
+    'Isle of Anglesey', 'Gwynedd', 'Conwy', 'Denbighshire', 'Flintshire',
+    'Wrexham', 'Powys', 'Ceredigion', 'Pembrokeshire', 'Carmarthenshire',
+    'Swansea', 'Neath Port Talbot', 'Bridgend', 'Vale of Glamorgan',
+    'Rhondda Cynon Taf', 'Merthyr Tydfil', 'Caerphilly', 'Blaenau Gwent',
+    'Torfaen', 'Monmouthshire', 'Newport', 'Cardiff'
+)