fix(e2e): three assertions that were wrong about correct behaviour

The staging gate was red on three journeys. All three were faults in the
tests; the site was behaving correctly in each case.

Next normalises canonical URLs against trailingSlash:false, so the homepage
ships "https://www.schoolcompare.co.uk" with no slash while every other route
keeps its path. Both address the same document. The test hardcoded the slash
and so failed only on the root — /rankings and /admissions passed throughout,
which is what made it look like a homepage bug rather than a test bug.
Compared with trailing slashes stripped from both sides.

The robots.txt assertion matched "Disallow: /" anywhere in the file and
tripped over the AI-crawler groups Cloudflare injects — ClaudeBot, GPTBot,
Amazonbot and six others all carry a blanket disallow, deliberately, and none
of them is Googlebot. It now parses the file into user-agent groups and checks
only the "*" group, which is also the thing the test was always trying to say:
Google may crawl the page, so it can see the noindex header.

Both were the same mistake as the doubled brand: asserting a naive string
rather than the semantics, and asserting against what the code assembles
rather than what the page renders.

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

backend/app.py

@@ -1232,6 +1232,13 @@ async def get_place(request: Request, kind: str, slug: str,
         "place": {"kind": place.kind, "slug": place.slug, "name": place.name,
                   "count": len(place.urns),
                   "parent_authority": place.parent_authority,
+                  # Every authority the place meaningfully sits in. SW19 is
+                  # mostly Merton but partly Wandsworth; naming one asserts
+                  # something false.
+                  "authorities": [
+                      {"name": name, "slug": _slugify(name), "count": n}
+                      for name, n in place.authorities
+                  ],
                   # Only phases that clear the threshold, so the page links
                   # variants that exist rather than 404s.
                   "phases": [ph for ph in ("primary", "secondary")

backend/places.py

@@ -30,6 +30,12 @@ class Place:
     name: str
     urns: tuple[int, ...]
     parent_authority: str | None    # authority NAME, for the 301 target
+    # Every authority the place meaningfully sits in, largest first. A quarter
+    # of outcodes and a third of towns straddle a boundary — SW19 is mostly
+    # Merton but partly Wandsworth — so naming only one asserts something
+    # false. parent_authority stays single because a redirect needs one
+    # target; this is what the page shows.
+    authorities: tuple[tuple[str, int], ...] = ()
     # 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.
@@ -71,39 +77,100 @@ def _phase_urns(group, publishable: set[int]) -> dict[str, tuple[int, ...]]:
     return out
 
 
-def _parent_authority(group) -> str | None:
+# A place is described by an authority when it holds at least a tenth of the
-    """The most common authority in a group — the useful 301 target.
+# schools, and at least two. GIAS carries occasional postcode errors — EN6
+# lists two Shropshire schools among fourteen in Hertfordshire — and a bare
+# "any authority present" rule would print those as though they were real.
+# There is deliberately no cap on how many are named. An earlier cut stopped
+# at three, which silently dropped the fourth in exactly the case where the
+# information matters most — a genuinely fragmented place. The share rule is
+# the only limit, and it already bounds the list at ten.
+_AUTHORITY_MIN_SHARE = 0.10
+_AUTHORITY_MIN_SCHOOLS = 2
+
+
+def _authorities(group) -> tuple[tuple[str, int], ...]:
+    """Authorities this place meaningfully sits in, largest first."""
+    from backend.app import EXCLUDED_FILTER_VALUES
 
-    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
+        return ()
-    top = group["local_authority"].dropna()
+    counts = group["local_authority"].dropna().value_counts()
-    return str(top.mode().iloc[0]) if not top.empty else None
+    total = int(counts.sum())
+    if not total:
+        return ()
+
+    kept = [
+        (str(name), int(n)) for name, n in counts.items()
+        if str(name) not in EXCLUDED_FILTER_VALUES
+        and n >= _AUTHORITY_MIN_SCHOOLS
+        and n / total >= _AUTHORITY_MIN_SHARE
+    ]
+    # A place too small or too fragmented for the share rule still names its
+    # largest authority, or the page would say nothing about where it is.
+    if not kept:
+        for name, n in counts.items():
+            if str(name) not in EXCLUDED_FILTER_VALUES:
+                return ((str(name), int(n)),)
+        return ()
+    return tuple(kept)
+
+
+def _parent_authority(authorities: tuple[tuple[str, int], ...]) -> str | None:
+    """The 301 target: the largest authority a place sits in.
+
+    Derived from `authorities` rather than computed separately. The first cut
+    used `mode()` here while `authorities` used `value_counts()`, and on an
+    exact tie pandas does not guarantee the two pick the same name — so the
+    redirect could have pointed somewhere other than the authority the page
+    named first. One computation, one answer.
+
+    Deriving it also inherits the sentinel filter, so a place can no longer
+    redirect to /schools/authority/does-not-apply.
+    """
+    return authorities[0][0] if authorities 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."""
+    """One Place per distinct SLUG in `column` that clears the threshold.
+
+    Grouped by slug, not by raw value, because GIAS spells the same place
+    several ways and they all resolve to one URL. Five town slugs come from
+    more than one spelling: "London" (1,819 schools) and "LONDON" (12) both
+    slugify to `london`; Weston-super-Mare is split 14/19 across two
+    spellings; Newcastle-under-Lyme across three.
+
+    Grouping by raw value meant the later group simply overwrote the earlier
+    one in this dict — so /schools/london could have shown twelve schools
+    instead of 1,819, silently and depending on row order.
+
+    The display name is the most common spelling, which is the one a reader
+    expects to see.
+    """
     from backend.app import _slugify
 
     if column not in df.columns:
         return {}
 
+    working = df.assign(_slug=df[column].map(
+        lambda v: _slugify(str(v).strip()) if isinstance(v, str) and v.strip() else None))
+    working = working[working["_slug"].notna() & (working["_slug"] != "")]
+
     out: dict[str, Place] = {}
-    for name, group in df.groupby(column, dropna=True):
+    for slug, group in working.groupby("_slug"):
-        name = str(name).strip()
+        slug = str(slug)
-        if not name:
-            continue
         urns = tuple(sorted({int(u) for u in group["urn"]} & publishable))
         if len(urns) < MIN_SCHOOLS:
             continue
-        slug = _slugify(name)
+        spellings = group[column].dropna().value_counts()
-        if not slug:
+        if spellings.empty:
             continue
+        name = str(spellings.index[0]).strip()
+        authorities = () if kind == "authority" else _authorities(group)
         place = Place(
             kind=kind, slug=slug, name=name, urns=urns,
-            parent_authority=_parent_authority(group) if kind == "town" else None,
+            parent_authority=_parent_authority(authorities),
+            authorities=authorities,
             phase_urns=_phase_urns(group, publishable),
         )
         out[place.key] = place
@@ -136,8 +203,10 @@ def _outcode_places(df, publishable: set[int]) -> dict[str, Place]:
         urns = tuple(sorted({int(u) for u in group["urn"]} & publishable))
         if len(urns) < MIN_SCHOOLS:
             continue
+        authorities = _authorities(group)
         place = Place(kind="outcode", slug=str(oc).lower(), name=str(oc),
-                      urns=urns, parent_authority=_parent_authority(group),
+                      urns=urns, parent_authority=_parent_authority(authorities),
+                      authorities=authorities,
                       phase_urns=_phase_urns(group, publishable))
         out[place.key] = place
     return out
@@ -179,8 +248,10 @@ def _locality_places(df, publishable: set[int],
                 "threshold of %d - not published",
                 slug, ", ".join(outcodes), len(urns), MIN_SCHOOLS)
             continue
+        authorities = _authorities(group)
         place = Place(kind="locality", slug=slug, name=name, urns=urns,
-                      parent_authority=_parent_authority(group),
+                      parent_authority=_parent_authority(authorities),
+                      authorities=authorities,
                       phase_urns=_phase_urns(group, publishable))
         out[place.key] = place
     return out

backend/tests/test_places.py

@@ -229,3 +229,117 @@ def test_no_curated_locality_names_a_london_borough():
         f"these are boroughs, not districts: {sorted(named)} - they already "
         "have an authority page covering every school"
     )
+
+
+def test_a_place_names_every_authority_it_straddles():
+    """SW19 is mostly Merton but partly Wandsworth.
+
+    A quarter of viable outcodes and a third of viable towns cross an
+    authority boundary, so naming only the largest asserts something false.
+    """
+    rows = (_town(26, "London", "Merton", start=300000)
+            + _town(7, "London", "Wandsworth", start=400000))
+    for r in rows:
+        r["postcode"] = "SW19 1AA"
+    reg = build_place_registry(_df(rows))
+
+    names = [n for n, _ in reg["outcode:sw19"].authorities]
+    assert names == ["Merton", "Wandsworth"]          # largest first
+    assert dict(reg["outcode:sw19"].authorities)["Wandsworth"] == 7
+
+
+def test_the_redirect_target_stays_a_single_authority():
+    # parent_authority and authorities do different jobs: a 301 needs one
+    # target, the page needs the truth.
+    rows = (_town(26, "London", "Merton", start=300000)
+            + _town(7, "London", "Wandsworth", start=400000))
+    for r in rows:
+        r["postcode"] = "SW19 1AA"
+    reg = build_place_registry(_df(rows))
+    assert reg["outcode:sw19"].parent_authority == "Merton"
+
+
+def test_a_stray_authority_below_the_share_threshold_is_not_named():
+    # GIAS carries postcode errors — EN6 lists two Shropshire schools among
+    # fourteen in Hertfordshire. Printing those as though real would be worse
+    # than omitting them.
+    rows = (_town(30, "Barnet", "Hertfordshire", start=300000)
+            + _town(1, "Barnet", "Shropshire", start=400000))
+    for r in rows:
+        r["postcode"] = "EN6 1AA"
+    reg = build_place_registry(_df(rows))
+    assert [n for n, _ in reg["outcode:en6"].authorities] == ["Hertfordshire"]
+
+
+def test_a_sentinel_authority_is_never_named():
+    rows = (_town(20, "London", "Merton", start=300000)
+            + _town(6, "London", "Does not apply", start=400000))
+    for r in rows:
+        r["postcode"] = "SW19 1AA"
+    reg = build_place_registry(_df(rows))
+    assert [n for n, _ in reg["outcode:sw19"].authorities] == ["Merton"]
+
+
+def test_a_place_always_names_at_least_one_authority():
+    # Even when every authority is below the share threshold, the page has to
+    # say where the place is.
+    rows = []
+    for i, la in enumerate(["A", "B", "C", "D", "E", "F", "G"]):
+        rows += _town(1, "Fragmented", la, start=300000 + i * 100)
+    reg = build_place_registry(_df(rows))
+    place = reg.get("town:fragmented")
+    assert place is not None
+    assert len(place.authorities) == 1
+
+
+def test_every_qualifying_authority_is_named_with_no_cap():
+    """An earlier cut stopped at three, dropping the fourth silently.
+
+    That truncation bit exactly where the information matters most — a
+    genuinely fragmented place — and nothing recorded it.
+    """
+    rows = []
+    for i, la in enumerate(["Hackney", "Lambeth", "Westminster", "Lewisham"]):
+        rows += _town(3, "Fourway", la, start=300000 + i * 100)
+    reg = build_place_registry(_df(rows))
+    assert len(reg["town:fourway"].authorities) == 4
+
+
+def test_the_redirect_target_is_the_authority_named_first():
+    """They were computed separately — mode() against value_counts() — and on
+    an exact tie pandas does not guarantee the two agree."""
+    rows = (_town(26, "London", "Merton", start=300000)
+            + _town(7, "London", "Wandsworth", start=400000))
+    for r in rows:
+        r["postcode"] = "SW19 1AA"
+    place = build_place_registry(_df(rows))["outcode:sw19"]
+    assert place.parent_authority == place.authorities[0][0]
+
+
+def test_a_place_never_redirects_to_a_sentinel_authority():
+    # Deriving the parent from `authorities` inherits its sentinel filter.
+    rows = (_town(6, "Someplace", "Does not apply", start=300000)
+            + _town(5, "Someplace", "Essex", start=400000))
+    reg = build_place_registry(_df(rows))
+    assert reg["town:someplace"].parent_authority == "Essex"
+
+
+def test_spellings_of_one_place_are_merged_not_overwritten():
+    """GIAS spells the same place several ways, and they share a URL.
+
+    "London" (1,819 schools) and "LONDON" (12) both slugify to `london`.
+    Grouping by raw value let the later group overwrite the earlier one, so
+    the page could have shown twelve schools instead of 1,819 — silently, and
+    depending on row order.
+    """
+    rows = (_town(6, "Weston-super-Mare", "North Somerset", start=300000)
+            + _town(5, "Weston-Super-Mare", "North Somerset", start=400000))
+    reg = build_place_registry(_df(rows))
+    assert len(reg["town:weston-super-mare"].urns) == 11
+
+
+def test_the_merged_place_takes_its_most_common_spelling():
+    rows = (_town(9, "Newcastle-under-Lyme", "Staffordshire", start=300000)
+            + _town(5, "NEWCASTLE-UNDER-LYME", "Staffordshire", start=400000))
+    reg = build_place_registry(_df(rows))
+    assert reg["town:newcastle-under-lyme"].name == "Newcastle-under-Lyme"

e2e/tests/journeys.spec.ts

@@ -1649,13 +1649,29 @@ const CANONICAL_ROUTES: Array<[string, string]> = [
   ['/admissions', 'https://www.schoolcompare.co.uk/admissions'],
 ];
 
+/**
+ * Next normalises canonical URLs against `trailingSlash: false`, so the root
+ * ships as `https://www.schoolcompare.co.uk` with no slash while every other
+ * route keeps its path. Both forms address the same document, and which one
+ * Next emits is its business, not something worth pinning a test to.
+ *
+ * The first cut hardcoded the slash and failed only on the homepage — the
+ * same gap as the doubled brand: it asserted the metadata object rather than
+ * what the page actually renders.
+ */
+function sameUrl(a: string | null, b: string): boolean {
+  const strip = (u: string) => u.replace(/\/+$/, '');
+  return strip(a ?? '') === strip(b);
+}
+
 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);
+    expect(sameUrl(hrefs[0], expected),
+      `${path} canonical was ${hrefs[0]}, expected ${expected}`).toBe(true);
   });
 }
 
