feat(admissions): publish the latest cut-off only, holding history back

Earlier years are to become a paid feature, so they stop being published.

The load-bearing part is that this is a change to the API, not only to the
page. /api/schools/{urn} is public and unauthenticated: leaving
admission_distance_history in the payload while declining to render it would
have handed the whole record to anyone who opened the network tab. It is
withheld at the source, and the page follows.

Nothing changes upstream. The tap, the plausibility band and
fact_admission_distance are untouched and still load every published year, so
restoring history for entitled callers is a change to one function in
data_loader rather than a re-collection.

What the reader now gets is the latest figure on the Admissions tile, and a
Distance section that answers the question the number alone cannot: whether
their own address falls inside it. Retitled to "How far away are you?", which
is what it now does — the previous title described a record that is no longer
there.

Removed with the history: the trend chart, the year-by-year table, the
per-year verdict strip, the trend summary and the coverage note, along with
their CSS. The section goes from 743px to 417px.

One consequence worth naming. A run of years used to soften a single close
call — a home just outside one year's cut-off was usually inside another. With
one year published, the "too close to call" band is the entire safety margin
between a parent and a place they do not have, so the verdict now names its
year, and the three outcomes are tinted apart rather than distinguished by
wording alone.

The existing stylesheet test earned its keep here: the three verdict classes
were referenced before they were written, and it caught them. Unstyled, a
"beyond the cut-off" result would have been indistinguishable from an "inside"
one — the exact failure the longhand class map was written to prevent.

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

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,21 +126,10 @@ describe('CutoffMapPanel', () => {
     expect(screen.getByRole('alert')).toHaveTextContent(/Something went wrong/);
   });
 
