Revert "style(transit): format the terrain provider test"

This reverts commit 5110f4cce3.
style(transit): format the terrain provider test
2026-11-14 15:22:21 +00:00 · 2026-11-13 03:26:17 +01:00 · 2026-11-13 03:25:07 +01:00 · 2026-11-13 03:22:10 +01:00 · 2026-11-13 03:22:10 +01:00 · 2026-11-12 21:50:22 +01:00
61 changed files with 822 additions and 1323 deletions
@@ -31,7 +31,6 @@ How to read this:
 | **adsb.lol**                                                          | Military flights + aircraft traces                                                                                                  | ODbL 1.0                                                                                                                                                                                                                                                                                                                                              | "adsb.lol" (ODbL)                                                                                                                           |
 | **adsbdb** (`api.adsbdb.com`) | Aircraft type, model name and registration by ICAO hex for enriched flights; airline and origin/destination airports for the tracked flight's callsign | No licence or rate limit is published for the service. Its own credits: aircraft data from PlaneBase, ICAO-to-N-number conversion by Guillaume Michel, and flight route data that "is the work of David Taylor, Edinburgh and Jim Mason, Glasgow, and may not be copied, published, or incorporated into other databases without the explicit permission of David J Taylor, Edinburgh" | "adsbdb — api.adsbdb.com" (courtesy); route data credited to David Taylor, Edinburgh, and Jim Mason, Glasgow |
 | **Planespotters.net** (`api.planespotters.net/pub/photos/hex/{hex}`) | One thumbnail photo of the tracked aircraft, by ICAO hex, in the CONTEXT panel's CONTACTS view under the tracked flight's name | [Planespotters photo API terms](https://www.planespotters.net/photo/api); each photo remains the copyright of its photographer. Thumbnails may be hotlinked on the condition that the photographer is named next to the photo and the photo links to its Planespotters page with a followable link | "Photo © {photographer}" beside every photo that names one, linked to its Planespotters page; "Planespotters.net" in Data attribution |
-| **Open Vessel Photos** (`openvesselphotos.org/v1/mmsi/{mmsi}`) | One photo of the selected vessel, by MMSI, in the CONTEXT panel's CONTACTS view under the vessel's name and MMSI | Free, keyless public API ([README](https://github.com/louptheron/openvesselphotos)); each photo keeps the open licence its author chose (CC BY, CC BY-SA, CC0, or public domain), given with it in the API | "Photo: {photographer} · {licence}" beside every photo, linked to the vessel's Open Vessel Photos page; "Open Vessel Photos" in Data attribution |
 | **AISStream.io**                                                      | Live vessels (AIS)                                                                                                                  | Free, beta, no formal ToS; AIS is a public broadcast                                                                                                                                                                                                                                                                                                  | "AISStream.io" (courtesy)                                                                                                                   |
 | **CelesTrak**                                                         | Satellite TLEs (SGP4) and SATCAT records (object type, operational status, owner) that file each satellite under a class                                                                                                            | US-government-origin data, no license; citation requested                                                                                                                                                                                                                                                                                             | "CelesTrak (celestrak.org), Dr. T.S. Kelso"                                                                                                 |
 | **The Space Devs — Launch Library 2 v2.3**                            | Recent launch, payload, stage, and recovery metadata for Space Missions (30d)                                                       | [The Space Devs terms of use](https://github.com/TheSpaceDevs/Tutorials/blob/main/faqs/faq_TSD.md#terms-of-use): data may be used and shared in any form; avoid forwarding it without added value; attribution is encouraged (not mandatory). [Official API limits](https://ll.thespacedevs.com/docs/): 15 unauthenticated calls/hour; optional token | "Launch Library 2 — The Space Devs" (courtesy attribution)                                                                                  |
@@ -239,8 +238,7 @@ The optional Local ADS-B layer and the broadcast-FM receiver use radio you recei


 - **adsbdb enrichment.** `/api/adsbdb` resolves an ICAO hex to aircraft type, model name and registration, and the tracked flight's callsign to an airline and an origin/destination pair. Fan-out is deliberately small because adsbdb is a free community API that publishes no quota: at most 4 requests in flight, dispatches dripped to roughly 5/s, and each key asked for at most once per session (for the flights layer's enrichment, a lookup that failed temporarily, such as an outage, a timeout, a rate limit or an authorization refusal that may clear, may be asked again after a 60-second cool-down; an answer, found or not, and a permanent refusal such as a 404 are final; Local ADS-B lookups are asked once), with route lookups reserved for the tracked aircraft. The dev-server proxy caches each key for 24 hours in `.gev-cache/adsbdb.json`, negative answers included, so fresh entries survive server restarts. That gitignored cache remains local to the deployment and is not bundled with this repo. adsbdb publishes no general service license; its README says the route data may not be copied, published, or incorporated into other databases without the explicit permission of David J Taylor, Edinburgh. Deployers are responsible for obtaining any permission their use requires. Enrichment is best-effort and fail-silent — a flight that gets no answer keeps what the flight feed already gave it.
- **Planespotters photos.** When you track an aircraft, the browser asks `https://api.planespotters.net/pub/photos/hex/{hex}` directly (the API answers cross-origin, so no key and no server proxy are involved) for that aircraft only, once per hex per session, through the same enrichment queue as adsbdb, with an 8-second timeout. A miss is remembered for the session; a request that failed temporarily (an outage, the timeout or a rate limit) may be asked again after a 60-second cool-down while the aircraft stays tracked, as for the flights layer's other enrichment. Either way no photo shows meanwhile. The first photo whose image is an `https://` URL on `*.plnspttrs.net`, and whose page is an `https://www.planespotters.net` URL is shown in the CONTEXT panel's CONTACTS view, under the tracked flight's name (`src/ui/views/panels/AwarenessPanel.vue`), and nowhere else; a vessel (see Open Vessel Photos below), an installation, a military aircraft or a converted TR-3B has none, and a military aircraft or TR-3B is never looked up. Anything else is dropped, so the app never shows or links outside Planespotters (`src/data/planespottersPhoto.js`, also exported as `gods-eye-view/sources/planespotters` for servers that cache the lookup). The photo follows the attribution rules: the thumbnail is hotlinked from the URL the API gives (never copied or re-hosted), the photographer's name, when the answer gives one, is visible text next to it ("Photo © {photographer}"; a photo whose answer names no one shows no credit line), and the photo and credit are a plain link to the photo's Planespotters page with `target="_blank" rel="noopener"` and never `rel="nofollow"`. If the image fails to load, the photo and its credit are hidden.
- **Open Vessel Photos.** When you select a vessel with a nine-digit MMSI, the browser asks `https://openvesselphotos.org/v1/mmsi/{mmsi}` directly (the API is keyless and answers cross-origin, so no key and no server proxy are involved; account credentials are never sent) for that vessel only, once per MMSI per session, with an 8-second timeout. A miss (a 404 or a vessel without photos) is remembered for the session; a failed request may be asked again after five minutes. The first photo whose image is an `https://openvesselphotos.org` URL and which names a licence is shown, at the 800 px size, in the CONTEXT panel's CONTACTS view under the vessel's name and MMSI (`src/ui/views/panels/AwarenessPanel.vue`), and nowhere else (`src/data/openVesselPhoto.js`, `src/layers/vessels/photos.js`). The image is hotlinked from the URL the API gives (never copied or re-hosted); the photographer and licence are visible text next to it ("Photo: {photographer} · {licence}", or "Photo · {licence}" when the answer names no one), and the photo and credit link to the vessel's Open Vessel Photos page with `target="_blank" rel="noopener"`. If the image fails to load, the photo and its credit are hidden.
+- **Planespotters photos.** When you track an aircraft, the browser asks `https://api.planespotters.net/pub/photos/hex/{hex}` directly (the API answers cross-origin, so no key and no server proxy are involved) for that aircraft only, once per hex per session, through the same enrichment queue as adsbdb, with an 8-second timeout. A miss is remembered for the session; a request that failed temporarily (an outage, the timeout or a rate limit) may be asked again after a 60-second cool-down while the aircraft stays tracked, as for the flights layer's other enrichment. Either way no photo shows meanwhile. The first photo whose image is an `https://` URL on `*.plnspttrs.net`, and whose page is an `https://www.planespotters.net` URL is shown in the CONTEXT panel's CONTACTS view, under the tracked flight's name (`src/ui/views/panels/AwarenessPanel.vue`), and nowhere else; a vessel, an installation, a military aircraft or a converted TR-3B has none, and a military aircraft or TR-3B is never looked up. Anything else is dropped, so the app never shows or links outside Planespotters (`src/data/planespottersPhoto.js`, also exported as `gods-eye-view/sources/planespotters` for servers that cache the lookup). The photo follows the attribution rules: the thumbnail is hotlinked from the URL the API gives (never copied or re-hosted), the photographer's name, when the answer gives one, is visible text next to it ("Photo © {photographer}"; a photo whose answer names no one shows no credit line), and the photo and credit are a plain link to the photo's Planespotters page with `target="_blank" rel="noopener"` and never `rel="nofollow"`. If the image fails to load, the photo and its credit are hidden.
 - **Launch Library 2.** `/api/launches` makes a server-side rolling-30-day query against the supported v2.3 detailed launch endpoint, caches successful responses for 15 minutes in memory and on disk, and serves the last successful response during a throttle or transient outage. Anonymous access is limited to 15 calls/hour; deployments can provide `LL2_API_TOKEN` for authenticated access. The Space Devs' published terms permit using and sharing the API data in any form, ask users not to forward it without adding value, disclaim complete accuracy, and encourage—but do not require—attribution. This app keeps a courtesy credit. Payload and stage/recovery records are shown only when supplied. Failed launches expose their source status and never receive fallback orbit geometry or a live/estimated marker. LL2 supplies launch context and event timing, not continuous ascent telemetry or live orbital state.
 - **TfL JamCams.** The camera list comes from the keyless `api.tfl.gov.uk` endpoint (an optional `TFL_APP_KEY` raises its rate limit); frames come from TfL's public S3 bucket. The "Powered by TfL Open Data" attribution is required by TfL's terms and is registered in the Data attribution popover.
 - **Ontario 511 CCTV.** The camera list comes from the `511on.ca/api/v2/get/cameras` endpoint, which now requires a free developer key (`ONTARIO_511_API_KEY`: sign up at 511on.ca/my511/register, then request it while logged in at 511on.ca/developers/doc; throttled to 10 calls a minute). Without the key the pack is skipped. Frames are server-registered still images under `511on.ca/map/Cctv/`. The source is live-fetched at runtime and attributed under the Open Government Licence - Ontario. Access is governed by Ontario 511's Developer's Access Agreement (511on.ca/developers/resources): the data stays under the Open Government Licence - Ontario unless otherwise specified; key requests are reviewed case by case and ask for the intended use and any third parties that will receive the data; attribution by link to 511on.ca is encouraged, and the Ontario 511 logo may not be altered or used to imply endorsement (this app links and shows no logo); and the data is provided "as is", a disclaimer distributors should pass on, which the credit does.
@@ -688,4 +686,4 @@ NOAA density imagery with the raw GLM product.

 ## In-app attribution

-The required Google Maps / Cesium credit renders on the on-globe credit line (`#cesium-credits`, bottom-left) and must stay visible — including in clean-view and recording modes (the whole line, logo + "Google Maps" + the "Data attribution" link, stays on screen; only the GEV panels/HUD fade). The layer-specific credits (adsb.lol, adsbdb, Planespotters.net, Open Vessel Photos, TeleGeography, OSM datacenters/dams/roads, NASA FIRMS, CelesTrak, USGS, City of Austin, Fintraffic, GBFS, Radio Browser, OpenSky, AISStream) are registered into the expandable **"Data attribution"** popover on that credit line via `viewer.creditDisplay.addStaticCredit(new Cesium.Credit(html, /* showOnScreen */ false))` — see `src/data/dataCredits.js`. When you add a new data source, add its license and attribution to this file **and** append an entry to `DATA_CREDITS` in `src/data/dataCredits.js` so it surfaces in the app.
+The required Google Maps / Cesium credit renders on the on-globe credit line (`#cesium-credits`, bottom-left) and must stay visible — including in clean-view and recording modes (the whole line, logo + "Google Maps" + the "Data attribution" link, stays on screen; only the GEV panels/HUD fade). The layer-specific credits (adsb.lol, adsbdb, Planespotters.net, TeleGeography, OSM datacenters/dams/roads, NASA FIRMS, CelesTrak, USGS, City of Austin, Fintraffic, GBFS, Radio Browser, OpenSky, AISStream) are registered into the expandable **"Data attribution"** popover on that credit line via `viewer.creditDisplay.addStaticCredit(new Cesium.Credit(html, /* showOnScreen */ false))` — see `src/data/dataCredits.js`. When you add a new data source, add its license and attribution to this file **and** append an entry to `DATA_CREDITS` in `src/data/dataCredits.js` so it surfaces in the app.
@@ -0,0 +1,7 @@
+- Fix the page freezing for seconds at a time with Transit on over a terrain
+  globe, most visibly while zooming over a large fleet. Every reread asked the
+  terrain for the height of every trail fix of every vehicle in view; heights
+  are now kept per point, read again only while the camera moves or tiles
+  load, and read within a time budget that puts vehicle positions first.
+  Switching the terrain provider or globe starts the kept heights afresh
+  (mazy1998, review by kvnloo, #1688).
@@ -1,2 +0,0 @@
- Show a new CCTV camera's frame the moment it is decoded, with no fade, so
-  switching cameras no longer lingers on an empty preview (samehkhamis, #1693).
@@ -1,3 +0,0 @@
- End a CCTV camera's monitor plane where its view meets the ground on globe
-  maps too, instead of a kilometre-wide plane hundreds of metres up
-  (samehkhamis, #1694).
@@ -1,3 +0,0 @@
- Show a selected vessel's photo from Open Vessel Photos, credited with its
-  photographer and open licence, and its MMSI beside its name in the CONTACTS
-  view (samehkhamis, #1695).
@@ -1,3 +0,0 @@
- Add an `./i18n` entry so an application with its own language menu can
-  start, follow and switch the interface language as the globe picker does
-  (samehkhamis, #1696).
@@ -1,4 +0,0 @@
- ALPR camera badges no longer take depth samples while the overlay paints, or
-  again each time the layer is switched back on. On a terrain globe their
-  height comes from the loaded terrain and is remembered per camera; some
-  badges move a few metres onto the drawn surface (mazy1998, #1706).
@@ -224,9 +224,7 @@ leaving out `command-dock` the voice control and its pointer reticle;
 leaving out `context` the Bhote Koshi reconstruction panel; and leaving out
 `intel-hud` the Intel HUD overlay (`#intel-hud`), whose readouts the HUD
 implementation publishes to the `gev-hud` store. An unknown
-view name is an error. An application that offers its own language choice
-starts and switches the language with the `./i18n` entry (`startPageLocale`,
-`followPageLocale`, `switchLocale`; see [I18N.md](./I18N.md)) and passes
+view name is an error. A host that does not initialize Core's locale passes
 `localePicker: false` to `createApplicationControls` instead of editing the
 markup. Node tests that import application modules register the component
 loader with `node --import=<core package>/build/register-vue`.
@@ -1513,14 +1513,10 @@ tile streamed in; floors resolve before new badges appear (bounded wait), and a
 badge whose cell has not resolved clamps until it does, then moves in place.
 Overlay anchors start on the same floor and write marker properties only on
 change. Once the camera is still and tiles have settled, each overlay anchor is
-replaced once by the rendered surface under it (accepted only within -30/+40 m
-of the floor cell), so badges do not float or sink on slopes; wedge corners
-follow their own floor cells instead of staying level with the apex. The
-surface is read outside the overlay paint, one camera per frame: a terrain
-globe answers from its loaded mesh (`globe.getHeight`) and only photoreal
-tiles are depth-sampled (`scene.sampleHeight`). Answers are kept per camera
-until the map source changes, so a refresh or turning the layer off and on
-samples nothing again. Unknown bearings never acquire a wedge. The selected
+replaced once by the rendered surface under it (two depth samples per paint,
+accepted only within -30/+40 m of the floor cell), so badges do not float or
+sink on slopes; wedge corners follow their own floor cells instead of staying
+level with the apex. Unknown bearings never acquire a wedge. The selected
 card's `DIRECTION` wraps after rounding to whole degrees, so a mapped bearing
 of 359.5° or more reads `0°` rather than `360°`. The row reads
 `N nearby · M on screen`; when every loaded camera is outside the view it adds
@@ -2228,9 +2224,7 @@ Frame loading, calibration editing and status display have separate modules;
 providers, camera placement and navigation policy retain their existing owners.
 Changing cameras invalidates old image callbacks and cancels an unfinished
 calibration edit. Failed refreshes preserve settled pixels for the same camera,
-while a newly selected camera never shows the prior camera's image. A frame is
-shown without a fade once it is decoded (or after one second if its decode never
-settles), so a new camera's preview is blank only while its frame loads. Disposal
+while a newly selected camera never shows the prior camera's image. Disposal
 releases listeners, subscriptions, image handlers, summary timers and chip-hide timers.

 ## UI disposal
@@ -3205,15 +3199,6 @@ stays in view or tracked; an answer, found or not, and a permanent refusal
 stay final for the session. A route belongs to the callsign it was looked up
 for, so a callsign change drops the old route. See `DATA_SOURCES.md`.

-A selected vessel gets a photo the same way. The browser asks Open Vessel
-Photos for it by MMSI (`fetchOpenVesselPhoto` in
-`src/sources/live/standalone.js`, read by `src/data/openVesselPhoto.js`), once
-per MMSI (`src/layers/vessels/photos.js`), and the CONTACTS view shows it under
-the vessel's name and MMSI ("NAME · MMSI 366999709") with the photographer,
-the photo's open licence and a link to the vessel's page. A vessel without an
-MMSI is never looked up; a miss stays final for the session, and a failed
-lookup is asked again after five minutes.
-
 `gods-eye-view/server/providers/live` is a Node-only entry for the existing
 plugins and shared request helpers. Importing it starts no sockets or timers.
 The existing aircraft normalizer is separately available through the portable
@@ -5084,10 +5069,6 @@ Shipped locales: **en** (source and fallback), **ar**, **de**, **es**, **fr**, *
  views re-render, code that published translated text words it again through
  `onLocaleChange`, and `<html lang>`/`dir` and the page's `data-i18n` markup
  follow. Nothing is lost; a toast already on screen keeps its words.
-  An application that offers the language elsewhere (a menu) uses the
-  `./i18n` entry (`src/i18n/page.js`): `startPageLocale` at boot,
-  `followPageLocale` for the markup and `switchLocale`, which does what a
-  picker choice does, with `localePicker: false`.
 - **Right to left.** Arabic (`ar`) and Hebrew (`he`) are in `RTL_LOCALES`, so
  `<html dir="rtl">`: the title, style indicator, both panel stacks and their
  icon rails swap sides through logical properties (`inset-inline-*`,
@@ -5825,6 +5806,23 @@ Noir samples also exclude its deliberately vignetted outer field, using shader
 settings and screen position rather than observed brightness. Selected-trail
 diagnostics report every condition even when selection fails.

+On a terrain globe Transit reads each vehicle's and trail point's height from
+the loaded surface (`globe.getHeight`, a ray cast against the drawn tile's
+mesh) and keeps the answer per point, about a metre apart
+(`src/layers/transit/height.js`, constants in `policy.js`). While the camera
+moves or tiles load a kept height is read again after 2 s; a height read once
+both have been still for 5 s is kept until either changes. Reads are budgeted
+at 16 ms per 200 ms window, 12 ms of it for re-reads, longest-kept first. A
+vehicle's own position is always read; the path its marker is drawn along
+comes next; the undrawn trail history of unselected vehicles may use a quarter
+of each budget. Past the budget a kept point keeps its last height, a new
+point takes the last height read in its ~111 m floor cell or waits, and the
+reread cycle continues until none waits. Before this, every reread asked the
+terrain for every trail fix of every vehicle in view, which blocked the page
+for up to 19 s at a time over a 650-vehicle fleet while zooming. Verified
+against Boston's MBTA feed on a keyless terrain globe only; no steeper city
+has a keyless feed to check against.
+
 Transit brackets use the normal-composite overlay surface: a 1.25 px mode-colour
 stroke over 3.25 px dark backing. Other contact themes retain their existing
 behavior. The selected trail uses a 3 px core over 5 px backing, mode-coloured
@@ -6589,10 +6587,6 @@ silently demoting every later lookup for the session.
  far cap, retargeting the existing video/canvas texture pipeline. Stills are drawn at their source aspect, centered on the placeholder dark (`#01070c`), instead of being stretched to the 16:9 canvas. Manual calibration only —
  auto-calibration and the drape mesh pipeline are deleted. A one-shot activation obstruction
  probe (`pickFromRay` on camera activation, clamping the plane short of the first hit) remains;
-  a hit at or beyond the camera's range counts as a miss, and on a globe map the plane also clamps
-  short of the globe's terrain along the axis (flat ground at the mount's ground when terrain is
-  missed or met beyond the range), whichever is nearer, so it never stands at the full range there
-  (about a kilometre wide and hundreds of metres up);
  ground placement is superseded by the shared-floor v3 behavior below. Calibration persists to
  `godsEyeView.cctv.calibration.v2` (wiped clean, no v1 import); a panel-only CAL badge shows
  `CALIBRATED`/`CURATED`/`RAW PRIOR` (no in-world tint). Panel is titled "CCTV" (not "CCTV
@@ -59,30 +59,6 @@ The language picker switches in place, without a reload. A view that calls `t()`

 A toast already on screen keeps its words.

-## An application with its own language choice
-
-An application that composes Core and offers the language somewhere else (a menu, a settings page) imports the `./i18n` entry (`src/i18n/page.js`) and passes `localePicker: false` to `createApplicationControls`:
-
-```js
-import {
-  LOCALES,
-  LOCALE_NAMES,
-  followPageLocale,
-  getLocale,
-  onLocaleChange,
-  startPageLocale,
-  switchLocale,
-} from '<core package>/i18n';
-
-startPageLocale(document); // before any view renders: ?lang=, stored choice, browser, English; translates data-i18n markup
-const stopFollowing = followPageLocale(document); // <html lang>/dir and data-i18n markup follow each switch
-
-for (const code of LOCALES) addMenuItem(LOCALE_NAMES[code], code === getLocale());
-menu.onChoose = (code) => switchLocale(code); // switched in place and stored (in ?lang when storage is blocked)
-```
-
-`switchLocale` does what a choice in the globe picker does, and returns `'unchanged'` for the active language. `onLocaleChange` tells the application's own menu to mark the new language.
-
 ## Rules

 - **Pass literals.** `t('Close')`, not `t(label)` (unless `label` holds a `msg()` value) and never a template literal with `${…}`.
@@ -133,7 +109,6 @@ Icons (`aria-hidden="true"`, Material Symbols), comments, CSS values and lowerca
 | `src/ui/i18n.js`                | the page's vue-i18n instance: the active locale and the catalogs               |
 | `src/i18n/marker.js`            | `msg` alone, for modules the server or tools import (no catalogs)              |
 | `src/i18n/locale.js`            | shipped languages, their names, choosing the language at boot                  |
-| `src/i18n/page.js`              | the `./i18n` entry: start, follow and switch the page's language               |
 | `src/i18n/locales/<code>.json`  | one catalog per language, keyed by English text                                |
 | `src/i18n/same-as-english.json` | per language, the entries that stay as in English on purpose                   |
 | `scripts/i18n.mjs`              | `npm run i18n`: extracts messages, checks the catalogs, finds unmarked UI text |
@@ -99,7 +99,6 @@
    "./application": "./src/app/application.js",
    "./application/viewer": "./src/app/viewer.js",
    "./time": "./src/time/worldClock.js",
-    "./i18n": "./src/i18n/page.js",
    "./build/vite": {
      "node": "./build/vite.js"
    },
@@ -385,8 +385,6 @@
  "src/layers/vessels/index.js",
  "src/layers/vessels/ingestion.js",
  "src/layers/vessels/lifecycle.js",
-  "src/layers/vessels/photos.js",
-  "src/layers/vessels/photos.test.mjs",
  "src/layers/vessels/policy.js",
  "src/layers/vessels/queries.js",
  "src/layers/vessels/rendering.js",
@@ -1337,13 +1335,9 @@
  "src/app/sourceComposition.js",
  "src/app/sourceComposition.test.mjs",
  "src/data/dataCredits.js",
-  "src/data/openVesselPhoto.js",
-  "src/data/openVesselPhoto.test.mjs",
  "src/data/layerState.js",
  "src/data/layerState.test.mjs",
  "src/data/spriteOrder.js",
-  "src/i18n/page.js",
-  "src/i18n/page.test.mjs",
  "src/i18n/locales/ar.json",
  "src/i18n/locales/de.json",
  "src/i18n/locales/es.json",
@@ -175,28 +175,6 @@
    ],
    "external": ["vue", "pinia", "vue-i18n"]
  },
-  "i18n": {
-    "exports": ["./i18n"],
-    "modules": [
-      "src/i18n/page.js",
-      "src/i18n/index.js",
-      "src/i18n/locale.js",
-      "src/i18n/locales/ar.json",
-      "src/i18n/locales/de.json",
-      "src/i18n/locales/es.json",
-      "src/i18n/locales/fr.json",
-      "src/i18n/locales/he.json",
-      "src/i18n/locales/it.json",
-      "src/i18n/locales/ja.json",
-      "src/i18n/locales/pt.json",
-      "src/i18n/locales/ru.json",
-      "src/i18n/locales/sv.json",
-      "src/i18n/locales/uk.json",
-      "src/i18n/locales/zh-CN.json",
-      "src/i18n/locales/zh-Hant.json"
-    ],
-    "external": []
-  },
  "time": {
    "exports": ["./time"],
    "modules": ["src/time/worldClock.js"],
@@ -1496,8 +1474,7 @@
      "src/sources/live/index.js",
      "src/sources/live/standalone.js",
      "src/sources/live/vessels.js",
-      "src/data/planespottersPhoto.js",
-      "src/data/openVesselPhoto.js"
+      "src/data/planespottersPhoto.js"
    ],
    "external": []
  },
@@ -1719,9 +1696,7 @@
      "src/i18n/locales/sv.json",
      "src/i18n/locales/uk.json",
      "src/i18n/locales/zh-CN.json",
-      "src/i18n/locales/zh-Hant.json",
-      "src/layers/vessels/photos.js",
-      "src/data/openVesselPhoto.js"
+      "src/i18n/locales/zh-Hant.json"
    ],
    "external": ["cesium"]
  },
@@ -3782,9 +3757,7 @@
      "src/data/ucsSatellites.js",
      "src/data/imagingSensors.js",
      "src/data/planespottersPhoto.js",
-      "src/ui/stores/dataLibrary.js",
-      "src/data/openVesselPhoto.js",
-      "src/layers/vessels/photos.js"
+      "src/ui/stores/dataLibrary.js"
    ],
    "external": [
      "hls.js",
@@ -4494,9 +4467,7 @@
      "src/layers/satellites/sensors.js",
      "src/data/ucsSatellites.js",
      "src/data/imagingSensors.js",
-      "src/data/planespottersPhoto.js",
-      "src/layers/vessels/photos.js",
-      "src/data/openVesselPhoto.js"
+      "src/data/planespottersPhoto.js"
    ],
    "external": [
      "hls.js",
@@ -5748,8 +5719,7 @@
      "src/layers/satellites/sensors.js",
      "src/data/ucsSatellites.js",
      "src/data/imagingSensors.js",
-      "src/data/planespottersPhoto.js",
-      "src/data/openVesselPhoto.js"
+      "src/data/planespottersPhoto.js"
    ],
    "external": ["@mapbox/vector-tile", "pbf"]
  },
@@ -9,8 +9,7 @@ import { t } from '../i18n/index.js';
 * Construct the existing controls and camera presentation. `initialShareCode`
 * opens a share code (the `<code>` of `/share/<code>`) at start-up, for a host
 * whose address does not carry one. `localePicker: false` removes the language
- * picker, for a host that offers its own language choice (`switchLocale` from
- * the `./i18n` entry).
+ * picker, for a host that does not initialize Core's locale.
 */
 export function createApplicationControls({
  scene: { viewer, mapStackController, operations },
@@ -29,7 +29,6 @@ export const writeCalibrationStoreV2 = layer.writeCalibrationStoreV2;
 export const deriveCalBadge = layer.deriveCalBadge;
 export const computeFrustumGeometry = layer.computeFrustumGeometry;
 export const activationProbeClampRange = layer.activationProbeClampRange;
-export const flatGroundAxisDistance = layer.flatGroundAxisDistance;
 export const frameSignatureFromPixels = layer.frameSignatureFromPixels;
 export const _createCctvProjectionPlaneForTest =
  layer._createCctvProjectionPlaneForTest;
@@ -35,7 +35,6 @@ import cctvLayer, {
  _pushAmbientCardEntriesForTest,
  _setCctvOverlayHostForTest,
  activationProbeClampRange,
-  flatGroundAxisDistance,
  bindCctvWorldClickGesture,
  clearProbeClampOnDeactivation,
  computeFrustumGeometry,
@@ -656,17 +655,6 @@ test('activation obstruction clamp uses the field-derived 12 m floor', () => {
  assert.equal(activationProbeClampRange(210, 250), null);
 });

-test('on a globe map the axis ends on flat ground at the mount ground', () => {
-  // A 24 m mount pitched 30° down meets the ground 48 m along its axis.
-  assert.ok(Math.abs(flatGroundAxisDistance(24, -30) - 48) < 1e-9);
-  // The default 700 m range then clamps just short of that, not 700 m out.
-  const clamp = activationProbeClampRange(700, flatGroundAxisDistance(24, -30));
-  assert.ok(Math.abs(clamp - 44) < 1e-9);
-  assert.equal(flatGroundAxisDistance(24, 0), null);
-  assert.equal(flatGroundAxisDistance(24, 10), null);
-  assert.equal(flatGroundAxisDistance(0, -30), null);
-});
-
 test('deactivation clears the probe clamp and restores nominal frustum geometry', () => {
  const record = {
    camera: { ...UNCLAMPED_CAMERA },
@@ -141,13 +141,6 @@ export const DATA_CREDITS = [
      '<a href="https://www.planespotters.net" target="_blank" rel="noopener">Planespotters.net</a> ' +
      '· each photo is © its photographer, credited beside it',
  },
-  {
-    key: 'openvesselphotos',
-    html:
-      'Vessel photos: ' +
-      '<a href="https://openvesselphotos.org" target="_blank" rel="noopener">Open Vessel Photos</a> ' +
-      "· each photo keeps its author's open licence, credited beside it",
-  },
  {
    key: 'aisstream',
    html:
@@ -51,13 +51,6 @@ test('Planespotters is credited with a plain followable link', () => {
  assert.doesNotMatch(credit.html, /nofollow/);
 });

-test('Open Vessel Photos is credited with a plain followable link', () => {
-  const credit = DATA_CREDITS.find((entry) => entry.key === 'openvesselphotos');
-  assert.ok(credit, 'the selected vessel photos come from Open Vessel Photos');
-  assert.match(credit.html, /href="https:\/\/openvesselphotos\.org"/);
-  assert.doesNotMatch(credit.html, /nofollow/);
-});
-
 test('the UCS Satellite Database is acknowledged with its version and webpage', () => {
  // UCS database manual, section 3: references name the version (the Excel
  // file's name) and link www.ucsusa.org/satellite_database.
@@ -1,135 +0,0 @@
-/**
- * @module openVesselPhoto
- * @description Reads an Open Vessel Photos answer into the one photo every
- * surface shows. Open Vessel Photos (https://openvesselphotos.org) serves a
- * free, keyless JSON and image API by MMSI. Every photo keeps the open licence
- * its author chose (CC BY, CC BY-SA, CC0 or public domain), so it is shown
- * with its credit and licence and links back to the vessel's page. A photo
- * whose image is not on Open Vessel Photos' own host, or whose answer names
- * no licence, is "no photo": nothing arbitrary is ever shown or linked.
- *
- * Accepts the upstream answer (`GET https://openvesselphotos.org/v1/mmsi/{mmsi}`,
- * `{mmsi, photos: [...]}`) and an already-read photo
- * (`{found, src, width, height, photographer, licence, link}`).
- * Pure: no fetch, no DOM.
- */
-
-/** The only host a photo may come from or link to. */
-const HOST = 'openvesselphotos.org';
-/** The API's per-vessel answer. */
-const API = `https://${HOST}/v1/mmsi/`;
-/** The image width asked for: sharp in the panel on a 2× screen, ~60 KB. */
-const IMAGE_SIZE = '800';
-
-const NO_PHOTO = Object.freeze({ found: false });
-
-/** A vessel's MMSI: nine digits. */
-export const MMSI = /^\d{9}$/;
-
-/** The API answer for one MMSI. */
-export function openVesselPhotosUrl(mmsi) {
-  return API + mmsi;
-}
-
-/** The vessel's page on Open Vessel Photos. */
-function vesselPage(mmsi) {
-  return `https://${HOST}/vessels/mmsi/${mmsi}`;
-}
-
-/** The parsed `https:` URL on the Open Vessel Photos host, or null. */
-function ownUrl(value) {
-  if (typeof value !== 'string' || !value) return null;
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    return null;
-  }
-  return url.protocol === 'https:' &&
-    !url.username &&
-    !url.password &&
-    !url.port &&
-    url.hostname === HOST
-    ? url
-    : null;
-}
-
-function dimension(value) {
-  const number = Number(value);
-  return value != null && Number.isFinite(number) && number > 0
-    ? Math.round(number)
-    : null;
-}
-
-function text(value) {
-  return typeof value === 'string' ? value.trim() : '';
-}
-
-/** One upstream photo of the vessel `mmsi`, checked. */
-function checkedUpstream(photo, mmsi) {
-  if (!photo || typeof photo !== 'object') return null;
-  const image = ownUrl(photo.urls?.mmsi);
-  const licence = text(photo.licenceName) || text(photo.licence);
-  if (!image || !licence) return null;
-  image.search = '';
-  image.hash = '';
-  image.searchParams.set('size', IMAGE_SIZE);
-  // The answer gives the full image's size; the 800 px one keeps its shape.
-  const width = dimension(photo.width);
-  const height = dimension(photo.height);
-  const scale =
-    width && width > Number(IMAGE_SIZE) ? Number(IMAGE_SIZE) / width : 1;
-  return {
-    found: true,
-    src: image.href,
-    width: width ? Math.round(width * scale) : null,
-    height: height ? Math.round(height * scale) : null,
-    photographer: text(photo.credit),
-    licence,
-    link: vesselPage(mmsi),
-  };
-}
-
-/** An already-read photo, checked again. */
-function checkedRead(photo) {
-  const image = ownUrl(photo.src);
-  const page = ownUrl(photo.link);
-  const licence = text(photo.licence);
-  if (!image || !page || !licence) return null;
-  return {
-    found: true,
-    src: image.href,
-    width: dimension(photo.width),
-    height: dimension(photo.height),
-    photographer: text(photo.photographer),
-    licence,
-    link: page.href,
-  };
-}
-
-/**
- * Read an Open Vessel Photos answer into the first photo that passes the
- * checks.
- * @param {*} payload Upstream answer or already-read photo.
- * @param {?string} [requestedMmsi] The MMSI asked for; an upstream answer
- *   naming another is no photo.
- * @returns {{found: true, src: string, width: ?number, height: ?number,
- *   photographer: string, licence: string, link: string} | {found: false}}
- */
-export function parseOpenVesselPhoto(payload, requestedMmsi = null) {
-  if (!payload || typeof payload !== 'object') return NO_PHOTO;
-  if (Array.isArray(payload.photos)) {
-    const mmsi = String(payload.mmsi ?? '');
-    if (!MMSI.test(mmsi)) return NO_PHOTO;
-    // An answer about another vessel is no photo of this one.
-    if (requestedMmsi != null && mmsi !== String(requestedMmsi))
-      return NO_PHOTO;
-    for (const photo of payload.photos) {
-      const checked = checkedUpstream(photo, mmsi);
-      if (checked) return checked;
-    }
-    return NO_PHOTO;
-  }
-  if (payload.found !== true) return NO_PHOTO;
-  return checkedRead(payload) || NO_PHOTO;
-}
@@ -1,120 +0,0 @@
-// src/data/openVesselPhoto.test.mjs — an Open Vessel Photos answer is read
-// into one credited, licensed photo, and nothing outside Open Vessel Photos'
-// own host is ever shown or linked.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  openVesselPhotosUrl,
-  parseOpenVesselPhoto,
-} from './openVesselPhoto.js';
-
-const UPSTREAM = Object.freeze({
-  mmsi: '366999709',
-  name: '01 USCGC Sockeye WPB87337',
-  photos: [
-    {
-      n: 1,
-      urls: {
-        cfr: null,
-        mmsi: 'https://openvesselphotos.org/v1/mmsi/366999709/photos/1.jpg',
-      },
-      credit: 'Gordon Leggett',
-      licence: 'CC-BY-4.0',
-      licenceName: 'CC BY 4.0',
-      width: 1600,
-      height: 1200,
-    },
-  ],
-});
-
-const PHOTO = Object.freeze({
-  found: true,
-  src: 'https://openvesselphotos.org/v1/mmsi/366999709/photos/1.jpg?size=800',
-  width: 800,
-  height: 600,
-  photographer: 'Gordon Leggett',
-  licence: 'CC BY 4.0',
-  link: 'https://openvesselphotos.org/vessels/mmsi/366999709',
-});
-
-const withPhoto = (overrides) => ({
-  ...UPSTREAM,
-  photos: [{ ...UPSTREAM.photos[0], ...overrides }],
-});
-
-test('the upstream answer maps to the 800 px image, its credit, licence and page', () => {
-  assert.deepEqual(parseOpenVesselPhoto(UPSTREAM), PHOTO);
-  assert.equal(
-    openVesselPhotosUrl('366999709'),
-    'https://openvesselphotos.org/v1/mmsi/366999709',
-  );
-});
-
-test('an image narrower than 800 px keeps its own size', () => {
-  const photo = parseOpenVesselPhoto(withPhoto({ width: 640, height: 480 }));
-  assert.equal(photo.width, 640);
-  assert.equal(photo.height, 480);
-});
-
-test('an already-read photo passes through its checks again', () => {
-  assert.deepEqual(parseOpenVesselPhoto(PHOTO), PHOTO);
-  assert.deepEqual(parseOpenVesselPhoto({ ...PHOTO, licence: '' }), {
-    found: false,
-  });
-});
-
-test('a photo off the Open Vessel Photos host, or without a licence, is no photo', () => {
-  for (const overrides of [
-    { urls: { mmsi: 'https://example.com/1.jpg' } },
-    {
-      urls: {
-        mmsi: 'http://openvesselphotos.org/v1/mmsi/366999709/photos/1.jpg',
-      },
-    },
-    { urls: { mmsi: 'https://openvesselphotos.org.evil.com/1.jpg' } },
-    { urls: { mmsi: 'https://[email protected]/1.jpg' } },
-    { licence: '', licenceName: '' },
-  ])
-    assert.deepEqual(parseOpenVesselPhoto(withPhoto(overrides)), {
-      found: false,
-    });
-  assert.deepEqual(
-    parseOpenVesselPhoto({ ...PHOTO, link: 'https://example.com/' }),
-    { found: false },
-  );
-});
-
-test('a vessel without photos, or an answer with a bad MMSI, is no photo', () => {
-  assert.deepEqual(parseOpenVesselPhoto({ ...UPSTREAM, photos: [] }), {
-    found: false,
-  });
-  assert.deepEqual(parseOpenVesselPhoto({ ...UPSTREAM, mmsi: '12/../x' }), {
-    found: false,
-  });
-  assert.deepEqual(parseOpenVesselPhoto(null), { found: false });
-});
-
-test('the next photo stands in when the first fails its checks', () => {
-  const second = {
-    ...UPSTREAM.photos[0],
-    n: 2,
-    urls: {
-      mmsi: 'https://openvesselphotos.org/v1/mmsi/366999709/photos/2.jpg',
-    },
-  };
-  const photo = parseOpenVesselPhoto({
-    ...UPSTREAM,
-    photos: [{ ...UPSTREAM.photos[0], licenceName: '', licence: '' }, second],
-  });
-  assert.equal(
-    photo.src,
-    'https://openvesselphotos.org/v1/mmsi/366999709/photos/2.jpg?size=800',
-  );
-});
-
-test('an answer about another vessel than the one asked for is no photo', () => {
-  assert.deepEqual(parseOpenVesselPhoto(UPSTREAM, '366999709'), PHOTO);
-  assert.deepEqual(parseOpenVesselPhoto(UPSTREAM, '227000101'), {
-    found: false,
-  });
-});
@@ -3804,8 +3804,6 @@
  "(+{minutes} min late)": "(تأخير {minutes} د)",
  "Exit cockpit to fly to a train": "اخرج من القمرة للانتقال إلى قطار",
  "Photo © {photographer}": "صورة © {photographer}",
-  "Photo: {photographer} · {licence}": "صورة: {photographer} · {licence}",
-  "Photo · {licence}": "صورة · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "الرحلة المشتركة: لا بيانات واردة الآن — يُعرض آخر موضع معروف",
  "The shared flight isn't reporting now — showing where it was at {time}": "الرحلة المشتركة: لا بيانات واردة الآن — يُعرض موضعها عند {time}",
  "The shared military flight isn't reporting now — showing where it was last seen": "الرحلة العسكرية المشتركة: لا بيانات واردة الآن — يُعرض آخر موضع معروف",
@@ -3480,8 +3480,6 @@
  "(+{minutes} min late)": "(+{minutes} min Verspätung)",
  "Exit cockpit to fly to a train": "Cockpit verlassen, um zu einem Zug zu fliegen",
  "Photo © {photographer}": "Foto © {photographer}",
-  "Photo: {photographer} · {licence}": "Foto: {photographer} · {licence}",
-  "Photo · {licence}": "Foto · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "Der geteilte Flug sendet gerade nicht – letzte bekannte Position wird gezeigt",
  "The shared flight isn't reporting now — showing where it was at {time}": "Der geteilte Flug sendet gerade nicht – Position um {time} wird gezeigt",
  "The shared military flight isn't reporting now — showing where it was last seen": "Der geteilte Militärflug sendet gerade nicht – letzte bekannte Position wird gezeigt",
@@ -3561,8 +3561,6 @@
  "(+{minutes} min late)": "(+{minutes} min de retraso)",
  "Exit cockpit to fly to a train": "Sal de la cabina para volar a un tren",
  "Photo © {photographer}": "Foto © {photographer}",
-  "Photo: {photographer} · {licence}": "Foto: {photographer} · {licence}",
-  "Photo · {licence}": "Foto · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "El vuelo compartido no está transmitiendo ahora; se muestra dónde se vio por última vez",
  "The shared flight isn't reporting now — showing where it was at {time}": "El vuelo compartido no está transmitiendo ahora; se muestra dónde estaba a las {time}",
  "The shared military flight isn't reporting now — showing where it was last seen": "El vuelo militar compartido no está transmitiendo ahora; se muestra dónde se vio por última vez",
@@ -3561,8 +3561,6 @@
  "(+{minutes} min late)": "(+{minutes} min de retard)",
  "Exit cockpit to fly to a train": "Quittez le cockpit pour rejoindre un train",
  "Photo © {photographer}": "Photo © {photographer}",
-  "Photo: {photographer} · {licence}": "Photo : {photographer} · {licence}",
-  "Photo · {licence}": "Photo · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "Le vol partagé n'émet pas actuellement — affichage de sa dernière position connue",
  "The shared flight isn't reporting now — showing where it was at {time}": "Le vol partagé n'émet pas actuellement — affichage de sa position à {time}",
  "The shared military flight isn't reporting now — showing where it was last seen": "Le vol militaire partagé n'émet pas actuellement — affichage de sa dernière position connue",
@@ -3385,8 +3385,6 @@
  "(+{minutes} min late)": "(+{minutes} דק׳ איחור)",
  "Exit cockpit to fly to a train": "צא מתא הטייס כדי לטוס לרכבת",
  "Photo © {photographer}": "צילום © {photographer}",
-  "Photo: {photographer} · {licence}": "צילום: {photographer} · {licence}",
-  "Photo · {licence}": "צילום · {licence}",
  "1 h/s": "שעה/שנ׳",
  "1 d/s": "יום/שנ׳",
  "1 wk/s": "שבוע/שנ׳",
@@ -3561,8 +3561,6 @@
  "(+{minutes} min late)": "(+{minutes} min di ritardo)",
  "Exit cockpit to fly to a train": "Esci dal cockpit per volare a un treno",
  "Photo © {photographer}": "Foto © {photographer}",
-  "Photo: {photographer} · {licence}": "Foto: {photographer} · {licence}",
-  "Photo · {licence}": "Foto · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "Il volo condiviso non sta trasmettendo ora: viene mostrata l'ultima posizione nota",
  "The shared flight isn't reporting now — showing where it was at {time}": "Il volo condiviso non sta trasmettendo ora: viene mostrata la posizione alle {time}",
  "The shared military flight isn't reporting now — showing where it was last seen": "Il volo militare condiviso non sta trasmettendo ora: viene mostrata l'ultima posizione nota",
@@ -3399,8 +3399,6 @@
  "(+{minutes} min late)": "（{minutes}分遅れ）",
  "Exit cockpit to fly to a train": "列車へ移動するにはコックピットを終了してください",
  "Photo © {photographer}": "写真 © {photographer}",
-  "Photo: {photographer} · {licence}": "写真：{photographer} · {licence}",
-  "Photo · {licence}": "写真 · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "共有されたフライトは現在報告していません。最後に確認された位置を表示しています",
  "The shared flight isn't reporting now — showing where it was at {time}": "共有されたフライトは現在報告していません。{time}時点の位置を表示しています",
  "The shared military flight isn't reporting now — showing where it was last seen": "共有された軍用機は現在報告していません。最後に確認された位置を表示しています",
@@ -3561,8 +3561,6 @@
  "(+{minutes} min late)": "(+{minutes} min de atraso)",
  "Exit cockpit to fly to a train": "Saia da cabine para voar até um trem",
  "Photo © {photographer}": "Foto © {photographer}",
-  "Photo: {photographer} · {licence}": "Foto: {photographer} · {licence}",
-  "Photo · {licence}": "Foto · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "O voo compartilhado não está transmitindo agora — mostrando a última posição conhecida",
  "The shared flight isn't reporting now — showing where it was at {time}": "O voo compartilhado não está transmitindo agora — mostrando onde estava às {time}",
  "The shared military flight isn't reporting now — showing where it was last seen": "O voo militar compartilhado não está transmitindo agora — mostrando a última posição conhecida",
@@ -3642,8 +3642,6 @@
  "(+{minutes} min late)": "(+{minutes} мин опоздания)",
  "Exit cockpit to fly to a train": "Выйдите из кабины, чтобы перелететь к поезду",
  "Photo © {photographer}": "Фото © {photographer}",
-  "Photo: {photographer} · {licence}": "Фото: {photographer} · {licence}",
-  "Photo · {licence}": "Фото · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "Общий рейс сейчас не передаёт данные — показано последнее известное место",
  "The shared flight isn't reporting now — showing where it was at {time}": "Общий рейс сейчас не передаёт данные — показано место в {time}",
  "The shared military flight isn't reporting now — showing where it was last seen": "Общий военный рейс сейчас не передаёт данные — показано последнее известное место",
@@ -3472,8 +3472,6 @@
  "(+{minutes} min late)": "(+{minutes} min försenad)",
  "Exit cockpit to fly to a train": "Lämna cockpiten för att flyga till ett tåg",
  "Photo © {photographer}": "Foto © {photographer}",
-  "Photo: {photographer} · {licence}": "Foto: {photographer} · {licence}",
-  "Photo · {licence}": "Foto · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "Den delade flygningen rapporterar inte just nu – visar senast kända position",
  "The shared flight isn't reporting now — showing where it was at {time}": "Den delade flygningen rapporterar inte just nu – visar positionen från {time}",
  "The shared military flight isn't reporting now — showing where it was last seen": "Den delade militärflygningen rapporterar inte just nu – visar senast kända position",
@@ -3642,8 +3642,6 @@
  "(+{minutes} min late)": "(+{minutes} хв запізнення)",
  "Exit cockpit to fly to a train": "Вийдіть із кабіни, щоб перелетіти до поїзда",
  "Photo © {photographer}": "Фото © {photographer}",
-  "Photo: {photographer} · {licence}": "Фото: {photographer} · {licence}",
-  "Photo · {licence}": "Фото · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "Спільний рейс зараз не передає даних — показано останнє відоме місце",
  "The shared flight isn't reporting now — showing where it was at {time}": "Спільний рейс зараз не передає даних — показано місце о {time}",
  "The shared military flight isn't reporting now — showing where it was last seen": "Спільний військовий рейс зараз не передає даних — показано останнє відоме місце",
@@ -3399,8 +3399,6 @@
  "(+{minutes} min late)": "（晚点 {minutes} 分钟）",
  "Exit cockpit to fly to a train": "请先退出座舱，再飞往列车",
  "Photo © {photographer}": "照片 © {photographer}",
-  "Photo: {photographer} · {licence}": "照片：{photographer} · {licence}",
-  "Photo · {licence}": "照片 · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "共享的航班目前没有发送信号——显示其最后出现的位置",
  "The shared flight isn't reporting now — showing where it was at {time}": "共享的航班目前没有发送信号——显示其在 {time} 的位置",
  "The shared military flight isn't reporting now — showing where it was last seen": "共享的军用航班目前没有发送信号——显示其最后出现的位置",
@@ -3399,8 +3399,6 @@
  "(+{minutes} min late)": "（誤點 {minutes} 分鐘）",
  "Exit cockpit to fly to a train": "請先退出座艙，再飛往列車",
  "Photo © {photographer}": "照片 © {photographer}",
-  "Photo: {photographer} · {licence}": "照片：{photographer} · {licence}",
-  "Photo · {licence}": "照片 · {licence}",
  "The shared flight isn't reporting now — showing where it was last seen": "共享的航班目前沒有發送信號——顯示其最後出現的位置",
  "The shared flight isn't reporting now — showing where it was at {time}": "共享的航班目前沒有發送信號——顯示其在 {time} 的位置",
  "The shared military flight isn't reporting now — showing where it was last seen": "共享的軍用航班目前沒有發送信號——顯示其最後出現的位置",
@@ -1,81 +0,0 @@
-/**
- * @module i18n/page
- * @description The page's interface language, for an application that
- * composes Core and offers its own language choice (a menu item, a settings
- * page) instead of the globe picker. It starts the language the standalone
- * application starts, keeps `<html lang>`/`<html dir>` and the page's
- * `data-i18n` markup in step, and switches in place, stored for the next
- * visit, exactly as the picker does. Guide: docs/I18N.md.
- */
-import {
-  DEFAULT_LOCALE,
-  LOCALES,
-  LOCALE_NAMES,
-  applyDocumentLanguage,
-  isRtlLocale,
-  normalizeLocale,
-  resolveLocale,
-} from './locale.js';
-import {
-  applyDocumentTranslations,
-  getLocale,
-  onLocaleChange,
-  persistLocale,
-  setLocale,
-} from './index.js';
-
-export {
-  DEFAULT_LOCALE,
-  LOCALES,
-  LOCALE_NAMES,
-  applyDocumentTranslations,
-  getLocale,
-  isRtlLocale,
-  onLocaleChange,
-};
-
-/**
- * Start the page in its language: `?lang=`, then the stored choice, then the
- * browser's languages, then English. Call it before any view renders, so
- * every lookup and `<html lang>`/`<html dir>` agree from the first frame; the
- * page's static `data-i18n` markup (a loading screen) is translated now.
- * @param {Document} [doc]
- * @param {Parameters<typeof resolveLocale>[0]} [inputs] Location, storage
- *   and languages, for tests.
- * @returns {string} The active locale.
- */
-export function startPageLocale(doc = globalThis.document, inputs) {
-  const locale = setLocale(resolveLocale(inputs));
-  applyDocumentLanguage(doc, locale);
-  applyDocumentTranslations(doc);
-  return locale;
-}
-
-/**
- * Keep `<html lang>`/`<html dir>` and the page's `data-i18n` markup in step
- * with every language switch.
- * @param {Document} [doc]
- * @returns {() => void} Stops following.
- */
-export function followPageLocale(doc = globalThis.document) {
-  return onLocaleChange(() => {
-    applyDocumentLanguage(doc, getLocale());
-    applyDocumentTranslations(doc);
-  });
-}
-
-/**
- * Switch the page to `locale` in place and keep it for the next visit. The
- * active language, or an unknown code that would fall back to it, changes
- * nothing.
- * @param {string} locale One of LOCALES.
- * @param {Parameters<typeof persistLocale>[1]} [options] Location, history
- *   and storage, for tests.
- * @returns {'unchanged'|'switched'}
- */
-export function switchLocale(locale, options) {
-  const next = normalizeLocale(locale) || DEFAULT_LOCALE;
-  if (next === getLocale()) return 'unchanged';
-  setLocale(persistLocale(next, options));
-  return 'switched';
-}
@@ -1,106 +0,0 @@
-// src/i18n/page.test.mjs — an application with its own language choice starts,
-// follows and switches the page's language as the globe picker does.
-import { afterEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { LOCALE_STORAGE_KEY } from './locale.js';
-import {
-  followPageLocale,
-  getLocale,
-  startPageLocale,
-  switchLocale,
-} from './page.js';
-import { setLocale } from './index.js';
-
-afterEach(() => setLocale('en'));
-
-function memoryStorage() {
-  const data = new Map();
-  return {
-    data,
-    getItem: (key) => data.get(key) ?? null,
-    setItem: (key, value) => data.set(key, String(value)),
-  };
-}
-
-function page(elements = []) {
-  return {
-    documentElement: { lang: '', dir: '' },
-    querySelectorAll: (selector) =>
-      selector === '[data-i18n]' ? elements : [],
-  };
-}
-
-/** A data-i18n element, as applyDocumentTranslations reads one. */
-function marked(text) {
-  return {
-    textContent: text,
-    hasAttribute: (name) => name === 'data-i18n',
-    getAttribute: () => null,
-  };
-}
-
-test('the page starts in ?lang=, else the stored choice, with lang and dir set', () => {
-  const doc = page();
-  const storage = memoryStorage();
-  storage.setItem(LOCALE_STORAGE_KEY, 'de');
-  assert.equal(
-    startPageLocale(doc, {
-      location: { search: '?lang=ar' },
-      storage,
-      languages: ['ru'],
-    }),
-    'ar',
-  );
-  assert.equal(getLocale(), 'ar');
-  assert.deepEqual(doc.documentElement, { lang: 'ar', dir: 'rtl' });
-  assert.equal(
-    startPageLocale(doc, { location: { search: '' }, storage, languages: [] }),
-    'de',
-  );
-  assert.deepEqual(doc.documentElement, { lang: 'de', dir: 'ltr' });
-});
-
-test("the page's data-i18n markup is in its language from the start", () => {
-  const close = marked('Close');
-  startPageLocale(page([close]), {
-    location: { search: '?lang=de' },
-    storage: memoryStorage(),
-    languages: [],
-  });
-  assert.equal(close.textContent, 'Schließen');
-});
-
-test('a switch is stored, drops ?lang, and the followed page takes it', () => {
-  const doc = page();
-  const stop = followPageLocale(doc);
-  const storage = memoryStorage();
-  const replaced = [];
-  const options = {
-    location: { href: 'https://example.test/?lang=fr#view' },
-    history: { replaceState: (_s, _t, url) => replaced.push(url) },
-    storage,
-  };
-  assert.equal(switchLocale('he', options), 'switched');
-  assert.equal(getLocale(), 'he');
-  assert.equal(storage.data.get(LOCALE_STORAGE_KEY), 'he');
-  assert.deepEqual(replaced, ['https://example.test/#view']);
-  assert.deepEqual(doc.documentElement, { lang: 'he', dir: 'rtl' });
-  stop();
-  switchLocale('ja', options);
-  assert.deepEqual(doc.documentElement, { lang: 'he', dir: 'rtl' });
-});
-
-test('choosing the active language, or one that falls back to it, changes nothing', () => {
-  const storage = memoryStorage();
-  const options = {
-    location: { href: 'https://example.test/' },
-    history: { replaceState() {} },
-    storage,
-  };
-  assert.equal(switchLocale('en', options), 'unchanged');
-  assert.equal(switchLocale('xx', options), 'unchanged');
-  assert.equal(storage.data.size, 0);
-  assert.equal(switchLocale('pt-BR', options), 'switched');
-  assert.equal(getLocale(), 'pt');
-  assert.equal(switchLocale('pt', options), 'unchanged');
-});
@@ -625,7 +625,6 @@
    "▲ {frp} MW",
    "SATELLITE",
    "Photo © {photographer}",
-    "Photo · {licence}",
    "PACK",
    "{count} packs",
    "Orthophoto",
@@ -4,10 +4,10 @@ import {
  MARKER_ICON_SIZE,
  SELECTED_MARKER_ICON_SIZE,
  MARKER_FLOOR_LIFT_M,
-  REMEMBERED_ANCHORS,
+  ANCHOR_SAMPLES_PER_PAINT,
  SURFACE_BELOW_FLOOR_M,
  SURFACE_ABOVE_FLOOR_M,
-  SURFACE_SAMPLES_PER_FRAME,
+  SURFACE_SAMPLES_PER_PAINT,
 } from './policy.js';
 import {
  MARKER_IMAGE,
@@ -19,17 +19,11 @@ import {
  validAlprGroundHeight,
 } from './visuals.js';

-const nextAnimationFrame = (step) =>
-  typeof requestAnimationFrame === 'function'
-    ? requestAnimationFrame(step)
-    : setTimeout(step, 16);
-
 /** Per-layer presentation on a caller-owned overlay; Cesium remains the fallback. */
 export function createAlprOverlay({
  state,
  services,
  onSurfaceChange = () => {},
-  requestFrame = nextAnimationFrame,
 }) {
  let lane,
    removeMapListener,
@@ -39,12 +33,7 @@ export function createAlprOverlay({
    hits = [],
    images = [],
    destroyed = false,
-    lastCamera = null,
-    sampling = false;
-  // Rendered-surface answers by camera id. Entities are rebuilt by a refresh
-  // and by turning the layer off and on; keeping the answers on them meant
-  // every rebuild sampled the same cameras again.
-  const surfaceAnswers = new Map();
+    lastCamera = null;
  const requestPaint = () => {
    if (!destroyed && state.enabled) lane?.requestPaint();
  };
@@ -103,72 +92,38 @@ export function createAlprOverlay({
      entity.gevAlprDisplayPosition = null;
      nativeVisible(entity, true);
    }
-    surfaceAnswers.clear();
    state.lastAnchorSampleAt = 0;
    retryUntil = Date.now() + 15000;
    requestPaint();
  }

-  function rememberSurface(record, height, checked) {
-    surfaceAnswers.delete(record.id);
-    surfaceAnswers.set(record.id, {
-      latitude: record.latitude,
-      longitude: record.longitude,
-      height,
-      checked,
-    });
-    if (surfaceAnswers.size > REMEMBERED_ANCHORS)
-      surfaceAnswers.delete(surfaceAnswers.keys().next().value);
-  }
-
-  /**
-   * Rendered surface height under a camera. A terrain globe answers from its
-   * loaded mesh; only photoreal tiles need `sampleHeight`, which renders depth
-   * and compiles its shaders on first use (a freeze of up to 1.9 s at load).
-   */
-  function surfaceHeight(record, entity) {
+  function anchorFor(record, entity, budget) {
+    if (entity.gevAlprCanvasPosition) return entity.gevAlprCanvasPosition;
    const scene = state.viewer.scene;
    const location = Cesium.Cartographic.fromDegrees(
      record.longitude,
      record.latitude,
    );
-    if (scene.globe?.show) return scene.globe.getHeight?.(location);
-    if (!scene.sampleHeightSupported) return undefined;
-    try {
-      return scene.sampleHeight(location, [entity]);
-    } catch {
-      /* streaming tiles */
-      return undefined;
-    }
-  }
-
-  /** The anchor a paint can have without sampling, or null while it waits for one. */
-  function anchorFor(record, entity) {
-    if (entity.gevAlprCanvasPosition) return entity.gevAlprCanvasPosition;
-    const scene = state.viewer.scene;
-    const answer = surfaceAnswers.get(record.id);
-    if (
-      answer?.latitude === record.latitude &&
-      answer.longitude === record.longitude
-    ) {
-      setAnchor(record, entity, answer.height);
-      if (answer.checked)
-        entity.gevAlprSurfaceCheckedFor = entity.gevAlprCanvasPosition;
-      return entity.gevAlprCanvasPosition;
-    }
-    // A floor-placed marker anchors where its native badge sits. A marker
-    // still waiting for its floor reads the terrain globe, or on photoreal
-    // tiles waits for sampleAnchors().
+    // A floor-placed marker anchors where its native badge sits; only a
+    // marker still waiting for its floor samples the rendered surface, and
+    // each paint samples a few at most (each sample is a depth render).
    let height;
    const floor = services.groundFloor.cachedGroundFloor(
      record.latitude,
      record.longitude,
    );
    if (validAlprGroundHeight(floor)) height = floor + MARKER_FLOOR_LIFT_M;
-    else if (scene.globe.show)
-      height = scene.globe.getHeight?.(
-        Cesium.Cartographic.fromDegrees(record.longitude, record.latitude),
-      );
+    else if (scene.sampleHeightSupported) {
+      if (budget.samples <= 0) return null;
+      budget.samples -= 1;
+      try {
+        height = scene.sampleHeight(location, [entity]);
+      } catch {
+        /* streaming tiles */
+      }
+    }
+    if (!validAlprGroundHeight(height) && scene.globe.show)
+      height = scene.globe.getHeight?.(location);
    if (!validAlprGroundHeight(height)) return null;
    setAnchor(record, entity, height);
    return entity.gevAlprCanvasPosition;
@@ -203,19 +158,14 @@ export function createAlprOverlay({
  }

  /**
-   * Sample the rendered surface for the overlay cameras, outside the paint.
-   *
-   * A camera with no floor yet gets its anchor from a sample. An anchored one
-   * is checked against the surface once: floors come from ~111 m cells, so on
-   * a slope a badge could float or sink by tens of metres. Checks run only
-   * while the camera is still and tiles have settled, and samples far outside
-   * the floor prior (a roof or a streaming tile) are rejected. Each frame
-   * takes SURFACE_SAMPLES_PER_FRAME samples, so no frame carries the whole
-   * cohort; sampling inside paint() put up to six depth renders in one frame.
+   * Replace floor anchors with the rendered surface under each overlay camera.
+   * Floors come from ~111 m cells, so on a slope a badge could float or sink
+   * by tens of metres. Runs only while the camera is still and tiles have
+   * settled, a few depth samples per paint, and each anchor at most once;
+   * samples far outside the floor prior (a roof or a streaming tile) are
+   * rejected. Returns whether anchors remain to check.
   */
-  function sampleAnchors() {
-    sampling = false;
-    if (destroyed || !state.enabled) return;
+  function refineAnchors(budget) {
    const camera = state.viewer.camera;
    const scene = state.viewer.scene;
    const still =
@@ -238,41 +188,27 @@ export function createAlprOverlay({
        position: Cesium.Cartesian3.clone(camera.positionWC),
        direction: Cesium.Cartesian3.clone(camera.directionWC),
      };
-    const canSample = scene.globe?.show || scene.sampleHeightSupported;
-    let samples = SURFACE_SAMPLES_PER_FRAME,
-      pending = false,
-      progressed = false,
-      moved = false;
-    // Cameras with no anchor come first: they are not on the overlay yet.
-    for (const record of records) {
-      const entity = state.dataSource.entities.getById(record.id);
-      if (!entity || entity.gevAlprCanvasPosition) continue;
-      // The floor may have resolved since the paint that found none.
-      if (anchorFor(record, entity)) moved = true;
-      else if (!canSample || samples <= 0) pending = true;
-      else {
-        samples -= 1;
-        const sample = surfaceHeight(record, entity);
-        if (validAlprGroundHeight(sample)) {
-          setAnchor(record, entity, sample);
-          rememberSurface(record, sample, false);
-          moved = progressed = true;
-        } else pending = true;
-      }
-    }
+    if (!scene.sampleHeightSupported) return false;
+    let pending = false;
    for (const record of records) {
      const entity = state.dataSource.entities.getById(record.id);
      const anchor = entity?.gevAlprCanvasPosition;
-      if (!anchor || !canSample || entity.gevAlprSurfaceCheckedFor === anchor)
-        continue;
-      if (!still || !surfaceSettled(scene) || samples <= 0) {
+      if (!anchor || entity.gevAlprSurfaceCheckedFor === anchor) continue;
+      if (!still || !surfaceSettled(scene) || budget.samples <= 0) {
        pending = true;
        continue;
      }
-      samples -= 1;
-      progressed = true;
-      const sample = surfaceHeight(record, entity);
-      let height = Cesium.Cartographic.fromCartesian(anchor).height;
+      budget.samples -= 1;
+      let sample;
+      try {
+        sample = scene.sampleHeight(
+          Cesium.Cartographic.fromDegrees(record.longitude, record.latitude),
+          [entity],
+        );
+      } catch {
+        /* streaming tiles */
+      }
+      const current = Cesium.Cartographic.fromCartesian(anchor).height;
      const floor = services.groundFloor.cachedGroundFloor(
        record.latitude,
        record.longitude,
@@ -282,43 +218,21 @@ export function createAlprOverlay({
        (!validAlprGroundHeight(floor) ||
          (sample >= floor - SURFACE_BELOW_FLOOR_M &&
            sample <= floor + SURFACE_ABOVE_FLOOR_M));
-      if (accepted && Math.abs(sample + MARKER_FLOOR_LIFT_M - height) > 1) {
-        height = sample + MARKER_FLOOR_LIFT_M;
-        setAnchor(record, entity, height);
-        moved = true;
-      }
+      if (accepted && Math.abs(sample + MARKER_FLOOR_LIFT_M - current) > 1)
+        setAnchor(record, entity, sample + MARKER_FLOOR_LIFT_M);
      entity.gevAlprSurfaceCheckedFor = entity.gevAlprCanvasPosition;
-      // A surface that did not answer is asked again after a rebuild.
-      if (validAlprGroundHeight(sample)) rememberSurface(record, height, true);
      if (entity.id === state.selectedId)
        entity.gevAlprDisplayPosition = entity.gevAlprCanvasPosition;
    }
-    if (moved) requestPaint();
-    if (!pending || Date.now() >= retryUntil) return;
-    // Take the next ration on the next frame; when nothing could be sampled
-    // (camera moving, tiles streaming, no floor yet) look again in 250 ms.
-    if (progressed) scheduleSampling();
-    else if (!retryTimer)
-      retryTimer = setTimeout(() => {
-        retryTimer = null;
-        scheduleSampling();
-      }, 250);
-  }
-
-  function scheduleSampling() {
-    if (sampling || destroyed) return;
-    sampling = true;
-    requestFrame(sampleAnchors);
+    return pending;
  }

  function paint({ ctx, width, height, keyhole, occluder }) {
    hits = [];
    if (!state.enabled || destroyed) return;
-    let waiting = false;
+    let unresolved = false;
    const painted = [];
-    const canSample =
-      state.viewer.scene.globe?.show ||
-      state.viewer.scene.sampleHeightSupported;
+    const budget = { samples: ANCHOR_SAMPLES_PER_PAINT };
    for (const record of records) {
      const entity = state.dataSource.entities.getById(record.id);
      if (!entity) continue;
@@ -332,14 +246,12 @@ export function createAlprOverlay({
        nativeVisible(entity, true);
        continue;
      }
-      const anchor = anchorFor(record, entity);
+      const anchor = anchorFor(record, entity, budget);
      if (!anchor) {
        nativeVisible(entity, true);
-        waiting = true;
+        unresolved = true;
        continue;
      }
-      if (canSample && entity.gevAlprSurfaceCheckedFor !== anchor)
-        waiting = true;
      canvasOwned(entity, true);
      if (occluder && !occluder.isPointVisible(anchor)) {
        setShown(entity, false);
@@ -423,9 +335,15 @@ export function createAlprOverlay({
      ctx.restore();
      hits.push({ id: record.id, x: origin.x, y: origin.y, radius: size / 2 });
    }
-    // Anchors still to find or to check are sampled after this paint, a few
-    // per frame, never inside it.
-    if (waiting && !retryTimer && Date.now() < retryUntil) scheduleSampling();
+    const refining = refineAnchors({
+      samples: Math.min(budget.samples, SURFACE_SAMPLES_PER_PAINT),
+    });
+    if ((unresolved || refining) && !retryTimer && Date.now() < retryUntil) {
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        requestPaint();
+      }, 250);
+    }
  }

  return {
@@ -45,10 +45,8 @@ function harness(t, count = 2, { floor = null } = {}) {
    active,
    removed = 0,
    paints = 0;
-  const frames = [];
  const overlay = createAlprOverlay({
    state,
-    requestFrame: (step) => frames.push(step),
    services: {
      groundFloor: { cachedGroundFloor: () => floor },
      overlays: {
@@ -108,12 +106,6 @@ function harness(t, count = 2, { floor = null } = {}) {
    entities,
    draw,
    paint: (occluder) => paint({ ctx, width: 800, height: 600, occluder }),
-    /** Run the sampling step queued for the next animation frame, if any. */
-    frame() {
-      const step = frames.shift();
-      step?.();
-      return Boolean(step);
-    },
    mapChanged() {
      mapListener({ detail: { status: 'ready' } });
    },
@@ -251,149 +243,41 @@ test('overlay glyphs and native badges shrink alike with distance', () => {
  assert.ok(Math.abs(markerScale(20_250) - 0.8) < 1e-9);
 });

-/** A photoreal scene: no globe, the rendered surface read by depth samples. */
-function photoreal(h, heightAt = () => 172) {
-  const scene = h.state.viewer.scene;
-  h.state.viewer.camera.directionWC = Cesium.Cartesian3.UNIT_X;
-  scene.globe.show = false;
-  scene.sampleHeightSupported = true;
-  scene.primitives = { length: 0, get: () => null };
-  const sampled = [];
-  scene.sampleHeight = (carto) => {
-    sampled.push(carto);
-    return heightAt(Cesium.Math.toDegrees(carto.latitude));
-  };
-  return sampled;
-}
-
-const anchorHeight = (h, id) =>
-  Cesium.Cartographic.fromCartesian(
-    h.entities.getById(id).gevAlprCanvasPosition,
-  ).height;
-
-/** Run sampling frames until none is queued, waiting out the 250 ms look-again. */
-function settle(t, h) {
-  for (let i = 0; i < 400; i++) if (!h.frame()) t.mock.timers.tick(250);
-}
-
 test('a still view replaces floor anchors with the rendered surface, within the floor window', (t) => {
  // Floors come from ~111 m cells; on a slope a badge floated above the mesh.
-  t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
  const h = harness(t, 2, { floor: 150 });
-  const sampled = photoreal(h, (latitude) => (latitude > 30.00005 ? 400 : 172));
+  const scene = h.state.viewer.scene;
+  const camera = h.state.viewer.camera;
+  camera.directionWC = Cesium.Cartesian3.UNIT_X;
+  scene.sampleHeightSupported = true;
+  scene.primitives = { length: 0, get: () => null };
+  let samples = 0;
+  scene.sampleHeight = (carto) => {
+    samples++;
+    return Cesium.Math.toDegrees(carto.latitude) > 30.00005 ? 400 : 172;
+  };
  h.overlay.sync(h.records);
  h.paint();
-  assert.ok(
-    Math.abs(anchorHeight(h, 'camera:0') - 151.5) < 0.01,
-    'floor anchor first',
-  );
-  assert.equal(h.frame(), true, 'the paint queued a sampling frame');
+  const height = (id) =>
+    Cesium.Cartographic.fromCartesian(
+      h.entities.getById(id).gevAlprCanvasPosition,
+    ).height;
  assert.equal(
-    sampled.length,
+    samples,
    0,
    'no depth samples while the camera may still be moving',
  );
-  settle(t, h);
+  assert.ok(Math.abs(height('camera:0') - 151.5) < 0.01, 'floor anchor first');
+  h.paint();
  assert.ok(
-    Math.abs(anchorHeight(h, 'camera:0') - 173.5) < 0.01,
+    Math.abs(height('camera:0') - 173.5) < 0.01,
    'rendered surface once still',
  );
  assert.ok(
-    Math.abs(anchorHeight(h, 'camera:1') - 151.5) < 0.01,
+    Math.abs(height('camera:1') - 151.5) < 0.01,
    'a rooftop-height sample is rejected',
  );
-  assert.equal(sampled.length, 2);
+  const taken = samples;
  h.paint();
-  settle(t, h);
-  assert.equal(sampled.length, 2, 'each anchor is checked once');
-});
-
-test('a paint never samples the surface; frames take one sample each', (t) => {
-  // Sampling inside paint() put up to six depth renders into one frame, and
-  // the first of them compiles shaders: a freeze of 0.8 to 1.9 s at load.
-  t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
-  const h = harness(t, 8);
-  const sampled = photoreal(h);
-  h.overlay.sync(h.records);
-  h.paint();
-  h.paint();
-  assert.equal(sampled.length, 0, 'no sample inside a paint');
-  assert.equal(h.draw.length, 0, 'unanchored cameras keep their native badge');
-  for (let taken = 1; taken <= 8; taken++) {
-    assert.equal(h.frame(), true);
-    assert.equal(sampled.length, taken, 'one sample per frame');
-  }
-  for (const record of h.records)
-    assert.ok(Math.abs(anchorHeight(h, record.id) - 172) < 0.01);
-  h.paint();
-  assert.ok(h.draw.length > 0, 'anchored cameras paint on the overlay');
-});
-
-test('a terrain globe is read from its mesh, never depth-sampled', (t) => {
-  t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
-  const h = harness(t, 3, { floor: 150 });
-  const sampled = photoreal(h);
-  const scene = h.state.viewer.scene;
-  scene.globe.show = true;
-  scene.globe.tilesLoaded = true;
-  let reads = 0;
-  scene.globe.getHeight = () => {
-    reads++;
-    return 172;
-  };
-  h.overlay.sync(h.records);
-  h.paint();
-  settle(t, h);
-  assert.equal(sampled.length, 0);
-  assert.equal(reads, 3);
-  // The same anchor the depth sample gave: the surface plus the marker lift.
-  for (const record of h.records)
-    assert.ok(Math.abs(anchorHeight(h, record.id) - 173.5) < 0.01);
-});
-
-test('surface answers outlive rebuilt markers and a re-enable, until the map changes', (t) => {
-  t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
-  const h = harness(t, 4, { floor: 150 });
-  const sampled = photoreal(h);
-  h.overlay.sync(h.records);
-  h.paint();
-  settle(t, h);
-  assert.equal(sampled.length, 4);
-  const before = h.records.map((record) => anchorHeight(h, record.id));
-
-  // A refresh or a toggle removes the entities and builds new ones.
-  const rebuild = () => {
-    h.overlay.clear();
-    h.entities.removeAll();
-    for (const record of h.records)
-      h.entities.add({
-        id: record.id,
-        billboard: { image: 'fallback', show: true },
-        polyline: { show: true },
-        polygon: { show: true },
-      });
-    h.overlay.sync(h.records);
-    h.paint();
-    settle(t, h);
-  };
-  rebuild();
-  h.state.enabled = false;
-  h.overlay.clear();
-  h.state.enabled = true;
-  rebuild();
-  assert.equal(sampled.length, 4, 'no camera is sampled again');
-  assert.deepEqual(
-    h.records.map((record) => anchorHeight(h, record.id)),
-    before,
-  );
-
-  // A camera that moved is a different question.
-  h.records[0] = { ...h.records[0], latitude: h.records[0].latitude + 0.001 };
-  rebuild();
-  assert.equal(sampled.length, 5);
-
-  h.mapChanged();
-  h.paint();
-  settle(t, h);
-  assert.equal(sampled.length, 9, 'a new map surface is sampled afresh');
+  assert.equal(samples, taken, 'each anchor is checked once');
 });
@@ -66,15 +66,14 @@ export const MAX_CANVAS_FRUSTUMS = 64;
 /** Metres a floor-placed marker sits above its resolved ground cell. */
 export const MARKER_FLOOR_LIFT_M = 1.5;

-/** Rendered-surface samples one frame may take (on photoreal tiles each is a
- * depth render of several milliseconds, so they are spread over frames). */
-export const SURFACE_SAMPLES_PER_FRAME = 1;
-/** Surface answers kept by camera id, so a refresh or re-enable asks nothing. */
-export const REMEMBERED_ANCHORS = 2048;
+/** Rendered-surface samples one overlay paint may take (each is a depth render). */
+export const ANCHOR_SAMPLES_PER_PAINT = 4;

 /** Accepted rendered-surface window around a floor cell (a cut or an embankment
 * sits within it; a rooftop or an unstreamed tile usually does not). */
 export const SURFACE_BELOW_FLOOR_M = 30;
+/** Rendered-surface refinements per paint while the camera is still. */
+export const SURFACE_SAMPLES_PER_PAINT = 2;
 export const SURFACE_ABOVE_FLOOR_M = 40;

 /** OSM attribution may collapse after five seconds; full credit stays in Data attribution. */
@@ -182,22 +182,7 @@ export function createPanel({ state: layerState, parts }) {
      : null;
  }

-  /** The credit line: the photographer, and an open photo's licence. A
-   *  photo whose answer names no photographer shows no photographer. */
-  function photoCredit(photo) {
-    if (photo.licence)
-      return photo.photographer
-        ? t('Photo: {photographer} · {licence}', {
-            photographer: photo.photographer,
-            licence: photo.licence,
-          })
-        : t('Photo · {licence}', { licence: photo.licence });
-    return photo.photographer
-      ? t('Photo © {photographer}', { photographer: photo.photographer })
-      : '';
-  }
-
-  /** The subject's photo with its credit, or null. The subject
+  /** The tracked airliner's photo with its credit, or null. The subject
   *  refresh resolves it; only the subject it was resolved for shows it. */
  function presentPhoto(subject) {
    const held = layerState.subjectPhoto;
@@ -213,7 +198,10 @@ export function createPanel({ state: layerState, parts }) {
      width: photo.width ?? null,
      height: photo.height ?? null,
      link: photo.link,
-      credit: photoCredit(photo),
+      // A photo whose answer names no photographer shows no credit line.
+      credit: photo.photographer
+        ? t('Photo © {photographer}', { photographer: photo.photographer })
+        : '',
    };
  }

@@ -113,52 +113,7 @@ test('the Contacts view has no photo without one, or with another subject’s',
  );
 });

-test('the selected vessel shows its own photo, by its id', () => {
-  const asked = [];
-  const { resolveSubjectPhoto, subjectFromContext } = createSubject({
-    state: {},
-    services: {
-      flights: {},
-      military: {},
-      vessels: {
-        getVesselPhoto: (id) => {
-          asked.push(id);
-          return id === 'uuid-1' ? PHOTO : null;
-        },
-      },
-      installations: {},
-    },
-    parts: { navigation: { isFlightLayer: () => false } },
-  });
-  assert.deepEqual(
-    resolveSubjectPhoto({ layerId: 'ais-live-vessels', id: 'uuid-1' }),
-    PHOTO,
-  );
-  assert.equal(
-    resolveSubjectPhoto({ layerId: 'ais-live-vessels', id: 'uuid-2' }),
-    null,
-  );
-  assert.deepEqual(asked, ['uuid-1', 'uuid-2']);
-  const vessel = (label, mmsi) =>
-    subjectFromContext({
-      layerId: 'ais-live-vessels',
-      id: 'ais-uuid-1',
-      label,
-      latitude: 38.3,
-      longitude: -123.05,
-      properties: { vesselId: 'uuid-1', mmsi },
-    });
-  assert.equal(
-    vessel('USCGC SOCKEYE', '366999709').label,
-    'USCGC SOCKEYE · MMSI 366999709',
-  );
-  assert.equal(vessel('USCGC SOCKEYE', '366999709').id, 'uuid-1');
-  // A vessel named by its MMSI, or without one, is not given it twice.
-  assert.equal(vessel('MMSI 366999709', '366999709').label, 'MMSI 366999709');
-  assert.equal(vessel('USCGC SOCKEYE', null).label, 'USCGC SOCKEYE');
-});
-
-test('only the tracked flight has a flight photo: not an installation, a military aircraft or another flight', () => {
+test('only the tracked flight has a photo: not a vessel, an installation, a military aircraft or another flight', () => {
  const tracked = {
    layerId: 'flights',
    id: 'abc123',
@@ -406,20 +406,17 @@ export function createSubject({ state: layerState, services, parts, source }) {
  }

  /**
-   * The subject's photo, for the Contacts panel: the tracked airliner's
-   * Planespotters photo, or the selected vessel's Open Vessel Photos photo.
+   * The tracked airliner's Planespotters photo, for the Contacts panel.
   *
-   * The flights layer looks photos up only for the plane it tracks, the
-   * vessel layer only for the vessel selected; an installation, a military
-   * aircraft or an untracked flight has none.
+   * Only the flights layer looks photos up, and only for the plane it tracks;
+   * a vessel, an installation, a military aircraft or an untracked flight has
+   * none.
   * @param {{layerId: string, id: string}|null} subject Current subject.
   * @param {?object} [tracked] The subject's tracked descriptor, when the
   *   caller already has it.
-   * @returns {?{src: string, width: ?number, height: ?number, photographer: string, link: string, licence?: string}}
+   * @returns {?{src: string, width: ?number, height: ?number, photographer: string, link: string}}
   */
  function resolveSubjectPhoto(subject, tracked = trackedSubjectOf(subject)) {
-    if (subject?.layerId === 'ais-live-vessels')
-      return aisLiveVesselsLayer.getVesselPhoto?.(subject.id) ?? null;
    return subject?.layerId === 'flights' && tracked?.photo
      ? tracked.photo
      : null;
@@ -520,15 +517,10 @@ export function createSubject({ state: layerState, services, parts, source }) {
    const latitude = Number(record.latitude);
    const longitude = Number(record.longitude);
    if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) return null;
-    // A vessel reads as its name and MMSI; a vessel named by its MMSI alone
-    // already carries it.
-    const label = String(record.label || record.id);
-    const mmsi = String(record.properties?.mmsi || '');
    return {
      layerId: record.layerId,
      id: record.properties?.vesselId || record.id,
-      // i18n-ignore: MMSI is a radio identity code, as on the vessel card
-      label: mmsi && !label.includes(mmsi) ? `${label} · MMSI ${mmsi}` : label,
+      label: record.label || record.id,
      memberNames: record.properties?.memberNames || [],
      position: Cesium.Cartesian3.fromDegrees(longitude, latitude, 0),
    };
@@ -260,21 +260,6 @@ export function createGeometry({ state: layerState, services, parts, source }) {
    return Math.max(PROBE_MIN_RANGE_M, hitDistance - PROBE_CLEARANCE_M);
  }

-  /**
-   * Distance along a pitched-down view axis to flat ground at the mount's own
-   * ground height, or null for an axis at or above the horizon.
-   * @param {number} mountHeightM Mount height above its ground.
-   * @param {number} pitchDeg Axis pitch (negative looks down).
-   * @returns {number|null}
-   */
-
-  function flatGroundAxisDistance(mountHeightM, pitchDeg) {
-    const height = Number(mountHeightM);
-    const pitch = Number(pitchDeg);
-    if (!Number.isFinite(height) || height <= 0 || !(pitch < 0)) return null;
-    return height / Math.sin(Cesium.Math.toRadians(Math.min(89, -pitch)));
-  }
-
  /**
   * Converts a computeFrustumGeometry result into the Cartesian3 positions the
   * entities consume. Fresh objects per call (geometry updates are rare —
@@ -631,14 +616,10 @@ export function createGeometry({ state: layerState, services, parts, source }) {
   * range, clamp the plane's effective range just short of the first hit so the
   * "big and dramatic" true end cap never clips into downtown buildings.
   *
-   * On a globe map it also picks the globe's terrain along the same axis
-   * (flat ground at the mount's ground when terrain is missed or met beyond
-   * the range) and clamps at the nearer end. These are the ONLY raycasts in the
-   * whole CCTV subsystem — once per activation, never per-frame (the
-   * zero-raycast invariant applies to steady state). The per-camera range
-   * slider overrides the clamp: a user-set rangeScale skips the probe
-   * entirely. A miss on the photoreal stack or a probe failure keeps the
-   * unclamped range.
+   * This is the ONLY raycast in the whole CCTV subsystem — once per activation,
+   * never per-frame (the zero-raycast invariant applies to steady state). The
+   * per-camera range slider overrides the clamp: a user-set rangeScale skips the
+   * probe entirely. Probe failure/miss keeps the unclamped range.
   * @param {Object} record - Camera record being activated.
   */

@@ -665,33 +646,9 @@ export function createGeometry({ state: layerState, services, parts, source }) {
      for (const runtime of layerState._projectionEntities) {
        if (runtime?.planeEntity) exclude.push(runtime.planeEntity);
      }
-      const ray = new Cesium.Ray(mountPos, dir);
-      // pickFromRay hits only primitives (the photoreal tiles), never the
-      // globe: on a globe map the ray runs on through the Earth and can meet
-      // a primitive thousands of kilometres away, which blocks nothing. Such
-      // a hit or none left the plane at the full nominal range, about a
-      // kilometre wide and hundreds of metres up. A hit at or beyond the range
-      // counts as none. On a globe map the axis also ends on the globe's
-      // terrain, the nearer of that and any primitive hit (a primitive behind
-      // a hill the axis has already entered blocks nothing). Terrain still
-      // loading at a coarse level can be missed or met beyond the range; then
-      // flat ground at the mount's own ground stands in for it.
-      const inRange = (distance) =>
-        Number.isFinite(distance) && distance > 0 && distance < camera.rangeM;
-      const hit = scene.pickFromRay(ray, exclude)?.position;
-      const hitDist = hit ? Cesium.Cartesian3.distance(mountPos, hit) : NaN;
-      const distances = inRange(hitDist) ? [hitDist] : [];
-      if (scene.globe?.show) {
-        const terrain = scene.globe.pick(ray, scene);
-        const terrainDist = terrain
-          ? Cesium.Cartesian3.distance(mountPos, terrain)
-          : NaN;
-        const ground = inRange(terrainDist)
-          ? terrainDist
-          : flatGroundAxisDistance(camera.mountHeightM, camera.pitchDeg);
-        if (Number.isFinite(ground) && ground > 0) distances.push(ground);
-      }
-      const dist = distances.length ? Math.min(...distances) : null;
+      const hit = scene.pickFromRay(new Cesium.Ray(mountPos, dir), exclude);
+      if (!hit?.position) return;
+      const dist = Cesium.Cartesian3.distance(mountPos, hit.position);
      record.probeClampRangeM = activationProbeClampRange(camera.rangeM, dist);
    } catch {
      // probe failure → keep the unclamped range
@@ -874,7 +831,6 @@ export function createGeometry({ state: layerState, services, parts, source }) {
    hasShippedFootprint,
    footprintPose,
    activationProbeClampRange,
-    flatGroundAxisDistance,
    frustumCartesians,
    frustumFrameEcef,
    applyFrustumGeometry,
@@ -73,7 +73,6 @@ export function createCctvLayer({ services, source }) {
      deriveCalBadge: parts.calibration.deriveCalBadge,
      computeFrustumGeometry: parts.geometry.computeFrustumGeometry,
      activationProbeClampRange: parts.geometry.activationProbeClampRange,
-      flatGroundAxisDistance: parts.geometry.flatGroundAxisDistance,
      frameSignatureFromPixels: parts.frames.frameSignatureFromPixels,
      _createCctvProjectionPlaneForTest:
        parts.testing._createCctvProjectionPlaneForTest,
@@ -5,6 +5,13 @@ import {
  FLOOR_WARM_PER_POLL,
  TRANSIT_POLL_MS,
  HEIGHT_SAMPLE_MAX_ALTITUDE_M,
+  TERRAIN_HEIGHT_CACHE_MAX,
+  TERRAIN_HEIGHT_FRESH_MS,
+  TERRAIN_NEED,
+  TERRAIN_READ_BUDGET_MS,
+  TERRAIN_READ_WINDOW_MS,
+  TERRAIN_REFRESH_BUDGET_MS,
+  TERRAIN_SETTLE_MS,
  withinViewBounds,
 } from './policy.js';

@@ -47,35 +54,190 @@ export function createHeight({ state, services, parts }) {
    return cameraAltitude() <= HEIGHT_SAMPLE_MAX_ALTITUDE_M;
  }

+  // --- Loaded-terrain heights ---
+  // `globe.getHeight` casts a ray against the mesh of the tile drawn under the
+  // point. The fleet asks for every fix of every trail on each reread, so the
+  // answers are kept per point and re-read on a time budget; see policy.js.
+  const terrainPoint = new Cesium.Cartographic();
+  /** Point key → `{ h, at }`: the height read there and when. */
+  const terrainHeights = new Map();
+  /** Floor-cell key → the last height read anywhere in that cell. */
+  const terrainCells = new Map();
+  let terrainWindowAt = -Infinity;
+  let terrainReadMs = 0;
+  let terrainRefreshMs = 0;
+  // Per need (history, path): the oldest read among the points this window
+  // left for later, and the bound the next window re-reads up to.
+  const terrainDeferredAt = [Infinity, Infinity];
+  const terrainRefreshUpTo = [Infinity, Infinity];
+  /** Points a pass left unread or due a re-read; see rereadFloors. */
+  let terrainWaiting = 0;
+  /** When the camera last moved or the globe was last loading tiles. */
+  let terrainChangedAt = -Infinity;
+  let cameraLon = NaN,
+    cameraLat = NaN,
+    cameraHeight = NaN;
+  const terrainStats = { reads: 0, reused: 0, deferred: 0, borrowed: 0 };
+  /** The globe and terrain provider the kept heights were read from. */
+  let terrainGlobeRead = null,
+    terrainProviderRead = null;
+
+  /** A number unique to a point on a `scale`-per-degree grid. */
+  function gridKey(lat, lon, scale) {
+    return (
+      (Math.round(lat * scale) + 90 * scale) * (360 * scale + 1) +
+      Math.round(lon * scale) +
+      180 * scale
+    );
+  }
+
+  function clearTerrainHeights() {
+    terrainHeights.clear();
+    terrainCells.clear();
+    terrainWindowAt = -Infinity;
+    terrainReadMs = terrainRefreshMs = 0;
+    terrainDeferredAt.fill(Infinity);
+    terrainRefreshUpTo.fill(Infinity);
+    terrainWaiting = 0;
+    terrainChangedAt = -Infinity;
+    cameraLon = cameraLat = cameraHeight = NaN;
+  }
+
+  /**
+   * The loaded terrain's height at a point, or undefined when it is not
+   * known yet. A point read within the reuse time answers from memory, and
+   * so does one read after the camera and the globe's tiles had settled: the
+   * surface under it cannot have changed since. Past
+   * the window's budget a held point keeps its last height and a new point
+   * borrows its floor cell's. `need` (TERRAIN_NEED) ranks the request: a
+   * vehicle's own position is read regardless, since a marker without a
+   * height is not drawn; the path a marker is drawn along comes next; a trail
+   * nobody is looking at takes what is left. Requests come in the same order
+   * every pass, so re-reads go to the longest-held points first: otherwise
+   * the first few would be re-read forever and the rest never.
+   */
+  function terrainHeight(globe, lat, lon, need) {
+    const now = performance.now();
+    if (now - terrainWindowAt >= TERRAIN_READ_WINDOW_MS) {
+      for (let i = 0; i < terrainDeferredAt.length; i++) {
+        terrainRefreshUpTo[i] = terrainDeferredAt[i];
+        terrainDeferredAt[i] = Infinity;
+      }
+      terrainWindowAt = now;
+      terrainReadMs = terrainRefreshMs = 0;
+      // The globe redraws a point from another tile only after the camera
+      // moves or a tile arrives.
+      const camera = state._viewer?.camera?.positionCartographic;
+      if (
+        globe.tilesLoaded === false ||
+        camera?.longitude !== cameraLon ||
+        camera?.latitude !== cameraLat ||
+        camera?.height !== cameraHeight
+      ) {
+        terrainChangedAt = now;
+        cameraLon = camera?.longitude;
+        cameraLat = camera?.latitude;
+        cameraHeight = camera?.height;
+      }
+    }
+    const key = gridKey(lat, lon, 1e5);
+    const held = terrainHeights.get(key);
+    if (
+      held &&
+      (now - held.at < TERRAIN_HEIGHT_FRESH_MS ||
+        held.at >= terrainChangedAt + TERRAIN_SETTLE_MS)
+    ) {
+      terrainStats.reused++;
+      return held.h;
+    }
+    const cellKey = gridKey(lat, lon, 1e3);
+    const marker = need === TERRAIN_NEED.MARKER;
+    // History may use a quarter of each budget; the path the rest.
+    const share = need === TERRAIN_NEED.HISTORY ? 0.25 : 1;
+    const affordable =
+      marker && !held
+        ? true
+        : terrainReadMs < TERRAIN_READ_BUDGET_MS * (marker ? 1 : share) &&
+          (!held ||
+            marker ||
+            (terrainRefreshMs < TERRAIN_REFRESH_BUDGET_MS * share &&
+              held.at <= terrainRefreshUpTo[need]));
+    if (!affordable) {
+      terrainStats.deferred++;
+      if (held) {
+        if (!marker && held.at < terrainDeferredAt[need])
+          terrainDeferredAt[need] = held.at;
+        terrainWaiting++;
+        return held.h;
+      }
+      const borrowed = terrainCells.get(cellKey);
+      if (borrowed !== undefined) {
+        terrainStats.borrowed++;
+        return borrowed;
+      }
+      terrainWaiting++;
+      return undefined;
+    }
+    Cesium.Cartographic.fromDegrees(lon, lat, 0, terrainPoint);
+    const rendered = globe.getHeight(terrainPoint);
+    const spent = performance.now() - now;
+    terrainReadMs += spent;
+    if (held) terrainRefreshMs += spent;
+    terrainStats.reads++;
+    // A tile that left the globe keeps the height it gave.
+    if (!Number.isFinite(rendered)) return held?.h;
+    if (held) {
+      held.h = rendered;
+      held.at = now;
+    } else {
+      if (terrainHeights.size >= TERRAIN_HEIGHT_CACHE_MAX) {
+        let drop = TERRAIN_HEIGHT_CACHE_MAX >> 2;
+        for (const old of terrainHeights.keys()) {
+          terrainHeights.delete(old);
+          if (--drop <= 0) break;
+        }
+        terrainCells.clear();
+      }
+      terrainHeights.set(key, { h: rendered, at: now });
+    }
+    terrainCells.set(cellKey, rendered);
+    return rendered;
+  }
+
  /**
   * The floor under a vehicle, and the best fallback if its own cell is cold.
   * @param {number} lat
   * @param {number} lon
+   * @param {?object} [entry] The vehicle, for a fixture floor.
+   * @param {number} [need] How much the answer matters; see TERRAIN_NEED.
   * @returns {{cell: string, height: number|null, prior: number|null}}
   */
-  const terrainPoint = new Cesium.Cartographic();
-  function requestHeight(lat, lon, entry = null) {
+  function requestHeight(lat, lon, entry = null, need = TERRAIN_NEED.PATH) {
    const coarse = coarseFloorCoord(lat, lon);
    const cell = `${coarse.lat},${coarse.lon}`;
    const fixtureFloor =
      entry?.qaFloorM ?? state._qaFixtureFloors?.get(entry?.key);
    if (Number.isFinite(fixtureFloor))
      return { cell, height: fixtureFloor, prior: null };
-    // On a terrain globe, use the loaded surface under the marker. This is
-    // synchronous cache work and does not launch a terrain request.
+    // On a terrain globe, use the loaded surface under the marker. This reads
+    // tiles already loaded and does not launch a terrain request.
    const globe = state._viewer?.scene?.globe;
+    const provider = state._viewer?.terrainProvider;
+    // A height belongs to the terrain it was read from. Checked before the
+    // flat-globe answer, so terrain → flat → terrain starts afresh too.
+    if (globe !== terrainGlobeRead || provider !== terrainProviderRead) {
+      clearTerrainHeights();
+      terrainGlobeRead = globe;
+      terrainProviderRead = provider;
+    }
    if (globe?.show === true) {
-      Cesium.Cartographic.fromDegrees(lon, lat, 0, terrainPoint);
-      const rendered = globe.getHeight?.(terrainPoint);
-      const flat =
-        state._viewer?.terrainProvider instanceof
-        Cesium.EllipsoidTerrainProvider;
-      if (Number.isFinite(rendered) || flat)
-        return {
-          cell,
-          height: (flat ? 0 : rendered) + GROUND_FLOOR_LIFT_M,
-          prior: null,
-        };
+      if (provider instanceof Cesium.EllipsoidTerrainProvider)
+        return { cell, height: GROUND_FLOOR_LIFT_M, prior: null };
+      const rendered = globe.getHeight
+        ? terrainHeight(globe, lat, lon, need)
+        : undefined;
+      if (Number.isFinite(rendered))
+        return { cell, height: rendered + GROUND_FLOOR_LIFT_M, prior: null };
    }
    const floor = cachedGroundFloor(lat, lon);
    if (Number.isFinite(floor)) {
@@ -107,6 +269,7 @@ export function createHeight({ state, services, parts }) {
  function rereadFloors() {
    state._floorTimer = null;
    if (!state._enabled) return;
+    terrainWaiting = 0;
    const onGround = nearGround(),
      candidates = [];
    const entries = [...state._vehicles.values()].filter(
@@ -120,6 +283,13 @@ export function createHeight({ state, services, parts }) {
        Number(b.key === state._selectedKey) -
        Number(a.key === state._selectedKey),
    );
+    // Every vehicle's own position before any trail: the first trails of a
+    // pass must not spend the budget the last markers are waiting on.
+    for (const entry of entries) {
+      const newest = entry.fixes.at(-1);
+      if (newest)
+        requestHeight(newest.lat, newest.lon, entry, TERRAIN_NEED.MARKER);
+    }
    for (const entry of entries) {
      const cells = new Map();
      const collect = (point, answer) => {
@@ -141,7 +311,12 @@ export function createHeight({ state, services, parts }) {
      };
      parts.trails.prepareEntry(entry, collect);
      const newest = entry.fixes.at(-1);
-      const answer = requestHeight(newest.lat, newest.lon, entry);
+      const answer = requestHeight(
+        newest.lat,
+        newest.lon,
+        entry,
+        TERRAIN_NEED.MARKER,
+      );
      entry.heightCell = answer.cell;
      // The selected vehicle's path also offers its history, newest segment
      // first; the vehicle's own cell is read where its newest fix is.
@@ -227,7 +402,12 @@ export function createHeight({ state, services, parts }) {
    for (const entry of entries) parts.trails.prepareEntry(entry);
    parts.rendering.requestVisibility();
    governorRequestRender('transit-floor');
-    if (state._floorAttempts++ < FLOOR_REREAD_ATTEMPTS)
+    // A pass that ran out of terrain budget before reaching every point
+    // comes back for the rest. Each pass reads its budget, and points stop
+    // falling due once the terrain settles, so this ends.
+    const waiting = terrainWaiting;
+    terrainWaiting = 0;
+    if (state._floorAttempts++ < FLOOR_REREAD_ATTEMPTS || waiting > 0)
      state._floorTimer = setTimeout(rereadFloors, FLOOR_REREAD_MS);
  }

@@ -258,6 +438,7 @@ export function createHeight({ state, services, parts }) {
    }
    state._floorAttempts = 0;
    state._heightDirty.clear();
+    clearTerrainHeights();
  }

  return {
@@ -267,5 +448,7 @@ export function createHeight({ state, services, parts }) {
    anchorFloors,
    rereadFloors,
    clear,
+    /** Terrain read counters since the layer was created, for checks. */
+    terrainStats: () => ({ ...terrainStats, held: terrainHeights.size }),
  };
 }
@@ -0,0 +1,390 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createHeight } from './height.js';
+import {
+  FLOOR_REREAD_ATTEMPTS,
+  FLOOR_REREAD_MS,
+  TERRAIN_HEIGHT_CACHE_MAX,
+  TERRAIN_HEIGHT_FRESH_MS,
+  TERRAIN_NEED,
+  TERRAIN_READ_BUDGET_MS,
+  TERRAIN_READ_WINDOW_MS,
+  TERRAIN_REFRESH_BUDGET_MS,
+  TERRAIN_SETTLE_MS,
+} from './policy.js';
+
+const LIFT = 1.5;
+
+/**
+ * A height part over a terrain globe whose every read costs `costMs` of a
+ * clock the test owns. `surface(lat, lon)` is the terrain; `reads` lists the
+ * points actually read.
+ */
+function terrain(t, { costMs = 0, surface = () => 100, provider = {} } = {}) {
+  const clock = { now: 1_000_000 };
+  t.mock.method(performance, 'now', () => clock.now);
+  const reads = [];
+  const world = { surface, costMs };
+  const globe = {
+    show: true,
+    getHeight(point) {
+      const lat = Cesium.Math.toDegrees(point.latitude);
+      const lon = Cesium.Math.toDegrees(point.longitude);
+      reads.push(`${lat.toFixed(5)},${lon.toFixed(5)}`);
+      clock.now += world.costMs;
+      return world.surface(lat, lon);
+    },
+  };
+  const state = {
+    _enabled: true,
+    _selectedKey: null,
+    _vehicles: new Map(),
+    _visible: new Set(),
+    _floorCursor: 0,
+    _floorAttempts: 0,
+    _floorTimer: null,
+    _heightDirty: new Set(),
+    _viewer: {
+      camera: { positionCartographic: { height: 500 } },
+      scene: { globe },
+      terrainProvider: provider,
+    },
+  };
+  const parts = {
+    trails: { prepareEntry() {} },
+    rendering: { requestVisibility() {} },
+  };
+  const height = createHeight({
+    state,
+    services: {
+      render: { governorRequestRender() {} },
+      ground: {
+        coarseFloorCoord: (lat, lon) => ({
+          lat: Number(lat.toFixed(3)),
+          lon: Number(lon.toFixed(3)),
+        }),
+        cachedGroundFloor: () => null,
+        neighborFloorM: () => null,
+        warmGroundFloor() {},
+        GROUND_FLOOR_LIFT_M: LIFT,
+      },
+    },
+    parts,
+  });
+  t.after(() => height.clear());
+  const nextWindow = () => {
+    clock.now += TERRAIN_READ_WINDOW_MS;
+  };
+  return { height, state, parts, globe, world, clock, reads, nextWindow };
+}
+
+test('a point is read from the terrain once and reused until its reuse time passes', (t) => {
+  const { height, reads, clock, world } = terrain(t);
+  const first = height.requestHeight(42.36, -71.06);
+  assert.deepEqual(first, { cell: '42.36,-71.06', height: 100 + LIFT, prior: null });
+  for (let i = 0; i < 500; i++) height.requestHeight(42.36, -71.06);
+  assert.equal(reads.length, 1, '501 requests, one terrain read');
+
+  // A point a metre away is its own point; the same cell does not stand in
+  // for it while the budget allows a read.
+  world.surface = (lat) => (lat > 42.36 ? 140 : 100);
+  assert.equal(height.requestHeight(42.36002, -71.06).height, 140 + LIFT);
+  assert.equal(reads.length, 2);
+
+  // The surface under the first point changed (the globe drew a finer tile).
+  world.surface = () => 120;
+  clock.now += TERRAIN_HEIGHT_FRESH_MS - 1;
+  assert.equal(height.requestHeight(42.36, -71.06).height, 100 + LIFT);
+  clock.now += 1;
+  assert.equal(height.requestHeight(42.36, -71.06).height, 120 + LIFT);
+  assert.equal(reads.length, 3);
+  assert.deepEqual(height.terrainStats(), {
+    reads: 3,
+    reused: 501,
+    deferred: 0,
+    borrowed: 0,
+    held: 2,
+  });
+});
+
+test('terrain that is not loaded yet is not remembered as an answer', (t) => {
+  const { height, reads, world } = terrain(t, { surface: () => undefined });
+  assert.deepEqual(height.requestHeight(42.36, -71.06), {
+    cell: '42.36,-71.06',
+    height: null,
+    prior: null,
+  });
+  assert.equal(height.requestHeight(42.36, -71.06).height, null);
+  assert.equal(reads.length, 2, 'each request asks again');
+  world.surface = () => 12;
+  assert.equal(height.requestHeight(42.36, -71.06).height, 12 + LIFT);
+  assert.equal(height.terrainStats().held, 1);
+});
+
+test('a tile that leaves the globe keeps the height it gave', (t) => {
+  const { height, clock, world } = terrain(t, { surface: () => 30 });
+  assert.equal(height.requestHeight(42.36, -71.06).height, 30 + LIFT);
+  world.surface = () => undefined;
+  clock.now += TERRAIN_HEIGHT_FRESH_MS * 20;
+  assert.equal(height.requestHeight(42.36, -71.06).height, 30 + LIFT);
+});
+
+test('new points stop being read once a window has spent its budget', (t) => {
+  const costMs = 5;
+  const { height, reads, nextWindow } = terrain(t, {
+    costMs,
+    surface: (lat, lon) => Math.round(lon * -1000),
+  });
+  const affordable = Math.ceil(TERRAIN_READ_BUDGET_MS / costMs);
+  // One point per floor cell (0.001° apart), more than the window affords.
+  const answers = [];
+  for (let i = 0; i < affordable + 3; i++)
+    answers.push(height.requestHeight(42.36, -71.06 - i * 0.001).height);
+  assert.equal(reads.length, affordable);
+  assert.deepEqual(
+    answers.slice(affordable),
+    [null, null, null],
+    'a point in a cell never read waits',
+  );
+  assert.ok(reads.length * costMs < TERRAIN_READ_BUDGET_MS + costMs, 'the overrun is one read at most');
+
+  // A new point in a cell that was read borrows that cell's height.
+  const borrowed = height.requestHeight(42.36004, -71.06);
+  assert.equal(borrowed.height, 71060 + LIFT);
+  assert.equal(reads.length, affordable, 'borrowing reads nothing');
+  assert.equal(height.terrainStats().borrowed, 1);
+
+  // The next window reads the points that waited, and the borrower its own.
+  nextWindow();
+  for (let i = affordable; i < affordable + 3; i++)
+    assert.equal(
+      height.requestHeight(42.36, -71.06 - i * 0.001).height,
+      Math.round((-71.06 - i * 0.001) * -1000) + LIFT,
+    );
+  assert.equal(reads.length, affordable + 3);
+});
+
+test("a vehicle's own position is read even when the window is spent", (t) => {
+  const { height, reads } = terrain(t, { costMs: TERRAIN_READ_BUDGET_MS });
+  height.requestHeight(42.36, -71.06);
+  assert.equal(height.requestHeight(42.37, -71.07).height, null, 'a trail point waits');
+  assert.equal(height.requestHeight(42.38, -71.08, null, TERRAIN_NEED.MARKER).height, 100 + LIFT);
+  assert.equal(reads.length, 2);
+});
+
+test('undrawn trail history leaves most of the budget to the paths markers are drawn along', (t) => {
+  const costMs = 1;
+  const { height, reads } = terrain(t, { costMs });
+  // New points, one per floor cell: history first, as a pass offers them.
+  let lon = -71;
+  const ask = (need) => height.requestHeight(42, (lon -= 0.001), null, need).height;
+  const history = Array.from({ length: 30 }, () => ask(TERRAIN_NEED.HISTORY));
+  const read = history.filter((h) => h !== null).length;
+  assert.equal(read, TERRAIN_READ_BUDGET_MS / 4, 'history stops at a quarter of the budget');
+  const path = Array.from({ length: 30 }, () => ask(TERRAIN_NEED.PATH));
+  assert.equal(path.filter((h) => h !== null).length, TERRAIN_READ_BUDGET_MS - read, 'the path takes the rest');
+  assert.equal(ask(TERRAIN_NEED.HISTORY), null);
+  assert.equal(ask(TERRAIN_NEED.MARKER), 100 + LIFT, 'a marker is still read');
+  assert.equal(reads.length, TERRAIN_READ_BUDGET_MS + 1);
+});
+
+test('held points keep their last height while re-reads are over budget, and the longest-held are re-read first so none starves', (t) => {
+  const costMs = TERRAIN_REFRESH_BUDGET_MS / 2;
+  const { height, reads, clock, world, nextWindow } = terrain(t, { surface: () => 50 });
+  const points = Array.from({ length: 40 }, (_, i) => [42.36, -71.06 - i * 0.001]);
+  for (const [lat, lon] of points) height.requestHeight(lat, lon);
+  assert.equal(reads.length, 40);
+
+  world.costMs = costMs;
+  world.surface = () => 80;
+  clock.now += TERRAIN_HEIGHT_FRESH_MS;
+  reads.length = 0;
+  const pass = () => points.map(([lat, lon]) => height.requestHeight(lat, lon).height);
+  const first = pass();
+  const perWindow = Math.ceil(TERRAIN_REFRESH_BUDGET_MS / costMs);
+  assert.equal(reads.length, perWindow, 'one window re-reads its budget and no more');
+  assert.deepEqual(first.slice(0, perWindow), Array(perWindow).fill(80 + LIFT));
+  assert.deepEqual(first.slice(perWindow), Array(40 - perWindow).fill(50 + LIFT), 'the rest keep their last height');
+
+  // Pass after pass, a window apart: the budget moves down the list instead
+  // of returning to the first points, whose reuse time runs out again long
+  // before the last ones have had a turn (40 points, ${perWindow} a window).
+  const turns = new Map();
+  for (const point of reads) turns.set(point, 1);
+  const cycle = Math.ceil(40 / perWindow);
+  for (let passes = 1; passes < cycle; passes++) {
+    nextWindow();
+    reads.length = 0;
+    pass();
+    for (const point of reads) turns.set(point, (turns.get(point) || 0) + 1);
+  }
+  assert.equal(turns.size, 40, 'every point was re-read in one cycle');
+  assert.ok([...turns.values()].every((count) => count === 1), 'and none twice before the others once');
+  assert.ok(cycle * TERRAIN_READ_WINDOW_MS > TERRAIN_HEIGHT_FRESH_MS, 'the cycle is longer than the reuse time, so the first points were stale again');
+  assert.deepEqual(pass().slice(-1), [80 + LIFT]);
+});
+
+test('once the camera and the tiles have settled a height is kept until either changes', (t) => {
+  const { height, state, globe, reads, clock, world } = terrain(t, { surface: () => 10 });
+  const read = () => height.requestHeight(42.36, -71.06).height;
+  assert.equal(read(), 10 + LIFT);
+  // Still settling: the point falls due and is read again.
+  world.surface = () => 20;
+  clock.now += TERRAIN_SETTLE_MS;
+  assert.equal(read(), 20 + LIFT);
+  assert.equal(reads.length, 2);
+  // Read after the settle time: kept, however long the view stays put.
+  world.surface = () => 99;
+  for (let i = 0; i < 50; i++) {
+    clock.now += 60_000;
+    assert.equal(read(), 20 + LIFT);
+  }
+  assert.equal(reads.length, 2);
+
+  // The camera moves: the globe may draw the point from a finer tile.
+  state._viewer.camera.positionCartographic = { longitude: 0, latitude: 0, height: 250 };
+  clock.now += TERRAIN_READ_WINDOW_MS;
+  assert.equal(read(), 99 + LIFT);
+  assert.equal(reads.length, 3);
+
+  // Settled again, then a tile starts loading with the camera still.
+  world.surface = () => 101;
+  clock.now += TERRAIN_SETTLE_MS;
+  assert.equal(read(), 101 + LIFT);
+  clock.now += 60_000;
+  assert.equal(read(), 101 + LIFT);
+  assert.equal(reads.length, 4);
+  world.surface = () => 105;
+  globe.tilesLoaded = false;
+  clock.now += TERRAIN_READ_WINDOW_MS;
+  assert.equal(read(), 105 + LIFT);
+  assert.equal(reads.length, 5);
+});
+
+test('another terrain provider or globe is read afresh, however settled the old heights were', (t) => {
+  const { height, state, globe, world, clock, reads } = terrain(t);
+  const viewer = state._viewer;
+  const at = () => height.requestHeight(42.36, -71.06).height;
+  // Read once the camera and tiles have long settled: kept indefinitely.
+  height.requestHeight(10, 10);
+  clock.now += TERRAIN_SETTLE_MS * 2;
+  reads.length = 0;
+  assert.equal(at(), 100 + LIFT);
+  clock.now += TERRAIN_SETTLE_MS * 10;
+  world.surface = () => 250;
+  assert.equal(at(), 100 + LIFT, 'same terrain: the kept height stands');
+  assert.equal(reads.length, 1);
+
+  viewer.terrainProvider = {};
+  assert.equal(at(), 250 + LIFT, 'a new provider is a new surface');
+  assert.equal(reads.length, 2);
+
+  world.surface = () => 400;
+  viewer.scene.globe = { show: true, getHeight: globe.getHeight };
+  assert.equal(at(), 400 + LIFT, 'and so is a new globe');
+  assert.equal(reads.length, 3);
+
+  // Terrain → flat → the same terrain provider: nothing asks the terrain
+  // while the globe is flat, yet the old heights must not come back.
+  const real = viewer.terrainProvider;
+  viewer.terrainProvider = new Cesium.EllipsoidTerrainProvider();
+  assert.equal(at(), LIFT);
+  world.surface = () => 30;
+  viewer.terrainProvider = real;
+  assert.equal(at(), 30 + LIFT);
+  assert.equal(reads.length, 4);
+});
+
+test('a flat globe answers without reading terrain', (t) => {
+  const { height, reads } = terrain(t, {
+    provider: new Cesium.EllipsoidTerrainProvider(),
+  });
+  assert.deepEqual(height.requestHeight(42.36, -71.06), {
+    cell: '42.36,-71.06',
+    height: LIFT,
+    prior: null,
+  });
+  assert.equal(reads.length, 0);
+});
+
+test('a hidden globe reads no terrain and clear() forgets what was read', (t) => {
+  const { height, reads, globe } = terrain(t);
+  height.requestHeight(42.36, -71.06);
+  height.clear();
+  assert.equal(height.terrainStats().held, 0);
+  height.requestHeight(42.36, -71.06);
+  assert.equal(reads.length, 2, 'a cleared layer reads again');
+  globe.show = false;
+  assert.equal(height.requestHeight(42.5, -71.5).height, null);
+  assert.equal(reads.length, 2);
+});
+
+test('the points kept stay bounded', (t) => {
+  const { height } = terrain(t);
+  const total = TERRAIN_HEIGHT_CACHE_MAX + 5_000;
+  for (let i = 0; i < total; i++)
+    height.requestHeight(10 + Math.floor(i / 1000) * 0.001, 20 + (i % 1000) * 0.0001);
+  const { held, reads } = height.terrainStats();
+  assert.equal(reads, total);
+  assert.ok(held <= TERRAIN_HEIGHT_CACHE_MAX, `${held} held`);
+  assert.ok(held >= TERRAIN_HEIGHT_CACHE_MAX * 0.7, `${held} held`);
+});
+
+test('a fleet rereading every trail fix reads each point once, not once per request', (t) => {
+  const { height, state, parts, reads } = terrain(t);
+  t.mock.timers.enable({ apis: ['setTimeout'] });
+  // 600 vehicles with 40 fixes each, 25 m apart along a street.
+  const fleet = Array.from({ length: 600 }, (_, v) => ({
+    key: `bus-${v}`,
+    fixes: Array.from({ length: 40 }, (_, i) => ({
+      lat: 42 + v * 0.002,
+      lon: -71 + i * 0.0003,
+    })),
+  }));
+  for (const entry of fleet) {
+    state._vehicles.set(entry.key, entry);
+    state._visible.add(entry);
+  }
+  let requests = 0;
+  parts.trails.prepareEntry = (entry, collect) => {
+    for (const fix of entry.fixes) {
+      requests++;
+      const answer = height.requestHeight(fix.lat, fix.lon, entry);
+      if (collect) collect(fix, answer);
+    }
+  };
+  height.anchorFloors();
+  for (let i = 0; i < FLOOR_REREAD_ATTEMPTS; i++) t.mock.timers.tick(FLOOR_REREAD_MS);
+  assert.equal(requests, 600 * 40 * 2 * (FLOOR_REREAD_ATTEMPTS + 1));
+  assert.equal(new Set(reads).size, 600 * 40);
+  assert.equal(reads.length, 600 * 40, `${requests} requests, ${reads.length} terrain reads`);
+  assert.ok(fleet.every((entry) => entry.heightM === 100 + LIFT && entry.heightResolved));
+});
+
+test('a reread cycle outlasts its attempts while trail points still wait for a read, then stops', (t) => {
+  const costMs = 4;
+  const { height, state, parts, reads, clock } = terrain(t, { costMs });
+  t.mock.timers.enable({ apis: ['setTimeout'] });
+  const entry = {
+    key: 'bus',
+    // One fix per floor cell, so nothing can be borrowed.
+    fixes: Array.from({ length: 60 }, (_, i) => ({ lat: 42, lon: -71 + i * 0.001 })),
+  };
+  state._vehicles.set(entry.key, entry);
+  state._visible.add(entry);
+  parts.trails.prepareEntry = (e) => {
+    for (const fix of e.fixes) height.requestHeight(fix.lat, fix.lon, e);
+  };
+  height.anchorFloors();
+  let passes = 1;
+  while (state._floorTimer && passes < 200) {
+    clock.now += FLOOR_REREAD_MS;
+    t.mock.timers.tick(FLOOR_REREAD_MS);
+    passes++;
+  }
+  assert.equal(new Set(reads).size, 60, 'every fix was read in the end');
+  assert.ok(passes > FLOOR_REREAD_ATTEMPTS + 1, `${passes} passes: the cycle kept going for the unread fixes`);
+  assert.ok(passes < 120, `${passes} passes: and stopped once none waited`);
+  assert.equal(state._floorTimer, null);
+});
@@ -12,6 +12,7 @@ import {
  isStaleVehicleFix,
  transitVehicleKey,
  vehicleReportTimeMs,
+  TERRAIN_NEED,
 } from './policy.js';
 import {
  transitModeFor,
@@ -272,7 +273,12 @@ export function createIngestion({ state, services, parts, source }) {
        // DEM one, or a change of map regime, moves a parked vehicle too. A
        // cell still cold takes the lowest neighbour as a prior, as before.
        const priorHeightM = entry.heightM;
-        const height = parts.height.requestHeight(record.lat, record.lon);
+        const height = parts.height.requestHeight(
+          record.lat,
+          record.lon,
+          null,
+          TERRAIN_NEED.MARKER,
+        );
        if (height.height !== null) {
          entry.heightCell = height.cell;
          entry.heightM = height.height;
@@ -309,7 +315,12 @@ export function createIngestion({ state, services, parts, source }) {
          }
          continue;
        }
-        const height = parts.height.requestHeight(record.lat, record.lon);
+        const height = parts.height.requestHeight(
+          record.lat,
+          record.lon,
+          null,
+          TERRAIN_NEED.MARKER,
+        );
        // Keep the local prior separate from resolved historical floors.
        // A neighbouring cell is not a guaranteed lower bound.
        const prior = height.height === null ? height.prior : height.height;
@@ -77,6 +77,43 @@ export const FLOOR_WARM_PER_POLL = 300;
 export const FLOOR_REREAD_MS = 900;
 /** Re-reads before a poll's cycle gives up and waits for the next poll. */
 export const FLOOR_REREAD_ATTEMPTS = 6;
+/**
+ * Terrain heights read from the globe's loaded surface are kept per point
+ * (1e-5°, about a metre): one read is a ray cast against the mesh of the tile
+ * drawn there, not a table lookup, and a fleet asks for every trail fix on
+ * every reread. While the camera moves or tiles load, a kept height is reused
+ * this long before the point is read again.
+ */
+export const TERRAIN_HEIGHT_FRESH_MS = 2_000;
+/**
+ * A height read once the camera has been still and the globe's tiles loaded
+ * for this long is kept until either changes: the globe draws a point from
+ * another tile only after one of them does.
+ */
+export const TERRAIN_SETTLE_MS = 5_000;
+/** Terrain read budgets are counted over windows of this length. */
+export const TERRAIN_READ_WINDOW_MS = 200;
+/**
+ * Milliseconds of terrain reads in one window. Past it a point never read
+ * takes the last height read in its ~111 m floor cell, or waits for a later
+ * pass; a vehicle's own position is read regardless.
+ */
+export const TERRAIN_READ_BUDGET_MS = 16;
+/**
+ * The share of that budget re-reads of kept points may use, the longest-kept
+ * first, leaving the rest for points never read.
+ */
+export const TERRAIN_REFRESH_BUDGET_MS = 12;
+/**
+ * How much a terrain height matters to what is drawn, lowest first. HISTORY is
+ * a past fix of a vehicle that is not selected (its trail is not drawn) and
+ * may use a quarter of each budget; PATH is the stretch a marker is drawn
+ * along, or any fix of the selected vehicle; MARKER is a vehicle's own
+ * position, read even when the window's budget is spent.
+ */
+export const TERRAIN_NEED = Object.freeze({ HISTORY: 0, PATH: 1, MARKER: 2 });
+/** Points kept; the oldest quarter is dropped past it. */
+export const TERRAIN_HEIGHT_CACHE_MAX = 60_000;

 // --- Rendering ---
 /** On-screen glyph size in CSS px at the near end of the distance ramp. */
@@ -8,6 +8,7 @@ import {
 } from '../../data/contactPlayback.js';
 import { createContactTrailRenderer } from '../../data/contactTrailRenderer.js';
 import { fixDistanceM } from './movement.js';
+import { TERRAIN_NEED } from './policy.js';
 import { transitStyleProfile } from '../../data/transitPresetStyle.js';

 const MODE_COLOR = {
@@ -72,8 +73,13 @@ export function createTrails({ state, services, parts, source }) {
      b = {};
    let vertices = 0,
      signature = '';
-    const floor = (point) => {
-      const answer = parts.height.requestHeight(point.lat, point.lon, entry);
+    const floor = (point, need = TERRAIN_NEED.PATH) => {
+      const answer = parts.height.requestHeight(
+        point.lat,
+        point.lon,
+        entry,
+        need,
+      );
      if (collect) collect(point, answer);
      return answer.height;
    };
@@ -99,12 +105,6 @@ export function createTrails({ state, services, parts, source }) {
          lon: a.lon + ((b.lon - a.lon) * i) / n,
        });
    }
-    for (let i = 0; i < entry.track.count; i++) {
-      readFix(entry.track, i, a);
-      const h = floor(a);
-      if (h !== null) correctHeight(entry.track, a.seq, h);
-    }
-    const order = [];
    const activeIndex = Math.max(
      0,
      Math.min(
@@ -112,6 +112,18 @@ export function createTrails({ state, services, parts, source }) {
        entry.sample.fromSeq - entry.track.baseSeq,
      ),
    );
+    for (let i = 0; i < entry.track.count; i++) {
+      readFix(entry.track, i, a);
+      // Fixes behind an unselected vehicle are kept but not drawn.
+      const h = floor(
+        a,
+        entry === selected || i >= activeIndex
+          ? TERRAIN_NEED.PATH
+          : TERRAIN_NEED.HISTORY,
+      );
+      if (h !== null) correctHeight(entry.track, a.seq, h);
+    }
+    const order = [];
    for (let i = activeIndex; i + 1 < entry.track.count; i++) order.push(i);
    if (entry === selected)
      for (let i = activeIndex - 1; i >= 0; i--) order.push(i);
@@ -7,7 +7,6 @@ import { createRendering } from './rendering.js';
 import { createSelection } from './selection.js';
 import { createTracking } from './tracking.js';
 import { createCards } from './cards.js';
-import { createPhotos } from './photos.js';
 import { createTesting } from './testing.js';
 import { createEvidence } from './evidence.js';
 import { createQueries } from './queries.js';
@@ -25,7 +24,6 @@ export function createVesselLayer({ source, services, options = {} } = {}) {
  parts.selection = createSelection(context);
  parts.tracking = createTracking(context);
  parts.cards = createCards(context);
-  parts.photos = createPhotos(context);
  parts.testing = createTesting(context);
  parts.evidence = createEvidence(context);
  parts.queries = createQueries(context);
@@ -92,9 +90,6 @@ export function createVesselLayer({ source, services, options = {} } = {}) {
    buildVesselCard: parts.cards.buildVesselCard,
    buildSelectedVesselCard: parts.cards.buildSelectedVesselCard,
    cardScreenSeparated: parts.cards.cardScreenSeparated,
-    /** The vessel's Open Vessel Photos photo, once its lookup answered. */
-    getVesselPhoto: (id) =>
-      parts.photos.vesselPhoto(vesselState.state.records.byId.get(id)),
  });
  Object.defineProperty(layer, 'testing', { value: parts.testing });
  return layer;
@@ -1,56 +0,0 @@
-import { MMSI, parseOpenVesselPhoto } from '../../data/openVesselPhoto.js';
-
-/** A failed lookup is asked again after this long; a miss is final. */
-const PHOTO_RETRY_MS = 5 * 60 * 1000;
-/** Lookups remembered per session, oldest dropped first. */
-const PHOTO_CACHE_LIMIT = 500;
-
-/**
- * The selected vessel's photo, looked up once per MMSI when it is selected.
- * The answer is read with `parseOpenVesselPhoto` whatever shape the source
- * returns, so only a checked photo is ever kept. A source without
- * `getEnrichment` has no photos.
- */
-export function createPhotos({ vesselState }) {
-  /** MMSI → photo, `null` for a final miss, or `{failedAtMs}`/`{pending}`. */
-  const answers = new Map();
-
-  function remember(mmsi, answer) {
-    answers.delete(mmsi);
-    answers.set(mmsi, answer);
-    if (answers.size > PHOTO_CACHE_LIMIT)
-      answers.delete(answers.keys().next().value);
-  }
-
-  /** Ask for the record's photo unless it is known, asked or cooling down. */
-  function requestVesselPhoto(record, now = Date.now()) {
-    const mmsi = String(record?.mmsi || '');
-    const source = vesselState._source;
-    if (!MMSI.test(mmsi) || typeof source?.getEnrichment !== 'function') return;
-    const known = answers.get(mmsi);
-    if (known !== undefined) {
-      if (known?.pending || known === null || known.found) return;
-      if (now - known.failedAtMs < PHOTO_RETRY_MS) return;
-    }
-    remember(mmsi, { pending: true });
-    Promise.resolve()
-      .then(() => source.getEnrichment({ kind: 'photo', id: mmsi }))
-      .then(
-        (answer) => {
-          const photo = parseOpenVesselPhoto(answer);
-          remember(mmsi, photo.found ? photo : null);
-        },
-        () => remember(mmsi, { failedAtMs: Date.now() }),
-      );
-  }
-
-  /** The vessel's checked photo, or null. */
-  function vesselPhoto(record) {
-    const answer = answers.get(String(record?.mmsi || ''));
-    if (!answer?.found) return null;
-    const { src, width, height, photographer, licence, link } = answer;
-    return { src, width, height, photographer, licence, link };
-  }
-
-  return { requestVesselPhoto, vesselPhoto };
-}
@@ -1,87 +0,0 @@
-// src/layers/vessels/photos.test.mjs — a selected vessel's photo is asked for
-// once per MMSI; a miss is final and a failure is retried only after a pause.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { createPhotos } from './photos.js';
-
-const ANSWER = Object.freeze({
-  mmsi: '366999709',
-  photos: [
-    {
-      urls: {
-        mmsi: 'https://openvesselphotos.org/v1/mmsi/366999709/photos/1.jpg',
-      },
-      credit: 'Gordon Leggett',
-      licenceName: 'CC BY 4.0',
-      width: 1600,
-      height: 1200,
-    },
-  ],
-});
-
-const settle = () => new Promise((resolve) => setImmediate(resolve));
-
-function fixture(answer) {
-  const asked = [];
-  const source = {
-    getSnapshot() {},
-    async getEnrichment(query) {
-      asked.push(query);
-      return answer(query);
-    },
-  };
-  const photos = createPhotos({ vesselState: { _source: source } });
-  return { photos, asked };
-}
-
-test('a selected vessel is asked once and shows its checked photo', async () => {
-  const { photos, asked } = fixture(() => ANSWER);
-  const record = { id: 'v1', mmsi: '366999709' };
-  photos.requestVesselPhoto(record);
-  photos.requestVesselPhoto(record);
-  await settle();
-  photos.requestVesselPhoto(record);
-  assert.deepEqual(asked, [{ kind: 'photo', id: '366999709' }]);
-  assert.deepEqual(photos.vesselPhoto(record), {
-    src: 'https://openvesselphotos.org/v1/mmsi/366999709/photos/1.jpg?size=800',
-    width: 800,
-    height: 600,
-    photographer: 'Gordon Leggett',
-    licence: 'CC BY 4.0',
-    link: 'https://openvesselphotos.org/vessels/mmsi/366999709',
-  });
-});
-
-test('a vessel without a valid MMSI, or a source without lookups, is never asked', async () => {
-  const { photos, asked } = fixture(() => ANSWER);
-  photos.requestVesselPhoto({ id: 'v1', mmsi: '' });
-  photos.requestVesselPhoto({ id: 'v2', mmsi: '12345' });
-  await settle();
-  assert.equal(asked.length, 0);
-  const bare = createPhotos({ vesselState: { _source: { getSnapshot() {} } } });
-  bare.requestVesselPhoto({ id: 'v3', mmsi: '366999709' });
-  assert.equal(bare.vesselPhoto({ mmsi: '366999709' }), null);
-});
-
-test('a miss is final; a failure is asked again only after the pause', async () => {
-  let fail = true;
-  const { photos, asked } = fixture(({ id }) => {
-    if (id === '111111111') return { mmsi: id, photos: [] };
-    if (fail) throw new Error('down');
-    return ANSWER;
-  });
-  const missing = { mmsi: '111111111' };
-  const flaky = { mmsi: '366999709' };
-  photos.requestVesselPhoto(missing);
-  photos.requestVesselPhoto(flaky, 0);
-  await settle();
-  photos.requestVesselPhoto(missing);
-  photos.requestVesselPhoto(flaky, Date.now() + 1000);
-  assert.equal(asked.length, 2);
-  fail = false;
-  photos.requestVesselPhoto(flaky, Date.now() + 10 * 60 * 1000);
-  await settle();
-  assert.equal(asked.length, 3);
-  assert.equal(photos.vesselPhoto(missing), null);
-  assert.equal(photos.vesselPhoto(flaky).photographer, 'Gordon Leggett');
-});
@@ -186,7 +186,6 @@ export function createSelection({
    // click, not up to VISIBILITY_UPDATE_MS later.
    components.rendering.updateVisibility(true);
    components.cards.updateSelectedVesselHud(record);
-    components.photos.requestVesselPhoto(record);
    if (registerSelectedContext(record)) {
      selectEntityContext(record);
    }
@@ -64,9 +64,12 @@ async function standaloneStartup(Cesium, credentials, fetchImpl) {
    document: {
      getElementById: () => ({ querySelector: () => ({}) }),
    },
-    startPageLocale: () => 'en',
-    followPageLocale: () => () => {},
+    resolveLocale: () => 'en',
+    setLocale() {},
+    getLocale: () => 'en',
+    onLocaleChange: () => () => {},
    mountApplicationViews() {},
+    applyDocumentLanguage() {},
    applyDocumentTranslations() {},
    CITY_POIS: [],
    createApplication: (options) => options,
@@ -16,5 +16,4 @@ export {
  createFlightSource,
  createMilitarySource,
  createVesselSource,
-  fetchOpenVesselPhoto,
 } from './standalone.js';
@@ -12,11 +12,6 @@ import {
 } from './aircraft.js';
 import { normalizeVesselTrack, vesselSnapshot } from './vessels.js';
 import { parsePlanespottersPhoto } from '../../data/planespottersPhoto.js';
-import {
-  MMSI,
-  openVesselPhotosUrl,
-  parseOpenVesselPhoto,
-} from '../../data/openVesselPhoto.js';

 const defaultFetch = (...args) => globalThis.fetch(...args);
 const header = (response, name) => response.headers?.get?.(name);
@@ -47,34 +42,6 @@ async function planespottersPhoto(fetchImpl, hex, signal) {
  return parsePlanespottersPhoto(payload);
 }

-/**
- * A vessel's Open Vessel Photos photo, read and host-checked. The API is
- * keyless and answers with `access-control-allow-origin: *`, so the browser
- * asks it straight. An MMSI it does not know answers 404: no photo.
- * @param {Function} fetchImpl fetch.
- * @param {string} mmsi The vessel's nine-digit MMSI.
- * @param {AbortSignal} [signal] Abort signal.
- * @returns {Promise<object>} A `parseOpenVesselPhoto` result.
- */
-export async function fetchOpenVesselPhoto(fetchImpl, mmsi, signal) {
-  const id = String(mmsi || '');
-  if (!MMSI.test(id))
-    throw new LiveSourceError('unsupported', 'Enrichment unavailable');
-  const timeout = AbortSignal.timeout(PHOTO_TIMEOUT_MS);
-  const { response, payload } = await readResponse(
-    fetchImpl,
-    openVesselPhotosUrl(id),
-    {
-      signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
-      credentials: 'omit',
-    },
-    'Open Vessel Photos',
-  );
-  if (response.status === 404) return parseOpenVesselPhoto(null);
-  if (!response.ok) throw httpError(response, 'Open Vessel Photos');
-  return parseOpenVesselPhoto(payload, id);
-}
-
 function openSkyError(response) {
  const error = httpError(response, 'Flights');
  const mode = String(
@@ -268,11 +235,6 @@ export function createVesselSource({
        status: response.status,
      };
    },
-    async getEnrichment(query, { signal } = {}) {
-      if (query.kind !== 'photo')
-        throw new LiveSourceError('unsupported', 'Enrichment unavailable');
-      return fetchOpenVesselPhoto(fetchImpl, query.id, signal);
-    },
    async getTrack(reference, { signal } = {}) {
      const { response, payload } = await readResponse(
        fetchImpl,
@@ -6,11 +6,13 @@ import { createStandaloneScene } from './scene.js';
 import { createStandaloneControls } from './controls.js';
 import { createStandaloneData } from './data.js';
 import { createStandaloneTools } from './tools.js';
+import { resolveLocale, applyDocumentLanguage } from '../i18n/locale.js';
 import {
  applyDocumentTranslations,
-  followPageLocale,
-  startPageLocale,
-} from '../i18n/page.js';
+  getLocale,
+  onLocaleChange,
+  setLocale,
+} from '../i18n/index.js';
 import { mountApplicationViews } from '../ui/views/index.js';
 import { createGoogleTokenSource } from '../maps/googleTokens.js';

@@ -35,7 +37,9 @@ export function createStandaloneApplication({
  // scripts execute after parsing, so the DOM is ready here: the views
  // translate as they render, and the page's static data-i18n* markup (the
  // loading screen) is translated here and after every language switch.
-  startPageLocale(document);
+  const activeLocale = resolveLocale();
+  setLocale(activeLocale);
+  applyDocumentLanguage(document, activeLocale);
  // Views render the page's markup; wiring reads it.
  mountApplicationViews(document);
  applyDocumentTranslations(document);
@@ -46,7 +50,12 @@ export function createStandaloneApplication({
  return createApplication({
    createScene: async (context) => {
      // A language switch applies in place; the page's own markup follows.
-      context.defer(followPageLocale(document));
+      context.defer(
+        onLocaleChange(() => {
+          applyDocumentLanguage(document, getLocale());
+          applyDocumentTranslations(document);
+        }),
+      );
      placeSearch = createStandalonePlaceSearch({
        // The bundled city and landmark data the offline name provider reads.
        // The search package takes it as plain data rather than importing it,
@@ -96,7 +96,7 @@ export class StyleManager extends ShellFacade {
   * @param {Cesium.Viewer} viewer - The CesiumJS viewer instance.
   * @param {object} [options]
   * @param {boolean} [options.localePicker=true] - false removes the language
-   *   picker, for a host that offers its own language choice.
+   *   picker, for a host that does not initialize Core's locale.
   */
  constructor(
    viewer,
@@ -764,7 +764,7 @@ export class StyleManager extends ShellFacade {
    this._lifetime.own(
      onLocaleChange(() => nextTick(() => this._sizeDisplayLabelColumn())),
    );
-    // A host that offers its own language choice shows no picker.
+    // A host that does not initialize Core's locale shows no picker.
    if (this._localePickerEnabled === false) return;
    this._publishLocalePicker();
  }
@@ -1,7 +1,6 @@
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import { CctvControls } from './cctvControls.js';
-import { CCTV_FRAME_DECODE_WAIT_MS } from './cctvFrames.js';

 function element() {
  const classes = new Set();
@@ -60,50 +59,6 @@ test('a late image completion cannot replace a newer camera preview', (t) => {
  assert.equal(controls._frame.cameraId, 'b');
 });

-test('a camera frame settles once decoded, and a stale decode cannot land', async (t) => {
-  const { controls, requests } = fixture(t);
-  const decodes = [];
-  const queue = (src, id) => {
-    controls._queueCctvFrame(src, id, true);
-    const request = requests.at(-1);
-    request.decode = () =>
-      new Promise((resolve) => decodes.push({ src, resolve }));
-    return request;
-  };
-  const first = queue('first.jpg', 'a');
-  first.onload();
-  assert.equal(controls._frame.hasFrame, false);
-  const second = queue('second.jpg', 'b');
-  second.onload();
-  decodes[1].resolve();
-  await Promise.resolve();
-  decodes[0].resolve();
-  await Promise.resolve();
-  assert.equal(controls._frame.src, 'second.jpg');
-  assert.equal(controls._frame.cameraId, 'b');
-  assert.equal(controls._frame.hasFrame, true);
-});
-
-test('a loaded frame shows when its decode rejects or never settles', async (t) => {
-  t.mock.timers.enable({ apis: ['setTimeout'] });
-  const { controls, requests } = fixture(t);
-  controls._queueCctvFrame('broken.jpg', 'a', true);
-  requests[0].decode = () => Promise.reject(new Error('EncodingError'));
-  requests[0].onload();
-  await Promise.resolve();
-  await Promise.resolve();
-  assert.equal(controls._frame.src, 'broken.jpg');
-  assert.equal(controls._frame.hasFrame, true);
-
-  controls._queueCctvFrame('hidden.jpg', 'b', true);
-  requests[1].decode = () => new Promise(() => {});
-  requests[1].onload();
-  assert.equal(controls._frame.hasFrame, false);
-  t.mock.timers.tick(CCTV_FRAME_DECODE_WAIT_MS);
-  assert.equal(controls._frame.src, 'hidden.jpg');
-  assert.equal(controls._frame.hasFrame, true);
-});
-
 test('failed refresh preserves settled pixels, but changing cameras clears them', (t) => {
  const { controls, requests } = fixture(t);
  controls._queueCctvFrame('first.jpg', 'a', true);
@@ -77,9 +77,6 @@ export function cctvSourceLabelText(label) {
  return SOURCE_LABELS[text] ? t(SOURCE_LABELS[text]) : text;
 }

-/** Longest wait for a loaded frame's decode before it is shown anyway. */
-export const CCTV_FRAME_DECODE_WAIT_MS = 1000;
-
 /** The preview before any frame: nothing requested, nothing shown. */
 export const EMPTY_CCTV_FRAME = Object.freeze({
  cameraId: '',
@@ -130,28 +127,7 @@ export function _queueCctvFrame(src, cameraId, cameraChanged) {

  const preloader = new Image();
  this._cctvFramePreloader = preloader;
-  // Settle once the image is decoded, not merely loaded: the panel's <img>
-  // then paints the frame the moment it takes the src, instead of showing
-  // its empty box for the decode.
-  // A decode that rejects after a load still has drawable data, as it was
-  // before decoding was awaited. A decode that never settles (a hidden tab may
-  // hold it until the page draws) shows the loaded frame after
-  // CCTV_FRAME_DECODE_WAIT_MS rather than leaving the preview loading.
-  preloader.onload = () => {
-    if (typeof preloader.decode !== 'function') {
-      this._settleCctvFrame(token, src, true);
-      return;
-    }
-    let settled = false;
-    const settle = () => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      this._settleCctvFrame(token, src, true);
-    };
-    const timer = setTimeout(settle, CCTV_FRAME_DECODE_WAIT_MS);
-    preloader.decode().then(settle, settle);
-  };
+  preloader.onload = () => this._settleCctvFrame(token, src, true);
  preloader.onerror = () => this._settleCctvFrame(token, src, false);
  preloader.src = src;
 }
@@ -250,11 +250,8 @@ html:not([lang='en']) .cctv-controls .scene-btn {
  height: auto;
  object-fit: contain;
  display: block;
-  /* No fade: a camera change hides the old frame at once (never its pixels
-     under the new camera) and shows the new one as soon as it is decoded. A
-     180 ms fade-in after every arriving frame made each camera click linger
-     on black. */
  opacity: 0;
+  transition: opacity 180ms ease;
 }

 #cctv-video {
Author	SHA1	Message	Date
Mazeyar Moeini Feizabadi	c29ee98e23	Revert "style(transit): format the terrain provider test" This reverts commit `5110f4cce3`.	2026-11-13 03:26:17 +01:00
Mazeyar Moeini FeizabadiandClaude Fable 5.2	5110f4cce3	style(transit): format the terrain provider test Co-Authored-By: Claude Fable 5.2 <[email protected]>	2026-11-13 03:25:07 +01:00
Mazeyar Moeini Feizabadi	8792e4701e	Merge remote-tracking branch 'origin/main' into mazeyar/transit-terrain-height-cache	2026-11-13 03:22:10 +01:00
Mazeyar Moeini FeizabadiandClaude Fable 5.2	87674240bd	fix(transit): start terrain heights afresh when the provider or globe changes A height read after the camera and tiles settled was kept until either changed, but swapping the terrain provider or the globe with a still camera changed neither, so the previous terrain's elevation could stand indefinitely. The cache is now cleared when either identity changes, checked before the flat-globe answer so terrain -> flat -> terrain is covered too. Found in review by kvnloo. Co-Authored-By: Claude Fable 5.2 <[email protected]>	2026-11-13 03:22:10 +01:00
Mazeyar Moeini FeizabadiandClaude Fable 5.2	d5f7926c7e	docs(changelog): name the transit height fragment after its pull request Co-Authored-By: Claude Fable 5.2 <[email protected]>	2026-11-12 21:50:22 +01:00
Mazeyar Moeini FeizabadiandClaude Fable 5.2	1c49a89faa	fix(transit): keep terrain heights per point so rereads stop freezing the page On a terrain globe every floor reread asked globe.getHeight, a ray cast against the drawn tile's mesh, for every trail fix of every vehicle in view, twice per pass and seven passes per poll. Over Boston's 650 vehicles that was about 150,000 reads per 10 s for about 8,000 distinct points, and blocked the page for up to 19 s at a time while zooming. Heights are now kept per point (1e-5 degrees), read again only while the camera moves or tiles load, and read within a time budget: vehicle positions first, the path a marker is drawn along next, undrawn trail history last. Co-Authored-By: Claude Fable 5.2 <[email protected]>	2026-11-12 21:10:49 +01:00