@@ -1663,7 +1679,8 @@ 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/');
+  expect(sameUrl(href, 'https://www.schoolcompare.co.uk/'),
+    `filtered homepage canonical was ${href}`).toBe(true);
 });
 
 test('a school page canonicalises to its own slug on the www host', async ({ page }) => {
@@ -1714,10 +1731,33 @@ test('staging answers noindex, and stays crawlable so the noindex is seen', asyn
   // 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.
+  //
+  // Scoped to the `*` group. The first cut matched `Disallow: /` anywhere in
+  // the file and tripped over the AI-crawler groups Cloudflare injects —
+  // ClaudeBot, GPTBot, Amazonbot and friends all carry a blanket disallow,
+  // deliberately, and none of them is Googlebot.
   const robots = await (await page.request.get('/robots.txt')).text();
-  expect(robots).not.toMatch(/^\s*Disallow:\s*\/\s*$/mi);
+  expect(blocksEverything(robots, '*'),
+    'the * group must not disallow the whole site, or the noindex is never seen')
+    .toBe(false);
 });
 
+/** True when `agent`'s group in a robots.txt disallows the entire site. */
+function blocksEverything(robots: string, agent: string): boolean {
+  let current: string | null = null;
+  let blocked = false;
+  for (const raw of robots.split('\n')) {
+    const line = raw.split('#')[0].trim();
+    if (!line) continue;
+    const [key, ...rest] = line.split(':');
+    const value = rest.join(':').trim();
+    const k = key.trim().toLowerCase();
+    if (k === 'user-agent') current = value;
+    else if (current === agent && k === 'disallow' && value === '/') blocked = true;
+  }
+  return blocked;
+}
+
 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 ?? [];
@@ -1868,3 +1908,46 @@ 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);
+  }
+});
+
+test('a place straddling a boundary names every authority it sits in', async ({ page }) => {
+  // A quarter of outcodes and a third of towns cross an authority boundary —
+  // SW19 is mostly Merton but partly Wandsworth. Naming only the largest
+  // asserts something false about the place.
+  const { places } = await (await page.request.get('/api/places')).json();
+  const outcode = places.find((p: { kind: string }) => p.kind === 'outcode');
+  expect(outcode).toBeTruthy();
+
+  // Find any place the registry reports as straddling.
+  let straddling: { kind: string; slug: string } | null = null;
+  for (const p of places.filter((p: { kind: string }) => p.kind === 'outcode').slice(0, 40)) {
+    const d = await (await page.request.get(`/api/places/outcode/${p.slug}`)).json();
+    if ((d.place.authorities ?? []).length > 1) { straddling = p; break; }
+  }
+  test.skip(!straddling, 'no straddling outcode found in the sample');
+
+  const detail = await (await page.request.get(
+    `/api/places/outcode/${straddling!.slug}`)).json();
+  await page.goto(`/schools/near/${straddling!.slug}`);
+
+  for (const a of detail.place.authorities) {
+    await expect(page.locator(`a[href="/schools/authority/${a.slug}"]`).first())
+      .toBeVisible();
+  }
+});

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