-  it('does not carry the caveat itself', () => {
-    // It moved to CutoffDistanceDetail so it renders once per section, and so
-    // it still appears for a school with no coordinates (no map, no check).
-    // Asserting its absence here is what stops the old three-paragraph stutter
-    // creeping back.
-    renderPanel([d(2024, 800)]);
-    expect(screen.queryByText(/Distance is the last criterion/)).not.toBeInTheDocument();
-  });
-
   it('keeps the map behind a request until there is a reason to show it', async () => {
-    renderPanel([d(2024, 800)]);
+    renderPanel();
     expect(screen.queryByTestId('cutoff-map')).not.toBeInTheDocument();
 
-    // A successful check is that reason: the rings only answer a question once
-    // there is a home to sit beside them.
     mockGeocode.mockResolvedValue(northOf(200));
     await check('SE23 3NA');
     await screen.findByRole('status');
@@ -154,8 +137,16 @@ describe('CutoffMapPanel', () => {
   });
 
   it('can also show the map without a postcode, on request', () => {
-    renderPanel([d(2024, 800)]);
-    fireEvent.click(screen.getByRole('button', { name: /Show these distances on a map/ }));
+    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/lastDistanceOffered.test.tsx

@@ -89,128 +89,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('primary Distance section', () => {
-  it('appears as its own section once there are two or more published years', () => {
-    // Not a third tab inside Admissions: stacking a 1402px view in the
-    // admissions viewport sized the whole card to it and left the default view
-    // as four tiles in ~1080px of blank card.
+describe('Distance section', () => {
+  it('appears for a school with a figure and coordinates', () => {
     const { container } = 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(container.querySelector('#distance')).toBeInTheDocument();
-    expect(screen.getByText('How far the last place went')).toBeInTheDocument();
-    // And it did not come back as a tab.
-    expect(screen.queryByRole('button', { name: 'Distance' })).not.toBeInTheDocument();
+    expect(screen.getByText('How far away are you?')).toBeInTheDocument();
   });
 
-  it('stays away 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.
+  it('stays away when the school has no coordinates to measure from', () => {
     const { container } = renderSchoolDetail({
       ...primaryFixture,
-      admissionDistance: cutoff({ distance_m: 700, year: 2024 }),
-      admissionDistanceHistory: history([[2024, 700]]),
+      schoolInfo: { ...primaryFixture.schoolInfo, latitude: null, longitude: null },
+      admissionDistance: cutoff({ distance_m: 700, year: 2026 }),
     });
 
     expect(container.querySelector('#distance')).not.toBeInTheDocument();
   });
 
-  it('lists every year in the span, including the ones with no figure', () => {
-    renderSchoolDetail({
+  it('stays away when no figure has been published', () => {
+    const { container } = renderSchoolDetail({
       ...primaryFixture,
-      admissionDistance: cutoff({ distance_m: 700, year: 2024 }),
-      admissionDistanceHistory: history([[2021, 1000], [2024, 700]]),
+      schoolInfo: { ...primaryFixture.schoolInfo, latitude: 51.5, longitude: -0.12 },
+      admissionDistance: null,
     });
 
-    // 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);
+    expect(container.querySelector('#distance')).not.toBeInTheDocument();
   });
 
-  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('draws the chart only once it will also state a direction', () => {
-    const four = renderSchoolDetail({
-      ...primaryFixture,
-      admissionDistance: cutoff({ distance_m: 700, year: 2024 }),
-      admissionDistanceHistory: history([[2021, 1000], [2022, 900], [2023, 800], [2024, 700]]),
-    });
-    expect(screen.getByText(/Last distance offered, by year/)).toBeInTheDocument();
-    four.unmount();
-
-    renderSchoolDetail({
-      ...primaryFixture,
-      admissionDistance: cutoff({ distance_m: 700, year: 2024 }),
-      admissionDistanceHistory: history([[2023, 800], [2024, 700]]),
-    });
-    expect(screen.queryByText(/Last distance offered, by year/)).not.toBeInTheDocument();
-  });
-
-  it('states the caveat exactly once, even though the check also renders', () => {
+  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,
       schoolInfo: { ...primaryFixture.schoolInfo, latitude: 51.5, longitude: -0.12 },
-      admissionDistance: cutoff({ distance_m: 700, year: 2024 }),
-      admissionDistanceHistory: history([[2021, 1000], [2024, 700]]),
+      admissionDistance: cutoff({ distance_m: 700, year: 2026 }),
     });
 
-    expect(screen.getAllByText(/Distance is the last criterion/)).toHaveLength(1);
-  });
-
-  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 section', () => {
-  it('renders as its own section once there are two published years', () => {
-    renderSecondarySchoolDetail({
+  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.getByRole('rowheader', { name: '2023' })).toBeInTheDocument();
-    // Two points is below the threshold that lets us state a direction, so no
-    // chart is drawn — a line through three points asserts a trend the
-    // summary underneath would refuse to.
-    expect(screen.queryByText(/Last distance offered, by year/)).not.toBeInTheDocument();
+    expect(container.querySelector('#distance')).toBeInTheDocument();
   });
 
   it('explains a selective school by how it admits rather than as missing data', () => {
@@ -218,7 +158,6 @@ describe('secondary Distance section', () => {
       ...secondaryFixture,
       schoolInfo: { ...secondaryFixture.schoolInfo, admissions_policy: 'Selective' },
       admissionDistance: null,
-      admissionDistanceHistory: [],
     });
 
     expect(screen.getByText(/ranked by the entrance test/)).toBeInTheDocument();
@@ -229,7 +168,6 @@ describe('secondary Distance section', () => {
     renderSecondarySchoolDetail({
       ...secondaryFixture,
       admissionDistance: null,
-      admissionDistanceHistory: [],
       admissionsHistory: [
         { year: 2022, oversubscribed: false },
         { year: 2023, oversubscribed: false },

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

@@ -9,8 +9,7 @@
 
 import { formatCutoffDistance, 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';
 
@@ -82,97 +81,42 @@ 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('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('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('calls a clearly further home beyond', () => {
+    expect(compareToCutoff(4000, 800, 2026).verdict).toBe('outside');
   });
 
-  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('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('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('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('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 +139,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');
-  });
-});