@@ -14,7 +14,7 @@ jest.mock('@/lib/places', () => ({
 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).toMatch(/schools in brentwood/i);
+    expect((m.title as { absolute: string }).absolute).toMatch(/schools in brentwood/i);
   });
 
   it('canonicalises to its own path on the www host', async () => {
@@ -23,6 +23,18 @@ describe('place page metadata', () => {
       .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/PlaceView.test.tsx

@@ -7,9 +7,9 @@ const detail: PlaceDetail = {
            parent_authority: 'Essex', phases: ['primary'] },
   schools: [
     { urn: 1, school_name: 'Alpha Primary', rwm_expected_pct: 82,
-      ofsted_grade: 1 } as never,
+      ofsted_grade: 1, phase: 'Primary' } as never,
     { urn: 2, school_name: 'Beta Primary', rwm_expected_pct: 44,
-      ofsted_grade: 3 } as never,
+      ofsted_grade: 3, phase: 'Primary' } as never,
   ],
   averages: { rwm_expected_pct: 63, attainment_8_score: null },
 };
@@ -112,3 +112,134 @@ describe('PlaceView phase variants', () => {
       .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();
+  });
+});
+
+describe('PlaceView table alignment', () => {
+  const aligned: PlaceDetail = {
+    place: { kind: 'town', slug: 'brentwood', name: 'Brentwood', count: 2,
+             parent_authority: 'Essex', phases: ['primary'] },
+    schools: [
+      { urn: 1, school_name: 'Alpha Primary', phase: 'Primary',
+        rwm_expected_pct: 82, attainment_8_score: null } as never,
+    ],
+    averages: { rwm_expected_pct: 63, attainment_8_score: null },
+  };
+
+  it('aligns the measure heading and its values with the same class', () => {
+    // They were aligned by two different selectors whose specificity did not
+    // match: `.table th:last-child` (0,2,1) won and went right, while `.num`
+    // (0,1,0) lost to `.table td` (0,1,1) and stayed left. Sharing one class
+    // is what makes them impossible to drift apart.
+    const { container } = render(<PlaceView detail={aligned} englandAverage={61}
+      neighbours={[]} />);
+    const th = container.querySelectorAll('th')[1];
+    const td = container.querySelectorAll('tbody td')[1];
+    expect(th.className).toBeTruthy();
+    expect(td.className).toBe(th.className);
+  });
+
+  it('leaves the school-name column unclassed so it takes the spare width', () => {
+    const { container } = render(<PlaceView detail={aligned} englandAverage={61}
+      neighbours={[]} />);
+    expect(container.querySelectorAll('th')[0].className).toBe('');
+  });
+});
+
+describe('PlaceView authorities', () => {
+  const straddling: PlaceDetail = {
+    place: { kind: 'outcode', slug: 'sw19', name: 'SW19', count: 33,
+             parent_authority: 'Merton', phases: ['primary'],
+             authorities: [
+               { name: 'Merton', slug: 'merton', count: 26 },
+               { name: 'Wandsworth', slug: 'wandsworth', count: 7 },
+             ] },
+    schools: [
+      { urn: 1, school_name: 'Alpha Primary', phase: 'Primary',
+        rwm_expected_pct: 82, attainment_8_score: null } as never,
+    ],
+    averages: { rwm_expected_pct: 63, attainment_8_score: null },
+  };
+
+  it('names every authority the place straddles, not just the largest', () => {
+    // SW19 is mostly Merton but partly Wandsworth. Naming one asserts
+    // something false about a quarter of outcodes.
+    render(<PlaceView detail={straddling} englandAverage={61} neighbours={[]} />);
+    expect(screen.getByRole('link', { name: 'Merton' }))
+      .toHaveAttribute('href', '/schools/authority/merton');
+    expect(screen.getByRole('link', { name: 'Wandsworth' }))
+      .toHaveAttribute('href', '/schools/authority/wandsworth');
+  });
+
+  it('joins them readably rather than as a bare list', () => {
+    // Asserted on the summary line's whole text: a loose /and/ matcher also
+    // hits "Wandsworth".
+    const { container } = render(<PlaceView detail={straddling}
+      englandAverage={61} neighbours={[]} />);
+    const summary = container.querySelector('header p');
+    expect(summary?.textContent).toContain('Merton and Wandsworth');
+  });
+
+  it('falls back to the single parent when the field is absent', () => {
+    // A cached API response predating the authorities field must not blank
+    // the line entirely.
+    const legacy = { ...straddling,
+      place: { ...straddling.place, authorities: undefined } };
+    render(<PlaceView detail={legacy} englandAverage={61} neighbours={[]} />);
+    expect(screen.getByRole('link', { name: 'Merton' })).toBeInTheDocument();
+  });
+});

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

@@ -37,7 +37,7 @@ export async function generateMetadata({ params }: Props): Promise<Metadata> {
   const word = phase === 'secondary' ? 'Secondary' : 'Primary';
   const { name } = detail.place;
   return {
-    title: `${word} Schools in ${name} — Ranked | schoolcompare`,
+    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.`,

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

@@ -53,7 +53,10 @@ export async function generateMetadata({ params }: Props): Promise<Metadata> {
 
   const { name, count } = detail.place;
   return {
-    title: `Schools in ${name} — Compare ${count} Schools | schoolcompare`,
+    // 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.`,

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

@@ -43,7 +43,7 @@ export async function generateMetadata({ params }: Props): Promise<Metadata> {
 
   const { name, count } = detail.place;
   return {
-    title: `Schools in ${name} — Local Authority | schoolcompare`,
+    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.`,

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

@@ -38,7 +38,7 @@ export async function generateMetadata({ params }: Props): Promise<Metadata> {
 
   const { name, count } = detail.place;
   return {
-    title: `Schools near ${name} | schoolcompare`,
+    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.`,

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

@@ -1,4 +1,8 @@
-/* Tokens only — see globals.css. Matches RankingsView's conventions. */
+/* 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;
@@ -24,6 +28,44 @@
   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);
@@ -46,6 +88,30 @@
   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;
@@ -72,18 +138,54 @@
   color: var(--text-secondary);
   font-weight: 600;
   font-size: 0.8125rem;
-  text-transform: uppercase;
-  letter-spacing: 0.04em;
 }
 
 .table tbody tr:last-child td {
   border-bottom: none;
 }
 
-.table th:last-child,
+/*
-.num {
+ * Header and value share one class and one rule, so they cannot drift apart.
+ *
+ * The first cut aligned them with two different selectors: `.table th:last-child`
+ * at (0,2,1) beat the element rule and went right, while `.num` at (0,1,0) lost
+ * to `.table td` at (0,1,1) and stayed left. The heading and its numbers sat on
+ * opposite edges of the column.
+ *
+ * width:1% with nowrap makes the measure column hug its content so the school
+ * name takes the remaining width — without it the two columns split evenly and
+ * the gap between heading and value reads as misalignment on a wide screen.
+ */
+.table th.num,
+.table td.num {
   text-align: right;
   font-variant-numeric: tabular-nums;
+  width: 1%;
+  white-space: nowrap;
+}
+
+/* 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 {
@@ -106,13 +208,3 @@
   padding: 0;
   margin: 0;
 }
-
-/* 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 1rem;
-  margin: 0 0 1.25rem;
-  font-size: 0.9375rem;
-}

nextjs-app/components/places/PlaceView.tsx

@@ -12,6 +12,7 @@
 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';
@@ -30,19 +31,110 @@ const OFSTED_LABELS: Array<[number, string]> = [
   [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>
+            {/* Same class as the value cell below: one rule aligns both, so
+                they cannot drift apart. */}
+            <th scope="col" className={styles.num}>
+              <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 metric = phase === 'secondary' ? 'attainment_8_score' : 'rwm_expected_pct';
+  // Fall back to the single parent when the API predates the authorities
-  const local = averages[metric];
+  // field, so a stale cache never blanks the line entirely.
+  const authorities = place.authorities?.length
+    ? place.authorities
+    : place.parent_authority
+      ? [{ name: place.parent_authority, slug: authoritySlug(place.parent_authority), count: 0 }]
+      : [];
+  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);
 
-  // ItemList tells Google this page is a ranked set rather than prose;
+  /*
-  // BreadcrumbList puts the place in a hierarchy. Capped at 20 because that
+   * An unphased page holds both primaries and secondaries, and they are
-  // is what the page shows above the fold and what the markup should mirror.
+   * 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': [
@@ -60,8 +152,7 @@ export function PlaceView({ detail, phase, englandAverage, neighbours }: Props)
       {
         '@type': 'BreadcrumbList',
         itemListElement: [
-          { '@type': 'ListItem', position: 1, name: 'Schools',
+          { '@type': 'ListItem', position: 1, name: 'Schools', item: absoluteUrl('/') },
-            item: absoluteUrl('/') },
           { '@type': 'ListItem', position: 2, name: place.name },
         ],
       },
@@ -74,16 +165,25 @@ export function PlaceView({ detail, phase, englandAverage, neighbours }: Props)
         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 && (
+          {authorities.length > 0 && (
             <>
               {' · '}
-              <Link href={`/schools/authority/${authoritySlug(place.parent_authority)}`}>
+              {/* Every authority, not just the largest. A quarter of outcodes
-                {place.parent_authority}
+                  and a third of towns cross a boundary: SW19 is mostly Merton
-              </Link>
+                  but partly Wandsworth, and naming one asserts otherwise. */}
+              {authorities.map((a, i) => (
+                <span key={a.slug}>
+                  {i > 0 && (i === authorities.length - 1 ? ' and ' : ', ')}
+                  <Link href={`/schools/authority/${a.slug}`} className={styles.inlineLink}>
+                    {a.name}
+                  </Link>
+                </span>
+              ))}
             </>
           )}
         </p>
@@ -92,7 +192,7 @@ export function PlaceView({ detail, phase, englandAverage, neighbours }: Props)
       {!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}`}>
+            <Link key={ph} href={`/schools/${place.slug}/${ph}`} className={styles.phaseLink}>
               {ph === 'secondary' ? 'Secondary schools' : 'Primary schools'} in {place.name}
             </Link>
           ))}
@@ -114,28 +214,17 @@ export function PlaceView({ detail, phase, englandAverage, neighbours }: Props)
         </ul>
       )}
 
-      <div className={styles.tableWrap}>
+      {groups.map(([p, list]) => (
-        <table className={styles.table}>
+        <section key={p} className={styles.group}>
-          <thead>
+          {groups.length > 1 && (
-            <tr>
+            <h2 className={styles.groupHeading}>
-              <th>School</th>
+              {p === 'secondary' ? 'Secondary schools' : 'Primary schools'}
-              <th>{phase === 'secondary' ? 'Attainment 8' : 'RWM expected'}</th>
+              <span className={styles.groupCount}>{list.length}</span>
-            </tr>
+            </h2>
-          </thead>
+          )}
-          <tbody>
+          <SchoolTable schools={list} phase={p} />
-            {schools.map((s) => (
+        </section>
-              <tr key={s.urn}>
+      ))}
-                <td>
-                  <Link href={schoolUrl(s.urn, s.school_name)}>{s.school_name}</Link>
-                </td>
-                <td className={styles.num}>
-                  {s[metric] == null ? '—' : Math.round(Number(s[metric]))}
-                </td>
-              </tr>
-            ))}
-          </tbody>
-        </table>
-      </div>
 
       {neighbours.length > 0 && (
         <nav className={styles.neighbours} aria-label="Nearby places">
@@ -143,7 +232,7 @@ export function PlaceView({ detail, phase, englandAverage, neighbours }: Props)
           <ul>
             {neighbours.map((n) => (
               <li key={n.kind + n.slug}>
-                <Link href={placeUrl(n.kind, n.slug)}>{n.name}</Link>
+                <Link href={placeUrl(n.kind, n.slug)} className={styles.inlineLink}>{n.name}</Link>
               </li>
             ))}
           </ul>

nextjs-app/lib/places.ts

@@ -18,8 +18,19 @@ export interface PlaceSummary {
   phases?: string[];
 }
 
+export interface PlaceAuthority {
+  name: string;
+  slug: string;
+  count: number;
+}
+
 export interface PlaceDetail {
-  place: PlaceSummary & { parent_authority: string | null };
+  place: PlaceSummary & {
+    parent_authority: string | null;
+    /** Every authority the place meaningfully sits in, largest first. SW19 is
+     *  mostly Merton but partly Wandsworth. */
+    authorities?: PlaceAuthority[];
+  };
   schools: School[];
   averages: {
     rwm_expected_pct: number | null;