From da689e03ac983499f9682c46889d454195e7231b Mon Sep 17 00:00:00 2001
From: monwiss <547445+monwiss@users.noreply.github.com>
Date: Thu, 24 Sep 2026 17:15:39 -0400
Subject: [PATCH 01/71] refactor(providers): move the tile budget helpers out
 of the TomTom module

utcDayKey, normalizeBudget and isOverBudget move unchanged to
src/data/tileBudget.js. Nothing in them was TomTom-specific; the next
keyed tile proxy (Xweather) counts a monthly allowance through the same
two functions. tomtomTiles.js re-exports them, so the traffic provider
and its tests keep their imports.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 scripts/format-scope.json       |  2 ++
 scripts/package-boundaries.json | 12 ++++++--
 src/data/tileBudget.js          | 53 +++++++++++++++++++++++++++++++++
 src/data/tileBudget.test.mjs    | 26 ++++++++++++++++
 src/data/tomtomTiles.js         | 41 ++-----------------------
 5 files changed, 94 insertions(+), 40 deletions(-)
 create mode 100644 src/data/tileBudget.js
 create mode 100644 src/data/tileBudget.test.mjs

diff --git a/scripts/format-scope.json b/scripts/format-scope.json
index eee546dd5..9b82af4b7 100644
--- a/scripts/format-scope.json
+++ b/scripts/format-scope.json
@@ -79,6 +79,8 @@
   "src/data/terrainHeightsProxy.test.mjs",
   "src/data/tomtomTiles.js",
   "src/data/tomtomTiles.test.mjs",
+  "src/data/tileBudget.js",
+  "src/data/tileBudget.test.mjs",
   "src/data/firmsCsv.js",
   "src/data/firmsCsv.test.mjs",
   "src/tooling/environmentProviders.test.mjs",
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index 189192f10..748f11d44 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -113,12 +113,16 @@
   "traffic-provider": {
     "runtime": "node",
     "exports": ["./server/providers/traffic"],
-    "modules": ["server/providers/traffic.js", "src/data/tomtomTiles.js"],
+    "modules": [
+      "server/providers/traffic.js",
+      "src/data/tomtomTiles.js",
+      "src/data/tileBudget.js"
+    ],
     "external": []
   },
   "traffic-source": {
     "exports": ["./sources/traffic"],
-    "modules": ["src/data/tomtomTiles.js"],
+    "modules": ["src/data/tomtomTiles.js", "src/data/tileBudget.js"],
     "external": []
   },
   "firms-csv": {
@@ -1009,6 +1013,7 @@
       "src/data/cameraSensitivity.js",
       "src/data/flowMatch.js",
       "src/data/tomtomTiles.js",
+      "src/data/tileBudget.js",
       "src/data/trafficBounds.js",
       "src/data/trafficFlowStyle.js",
       "src/data/trafficPresetStyle.js",
@@ -1424,6 +1429,7 @@
       "src/data/telegeographySubmarineCables.js",
       "src/data/terrainHeights.js",
       "src/data/tomtomTiles.js",
+      "src/data/tileBudget.js",
       "src/data/tr3bRegistry.js",
       "src/data/trackedCamera.js",
       "src/data/trackedModelRegime.js",
@@ -2071,6 +2077,7 @@
       "src/data/scenePick.js",
       "src/data/spriteOrder.js",
       "src/data/tomtomTiles.js",
+      "src/data/tileBudget.js",
       "src/data/tr3bRegistry.js",
       "src/data/trackedCamera.js",
       "src/data/trackedModelRegime.js",
@@ -2707,6 +2714,7 @@
     "exports": ["./layers/traffic/source"],
     "modules": [
       "src/data/tomtomTiles.js",
+      "src/data/tileBudget.js",
       "src/layers/traffic/flowDecode.js",
       "src/layers/traffic/flowSource.js",
       "src/layers/traffic/source.js",
diff --git a/src/data/tileBudget.js b/src/data/tileBudget.js
new file mode 100644
index 000000000..dcc44a28c
--- /dev/null
+++ b/src/data/tileBudget.js
@@ -0,0 +1,53 @@
+/**
+ * @file Upstream-request accounting shared by the keyed tile proxies.
+ *
+ * A soft cap per UTC period, persisted as `{date, count}` so it survives a
+ * restart. Nothing here is provider-specific: the caller picks the period by
+ * the key it passes, and decides what happens over the cap.
+ *
+ * Zero dependencies and Cesium-free, so providers and browser helpers can
+ * import it and node:test can exercise it directly.
+ *
+ * @module data/tileBudget
+ */
+
+/**
+ * UTC calendar-day key for budget bucketing.
+ *
+ * @param {number} [epochMs=Date.now()] - Timestamp in ms.
+ * @returns {string} 'YYYY-MM-DD' in UTC.
+ */
+export function utcDayKey(epochMs = Date.now()) {
+  return new Date(epochMs).toISOString().slice(0, 10);
+}
+
+/**
+ * Normalize a persisted budget state against today's UTC day key.
+ * Rolls the counter to zero on day change; replaces missing/corrupt state.
+ * Returns the SAME object when it is already valid for `dayKey` (cheap to
+ * call on every request).
+ *
+ * @param {{date:string, count:number}|null|undefined} state - Persisted state.
+ * @param {string} dayKey - Today's UTC day key (from `utcDayKey`).
+ * @returns {{date:string, count:number}} Valid state for `dayKey`.
+ */
+export function normalizeBudget(state, dayKey) {
+  const valid =
+    Boolean(state) &&
+    state.date === dayKey &&
+    Number.isFinite(state.count) &&
+    state.count >= 0;
+  return valid ? state : { date: dayKey, count: 0 };
+}
+
+/**
+ * Whether the daily soft cap has been reached.
+ *
+ * @param {{count:number}} state - Normalized budget state.
+ * @param {number} limit - Daily tile budget; non-positive/invalid never blocks.
+ * @returns {boolean} True when `count >= limit`.
+ */
+export function isOverBudget(state, limit) {
+  if (!Number.isFinite(limit) || limit <= 0) return false;
+  return state.count >= limit;
+}
diff --git a/src/data/tileBudget.test.mjs b/src/data/tileBudget.test.mjs
new file mode 100644
index 000000000..fa48440bb
--- /dev/null
+++ b/src/data/tileBudget.test.mjs
@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { isOverBudget, normalizeBudget, utcDayKey } from './tileBudget.js';
+import * as tomtom from './tomtomTiles.js';
+
+test('tile budget helpers live in one module and TomTom re-exports them', () => {
+  assert.equal(tomtom.utcDayKey, utcDayKey);
+  assert.equal(tomtom.normalizeBudget, normalizeBudget);
+  assert.equal(tomtom.isOverBudget, isOverBudget);
+});
+
+test('normalizeBudget keeps a valid state and resets another period', () => {
+  const state = { date: '2026-09-24', count: 3 };
+  assert.equal(normalizeBudget(state, '2026-09-24'), state);
+  assert.deepEqual(normalizeBudget(state, '2026-09-25'), {
+    date: '2026-09-25',
+    count: 0,
+  });
+  assert.deepEqual(
+    normalizeBudget({ date: '2026-09-24', count: -1 }, '2026-09-24'),
+    {
+      date: '2026-09-24',
+      count: 0,
+    },
+  );
+});
diff --git a/src/data/tomtomTiles.js b/src/data/tomtomTiles.js
index af4fc95b3..a1dbc18cb 100644
--- a/src/data/tomtomTiles.js
+++ b/src/data/tomtomTiles.js
@@ -131,42 +131,7 @@ export function tilesForBounds(bounds, zoom = 12, { maxTiles = 64 } = {}) {
 // ─── Daily budget accounting ───────────────────────────────
 
 /**
- * UTC calendar-day key for budget bucketing.
- *
- * @param {number} [epochMs=Date.now()] - Timestamp in ms.
- * @returns {string} 'YYYY-MM-DD' in UTC.
+ * Re-exported from `./tileBudget.js`, which keyed tile proxies share. The
+ * traffic provider and its tests keep one import for tile math and budget.
  */
-export function utcDayKey(epochMs = Date.now()) {
-  return new Date(epochMs).toISOString().slice(0, 10);
-}
-
-/**
- * Normalize a persisted budget state against today's UTC day key.
- * Rolls the counter to zero on day change; replaces missing/corrupt state.
- * Returns the SAME object when it is already valid for `dayKey` (cheap to
- * call on every request).
- *
- * @param {{date:string, count:number}|null|undefined} state - Persisted state.
- * @param {string} dayKey - Today's UTC day key (from `utcDayKey`).
- * @returns {{date:string, count:number}} Valid state for `dayKey`.
- */
-export function normalizeBudget(state, dayKey) {
-  const valid =
-    Boolean(state) &&
-    state.date === dayKey &&
-    Number.isFinite(state.count) &&
-    state.count >= 0;
-  return valid ? state : { date: dayKey, count: 0 };
-}
-
-/**
- * Whether the daily soft cap has been reached.
- *
- * @param {{count:number}} state - Normalized budget state.
- * @param {number} limit - Daily tile budget; non-positive/invalid never blocks.
- * @returns {boolean} True when `count >= limit`.
- */
-export function isOverBudget(state, limit) {
-  if (!Number.isFinite(limit) || limit <= 0) return false;
-  return state.count >= limit;
-}
+export { utcDayKey, normalizeBudget, isOverBudget } from './tileBudget.js';

From b09db551495e2c9e51c8ff30c903f9e1a4c851c3 Mon Sep 17 00:00:00 2001
From: daikaginza <daika.ginza@gmail.com>
Date: Mon, 28 Sep 2026 11:53:13 +0700
Subject: [PATCH 02/71] fix(server): declare the method contract on the three
 read-only query proxies
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

/api/opensky, /api/adsblol/mil and /api/route answered any verb with the same
body while ignoring the request entirely. Measured against a running server
before the change: POST /api/opensky returned 200 with 833,759 bytes of live
state vectors, POST /api/adsblol/mil returned 47,372 bytes. Their siblings do
not: /api/geocode, /api/weather and /api/transit answer 405, and /api/overpass
is deliberately POST-only.

These three are read-only query proxies, so they now answer 405 to anything but
GET, using the wording and shape /api/geocode already uses. The refusal comes
first, before rate limiting and before any upstream call, which the tests
assert by stubbing fetch to throw.

Scope, stated plainly: this is a consistency and intent fix. No rate limiter
was being bypassed — /api/route already limits every request regardless of
verb, and the two aircraft routes have no limiter at all, only 9s and 12s
server-side caches that bound upstream cost for any method.

One existing fixture in src/search/geospatial.test.mjs built a request without
a method, which a real Node request always has; it now sets GET.

Verified on a running server after the change: GET still 200 on all three,
POST 405 on all three, /api/overpass and the other proxies unchanged.
Suite goes from 5090 to 5092 tests, 0 failures.
---
 docs/CURRENT-STATE.md                 |  1 +
 server/providers/aircraft/adsb-lol.js |  7 +++++++
 server/providers/aircraft/opensky.js  |  8 ++++++++
 server/providers/places/routes.js     |  7 +++++++
 src/search/geospatial.test.mjs        |  6 +++++-
 src/tooling/liveProviders.test.mjs    | 23 +++++++++++++++++++++++
 src/tooling/placeProviders.test.mjs   | 19 +++++++++++++++++++
 7 files changed, 70 insertions(+), 1 deletion(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 22ce1eb3b..15e159ac8 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4072,6 +4072,7 @@ are omitted rather than framing the wrong part of the globe.
 - `/api/overpass` is bounded by body/response caps, per-client/global rate limits, concurrency limits, operator-configured upstreams, in-flight dedupe, cache bounds, and static validation that every selector is spatially bounded.
 - `/api/military-installations` uses an independent limiter with the same 90-per-client/300-global one-minute bounds, so viewport installation refreshes never consume `/api/overpass` annotation capacity.
 - `/api/route` proxies bounded OSRM route requests for annotation routes, with profile allowlisting, distance caps, response caps, caching, and sanitized "no route found" errors.
+- `/api/opensky`, `/api/adsblol/mil`, and `/api/route` are read-only query proxies and answer `405 Method Not Allowed` to anything but `GET`, as `/api/geocode` and the other query proxies already did. The refusal precedes rate limiting and any upstream call.
 - Track endpoints: `/api/ais-live/track?mmsi=` (server-accumulated ring buffers; sub-route handled before the rows snapshot), `/api/opensky-track?icao24=` (OAuth, 60s cache, sanitized errors, independent OpenSky credit bucket), `/api/adsblol/trace?hex=` (60s cache, 5MB cap, ODbL attribution required in UI).
 - Realtime debug logs redact API keys, bearer tokens, client secrets, and image data URLs before writing to disk; request bodies are size-capped.
 - `/api/realtime/debug-log` enforces an always-on 120-per-client/400-global one-minute limiter (not the opt-in `GEV_RATELIMIT_OPENAI_PER_MIN` bucket the cost-bearing OpenAI routes share), appends asynchronously through a serialized queue, and rotates `realtime-conversations.jsonl` at 32 MB keeping one prior generation, so the sink is bounded at twice that regardless of session length. A malformed record answers 400 and a failed write 500, both with a fixed message.
diff --git a/server/providers/aircraft/adsb-lol.js b/server/providers/aircraft/adsb-lol.js
index fc5ab0bd3..80140bb56 100644
--- a/server/providers/aircraft/adsb-lol.js
+++ b/server/providers/aircraft/adsb-lol.js
@@ -68,6 +68,13 @@ export function adsbLolProxy() {
 
   const installMiddleware = (server) => {
     server.middlewares.use('/api/adsblol/mil', async (req, res) => {
+      // Read-only snapshot endpoint; match the method contract its sibling
+      // query proxies already declare instead of serving every verb alike.
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Method Not Allowed' }));
+        return;
+      }
       try {
         const now = Date.now();
         if (_cache && now - _cacheAt < CACHE_MS) {
diff --git a/server/providers/aircraft/opensky.js b/server/providers/aircraft/opensky.js
index 612d01e11..aa0dad268 100644
--- a/server/providers/aircraft/opensky.js
+++ b/server/providers/aircraft/opensky.js
@@ -350,6 +350,14 @@ function openSkySourceIsStale(sourceEpochMs, now = Date.now()) {
 export function openSkyProxy() {
   const installMiddleware = (server) => {
     server.middlewares.use('/api/opensky', async (req, res) => {
+      // Read-only snapshot endpoint: state the method contract the way
+      // /api/geocode and the other query proxies state it, rather than
+      // answering any verb with the same body and ignoring the request body.
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Method Not Allowed' }));
+        return;
+      }
       try {
         const requestedMode = normalizeOpenSkyAuthMode(
           process.env.OPENSKY_AUTH_MODE,
diff --git a/server/providers/places/routes.js b/server/providers/places/routes.js
index 42e24ad32..8e837fcd4 100644
--- a/server/providers/places/routes.js
+++ b/server/providers/places/routes.js
@@ -227,6 +227,13 @@ export function installRouteMiddleware(
   // only shape that asks the upstream for them. A response WITHOUT steps is
   // byte for byte what this endpoint has always returned.
   middlewares.use('/api/route', async (req, res) => {
+    // The documented shape above is a GET with query parameters; say so,
+    // the way the other query proxies do, instead of answering any verb.
+    if (req.method !== 'GET') {
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Method Not Allowed' }));
+      return;
+    }
     const fail = (msg) => {
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ ok: false, error: msg }));
diff --git a/src/search/geospatial.test.mjs b/src/search/geospatial.test.mjs
index be846bb36..dbedbe53f 100644
--- a/src/search/geospatial.test.mjs
+++ b/src/search/geospatial.test.mjs
@@ -209,7 +209,11 @@ test('routing middleware uses configured OSRM servers while retaining request bo
   const request = async (query) => {
     let payload;
     await handler(
-      { url: `/?${query}`, socket: { remoteAddress: '127.0.0.1' } },
+      {
+        url: `/?${query}`,
+        method: 'GET',
+        socket: { remoteAddress: '127.0.0.1' },
+      },
       {
         writeHead() {},
         end(body) {
diff --git a/src/tooling/liveProviders.test.mjs b/src/tooling/liveProviders.test.mjs
index 38953eff9..c25c445d4 100644
--- a/src/tooling/liveProviders.test.mjs
+++ b/src/tooling/liveProviders.test.mjs
@@ -381,3 +381,26 @@ test('track backfill proxy returns 502 on an oversized upstream body and caches
   assert.equal(res2.statusCode, 502);
   assert.equal(callCount, 1);
 });
+
+test('the aircraft snapshot routes decline a non-GET before any upstream work', async (t) => {
+  // Both routes answered every verb with the full snapshot, unlike the query
+  // proxies beside them, so nothing said whether a body was read or ignored.
+  // A stubbed fetch that throws proves the refusal happens before the handler
+  // reaches upstream, rather than after paying for the work and discarding it.
+  t.mock.method(globalThis, 'fetch', async (url) => {
+    throw new Error(`upstream must not be reached: ${url}`);
+  });
+  const cases = [
+    [install(providers.openSkyProxy()), '/api/opensky'],
+    [install(providers.adsbLolProxy()), '/api/adsblol/mil'],
+  ];
+  for (const [request, route] of cases) {
+    for (const method of ['POST', 'PUT', 'DELETE', 'PATCH']) {
+      const response = await request(route, '/', method);
+      assert.equal(response.statusCode, 405, `${method} ${route}`);
+      assert.deepEqual(JSON.parse(response.body), {
+        error: 'Method Not Allowed',
+      });
+    }
+  }
+});
diff --git a/src/tooling/placeProviders.test.mjs b/src/tooling/placeProviders.test.mjs
index 78d311369..968c5a9fa 100644
--- a/src/tooling/placeProviders.test.mjs
+++ b/src/tooling/placeProviders.test.mjs
@@ -482,3 +482,22 @@ test('the upstream host is pinned: a redirect is refused, not followed', async (
   await request('/api/route', '?profile=car&coords=-97,30;-97.01,30.01');
   assert.deepEqual(seen, ['error'], 'a redirect would escape the pinned host');
 });
+
+test('the routing proxy declines a non-GET before rate limiting or upstream', async (t) => {
+  // The documented shape is a GET with query parameters, but every verb was
+  // answered alike. Refuse first: a stubbed fetch that throws shows the
+  // rejection costs neither an upstream call nor a rate-limit slot.
+  const request = install(installRouteMiddleware);
+  t.mock.method(globalThis, 'fetch', async () => {
+    throw new Error('upstream must not be reached');
+  });
+  for (const method of ['POST', 'PUT', 'DELETE', 'PATCH']) {
+    const response = await request(
+      '/api/route',
+      '?profile=car&coords=-97,30;-97.01,30.01',
+      method,
+    );
+    assert.equal(response.statusCode, 405, method);
+    assert.deepEqual(response.body, { error: 'Method Not Allowed' });
+  }
+});

From fb6b4e34f0aab85c715146739152d753d5a3efa8 Mon Sep 17 00:00:00 2001
From: daikaginza <daika.ginza@gmail.com>
Date: Mon, 28 Sep 2026 13:16:17 +0700
Subject: [PATCH 03/71] docs: changelog entry for the read-only proxy method
 contract (#794)

---
 CHANGELOG.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 58103d04d..7885f0131 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+- The read-only query proxies state their method contract. `/api/opensky`,
+  `/api/adsblol/mil` and `/api/route` answered any verb with the same body
+  while ignoring the request; they now answer `405 Method Not Allowed` to
+  anything but `GET`, the way `/api/geocode` and the other query proxies
+  already did, and declare `Allow: GET` with it the way `/api/radio/stations`
+  does. The refusal precedes rate limiting and any upstream call
+  (daikaginza, #794).
+
 - Public Overpass instances are no longer used by default. Street Traffic
   roads come from TomTom flow tiles, OpenFreeMap vector tiles, or both, chosen
   on the layer row (TomTom / OSM / Hybrid) or with `?trafficRoads=`. With a

From 2e5dfce1af9b07664005bd1bd77e5bcb4ccf0ba4 Mon Sep 17 00:00:00 2001
From: daikaginza <daika.ginza@gmail.com>
Date: Tue, 29 Sep 2026 10:56:20 +0700
Subject: [PATCH 04/71] fix(server): declare Allow: GET on the new 405
 responses

RFC 9110 section 15.5.6 requires a 405 to name the methods it accepts, and
/api/radio/stations already does this in-tree. Thanks to kvnloo for catching it
on review. The same gap on the pre-existing handlers is tracked in #809 and is
deliberately left alone here.
---
 docs/CURRENT-STATE.md                 | 2 +-
 server/providers/aircraft/adsb-lol.js | 5 ++++-
 server/providers/aircraft/opensky.js  | 5 ++++-
 server/providers/places/routes.js     | 2 +-
 src/tooling/liveProviders.test.mjs    | 3 +++
 src/tooling/placeProviders.test.mjs   | 2 ++
 6 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 15e159ac8..6e3039920 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4072,7 +4072,7 @@ are omitted rather than framing the wrong part of the globe.
 - `/api/overpass` is bounded by body/response caps, per-client/global rate limits, concurrency limits, operator-configured upstreams, in-flight dedupe, cache bounds, and static validation that every selector is spatially bounded.
 - `/api/military-installations` uses an independent limiter with the same 90-per-client/300-global one-minute bounds, so viewport installation refreshes never consume `/api/overpass` annotation capacity.
 - `/api/route` proxies bounded OSRM route requests for annotation routes, with profile allowlisting, distance caps, response caps, caching, and sanitized "no route found" errors.
-- `/api/opensky`, `/api/adsblol/mil`, and `/api/route` are read-only query proxies and answer `405 Method Not Allowed` to anything but `GET`, as `/api/geocode` and the other query proxies already did. The refusal precedes rate limiting and any upstream call.
+- `/api/opensky`, `/api/adsblol/mil`, and `/api/route` are read-only query proxies and answer `405 Method Not Allowed` to anything but `GET`, as `/api/geocode` and the other query proxies already did, declaring `Allow: GET` with it as `/api/radio/stations` does. The refusal precedes rate limiting and any upstream call.
 - Track endpoints: `/api/ais-live/track?mmsi=` (server-accumulated ring buffers; sub-route handled before the rows snapshot), `/api/opensky-track?icao24=` (OAuth, 60s cache, sanitized errors, independent OpenSky credit bucket), `/api/adsblol/trace?hex=` (60s cache, 5MB cap, ODbL attribution required in UI).
 - Realtime debug logs redact API keys, bearer tokens, client secrets, and image data URLs before writing to disk; request bodies are size-capped.
 - `/api/realtime/debug-log` enforces an always-on 120-per-client/400-global one-minute limiter (not the opt-in `GEV_RATELIMIT_OPENAI_PER_MIN` bucket the cost-bearing OpenAI routes share), appends asynchronously through a serialized queue, and rotates `realtime-conversations.jsonl` at 32 MB keeping one prior generation, so the sink is bounded at twice that regardless of session length. A malformed record answers 400 and a failed write 500, both with a fixed message.
diff --git a/server/providers/aircraft/adsb-lol.js b/server/providers/aircraft/adsb-lol.js
index 80140bb56..1e5565832 100644
--- a/server/providers/aircraft/adsb-lol.js
+++ b/server/providers/aircraft/adsb-lol.js
@@ -71,7 +71,10 @@ export function adsbLolProxy() {
       // Read-only snapshot endpoint; match the method contract its sibling
       // query proxies already declare instead of serving every verb alike.
       if (req.method !== 'GET') {
-        res.writeHead(405, { 'Content-Type': 'application/json' });
+        res.writeHead(405, {
+          'Content-Type': 'application/json',
+          Allow: 'GET',
+        });
         res.end(JSON.stringify({ error: 'Method Not Allowed' }));
         return;
       }
diff --git a/server/providers/aircraft/opensky.js b/server/providers/aircraft/opensky.js
index aa0dad268..679548300 100644
--- a/server/providers/aircraft/opensky.js
+++ b/server/providers/aircraft/opensky.js
@@ -354,7 +354,10 @@ export function openSkyProxy() {
       // /api/geocode and the other query proxies state it, rather than
       // answering any verb with the same body and ignoring the request body.
       if (req.method !== 'GET') {
-        res.writeHead(405, { 'Content-Type': 'application/json' });
+        res.writeHead(405, {
+          'Content-Type': 'application/json',
+          Allow: 'GET',
+        });
         res.end(JSON.stringify({ error: 'Method Not Allowed' }));
         return;
       }
diff --git a/server/providers/places/routes.js b/server/providers/places/routes.js
index 8e837fcd4..2c67f1f5c 100644
--- a/server/providers/places/routes.js
+++ b/server/providers/places/routes.js
@@ -230,7 +230,7 @@ export function installRouteMiddleware(
     // The documented shape above is a GET with query parameters; say so,
     // the way the other query proxies do, instead of answering any verb.
     if (req.method !== 'GET') {
-      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.writeHead(405, { 'Content-Type': 'application/json', Allow: 'GET' });
       res.end(JSON.stringify({ error: 'Method Not Allowed' }));
       return;
     }
diff --git a/src/tooling/liveProviders.test.mjs b/src/tooling/liveProviders.test.mjs
index c25c445d4..856a528a2 100644
--- a/src/tooling/liveProviders.test.mjs
+++ b/src/tooling/liveProviders.test.mjs
@@ -398,6 +398,9 @@ test('the aircraft snapshot routes decline a non-GET before any upstream work',
     for (const method of ['POST', 'PUT', 'DELETE', 'PATCH']) {
       const response = await request(route, '/', method);
       assert.equal(response.statusCode, 405, `${method} ${route}`);
+      // RFC 9110 section 15.5.6 requires a 405 to name the methods it does
+      // accept, which is what `/api/radio/stations` already does in-tree.
+      assert.equal(response.headers.allow, 'GET', `${method} ${route}`);
       assert.deepEqual(JSON.parse(response.body), {
         error: 'Method Not Allowed',
       });
diff --git a/src/tooling/placeProviders.test.mjs b/src/tooling/placeProviders.test.mjs
index 968c5a9fa..afc323efc 100644
--- a/src/tooling/placeProviders.test.mjs
+++ b/src/tooling/placeProviders.test.mjs
@@ -498,6 +498,8 @@ test('the routing proxy declines a non-GET before rate limiting or upstream', as
       method,
     );
     assert.equal(response.statusCode, 405, method);
+    // RFC 9110 section 15.5.6 requires a 405 to name the methods it accepts.
+    assert.equal(response.headers.allow, 'GET', method);
     assert.deepEqual(response.body, { error: 'Method Not Allowed' });
   }
 });

From d3370d6bc4ce5f264fd29eece459052e6565cb1a Mon Sep 17 00:00:00 2001
From: daikaginza <daika.ginza@gmail.com>
Date: Sun, 18 Oct 2026 13:36:40 +0700
Subject: [PATCH 05/71] docs(changelog): move the entry into a changelog.d
 fragment

Main now takes pending entries as changelog.d/<pr>-<slug>.md
files (#787), so the entry leaves CHANGELOG.md for changelog.d/794-api-method-guard.md.
---
 changelog.d/794-api-method-guard.md | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 changelog.d/794-api-method-guard.md

diff --git a/changelog.d/794-api-method-guard.md b/changelog.d/794-api-method-guard.md
new file mode 100644
index 000000000..530be060e
--- /dev/null
+++ b/changelog.d/794-api-method-guard.md
@@ -0,0 +1,7 @@
+- The read-only query proxies state their method contract. `/api/flights`,
+  `/api/military` and `/api/route` answered any verb with the same body
+  while ignoring the request; they now answer `405 Method Not Allowed` to
+  anything but `GET`, the way `/api/geocode` and the other query proxies
+  already did, and declare `Allow: GET` with it the way `/api/radio/stations`
+  does. The refusal precedes rate limiting and any upstream call
+  (daikaginza, #794).

From 586ed4f8ea7f89ff24f82635419cee2e618b8856 Mon Sep 17 00:00:00 2001
From: Said <asturksever@mac.home>
Date: Tue, 20 Oct 2026 01:21:04 +0100
Subject: [PATCH 06/71] fix(tools): bound untrusted display text at output
 boundaries

---
 docs/CURRENT-STATE.md                   |  7 ++++++
 scripts/package-boundaries.json         |  6 +++++
 src/data/alprCameras.test.mjs           | 21 +++++++++++++++++
 src/data/displayText.js                 | 12 ++++++++++
 src/layers/alpr/records.js              |  3 ++-
 src/tools/queries/surveillance.js       | 11 +++++----
 src/tools/queries/surveillance.test.mjs | 31 +++++++++++++++++++++++++
 src/voice/gevActions.js                 | 19 +++++++--------
 src/voice/gevActions.test.mjs           | 13 +++++++++++
 9 files changed, 106 insertions(+), 17 deletions(-)
 create mode 100644 src/data/displayText.js

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 55b7a63ab..b3a48f66e 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -1,5 +1,12 @@
 # God's Eye View Current State
 
+External ALPR tags, surveillance-tool display fields, voice context text and
+compact analyst strings collapse controls and whitespace before a final
+180-character cap (scene labels retain their 120-character cap). Empty ALPR
+values remain null and Unicode text is preserved without splitting a surrogate
+pair. These fields remain untrusted source data in structured tool output; text
+normalization does not establish trust or eliminate prompt injection.
+
 Shared distance checks use `src/geoDistance.js` with `{ lat, lon }` points and
 the IUGG mean spherical Earth radius, 6371.0088 km. `greatCircleKm` is
 canonical; `greatCircleMeters` is its exact metre conversion. Missing,
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index ca5dc0c7f..859b030e7 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -1450,6 +1450,7 @@
       "src/layers/alpr/overlay.js",
       "src/layers/alpr/source.js",
       "src/data/inputOwnership.js",
+      "src/data/displayText.js",
       "src/layers/alpr/records.js",
       "src/data/tomtomTiles.js",
       "src/layers/alpr/tileRecords.js",
@@ -2228,6 +2229,7 @@
       "src/ui/visualSettings.js",
       "src/voice/commands.js",
       "src/voice/control.js",
+      "src/data/displayText.js",
       "src/voice/gevActions.js",
       "src/agent/worldPacket.js",
       "src/voice/speech.js",
@@ -2914,6 +2916,7 @@
       "src/search/coordinateParser.js",
       "src/search/presetGeocoder.js",
       "src/app/localGeojsonServices.js",
+      "src/data/displayText.js",
       "src/layers/alpr/records.js",
       "src/layers/earthquakes/records.js",
       "src/app/layers/perimeters.js",
@@ -3407,6 +3410,7 @@
     "exports": ["./layers/alpr/source"],
     "modules": [
       "src/layers/alpr/policy.js",
+      "src/data/displayText.js",
       "src/layers/alpr/records.js",
       "src/layers/alpr/source.js",
       "src/data/tomtomTiles.js",
@@ -3817,6 +3821,7 @@
       "src/i18n/marker.js",
       "src/tools/queries/imagery.js",
       "src/tools/queries/cables.js",
+      "src/data/displayText.js",
       "src/tools/queries/surveillance.js",
       "src/tools/queries/infrastructure.js",
       "src/tools/queries/events.js",
@@ -3923,6 +3928,7 @@
       "src/layers/submarineCables/bundledSource.js",
       "src/layers/alpr/source.js",
       "src/layers/alpr/policy.js",
+      "src/data/displayText.js",
       "src/layers/alpr/records.js",
       "src/layers/alpr/tileRecords.js",
       "src/sources/infrastructureData.js",
diff --git a/src/data/alprCameras.test.mjs b/src/data/alprCameras.test.mjs
index 5a50220d5..e68b11da3 100644
--- a/src/data/alprCameras.test.mjs
+++ b/src/data/alprCameras.test.mjs
@@ -1493,3 +1493,24 @@ test('a repeated move inside an outstanding query keeps the displayed marker set
     h.restore();
   }
 });
+
+test('ALPR display tags collapse controls and cap final text without erasing Unicode', () => {
+  const record = normalizeAlprNode({
+    type: 'node',
+    id: 1,
+    lat: 30,
+    lon: -97,
+    tags: {
+      'surveillance:type': 'ALPR',
+      operator: '  Şehir\n\u0000 PD  ',
+      manufacturer: '😀'.repeat(200),
+      'camera:type': null,
+      'surveillance:zone': '\t traffic   zone ',
+    },
+  });
+  assert.equal(record.operator, 'Şehir PD');
+  assert.equal(record.manufacturer.length, 180);
+  assert.equal(record.manufacturer, '😀'.repeat(90));
+  assert.equal(record.cameraType, null);
+  assert.equal(record.zone, 'traffic zone');
+});
diff --git a/src/data/displayText.js b/src/data/displayText.js
new file mode 100644
index 000000000..1138c4cc0
--- /dev/null
+++ b/src/data/displayText.js
@@ -0,0 +1,12 @@
+/** Bounded, single-line external display text; it remains untrusted source data. */
+export function normalizeDisplayText(value, maxLength = 180) {
+  if (value == null || typeof value === 'object' || typeof value === 'function')
+    return '';
+  return String(value)
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, maxLength)
+    .replace(/[\uD800-\uDBFF]$/, '')
+    .trim();
+}
diff --git a/src/layers/alpr/records.js b/src/layers/alpr/records.js
index 0d751f12d..d8d2ac104 100644
--- a/src/layers/alpr/records.js
+++ b/src/layers/alpr/records.js
@@ -1,7 +1,8 @@
+import { normalizeDisplayText } from '../../data/displayText.js';
 import { QUERY_LIMIT, QUERY_SNAP_DEGREES } from './policy.js';
 
 export function textTag(value) {
-  const t = String(value ?? '').trim();
+  const t = normalizeDisplayText(value);
   return t || null;
 }
 
diff --git a/src/tools/queries/surveillance.js b/src/tools/queries/surveillance.js
index 06723007a..4ddafabc2 100644
--- a/src/tools/queries/surveillance.js
+++ b/src/tools/queries/surveillance.js
@@ -1,5 +1,6 @@
 /** Automated license plate reader cameras mapped in OpenStreetMap. */
 
+import { normalizeDisplayText } from '../../data/displayText.js';
 import { suggestView } from '../views.js';
 import { defineTool, ToolError } from '../catalog.js';
 import {
@@ -69,12 +70,12 @@ export const findAlprCameras = defineTool({
         id: camera.id,
         lat: round(point.lat, 6),
         lon: round(point.lon, 6),
-        operator: camera.operator || null,
-        manufacturer: camera.manufacturer || null,
-        camera_type: camera.cameraType || null,
-        zone: camera.zone || null,
+        operator: normalizeDisplayText(camera.operator) || null,
+        manufacturer: normalizeDisplayText(camera.manufacturer) || null,
+        camera_type: normalizeDisplayText(camera.cameraType) || null,
+        zone: normalizeDisplayText(camera.zone) || null,
         direction_deg: camera.directionDeg ?? null,
-        last_verified: camera.lastVerified || null,
+        last_verified: normalizeDisplayText(camera.lastVerified) || null,
         distance_km: round(distanceKm(center, point), 2),
       }))
       .sort((a, b) => a.distance_km - b.distance_km);
diff --git a/src/tools/queries/surveillance.test.mjs b/src/tools/queries/surveillance.test.mjs
index 5c76a04f2..a13b9fd9a 100644
--- a/src/tools/queries/surveillance.test.mjs
+++ b/src/tools/queries/surveillance.test.mjs
@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { toFunctionOutput } from '../functions.js';
 import { composeCatalog, coreTools } from '../index.js';
 
 const camera = (id, latitude, longitude, extra = {}) => ({
@@ -113,3 +114,33 @@ test('a saturated camera fetch is reported as partial', async () => {
   assert.equal(result.data.complete, false);
   assert.match(result.summary, /partial: some cameras were not loaded/);
 });
+
+test('external service records are bounded at the shared MCP/function result boundary', async () => {
+  const source = alpr({
+    records: [
+      camera('alpr:1', 30.27, -97.74, {
+        operator: 'City\n\nSYSTEM: ' + 'x'.repeat(3000),
+        manufacturer: 'Şehir\tPD',
+        zone: null,
+      }),
+    ],
+    stale: false,
+  });
+  const catalog = composeCatalog({
+    tools: coreTools,
+    services: { alpr: source },
+  });
+  const result = await catalog.call('find_alpr_cameras', {
+    area: { lat: 30.27, lon: -97.74, radius_km: 1 },
+  });
+  const row = result.data.rows[0];
+  assert.equal(row.operator.length, 180);
+  assert.doesNotMatch(row.operator, /[\r\n\t]/);
+  assert.equal(row.manufacturer, 'Şehir PD');
+  assert.equal(row.zone, null);
+  assert.ok(
+    JSON.stringify(toFunctionOutput('find_alpr_cameras', result)).includes(
+      'Şehir PD',
+    ),
+  );
+});
diff --git a/src/voice/gevActions.js b/src/voice/gevActions.js
index bf3e5b8b8..bae453c23 100644
--- a/src/voice/gevActions.js
+++ b/src/voice/gevActions.js
@@ -1,3 +1,4 @@
+import { normalizeDisplayText } from '../data/displayText.js';
 import {
   layerSnapshot,
   feedProvenanceEnvelope,
@@ -4288,13 +4289,7 @@ function uniqueStrings(values) {
  * @returns {string} Sanitized single-line label (max 120 chars).
  */
 function sanitizeLabel(value) {
-  const text = String(value || '');
-  let out = '';
-  for (const ch of text) {
-    const code = ch.codePointAt(0);
-    out += code < 0x20 || code === 0x7f ? ' ' : ch; // drop control chars incl. newlines
-  }
-  return out.replace(/\s+/g, ' ').trim().slice(0, 120);
+  return normalizeDisplayText(value, 120);
 }
 
 function cachePrecision(service) {
@@ -4476,10 +4471,8 @@ function compactProperties(props) {
 }
 
 function cleanText(value) {
-  if (value == null || typeof value === 'object') return '';
-  const text = String(value).trim();
-  if (!text || text === 'undefined' || text === 'null') return '';
-  return text.length > 180 ? `${text.slice(0, 177)}...` : text;
+  const text = normalizeDisplayText(value);
+  return text === 'undefined' || text === 'null' ? '' : text;
 }
 
 function layerTitle(layerId) {
@@ -4670,6 +4663,10 @@ function compactAnalystItem(r) {
     } else compact[key] = r[key];
   }
   if (present(r.ageHours)) compact.ageHours = r.ageHours;
+  for (const key of Object.keys(compact)) {
+    if (typeof compact[key] === 'string')
+      compact[key] = normalizeDisplayText(compact[key]);
+  }
   return compact;
 }
 
diff --git a/src/voice/gevActions.test.mjs b/src/voice/gevActions.test.mjs
index 4a3a8ec72..2009d789e 100644
--- a/src/voice/gevActions.test.mjs
+++ b/src/voice/gevActions.test.mjs
@@ -3931,3 +3931,16 @@ test('analyst-only lookup distinguishes duplicate names and uses canonical aircr
   assert.equal(plane.ok, true);
   assert.equal(plane.latitude, 36, 'canonical ID resolves the current position, not old coordinates');
 });
+
+
+test('analyst item display strings are single-line and bounded for voice', async () => {
+  globalThis.window = globalThis.window || { clearTimeout, setTimeout, requestIdleCallback: null };
+  const rows = [{ id: 'stable-id', name: 'Şehir\n' + 'x'.repeat(3000), label: 'Town\tStation', operator: 'City\nPD', lat: 30, lon: -97 }];
+  const { runner } = manifestRunner({ bikeshare: { getStats: () => ({ count: 1, lastUpdate: Date.now() }), getAnalystRecords: () => rows } });
+  const result = await runner('analyst_query', { layers: ['bikeshare'], scope: { kind: 'anywhere' }, limit: 1 });
+  assert.equal(result.ok, true);
+  assert.equal(result.items[0].name.length, 180);
+  assert.equal(result.items[0].label, 'Town Station');
+  assert.equal(result.items[0].id, 'stable-id');
+  for (const value of Object.values(result.items[0])) if (typeof value === 'string') assert.doesNotMatch(value, /[\r\n\t]/);
+});

From 3685c416f3d0e13a2e19e9e70e777d3723b323cc Mon Sep 17 00:00:00 2001
From: Said <asturksever@mac.home>
Date: Tue, 20 Oct 2026 01:21:41 +0100
Subject: [PATCH 07/71] docs: record text fix

---
 changelog.d/1280-text-issue-fix.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 changelog.d/1280-text-issue-fix.md

diff --git a/changelog.d/1280-text-issue-fix.md b/changelog.d/1280-text-issue-fix.md
new file mode 100644
index 000000000..d13f3f9cc
--- /dev/null
+++ b/changelog.d/1280-text-issue-fix.md
@@ -0,0 +1 @@
+- Bound untrusted display text at output boundaries (asturksever, #1280).

From cbca6a228d83ff13a19a9f20bd9003a4eefd3d3a Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Fri, 23 Oct 2026 12:31:18 +0100
Subject: [PATCH 08/71] fix(voice): keep canonical analyst IDs out of
 display-text normalization

compactAnalystItem normalized every string field, including `id`.
Bikeshare uses the raw station name as its ID, so a station with
repeated spaces or a name over 180 code units was registered as a
referent under a different key and a numbered fly_to_location reported
it as no longer loaded. Normalize display fields only; layerKey, id,
icao24, mmsi, noradId, registration and callsign pass through as the
layer reports them.

Adds an analyst_query -> referent -> fly_to_location test for
repeated-space and long station names, and documents the rule in
docs/CURRENT-STATE.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/CURRENT-STATE.md         |  8 +++++--
 src/voice/gevActions.js       | 20 +++++++++++++++++-
 src/voice/gevActions.test.mjs | 40 +++++++++++++++++++++++++++++++++++
 3 files changed, 65 insertions(+), 3 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 721caabd4..0e875c1ea 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -13,8 +13,12 @@ External ALPR tags, surveillance-tool display fields, voice context text and
 compact analyst strings collapse controls and whitespace before a final
 180-character cap (scene labels retain their 120-character cap). Empty ALPR
 values remain null and Unicode text is preserved without splitting a surrogate
-pair. These fields remain untrusted source data in structured tool output; text
-normalization does not establish trust or eliminate prompt injection.
+pair. Only display fields are normalized: canonical analyst identifiers
+(`id`, `layerKey`, `icao24`, `mmsi`, `noradId`, `registration`, `callsign`)
+pass through unchanged, because bikeshare uses the raw station name as its ID
+and numbered voice references resolve by that key. These fields remain
+untrusted source data in structured tool output; text normalization does not
+establish trust or eliminate prompt injection.
 
 Terrain height requests accept at most 64 points, matching the browser service's
 existing batch size and one bounded upstream chunk. Larger requests return HTTP
diff --git a/src/voice/gevActions.js b/src/voice/gevActions.js
index 308736ed5..71610992c 100644
--- a/src/voice/gevActions.js
+++ b/src/voice/gevActions.js
@@ -4570,6 +4570,21 @@ const ANALYST_IDENTITY_FIELDS = Object.freeze([
   'noradId',
 ]);
 
+/**
+ * Analyst item keys that identify a record rather than describe it: the
+ * referent registry, track_entity and locateLayerEntity match on them, so
+ * display-text normalization must leave them byte-for-byte unchanged.
+ */
+const ANALYST_CANONICAL_FIELDS = new Set([
+  'layerKey',
+  'id',
+  'icao24',
+  'mmsi',
+  'noradId',
+  'registration',
+  'callsign',
+]);
+
 /**
  * Compact one analyst record for the voice payload: identity, position (so a
  * follow-up can fly to it), distance, and that layer's manifest fields with
@@ -4607,8 +4622,11 @@ function compactAnalystItem(r) {
     } else compact[key] = r[key];
   }
   if (present(r.ageHours)) compact.ageHours = r.ageHours;
+  // Display text only: canonical keys are lookup identities (bikeshare uses
+  // the raw station name as its id), so the referent registry and
+  // locateLayerEntity must see them exactly as the layer reports them.
   for (const key of Object.keys(compact)) {
-    if (typeof compact[key] === 'string')
+    if (typeof compact[key] === 'string' && !ANALYST_CANONICAL_FIELDS.has(key))
       compact[key] = normalizeDisplayText(compact[key]);
   }
   return compact;
diff --git a/src/voice/gevActions.test.mjs b/src/voice/gevActions.test.mjs
index 2009d789e..5367bd2f3 100644
--- a/src/voice/gevActions.test.mjs
+++ b/src/voice/gevActions.test.mjs
@@ -3944,3 +3944,43 @@ test('analyst item display strings are single-line and bounded for voice', async
   assert.equal(result.items[0].id, 'stable-id');
   for (const value of Object.values(result.items[0])) if (typeof value === 'string') assert.doesNotMatch(value, /[\r\n\t]/);
 });
+
+test('analyst_query keeps canonical IDs raw so numbered references still fly to the station', async () => {
+  globalThis.window = globalThis.window || { clearTimeout, setTimeout, requestIdleCallback: null };
+  const { viewer, styleManager } = createVoiceNavigationHarness();
+  const referents = createReferentRegistry();
+  const longName = 'Station ' + 'é'.repeat(200);
+  const spaced = 'Congress  Ave   & 2nd';
+  const stations = [
+    { id: spaced, name: spaced, lat: 30.2672, lon: -97.7431 },
+    { id: longName, name: longName, lat: 30.2711, lon: -97.7437 },
+  ];
+  const bikeshare = { getStats: () => ({ count: stations.length, lastUpdate: Date.now() }), getAnalystRecords: () => stations };
+  const runner = createActionRunner({
+    viewer, styleManager,
+    dataManager: {
+      layers: new Map([['bikeshare', { module: bikeshare }]]),
+      isEnabled: () => true,
+      getAll: () => [{ id: 'bikeshare', name: 'bikeshare', enabled: true, stats: bikeshare.getStats() }],
+    },
+    deixis: { referents },
+  });
+  const listed = await runner('analyst_query', { layers: ['bikeshare'], scope: { kind: 'anywhere' }, limit: 2 });
+  assert.equal(listed.ok, true);
+  const bySpaced = listed.items.find((item) => item.id === spaced);
+  const byLong = listed.items.find((item) => item.id === longName);
+  assert.ok(bySpaced && byLong, 'compact items keep the raw station-name IDs');
+  assert.equal(bySpaced.name, 'Congress Ave & 2nd', 'display name is still normalized');
+  assert.equal(byLong.name.length, 180, 'display name is still bounded');
+  assert.equal(byLong.id.length, longName.length);
+  const registered = referents.list();
+  assert.equal(registered.length, 2, 'the analyst result became the numbered list');
+  for (const ref of registered) {
+    const station = stations.find((row) => row.id === ref.id);
+    assert.ok(station, `referent ${ref.n} keeps the canonical ID`);
+    const flown = await runner('fly_to_location', { referent: ref.n });
+    assert.equal(flown.ok, true, `referent ${ref.n} resolves instead of "no longer loaded"`);
+    assert.equal(flown.latitude, station.lat);
+    assert.equal(flown.longitude, station.lon);
+  }
+});

From bbfb23a765e0bc2927993a4884317f38f92fa4bd Mon Sep 17 00:00:00 2001
From: BreezeDelegate <271538431+BreezeDelegate@users.noreply.github.com>
Date: Sat, 26 Sep 2026 00:04:43 +0200
Subject: [PATCH 09/71] fix(ci): run allocation gates on Node 26

---
 changelog.d/766-node26-allocation-gates.md   |  1 +
 docs/CURRENT-STATE.md                        | 17 +++++++-------
 scripts/qa-l9-matrix.mjs                     | 24 ++++++++++----------
 scripts/run-unit-tests.mjs                   | 22 +++++++++---------
 src/data/focusAllocations.test.mjs           |  2 +-
 src/overlays/worldOverlayAllocation.test.mjs |  2 +-
 src/qaL9MatrixVerdicts.test.mjs              |  3 ++-
 src/unitTestRunner.test.mjs                  | 23 ++++++++-----------
 8 files changed, 46 insertions(+), 48 deletions(-)
 create mode 100644 changelog.d/766-node26-allocation-gates.md

diff --git a/changelog.d/766-node26-allocation-gates.md b/changelog.d/766-node26-allocation-gates.md
new file mode 100644
index 000000000..a0fcb6a9f
--- /dev/null
+++ b/changelog.d/766-node26-allocation-gates.md
@@ -0,0 +1 @@
+- Run the existing GC-bracketed allocation regression gates on Node 26 as well as Node 24. Keep the current byte budgets so CI catches allocation regressions on both supported runtimes (#39).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index d49d92238..a7c2e2f7f 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -3148,9 +3148,9 @@ down | auth-failed` (plus the unchanged `missing-key`/`unsupported`) with
 >   style-switch persistence state. Browser/GPU performance comparison remains
 >   operator-side; the final accounting records only comparable population
 >   reductions and deterministic Node allocation/solve measurements. Those
->   allocation gates are calibrated on Node.js 24.14.x; `package.json` permits
->   supported product runtimes on Node 24 or 26, while the allocation runner
->   separately enforces Node 24 for these two calibrated probes. Each probe
+>   allocation gates are calibrated on both supported Node majors (24 and 26);
+>   `package.json` permits those same product runtimes, and the existing CI matrix
+>   executes the two calibrated probes on both entries. Each probe
 >   compiles synchronously and discards explicit-GC
 >   transition chunks before applying the unchanged byte ceilings. The unit
 >   runner executes ordinary test files with Node's default parallelism, then
@@ -4987,12 +4987,11 @@ and unreachable upstream (502/504) separately from road geometry.
 
 > **Reading `npm test` totals:** the count depends on the Node major. The two
 > GC-bracketed allocation microbenchmarks (`src/data/focusAllocations.test.mjs`
-> = 1 test, `src/overlays/worldOverlayAllocation.test.mjs` = 13) only RUN on the
-> calibrated Node 24 runtime; on any other major the runner skips both files and
-> their 14 tests are absent from the total. A branch total quoted without its
-> Node version is therefore not reproducible. As of the fly_route cinematic
-> branch: **2,281 on Node 25.6.1** (allocation suites skipped) = 2,255 on
-> `main` + 26 route pins; the same tree on Node 24 reports 2,295.
+> = 1 test, `src/overlays/worldOverlayAllocation.test.mjs` = 13) RUN on both
+> supported Node 24 and Node 26. Unsupported majors may still skip those files
+> unless `GEV_REQUIRE_ALLOCATION_GATE=1` is set; every current supported CI
+> matrix entry is calibrated and therefore executes them. Historical totals recorded from unsupported Node 25
+> runs can therefore remain lower because their 14 allocation tests were skipped.
 
 - **Camera verbs** (`src/cameraVerbs.js`) — one motion slot, driven per clock tick. `move_camera` orbits/pans/tilts/rotates; `fly_route` is a cinematic dolly along an existing route annotation. `rotate_globe` rotates the world-space camera rigidly around Earth's center using its screen-up axis, preserving geocentric range and framing. Left/right describe visible globe motion, while `rotate` turns the camera in place. Omitted globe direction/mode default to right/continuous; explicit values prevail. Other camera motions keep their once default. Admission requires 3D, no Cockpit/tracking owner and the whole globe inside the existing keyhole circle, using the shared keyhole/projection geometry and vertical camera FOV with a rotation-local bounding-sphere cone for off-axis containment. Canvas-edge clipping alone does not block a rigid rotation or its unchanged Globe View preset. There is no altitude cutoff. An already smaller, fully framed globe rotates directly; repeated nudges, direction and speed changes recheck current framing without demanding a reset merely because ellipsoid altitude varied. A close-up or overlap refuses without moving the camera. When the unchanged Globe View preset fits, voice says “Globe rotation isn’t available from this view. You can say ‘Reset to Globe View and rotate the globe.’” without asking a permission question or automatically resetting. Explicit Reset/Show Globe View commands remain direct; an explicit reset-and-rotate request waits for reset success before requesting rotation. If OpenAI dispatches both tools together, rotation waits for earlier same-response resets and is skipped if any fails or is cancelled. OpenAI rejects later tool calls in the same response after a globe refusal, including calls arriving while globe admission is pending, and preserves response-scoped `tool_choice: none` for the refusal follow-up; Gemini rejects further tool execution, including queued sibling calls, until fresh typed input or admitted speech. Model interruption, advisory captions and microphone toggles do not release that guard. There is no pending Yes/No offer. Outside the refused response, explicit-command interpretation and avoiding repeated resets remain model-guided; a distinct model-issued reset call is not an app-enforced proof of user intent. A failed standalone reset can still be retried by the model, and a reset result does not guarantee the camera has fully settled. Before suggesting a reset, a cloned camera checks the unchanged Globe View destination against the same keyhole/depth rules without moving the live camera. If that preset cannot fit, `globe-reset-unavailable` asks for further zoom and the refusal instructs further zoom instead of a reset; this also covers ultrawide views. Unsupported view geometry or non-WGS84 projection assumptions fail closed without the closer-zoom instruction. Supported camera inputs/navigation intents cancel rotation before their action. Finite radius greater than the ellipsoid's maximum radius proves whole-arc clearance at constant centre-distance; no low-altitude swept solver is needed. The unchanged Globe View reset preset remains 18,000,000 m. Terrain and buildings remain outside the guarantee.
   - **The route dolly is shaped, not linear** (2026-08-20). A trapezoid speed profile (smoothstep up, cruise, smoothstep down, distance taken as the closed-form integral) eases both ends without changing the pace — duration is still `totalM / ROUTE_M_S[speed]`, with one exception: a 0.5 s minimum keeps a degenerate route from being an instant teleport, so routes under 10 m (slow) / 20 m (normal) / 45 m (fast) fly SLOWER than the speed word, never faster. Turns bank up to **10°** (a 90° street corner settles near 7.5°), measured as a triangular pulse over a 4 s window centred on the camera so the roll leads in and unwinds after. Altitude breathes ±20 m around the 260 m mean and lifts up to 26 m into turns. Pitch is LOCKED at −32°; heading comes from a gaze that leads the path by 6.5 s of travel. `prefers-reduced-motion` zeroes the roll and the altitude shaping and keeps the easing.
diff --git a/scripts/qa-l9-matrix.mjs b/scripts/qa-l9-matrix.mjs
index 8709366de..d36bab9cb 100644
--- a/scripts/qa-l9-matrix.mjs
+++ b/scripts/qa-l9-matrix.mjs
@@ -239,11 +239,11 @@ function satisfiesEngines(version, range) {
  * re-resolve the interpreter from PATH and hand the gate a different Node than
  * the one the check believes it selected.
  * @param {string} version e.g. "v24.19.0"
- * @returns {boolean} true only for a parseable Node 24.
+ * @returns {boolean} true for a parseable supported Node 24 or 26.
  */
 function isCalibratedAllocationRuntime(version) {
   const [maj] = String(version || '').trim().replace(/^v/, '').split('.').map((n) => Number.parseInt(n, 10));
-  return maj === 24;
+  return maj === 24 || maj === 26;
 }
 
 /**
@@ -546,7 +546,7 @@ const check = (spec) => { CHECKS.push(spec); };
 
 // ─── A · REPO GATES ───────────────────────────────────────────────────────
 check({
-  id: 'A1', group: 'A', desc: 'Node runtime satisfies package.json engines (allocation budgets are pinned to Node 24)',
+  id: 'A1', group: 'A', desc: 'Node runtime satisfies package.json engines (allocation budgets cover supported Node majors)',
   run: async () => {
     const pkg = JSON.parse(readFileSync(resolve(REPO_ROOT, 'package.json'), 'utf8'));
     const range = pkg.engines?.node || '(unset)';
@@ -557,7 +557,7 @@ check({
     if (satisfied) return pass(`node ${process.versions.node} satisfies "${range}"`);
     // An off-range runtime is an environment problem, not a product defect —
     // but it silently disables the allocation gate, so say so loudly. A3 then
-    // runs that gate under a discovered Node 24.
+    // runs that gate under a discovered calibrated Node 24 fallback.
     return env.node24
       ? skip(`node ${process.versions.node} is OUTSIDE "${range}"; A3 runs the allocation gate under ${env.node24.label}, but prefer running the whole L9 pass on Node 24`, 'ENV')
       : fail(`node ${process.versions.node} is OUTSIDE "${range}" and no Node 24 runtime was found — the allocation gate cannot run at all`);
@@ -579,13 +579,13 @@ check({
 });
 
 check({
-  id: 'A3', group: 'A', desc: 'Allocation microbenchmarks actually EXECUTE (they silently skip off Node 24)',
+  id: 'A3', group: 'A', desc: 'Allocation microbenchmarks actually EXECUTE on supported Node majors',
   run: async () => {
     // npm test prints "[unit] SKIPPED n allocation microbenchmarks" and still
-    // exits 0 when the runtime is not Node 24. A green suite is therefore NOT
-    // proof the gate ran. Force it, under Node 24 when one is discoverable.
+    // exits 0 when the runtime is outside the calibrated supported majors. A green
+    // suite is therefore NOT proof the gate ran. Force it under a calibrated runtime.
     //
-    // ALWAYS invoke the Node 24 BINARY directly — never `npm test`. npm
+    // ALWAYS invoke the calibrated Node binary directly — never `npm test`. npm
     // re-resolves the interpreter from PATH and can land back on the system
     // Node even when THIS process is already 24: running the whole matrix under
     // `mise exec node@24.19.0 --`, the npm shell-out still re-execed system
@@ -597,10 +597,10 @@ check({
       const v = await sh(bin, ['--version'], { timeoutMs: 60000 });
       const version = (v.out || '').trim();
       if (!isCalibratedAllocationRuntime(version)) {
-        // run-unit-tests.mjs refuses to measure calibrated budgets off Node 24,
+        // run-unit-tests.mjs refuses to measure calibrated budgets off supported Node majors,
         // so a wrong binary means the gate never ran. That is this check failing
         // to establish its own claim — not evidence about the product.
-        return crash(`the runtime selected for the allocation gate (${label}) reports ${version || 'no parseable version'}, not Node 24 — the gate would refuse or silently skip, so this check verified nothing`);
+        return crash(`the runtime selected for the allocation gate (${label}) reports ${version || 'no parseable version'}, not Node 24 or 26 — the gate would refuse or silently skip, so this check verified nothing`);
       }
       const r = await sh(bin, [resolve(REPO_ROOT, 'scripts/run-unit-tests.mjs')], {
         timeoutMs: 600000, env: { GEV_REQUIRE_ALLOCATION_GATE: '1' },
@@ -611,9 +611,9 @@ check({
     };
 
     const [maj] = process.versions.node.split('.').map(Number);
-    if (maj === 24) return runGate(process.execPath, 'this runtime');
+    if (maj === 24 || maj === 26) return runGate(process.execPath, 'this runtime');
     if (env.node24) return runGate(env.node24.bin, env.node24.label);
-    return skip(`no Node 24 runtime found (running ${process.versions.node}); the gate SKIPS silently — install Node 24 and re-run`, 'OWNER-RUN');
+    return skip(`no calibrated Node 24/26 runtime found (running ${process.versions.node}); the gate SKIPS silently — install a supported Node runtime and re-run`, 'OWNER-RUN');
   },
 });
 
diff --git a/scripts/run-unit-tests.mjs b/scripts/run-unit-tests.mjs
index 3712df28e..29c3e2b00 100644
--- a/scripts/run-unit-tests.mjs
+++ b/scripts/run-unit-tests.mjs
@@ -8,15 +8,16 @@ export const ALLOCATION_TEST_FILES = Object.freeze([
   'src/overlays/worldOverlayAllocation.test.mjs',
 ]);
 
-/** Whether this runtime matches the one the allocation budgets were calibrated on. */
+/** Whether this runtime matches a supported major the allocation budgets are calibrated on. */
 export function isCalibratedAllocationRuntime(version = process.versions.node) {
-  return Number.parseInt(String(version).split('.')[0], 10) === 24;
+  const major = Number.parseInt(String(version).split('.')[0], 10);
+  return major === 24 || major === 26;
 }
 
-/** Require the runtime on which allocation budgets were calibrated. */
-export function assertNode24AllocationRuntime(version = process.versions.node) {
+/** Require a runtime on which allocation budgets are calibrated. */
+export function assertCalibratedAllocationRuntime(version = process.versions.node) {
   if (!isCalibratedAllocationRuntime(version)) {
-    throw new Error(`Allocation budgets require the calibrated Node 24 runtime; received ${version}`);
+    throw new Error(`Allocation budgets require calibrated Node 24 or 26; received ${version}`);
   }
   return version;
 }
@@ -86,19 +87,18 @@ export function runUnitTests() {
   const parallelStatus = runTests(['--test', ...plan.parallel]);
   if (parallelStatus !== 0) return parallelStatus;
 
-  // The GC-bracketed budgets are calibrated on Node 24 and are meaningless on
-  // other allocators. A contributor's suite must stay green on any supported
-  // engine (package.json permits >=24), so uncalibrated runtimes skip the
+  // The GC-bracketed budgets are calibrated on every supported Node major.
+  // Unsupported runtimes may still run ordinary tests, so uncalibrated runtimes skip the
   // probes with a warning. Set GEV_REQUIRE_ALLOCATION_GATE=1 (pinned CI /
   // release batteries) to make an uncalibrated runtime a hard failure.
   if (!isCalibratedAllocationRuntime()) {
     if (process.env.GEV_REQUIRE_ALLOCATION_GATE === '1') {
-      assertNode24AllocationRuntime();
+      assertCalibratedAllocationRuntime();
     }
     console.warn(
       `[unit] SKIPPED ${ALLOCATION_TEST_FILES.length} allocation microbenchmarks: `
-      + `budgets are calibrated for Node 24, running ${process.versions.node}. `
-      + 'Run under Node 24 (or set GEV_REQUIRE_ALLOCATION_GATE=1 to fail instead).',
+      + `budgets are calibrated for Node 24 and 26, running ${process.versions.node}. `
+      + 'Run under Node 24 or 26 (or set GEV_REQUIRE_ALLOCATION_GATE=1 to fail instead).',
     );
     return 0;
   }
diff --git a/src/data/focusAllocations.test.mjs b/src/data/focusAllocations.test.mjs
index 86f28db18..f58e5f121 100644
--- a/src/data/focusAllocations.test.mjs
+++ b/src/data/focusAllocations.test.mjs
@@ -13,7 +13,7 @@ import { isCalibratedAllocationRuntime } from '../../scripts/run-unit-tests.mjs'
  */
 test('converged focus treatment stays within the GC-bracketed allocation budget', (t) => {
   if (!isCalibratedAllocationRuntime()) {
-    return t.skip(`allocation budgets are calibrated for Node 24; running ${process.versions.node}`);
+    return t.skip(`allocation budgets are calibrated for Node 24 or 26; running ${process.versions.node}`);
   }
   const result = spawnSync(
     process.execPath,
diff --git a/src/overlays/worldOverlayAllocation.test.mjs b/src/overlays/worldOverlayAllocation.test.mjs
index e29785d48..70197097a 100644
--- a/src/overlays/worldOverlayAllocation.test.mjs
+++ b/src/overlays/worldOverlayAllocation.test.mjs
@@ -333,7 +333,7 @@ function runAllocationProbe(entryCount, profile = 'generic') {
 for (const workload of WORKLOADS) {
   test(`steady moving-source frames stay in budget ${workload.name}`, (t) => {
     if (!CALIBRATED_ALLOCATION_RUNTIME) {
-      return t.skip(`allocation budgets are calibrated for Node 24; running ${process.versions.node}`);
+      return t.skip(`allocation budgets are calibrated for Node 24 or 26; running ${process.versions.node}`);
     }
     const payload = runAllocationProbe(workload.entries, workload.profile);
 
diff --git a/src/qaL9MatrixVerdicts.test.mjs b/src/qaL9MatrixVerdicts.test.mjs
index 867e34410..2ec826e8d 100644
--- a/src/qaL9MatrixVerdicts.test.mjs
+++ b/src/qaL9MatrixVerdicts.test.mjs
@@ -127,9 +127,10 @@ test('an unevaluable engines range reports unknown rather than guessing', () =>
 // A full pass run under `mise exec node@24 --` still re-execed system Node 25
 // through npm; the forced gate refused ("received 25.6.1") and A3 reported it
 // as a product failure. A3 now invokes the binary directly and checks it.
-test('only a parseable Node 24 counts as the calibrated allocation runtime', () => {
+test('every supported Node major counts as a calibrated allocation runtime', () => {
   assert.equal(isCalibratedAllocationRuntime('v24.19.0'), true);
   assert.equal(isCalibratedAllocationRuntime('24.19.0'), true, 'the v prefix is optional');
+  assert.equal(isCalibratedAllocationRuntime('v26.3.0'), true);
   assert.equal(isCalibratedAllocationRuntime('v25.6.1'), false, 'the npm re-resolution case');
   assert.equal(isCalibratedAllocationRuntime('v22.21.1'), false);
   for (const junk of ['', '   ', 'node', undefined, null]) {
diff --git a/src/unitTestRunner.test.mjs b/src/unitTestRunner.test.mjs
index 80d9091e0..e206726e8 100644
--- a/src/unitTestRunner.test.mjs
+++ b/src/unitTestRunner.test.mjs
@@ -7,7 +7,7 @@ import {
   ALLOCATION_TEST_FILES,
   UNIT_TEST_ROOTS,
   allocationTestArgs,
-  assertNode24AllocationRuntime,
+  assertCalibratedAllocationRuntime,
   buildUnitTestPlan,
   discoverUnitTestFiles,
   isCalibratedAllocationRuntime,
@@ -87,30 +87,27 @@ test('the runner discovers every test file in the repository', () => {
   }
 });
 
-test('allocation runtime calibration is explicit and pinned to Node 24', () => {
-  assert.equal(assertNode24AllocationRuntime('24.19.0'), '24.19.0');
+test('allocation runtime calibration covers both supported Node majors', () => {
+  assert.equal(assertCalibratedAllocationRuntime('24.19.0'), '24.19.0');
   assert.throws(
-    () => assertNode24AllocationRuntime('22.23.1'),
-    /calibrated Node 24 runtime/,
-  );
-  assert.throws(
-    () => assertNode24AllocationRuntime('26.0.0'),
-    /calibrated Node 24 runtime/,
+    () => assertCalibratedAllocationRuntime('22.23.1'),
+    /calibrated Node 24 or 26/,
   );
+  assert.equal(assertCalibratedAllocationRuntime('26.0.0'), '26.0.0');
   assert.equal(isCalibratedAllocationRuntime('24.19.0'), true);
   assert.equal(isCalibratedAllocationRuntime('22.23.1'), false);
-  assert.equal(isCalibratedAllocationRuntime('26.3.0'), false);
+  assert.equal(isCalibratedAllocationRuntime('26.3.0'), true);
 });
 
-test('npm test stays green on every supported engine, not only the calibrated one', () => {
+test('npm test calibrates both supported engines while retaining off-range warnings', () => {
   // package.json wiring: `npm test` must invoke this runner, and the engines
   // range it advertises must not be narrower than what the runner tolerates.
   const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
   assert.equal(pkg.scripts.test, 'node scripts/run-unit-tests.mjs');
   const enginesNode = String(pkg.engines?.node || '');
   assert.ok(enginesNode, 'engines.node must be declared');
-  // The runner throws for uncalibrated runtimes ONLY behind the explicit
-  // opt-in env; by default it skips, so a supported non-24 engine cannot fail.
+  // Unsupported runtimes only skip probes without the explicit opt-in hard gate.
+  // Node 26 is calibrated and runs those probes with the same budgets.
   const runner = readFileSync(new URL('../scripts/run-unit-tests.mjs', import.meta.url), 'utf8');
   assert.match(runner, /GEV_REQUIRE_ALLOCATION_GATE/);
   assert.match(runner, /SKIPPED .*allocation microbenchmarks/);

From 84c1fef8d34dfd4dd556b6dca6bda9e3d2cf6b75 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Itallo=20Brand=C3=A3o?=
 <45429643+IMBrandao@users.noreply.github.com>
Date: Wed, 4 Nov 2026 15:15:34 -0300
Subject: [PATCH 10/71] fix(firms): stop requesting the retired Suomi NPP
 source

NASA stopped delivering Suomi NPP data on 2026-11-02 (FIRMS news page).
With a live MAP_KEY on 2026-11-04, VIIRS_SNPP_NRT came back ok with zero
rows while NOAA-20, NOAA-21 and MODIS returned 57k, 49k and 11k, so the
source only spent one transaction per refresh. The proxy now requests
NOAA-20, NOAA-21 and MODIS NRT. The "N" satellite label stays, so cached
or archived Suomi NPP rows still read SNPP.

Tests count sources from the list instead of assuming four, and a
regression test keeps the retired source out of the production list.

Refs #849

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 DATA_SOURCES.md                           |  7 ++++---
 docs/CURRENT-STATE.md                     |  5 +++++
 server/providers/firms.js                 | 14 ++++++--------
 src/data/firmsProxy.test.mjs              | 18 ++++++++++++++----
 src/tooling/environmentProviders.test.mjs |  4 ++--
 5 files changed, 31 insertions(+), 17 deletions(-)

diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index cac0b5ab7..efee6b9ff 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -273,11 +273,12 @@ Bundled OSM-derived data is distributed under [ODbL 1.0](https://opendatacommons
 > We acknowledge the use of data and/or imagery from NASA's Fire Information for Resource Management System (FIRMS) (https://earthdata.nasa.gov/firms), part of NASA's Earth Observing System Data and Information System (EOSDIS).
 
 FIRMS active fires are **fetched live at runtime** (CC0 / U.S. public domain data): the
-`/api/firms` server-side proxy merges the three VIIRS NRT sources (NOAA-20, NOAA-21,
-Suomi-NPP) and MODIS NRT (Terra + Aqua), clamped to the trailing 24 h, cached 30 min to respect the shared MAP_KEY
+`/api/firms` server-side proxy merges the two VIIRS NRT sources (NOAA-20, NOAA-21)
+and MODIS NRT (Terra + Aqua), clamped to the trailing 24 h, cached 30 min to respect the shared MAP_KEY
 transaction quota. Requires a free `FIRMS_MAP_KEY`
 (https://firms.modaps.eosdis.nasa.gov/api/map_key/); the layer is empty without it.
-The former bundled 2026-05-25 snapshot was removed 2026-07-16.
+The former bundled 2026-05-25 snapshot was removed 2026-07-16. Suomi NPP (`VIIRS_SNPP_NRT`)
+is no longer requested: NASA stopped delivering its data on 2026-11-02.
 
 ### Natural Earth physical regions (`natural_earth/`)
 
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index e868dfc95..102efb997 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -2325,6 +2325,11 @@ accessible name remains "Don't show this again". Control behavior is unchanged.
 
 ## FIRMS source status
 
+The FIRMS proxy requests VIIRS NOAA-20, VIIRS NOAA-21 and MODIS NRT (Terra and
+Aqua). It no longer requests VIIRS Suomi NPP: NASA stopped delivering Suomi NPP
+data on 2026-11-02, and the source returned no rows while still costing one
+MAP_KEY transaction per refresh.
+
 The FIRMS CSV parser rejects impossible acquisition calendar dates before the proxy filters records to the trailing 24 hours, while retaining valid UTC acquisition times.
 The `get_active_fires` tool reports acquisition times as UTC ISO timestamps,
 including zero-padded hours and minutes; missing or invalid dates and times
diff --git a/server/providers/firms.js b/server/providers/firms.js
index 20a2f4bab..51ea4fc56 100644
--- a/server/providers/firms.js
+++ b/server/providers/firms.js
@@ -131,8 +131,8 @@ export async function fetchFirms(
  * NASA FIRMS live active-fire proxy with a memory + disk cache.
  * Upstream: https://firms.modaps.eosdis.nasa.gov/api/area/csv/{KEY}/{SOURCE}/world/2
  *
- * Merges three VIIRS NRT sources (NOAA-20, NOAA-21, Suomi-NPP — independent
- * satellites, no cross-source dedup) plus MODIS_NRT (combined Terra+Aqua,
+ * Merges two VIIRS NRT sources (NOAA-20, NOAA-21 — independent satellites, no
+ * cross-source dedup) plus MODIS_NRT (combined Terra+Aqua,
  * ~1 km, numeric 0-100 confidence), fetched sequentially (quota courtesy)
  * with `days=2` (`days=1` means "current UTC day", nearly empty just after
  * 00:00Z) and clamps to the trailing 24 h via src/data/firmsCsv.js. FIRMS
@@ -141,6 +141,9 @@ export async function fetchFirms(
  * fresh-enough disk cache (.gev-cache/firms.json) prevents ANY upstream
  * fetch across dev-server restarts. Pattern mirrors celestrakProxy.
  *
+ * VIIRS_SNPP_NRT is not requested: NASA stopped delivering Suomi NPP data on
+ * 2026-11-02, so that source only spent a transaction per refresh (#849).
+ *
  * Routes:
  *   GET /api/firms        → {fetchedAt, stale, ttlMs, sources, count, fires}
  *   GET /api/firms/status → {hasKey, lastFetch, count, stale, ttlMs, transactions}
@@ -153,12 +156,7 @@ export async function fetchFirms(
 export function firmsProxy() {
   const TTL_MS = 30 * 60_000;
   const STATUS_TTL_MS = 5 * 60_000;
-  const SOURCES = [
-    'VIIRS_NOAA20_NRT',
-    'VIIRS_NOAA21_NRT',
-    'VIIRS_SNPP_NRT',
-    'MODIS_NRT',
-  ];
+  const SOURCES = ['VIIRS_NOAA20_NRT', 'VIIRS_NOAA21_NRT', 'MODIS_NRT'];
   /**
    * Per-source body cap. A VIIRS world/2 pull is ~130k rows x ~100 B, about
    * 13 MB per satellite in heavy fire season (MODIS runs smaller), so this is a
diff --git a/src/data/firmsProxy.test.mjs b/src/data/firmsProxy.test.mjs
index 14668c825..135002ca7 100644
--- a/src/data/firmsProxy.test.mjs
+++ b/src/data/firmsProxy.test.mjs
@@ -21,7 +21,7 @@ assert.notEqual(start, -1, 'FIRMS refresh function exists');
 const end = config.indexOf('\n  }', start);
 assert.notEqual(end, -1, 'FIRMS refresh function closes');
 const refreshSource = config.slice(start, end + 4);
-const SOURCES = ['VIIRS_NOAA20_NRT', 'VIIRS_NOAA21_NRT', 'VIIRS_SNPP_NRT', 'MODIS_NRT'];
+const SOURCES = ['VIIRS_NOAA20_NRT', 'VIIRS_NOAA21_NRT', 'MODIS_NRT'];
 const NOW = Date.UTC(2026, 8, 11, 12);
 const recent = { acqDate: '2026-09-11', acqTime: '1100' };
 
@@ -63,7 +63,7 @@ test('FIRMS keeps successful sources when another upstream fails', async () => {
     if (source === SOURCES[1]) throw new Error('upstream unavailable');
     return [recent];
   })('fixture');
-  assert.equal(result.fires.length, 3);
+  assert.equal(result.fires.length, SOURCES.length - 1);
   assert.deepEqual(result.sources, SOURCES.map((source, index) => ({
     source, count: index === 1 ? 0 : 1, ok: index !== 1,
   })));
@@ -77,7 +77,7 @@ test('FIRMS reports one failure if consuming a source throws before append', asy
       // Fault injection for aggregation; ordinary parsed CSV returns an array.
       return { length: 1, [Symbol.iterator]() { throw new Error('aggregation failed'); } };
     })('fixture');
-  assert.equal(result.fires.length, 3);
+  assert.equal(result.fires.length, SOURCES.length - 1);
   assert.deepEqual(result.sources, SOURCES.map((source, index) => ({
     source, count: index === 0 ? 0 : 1, ok: index !== 0,
   })));
@@ -107,7 +107,7 @@ function wrappedAddressSelectionFailure() {
     { name: 'ConnectTimeoutError', code: 'UND_ERR_CONNECT_TIMEOUT', cause: inner });
   return new TypeError('fetch failed', { cause });
 }
-const URL_WITH_KEY = 'https://firms.modaps.eosdis.nasa.gov/api/area/csv/SECRET/VIIRS_SNPP_NRT/world/2';
+const URL_WITH_KEY = 'https://firms.modaps.eosdis.nasa.gov/api/area/csv/SECRET/VIIRS_NOAA20_NRT/world/2';
 
 test('FIRMS failures log the socket cause, never the keyed URL', () => {
   const described = describeFetchError(addressSelectionFailure());
@@ -307,3 +307,13 @@ test('every FIRMS upstream request goes through the IPv4 fallback', async () =>
   assert.ok(calls[0][2] instanceof AbortSignal);
   assert.deepEqual(calls[1], ['read', response, calls[0][2]], 'the body read shares the request deadline');
 });
+
+test('FIRMS requests only the satellites NASA still delivers', () => {
+  const listed = config.match(/const SOURCES = \[([^\]]*)\];/);
+  assert.ok(listed, 'FIRMS source list exists');
+  const production = [...listed[1].matchAll(/'([A-Z0-9_]+)'/g)].map((m) => m[1]);
+  assert.deepEqual(production, SOURCES, 'the test mirrors the production source list');
+  // NASA stopped delivering Suomi NPP data on 2026-11-02 (#849): requesting it
+  // returns no rows and still spends a MAP_KEY transaction on every refresh.
+  assert.ok(!production.includes('VIIRS_SNPP_NRT'));
+});
diff --git a/src/tooling/environmentProviders.test.mjs b/src/tooling/environmentProviders.test.mjs
index da3cfc335..feca9432d 100644
--- a/src/tooling/environmentProviders.test.mjs
+++ b/src/tooling/environmentProviders.test.mjs
@@ -313,9 +313,9 @@ test('FIRMS retains a large successful source during partial failure and filters
   const first = json(await request());
   assert.equal(first.count, 130001);
   assert.equal(first.sources.filter((s) => s.ok).length, 1);
-  assert.equal(calls, 4);
+  assert.equal(calls, first.sources.length);
   assert.equal(json(await request()).count, 130001);
-  assert.equal(calls, 4);
+  assert.equal(calls, first.sources.length);
   assert.deepEqual(json(await request('/status')).transactions, {
     used: 3,
     limit: 5000,

From b342e405d7514505861ab26244f38496a59350cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Itallo=20Brand=C3=A3o?=
 <45429643+IMBrandao@users.noreply.github.com>
Date: Wed, 4 Nov 2026 15:20:09 -0300
Subject: [PATCH 11/71] docs(changelog): add fragment for #1552

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 changelog.d/1552-firms-drop-snpp.md | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 changelog.d/1552-firms-drop-snpp.md

diff --git a/changelog.d/1552-firms-drop-snpp.md b/changelog.d/1552-firms-drop-snpp.md
new file mode 100644
index 000000000..fcb375bda
--- /dev/null
+++ b/changelog.d/1552-firms-drop-snpp.md
@@ -0,0 +1,4 @@
+- Stop requesting Suomi NPP in Active Fires. NASA stopped delivering its data
+  on November 2, 2026, so `VIIRS_SNPP_NRT` returned no rows while still costing
+  a MAP_KEY transaction on every refresh; the layer now merges VIIRS NOAA-20,
+  VIIRS NOAA-21 and MODIS (IMBrandao, #1552).

From b37025414d90d6b696dcecd252c222972c00c557 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Itallo=20Brand=C3=A3o?=
 <45429643+IMBrandao@users.noreply.github.com>
Date: Thu, 5 Nov 2026 02:57:27 -0300
Subject: [PATCH 12/71] test(firms): pin the refresh call count and read
 sources from production

Review follow-up for #1552:
- environmentProviders: assert exactly 3 upstream calls per refresh again,
  so a returning fourth source would fail the test.
- firmsProxy: build the test's SOURCES from server/providers/firms.js, so
  there is one list instead of a mirrored copy.
- firmsProxy: drop the unused fourth count entry.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/data/firmsProxy.test.mjs              | 13 ++++++-------
 src/tooling/environmentProviders.test.mjs |  4 ++--
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/data/firmsProxy.test.mjs b/src/data/firmsProxy.test.mjs
index 135002ca7..dc9ed8144 100644
--- a/src/data/firmsProxy.test.mjs
+++ b/src/data/firmsProxy.test.mjs
@@ -21,7 +21,10 @@ assert.notEqual(start, -1, 'FIRMS refresh function exists');
 const end = config.indexOf('\n  }', start);
 assert.notEqual(end, -1, 'FIRMS refresh function closes');
 const refreshSource = config.slice(start, end + 4);
-const SOURCES = ['VIIRS_NOAA20_NRT', 'VIIRS_NOAA21_NRT', 'MODIS_NRT'];
+// Read the source list from production so these tests share one source of truth.
+const listed = config.match(/const SOURCES = \[([^\]]*)\];/);
+assert.ok(listed, 'FIRMS source list exists');
+const SOURCES = [...listed[1].matchAll(/'([A-Z0-9_]+)'/g)].map((m) => m[1]);
 const NOW = Date.UTC(2026, 8, 11, 12);
 const recent = { acqDate: '2026-09-11', acqTime: '1100' };
 
@@ -54,7 +57,7 @@ test('FIRMS retains large sources in order and filters expired rows', async () =
   assert.equal(result.fires[199_999], large.at(-1));
   assert.equal(result.fires.at(-1), last);
   assert.deepEqual(result.sources, SOURCES.map((source, index) => ({
-    source, count: [200_000, 1, 0, 0][index], ok: true,
+    source, count: [200_000, 1, 0][index], ok: true,
   })));
 });
 
@@ -309,11 +312,7 @@ test('every FIRMS upstream request goes through the IPv4 fallback', async () =>
 });
 
 test('FIRMS requests only the satellites NASA still delivers', () => {
-  const listed = config.match(/const SOURCES = \[([^\]]*)\];/);
-  assert.ok(listed, 'FIRMS source list exists');
-  const production = [...listed[1].matchAll(/'([A-Z0-9_]+)'/g)].map((m) => m[1]);
-  assert.deepEqual(production, SOURCES, 'the test mirrors the production source list');
   // NASA stopped delivering Suomi NPP data on 2026-11-02 (#849): requesting it
   // returns no rows and still spends a MAP_KEY transaction on every refresh.
-  assert.ok(!production.includes('VIIRS_SNPP_NRT'));
+  assert.ok(!SOURCES.includes('VIIRS_SNPP_NRT'));
 });
diff --git a/src/tooling/environmentProviders.test.mjs b/src/tooling/environmentProviders.test.mjs
index feca9432d..22eb39ad3 100644
--- a/src/tooling/environmentProviders.test.mjs
+++ b/src/tooling/environmentProviders.test.mjs
@@ -313,9 +313,9 @@ test('FIRMS retains a large successful source during partial failure and filters
   const first = json(await request());
   assert.equal(first.count, 130001);
   assert.equal(first.sources.filter((s) => s.ok).length, 1);
-  assert.equal(calls, first.sources.length);
+  assert.equal(calls, 3);
   assert.equal(json(await request()).count, 130001);
-  assert.equal(calls, first.sources.length);
+  assert.equal(calls, 3);
   assert.deepEqual(json(await request('/status')).transactions, {
     used: 3,
     limit: 5000,

From b6ad32009fec418d1a5bbff4aa18adb1fbf5cd4c Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Thu, 5 Nov 2026 12:52:28 +0400
Subject: [PATCH 13/71] Say why Transit and Bike Share rows are empty outside
 coverage
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Over a city with no feed or system (London, Tokyo) both rows read
"ON · — · never", the same as a feed that never answered. Transit already
computed a coverage note but put it only in `coverage`, which the row does
not show; Bike Share reported nothing at all.

Both layers now report a `zoom-in` guidance status with a `statusMessage`:
"Fly below 3,000 km to a covered region" / "No feed here yet · N regions
available" for Transit, and "Fly below 48 km to a covered city" / "No bike
share here yet · N systems available" for Bike Share. A loading or failed
Bike Share city keeps its own text. Leaving coverage clears the layer's
last-update time, so the row no longer dates data it no longer draws.

The coverage-note translations move from the voice card into
`translateStatusMessage` (ui/statusText.js), which the Layers row and the
voice card now share.
---
 docs/CURRENT-STATE.md                        |  13 ++
 src/i18n/locales/ar.json                     |   9 ++
 src/i18n/locales/de.json                     |   5 +
 src/i18n/locales/es.json                     |   6 +
 src/i18n/locales/fr.json                     |   6 +
 src/i18n/locales/it.json                     |   6 +
 src/i18n/locales/ja.json                     |   4 +
 src/i18n/locales/pt.json                     |   6 +
 src/i18n/locales/ru.json                     |   7 ++
 src/i18n/locales/uk.json                     |   7 ++
 src/i18n/locales/zh-CN.json                  |   4 +
 src/i18n/locales/zh-Hant.json                |   4 +
 src/layers/bikeshare/controls.js             |  22 +++-
 src/layers/bikeshare/coverageStatus.test.mjs | 124 +++++++++++++++++++
 src/layers/bikeshare/viewport.js             |   3 +
 src/layers/transit/lifecycle.test.mjs        |  39 ++++++
 src/layers/transit/queries.js                |  13 +-
 src/layers/transit/viewport.js               |   3 +
 src/ui/layerPanel.js                         |   9 +-
 src/ui/layerPanel.test.mjs                   |  54 ++++++++
 src/ui/statusText.js                         |  63 ++++++++++
 src/ui/statusText.test.mjs                   |  58 ++++++++-
 src/voice/resultDisplay.js                   |  31 +----
 23 files changed, 459 insertions(+), 37 deletions(-)
 create mode 100644 src/layers/bikeshare/coverageStatus.test.mjs

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index f1244947d..8368eeacf 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -1817,6 +1817,19 @@ Mapped-installation zoom guidance appears in the layer row without counting as
 a global loading failure. Guidance statuses do not suppress independent refresh
 errors.
 
+Transit and Bike Share report the same kind of guidance when no feed or system
+covers the view, instead of an undated `never`. Above their altitude gates the
+rows read `GTFS-RT · Fly below 3,000 km to a covered region` and
+`GBFS · Fly below 48 km to a covered city`; lower down over a city neither
+covers (London, Tokyo) they read `GTFS-RT · No feed here yet · N regions
+available` and `GBFS · No bike share here yet · N systems available`, N being
+the enabled feeds and the catalogued systems. The
+chip stays ON. A Bike Share city that is loading or failed keeps its own
+loading or error text. Leaving every covered feed or system clears the layer's
+last-update time, so the row never dates data it no longer draws. The same
+English notes are the voice analyst's empty-result notes; both surfaces show
+them translated through `translateStatusMessage` (`src/ui/statusText.js`).
+
 ## Places and CCTV request bounds
 
 With a Google key configured, nearby and text search reject missing, blank,
diff --git a/src/i18n/locales/ar.json b/src/i18n/locales/ar.json
index c9fca14ce..b7193b9e8 100644
--- a/src/i18n/locales/ar.json
+++ b/src/i18n/locales/ar.json
@@ -2912,6 +2912,15 @@
     "many": "لا مصدر بيانات هنا بعد · {n} منطقة متاحة",
     "other": "لا مصدر بيانات هنا بعد · {n} منطقة متاحة"
   },
+  "Fly below {km} km to a covered city": "انخفض إلى ما دون {km} كم فوق مدينة مغطاة",
+  "No bike share here yet · {n} systems available": {
+    "zero": "لا دراجات مشتركة هنا بعد · {n} نظام متاح",
+    "one": "لا دراجات مشتركة هنا بعد · نظام واحد متاح ({n})",
+    "two": "لا دراجات مشتركة هنا بعد · نظامان متاحان ({n})",
+    "few": "لا دراجات مشتركة هنا بعد · {n} أنظمة متاحة",
+    "many": "لا دراجات مشتركة هنا بعد · {n} نظامًا متاحًا",
+    "other": "لا دراجات مشتركة هنا بعد · {n} نظام متاح"
+  },
   "degraded": "متدهور",
   "stale": "متقادم",
   "partial": "جزئي",
diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json
index bb683ed9f..57be9f388 100644
--- a/src/i18n/locales/de.json
+++ b/src/i18n/locales/de.json
@@ -2662,6 +2662,11 @@
     "one": "Hier noch kein Feed · {n} Region verfügbar",
     "other": "Hier noch kein Feed · {n} Regionen verfügbar"
   },
+  "Fly below {km} km to a covered city": "Unter {km} km Höhe zu einer abgedeckten Stadt fliegen",
+  "No bike share here yet · {n} systems available": {
+    "one": "Hier noch kein Bikesharing · {n} System verfügbar",
+    "other": "Hier noch kein Bikesharing · {n} Systeme verfügbar"
+  },
   "degraded": "eingeschränkt",
   "stale": "veraltet",
   "partial": "teilweise",
diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json
index 10dcbef8f..2a3bb478d 100644
--- a/src/i18n/locales/es.json
+++ b/src/i18n/locales/es.json
@@ -2821,6 +2821,12 @@
     "many": "Aún no hay fuente aquí · {n} de regiones disponibles",
     "other": "Aún no hay fuente aquí · {n} regiones disponibles"
   },
+  "Fly below {km} km to a covered city": "Desciende por debajo de {km} km sobre una ciudad con cobertura",
+  "No bike share here yet · {n} systems available": {
+    "one": "Aún no hay bicis compartidas aquí · {n} sistema disponible",
+    "many": "Aún no hay bicis compartidas aquí · {n} de sistemas disponibles",
+    "other": "Aún no hay bicis compartidas aquí · {n} sistemas disponibles"
+  },
   "Wind speed field unavailable": "Campo de velocidad del viento no disponible",
   "Decoder feeds": "Fuentes del decodificador",
   "WebUSB + decoder feeds": "WebUSB + fuentes del decodificador",
diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json
index 108e56f36..57186643b 100644
--- a/src/i18n/locales/fr.json
+++ b/src/i18n/locales/fr.json
@@ -2531,6 +2531,12 @@
     "many": "Pas encore de flux ici · {n} de régions disponibles",
     "other": "Pas encore de flux ici · {n} régions disponibles"
   },
+  "Fly below {km} km to a covered city": "Descendez sous {km} km au-dessus d'une ville couverte",
+  "No bike share here yet · {n} systems available": {
+    "one": "Pas encore de vélos partagés ici · {n} système disponible",
+    "many": "Pas encore de vélos partagés ici · {n} de systèmes disponibles",
+    "other": "Pas encore de vélos partagés ici · {n} systèmes disponibles"
+  },
   "degraded": "dégradé",
   "stale": "obsolète",
   "partial": "partiel",
diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json
index 6768f93c7..cecbc7a03 100644
--- a/src/i18n/locales/it.json
+++ b/src/i18n/locales/it.json
@@ -2531,6 +2531,12 @@
     "many": "Ancora nessun feed qui · {n} di regioni disponibili",
     "other": "Ancora nessun feed qui · {n} regioni disponibili"
   },
+  "Fly below {km} km to a covered city": "Scendi sotto {km} km su una città coperta",
+  "No bike share here yet · {n} systems available": {
+    "one": "Ancora nessun bike sharing qui · {n} sistema disponibile",
+    "many": "Ancora nessun bike sharing qui · {n} di sistemi disponibili",
+    "other": "Ancora nessun bike sharing qui · {n} sistemi disponibili"
+  },
   "degraded": "degradato",
   "stale": "obsoleto",
   "partial": "parziale",
diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json
index b4566b4cb..47a84c9d4 100644
--- a/src/i18n/locales/ja.json
+++ b/src/i18n/locales/ja.json
@@ -2401,6 +2401,10 @@
   "No feed here yet · {n} regions available": {
     "other": "ここにはまだフィードがありません · 利用可能な地域 {n}か所"
   },
+  "Fly below {km} km to a covered city": "{km} km未満まで高度を下げ、カバー範囲内の都市へ移動してください",
+  "No bike share here yet · {n} systems available": {
+    "other": "ここにはまだシェアサイクルがありません · 利用可能なシステム {n}件"
+  },
   "degraded": "性能低下",
   "stale": "更新遅延",
   "partial": "部分的",
diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json
index 3f37cde2e..2ac851bc0 100644
--- a/src/i18n/locales/pt.json
+++ b/src/i18n/locales/pt.json
@@ -2533,6 +2533,12 @@
     "many": "Ainda não há feed aqui · {n} de regiões disponíveis",
     "other": "Ainda não há feed aqui · {n} regiões disponíveis"
   },
+  "Fly below {km} km to a covered city": "Desça abaixo de {km} km sobre uma cidade com cobertura",
+  "No bike share here yet · {n} systems available": {
+    "one": "Ainda não há bicicletas compartilhadas aqui · {n} sistema disponível",
+    "many": "Ainda não há bicicletas compartilhadas aqui · {n} de sistemas disponíveis",
+    "other": "Ainda não há bicicletas compartilhadas aqui · {n} sistemas disponíveis"
+  },
   "degraded": "degradado",
   "stale": "desatualizado",
   "partial": "parcial",
diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json
index e279508ef..cba8c8796 100644
--- a/src/i18n/locales/ru.json
+++ b/src/i18n/locales/ru.json
@@ -2884,6 +2884,13 @@
     "many": "Здесь пока нет потока данных · доступно {n} регионов",
     "other": "Здесь пока нет потока данных · доступно {n} региона"
   },
+  "Fly below {km} km to a covered city": "Опуститесь ниже {km} км над городом с покрытием",
+  "No bike share here yet · {n} systems available": {
+    "one": "Здесь пока нет проката велосипедов · доступна {n} система",
+    "few": "Здесь пока нет проката велосипедов · доступны {n} системы",
+    "many": "Здесь пока нет проката велосипедов · доступно {n} систем",
+    "other": "Здесь пока нет проката велосипедов · доступно {n} системы"
+  },
   "Wind speed field unavailable": "Поле скорости ветра недоступно",
   "Decoder feeds": "Потоки декодера",
   "WebUSB + decoder feeds": "WebUSB + потоки декодера",
diff --git a/src/i18n/locales/uk.json b/src/i18n/locales/uk.json
index 8c3b634b9..71054ea18 100644
--- a/src/i18n/locales/uk.json
+++ b/src/i18n/locales/uk.json
@@ -2595,6 +2595,13 @@
     "many": "Тут поки немає потоку даних · доступно {n} регіонів",
     "other": "Тут поки немає потоку даних · доступно {n} регіону"
   },
+  "Fly below {km} km to a covered city": "Опустіться нижче {km} км над містом із покриттям",
+  "No bike share here yet · {n} systems available": {
+    "one": "Тут поки немає прокату велосипедів · доступна {n} система",
+    "few": "Тут поки немає прокату велосипедів · доступні {n} системи",
+    "many": "Тут поки немає прокату велосипедів · доступно {n} систем",
+    "other": "Тут поки немає прокату велосипедів · доступно {n} системи"
+  },
   "degraded": "з перебоями",
   "stale": "застарів",
   "partial": "частково",
diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json
index 6125315f2..0d4033ced 100644
--- a/src/i18n/locales/zh-CN.json
+++ b/src/i18n/locales/zh-CN.json
@@ -2302,6 +2302,10 @@
   "No feed here yet · {n} regions available": {
     "other": "此处暂无数据源 · 有 {n} 个覆盖区域"
   },
+  "Fly below {km} km to a covered city": "请降至 {km} km 以下并飞往有覆盖的城市",
+  "No bike share here yet · {n} systems available": {
+    "other": "此处暂无共享单车 · 有 {n} 个可用系统"
+  },
   "degraded": "降级",
   "stale": "过期",
   "partial": "部分可用",
diff --git a/src/i18n/locales/zh-Hant.json b/src/i18n/locales/zh-Hant.json
index 66eb37b96..457a32aeb 100644
--- a/src/i18n/locales/zh-Hant.json
+++ b/src/i18n/locales/zh-Hant.json
@@ -2290,6 +2290,10 @@
   "No feed here yet · {n} regions available": {
     "other": "此處暫無數據源 · 有 {n} 個覆蓋區域"
   },
+  "Fly below {km} km to a covered city": "請降至 {km} km 以下並飛往有覆蓋的城市",
+  "No bike share here yet · {n} systems available": {
+    "other": "此處暫無共享單車 · 有 {n} 個可用系統"
+  },
   "degraded": "降級",
   "stale": "過期",
   "partial": "部分可用",
diff --git a/src/layers/bikeshare/controls.js b/src/layers/bikeshare/controls.js
index 5f73a2dc9..993022506 100644
--- a/src/layers/bikeshare/controls.js
+++ b/src/layers/bikeshare/controls.js
@@ -1,5 +1,6 @@
 import { msg, t } from '../../i18n/index.js';
-import { STATUS_POLL_MS } from './policy.js';
+import { ACTIVATION_ENTER_ALTITUDE_M, STATUS_POLL_MS } from './policy.js';
+import { GBFS_CITY_REGISTRY } from './registry.js';
 
 export function createControls({ state: layerState, services, parts, source }) {
   const methods = {
@@ -57,7 +58,7 @@ export function createControls({ state: layerState, services, parts, source }) {
 
     /**
      * Return current layer statistics for the UI status display.
-     * @returns {{ count: number, lastUpdate: number|null, loading: boolean, loadingLabel?: string, error?: string, degraded?: boolean, stale?: boolean }}
+     * @returns {{ count: number, lastUpdate: number|null, loading: boolean, loadingLabel?: string, error?: string, degraded?: boolean, stale?: boolean, status?: string, statusMessage?: string }}
      */
     getStats() {
       const stats = {
@@ -65,6 +66,23 @@ export function createControls({ state: layerState, services, parts, source }) {
         lastUpdate: layerState._lastUpdate,
         loading: layerState._loading,
       };
+      // No system in range is guidance, not an empty feed: the camera is too
+      // high, or no catalogued system is near the view. A city that failed
+      // leaves range empty too, and reports its failure below instead.
+      if (
+        layerState._enabled &&
+        !layerState._loading &&
+        layerState._activeCityIds.size === 0 &&
+        layerState._failedCityIds.size === 0
+      ) {
+        // English data (the analyst's empty note to the model, and the Layers
+        // row's prompt); both show it through translateStatusMessage
+        // (ui/statusText.js).
+        const note = layerState._altitudeGateEnabled
+          ? `No bike share here yet · ${GBFS_CITY_REGISTRY.length} systems available`
+          : `Fly below ${Math.round(ACTIVATION_ENTER_ALTITUDE_M / 1000).toLocaleString('en-US')} km to a covered city`;
+        return { ...stats, status: 'zoom-in', statusMessage: note };
+      }
       if (layerState._loading) {
         stats.loadingLabel =
           layerState._activeCityIds.size > 0
diff --git a/src/layers/bikeshare/coverageStatus.test.mjs b/src/layers/bikeshare/coverageStatus.test.mjs
new file mode 100644
index 000000000..a9f17e73e
--- /dev/null
+++ b/src/layers/bikeshare/coverageStatus.test.mjs
@@ -0,0 +1,124 @@
+// BIKESHARE COVERAGE STATUS — a view with no system says so.
+//
+// Over a city with no catalogued system (London, Tokyo) the layer drew nothing
+// and reported nothing, so its row read "ON · — · GBFS · never": the same as a
+// feed that had never answered. These cases pin the rule that replaced it:
+// with no system in range the layer reports a guidance status that says why,
+// and a view it left keeps no date for data it no longer draws.
+//
+// Run with: npm test
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createState } from './state.js';
+import { createControls } from './controls.js';
+import { createModel } from './model.js';
+import { createViewport } from './viewport.js';
+import { GBFS_CITY_REGISTRY } from './registry.js';
+
+const LONDON = { lat: 51.5072, lon: -0.1276 };
+
+function makeLayer() {
+  const services = {
+    overlays: {
+      setOverlayEntries() {},
+      setOverlaySourceVisible() {},
+      clearOverlaySource() {},
+    },
+    render: { governorRequestRender() {} },
+  };
+  const state = createState({ services });
+  const parts = {
+    queries: { collectDetectableStations: () => [] },
+    model: createModel({ state, services, parts: {}, source: null }),
+    ingestion: { abortInFlight() {} },
+    rendering: { removeCityPoints() {} },
+  };
+  parts.viewport = createViewport({ state, services, parts, source: null });
+  const { methods } = createControls({ state, services, parts, source: {} });
+  state._enabled = true;
+  return { state, methods, viewport: parts.viewport };
+}
+
+/** A viewer looking straight down at `at` from `height` metres. */
+function viewerAt(at, height) {
+  const rad = Math.PI / 180;
+  return {
+    camera: {
+      positionCartographic: {
+        height,
+        latitude: at.lat * rad,
+        longitude: at.lon * rad,
+      },
+      computeViewRectangle: () => undefined,
+    },
+    scene: { globe: {} },
+  };
+}
+
+test('above the altitude gate the row says how low to fly', async () => {
+  const { state, methods, viewport } = makeLayer();
+  state._viewer = viewerAt(LONDON, 2_000_000);
+  await viewport.runProximityCheck();
+
+  const stats = methods.getStats();
+  assert.equal(stats.status, 'zoom-in');
+  assert.equal(stats.statusMessage, 'Fly below 48 km to a covered city');
+  assert.equal(stats.error, undefined);
+});
+
+test('a city with no system says so and counts the ones there are', async () => {
+  const { state, methods, viewport } = makeLayer();
+  state._viewer = viewerAt(LONDON, 8_000);
+  await viewport.runProximityCheck();
+
+  const stats = methods.getStats();
+  assert.equal(stats.status, 'zoom-in');
+  assert.equal(
+    stats.statusMessage,
+    `No bike share here yet · ${GBFS_CITY_REGISTRY.length} systems available`,
+  );
+  assert.equal(stats.count, 0);
+});
+
+test('a city with a system in range is not given the prompt', () => {
+  const { state, methods } = makeLayer();
+  state._altitudeGateEnabled = true;
+  state._activeCityIds.add('boston-bluebikes');
+
+  assert.equal(methods.getStats().status, undefined);
+});
+
+test('a loading or failed city reports itself, not the prompt', () => {
+  const { state, methods } = makeLayer();
+  state._altitudeGateEnabled = true;
+  state._loading = true;
+  assert.equal(methods.getStats().status, undefined);
+
+  // A city that failed is dropped from range, and still owns the row.
+  state._loading = false;
+  state._failedCityIds.add('boston-bluebikes');
+  const stats = methods.getStats();
+  assert.equal(stats.status, undefined);
+  assert.equal(stats.error, 'GBFS fetch error');
+});
+
+test('a disabled layer reports no prompt', () => {
+  const { state, methods } = makeLayer();
+  state._enabled = false;
+  assert.equal(methods.getStats().status, undefined);
+});
+
+test('leaving every system behind drops the date of the data it drew', async () => {
+  for (const height of [8_000, 2_000_000]) {
+    const { state, methods, viewport } = makeLayer();
+    state._lastUpdate = Date.now();
+    // Boston's stations were drawn and dated; the camera moves to London.
+    state._activeCityIds.add('boston-bluebikes');
+    state._cityRuntime.set('boston-bluebikes', {});
+    state._viewer = viewerAt(LONDON, height);
+    await viewport.runProximityCheck();
+
+    assert.equal(state._activeCityIds.size, 0);
+    assert.equal(methods.getStats().lastUpdate, null, `at ${height} m`);
+  }
+});
diff --git a/src/layers/bikeshare/viewport.js b/src/layers/bikeshare/viewport.js
index 25a4df7d0..0739d341c 100644
--- a/src/layers/bikeshare/viewport.js
+++ b/src/layers/bikeshare/viewport.js
@@ -125,6 +125,8 @@ export function createViewport({ state: layerState, services, parts, source }) {
     // A failure belongs to a city in range; none are once everything is off.
     layerState._failedCityIds.clear();
     layerState._count = 0;
+    // Nothing is left on the map to date.
+    layerState._lastUpdate = null;
   }
 
   /**
@@ -227,6 +229,7 @@ export function createViewport({ state: layerState, services, parts, source }) {
     layerState._activeCityIds = nextActive;
     if (layerState._activeCityIds.size === 0) {
       layerState._count = 0;
+      layerState._lastUpdate = null;
       return;
     }
 
diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs
index ea547f85d..a269dc9e9 100644
--- a/src/layers/transit/lifecycle.test.mjs
+++ b/src/layers/transit/lifecycle.test.mjs
@@ -3982,3 +3982,42 @@ test('parked transit reprojects held and reported courses at the bounded camera
     'selected unknown course also stays screen-up',
   );
 });
+
+test('a view with no feed reads its coverage prompt, not an undated feed', async (t) => {
+  const app = harness(t);
+  app.serve('mbta', () => ({
+    status: 200,
+    body: snapshot(
+      'mbta',
+      'MBTA',
+      [vehicle('bus-1', 42.36, -71.06, Date.now() / 1000)],
+      { fetchedAt: Date.now() },
+    ),
+  }));
+  app.layer.enable(app.viewer);
+  await app.layer.update();
+  assert.ok(app.layer.getStats().lastUpdate, 'Boston has a dated snapshot');
+
+  // London has no registered feed: the row prompts instead of dating Boston's
+  // last snapshot over an empty map.
+  app.lookAt({ west: -0.2, south: 51.45, east: -0.05, north: 51.55 });
+  app.advance(1_000);
+  const away = app.layer.getStats();
+  assert.equal(away.status, 'zoom-in');
+  assert.equal(away.count, 0);
+  assert.equal(away.lastUpdate, null);
+  assert.match(
+    away.statusMessage,
+    /^No feed here yet · \d+ regions available$/,
+  );
+  assert.equal(away.coverage, away.statusMessage);
+
+  // Above the altitude gate the prompt says how low to fly.
+  app.viewer.camera.positionCartographic.height = 10_000_000;
+  app.lookAt({ west: -0.2, south: 51.45, east: -0.05, north: 51.55 });
+  app.advance(1_000);
+  assert.equal(
+    app.layer.getStats().statusMessage,
+    'Fly below 3,000 km to a covered region',
+  );
+});
diff --git a/src/layers/transit/queries.js b/src/layers/transit/queries.js
index b86613160..8023cdb39 100644
--- a/src/layers/transit/queries.js
+++ b/src/layers/transit/queries.js
@@ -240,17 +240,20 @@ export function createQueries({ state, parts }) {
       const health = aggregateTransitFeedHealth(statuses, now);
       const count = state._vehicles.size;
       if (state._enabled && active.length === 0) {
+        // English data (the analyst's empty note to the model, and the Layers
+        // row's prompt); both show it through translateStatusMessage
+        // (ui/statusText.js).
+        const note = state._altitudeGateOpen
+          ? `No feed here yet · ${TRANSIT_ENABLED_FEEDS.length} regions available`
+          : `Fly below ${Math.round(ACTIVATION_ALTITUDE_M / 1000).toLocaleString('en-US')} km to a covered region`;
         return {
           count: 0,
           lastUpdate: state._lastUpdate,
           error: null,
           source: 'GTFS-RT',
           status: 'zoom-in',
-          // English data (the analyst's empty note to the model); the voice
-          // card shows it through NOTE_PATTERNS (voice/resultDisplay.js).
-          coverage: state._altitudeGateOpen
-            ? `No feed here yet · ${TRANSIT_ENABLED_FEEDS.length} regions available`
-            : `Fly below ${Math.round(ACTIVATION_ALTITUDE_M / 1000).toLocaleString('en-US')} km to a covered region`,
+          statusMessage: note,
+          coverage: note,
         };
       }
       // Age is shown by the same rule the row state uses, so the text and the
diff --git a/src/layers/transit/viewport.js b/src/layers/transit/viewport.js
index 730126f10..27cc0569c 100644
--- a/src/layers/transit/viewport.js
+++ b/src/layers/transit/viewport.js
@@ -108,6 +108,9 @@ export function createViewport({ state, services, parts }) {
         parts.ingestion.removeFeedVehicles(feedId);
       }
     }
+    // Leaving coverage leaves nothing on the map to date: a row that read
+    // "26s ago" over an empty view would claim a feed that is no longer here.
+    if (desired.size === 0) state._lastUpdate = null;
     for (const [feedId, feed] of desired) {
       if (!state._activeFeeds.has(feedId)) {
         state._activeFeeds.set(feedId, feed);
diff --git a/src/ui/layerPanel.js b/src/ui/layerPanel.js
index b24e8be7b..29a4bc3c0 100644
--- a/src/ui/layerPanel.js
+++ b/src/ui/layerPanel.js
@@ -11,14 +11,17 @@ import {
 } from './layerNames.js';
 export { localizeLayerName } from './layerNames.js';
 import { createWeatherPanel } from './weatherPanel.js';
-import { translateFeedError, translateStatusLine } from './statusText.js';
+import {
+  translateFeedError,
+  translateStatusLine,
+  translateStatusMessage,
+} from './statusText.js';
 import {
   formatNumber,
   getLocale,
   msg,
   onLocaleChange,
   t,
-  translateKnown,
 } from '../i18n/index.js';
 
 // Feed-state values are machine ids (QA hooks, CSS feed-* classes); only the
@@ -691,7 +694,7 @@ export class LayerPanel {
       typeof stats.statusMessage === 'string' &&
       stats.statusMessage.trim()
     ) {
-      return `${source} · ${translateKnown(stats.statusMessage.trim())}`;
+      return `${source} · ${translateStatusMessage(stats.statusMessage.trim())}`;
     }
     const ago = stats.lastUpdate ? this._timeAgo(stats.lastUpdate) : t('never');
     if (stats.loading) {
diff --git a/src/ui/layerPanel.test.mjs b/src/ui/layerPanel.test.mjs
index 73710e3fc..1be2df5d7 100644
--- a/src/ui/layerPanel.test.mjs
+++ b/src/ui/layerPanel.test.mjs
@@ -431,3 +431,57 @@ test('without the Utilities list, Directions stays in Data Layers under Utilitie
     restore();
   }
 });
+
+test('a layer with no feed in view says why instead of "never"', async () => {
+  const { LayerPanel, presentLayerCount, presentLayerToggle } =
+    await import('./layerPanel.js');
+  const { setLocale } = await import('../i18n/index.js');
+  const panel = LayerPanel.prototype;
+  const rows = [
+    {
+      id: 'transit',
+      name: 'Transit',
+      source: 'GTFS-RT',
+      enabled: true,
+      stats: {
+        count: 0,
+        lastUpdate: null,
+        source: 'GTFS-RT',
+        status: 'zoom-in',
+        statusMessage: 'No feed here yet · 16 regions available',
+      },
+      meta: 'GTFS-RT · No feed here yet · 16 regions available',
+    },
+    {
+      id: 'bikeshare',
+      name: 'Bikeshare',
+      source: 'GBFS',
+      enabled: true,
+      stats: {
+        count: 0,
+        lastUpdate: null,
+        loading: false,
+        status: 'zoom-in',
+        statusMessage: 'Fly below 48 km to a covered city',
+      },
+      meta: 'GBFS · Fly below 48 km to a covered city',
+    },
+  ];
+  for (const layer of rows) {
+    // Guidance is normal operation: the layer is on and nothing has failed.
+    assert.equal(presentLayerToggle(layer).text, 'ON');
+    assert.equal(presentLayerCount(layer.stats).empty, true);
+    assert.equal(panel._buildMetaText(layer), layer.meta);
+  }
+
+  setLocale('ru');
+  try {
+    for (const layer of rows) {
+      const meta = panel._buildMetaText(layer);
+      assert.doesNotMatch(meta, /never|Fly below|No feed|covered/, meta);
+      assert.match(meta, /^(GTFS-RT|GBFS) · /, meta);
+    }
+  } finally {
+    setLocale('en');
+  }
+});
diff --git a/src/ui/statusText.js b/src/ui/statusText.js
index 1af6b8b2a..f4cbb59a0 100644
--- a/src/ui/statusText.js
+++ b/src/ui/statusText.js
@@ -265,3 +265,66 @@ export function translateStatusLine(text) {
     .map(translateStatusPiece)
     .join(STATUS_SEPARATOR);
 }
+
+/** Thousands separators out of an English number ("3,000" → 3000). */
+const englishNumber = (text) => Number(text.replace(/,/g, ''));
+
+// Coverage notes of a layer whose view has no feed, whole lines with a number
+// in them: transit (transit/queries.js) and bikeshare (bikeshare/controls.js).
+// Their " · " is part of one sentence, so they are matched before the line is
+// split into pieces. Keep these in step with the producers.
+const COVERAGE_NOTE_PATTERNS = [
+  [
+    /^Fly below ([\d,]+) km to a covered region$/,
+    ([, km]) =>
+      t('Fly below {km} km to a covered region', {
+        km: formatNumber(englishNumber(km)),
+      }),
+  ],
+  [
+    /^No feed here yet · ([\d,]+) regions available$/,
+    ([, regions]) => {
+      const count = englishNumber(regions);
+      return tn(
+        count,
+        'No feed here yet · {n} region available',
+        'No feed here yet · {n} regions available',
+        { n: formatNumber(count) },
+      );
+    },
+  ],
+  [
+    /^Fly below ([\d,]+) km to a covered city$/,
+    ([, km]) =>
+      t('Fly below {km} km to a covered city', {
+        km: formatNumber(englishNumber(km)),
+      }),
+  ],
+  [
+    /^No bike share here yet · ([\d,]+) systems available$/,
+    ([, systems]) => {
+      const count = englishNumber(systems);
+      return tn(
+        count,
+        'No bike share here yet · {n} system available',
+        'No bike share here yet · {n} systems available',
+        { n: formatNumber(count) },
+      );
+    },
+  ],
+];
+
+/**
+ * A layer's status message in the UI language: its catalog entry, a coverage
+ * note by its shape, or a status line translated piece by piece.
+ */
+export function translateStatusMessage(text) {
+  if (typeof text !== 'string') return text;
+  const known = translateKnown(text);
+  if (known !== text) return known;
+  for (const [pattern, format] of COVERAGE_NOTE_PATTERNS) {
+    const match = pattern.exec(text);
+    if (match) return format(match);
+  }
+  return translateStatusLine(text);
+}
diff --git a/src/ui/statusText.test.mjs b/src/ui/statusText.test.mjs
index a64975c48..1b6479b45 100644
--- a/src/ui/statusText.test.mjs
+++ b/src/ui/statusText.test.mjs
@@ -3,7 +3,11 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { setLocale, t } from '../i18n/index.js';
-import { translateFeedError, translateStatusLine } from './statusText.js';
+import {
+  translateFeedError,
+  translateStatusLine,
+  translateStatusMessage,
+} from './statusText.js';
 
 function inLocale(locale, run) {
   setLocale(locale);
@@ -75,3 +79,55 @@ for (const locale of ['es', 'ru']) {
     });
   });
 }
+
+// A layer's coverage note when no feed covers the view: one sentence with a
+// " · " in it (transit/queries.js, bikeshare/controls.js).
+const COVERAGE_NOTES = [
+  'Fly below 3,000 km to a covered region',
+  'No feed here yet · 16 regions available',
+  'Fly below 48 km to a covered city',
+  'No bike share here yet · 61 systems available',
+];
+
+test('en: coverage notes show as they came', () => {
+  setLocale('en');
+  for (const text of COVERAGE_NOTES)
+    assert.equal(translateStatusMessage(text), text);
+  assert.equal(
+    translateStatusMessage('No bike share here yet · 1 systems available'),
+    'No bike share here yet · 1 system available',
+  );
+});
+
+for (const locale of ['es', 'ru', 'ja']) {
+  test(`${locale}: a coverage note translates whole, numbers kept`, () => {
+    inLocale(locale, () => {
+      for (const text of COVERAGE_NOTES) {
+        const shown = translateStatusMessage(text);
+        assert.doesNotMatch(
+          shown,
+          /\b(Fly|below|covered|feed|bike share|available)\b/,
+          shown,
+        );
+        const number = /[\d,]+(?= km| regions| systems)/.exec(text)[0];
+        assert.ok(
+          shown.replace(/[^\d]/g, '').includes(number.replace(/,/g, '')),
+          shown,
+        );
+      }
+    });
+  });
+
+  test(`${locale}: a status message without a coverage note keeps its other forms`, () => {
+    inLocale(locale, () => {
+      assert.equal(
+        translateStatusMessage('Upstream response too large'),
+        t('Upstream response too large'),
+      );
+      assert.equal(
+        translateStatusMessage('2 feeds live · 14 heard'),
+        translateStatusLine('2 feeds live · 14 heard'),
+      );
+    });
+  });
+}
diff --git a/src/voice/resultDisplay.js b/src/voice/resultDisplay.js
index 112200f7f..cd909d2f7 100644
--- a/src/voice/resultDisplay.js
+++ b/src/voice/resultDisplay.js
@@ -29,7 +29,7 @@ import {
 } from '../i18n/index.js';
 import { layerNameForId, sourceLabel } from '../ui/layerNames.js';
 import { localizePlaceName } from '../ui/placeNames.js';
-import { translateStatusLine } from '../ui/statusText.js';
+import { translateStatusMessage } from '../ui/statusText.js';
 import { formatQuantity } from '../ui/unitLabels.js';
 
 /** Split "a; b" caveat text into separate notes. */
@@ -397,27 +397,6 @@ const NOTE_PATTERNS = [
             'Contacts panel snapshot — the same retained cohort supplies the card, speech, and follow-up memory',
           )) + period,
   ],
-  // Transit's empty note when no feed covers the view (transit/queries.js);
-  // the model gets the English.
-  [
-    /^Fly below ([\d,]+) km to a covered region$/,
-    ([, km]) =>
-      t('Fly below {km} km to a covered region', {
-        km: formatNumber(Number(km.replace(/,/g, ''))),
-      }),
-  ],
-  [
-    /^No feed here yet · ([\d,]+) regions available$/,
-    ([, regions]) => {
-      const count = Number(regions.replace(/,/g, ''));
-      return tn(
-        count,
-        'No feed here yet · {n} region available',
-        'No feed here yet · {n} regions available',
-        { n: formatNumber(count) },
-      );
-    },
-  ],
   [
     /^([a-z0-9-]+) (off|loading|error)$/,
     ([, key, status]) =>
@@ -444,10 +423,10 @@ function shownNote(text) {
     const shown = match ? show(match) : null;
     if (shown) return shown;
   }
-  // A layer's empty note can be its status line, English pieces joined by
-  // " · " ("feeds 1090, 978 stale · 0 heard", "TTC 0 (95s old)").
-  const known = translateKnown(text);
-  return known !== text ? known : translateStatusLine(text);
+  // A layer's empty note can be its coverage note ("Fly below 3,000 km to a
+  // covered region") or its status line, English pieces joined by " · "
+  // ("feeds 1090, 978 stale · 0 heard", "TTC 0 (95s old)").
+  return translateStatusMessage(text);
 }
 
 /** Feed states as the card's chips show them; the values stay English. */

From 25c33893f666bf77b8cb416151657ab84a4a1834 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Thu, 5 Nov 2026 12:53:09 +0400
Subject: [PATCH 14/71] Add the changelog entry for #1576

---
 changelog.d/1576-transit-bikeshare-coverage-prompt.md | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 changelog.d/1576-transit-bikeshare-coverage-prompt.md

diff --git a/changelog.d/1576-transit-bikeshare-coverage-prompt.md b/changelog.d/1576-transit-bikeshare-coverage-prompt.md
new file mode 100644
index 000000000..c3dcbe82a
--- /dev/null
+++ b/changelog.d/1576-transit-bikeshare-coverage-prompt.md
@@ -0,0 +1,6 @@
+- Say why Transit and Bike Share are empty outside coverage. Over a city with
+  no feed or system (London, Tokyo) their Layers rows read
+  `No feed here yet · 16 regions available` and
+  `No bike share here yet · 61 systems available`, or how low to fly, instead
+  of `never`; leaving coverage clears the last-update time (German, @gekh,
+  #1576).

From 652f3c8ea110f3b583e9adfd542617b06808f39b Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Thu, 5 Nov 2026 12:53:17 +0400
Subject: [PATCH 15/71] Hide a vessel's detection callout while its own card
 paints

With Vessels and Detection on, a vessel with an ambient card on the map
also got its detection callout next to the bracket. The callout lane
paints beneath the cards, so its text showed through the card's plate
and covered the speed and course.

The callout now gives way only to a card the shared overlay actually
paints in the same frame. The overlay paints part of the published
cards (shared budget, collisions, UI chrome), so a vessel whose card
was dropped keeps its callout.

The detection lane paints before the cards publish their paint rects,
so getOverlayPaintRect has nothing for the current frame there. The new
isOverlayEntryQueued answers from the paint queue that the overlay
solves before painting. Vessel detection objects name their card in
cardSourceId/cardEntryId.
---
 docs/CURRENT-STATE.md              |  2 +-
 src/data/aisLiveVessels.test.mjs   | 39 +++++++++++++++++++
 src/data/detection.js              | 24 +++++++++++-
 src/data/detectionHost.test.mjs    | 62 ++++++++++++++++++++++++++++++
 src/layers/vessels/queries.js      |  7 +++-
 src/overlays/worldOverlay.js       | 26 +++++++++++++
 src/overlays/worldOverlay.test.mjs | 38 ++++++++++++++++++
 7 files changed, 194 insertions(+), 4 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index f1244947d..370edcd7b 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5322,7 +5322,7 @@ silently demoting every later lookup for the session.
   Mission world text has no native `LabelGraphics`: overview launch markers publish at most 48 ambient candidates for a 24-winner budget, while selecting a mission clears that overview source and publishes its launch-site callout, stage re-entry annotations, live/estimated payload-position readout, and orbit annotation as protected selected-lane entries. The source retains the exact former strings and colors. Static anchors reuse the Cartesian values used to build their mission geometry; the moving payload entry reads the layer's per-frame live-position cache; catalog-backed orbit annotation positions are cached in the same one-second matrix update that realigns the orbit primitive. Keyhole edge fade, horizon culling, final collision placement, and UI exclusion are owned by the shared host. Deselect restores the bounded overview, and refresh, disable, and destroy replace or clear both mission sources.
   A selected mission renders its orbit as four repeating tactical sectors, each containing one prominent cyan dot followed by one hundred thin translucent dashes. The bright dots act as orbit anchors while the subdued dash field remains depth-tested against the globe and is shown only for the selected mission.
   Close selected-pad views add one static 500 m-radius cyan launch-zone ring with a low-opacity translucent fill over the sampled photoreal launch-site surface. The single scene primitive is created only for the visible selected site and is otherwise dormant. It appears during Focus, sufficiently close manual zoom, and the replay countdown, but is suppressed above 120 km camera altitude, beyond 180 km direct camera-to-pad range, for unselected missions, and whenever Space Missions is inactive. Focus establishes a launch-site-centered camera transform once; subsequent manual heading and pitch changes remain centered on that site without an automated per-frame correction. Surface mission markers and labels use an additional conservative globe-limb margin before the exact ellipsoid occluder boundary, preventing near-horizon visibility from alternating between frames.
-- **AIS vessels**: chevron symbology (naval cyan base, type tints), world-space headings, MMSI-keyed reconciliation (selection survives refreshes; pinned 3 refreshes with STALE marker when absent), detection-overlay integration (`type: 'SEA'`), contextStore registration for voice Q&A. Empty-space clicks, id-less photorealistic-tile picks, and Escape dismiss the vessel card/HUD/context and clear its trail; picks owned by another layer (including `gev-trail:*`) and raw vessel-record picks without a live MMSI key are no-ops for vessel selection. Click and key handlers detach while the layer is disabled and reinstall on enable. Selecting another vessel replaces the selection and trail, and reconciliation clears a trail if its owning vessel is evicted.
+- **AIS vessels**: chevron symbology (naval cyan base, type tints), world-space headings, MMSI-keyed reconciliation (selection survives refreshes; pinned 3 refreshes with STALE marker when absent), detection-overlay integration (`type: 'SEA'`; a vessel whose ambient card the shared host paints in the current frame draws no detection callout, because the callout would show through the card's plate, while a vessel whose card was published but not painted (shared budget, collisions, UI chrome) keeps its callout — its detectable object names the card in `cardSourceId`/`cardEntryId`, and the callout lane asks `isOverlayEntryQueued` in `src/overlays/worldOverlay.js`, which answers from the solved paint queue because the detection lane paints before the cards publish their paint rects), contextStore registration for voice Q&A. Empty-space clicks, id-less photorealistic-tile picks, and Escape dismiss the vessel card/HUD/context and clear its trail; picks owned by another layer (including `gev-trail:*`) and raw vessel-record picks without a live MMSI key are no-ops for vessel selection. Click and key handlers detach while the layer is disabled and reinstall on enable. Selecting another vessel replaces the selection and trail, and reconciliation clears a trail if its owning vessel is evicted.
 - **Track trails**: server accumulates per-MMSI ring buffers (`/api/vessels/track?mmsi=`, Float32+Uint32, 64 samples, 30s/25m thinning); aircraft backfill proxies `/api/flights/track` (OAuth, own credit bucket). Military aircraft keep only their locally accumulated trails: `/api/military/track` validates the hex, then answers `503 history_unavailable` without an upstream request.
 - Shared `src/data/pickRegistry.js` stops the two flight layers' click handlers from fighting over the camera.
 
diff --git a/src/data/aisLiveVessels.test.mjs b/src/data/aisLiveVessels.test.mjs
index 8e12bff94..edb3505f2 100644
--- a/src/data/aisLiveVessels.test.mjs
+++ b/src/data/aisLiveVessels.test.mjs
@@ -1786,3 +1786,42 @@ test('vessel focus wire skips hidden sprites at rest while a target is tracked',
   assert.equal(result.activeCount, 1);
   for (const billboard of hidden) assert.equal(billboard.color.alpha, 1);
 });
+
+test('detection objects name the vessel card their callout gives way to', () => {
+  const vessel = (mmsi, name) => ({
+    name,
+    mmsi,
+    type: 'Cargo',
+    destination: '',
+    speed: 9.5,
+    course: 80,
+    heading: 80,
+    lastPositionUtc: '',
+    missedRefreshes: 0,
+    position: POS,
+    billboard: null,
+  });
+  const keyed = vessel('200', 'GOLDEN BEAR');
+  const unkeyed = { ...vessel('', 'NO MMSI'), lat: 37.8, lon: -122.4 };
+  _setVesselStateForTest({
+    viewer: {},
+    records: [keyed, unkeyed],
+    billboardCollection: { show: true, remove() {} },
+  });
+  try {
+    const objects = Object.fromEntries(
+      aisLiveVesselsLayer
+        .getDetectableObjects()
+        .map((object) => [object.id, object]),
+    );
+    assert.equal(objects['GOLDEN BEAR'].cardSourceId, 'ais-live-vessels');
+    assert.equal(objects['GOLDEN BEAR'].cardEntryId, 'vessel:200');
+    assert.equal(
+      objects['NO MMSI'].cardEntryId,
+      'vessel:unkeyed:NO MMSI:37.80000:-122.40000',
+      'the same identity the vessel card is published under',
+    );
+  } finally {
+    _setVesselStateForTest({ enabled: false });
+  }
+});
diff --git a/src/data/detection.js b/src/data/detection.js
index 36ed6372e..8ea124649 100644
--- a/src/data/detection.js
+++ b/src/data/detection.js
@@ -21,7 +21,10 @@ import {
   getKeyholeFadeTuning,
   keyholeLabelAlphaFromGeometry,
 } from '../celestialRing.js';
-import { registerWorldOverlayPaintLane } from '../overlays/worldOverlay.js';
+import {
+  isOverlayEntryQueued,
+  registerWorldOverlayPaintLane,
+} from '../overlays/worldOverlay.js';
 import {
   DETECTION_STYLE,
   DETECTION_THEME_MAP,
@@ -576,6 +579,7 @@ export function getDetectionDiagnostics() {
   // sprites/strokes. Nothing is copied on the production paint path.
   result.calloutRects = _calloutPool
     .slice(0, _calloutCount)
+    .filter((row) => !row.yielded)
     .map(({ x, y, w, h, alpha }) => ({ x, y, w, h, alpha }));
   return result;
 }
@@ -1077,6 +1081,9 @@ function _stashCallout(entry, acquireFade, keyhole) {
       font: FONT,
       microFont: MICRO_FONT,
       alpha: 1,
+      cardSourceId: '',
+      cardEntryId: '',
+      yielded: false,
     };
     _calloutPool[_calloutCount] = row;
   }
@@ -1103,6 +1110,9 @@ function _stashCallout(entry, acquireFade, keyhole) {
   row.font = FONT;
   row.microFont = MICRO_FONT;
   row.alpha = alpha;
+  row.cardSourceId = candidate.cardSourceId;
+  row.cardEntryId = candidate.cardEntryId;
+  row.yielded = false;
   _calloutCount++;
 }
 
@@ -1134,7 +1144,15 @@ function _paintCalloutLane(frame) {
   ctx.textBaseline = 'alphabetic';
   for (let i = 0; i < _calloutCount; i++) {
     const row = _calloutPool[i];
-    paintDetectionCallout(ctx, row, row.alpha);
+    // The contact's own card (an ambient vessel card) already names it, and
+    // this callout would show through the card's plate. Checked every frame
+    // against the cards queued for THIS frame: the host paints only part of
+    // the published cards, and a contact whose card did not paint keeps its
+    // callout.
+    row.yielded =
+      row.cardEntryId !== '' &&
+      isOverlayEntryQueued(row.cardSourceId, row.cardEntryId);
+    if (!row.yielded) paintDetectionCallout(ctx, row, row.alpha);
   }
   ctx.globalAlpha = 1;
 }
@@ -1211,6 +1229,8 @@ function _materializeCandidate(
     primary,
     micro,
     hasMicro: card.hasMicro,
+    cardSourceId: obj.cardSourceId ? String(obj.cardSourceId) : '',
+    cardEntryId: obj.cardEntryId ? String(obj.cardEntryId) : '',
   };
 }
 
diff --git a/src/data/detectionHost.test.mjs b/src/data/detectionHost.test.mjs
index f8858d602..7bcb9300e 100644
--- a/src/data/detectionHost.test.mjs
+++ b/src/data/detectionHost.test.mjs
@@ -19,9 +19,11 @@ import {
   suspendDetection,
 } from './detection.js';
 import {
+  clearOverlaySource,
   destroyWorldOverlay,
   initWorldOverlay,
   setOverlayEntries,
+  setOverlaySourceVisible,
 } from '../overlays/worldOverlay.js';
 import { DETECTION_THEME_MAP } from '../overlays/worldOverlayTokens.js';
 import {
@@ -579,6 +581,66 @@ test('every style paints its OWN plate token through the production callout path
   }
 });
 
+test('a callout gives way to its contact\'s own card only while that card paints', () => {
+  // A vessel's ambient card already shows its name, speed and course, and the
+  // callout drawn beneath it shows through the card's plate. The host paints
+  // only part of the published cards (shared budget, collisions, UI chrome),
+  // so a contact whose card was published but not painted keeps its callout.
+  const env = installEnvironment({ width: 900, height: 600, dpr: 1 });
+  try {
+    const ships = [
+      { x: -0.3, sourceId: 'carded', id: 'SHIP-CARDED', card: 'vessel:carded' },
+      { x: 0.3, sourceId: 'dropped', id: 'SHIP-DROPPED', card: 'vessel:dropped' },
+    ].map(({ x, sourceId, id, card }) => ({
+      position: new Cesium.Cartesian3(x, 0, 6_356_752),
+      sourceId,
+      id,
+      metric: '6 kn',
+      type: 'SEA',
+      cardSourceId: card === 'vessel:carded' ? 'vessel-cards' : 'dropped-cards',
+      cardEntryId: card,
+    }));
+    initWorldOverlay(env.viewer);
+    initDetection(env.viewer, [{ id: 'ais-live-vessels', getDetectableObjects: () => ships }], () => {});
+    const card = (id, title, x) => ({
+      id,
+      position: new Cesium.Cartesian3(x, 0, 6_356_752),
+      variant: 'label',
+      title,
+      selected: true,
+      protected: true,
+      horizonCull: false,
+      edgeFade: 'none',
+    });
+    setOverlayEntries('vessel-cards', [card('vessel:carded', 'CARD-CARDED', -0.3)]);
+    // Published, but the host does not paint it this frame.
+    setOverlayEntries('dropped-cards', [card('vessel:dropped', 'CARD-DROPPED', 0.3)]);
+    setOverlaySourceVisible('dropped-cards', false);
+    setMode('DENSE');
+    settleFrame(env);
+    env.ctx.calls.length = 0;
+    settleFrame(env);
+
+    const painted = (text) => env.ctx.calls.some(([name, value]) => name === 'fillText' && value === text);
+    assert.ok(painted('CARD-CARDED'), 'the fixture card reached the frame');
+    assert.ok(!painted('CARD-DROPPED'), 'the hidden source paints no card');
+    assert.ok(!painted('SHIP-CARDED'), 'no callout under the painted card');
+    assert.ok(painted('SHIP-DROPPED'), 'the contact whose card did not paint keeps its callout');
+    assert.equal(getDetectionDiagnostics().calloutRects.length, 1,
+      'only the callout that painted is reported');
+
+    // The card leaves the host: the callout comes back on the next frame.
+    clearOverlaySource('vessel-cards');
+    env.ctx.calls.length = 0;
+    settleFrame(env);
+    assert.ok(painted('SHIP-CARDED'), 'the callout returns once its card stops painting');
+  } finally {
+    destroyDetection();
+    destroyWorldOverlay();
+    env.cleanup();
+  }
+});
+
 test('space-tier callouts take the heavier plate while air contacts keep the light one', () => {
   // Satellites sit over the high-albedo lit Earth disc far more often than
   // aircraft do, so the space tier carries the heavier backing. Losing the
diff --git a/src/layers/vessels/queries.js b/src/layers/vessels/queries.js
index c848acc2d..7b2b66825 100644
--- a/src/layers/vessels/queries.js
+++ b/src/layers/vessels/queries.js
@@ -21,6 +21,7 @@ import {
   REFRESH_MS,
   FOCUS_EVIDENCE_DEV,
 } from './policy.js';
+import { VESSEL_OVERLAY_SOURCE_ID } from '../../data/vesselLabels.js';
 
 export function createQueries({
   vesselState,
@@ -469,7 +470,7 @@ export function createQueries({
      * @param {Object} [options={}] - Options from the detection system.
      * @param {number} [options.maxCount] - Maximum objects to return (defaults to all).
      * @param {number} [options.seed] - Seed offset for stride sampling.
-     * @returns {Array<{position: Cesium.Cartesian3, id: string, type: string, skipLabel: boolean}>}
+     * @returns {Array<{position: Cesium.Cartesian3, id: string, type: string, skipLabel: boolean, cardSourceId: string, cardEntryId: string}>}
      */
     getDetectableObjects(options = {}) {
       if (
@@ -504,6 +505,10 @@ export function createQueries({
           id: record.name || record.mmsi || 'VESSEL',
           type: 'SEA',
           skipLabel: record === selected,
+          // The vessel's ambient card: while the overlay paints it, detection
+          // draws no callout under it.
+          cardSourceId: VESSEL_OVERLAY_SOURCE_ID,
+          cardEntryId: components.cards.vesselOverlayEntryId(record),
           klass: record.type
             ? String(record.type).toUpperCase().slice(0, 14)
             : undefined,
diff --git a/src/overlays/worldOverlay.js b/src/overlays/worldOverlay.js
index 7b0b9d5fd..16699c548 100644
--- a/src/overlays/worldOverlay.js
+++ b/src/overlays/worldOverlay.js
@@ -1065,6 +1065,22 @@ export function getOverlayPaintRect(sourceId, entryId) {
   return rect && rect.key === key && rect.stamp === _frameStamp ? rect : null;
 }
 
+/**
+ * Whether an entry is queued to paint in the frame being painted. Custom lanes
+ * run before the host's own entries, so `getOverlayPaintRect` has nothing for
+ * this frame yet while they paint; this answers from the solved paint queue.
+ * @param {string} sourceId
+ * @param {string} entryId
+ * @returns {boolean}
+ */
+export function isOverlayEntryQueued(sourceId, entryId) {
+  if (_destroyed) return false;
+  const record = _records.get(entryKey(String(sourceId), String(entryId)));
+  return (
+    !!record && record.queuedStamp === _frameStamp && record.queuedAlpha > 0.001
+  );
+}
+
 /**
  * Resolve the topmost interactive world-overlay entry at CSS-pixel coords.
  * @param {number} x
@@ -1737,6 +1753,8 @@ function getProjectionRecord(entry) {
       contentAlpha: 1,
       altitudeAlpha: 1,
       sourceAlpha: 1,
+      queuedStamp: 0,
+      queuedAlpha: 0,
       protectedPlacement: null,
       distanceOptions: {},
       altitudeOptions: {},
@@ -2254,6 +2272,14 @@ function addPaintItem(record, placement, temporalAlpha, selected) {
   item.zIndex = record.entry.zIndex;
   item.key = record.key;
   _paintQueue[_paintCount++] = item;
+  // Read by `isOverlayEntryQueued` while the custom lanes paint, before this
+  // item publishes its paint rect. Keyhole and sonar fades are left out.
+  record.queuedStamp = _frameStamp;
+  record.queuedAlpha =
+    record.sourceAlpha *
+    temporalAlpha *
+    record.distanceAlpha *
+    record.altitudeAlpha;
 }
 
 function sourceCanPaint(sourceId) {
diff --git a/src/overlays/worldOverlay.test.mjs b/src/overlays/worldOverlay.test.mjs
index f2e608b78..a0b5160b6 100644
--- a/src/overlays/worldOverlay.test.mjs
+++ b/src/overlays/worldOverlay.test.mjs
@@ -24,6 +24,7 @@ import {
   activateWorldOverlayAction,
   initWorldOverlay,
   subscribeWorldOverlayActions,
+  isOverlayEntryQueued,
   isOverlayPointVisible,
   normalizeOverlayEntry,
   paintLaneForOverlayEntry,
@@ -1213,6 +1214,43 @@ test('custom detection lane receives the shared host frame and paints below ordi
   env.cleanup();
 });
 
+test('a detection lane sees which cards this frame will paint before they publish paint rects', () => {
+  // The detection lane paints first, so a card's paint rectangle for this
+  // frame does not exist yet when it runs. The queued check is what lets a
+  // contact's callout give way to that contact's own card in the same frame.
+  const env = installMockEnvironment({ width: 400, height: 300, dpr: 1 });
+  initWorldOverlay(env.viewer);
+  const seen = [];
+  registerWorldOverlayPaintLane('detection', () => {
+    seen.push({
+      shown: isOverlayEntryQueued('cards', 'SHOWN'),
+      hidden: isOverlayEntryQueued('hidden-cards', 'HIDDEN'),
+      unknown: isOverlayEntryQueued('cards', 'NOT-PUBLISHED'),
+      rect: getOverlayPaintRect('cards', 'SHOWN'),
+    });
+  }, { id: 'detection', active: true, target: 'detection' });
+  setOverlayEntries('cards', [selectedEntry('SHOWN', {
+    position: positionAtScreen(200, 150),
+  })]);
+  setOverlayEntries('hidden-cards', [selectedEntry('HIDDEN', {
+    position: positionAtScreen(100, 100),
+  })]);
+  setOverlaySourceVisible('hidden-cards', false);
+
+  env.postRender.raise();
+  assert.deepEqual(seen[0], { shown: true, hidden: false, unknown: false, rect: null },
+    'the card is queued while its paint rect is still unpublished');
+  assert.ok(getOverlayPaintRect('cards', 'SHOWN'), 'the card did paint after the lane');
+  assert.equal(getOverlayPaintRect('hidden-cards', 'HIDDEN'), null);
+
+  clearOverlaySource('cards');
+  env.postRender.raise();
+  assert.equal(seen[1].shown, false, 'a card cleared since the last frame is no longer queued');
+  destroyWorldOverlay();
+  assert.equal(isOverlayEntryQueued('cards', 'SHOWN'), false);
+  env.cleanup();
+});
+
 test('custom-lane painter state is bracketed by host save/restore', () => {
   // A painter that leaks a clip or alpha must not corrupt later frames: the
   // host wraps every custom-lane painter in save/try/finally-restore. Pin the

From 092e7e71a8cabcaa2ed1274f5f217a0e971e1bec Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Thu, 5 Nov 2026 12:54:11 +0400
Subject: [PATCH 16/71] Add the changelog entry for #1577

---
 changelog.d/1577-vessel-callout-under-card.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1577-vessel-callout-under-card.md

diff --git a/changelog.d/1577-vessel-callout-under-card.md b/changelog.d/1577-vessel-callout-under-card.md
new file mode 100644
index 000000000..579d805b9
--- /dev/null
+++ b/changelog.d/1577-vessel-callout-under-card.md
@@ -0,0 +1,3 @@
+- A vessel whose ambient card is on the map no longer gets a Detection callout
+  showing through the card and covering its speed and course. A vessel whose
+  card the overlay did not paint keeps its callout (German, @gekh, #1577).

From ee3466dff93152204238bd7f83bd456d850bef00 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Thu, 5 Nov 2026 13:14:00 +0400
Subject: [PATCH 17/71] Keep the queued-card check off the per-frame allocation
 path

Writing a fractional alpha onto the overlay record for every paint item
boxed a heap number per item per frame. The allocation gate caught it:
the generic 60-entry workload went from 2,838 to 12,614 B/frame. The
record now keeps only the frame stamp and a pointer to its paint item,
and isOverlayEntryQueued multiplies the alphas when it is asked. The
gate is back to main's numbers on Node 24.
---
 src/overlays/worldOverlay.js | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/overlays/worldOverlay.js b/src/overlays/worldOverlay.js
index 16699c548..726e766ee 100644
--- a/src/overlays/worldOverlay.js
+++ b/src/overlays/worldOverlay.js
@@ -1076,8 +1076,14 @@ export function getOverlayPaintRect(sourceId, entryId) {
 export function isOverlayEntryQueued(sourceId, entryId) {
   if (_destroyed) return false;
   const record = _records.get(entryKey(String(sourceId), String(entryId)));
+  if (!record || record.queuedStamp !== _frameStamp) return false;
+  // Same channels as the paint, minus the per-frame keyhole and sonar fades.
   return (
-    !!record && record.queuedStamp === _frameStamp && record.queuedAlpha > 0.001
+    record.sourceAlpha *
+      record.queuedItem.temporalAlpha *
+      record.distanceAlpha *
+      record.altitudeAlpha >
+    0.001
   );
 }
 
@@ -1754,7 +1760,7 @@ function getProjectionRecord(entry) {
       altitudeAlpha: 1,
       sourceAlpha: 1,
       queuedStamp: 0,
-      queuedAlpha: 0,
+      queuedItem: null,
       protectedPlacement: null,
       distanceOptions: {},
       altitudeOptions: {},
@@ -2273,13 +2279,10 @@ function addPaintItem(record, placement, temporalAlpha, selected) {
   item.key = record.key;
   _paintQueue[_paintCount++] = item;
   // Read by `isOverlayEntryQueued` while the custom lanes paint, before this
-  // item publishes its paint rect. Keyhole and sonar fades are left out.
+  // item publishes its paint rect. Only a stamp and a pointer: storing the
+  // item's alpha here would box a double per paint item per frame.
   record.queuedStamp = _frameStamp;
-  record.queuedAlpha =
-    record.sourceAlpha *
-    temporalAlpha *
-    record.distanceAlpha *
-    record.altitudeAlpha;
+  record.queuedItem = item;
 }
 
 function sourceCanPaint(sourceId) {

From da00b096d2bae42b28a5e34a6c7aed5543d0291b Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Thu, 5 Nov 2026 21:21:02 +0400
Subject: [PATCH 18/71] Fade a vessel's callout by its card's painted opacity

The callout now asks for the opacity its own card paints with this frame,
keyhole fade included, and fades out as the card fades in. A card faded out
at the keyhole rim leaves the callout readable, and a card fading out after
leaving its source still hides it. The vessel card id is cached on the
record, and the allocation gate covers the lookup.
---
 docs/CURRENT-STATE.md                         |   2 +-
 src/data/aisLiveVessels.test.mjs              |   1 +
 src/data/detection.js                         |  33 ++--
 src/data/detectionHost.test.mjs               | 174 ++++++++++++++++++
 src/layers/vessels/cards.js                   |   8 +
 src/layers/vessels/records.js                 |   3 +
 src/overlays/worldOverlay.js                  |  91 +++++----
 src/overlays/worldOverlay.test.mjs            |  16 +-
 .../worldOverlayAllocation.worker.mjs         |   3 +
 9 files changed, 274 insertions(+), 57 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 370edcd7b..26cf5af18 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5322,7 +5322,7 @@ silently demoting every later lookup for the session.
   Mission world text has no native `LabelGraphics`: overview launch markers publish at most 48 ambient candidates for a 24-winner budget, while selecting a mission clears that overview source and publishes its launch-site callout, stage re-entry annotations, live/estimated payload-position readout, and orbit annotation as protected selected-lane entries. The source retains the exact former strings and colors. Static anchors reuse the Cartesian values used to build their mission geometry; the moving payload entry reads the layer's per-frame live-position cache; catalog-backed orbit annotation positions are cached in the same one-second matrix update that realigns the orbit primitive. Keyhole edge fade, horizon culling, final collision placement, and UI exclusion are owned by the shared host. Deselect restores the bounded overview, and refresh, disable, and destroy replace or clear both mission sources.
   A selected mission renders its orbit as four repeating tactical sectors, each containing one prominent cyan dot followed by one hundred thin translucent dashes. The bright dots act as orbit anchors while the subdued dash field remains depth-tested against the globe and is shown only for the selected mission.
   Close selected-pad views add one static 500 m-radius cyan launch-zone ring with a low-opacity translucent fill over the sampled photoreal launch-site surface. The single scene primitive is created only for the visible selected site and is otherwise dormant. It appears during Focus, sufficiently close manual zoom, and the replay countdown, but is suppressed above 120 km camera altitude, beyond 180 km direct camera-to-pad range, for unselected missions, and whenever Space Missions is inactive. Focus establishes a launch-site-centered camera transform once; subsequent manual heading and pitch changes remain centered on that site without an automated per-frame correction. Surface mission markers and labels use an additional conservative globe-limb margin before the exact ellipsoid occluder boundary, preventing near-horizon visibility from alternating between frames.
-- **AIS vessels**: chevron symbology (naval cyan base, type tints), world-space headings, MMSI-keyed reconciliation (selection survives refreshes; pinned 3 refreshes with STALE marker when absent), detection-overlay integration (`type: 'SEA'`; a vessel whose ambient card the shared host paints in the current frame draws no detection callout, because the callout would show through the card's plate, while a vessel whose card was published but not painted (shared budget, collisions, UI chrome) keeps its callout — its detectable object names the card in `cardSourceId`/`cardEntryId`, and the callout lane asks `isOverlayEntryQueued` in `src/overlays/worldOverlay.js`, which answers from the solved paint queue because the detection lane paints before the cards publish their paint rects), contextStore registration for voice Q&A. Empty-space clicks, id-less photorealistic-tile picks, and Escape dismiss the vessel card/HUD/context and clear its trail; picks owned by another layer (including `gev-trail:*`) and raw vessel-record picks without a live MMSI key are no-ops for vessel selection. Click and key handlers detach while the layer is disabled and reinstall on enable. Selecting another vessel replaces the selection and trail, and reconciliation clears a trail if its owning vessel is evicted.
+- **AIS vessels**: chevron symbology (naval cyan base, type tints), world-space headings, MMSI-keyed reconciliation (selection survives refreshes; pinned 3 refreshes with STALE marker when absent), detection-overlay integration (`type: 'SEA'`; a vessel's detection callout fades out while its own ambient card paints in the same frame, judged by the card's painted opacity including the keyhole fade, so a card dropped by budget, collisions or UI chrome, or faded out at the keyhole rim, leaves the callout readable), contextStore registration for voice Q&A. Empty-space clicks, id-less photorealistic-tile picks, and Escape dismiss the vessel card/HUD/context and clear its trail; picks owned by another layer (including `gev-trail:*`) and raw vessel-record picks without a live MMSI key are no-ops for vessel selection. Click and key handlers detach while the layer is disabled and reinstall on enable. Selecting another vessel replaces the selection and trail, and reconciliation clears a trail if its owning vessel is evicted.
 - **Track trails**: server accumulates per-MMSI ring buffers (`/api/vessels/track?mmsi=`, Float32+Uint32, 64 samples, 30s/25m thinning); aircraft backfill proxies `/api/flights/track` (OAuth, own credit bucket). Military aircraft keep only their locally accumulated trails: `/api/military/track` validates the hex, then answers `503 history_unavailable` without an upstream request.
 - Shared `src/data/pickRegistry.js` stops the two flight layers' click handlers from fighting over the camera.
 
diff --git a/src/data/aisLiveVessels.test.mjs b/src/data/aisLiveVessels.test.mjs
index edb3505f2..e1c2fcc5a 100644
--- a/src/data/aisLiveVessels.test.mjs
+++ b/src/data/aisLiveVessels.test.mjs
@@ -1821,6 +1821,7 @@ test('detection objects name the vessel card their callout gives way to', () =>
       'vessel:unkeyed:NO MMSI:37.80000:-122.40000',
       'the same identity the vessel card is published under',
     );
+    assert.equal(keyed.overlayEntryId, 'vessel:200', 'cached on the record for later frames');
   } finally {
     _setVesselStateForTest({ enabled: false });
   }
diff --git a/src/data/detection.js b/src/data/detection.js
index 8ea124649..f4d1ddf3b 100644
--- a/src/data/detection.js
+++ b/src/data/detection.js
@@ -22,7 +22,7 @@ import {
   keyholeLabelAlphaFromGeometry,
 } from '../celestialRing.js';
 import {
-  isOverlayEntryQueued,
+  getQueuedOverlayEntryAlpha,
   registerWorldOverlayPaintLane,
 } from '../overlays/worldOverlay.js';
 import {
@@ -110,6 +110,11 @@ const THEME_MAP = DETECTION_THEME_MAP;
 const SPARSE_ZONE_FRACTION = 0.5;
 /** Solve cadence for membership/collision; accepted identities still reproject every frame. */
 const LABEL_SOLVE_INTERVAL_MS = 125;
+/**
+ * A contact's own card at this opacity or more hides its callout; below it the
+ * callout fades in, so a card fading in or out never snaps the callout.
+ */
+const CARD_ALPHA_HIDING_CALLOUT = 0.5;
 /** Alpha bands retain bracket batching while approximating a continuous radial fade. */
 const BRACKET_ALPHA_STEPS = 4;
 /** Finer bands for Global Context echo brackets, whose fade is animated. */
@@ -579,8 +584,8 @@ export function getDetectionDiagnostics() {
   // sprites/strokes. Nothing is copied on the production paint path.
   result.calloutRects = _calloutPool
     .slice(0, _calloutCount)
-    .filter((row) => !row.yielded)
-    .map(({ x, y, w, h, alpha }) => ({ x, y, w, h, alpha }));
+    .filter((row) => row.paintAlpha > 0.001)
+    .map(({ x, y, w, h, paintAlpha }) => ({ x, y, w, h, alpha: paintAlpha }));
   return result;
 }
 
@@ -1083,7 +1088,7 @@ function _stashCallout(entry, acquireFade, keyhole) {
       alpha: 1,
       cardSourceId: '',
       cardEntryId: '',
-      yielded: false,
+      paintAlpha: 1,
     };
     _calloutPool[_calloutCount] = row;
   }
@@ -1112,7 +1117,7 @@ function _stashCallout(entry, acquireFade, keyhole) {
   row.alpha = alpha;
   row.cardSourceId = candidate.cardSourceId;
   row.cardEntryId = candidate.cardEntryId;
-  row.yielded = false;
+  row.paintAlpha = alpha;
   _calloutCount++;
 }
 
@@ -1144,15 +1149,15 @@ function _paintCalloutLane(frame) {
   ctx.textBaseline = 'alphabetic';
   for (let i = 0; i < _calloutCount; i++) {
     const row = _calloutPool[i];
-    // The contact's own card (an ambient vessel card) already names it, and
-    // this callout would show through the card's plate. Checked every frame
-    // against the cards queued for THIS frame: the host paints only part of
-    // the published cards, and a contact whose card did not paint keeps its
-    // callout.
-    row.yielded =
-      row.cardEntryId !== '' &&
-      isOverlayEntryQueued(row.cardSourceId, row.cardEntryId);
-    if (!row.yielded) paintDetectionCallout(ctx, row, row.alpha);
+    // Under the contact's own card (an ambient vessel card) the callout would
+    // show through the plate. Only a card painting this frame counts.
+    const cardAlpha =
+      row.cardEntryId === ''
+        ? 0
+        : getQueuedOverlayEntryAlpha(row.cardSourceId, row.cardEntryId);
+    row.paintAlpha =
+      row.alpha * Math.max(0, 1 - cardAlpha / CARD_ALPHA_HIDING_CALLOUT);
+    if (row.paintAlpha > 0.001) paintDetectionCallout(ctx, row, row.paintAlpha);
   }
   ctx.globalAlpha = 1;
 }
diff --git a/src/data/detectionHost.test.mjs b/src/data/detectionHost.test.mjs
index 7bcb9300e..4c1c6dddc 100644
--- a/src/data/detectionHost.test.mjs
+++ b/src/data/detectionHost.test.mjs
@@ -21,10 +21,17 @@ import {
 import {
   clearOverlaySource,
   destroyWorldOverlay,
+  getOverlayPaintRect,
   initWorldOverlay,
   setOverlayEntries,
   setOverlaySourceVisible,
 } from '../overlays/worldOverlay.js';
+import { applyVesselOverlayPolicy } from './vesselLabels.js';
+import {
+  getKeyholeFadeTuning,
+  getKeyholeGeometry,
+  keyholeLabelAlphaFromGeometry,
+} from '../celestialRing.js';
 import { DETECTION_THEME_MAP } from '../overlays/worldOverlayTokens.js';
 import {
   clearAwarenessEchoField,
@@ -641,6 +648,173 @@ test('a callout gives way to its contact\'s own card only while that card paints
   }
 });
 
+/** A vessel detection contact that names its ambient card, like the AIS layer does. */
+function shipWithCard(mmsi, position) {
+  return {
+    position,
+    sourceId: mmsi,
+    id: `SHIP-${mmsi}`,
+    metric: '6 kn',
+    type: 'SEA',
+    cardSourceId: 'ais-live-vessels',
+    cardEntryId: `vessel:${mmsi}`,
+  };
+}
+
+/** The production ambient vessel card (not protected: it goes through the arbiter). */
+function ambientVesselCard(mmsi, position) {
+  return applyVesselOverlayPolicy({
+    id: `vessel:${mmsi}`,
+    position,
+    title: `CARD-${mmsi}`,
+    details: ['CARGO · 6KT · 80°'],
+    gapPx: 10,
+  });
+}
+
+test('a callout stays readable when its own card is faded out at the keyhole rim', () => {
+  // Default keyhole tuning: 7% feather, 1% outside opacity.
+  assert.deepEqual(getKeyholeFadeTuning(), { fadeRatio: 0.07, outsideOpacity: 0.01 });
+  const width = 1600;
+  const height = 900;
+  const keyhole = getKeyholeGeometry(width, height);
+  const env = installEnvironment({ width, height, dpr: 1 });
+  // Just outside the keyhole's left rim: the card sits above or below the
+  // anchor (outside, 1% alpha), the callout to its right (inside the feather).
+  const position = new Cesium.Cartesian3(270 / (width / 2) - 1, 1 - 460 / (height / 2), 6_356_752);
+  const ship = shipWithCard('200', position);
+  try {
+    initWorldOverlay(env.viewer);
+    initDetection(env.viewer, [{ id: 'ais-live-vessels', getDetectableObjects: () => [ship] }], () => {});
+    setMode('DENSE');
+    for (let i = 0; i < 4; i++) settleFrame(env);
+    const [alone] = getDetectionDiagnostics().calloutRects;
+    assert.ok(alone && alone.alpha >= 0.5, 'without a card the callout is clearly visible');
+
+    setOverlayEntries('ais-live-vessels', [ambientVesselCard('200', position)]);
+    for (let i = 0; i < 4; i++) settleFrame(env);
+    const rect = getOverlayPaintRect('ais-live-vessels', 'vessel:200');
+    assert.ok(rect, 'the host paints the card (at the outside opacity)');
+    const cardAlpha = keyholeLabelAlphaFromGeometry(rect.x + rect.w / 2, rect.y + rect.h / 2, keyhole);
+    assert.ok(cardAlpha <= 0.05, `the card is invisible at the rim (keyhole alpha ${cardAlpha})`);
+
+    const callouts = getDetectionDiagnostics().calloutRects;
+    assert.equal(callouts.length, 1, 'the callout keeps painting while its card is faded out');
+    assert.ok(callouts[0].alpha >= 0.4, 'and stays readable');
+  } finally {
+    destroyDetection();
+    destroyWorldOverlay();
+    env.cleanup();
+  }
+});
+
+test('a callout stays hidden while its card fades out after leaving the published cohort', () => {
+  const env = installEnvironment({ width: 1600, height: 900, dpr: 1 });
+  const at = (x, y) => new Cesium.Cartesian3(x, y, 6_356_752);
+  const ship = shipWithCard('200', at(0.1, 0.1));
+  const painted = (text) => env.ctx.calls.some(([name, value]) => name === 'fillText' && value === text);
+  const frame = (ms) => {
+    env.ctx.calls.length = 0;
+    env.advance(ms);
+    env.postRender.raise();
+  };
+  try {
+    initWorldOverlay(env.viewer);
+    initDetection(env.viewer, [{ id: 'ais-live-vessels', getDetectableObjects: () => [ship] }], () => {});
+    setMode('DENSE');
+    setOverlayEntries('ais-live-vessels', [ambientVesselCard('200', ship.position)]);
+    for (let i = 0; i < 6; i++) frame(250);
+    frame(16);
+    assert.ok(painted('CARD-200') && !painted('SHIP-200'), 'steady state: card only');
+
+    // The vessel layer republishes its screen-grid cohort after a camera move:
+    // this vessel's card is replaced by another one, the vessel stays detectable.
+    setOverlayEntries('ais-live-vessels', [ambientVesselCard('300', at(-0.5, -0.4))]);
+    frame(16);
+    assert.ok(getOverlayPaintRect('ais-live-vessels', 'vessel:200'), 'the dropped card is still fading out');
+    assert.ok(painted('CARD-200'), 'and its text still paints');
+    assert.ok(!painted('SHIP-200'), 'no full callout under the fading card');
+
+    for (let i = 0; i < 4; i++) frame(250);
+    assert.ok(!painted('CARD-200'), 'the card has faded out');
+    assert.ok(painted('SHIP-200'), 'and the callout is back');
+  } finally {
+    destroyDetection();
+    destroyWorldOverlay();
+    env.cleanup();
+  }
+});
+
+test('a vessel whose ambient card loses the collision keeps its callout', () => {
+  const env = installEnvironment({ width: 900, height: 600, dpr: 1 });
+  // Four vessels a few pixels apart: their cards collide (a card goes only
+  // above or below its anchor), so the arbiter paints only some of them.
+  const ships = [0, 1, 2, 3].map((i) =>
+    shipWithCard(String(100 + i), new Cesium.Cartesian3(-0.2 + i * 0.005, i * 0.005, 6_356_752)),
+  );
+  const painted = (text) => env.ctx.calls.some(([name, value]) => name === 'fillText' && value === text);
+  try {
+    initWorldOverlay(env.viewer);
+    initDetection(env.viewer, [{ id: 'ais-live-vessels', getDetectableObjects: () => ships }], () => {});
+    setOverlayEntries(
+      'ais-live-vessels',
+      ships.map((ship) => ambientVesselCard(ship.sourceId, ship.position)),
+    );
+    setMode('DENSE');
+    for (let i = 0; i < 4; i++) settleFrame(env);
+    env.ctx.calls.length = 0;
+    settleFrame(env);
+
+    const winners = ships.filter((ship) => getOverlayPaintRect('ais-live-vessels', ship.cardEntryId));
+    assert.ok(
+      winners.length >= 1 && winners.length < ships.length,
+      `the colliding cards leave some unpainted (${winners.length} of ${ships.length} painted)`,
+    );
+    for (const ship of ships) {
+      const carded = winners.includes(ship);
+      assert.equal(
+        painted(ship.id),
+        !carded,
+        carded ? `${ship.id} draws no callout under its card` : `${ship.id} keeps its callout`,
+      );
+    }
+  } finally {
+    destroyDetection();
+    destroyWorldOverlay();
+    env.cleanup();
+  }
+});
+
+test('a callout fades out while its card fades in instead of vanishing at once', () => {
+  const env = installEnvironment({ width: 1600, height: 900, dpr: 1 });
+  const ship = shipWithCard('200', new Cesium.Cartesian3(0.1, 0.1, 6_356_752));
+  try {
+    initWorldOverlay(env.viewer);
+    initDetection(env.viewer, [{ id: 'ais-live-vessels', getDetectableObjects: () => [ship] }], () => {});
+    setMode('DENSE');
+    for (let i = 0; i < 4; i++) settleFrame(env);
+    const [alone] = getDetectionDiagnostics().calloutRects;
+    assert.ok(alone.alpha >= 0.9, 'the callout starts fully visible');
+
+    setOverlayEntries('ais-live-vessels', [ambientVesselCard('200', ship.position)]);
+    const alphas = [];
+    for (let i = 0; i < 30; i++) {
+      env.advance(16);
+      env.postRender.raise();
+      alphas.push(getDetectionDiagnostics().calloutRects[0]?.alpha ?? 0);
+    }
+    assert.ok(
+      alphas.some((alpha) => alpha > 0.1 && alpha < alone.alpha - 0.1),
+      `the callout passes through partial opacity: ${alphas.map((a) => a.toFixed(2)).join(' ')}`,
+    );
+    assert.equal(alphas.at(-1), 0, 'and is gone once the card is fully in');
+  } finally {
+    destroyDetection();
+    destroyWorldOverlay();
+    env.cleanup();
+  }
+});
+
 test('space-tier callouts take the heavier plate while air contacts keep the light one', () => {
   // Satellites sit over the high-albedo lit Earth disc far more often than
   // aircraft do, so the space tier carries the heavier backing. Losing the
diff --git a/src/layers/vessels/cards.js b/src/layers/vessels/cards.js
index bcf3459f1..2563bf420 100644
--- a/src/layers/vessels/cards.js
+++ b/src/layers/vessels/cards.js
@@ -117,6 +117,14 @@ export function createCards({
   /** Stable overlay identity for MMSI-keyed and source-retained unkeyed rows. */
 
   function vesselOverlayEntryId(record) {
+    // Cached on the record: detection asks for it every frame for every vessel.
+    if (record?.overlayEntryId) return record.overlayEntryId;
+    const id = composeVesselOverlayEntryId(record);
+    if (record) record.overlayEntryId = id;
+    return id;
+  }
+
+  function composeVesselOverlayEntryId(record) {
     const mmsi = String(record?.mmsi || '').trim();
     if (mmsi) return `vessel:${mmsi}`;
     const name = String(record?.name || 'VESSEL').trim() || 'VESSEL';
diff --git a/src/layers/vessels/records.js b/src/layers/vessels/records.js
index ad6d85cbd..aeb2f39bf 100644
--- a/src/layers/vessels/records.js
+++ b/src/layers/vessels/records.js
@@ -23,6 +23,9 @@ export function normalizeVessel(row) {
     lastPositionUtc: String(row.last_position_UTC || ''),
     lastPositionEpoch: finiteNumber(row.last_position_epoch),
     missedRefreshes: 0,
+    // Filled on first use by the cards' `vesselOverlayEntryId`. The id reads
+    // only the MMSI, or for an unkeyed row fields it never updates.
+    overlayEntryId: null,
   };
 }
 
diff --git a/src/overlays/worldOverlay.js b/src/overlays/worldOverlay.js
index 726e766ee..aabcc7be0 100644
--- a/src/overlays/worldOverlay.js
+++ b/src/overlays/worldOverlay.js
@@ -258,6 +258,10 @@ const _paintQueue = [];
 const _paintItemPool = [];
 const _paintRectPool = [];
 const _paintRectByKey = new Map();
+/** @type {Map<string, Map<string, object>>} This frame's paint items by source and entry id. */
+const _queuedItemBySource = new Map();
+/** Index rows that stop painting are dropped this many frames apart. */
+const QUEUED_ITEM_PRUNE_FRAMES = 600;
 const _hitRects = [];
 const _paintedBySource = Object.create(null);
 const _paintedSourceKeys = [];
@@ -1066,24 +1070,26 @@ export function getOverlayPaintRect(sourceId, entryId) {
 }
 
 /**
- * Whether an entry is queued to paint in the frame being painted. Custom lanes
- * run before the host's own entries, so `getOverlayPaintRect` has nothing for
- * this frame yet while they paint; this answers from the solved paint queue.
+ * Opacity an entry will paint with in the frame being painted, or 0 when it is
+ * not queued. Valid from the custom lanes, which paint before the entries in
+ * later lanes publish their paint rects. Leaves out only the Cyber sonar fade.
  * @param {string} sourceId
  * @param {string} entryId
- * @returns {boolean}
+ * @returns {number}
  */
-export function isOverlayEntryQueued(sourceId, entryId) {
-  if (_destroyed) return false;
-  const record = _records.get(entryKey(String(sourceId), String(entryId)));
-  if (!record || record.queuedStamp !== _frameStamp) return false;
-  // Same channels as the paint, minus the per-frame keyhole and sonar fades.
+export function getQueuedOverlayEntryAlpha(sourceId, entryId) {
+  if (_destroyed) return 0;
+  const item = _queuedItemBySource.get(sourceId)?.get(entryId);
+  // Pooled items are reassigned every frame: check the frame and the entry.
+  if (!item || item.stamp !== _frameStamp) return 0;
+  const record = item.record;
+  if (record.entry.id !== entryId || record.entry.source !== sourceId) return 0;
   return (
     record.sourceAlpha *
-      record.queuedItem.temporalAlpha *
-      record.distanceAlpha *
-      record.altitudeAlpha >
-    0.001
+    item.temporalAlpha *
+    record.distanceAlpha *
+    record.altitudeAlpha *
+    (_keyhole ? entryKeyholeAlpha(record.entry, item.placement, _keyhole) : 1)
   );
 }
 
@@ -1759,8 +1765,6 @@ function getProjectionRecord(entry) {
       contentAlpha: 1,
       altitudeAlpha: 1,
       sourceAlpha: 1,
-      queuedStamp: 0,
-      queuedItem: null,
       protectedPlacement: null,
       distanceOptions: {},
       altitudeOptions: {},
@@ -2277,12 +2281,27 @@ function addPaintItem(record, placement, temporalAlpha, selected) {
   item.lane = paintLaneForOverlayEntry(record.entry);
   item.zIndex = record.entry.zIndex;
   item.key = record.key;
+  item.stamp = _frameStamp;
   _paintQueue[_paintCount++] = item;
-  // Read by `isOverlayEntryQueued` while the custom lanes paint, before this
-  // item publishes its paint rect. Only a stamp and a pointer: storing the
-  // item's alpha here would box a double per paint item per frame.
-  record.queuedStamp = _frameStamp;
-  record.queuedItem = item;
+  // Indexed by source and id rather than by `record.key`, so a lookup builds
+  // no string. A card fading out after it left its source's entries is still
+  // queued here, though `_records` no longer has it.
+  let bySource = _queuedItemBySource.get(record.entry.source);
+  if (!bySource) {
+    bySource = new Map();
+    _queuedItemBySource.set(record.entry.source, bySource);
+  }
+  bySource.set(record.entry.id, item);
+}
+
+/** Drop index rows for entries that stopped painting (bounded, not per frame). */
+function pruneQueuedItemIndex() {
+  for (const [sourceId, bySource] of _queuedItemBySource) {
+    for (const [entryId, item] of bySource) {
+      if (item.stamp !== _frameStamp) bySource.delete(entryId);
+    }
+    if (bySource.size === 0) _queuedItemBySource.delete(sourceId);
+  }
 }
 
 function sourceCanPaint(sourceId) {
@@ -2354,6 +2373,7 @@ function solveDomains(timestamp) {
     solveRevision += domain.arbiter.solveRevision;
   }
   _paintQueue.length = _paintCount;
+  if (_frameStamp % QUEUED_ITEM_PRUNE_FRAMES === 0) pruneQueuedItemIndex();
   _solveDirty = false;
   _diagnostics.solveMs = solveMs;
   _diagnostics.selectedCount = selectedCount;
@@ -2482,23 +2502,25 @@ function paintCustomLane(lane) {
   }
 }
 
+/** Keyhole edge fade of one placed entry (1 for entries that do not fade). */
+function entryKeyholeAlpha(entry, placement, keyhole) {
+  if (entry.edgeFade !== 'keyhole') return 1;
+  const keyholeX = placement.centerX - keyhole.centerX;
+  const keyholeY = placement.centerY - keyhole.centerY;
+  return keyholeX * keyholeX + keyholeY * keyholeY <=
+    keyhole.radius * keyhole.radius
+    ? 1
+    : keyholeLabelAlphaFromGeometry(
+        placement.centerX,
+        placement.centerY,
+        keyhole,
+      );
+}
+
 function paintEntryItem(item, keyhole, sonar) {
   const { record, placement } = item;
   const entry = record.entry;
-  let keyholeAlpha = 1;
-  if (entry.edgeFade === 'keyhole') {
-    const keyholeX = placement.centerX - keyhole.centerX;
-    const keyholeY = placement.centerY - keyhole.centerY;
-    keyholeAlpha =
-      keyholeX * keyholeX + keyholeY * keyholeY <=
-      keyhole.radius * keyhole.radius
-        ? 1
-        : keyholeLabelAlphaFromGeometry(
-            placement.centerX,
-            placement.centerY,
-            keyhole,
-          );
-  }
+  const keyholeAlpha = entryKeyholeAlpha(entry, placement, keyhole);
   // All five channels are normalized at their source. Keep the multiply on
   // the hot paint path so its intermediate doubles remain unboxed; the pure
   // `combinedOverlayAlpha` export still specifies/tests the same binding.
@@ -2799,6 +2821,7 @@ export function destroyWorldOverlay() {
   _accessibleActivatorByKey.clear();
   _accessibilitySignature = '';
   _paintRectByKey.clear();
+  _queuedItemBySource.clear();
   _paintCount = 0;
   _paintRectCount = 0;
   _hitRectCount = 0;
diff --git a/src/overlays/worldOverlay.test.mjs b/src/overlays/worldOverlay.test.mjs
index a0b5160b6..6e713a5da 100644
--- a/src/overlays/worldOverlay.test.mjs
+++ b/src/overlays/worldOverlay.test.mjs
@@ -24,7 +24,7 @@ import {
   activateWorldOverlayAction,
   initWorldOverlay,
   subscribeWorldOverlayActions,
-  isOverlayEntryQueued,
+  getQueuedOverlayEntryAlpha,
   isOverlayPointVisible,
   normalizeOverlayEntry,
   paintLaneForOverlayEntry,
@@ -1216,16 +1216,16 @@ test('custom detection lane receives the shared host frame and paints below ordi
 
 test('a detection lane sees which cards this frame will paint before they publish paint rects', () => {
   // The detection lane paints first, so a card's paint rectangle for this
-  // frame does not exist yet when it runs. The queued check is what lets a
+  // frame does not exist yet when it runs. The queued alpha is what lets a
   // contact's callout give way to that contact's own card in the same frame.
   const env = installMockEnvironment({ width: 400, height: 300, dpr: 1 });
   initWorldOverlay(env.viewer);
   const seen = [];
   registerWorldOverlayPaintLane('detection', () => {
     seen.push({
-      shown: isOverlayEntryQueued('cards', 'SHOWN'),
-      hidden: isOverlayEntryQueued('hidden-cards', 'HIDDEN'),
-      unknown: isOverlayEntryQueued('cards', 'NOT-PUBLISHED'),
+      shown: getQueuedOverlayEntryAlpha('cards', 'SHOWN'),
+      hidden: getQueuedOverlayEntryAlpha('hidden-cards', 'HIDDEN'),
+      unknown: getQueuedOverlayEntryAlpha('cards', 'NOT-PUBLISHED'),
       rect: getOverlayPaintRect('cards', 'SHOWN'),
     });
   }, { id: 'detection', active: true, target: 'detection' });
@@ -1238,16 +1238,16 @@ test('a detection lane sees which cards this frame will paint before they publis
   setOverlaySourceVisible('hidden-cards', false);
 
   env.postRender.raise();
-  assert.deepEqual(seen[0], { shown: true, hidden: false, unknown: false, rect: null },
+  assert.deepEqual(seen[0], { shown: 1, hidden: 0, unknown: 0, rect: null },
     'the card is queued while its paint rect is still unpublished');
   assert.ok(getOverlayPaintRect('cards', 'SHOWN'), 'the card did paint after the lane');
   assert.equal(getOverlayPaintRect('hidden-cards', 'HIDDEN'), null);
 
   clearOverlaySource('cards');
   env.postRender.raise();
-  assert.equal(seen[1].shown, false, 'a card cleared since the last frame is no longer queued');
+  assert.equal(seen[1].shown, 0, 'a card cleared since the last frame is no longer queued');
   destroyWorldOverlay();
-  assert.equal(isOverlayEntryQueued('cards', 'SHOWN'), false);
+  assert.equal(getQueuedOverlayEntryAlpha('cards', 'SHOWN'), 0);
   env.cleanup();
 });
 
diff --git a/src/overlays/worldOverlayAllocation.worker.mjs b/src/overlays/worldOverlayAllocation.worker.mjs
index e2a4c6240..93b47e7f3 100644
--- a/src/overlays/worldOverlayAllocation.worker.mjs
+++ b/src/overlays/worldOverlayAllocation.worker.mjs
@@ -1217,6 +1217,9 @@ function buildPhase6DetectionWorkload(count) {
           : `FL${String(180 + (index % 220)).padStart(3, '0')}`,
       type: ['AIR', 'SAT', 'SEA', 'VEH'][index % 4],
       tier: index % 17 === 0 ? 'military' : undefined,
+      // Vessels name their ambient card, so each callout asks the host for it.
+      cardSourceId: index % 4 === 2 ? 'ais-live-vessels' : undefined,
+      cardEntryId: index % 4 === 2 ? `vessel:${index}` : undefined,
     });
   }
   return {

From 90db4eb2c9ed0c61adbfe6ffaf7a17b1ffe1d829 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Thu, 5 Nov 2026 21:21:03 +0400
Subject: [PATCH 19/71] Name the real gate altitude and repaint coverage rows
 at once

The Transit prompt said "Fly below 3,000 km", but the closed gate opens at
2,850 km; it now names the enter threshold, as Bike Share does. When the
camera changes coverage, Transit and Bike Share ask the Layers panel to
repaint instead of leaving the old prompt up until the next 15 s / 60 s tick.
---
 docs/CURRENT-STATE.md                  |   2 +-
 src/layers/bikeshare/controls.js       |   9 ++
 src/layers/bikeshare/lifecycle.js      |   1 +
 src/layers/bikeshare/state.js          |   4 +
 src/layers/bikeshare/viewport.js       |  17 ++++
 src/layers/promptRepaint.test.mjs      | 122 +++++++++++++++++++++++++
 src/layers/transit/gatePrompt.test.mjs |  66 +++++++++++++
 src/layers/transit/lifecycle.test.mjs  |   2 +-
 src/layers/transit/queries.js          |   4 +-
 src/layers/transit/viewport.js         |   7 ++
 src/ui/statusText.test.mjs             |   2 +-
 src/voice/analystEmptyNotes.test.mjs   |   2 +-
 src/voice/resultDisplay.js             |   2 +-
 13 files changed, 233 insertions(+), 7 deletions(-)
 create mode 100644 src/layers/promptRepaint.test.mjs
 create mode 100644 src/layers/transit/gatePrompt.test.mjs

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 8368eeacf..946254fbf 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -1819,7 +1819,7 @@ errors.
 
 Transit and Bike Share report the same kind of guidance when no feed or system
 covers the view, instead of an undated `never`. Above their altitude gates the
-rows read `GTFS-RT · Fly below 3,000 km to a covered region` and
+rows read `GTFS-RT · Fly below 2,850 km to a covered region` and
 `GBFS · Fly below 48 km to a covered city`; lower down over a city neither
 covers (London, Tokyo) they read `GTFS-RT · No feed here yet · N regions
 available` and `GBFS · No bike share here yet · N systems available`, N being
diff --git a/src/layers/bikeshare/controls.js b/src/layers/bikeshare/controls.js
index 993022506..78edd907b 100644
--- a/src/layers/bikeshare/controls.js
+++ b/src/layers/bikeshare/controls.js
@@ -14,6 +14,15 @@ export function createControls({ state: layerState, services, parts, source }) {
 
     updateInterval: STATUS_POLL_MS,
 
+    /**
+     * Keep the manager so camera-driven coverage changes can repaint the row
+     * before the next status poll.
+     * @param {object} dataManager DataLayerManager instance.
+     */
+    attachDataManager(dataManager) {
+      layerState._dataManager = dataManager;
+    },
+
     /**
      * Return a sampled array of detectable station objects for HUD overlay rendering.
      * @param {Object} [options] - Sampling options (maxCount, seed).
diff --git a/src/layers/bikeshare/lifecycle.js b/src/layers/bikeshare/lifecycle.js
index 3e46b5972..050269bfd 100644
--- a/src/layers/bikeshare/lifecycle.js
+++ b/src/layers/bikeshare/lifecycle.js
@@ -169,6 +169,7 @@ export function createLifecycle({
         viewer.scene.primitives.remove(layerState._pointCollection);
         layerState._pointCollection = null;
       }
+      layerState._dataManager = null;
       layerState._viewer = null;
     },
   };
diff --git a/src/layers/bikeshare/state.js b/src/layers/bikeshare/state.js
index 3617914bf..518c2397a 100644
--- a/src/layers/bikeshare/state.js
+++ b/src/layers/bikeshare/state.js
@@ -19,6 +19,10 @@ export function createState({ services }) {
 
   layerState._viewer = null;
 
+  /** @type {{ refreshLayerStats?: () => void }|null} Manager that repaints the layer's row. */
+
+  layerState._dataManager = null;
+
   /** @type {Cesium.PointPrimitiveCollection|null} Primitive collection for station dots. */
 
   layerState._pointCollection = null;
diff --git a/src/layers/bikeshare/viewport.js b/src/layers/bikeshare/viewport.js
index 0739d341c..dbc328f61 100644
--- a/src/layers/bikeshare/viewport.js
+++ b/src/layers/bikeshare/viewport.js
@@ -116,6 +116,14 @@ export function createViewport({ state: layerState, services, parts, source }) {
     parts.rendering.removeCityPoints(cityId);
   }
 
+  /**
+   * Repaint the layer's row now. Its text follows the camera (coverage
+   * prompt, station count), and the manager tick is 60 s.
+   */
+  function refreshRow() {
+    layerState._dataManager?.refreshLayerStats?.();
+  }
+
   /** Deactivate all currently active cities and clear the active set. */
 
   function deactivateAllCities() {
@@ -205,9 +213,11 @@ export function createViewport({ state: layerState, services, parts, source }) {
 
     const generation = ++layerState._proximityGeneration;
     const altitude = getCameraAltitude(layerState._viewer);
+    const wasGateEnabled = layerState._altitudeGateEnabled;
     // Altitude gate: disable all cities when camera is too high
     if (!shouldActivateAtAltitude(altitude)) {
       deactivateAllCities();
+      if (wasGateEnabled) refreshRow();
       return;
     }
 
@@ -226,12 +236,18 @@ export function createViewport({ state: layerState, services, parts, source }) {
       if (!nextActive.has(cityId)) layerState._failedCityIds.delete(cityId);
     }
 
+    const changed =
+      !wasGateEnabled ||
+      nextActive.size !== layerState._activeCityIds.size ||
+      [...nextActive].some((cityId) => !layerState._activeCityIds.has(cityId));
     layerState._activeCityIds = nextActive;
     if (layerState._activeCityIds.size === 0) {
       layerState._count = 0;
       layerState._lastUpdate = null;
+      if (changed) refreshRow();
       return;
     }
+    if (changed) refreshRow();
 
     // Only activate cities that don't already have rendered points
     const toActivate = [];
@@ -243,6 +259,7 @@ export function createViewport({ state: layerState, services, parts, source }) {
     await Promise.all(
       toActivate.map((cityId) => activateCity(cityId, generation)),
     );
+    if (generation === layerState._proximityGeneration) refreshRow();
   }
 
   /** Schedule a debounced proximity check after camera movement. */
diff --git a/src/layers/promptRepaint.test.mjs b/src/layers/promptRepaint.test.mjs
new file mode 100644
index 000000000..563aaeac7
--- /dev/null
+++ b/src/layers/promptRepaint.test.mjs
@@ -0,0 +1,122 @@
+// When the camera changes which coverage prompt a Transit or
+// Bike Share row shows, the layer asks the panel to repaint at once, instead
+// of leaving the old prompt up until the manager's next tick (Transit 15 s,
+// Bike Share 60 s).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createState as createBikeState } from './bikeshare/state.js';
+import { createControls as createBikeControls } from './bikeshare/controls.js';
+import { createModel as createBikeModel } from './bikeshare/model.js';
+import { createViewport as createBikeViewport } from './bikeshare/viewport.js';
+import { createState as createTransitState } from './transit/state.js';
+import { createViewport as createTransitViewport } from './transit/viewport.js';
+import { createQueries as createTransitQueries } from './transit/queries.js';
+
+const rad = Math.PI / 180;
+const LONDON = { lat: 51.5072, lon: -0.1276 };
+const BOSTON = { lat: 42.3601, lon: -71.0589 };
+
+const services = () => ({
+  overlays: {
+    setOverlayEntries() {},
+    setOverlaySourceVisible() {},
+    clearOverlaySource() {},
+  },
+  render: { governorRequestRender() {} },
+});
+
+function viewer(at, height) {
+  return {
+    camera: {
+      positionCartographic: {
+        height,
+        latitude: at.lat * rad,
+        longitude: at.lon * rad,
+      },
+      computeViewRectangle: () => undefined,
+    },
+    scene: { globe: {} },
+  };
+}
+
+function spyManager() {
+  const dm = { repaints: 0 };
+  dm.refreshLayerStats = () => {
+    dm.repaints++;
+  };
+  return dm;
+}
+
+test('Bike Share: flying from London into Boston repaints the prompt row', async () => {
+  const svc = services();
+  const state = createBikeState({ services: svc });
+  const parts = {
+    queries: { collectDetectableStations: () => [] },
+    model: createBikeModel({ state, services: svc, parts: {}, source: null }),
+    ingestion: {
+      abortInFlight() {},
+      loadCityStationInfo: async () => new Map(),
+      loadCityStationStatus: async () => new Map(),
+    },
+    rendering: {
+      removeCityPoints() {},
+      ensureCityPoints() {},
+      applyStatusToPoints() {},
+    },
+  };
+  parts.viewport = createBikeViewport({
+    state,
+    services: svc,
+    parts,
+    source: null,
+  });
+  const { methods } = createBikeControls({
+    state,
+    services: svc,
+    parts,
+    source: {},
+  });
+  state._enabled = true;
+  const dm = spyManager();
+  methods.attachDataManager(dm);
+
+  state._viewer = viewer(LONDON, 8_000);
+  await parts.viewport.runProximityCheck();
+  assert.equal(methods.getStats().status, 'zoom-in');
+
+  const before = dm.repaints;
+  state._viewer = viewer(BOSTON, 3_000);
+  await parts.viewport.runProximityCheck();
+  assert.equal(methods.getStats().status, undefined, 'Boston is covered');
+  assert.ok(dm.repaints > before, 'the row was asked to repaint');
+});
+
+test('Transit: leaving Boston for London repaints the row', () => {
+  const svc = services();
+  const state = createTransitState({ services: svc });
+  const parts = {
+    ingestion: {
+      feedStatus: () => ({ count: 0 }),
+      pollFeed() {},
+      removeFeedVehicles() {},
+      sweepAgedVehicles() {},
+    },
+    rendering: { requestVisibility() {}, syncRenderHold() {} },
+  };
+  parts.viewport = createTransitViewport({ state, services: svc, parts });
+  const queries = createTransitQueries({ state, parts }).methods;
+  state._enabled = true;
+  const dm = spyManager();
+  state._dataManager = dm;
+
+  state._viewer = viewer(BOSTON, 4_000);
+  parts.viewport.runProximityCheck();
+  assert.ok(state._activeFeeds.size > 0, 'Boston has a feed');
+  state._lastUpdate = Date.now();
+
+  const before = dm.repaints;
+  state._viewer = viewer(LONDON, 4_000);
+  parts.viewport.runProximityCheck();
+  assert.equal(queries.getStats().status, 'zoom-in');
+  assert.ok(dm.repaints > before, 'the row was asked to repaint');
+});
diff --git a/src/layers/transit/gatePrompt.test.mjs b/src/layers/transit/gatePrompt.test.mjs
new file mode 100644
index 000000000..7f439fcdc
--- /dev/null
+++ b/src/layers/transit/gatePrompt.test.mjs
@@ -0,0 +1,66 @@
+// The Transit coverage prompt names the altitude the closed gate
+// actually opens at. Descending over Boston to 2,900 km (below 3,000 km, above
+// the 2,850 km enter threshold) loads nothing, so a prompt "Fly below 3,000 km"
+// asks for something the camera has already done.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createState } from './state.js';
+import { createViewport } from './viewport.js';
+import { createQueries } from './queries.js';
+import { ACTIVATION_ENTER_ALTITUDE_M } from './policy.js';
+
+const BOSTON = { lat: 42.3601, lon: -71.0589 };
+
+function makeLayer() {
+  const services = {
+    overlays: {
+      setOverlayEntries() {},
+      setOverlaySourceVisible() {},
+      clearOverlaySource() {},
+    },
+    render: { governorRequestRender() {} },
+  };
+  const state = createState({ services });
+  const polled = [];
+  const parts = {
+    ingestion: {
+      feedStatus: () => ({ count: 0 }),
+      pollFeed: (feed) => polled.push(feed.id),
+      removeFeedVehicles() {},
+      sweepAgedVehicles() {},
+    },
+    rendering: { requestVisibility() {}, syncRenderHold() {} },
+  };
+  parts.viewport = createViewport({ state, services, parts });
+  const queries = createQueries({ state, parts }).methods;
+  state._enabled = true;
+  const rad = Math.PI / 180;
+  state._viewer = {
+    camera: {
+      positionCartographic: {
+        height: 0,
+        latitude: BOSTON.lat * rad,
+        longitude: BOSTON.lon * rad,
+      },
+      computeViewRectangle: () => undefined,
+    },
+    scene: { globe: {} },
+  };
+  return { state, queries, viewport: parts.viewport, polled };
+}
+
+test('below the prompted altitude but above the gate, the prompt names the gate', () => {
+  const { state, queries, viewport, polled } = makeLayer();
+  state._viewer.camera.positionCartographic.height = 2_900_000;
+  viewport.runProximityCheck();
+
+  // Nothing loads at 2,900 km: the gate opens at the enter threshold.
+  assert.equal(state._altitudeGateOpen, false);
+  assert.deepEqual(polled, []);
+
+  const km = Math.round(ACTIVATION_ENTER_ALTITUDE_M / 1000).toLocaleString(
+    'en-US',
+  );
+  const { statusMessage } = queries.getStats();
+  assert.equal(statusMessage, `Fly below ${km} km to a covered region`);
+});
diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs
index a269dc9e9..dc18fd6f0 100644
--- a/src/layers/transit/lifecycle.test.mjs
+++ b/src/layers/transit/lifecycle.test.mjs
@@ -4018,6 +4018,6 @@ test('a view with no feed reads its coverage prompt, not an undated feed', async
   app.advance(1_000);
   assert.equal(
     app.layer.getStats().statusMessage,
-    'Fly below 3,000 km to a covered region',
+    'Fly below 2,850 km to a covered region',
   );
 });
diff --git a/src/layers/transit/queries.js b/src/layers/transit/queries.js
index 8023cdb39..748929213 100644
--- a/src/layers/transit/queries.js
+++ b/src/layers/transit/queries.js
@@ -1,5 +1,5 @@
 import {
-  ACTIVATION_ALTITUDE_M,
+  ACTIVATION_ENTER_ALTITUDE_M,
   FEED_STALE_AFTER_MS,
   aggregateTransitFeedHealth,
   transitDetectionClass,
@@ -245,7 +245,7 @@ export function createQueries({ state, parts }) {
         // (ui/statusText.js).
         const note = state._altitudeGateOpen
           ? `No feed here yet · ${TRANSIT_ENABLED_FEEDS.length} regions available`
-          : `Fly below ${Math.round(ACTIVATION_ALTITUDE_M / 1000).toLocaleString('en-US')} km to a covered region`;
+          : `Fly below ${Math.round(ACTIVATION_ENTER_ALTITUDE_M / 1000).toLocaleString('en-US')} km to a covered region`;
         return {
           count: 0,
           lastUpdate: state._lastUpdate,
diff --git a/src/layers/transit/viewport.js b/src/layers/transit/viewport.js
index 27cc0569c..0e3b317d4 100644
--- a/src/layers/transit/viewport.js
+++ b/src/layers/transit/viewport.js
@@ -83,7 +83,9 @@ export function createViewport({ state, services, parts }) {
     if (!state._enabled || !state._viewer) return;
     refreshViewBounds();
     const altitude = getCameraAltitude();
+    const wasGateOpen = state._altitudeGateOpen;
     state._altitudeGateOpen = altitudeGateOpen(altitude);
+    let changed = state._altitudeGateOpen !== wasGateOpen;
     const center = state._altitudeGateOpen ? getCameraCenterLatLon() : null;
     const desired = new Map();
     if (center) {
@@ -106,6 +108,7 @@ export function createViewport({ state, services, parts }) {
         state._activeFeeds.delete(feedId);
         state._feedStatus.delete(feedId);
         parts.ingestion.removeFeedVehicles(feedId);
+        changed = true;
       }
     }
     // Leaving coverage leaves nothing on the map to date: a row that read
@@ -115,11 +118,15 @@ export function createViewport({ state, services, parts }) {
       if (!state._activeFeeds.has(feedId)) {
         state._activeFeeds.set(feedId, feed);
         void parts.ingestion.pollFeed(feed, state._generation);
+        changed = true;
       }
     }
     parts.ingestion.sweepAgedVehicles(Date.now());
     parts.rendering.syncRenderHold();
     governorRequestRender('transit-proximity');
+    // The row's text follows the camera (coverage prompt, feed list), so it
+    // repaints now instead of at the next 15 s manager tick.
+    if (changed) state._dataManager?.refreshLayerStats?.();
   }
 
   function onCameraChanged() {
diff --git a/src/ui/statusText.test.mjs b/src/ui/statusText.test.mjs
index 1b6479b45..6d1648b6d 100644
--- a/src/ui/statusText.test.mjs
+++ b/src/ui/statusText.test.mjs
@@ -83,7 +83,7 @@ for (const locale of ['es', 'ru']) {
 // A layer's coverage note when no feed covers the view: one sentence with a
 // " · " in it (transit/queries.js, bikeshare/controls.js).
 const COVERAGE_NOTES = [
-  'Fly below 3,000 km to a covered region',
+  'Fly below 2,850 km to a covered region',
   'No feed here yet · 16 regions available',
   'Fly below 48 km to a covered city',
   'No bike share here yet · 61 systems available',
diff --git a/src/voice/analystEmptyNotes.test.mjs b/src/voice/analystEmptyNotes.test.mjs
index b0de16ebd..cfacee4bf 100644
--- a/src/voice/analystEmptyNotes.test.mjs
+++ b/src/voice/analystEmptyNotes.test.mjs
@@ -70,7 +70,7 @@ const cases = [
 
 // Transit's coverage text when nothing is in view (transit/queries.js).
 const transitCoverage = [
-  'transit: Fly below 3,000 km to a covered region',
+  'transit: Fly below 2,850 km to a covered region',
   'transit: No feed here yet · 12 regions available',
 ];
 
diff --git a/src/voice/resultDisplay.js b/src/voice/resultDisplay.js
index cd909d2f7..72a929b94 100644
--- a/src/voice/resultDisplay.js
+++ b/src/voice/resultDisplay.js
@@ -423,7 +423,7 @@ function shownNote(text) {
     const shown = match ? show(match) : null;
     if (shown) return shown;
   }
-  // A layer's empty note can be its coverage note ("Fly below 3,000 km to a
+  // A layer's empty note can be its coverage note ("Fly below 2,850 km to a
   // covered region") or its status line, English pieces joined by " · "
   // ("feeds 1090, 978 stale · 0 heard", "TTC 0 (95s old)").
   return translateStatusMessage(text);

From 433b336c2d57087986d8114735861f53d790d7d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Itallo=20Brand=C3=A3o?=
 <45429643+IMBrandao@users.noreply.github.com>
Date: Fri, 6 Nov 2026 02:50:42 -0300
Subject: [PATCH 20/71] feat(transit): add Szczecin buses and trams (ZDiTM,
 CC0)

Keyless GTFS-Realtime feed published by ZDiTM Szczecin under CC0 1.0.
Speeds are m/s (checked against vehicle movement), the file refreshes about
every 20 s, and the feed carries no route ids, so vehicles take the default
bus mode.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 DATA_SOURCES.md                 |  3 ++-
 README.md                       |  2 +-
 changelog.d/szczecin-transit.md |  3 +++
 docs/CURRENT-STATE.md           |  4 ++--
 src/data/transitFeeds.js        | 23 +++++++++++++++++++++++
 src/data/transitFeeds.test.mjs  | 26 ++++++++++++++++++++++++++
 6 files changed, 57 insertions(+), 4 deletions(-)
 create mode 100644 changelog.d/szczecin-transit.md

diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index ed0895b0a..6532837d8 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -99,6 +99,7 @@ How to read this:
 | **YRT/Viva** (rtu.york.ca) | Transit layer live vehicles, York Region ON | York Region Transit realtime data, first-party York Region infrastructure under the YRT Open Data Licence v2.0, which permits commercial use and makes attribution optional. Viva route ids are named by colour from York Region’s published GTFS. | "Contains public transit Information made available under YRT’s Open Data Licence" — the licence’s own wording, given though not required |
 | **Burlington Transit** (opendata.burlington.ca) | Transit layer live vehicles, Burlington ON | Burlington Transit realtime data under the City of Burlington Open Data Terms of Use, which permit any lawful purpose. The terms are revocable and must travel with the data, so the credit links them. Route ids are internal keys and are joined to the City’s published GTFS. | Credit to the City of Burlington plus a link to its Open Data Terms of Use, which the licence requires |
 | **SMTR Rio de Janeiro** (dados.mobilidade.rio) | Transit layer live vehicles, Rio de Janeiro: municipal buses (SPPO) and the Mobi-Rio BRT, as two feeds | CC BY 4.0, stated on both data.rio catalog pages. Keyless GTFS-Realtime published by the Secretaria Municipal de Transportes, labelled beta, with a gateway limit of 5 requests a second and 60 a minute. Line names come from SMTR’s GTFS `routes.txt` (dados.mobilidade.rio/gtfs/schedule), under the same licence. | Attribution to SMTR / Prefeitura da Cidade do Rio de Janeiro under CC BY 4.0 |
+| **ZDiTM Szczecin** (zditm.szczecin.pl) | Transit layer live vehicles, Szczecin, Poland: buses and trams as one feed | CC0 1.0, stated on the ZDiTM developer page: “The data are provided free of charge under the CC0 1.0 licence, for use in any context, with no prior notification required.” Keyless GTFS-Realtime; the page says one update a minute, measured at about every 20 seconds. The feed carries no route id, so every vehicle takes the default bus mode. | None required (CC0); credited to ZDiTM Szczecin as a courtesy |
 | **Radio Browser**                                                     | Geolocated internet-radio station directory and station-level tags                                                                  | Public-domain directory data under PDDL 1.0; individual broadcaster stream terms apply                                                                                                                                                                                                                                                                | "Radio Browser" plus a link to the selected broadcaster                                                                                     |
 | **Re:Earth Terrain** (Mapterhorn)                                     | Terrain (keyless globe stacks — OSM etc. — + `/api/terrain/heights` ellipsoidal-height lookups)                                     | Terrain mesh: CC BY 4.0; geoid: EGM2008 (NGA, public domain)                                                                                                                                                                                                                                                                                          | "Terrain (keyless globe stacks): Re:Earth Terrain / Mapterhorn (CC BY 4.0) / EGM2008 (NGA)"                                                 |
 | **OpenSeaMap** (`tiles.openseamap.org`) | Sea Marks layer: raster overlay of buoys, lighthouses and ports (#10) | Chart tiles CC BY-SA 2.0; data ODbL 1.0 via OpenStreetMap | "Sea marks © OpenSeaMap contributors (CC BY-SA 2.0) · Data © OpenStreetMap contributors (ODbL)" |
@@ -186,7 +187,7 @@ The optional Local ADS-B layer and the broadcast-FM receiver use radio you recei
 - **Houston TranStar cameras.** Keyless. The camera list is the public `traffic.houstontranstar.org/data/layers/cctvSnapshots_json.js` catalog (~1,000 cameras across Greater Houston); frames are stills at `www.houstontranstar.org/snapshots/cctv/<id>.jpg`, synthesized from a validated numeric id rather than taken from the payload, and only that host is registered. Cameras whose catalog id is `0` (a different, non-snapshot class) and cameras outside Greater Houston are dropped. TranStar's `dir` field is the side of the freeway the camera sits on, not the way it faces: TranStar's own map shows it as "Traffic closest to the camera is traveling …" (South → eastbound, North → westbound, West → southbound, East → northbound). That travel direction (90°, 270°, 180°, 0°) seeds the heading as a low-confidence prior with the low-confidence pose; `None` or an unknown value uses the shared id-hash fallback at low confidence. Headings are corrected with the in-app calibration gizmo. Off by default. TranStar's [Content Usage terms](https://traffic.houstontranstar.org/disclaimer.aspx) prohibit copying or distributing the site's information, and external framing or linking to specific images, without TxDOT's prior written permission; its FAQ grants permission-free use only for the RSS feeds. This project does not hold that permission for downstream installations, so the pack loads only when an operator who holds TxDOT's written permission sets `CCTV_HOUSTON_ENABLED=1`; with the flag unset, empty or any other value, the server makes no request to TranStar. Once enabled, it loads the 250 cameras nearest downtown, Uptown, the Medical Center, IAH and Galveston; `CCTV_HOUSTON_MAX_SOURCES` (8–400) changes the cap. Snapshots update about every 3 minutes, which is also the ambient still cadence. Frames are fetched from TranStar and relayed to the browser on demand, buffered only transiently per request, sent with `Cache-Control: no-store`, and not archived.
 - **Autostrada del Brennero (A22) webcams.** Keyless. The camera list is one request to the Open Data Hub tourism API (`tourism.api.opendatahub.com/v1/WebcamInfo?source=a22`), run by NOI Techpark in South Tyrol, which republishes Autobrennero's own list of 13 motorway webcams with coordinates and kilometre markers. Frames are the operator's stills on `www.autobrennero.it/WebCamImg/km<N>.jpg`, refreshed about once a minute, and only the exact image for each camera's kilometre is registered. The feed names no bearing, so headings use the id-hash fallback at low confidence. The road climbs from about 20 m in the Po valley to about 1,370 m at the Brenner Pass, so each camera's ground elevation comes from a per-kilometre table sampled from the Copernicus GLO-90 DEM (via Open-Meteo's elevation API); a camera not in the table uses a 200 m prior. The Open Data Hub tags every record CC0 (`ClosedData: false`, Autobrennero as licence holder), but that tag is the aggregator's metadata and Autobrennero publishes no terms of its own for the images, so they are credited to the operator as a courtesy and are not redistributed. Frames are fetched at request time and never stored. Disable with `CCTV_A22_ENABLED=0`.
 - **Camera frame content.** Public camera frames can contain people, vehicles and license plates, and the camera layer does nothing with them beyond putting them on the map. A successful upstream response is relayed as the provider served it: nothing in the camera pipeline blurs, redacts, enhances or restores it, and nothing there runs face, plate or object detection or otherwise recognises or classifies what is in the picture. (The ALPR layer described below maps where plate-reader cameras are, from locations contributors tagged in OpenStreetMap; it reads nothing from any camera frame.) When an upstream has no frame for a camera, what you see instead is a Google Street View still or the app's own placeholder card; the panel's source badge names which of them you are looking at, and a refresh that fails after a frame has arrived leaves the last good picture on screen rather than replacing it. The browser resamples each frame for display: onto a fixed 1920x1080 surface for the camera's projection plane in the scene, and onto a 192x108 canvas for the small ambient card. That scaling is the only change made to the picture, and the only pixels the camera layer reads back are a 64x36 downscale hashed to tell whether the picture has changed. Live streams are piped through; the still path reads the image into memory to pass it on — TxDOT wraps its JPEG in a JSON envelope, which is decoded there — and no frame is written to disk (the disk cache, `.gev-cache/`, holds feed JSON for other layers and never camera imagery). Outside that pipeline, the voice assistant is the one feature that sends imagery anywhere: when it answers a question about what is in view it may attach a downscaled screenshot of the rendered scene — including any camera plane on screen — to the request it sends to the voice model. Frames are fetched only from server-registered camera URLs — a client cannot hand the proxy a URL (see [SECURITY.md](SECURITY.md)). What the app does stays inside the line README draws: no named-person search, no face recognition, no tracking individuals.
-- **Transit (GTFS-Realtime).** The proxy requests only registered operator feeds, validates redirects, bounds responses, and uses conditional requests, short snapshot caching and failure backoff. All eighteen registered feeds, covering seventeen regions, are live-enabled; each can be disabled independently. Vehicles use delayed playback between reports, with report age and waiting states shown separately. Session-local selected trails are available for every feed. MBTA additionally retains up to 15 minutes of recently observed positions in the running proxy, so available history can survive a browser reload; server restart clears it. History reads never fetch upstream, and other feeds have no proxy retention. Nothing is archived to disk or collected in the background. Operator text credits are included as a courtesy and do not imply endorsement. Heights are aligned to work with Google 3D tiles; subway markers are shown at street level because these feeds do not supply depth. The TTC feed is BusTime, the surface system: it carries buses and streetcars and no subway at all. About four in ten of its vehicles report no route at all (unassigned or deadheading), and those are shown with the feed default rather than a route-established mode. It sends no ETag or Last-Modified, so its conditional requests fall through to the ordinary snapshot cache. Three Golden Horseshoe neighbours run alongside it — MiWay, Hamilton HSR and Durham Region Transit — each bus-only and each polled only near its own region. Durham Region Transit publishes no bearing on any vehicle, so those sprites take their heading from observed movement like any other feed that omits it. Guelph, Kingston and Barrie extend the same pattern eastward and north. Hamilton, Guelph, Burlington, YRT and Rio’s SMTR publish route ids that are not the number on the vehicle, so those entries carry a route-name table taken from each operator’s own published GTFS; any id missing from a table renders unchanged rather than blank. A label is never invented: YRT runs a route `9101` that appears nowhere in its published routes, so it stays as the feed sends it. Burlington’s is the one that cannot be shortcut: `351` is route 1 while `3510` is route 10, so the table is a real join rather than a trimmed prefix. GO Transit / Metrolinx is deliberately absent: its REALTIME feed requires an API key issued by manual review, which the keyless admission rule excludes (its static schedule download is keyless, but carries no vehicle positions). Barrie and YRT/Viva each invite acceptance of their licence through a form, and each licence also states that using the data is itself acceptance; this deployment relies on that clause, which is recorded in both entries. Grand River Transit in Waterloo is absent for a different reason: it answers, but its feed header was months stale and it publishes no per-vehicle timestamps, so it would render vehicles that look live and are not. Ottawa’s OC Transpo falls to the same keyless admission rule as GO Transit — its realtime feed requires an API key. London Transit and Thunder Bay Transit publish vehicle positions over plain HTTP with no HTTPS endpoint available. Every other Ontario system — Brampton, Oakville, Niagara, Milton, Windsor, Greater Sudbury, UP Express and a dozen smaller operators — publishes static GTFS schedules only, with no realtime vehicle positions to register. Between the nine included and these exclusions, every Ontario realtime vehicle-position feed catalogued in the Mobility Database is accounted for.
+- **Transit (GTFS-Realtime).** The proxy requests only registered operator feeds, validates redirects, bounds responses, and uses conditional requests, short snapshot caching and failure backoff. All nineteen registered feeds, covering eighteen regions, are live-enabled; each can be disabled independently. Vehicles use delayed playback between reports, with report age and waiting states shown separately. Session-local selected trails are available for every feed. MBTA additionally retains up to 15 minutes of recently observed positions in the running proxy, so available history can survive a browser reload; server restart clears it. History reads never fetch upstream, and other feeds have no proxy retention. Nothing is archived to disk or collected in the background. Operator text credits are included as a courtesy and do not imply endorsement. Heights are aligned to work with Google 3D tiles; subway markers are shown at street level because these feeds do not supply depth. The TTC feed is BusTime, the surface system: it carries buses and streetcars and no subway at all. About four in ten of its vehicles report no route at all (unassigned or deadheading), and those are shown with the feed default rather than a route-established mode. It sends no ETag or Last-Modified, so its conditional requests fall through to the ordinary snapshot cache. Three Golden Horseshoe neighbours run alongside it — MiWay, Hamilton HSR and Durham Region Transit — each bus-only and each polled only near its own region. Durham Region Transit publishes no bearing on any vehicle, so those sprites take their heading from observed movement like any other feed that omits it. Guelph, Kingston and Barrie extend the same pattern eastward and north. Hamilton, Guelph, Burlington, YRT and Rio’s SMTR publish route ids that are not the number on the vehicle, so those entries carry a route-name table taken from each operator’s own published GTFS; any id missing from a table renders unchanged rather than blank. A label is never invented: YRT runs a route `9101` that appears nowhere in its published routes, so it stays as the feed sends it. Burlington’s is the one that cannot be shortcut: `351` is route 1 while `3510` is route 10, so the table is a real join rather than a trimmed prefix. GO Transit / Metrolinx is deliberately absent: its REALTIME feed requires an API key issued by manual review, which the keyless admission rule excludes (its static schedule download is keyless, but carries no vehicle positions). Barrie and YRT/Viva each invite acceptance of their licence through a form, and each licence also states that using the data is itself acceptance; this deployment relies on that clause, which is recorded in both entries. Grand River Transit in Waterloo is absent for a different reason: it answers, but its feed header was months stale and it publishes no per-vehicle timestamps, so it would render vehicles that look live and are not. Ottawa’s OC Transpo falls to the same keyless admission rule as GO Transit — its realtime feed requires an API key. London Transit and Thunder Bay Transit publish vehicle positions over plain HTTP with no HTTPS endpoint available. Every other Ontario system — Brampton, Oakville, Niagara, Milton, Windsor, Greater Sudbury, UP Express and a dozen smaller operators — publishes static GTFS schedules only, with no realtime vehicle positions to register. Between the nine included and these exclusions, every Ontario realtime vehicle-position feed catalogued in the Mobility Database is accounted for.
 - **Radio country coverage (optional).** Set `RADIO_PRIORITY_COUNTRIES=IN,PL` in the local `.env` and restart to include stations beyond the global click charts. The operator may choose up to eight unique ISO alpha-2 country codes; no key is needed. Each country adds one bounded query (at most 200 rows) and reserves up to 40 unique, usable stations inside the existing 750-station catalog. Country seeds precede specialist-tag seeds and global popularity fill; unused slots return to the shared pool. This is a coverage preference, not an exhaustive national directory or a guarantee of stations in every city. Countries with no eligible HTTPS MP3/AAC geolocated stations remain empty. An unset list preserves global selection. Country requests share the directory cache and three-worker pool; failed country queries are reported in coverage without blocking a healthy global refresh. Failed/degraded refreshes back off for one minute, with at most three mirrors per query.
 
 - **Radio Browser.** In every installation, including when `RADIO_PRIORITY_COUNTRIES` is unset, each request tries at most three mirror candidates (later fallback candidates are skipped), and failed or partial catalog refreshes back off for 60 seconds. A cold-start failure therefore continues returning 503 during that delay even if upstream recovers. `/api/radio/stations` discovers official API mirrors, makes bounded and coalesced healthy/geolocated HTTPS-station queries, caches the normalized public-domain directory for 45 minutes, and may serve the last good catalog for up to seven days during an outage. Refreshes must meet minimum accepted-query and station coverage before replacing a warm catalog; broad/specialist responses whose rows all fail the product's health policy do not count as successful queries. Optional priority-country outcomes are advisory: valid, in-limit responses with no eligible stations succeed as empty results, while failed or malformed country queries report unsuccessful coverage without degrading the global catalog. A usable partial cold catalog is explicitly `DEGRADED`, and non-array or empty broad/specialist payloads are rejected atomically. Individual structurally malformed rows are skipped rather than failing the whole query; the response carries their bounded `rejectedStationCount` (at most 10,000), which the client adds to its own rejected rows and reports as degraded coverage without discarding the accepted generation. Every directory and click-count request rejects redirects, validates all resolved addresses as globally routable (including reserved/documentation IPv4 and special/non-global IPv6 exclusions), and pins the TLS connection to a validated address. Only MP3/AAC non-HLS directory rows with public HTTPS stream targets are returned; favicons are intentionally omitted. Pressing play connects one browser audio element directly to the selected broadcaster and calls the directory's click counter through known-ID-only `POST /api/radio/click/:uuid`. GEV never proxies, caches, records, bundles, or redistributes audio. Radio Browser supplies station-level tags, not dependable current-song or upcoming-program metadata, so Radio filtering never claims either. Direct playback exposes the listener's IP address to the broadcaster, whose own stream terms apply.
diff --git a/README.md b/README.md
index 6212f3991..6c8de0d79 100644
--- a/README.md
+++ b/README.md
@@ -444,7 +444,7 @@ Twenty-one layers and map sources. **Nineteen have a keyless path.** Some offer
 | 📷 **Mapped ALPR Cameras**  | License-plate-reader camera locations tagged by OpenStreetMap contributors, loaded one city-sized view at a time, with **SHOW NEAREST**. Locations and tags only: no plate data, no video                                                                                                                                                                                           | OpenStreetMap (incl. DeFlock mapping)   | 🟢                                                                                                  |
 | 📷 **Street Level**         | Street-level photos behind one panel, one chip per provider: coverage on the streets, image cones, an embedded viewer with full-screen **EXPAND**. Mapillary, Google Street View, KartaView and Panoramax | Mapillary · Google · KartaView · Panoramax | 🟢 KartaView, Panoramax · 🟡 Mapillary token · 🔴 Google Maps key |
 | 📻 **Radio**                | Geolocated world radio with an **analog tuner** — drag the needle across up to 750 stations and the globe flies to each broadcaster                                                                                                                                                                                                                                                 | Radio Browser / broadcasters            | 🟢                                                                                                  |
-| 🚌 **Transit**              | Live buses, trams, metros, trains and ferries with delayed playback between reports, selected-vehicle trails, and mode-coloured DETECT labels — Boston, Austin, Minneapolis, Helsinki, the Netherlands, Norway, South East Queensland, Rio de Janeiro (buses and BRT), and nine in Ontario: Toronto (surface vehicles; the subway publishes no positions), Mississauga, Hamilton, Durham Region, York Region, Guelph, Burlington, Barrie and Kingston                                                                                                                                               | Operator GTFS-Realtime feeds            | 🟢                                                                                                  |
+| 🚌 **Transit**              | Live buses, trams, metros, trains and ferries with delayed playback between reports, selected-vehicle trails, and mode-coloured DETECT labels — Boston, Austin, Minneapolis, Helsinki, the Netherlands, Norway, South East Queensland, Rio de Janeiro (buses and BRT), Szczecin, and nine in Ontario: Toronto (surface vehicles; the subway publishes no positions), Mississauga, Hamilton, Durham Region, York Region, Guelph, Burlington, Barrie and Kingston                                                                                                                                               | Operator GTFS-Realtime feeds            | 🟢                                                                                                  |
 | 🚲 **Bikeshare**            | Live station availability                                                                                                                                                                                                                                                                                                                                                           | GBFS                                    | 🟢                                                                                                  |
 | 🧭 **Directions**           | Click A and B on the globe for a street-following drive, walk or cycle route draped on the terrain with turn-by-turn steps — then FLY the camera along it. No key, no geocoder, no mic                                                                                                                                                                                              | OSRM on FOSSGIS servers (OpenStreetMap) | 🟢                                                                                                  |
 | ⌖ **OSM Places**           | Voice place search ("hospitals in Kathmandu") from OpenStreetMap, drawn as numbered points that follow-up questions can filter. Needs your own Overpass server (`OVERPASS_UPSTREAMS`); off otherwise                                                                                                                                                                                                                                                                                                                               |
diff --git a/changelog.d/szczecin-transit.md b/changelog.d/szczecin-transit.md
new file mode 100644
index 000000000..5b2411211
--- /dev/null
+++ b/changelog.d/szczecin-transit.md
@@ -0,0 +1,3 @@
+- Add Szczecin, Poland to the Transit layer: buses and trams from ZDiTM's
+  keyless GTFS-Realtime feed, published under CC0 1.0. The feed carries no
+  route ids, so vehicles show as buses (IMBrandao).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index abfa3fc04..85bfd2e92 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4644,9 +4644,9 @@ Transit is off by default, and share links use token `j`. The movement panel ord
 places Transit directly after Street Traffic and before Bike Share. Cameras and
 utilities retain their own groups. The layer polls
 registered feeds near the camera every 15 seconds, below a 3,000 km altitude
-gate. Seventeen keyless regions are available: Boston, Austin, Minneapolis–St Paul,
+gate. Eighteen keyless regions are available: Boston, Austin, Minneapolis–St Paul,
 Helsinki, the Netherlands, Norway, South East Queensland, Rio de Janeiro
-(municipal buses and the Mobi-Rio BRT, two feeds), and nine in
+(municipal buses and the Mobi-Rio BRT, two feeds), Szczecin, and nine in
 Ontario — Toronto (TTC surface vehicles; the subway publishes no
 positions), MiWay, Hamilton HSR, Durham Region, YRT/Viva, Guelph,
 Burlington, Barrie and Kingston. Mode silhouettes
diff --git a/src/data/transitFeeds.js b/src/data/transitFeeds.js
index 48ca450a1..76b2764a6 100644
--- a/src/data/transitFeeds.js
+++ b/src/data/transitFeeds.js
@@ -788,6 +788,29 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     defaultMode: 'bus',
     routeLabel: rioRouteLabel,
   }),
+  Object.freeze({
+    id: 'zditm-szczecin',
+    name: 'Szczecin buses and trams',
+    operator:
+      'Zarząd Dróg i Transportu Miejskiego w Szczecinie (ZDiTM), Szczecin',
+    region: 'Szczecin, Poland',
+    // Every vehicle in a 2026-11-05 snapshot sat between 53.34–53.55 N and
+    // 14.44–14.77 E, inside 20 km of this point.
+    center: Object.freeze({ lat: 53.44, lon: 14.56 }),
+    loadRadiusKm: 25,
+    url: 'https://www.zditm.szczecin.pl/storage/gtfs/gtfs-rt-vehicles.pb',
+    license: 'CC0 1.0',
+    licenseUrl: 'https://www.zditm.szczecin.pl/en/zditm/for-developers',
+    attribution:
+      'Zarząd Dróg i Transportu Miejskiego w Szczecinie (ZDiTM Szczecin)',
+    defaultEnabled: true,
+    terms: Object.freeze({
+      quote:
+        'The data are provided free of charge under the CC0 1.0 licence, for use in any context, with no prior notification required.',
+      note: 'CC0 needs no credit; it is given anyway as a courtesy. ZDiTM gives no guarantee of accuracy or completeness. The developer page says the feed updates every minute; measured on 2026-11-05 the file changed about every 20 seconds, with vehicle timestamps up to 50 seconds old. Speeds are m/s: checked against vehicle movement between two snapshots. The feed carries no route id at all, so every vehicle takes the feed default mode even though the city also runs trams.',
+    }),
+    defaultMode: 'bus',
+  }),
 ]);
 
 /**
diff --git a/src/data/transitFeeds.test.mjs b/src/data/transitFeeds.test.mjs
index d6dc93eb6..5fab7c27d 100644
--- a/src/data/transitFeeds.test.mjs
+++ b/src/data/transitFeeds.test.mjs
@@ -552,3 +552,29 @@ test('Rio feeds are CC BY 4.0 and live', () => {
     'Rio has a DATA_SOURCES row',
   );
 });
+
+test('Szczecin is CC0, live, covers the city and not Berlin', () => {
+  const feed = getTransitFeed('zditm-szczecin');
+  assert.equal(feed.defaultEnabled, true);
+  assert.equal(feed.license, 'CC0 1.0');
+  assert.equal(
+    feed.licenseUrl,
+    'https://www.zditm.szczecin.pl/en/zditm/for-developers',
+  );
+  assert.match(feed.terms.quote, /CC0 1\.0 licence/);
+  assert.match(feed.attribution, /ZDiTM/);
+  assert.equal(feed.routeLabel, undefined, 'the feed has no route ids');
+  assert.equal(transitModeFor(feed, null), 'bus');
+  const ids = (lat, lon) => transitFeedsInRange(lat, lon).map((f) => f.id);
+  assert.ok(ids(53.4285, 14.5528).includes('zditm-szczecin'), 'city centre');
+  assert.ok(ids(53.5, 14.7).includes('zditm-szczecin'), 'north-east edge');
+  assert.ok(!ids(52.52, 13.405).includes('zditm-szczecin'), 'Berlin');
+  const sources = readFileSync(
+    new URL('../../DATA_SOURCES.md', import.meta.url),
+    'utf8',
+  );
+  assert.ok(
+    sources.split('\n').some((l) => l.startsWith('| **ZDiTM Szczecin')),
+    'Szczecin has a DATA_SOURCES row',
+  );
+});

From 1015b1666463f98bdcb512b8e0565e5f9d96e53a Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Fri, 6 Nov 2026 14:45:37 +0400
Subject: [PATCH 21/71] Prune queued-card rows whose pooled item paints another
 entry

A pooled paint item reused by another card keeps a fresh frame stamp, so
rows for cards that stopped painting survived every prune and the index
grew for the whole session. The prune now also drops a row whose item
paints a different entry id or source, and a test pins the bound.
---
 src/overlays/worldOverlay.js       | 10 ++++++-
 src/overlays/worldOverlay.test.mjs | 47 ++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+), 1 deletion(-)

diff --git a/src/overlays/worldOverlay.js b/src/overlays/worldOverlay.js
index aabcc7be0..df3055de6 100644
--- a/src/overlays/worldOverlay.js
+++ b/src/overlays/worldOverlay.js
@@ -2298,7 +2298,15 @@ function addPaintItem(record, placement, temporalAlpha, selected) {
 function pruneQueuedItemIndex() {
   for (const [sourceId, bySource] of _queuedItemBySource) {
     for (const [entryId, item] of bySource) {
-      if (item.stamp !== _frameStamp) bySource.delete(entryId);
+      // A pooled item that now paints another entry keeps a fresh stamp.
+      const entry = item.record.entry;
+      if (
+        item.stamp !== _frameStamp ||
+        entry.id !== entryId ||
+        entry.source !== sourceId
+      ) {
+        bySource.delete(entryId);
+      }
     }
     if (bySource.size === 0) _queuedItemBySource.delete(sourceId);
   }
diff --git a/src/overlays/worldOverlay.test.mjs b/src/overlays/worldOverlay.test.mjs
index 6e713a5da..39bc74c44 100644
--- a/src/overlays/worldOverlay.test.mjs
+++ b/src/overlays/worldOverlay.test.mjs
@@ -2353,3 +2353,50 @@ test('promoting an ambient entry to selected paints it once with no fading dupli
     assert.equal(paint(), 1, 'deselect restores the ambient card without re-entry cooldown');
   } finally { env.cleanup(); }
 });
+
+test('the queued-card index stays bounded while card identities churn', () => {
+  // The index is internal: capture the per-source map the same way the
+  // projection-record test captures its map, through Map.prototype.set.
+  const originalSet = Map.prototype.set;
+  let queuedIndex = null;
+  Map.prototype.set = function captureQueuedIndex(key, value) {
+    if (typeof key === 'string' && key.startsWith('churn-card-')
+      && value && typeof value === 'object' && 'temporalAlpha' in value
+      && 'placement' in value && 'stamp' in value) {
+      queuedIndex = this;
+    }
+    return originalSet.call(this, key, value);
+  };
+  const env = installMockEnvironment({ width: 400, height: 300, dpr: 1 });
+  try {
+    initWorldOverlay(env.viewer);
+    const FRAMES = 1300;
+    for (let frame = 0; frame < FRAMES; frame++) {
+      // One painted card whose identity changes every frame: the same pooled
+      // paint item serves every id (a vessel cohort republished as the camera
+      // moves, a CCTV or radio card swapping).
+      setOverlayEntries('cards', [selectedEntry(`churn-card-${frame}`, {
+        position: positionAtScreen(200, 150),
+      })]);
+      env.advanceTime(16);
+      env.postRender.raise();
+      assert.equal(getQueuedOverlayEntryAlpha('cards', `churn-card-${frame}`), 1,
+        'the live card is queued in the frame just painted');
+      if (frame > 0) {
+        assert.equal(getQueuedOverlayEntryAlpha('cards', `churn-card-${frame - 1}`), 0,
+          'a stale row never reports the previous card as queued');
+      }
+    }
+    assert.ok(queuedIndex, 'the queued-card index was never populated');
+    // Rows are pruned every 600 painted frames, so with one new id per frame
+    // the index holds at most one prune window of ids plus the live card.
+    const bound = 600 + 1;
+    assert.ok(
+      queuedIndex.size <= bound,
+      `queued-card index holds ${queuedIndex.size} rows after ${FRAMES} identities (bound ${bound})`,
+    );
+  } finally {
+    Map.prototype.set = originalSet;
+    env.cleanup();
+  }
+});

From 697b6b59e66291c6c690b6a77fd2030396233e03 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Fri, 6 Nov 2026 14:45:39 +0400
Subject: [PATCH 22/71] Repaint coverage rows after loads, nudges and cleared
 failures

---
 src/data/lifecycle.js                         |  19 +-
 src/data/manager.js                           |   4 +-
 src/data/manager.test.mjs                     |  25 ++
 src/layers/bikeshare/controls.js              |  15 +-
 src/layers/bikeshare/rowRepaint.test.mjs      | 295 ++++++++++++++++++
 src/layers/bikeshare/state.js                 |   2 +-
 src/layers/bikeshare/viewport.js              |  13 +-
 .../transit/refreshErrorRepaint.test.mjs      |  98 ++++++
 src/layers/transit/state.js                   |   2 +-
 src/layers/transit/viewport.js                |   2 +-
 10 files changed, 464 insertions(+), 11 deletions(-)
 create mode 100644 src/layers/bikeshare/rowRepaint.test.mjs
 create mode 100644 src/layers/transit/refreshErrorRepaint.test.mjs

diff --git a/src/data/lifecycle.js b/src/data/lifecycle.js
index 6c2290c72..c01926451 100644
--- a/src/data/lifecycle.js
+++ b/src/data/lifecycle.js
@@ -2385,11 +2385,28 @@ export class LayerLifecycle {
   /**
    * Ask presentation to repaint layer rows now, for data that lands outside
    * the manager tick (Transit's proximity polls, Directions' route steps).
+   * @param {string} [layerId] - The layer whose row changed.
    */
-  refreshLayerStats() {
+  refreshLayerStats(layerId) {
+    this._dropRecoveredRefreshError(layerId);
     this._publishActivity({ type: 'status' });
   }
 
+  /**
+   * A tick's failure belongs to the feed it polled. Once the layer's own stats
+   * stop reporting one (the camera left that feed), the row stops showing it
+   * instead of waiting for the next tick.
+   */
+  _dropRecoveredRefreshError(layerId) {
+    const entry = layerId ? this.layers.get(layerId) : null;
+    if (!entry?.managerRefreshError || entry.refreshing) return;
+    const failure = refreshFailureFromStats(
+      this._moduleStats(entry),
+      entry.module.name || layerId,
+    );
+    if (!failure) entry.managerRefreshError = null;
+  }
+
   _publishActivity(change) {
     for (const callback of this._activityListeners) {
       try {
diff --git a/src/data/manager.js b/src/data/manager.js
index cf7b31fae..688fb94d2 100644
--- a/src/data/manager.js
+++ b/src/data/manager.js
@@ -20,8 +20,10 @@ export class DataLayerManager extends LayerLifecycle {
    * manager tick (camera-driven loads such as Transit's proximity polls), so a
    * row shows its count when the data lands instead of at the next interval.
    * One DOM pass; skipped while the document is hidden.
+   * @param {string} [layerId] - The layer whose row changed.
    */
-  refreshLayerStats() {
+  refreshLayerStats(layerId) {
+    this._dropRecoveredRefreshError(layerId);
     this._refreshTogglePanel();
   }
 
diff --git a/src/data/manager.test.mjs b/src/data/manager.test.mjs
index 70f705ec6..de3502979 100644
--- a/src/data/manager.test.mjs
+++ b/src/data/manager.test.mjs
@@ -2677,6 +2677,31 @@ test('refreshLayerStats reaches presentation through the bare lifecycle', async
   assert.deepEqual(changes, ['status']);
 });
 
+test('refreshLayerStats(layerId) drops a tick failure the layer no longer reports', async () => {
+  const { LayerLifecycle } = await import('./lifecycle.js');
+  const lifecycle = new LayerLifecycle({});
+  let stats = { count: 0, error: 'Feed unavailable' };
+  lifecycle.register({
+    id: 'feed',
+    name: 'Feed',
+    getStats: () => stats,
+    async update() {},
+  });
+  const entry = lifecycle.layers.get('feed');
+  entry.enabled = true;
+  entry.initialized = true;
+  entry.managerRefreshError = 'Feed unavailable';
+
+  lifecycle.refreshLayerStats('feed');
+  assert.equal(entry.managerRefreshError, 'Feed unavailable');
+
+  stats = { count: 0 };
+  lifecycle.refreshLayerStats();
+  assert.equal(entry.managerRefreshError, 'Feed unavailable');
+  lifecycle.refreshLayerStats('feed');
+  assert.equal(entry.managerRefreshError, null);
+});
+
 test('periodic polls pause hidden, catch up once when due, and dispose visibility listeners', async (t) => {
   const listeners = new Set();
   const doc = {
diff --git a/src/layers/bikeshare/controls.js b/src/layers/bikeshare/controls.js
index 78edd907b..03bb544ab 100644
--- a/src/layers/bikeshare/controls.js
+++ b/src/layers/bikeshare/controls.js
@@ -70,17 +70,26 @@ export function createControls({ state: layerState, services, parts, source }) {
      * @returns {{ count: number, lastUpdate: number|null, loading: boolean, loadingLabel?: string, error?: string, degraded?: boolean, stale?: boolean, status?: string, statusMessage?: string }}
      */
     getStats() {
+      // A city in range without points is loading even before its fetch
+      // starts: the row repaints on entry, ahead of beginLoading().
+      const loading =
+        layerState._loading ||
+        [...layerState._activeCityIds].some(
+          (cityId) =>
+            !layerState._cityRuntime.has(cityId) &&
+            !layerState._failedCityIds.has(cityId),
+        );
       const stats = {
         count: layerState._count,
         lastUpdate: layerState._lastUpdate,
-        loading: layerState._loading,
+        loading,
       };
       // No system in range is guidance, not an empty feed: the camera is too
       // high, or no catalogued system is near the view. A city that failed
       // leaves range empty too, and reports its failure below instead.
       if (
         layerState._enabled &&
-        !layerState._loading &&
+        !loading &&
         layerState._activeCityIds.size === 0 &&
         layerState._failedCityIds.size === 0
       ) {
@@ -92,7 +101,7 @@ export function createControls({ state: layerState, services, parts, source }) {
           : `Fly below ${Math.round(ACTIVATION_ENTER_ALTITUDE_M / 1000).toLocaleString('en-US')} km to a covered city`;
         return { ...stats, status: 'zoom-in', statusMessage: note };
       }
-      if (layerState._loading) {
+      if (loading) {
         stats.loadingLabel =
           layerState._activeCityIds.size > 0
             ? t('syncing {count} city feeds...', {
diff --git a/src/layers/bikeshare/rowRepaint.test.mjs b/src/layers/bikeshare/rowRepaint.test.mjs
new file mode 100644
index 000000000..144ff5502
--- /dev/null
+++ b/src/layers/bikeshare/rowRepaint.test.mjs
@@ -0,0 +1,295 @@
+// Bike Share row repaints: entering a city, leaving it or nudging the camera
+// mid-load, and leaving a failed city.
+// Bike Share: after the camera settles, the last row the panel painted must
+// match what the layer reports now. Each case drives the real viewport,
+// ingestion, rendering and controls; the manager is a spy that records the
+// row text (LayerPanel._buildMetaText) at every refreshLayerStats() call.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { CITY_BY_ID } from './registry.js';
+import { createState } from './state.js';
+import { createControls } from './controls.js';
+import { createIngestion } from './ingestion.js';
+import { createModel } from './model.js';
+import { createViewport } from './viewport.js';
+import { createRendering } from './rendering.js';
+import { createLifecycle } from './lifecycle.js';
+import { LayerPanel, layerFeedState } from '../../ui/layerPanel.js';
+
+const BOSTON_ID = 'boston-bluebikes';
+const TORONTO_ID = 'toronto-bike-share';
+const BUFFALO_ID = 'buffalo-reddy';
+const LONDON = { lat: 51.5072, lon: -0.1276 };
+const BOSTON = { lat: 42.3601, lon: -71.0589 };
+const BOSTON_NUDGED = { lat: 42.37, lon: -71.05 };
+const BETWEEN = { lat: 43.25, lon: -79.1 };
+const TORONTO_ONLY = { lat: 43.7, lon: -79.6 };
+const LOW_M = 10_000;
+
+globalThis.document ??= {
+  addEventListener() {},
+  removeEventListener() {},
+};
+
+function deferred() {
+  let resolve;
+  const promise = new Promise((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+
+function makeSource() {
+  const cityOf = (url) => {
+    for (const [id, city] of CITY_BY_ID) {
+      if (url === city.stationInformationUrl) return { id, kind: 'info' };
+      if (url === city.stationStatusUrl) return { id, kind: 'status' };
+    }
+    throw new Error(`unexpected GBFS url ${url}`);
+  };
+  const source = {
+    dead: new Set(),
+    /** `${cityId}:${kind}` → deferred that gates the answer. */
+    gates: new Map(),
+    async getStations(url, { signal } = {}) {
+      const { id, kind } = cityOf(url);
+      const gate = source.gates.get(`${id}:${kind}`);
+      if (gate) {
+        await new Promise((resolve, reject) => {
+          gate.promise.then(resolve);
+          signal?.addEventListener('abort', () =>
+            reject(Object.assign(new Error('aborted'), { name: 'AbortError' })),
+          );
+        });
+      } else {
+        await new Promise((resolve) => setTimeout(resolve, 1));
+      }
+      signal?.throwIfAborted();
+      if (source.dead.has(id)) throw new Error('GBFS HTTP 503');
+      const city = CITY_BY_ID.get(id);
+      if (kind === 'info') {
+        return {
+          data: {
+            stations: [
+              {
+                station_id: `${id}-1`,
+                name: `${id} dock`,
+                lat: city.centerLat,
+                lon: city.centerLon,
+                capacity: 10,
+              },
+            ],
+          },
+        };
+      }
+      return {
+        data: {
+          stations: [
+            {
+              station_id: `${id}-1`,
+              num_bikes_available: 3,
+              num_docks_available: 7,
+              is_installed: true,
+              is_renting: true,
+              is_returning: true,
+            },
+          ],
+        },
+      };
+    },
+  };
+  return source;
+}
+
+/** The row as the panel draws it: state chip, count, meta text. */
+const rowText = (raw) => {
+  const stats = {
+    count: 0,
+    lastUpdate: null,
+    ...raw,
+    loading: raw.loading === true,
+  };
+  const meta = LayerPanel.prototype._buildMetaText({
+    id: 'bikeshare',
+    source: 'GBFS',
+    enabled: true,
+    lifecycleState: 'enabled',
+    stats,
+  });
+  return `${layerFeedState(stats)} | ${stats.count || '—'} | ${meta}`;
+};
+
+function makeLiveLayer() {
+  const source = makeSource();
+  const services = {
+    render: { governorRequestRender() {} },
+    overlays: {
+      setOverlayEntries() {},
+      setOverlaySourceVisible() {},
+      clearOverlaySource() {},
+    },
+    sprites: { registerSpriteCollection() {}, restoreSpriteOrder() {} },
+    picking: { registerPickOwner() {}, unregisterPickOwner() {} },
+  };
+  const state = createState({ services });
+  const parts = {};
+  const context = { state, services, parts, source };
+  parts.ingestion = createIngestion(context);
+  parts.model = createModel(context);
+  parts.viewport = createViewport(context);
+  parts.rendering = createRendering(context);
+  parts.selection = {
+    _installClickHandler() {},
+    _clearSelection() {},
+    _onKeyDown() {},
+  };
+  parts.queries = { collectDetectableStations: () => [] };
+  parts.lifecycle = createLifecycle(context);
+  const { methods: controls } = createControls(context);
+
+  const camera = { ...LONDON, height: LOW_M };
+  const viewer = {
+    camera: {
+      get positionCartographic() {
+        return Cesium.Cartographic.fromDegrees(
+          camera.lon,
+          camera.lat,
+          camera.height,
+        );
+      },
+      computeViewRectangle: () => undefined,
+      changed: { addEventListener() {}, removeEventListener() {} },
+    },
+    scene: { globe: {}, primitives: { add() {}, remove() {} } },
+  };
+  parts.lifecycle.methods.init(viewer);
+
+  const painted = [];
+  controls.attachDataManager({
+    refreshLayerStats() {
+      painted.push(rowText(controls.getStats()));
+    },
+  });
+
+  return {
+    state,
+    source,
+    painted,
+    lastPainted: () => painted.at(-1),
+    live: () => rowText(controls.getStats()),
+    moveTo(place, height = LOW_M) {
+      Object.assign(camera, place, { height });
+      return parts.viewport.runProximityCheck();
+    },
+    async enable() {
+      parts.lifecycle.methods.enable(viewer);
+      await settle();
+    },
+  };
+}
+
+async function settle() {
+  for (let i = 0; i < 5; i += 1)
+    await new Promise((resolve) => setTimeout(resolve, 2));
+}
+
+test('entering a city paints the loading row, not "never"', async () => {
+  const layer = makeLiveLayer();
+  const info = deferred();
+  layer.source.gates.set(`${BOSTON_ID}:info`, info);
+  await layer.enable();
+  const before = layer.painted.length;
+  const entering = layer.moveTo(BOSTON);
+  assert.ok(layer.painted.length > before, 'entering repainted');
+  const atEntry = layer.lastPainted();
+  const liveAfter = layer.live();
+  info.resolve();
+  await entering;
+  await settle();
+  assert.match(liveAfter, /syncing 1 city feeds/);
+  assert.match(atEntry, /^loading \|/, 'the entry repaint reads loading');
+  assert.doesNotMatch(atEntry, /never/);
+});
+test('re-entering a city with cached station info paints loading', async () => {
+  const layer = makeLiveLayer();
+  await layer.enable();
+  await layer.moveTo(BOSTON);
+  await settle();
+  await layer.moveTo(LONDON);
+  await settle();
+  const status = deferred();
+  layer.source.gates.set(`${BOSTON_ID}:status`, status);
+  const entering = layer.moveTo(BOSTON);
+  const atEntry = layer.lastPainted();
+  await Promise.resolve();
+  await Promise.resolve();
+  const liveAfter = layer.live();
+  status.resolve();
+  await entering;
+  await settle();
+  assert.match(liveAfter, /syncing 1 city feeds/);
+  assert.match(atEntry, /^loading \|/, 'the entry repaint reads loading');
+  assert.doesNotMatch(atEntry, /never/);
+});
+
+test('leaving a city mid-load does not leave the row on LOADING', async () => {
+  const layer = makeLiveLayer();
+  layer.source.gates.set(`${BOSTON_ID}:info`, deferred());
+  await layer.enable();
+  const entering = layer.moveTo(BOSTON);
+  await settle();
+  assert.equal(layer.state._loading, true);
+
+  await layer.moveTo(LONDON);
+  await entering;
+  await settle();
+  assert.equal(layer.state._loading, false);
+  assert.match(layer.live(), /No bike share here yet/);
+  assert.equal(layer.lastPainted(), layer.live());
+});
+
+test('a camera nudge during the first load still repaints the drawn stations', async () => {
+  const layer = makeLiveLayer();
+  const status = deferred();
+  layer.source.gates.set(`${BOSTON_ID}:status`, status);
+  await layer.enable();
+  const entering = layer.moveTo(BOSTON);
+  await settle();
+  assert.ok(layer.state._cityRuntime.has(BOSTON_ID), 'points are drawn');
+
+  await layer.moveTo(BOSTON_NUDGED);
+  status.resolve();
+  await entering;
+  await settle();
+  assert.equal(layer.state._count, 1, 'one station on the map');
+  assert.equal(layer.lastPainted(), layer.live());
+});
+
+test('leaving a city whose load failed repaints the error away', async () => {
+  const layer = makeLiveLayer();
+  layer.source.dead.add(BOSTON_ID);
+  await layer.enable();
+  await layer.moveTo(BOSTON);
+  await settle();
+  assert.match(layer.lastPainted(), /GBFS fetch error/i);
+
+  await layer.moveTo(LONDON);
+  await settle();
+  assert.match(layer.live(), /No bike share here yet/);
+  assert.equal(layer.lastPainted(), layer.live());
+});
+
+test('leaving the failed city of two repaints DEGRADED away', async () => {
+  const layer = makeLiveLayer();
+  layer.source.dead.add(BUFFALO_ID);
+  await layer.enable();
+  await layer.moveTo(BETWEEN);
+  await settle();
+  assert.match(layer.lastPainted(), /^degraded/);
+
+  await layer.moveTo(TORONTO_ONLY);
+  await settle();
+  assert.doesNotMatch(layer.live(), /^degraded/);
+  assert.equal(layer.lastPainted(), layer.live());
+});
diff --git a/src/layers/bikeshare/state.js b/src/layers/bikeshare/state.js
index 518c2397a..199c9b5ca 100644
--- a/src/layers/bikeshare/state.js
+++ b/src/layers/bikeshare/state.js
@@ -19,7 +19,7 @@ export function createState({ services }) {
 
   layerState._viewer = null;
 
-  /** @type {{ refreshLayerStats?: () => void }|null} Manager that repaints the layer's row. */
+  /** @type {{ refreshLayerStats?: (layerId?: string) => void }|null} Manager that repaints the layer's row. */
 
   layerState._dataManager = null;
 
diff --git a/src/layers/bikeshare/viewport.js b/src/layers/bikeshare/viewport.js
index dbc328f61..008c01333 100644
--- a/src/layers/bikeshare/viewport.js
+++ b/src/layers/bikeshare/viewport.js
@@ -121,7 +121,7 @@ export function createViewport({ state: layerState, services, parts, source }) {
    * prompt, station count), and the manager tick is 60 s.
    */
   function refreshRow() {
-    layerState._dataManager?.refreshLayerStats?.();
+    layerState._dataManager?.refreshLayerStats?.('bikeshare');
   }
 
   /** Deactivate all currently active cities and clear the active set. */
@@ -232,12 +232,17 @@ export function createViewport({ state: layerState, services, parts, source }) {
       }
     }
     // A failure never outlives its city's range.
+    let failureCleared = false;
     for (const cityId of layerState._failedCityIds) {
-      if (!nextActive.has(cityId)) layerState._failedCityIds.delete(cityId);
+      if (!nextActive.has(cityId)) {
+        layerState._failedCityIds.delete(cityId);
+        failureCleared = true;
+      }
     }
 
     const changed =
       !wasGateEnabled ||
+      failureCleared ||
       nextActive.size !== layerState._activeCityIds.size ||
       [...nextActive].some((cityId) => !layerState._activeCityIds.has(cityId));
     layerState._activeCityIds = nextActive;
@@ -259,7 +264,9 @@ export function createViewport({ state: layerState, services, parts, source }) {
     await Promise.all(
       toActivate.map((cityId) => activateCity(cityId, generation)),
     );
-    if (generation === layerState._proximityGeneration) refreshRow();
+    // Superseded loads repaint too: a newer check may have painted the row
+    // while this one was still loading, or found nothing to load itself.
+    if (layerState._enabled) refreshRow();
   }
 
   /** Schedule a debounced proximity check after camera movement. */
diff --git a/src/layers/transit/refreshErrorRepaint.test.mjs b/src/layers/transit/refreshErrorRepaint.test.mjs
new file mode 100644
index 000000000..d1a5c16b8
--- /dev/null
+++ b/src/layers/transit/refreshErrorRepaint.test.mjs
@@ -0,0 +1,98 @@
+// Transit: a manager tick that failed over Boston must not keep its error on
+// the row the coverage repaint draws after the camera leaves for London.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createState } from './state.js';
+import { createViewport } from './viewport.js';
+import { createQueries } from './queries.js';
+import { LayerLifecycle } from '../../data/lifecycle.js';
+import { LayerPanel, layerFeedState } from '../../ui/layerPanel.js';
+
+const rad = Math.PI / 180;
+const LONDON = { lat: 51.5072, lon: -0.1276 };
+const BOSTON = { lat: 42.3601, lon: -71.0589 };
+
+function viewer(at, height) {
+  return {
+    camera: {
+      positionCartographic: {
+        height,
+        latitude: at.lat * rad,
+        longitude: at.lon * rad,
+      },
+      computeViewRectangle: () => undefined,
+    },
+    scene: { globe: {} },
+  };
+}
+
+test('leaving a feed whose tick failed repaints its error away', async () => {
+  const services = {
+    overlays: {
+      setOverlayEntries() {},
+      setOverlaySourceVisible() {},
+      clearOverlaySource() {},
+    },
+    render: { governorRequestRender() {} },
+  };
+  const state = createState({ services });
+  const feedStatus = (feedId) => {
+    if (!state._feedStatus.has(feedId))
+      state._feedStatus.set(feedId, { count: 0, error: null, loading: false });
+    return state._feedStatus.get(feedId);
+  };
+  const parts = {
+    ingestion: {
+      feedStatus,
+      // As pollFeed's catch does when the proxy answers 503.
+      pollFeed(feed) {
+        Object.assign(feedStatus(feed.id), {
+          error: `${feed.name} feed unavailable`,
+          loading: false,
+        });
+        return Promise.resolve();
+      },
+      removeFeedVehicles() {},
+      sweepAgedVehicles() {},
+    },
+    rendering: { requestVisibility() {}, syncRenderHold() {} },
+  };
+  parts.viewport = createViewport({ state, services, parts });
+  const queries = createQueries({ state, parts }).methods;
+  state._enabled = true;
+
+  const lifecycle = new LayerLifecycle(null);
+  lifecycle.register({
+    id: 'transit',
+    name: 'Transit',
+    source: 'GTFS-RT',
+    getStats: () => queries.getStats(),
+    async update() {},
+  });
+  const entry = lifecycle.layers.get('transit');
+  entry.enabled = true;
+  entry.lifecycleState = 'enabled';
+  entry.initialized = true;
+
+  const row = () => {
+    const layer = lifecycle.getAll()[0];
+    return `${layerFeedState(layer.stats)} | ${LayerPanel.prototype._buildMetaText(layer)}`;
+  };
+  const painted = [];
+  state._dataManager = {
+    refreshLayerStats(layerId) {
+      lifecycle.refreshLayerStats(layerId);
+      painted.push(row());
+    },
+  };
+
+  state._viewer = viewer(BOSTON, 4_000);
+  parts.viewport.runProximityCheck();
+  await lifecycle.refreshLayer('transit');
+  assert.match(row(), /feed unavailable/, 'the tick recorded the failure');
+
+  state._viewer = viewer(LONDON, 4_000);
+  parts.viewport.runProximityCheck();
+  assert.equal(queries.getStats().status, 'zoom-in');
+  assert.doesNotMatch(painted.at(-1), /feed unavailable/);
+});
diff --git a/src/layers/transit/state.js b/src/layers/transit/state.js
index 75b13d84b..569298e6e 100644
--- a/src/layers/transit/state.js
+++ b/src/layers/transit/state.js
@@ -112,7 +112,7 @@ export function createState({ services }) {
   state._cockpitVision = false;
   /** @type {Array<[string, EventListener]>} window listeners to remove on destroy. */
   state._styleListeners = [];
-  /** @type {{ refreshLayerStats?: () => void }|null} */
+  /** @type {{ refreshLayerStats?: (layerId?: string) => void }|null} */
   state._dataManager = null;
   /** @type {number|null} */
   state._lastUpdate = null;
diff --git a/src/layers/transit/viewport.js b/src/layers/transit/viewport.js
index 0e3b317d4..a62d49009 100644
--- a/src/layers/transit/viewport.js
+++ b/src/layers/transit/viewport.js
@@ -126,7 +126,7 @@ export function createViewport({ state, services, parts }) {
     governorRequestRender('transit-proximity');
     // The row's text follows the camera (coverage prompt, feed list), so it
     // repaints now instead of at the next 15 s manager tick.
-    if (changed) state._dataManager?.refreshLayerStats?.();
+    if (changed) state._dataManager?.refreshLayerStats?.('transit');
   }
 
   function onCameraChanged() {

From 5c4918affb792bbfe4ac863031b3dcd55734a30c Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Fri, 6 Nov 2026 20:20:11 +0400
Subject: [PATCH 23/71] Tighten coverage prompt comments and docs

---
 .../1576-transit-bikeshare-coverage-prompt.md |  2 +-
 docs/CURRENT-STATE.md                         | 22 +++++++++----------
 src/data/lifecycle.js                         |  5 ++---
 src/layers/bikeshare/controls.js              | 13 +++++------
 src/layers/bikeshare/coverageStatus.test.mjs  |  7 ++----
 src/layers/bikeshare/rowRepaint.test.mjs      |  2 --
 src/layers/bikeshare/viewport.js              |  5 +----
 src/layers/promptRepaint.test.mjs             |  6 ++---
 src/layers/transit/gatePrompt.test.mjs        |  6 ++---
 src/layers/transit/queries.js                 |  5 ++---
 src/layers/transit/viewport.js                |  6 ++---
 src/ui/statusText.js                          |  6 ++---
 12 files changed, 31 insertions(+), 54 deletions(-)

diff --git a/changelog.d/1576-transit-bikeshare-coverage-prompt.md b/changelog.d/1576-transit-bikeshare-coverage-prompt.md
index c3dcbe82a..660c1f30b 100644
--- a/changelog.d/1576-transit-bikeshare-coverage-prompt.md
+++ b/changelog.d/1576-transit-bikeshare-coverage-prompt.md
@@ -1,6 +1,6 @@
 - Say why Transit and Bike Share are empty outside coverage. Over a city with
   no feed or system (London, Tokyo) their Layers rows read
-  `No feed here yet · 16 regions available` and
+  `No feed here yet · 17 regions available` and
   `No bike share here yet · 61 systems available`, or how low to fly, instead
   of `never`; leaving coverage clears the last-update time (German, @gekh,
   #1576).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 69d83d759..13cce0050 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -1975,18 +1975,16 @@ Mapped-installation zoom guidance appears in the layer row without counting as
 a global loading failure. Guidance statuses do not suppress independent refresh
 errors.
 
-Transit and Bike Share report the same kind of guidance when no feed or system
-covers the view, instead of an undated `never`. Above their altitude gates the
-rows read `GTFS-RT · Fly below 2,850 km to a covered region` and
-`GBFS · Fly below 48 km to a covered city`; lower down over a city neither
-covers (London, Tokyo) they read `GTFS-RT · No feed here yet · N regions
-available` and `GBFS · No bike share here yet · N systems available`, N being
-the enabled feeds and the catalogued systems. The
-chip stays ON. A Bike Share city that is loading or failed keeps its own
-loading or error text. Leaving every covered feed or system clears the layer's
-last-update time, so the row never dates data it no longer draws. The same
-English notes are the voice analyst's empty-result notes; both surfaces show
-them translated through `translateStatusMessage` (`src/ui/statusText.js`).
+Transit and Bike Share say the same when no feed or system covers the view,
+instead of an undated `never`. Above their altitude gates the rows read
+`GTFS-RT · Fly below 2,850 km to a covered region` and
+`GBFS · Fly below 48 km to a covered city`; lower, over a city neither covers
+(London, Tokyo), `GTFS-RT · No feed here yet · N regions available` and
+`GBFS · No bike share here yet · N systems available` (covered regions,
+catalogued systems). The chip stays ON. A loading or failed Bike Share city
+shows its own text. Leaving coverage clears the last-update time. The voice
+analyst gets the same English notes; both translate them through
+`translateStatusMessage` (`src/ui/statusText.js`).
 
 ## Places and CCTV request bounds
 
diff --git a/src/data/lifecycle.js b/src/data/lifecycle.js
index c01926451..3ea02eca9 100644
--- a/src/data/lifecycle.js
+++ b/src/data/lifecycle.js
@@ -2393,9 +2393,8 @@ export class LayerLifecycle {
   }
 
   /**
-   * A tick's failure belongs to the feed it polled. Once the layer's own stats
-   * stop reporting one (the camera left that feed), the row stops showing it
-   * instead of waiting for the next tick.
+   * Drop a tick failure the layer's stats no longer report (the camera left
+   * that feed) instead of showing it until the next tick.
    */
   _dropRecoveredRefreshError(layerId) {
     const entry = layerId ? this.layers.get(layerId) : null;
diff --git a/src/layers/bikeshare/controls.js b/src/layers/bikeshare/controls.js
index 03bb544ab..d90a62b5b 100644
--- a/src/layers/bikeshare/controls.js
+++ b/src/layers/bikeshare/controls.js
@@ -15,8 +15,7 @@ export function createControls({ state: layerState, services, parts, source }) {
     updateInterval: STATUS_POLL_MS,
 
     /**
-     * Keep the manager so camera-driven coverage changes can repaint the row
-     * before the next status poll.
+     * Kept so camera moves can repaint the row before the next status poll.
      * @param {object} dataManager DataLayerManager instance.
      */
     attachDataManager(dataManager) {
@@ -84,18 +83,16 @@ export function createControls({ state: layerState, services, parts, source }) {
         lastUpdate: layerState._lastUpdate,
         loading,
       };
-      // No system in range is guidance, not an empty feed: the camera is too
-      // high, or no catalogued system is near the view. A city that failed
-      // leaves range empty too, and reports its failure below instead.
+      // No system in range: the camera is too high or no system is near. A
+      // failed city also leaves range empty and reports its failure below.
       if (
         layerState._enabled &&
         !loading &&
         layerState._activeCityIds.size === 0 &&
         layerState._failedCityIds.size === 0
       ) {
-        // English data (the analyst's empty note to the model, and the Layers
-        // row's prompt); both show it through translateStatusMessage
-        // (ui/statusText.js).
+        // English: the analyst's empty note and the row's prompt, both shown
+        // through translateStatusMessage (ui/statusText.js).
         const note = layerState._altitudeGateEnabled
           ? `No bike share here yet · ${GBFS_CITY_REGISTRY.length} systems available`
           : `Fly below ${Math.round(ACTIVATION_ENTER_ALTITUDE_M / 1000).toLocaleString('en-US')} km to a covered city`;
diff --git a/src/layers/bikeshare/coverageStatus.test.mjs b/src/layers/bikeshare/coverageStatus.test.mjs
index a9f17e73e..004c75c94 100644
--- a/src/layers/bikeshare/coverageStatus.test.mjs
+++ b/src/layers/bikeshare/coverageStatus.test.mjs
@@ -1,10 +1,7 @@
 // BIKESHARE COVERAGE STATUS — a view with no system says so.
 //
-// Over a city with no catalogued system (London, Tokyo) the layer drew nothing
-// and reported nothing, so its row read "ON · — · GBFS · never": the same as a
-// feed that had never answered. These cases pin the rule that replaced it:
-// with no system in range the layer reports a guidance status that says why,
-// and a view it left keeps no date for data it no longer draws.
+// With no system in range (London, Tokyo) the layer says why instead of
+// "never", and keeps no date for data it no longer draws.
 //
 // Run with: npm test
 import { test } from 'node:test';
diff --git a/src/layers/bikeshare/rowRepaint.test.mjs b/src/layers/bikeshare/rowRepaint.test.mjs
index 144ff5502..5f5538168 100644
--- a/src/layers/bikeshare/rowRepaint.test.mjs
+++ b/src/layers/bikeshare/rowRepaint.test.mjs
@@ -1,5 +1,3 @@
-// Bike Share row repaints: entering a city, leaving it or nudging the camera
-// mid-load, and leaving a failed city.
 // Bike Share: after the camera settles, the last row the panel painted must
 // match what the layer reports now. Each case drives the real viewport,
 // ingestion, rendering and controls; the manager is a spy that records the
diff --git a/src/layers/bikeshare/viewport.js b/src/layers/bikeshare/viewport.js
index 008c01333..d4cc44cb6 100644
--- a/src/layers/bikeshare/viewport.js
+++ b/src/layers/bikeshare/viewport.js
@@ -116,10 +116,7 @@ export function createViewport({ state: layerState, services, parts, source }) {
     parts.rendering.removeCityPoints(cityId);
   }
 
-  /**
-   * Repaint the layer's row now. Its text follows the camera (coverage
-   * prompt, station count), and the manager tick is 60 s.
-   */
+  /** Repaint the row now: it follows the camera, the manager tick is 60 s. */
   function refreshRow() {
     layerState._dataManager?.refreshLayerStats?.('bikeshare');
   }
diff --git a/src/layers/promptRepaint.test.mjs b/src/layers/promptRepaint.test.mjs
index 563aaeac7..38193ca72 100644
--- a/src/layers/promptRepaint.test.mjs
+++ b/src/layers/promptRepaint.test.mjs
@@ -1,7 +1,5 @@
-// When the camera changes which coverage prompt a Transit or
-// Bike Share row shows, the layer asks the panel to repaint at once, instead
-// of leaving the old prompt up until the manager's next tick (Transit 15 s,
-// Bike Share 60 s).
+// A camera move that changes a Transit or Bike Share coverage prompt repaints
+// the row at once, not at the next manager tick (15 s, 60 s).
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { createState as createBikeState } from './bikeshare/state.js';
diff --git a/src/layers/transit/gatePrompt.test.mjs b/src/layers/transit/gatePrompt.test.mjs
index 7f439fcdc..dc4c3e863 100644
--- a/src/layers/transit/gatePrompt.test.mjs
+++ b/src/layers/transit/gatePrompt.test.mjs
@@ -1,7 +1,5 @@
-// The Transit coverage prompt names the altitude the closed gate
-// actually opens at. Descending over Boston to 2,900 km (below 3,000 km, above
-// the 2,850 km enter threshold) loads nothing, so a prompt "Fly below 3,000 km"
-// asks for something the camera has already done.
+// The Transit prompt names the altitude the gate opens at: at 2,900 km over
+// Boston (under 3,000 km, above the 2,850 km enter threshold) nothing loads.
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { createState } from './state.js';
diff --git a/src/layers/transit/queries.js b/src/layers/transit/queries.js
index 2efe928d5..7a9f2e074 100644
--- a/src/layers/transit/queries.js
+++ b/src/layers/transit/queries.js
@@ -245,9 +245,8 @@ export function createQueries({ state, parts }) {
       const health = aggregateTransitFeedHealth(statuses, now);
       const count = state._vehicles.size;
       if (state._enabled && active.length === 0) {
-        // English data (the analyst's empty note to the model, and the Layers
-        // row's prompt); both show it through translateStatusMessage
-        // (ui/statusText.js).
+        // English: the analyst's empty note and the row's prompt, both shown
+        // through translateStatusMessage (ui/statusText.js).
         const note = state._altitudeGateOpen
           ? `No feed here yet · ${TRANSIT_REGION_COUNT} regions available`
           : `Fly below ${Math.round(ACTIVATION_ENTER_ALTITUDE_M / 1000).toLocaleString('en-US')} km to a covered region`;
diff --git a/src/layers/transit/viewport.js b/src/layers/transit/viewport.js
index a62d49009..38315e4ae 100644
--- a/src/layers/transit/viewport.js
+++ b/src/layers/transit/viewport.js
@@ -111,8 +111,7 @@ export function createViewport({ state, services, parts }) {
         changed = true;
       }
     }
-    // Leaving coverage leaves nothing on the map to date: a row that read
-    // "26s ago" over an empty view would claim a feed that is no longer here.
+    // Nothing is left on the map to date.
     if (desired.size === 0) state._lastUpdate = null;
     for (const [feedId, feed] of desired) {
       if (!state._activeFeeds.has(feedId)) {
@@ -124,8 +123,7 @@ export function createViewport({ state, services, parts }) {
     parts.ingestion.sweepAgedVehicles(Date.now());
     parts.rendering.syncRenderHold();
     governorRequestRender('transit-proximity');
-    // The row's text follows the camera (coverage prompt, feed list), so it
-    // repaints now instead of at the next 15 s manager tick.
+    // Repaint now: the row follows the camera, the manager tick is 15 s.
     if (changed) state._dataManager?.refreshLayerStats?.('transit');
   }
 
diff --git a/src/ui/statusText.js b/src/ui/statusText.js
index f4cbb59a0..d13faff7e 100644
--- a/src/ui/statusText.js
+++ b/src/ui/statusText.js
@@ -269,10 +269,8 @@ export function translateStatusLine(text) {
 /** Thousands separators out of an English number ("3,000" → 3000). */
 const englishNumber = (text) => Number(text.replace(/,/g, ''));
 
-// Coverage notes of a layer whose view has no feed, whole lines with a number
-// in them: transit (transit/queries.js) and bikeshare (bikeshare/controls.js).
-// Their " · " is part of one sentence, so they are matched before the line is
-// split into pieces. Keep these in step with the producers.
+// Coverage notes (transit/queries.js, bikeshare/controls.js). Their " · " is
+// inside one sentence, so they match whole before the line is split.
 const COVERAGE_NOTE_PATTERNS = [
   [
     /^Fly below ([\d,]+) km to a covered region$/,

From c9f40a837cd08d025d5c1d58d31d3dff5ef37561 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Fri, 6 Nov 2026 20:20:11 +0400
Subject: [PATCH 24/71] Tighten callout fade comments and docs

---
 docs/CURRENT-STATE.md              |  2 +-
 src/data/detection.js              |  9 +++------
 src/data/detectionHost.test.mjs    |  6 ++----
 src/layers/vessels/queries.js      |  3 +--
 src/layers/vessels/records.js      |  3 +--
 src/overlays/worldOverlay.js       | 11 +++++------
 src/overlays/worldOverlay.test.mjs | 14 ++++++--------
 7 files changed, 19 insertions(+), 29 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index c4d66de8a..6d9193078 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5483,7 +5483,7 @@ silently demoting every later lookup for the session.
   Mission world text has no native `LabelGraphics`: overview launch markers publish at most 48 ambient candidates for a 24-winner budget, while selecting a mission clears that overview source and publishes its launch-site callout, stage re-entry annotations, live/estimated payload-position readout, and orbit annotation as protected selected-lane entries. The source retains the exact former strings and colors. Static anchors reuse the Cartesian values used to build their mission geometry; the moving payload entry reads the layer's per-frame live-position cache; catalog-backed orbit annotation positions are cached in the same one-second matrix update that realigns the orbit primitive. Keyhole edge fade, horizon culling, final collision placement, and UI exclusion are owned by the shared host. Deselect restores the bounded overview, and refresh, disable, and destroy replace or clear both mission sources.
   A selected mission renders its orbit as four repeating tactical sectors, each containing one prominent cyan dot followed by one hundred thin translucent dashes. The bright dots act as orbit anchors while the subdued dash field remains depth-tested against the globe and is shown only for the selected mission.
   Close selected-pad views add one static 500 m-radius cyan launch-zone ring with a low-opacity translucent fill over the sampled photoreal launch-site surface. The single scene primitive is created only for the visible selected site and is otherwise dormant. It appears during Focus, sufficiently close manual zoom, and the replay countdown, but is suppressed above 120 km camera altitude, beyond 180 km direct camera-to-pad range, for unselected missions, and whenever Space Missions is inactive. Focus establishes a launch-site-centered camera transform once; subsequent manual heading and pitch changes remain centered on that site without an automated per-frame correction. Surface mission markers and labels use an additional conservative globe-limb margin before the exact ellipsoid occluder boundary, preventing near-horizon visibility from alternating between frames.
-- **AIS vessels**: chevron symbology (naval cyan base, type tints), world-space headings, MMSI-keyed reconciliation (selection survives refreshes; pinned 3 refreshes with STALE marker when absent), detection-overlay integration (`type: 'SEA'`; a vessel's detection callout fades out while its own ambient card paints in the same frame, judged by the card's painted opacity including the keyhole fade, so a card dropped by budget, collisions or UI chrome, or faded out at the keyhole rim, leaves the callout readable), contextStore registration for voice Q&A. Empty-space clicks, id-less photorealistic-tile picks, and Escape dismiss the vessel card/HUD/context and clear its trail; picks owned by another layer (including `gev-trail:*`) and raw vessel-record picks without a live MMSI key are no-ops for vessel selection. Click and key handlers detach while the layer is disabled and reinstall on enable. Selecting another vessel replaces the selection and trail, and reconciliation clears a trail if its owning vessel is evicted.
+- **AIS vessels**: chevron symbology (naval cyan base, type tints), world-space headings, MMSI-keyed reconciliation (selection survives refreshes; pinned 3 refreshes with STALE marker when absent), detection-overlay integration (`type: 'SEA'`; a vessel's callout fades by the painted opacity of its own ambient card, so a card dropped by budget, collisions or UI chrome, or faded at the keyhole rim, leaves the callout readable), contextStore registration for voice Q&A. Empty-space clicks, id-less photorealistic-tile picks, and Escape dismiss the vessel card/HUD/context and clear its trail; picks owned by another layer (including `gev-trail:*`) and raw vessel-record picks without a live MMSI key are no-ops for vessel selection. Click and key handlers detach while the layer is disabled and reinstall on enable. Selecting another vessel replaces the selection and trail, and reconciliation clears a trail if its owning vessel is evicted.
 - **Track trails**: server accumulates per-MMSI ring buffers (`/api/vessels/track?mmsi=`, Float32+Uint32, 64 samples, 30s/25m thinning); aircraft backfill proxies `/api/flights/track` (OAuth, own credit bucket). Military aircraft keep only their locally accumulated trails: `/api/military/track` validates the hex, then answers `503 history_unavailable` without an upstream request.
 - Shared `src/data/pickRegistry.js` stops the two flight layers' click handlers from fighting over the camera.
 
diff --git a/src/data/detection.js b/src/data/detection.js
index f4d1ddf3b..b4dc29522 100644
--- a/src/data/detection.js
+++ b/src/data/detection.js
@@ -110,10 +110,7 @@ const THEME_MAP = DETECTION_THEME_MAP;
 const SPARSE_ZONE_FRACTION = 0.5;
 /** Solve cadence for membership/collision; accepted identities still reproject every frame. */
 const LABEL_SOLVE_INTERVAL_MS = 125;
-/**
- * A contact's own card at this opacity or more hides its callout; below it the
- * callout fades in, so a card fading in or out never snaps the callout.
- */
+/** Own-card opacity that fully hides a callout; below it the callout fades in. */
 const CARD_ALPHA_HIDING_CALLOUT = 0.5;
 /** Alpha bands retain bracket batching while approximating a continuous radial fade. */
 const BRACKET_ALPHA_STEPS = 4;
@@ -1149,8 +1146,8 @@ function _paintCalloutLane(frame) {
   ctx.textBaseline = 'alphabetic';
   for (let i = 0; i < _calloutCount; i++) {
     const row = _calloutPool[i];
-    // Under the contact's own card (an ambient vessel card) the callout would
-    // show through the plate. Only a card painting this frame counts.
+    // The callout would show through its contact's own card: fade it by the
+    // opacity that card paints with this frame.
     const cardAlpha =
       row.cardEntryId === ''
         ? 0
diff --git a/src/data/detectionHost.test.mjs b/src/data/detectionHost.test.mjs
index 4c1c6dddc..f479869f9 100644
--- a/src/data/detectionHost.test.mjs
+++ b/src/data/detectionHost.test.mjs
@@ -589,10 +589,8 @@ test('every style paints its OWN plate token through the production callout path
 });
 
 test('a callout gives way to its contact\'s own card only while that card paints', () => {
-  // A vessel's ambient card already shows its name, speed and course, and the
-  // callout drawn beneath it shows through the card's plate. The host paints
-  // only part of the published cards (shared budget, collisions, UI chrome),
-  // so a contact whose card was published but not painted keeps its callout.
+  // The callout shows through its card's plate. The host paints only some
+  // published cards (budget, collisions, UI chrome); an unpainted one keeps it.
   const env = installEnvironment({ width: 900, height: 600, dpr: 1 });
   try {
     const ships = [
diff --git a/src/layers/vessels/queries.js b/src/layers/vessels/queries.js
index f26ada86b..0be276913 100644
--- a/src/layers/vessels/queries.js
+++ b/src/layers/vessels/queries.js
@@ -505,8 +505,7 @@ export function createQueries({
           id: record.name || record.mmsi || 'VESSEL',
           type: 'SEA',
           skipLabel: record === selected,
-          // The vessel's ambient card: while the overlay paints it, detection
-          // draws no callout under it.
+          // Detection hides the callout while this card paints.
           cardSourceId: VESSEL_OVERLAY_SOURCE_ID,
           cardEntryId: components.cards.vesselOverlayEntryId(record),
           klass: record.type
diff --git a/src/layers/vessels/records.js b/src/layers/vessels/records.js
index aeb2f39bf..f6f581784 100644
--- a/src/layers/vessels/records.js
+++ b/src/layers/vessels/records.js
@@ -23,8 +23,7 @@ export function normalizeVessel(row) {
     lastPositionUtc: String(row.last_position_UTC || ''),
     lastPositionEpoch: finiteNumber(row.last_position_epoch),
     missedRefreshes: 0,
-    // Filled on first use by the cards' `vesselOverlayEntryId`. The id reads
-    // only the MMSI, or for an unkeyed row fields it never updates.
+    // Cached by `vesselOverlayEntryId`; the fields it reads never change.
     overlayEntryId: null,
   };
 }
diff --git a/src/overlays/worldOverlay.js b/src/overlays/worldOverlay.js
index c569e03b8..71f4b849f 100644
--- a/src/overlays/worldOverlay.js
+++ b/src/overlays/worldOverlay.js
@@ -1047,9 +1047,9 @@ export function getOverlayPaintRect(sourceId, entryId) {
 }
 
 /**
- * Opacity an entry will paint with in the frame being painted, or 0 when it is
- * not queued. Valid from the custom lanes, which paint before the entries in
- * later lanes publish their paint rects. Leaves out only the Cyber sonar fade.
+ * Opacity an entry paints with this frame, or 0 when it is not queued. Custom
+ * lanes may call it before later lanes publish paint rects. Leaves out the
+ * Cyber sonar fade and yield-collision hiding.
  * @param {string} sourceId
  * @param {string} entryId
  * @returns {number}
@@ -2253,9 +2253,8 @@ function addPaintItem(record, placement, temporalAlpha, selected) {
   item.collisionHidden = false;
   item.stamp = _frameStamp;
   _paintQueue[_paintCount++] = item;
-  // Indexed by source and id rather than by `record.key`, so a lookup builds
-  // no string. A card fading out after it left its source's entries is still
-  // queued here, though `_records` no longer has it.
+  // Keyed by source and id, not `record.key`, so a lookup builds no string.
+  // Also holds cards fading out after they left `_records`.
   let bySource = _queuedItemBySource.get(record.entry.source);
   if (!bySource) {
     bySource = new Map();
diff --git a/src/overlays/worldOverlay.test.mjs b/src/overlays/worldOverlay.test.mjs
index dfc82cebd..1b8223bbc 100644
--- a/src/overlays/worldOverlay.test.mjs
+++ b/src/overlays/worldOverlay.test.mjs
@@ -1224,9 +1224,8 @@ test('custom detection lane receives the shared host frame and paints below ordi
 });
 
 test('a detection lane sees which cards this frame will paint before they publish paint rects', () => {
-  // The detection lane paints first, so a card's paint rectangle for this
-  // frame does not exist yet when it runs. The queued alpha is what lets a
-  // contact's callout give way to that contact's own card in the same frame.
+  // The detection lane paints before the cards publish this frame's paint
+  // rects, so it reads the queued alpha instead.
   const env = installMockEnvironment({ width: 400, height: 300, dpr: 1 });
   initWorldOverlay(env.viewer);
   const seen = [];
@@ -2529,8 +2528,8 @@ test('promoting an ambient entry to selected paints it once with no fading dupli
 });
 
 test('the queued-card index stays bounded while card identities churn', () => {
-  // The index is internal: capture the per-source map the same way the
-  // projection-record test captures its map, through Map.prototype.set.
+  // The index is internal: capture it through Map.prototype.set, like the
+  // projection-record test.
   const originalSet = Map.prototype.set;
   let queuedIndex = null;
   Map.prototype.set = function captureQueuedIndex(key, value) {
@@ -2546,9 +2545,8 @@ test('the queued-card index stays bounded while card identities churn', () => {
     initWorldOverlay(env.viewer);
     const FRAMES = 1300;
     for (let frame = 0; frame < FRAMES; frame++) {
-      // One painted card whose identity changes every frame: the same pooled
-      // paint item serves every id (a vessel cohort republished as the camera
-      // moves, a CCTV or radio card swapping).
+      // One card whose id changes every frame reuses one pooled paint item,
+      // like a vessel cohort republished as the camera moves.
       setOverlayEntries('cards', [selectedEntry(`churn-card-${frame}`, {
         position: positionAtScreen(200, 150),
       })]);

From ea76fc4bc07327b9d8297aa6b2663660ca0d5947 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Fri, 6 Nov 2026 22:01:39 +0400
Subject: [PATCH 25/71] Fold duplicate coverage tests into their neighbours

---
 .../1576-transit-bikeshare-coverage-prompt.md |   8 +-
 src/data/manager.js                           |  12 --
 src/layers/bikeshare/coverageStatus.test.mjs  | 121 ------------------
 src/layers/bikeshare/rowRepaint.test.mjs      |  79 +++++++++++-
 src/layers/bikeshare/viewport.js              |   4 +-
 src/layers/promptRepaint.test.mjs             | 120 -----------------
 src/layers/transit/gatePrompt.test.mjs        |  64 ---------
 src/layers/transit/lifecycle.test.mjs         |  12 ++
 .../transit/refreshErrorRepaint.test.mjs      |   2 +
 9 files changed, 94 insertions(+), 328 deletions(-)
 delete mode 100644 src/layers/bikeshare/coverageStatus.test.mjs
 delete mode 100644 src/layers/promptRepaint.test.mjs
 delete mode 100644 src/layers/transit/gatePrompt.test.mjs

diff --git a/changelog.d/1576-transit-bikeshare-coverage-prompt.md b/changelog.d/1576-transit-bikeshare-coverage-prompt.md
index 660c1f30b..4d13d8d3e 100644
--- a/changelog.d/1576-transit-bikeshare-coverage-prompt.md
+++ b/changelog.d/1576-transit-bikeshare-coverage-prompt.md
@@ -1,6 +1,4 @@
 - Say why Transit and Bike Share are empty outside coverage. Over a city with
-  no feed or system (London, Tokyo) their Layers rows read
-  `No feed here yet · 17 regions available` and
-  `No bike share here yet · 61 systems available`, or how low to fly, instead
-  of `never`; leaving coverage clears the last-update time (German, @gekh,
-  #1576).
+  no feed or system (London, Tokyo) their Layers rows say so and count the
+  covered regions or systems, or say how low to fly, instead of `never`;
+  leaving coverage clears the last-update time (German, @gekh, #1576).
diff --git a/src/data/manager.js b/src/data/manager.js
index 688fb94d2..5de10f665 100644
--- a/src/data/manager.js
+++ b/src/data/manager.js
@@ -15,18 +15,6 @@ export class DataLayerManager extends LayerLifecycle {
     this._presentation.refresh();
   }
 
-  /**
-   * Repaint the toggle panel now. For layers whose data arrives outside their
-   * manager tick (camera-driven loads such as Transit's proximity polls), so a
-   * row shows its count when the data lands instead of at the next interval.
-   * One DOM pass; skipped while the document is hidden.
-   * @param {string} [layerId] - The layer whose row changed.
-   */
-  refreshLayerStats(layerId) {
-    this._dropRecoveredRefreshError(layerId);
-    this._refreshTogglePanel();
-  }
-
   _buildMetaText(layer) {
     return this._presentation.panel._buildMetaText(layer);
   }
diff --git a/src/layers/bikeshare/coverageStatus.test.mjs b/src/layers/bikeshare/coverageStatus.test.mjs
deleted file mode 100644
index 004c75c94..000000000
--- a/src/layers/bikeshare/coverageStatus.test.mjs
+++ /dev/null
@@ -1,121 +0,0 @@
-// BIKESHARE COVERAGE STATUS — a view with no system says so.
-//
-// With no system in range (London, Tokyo) the layer says why instead of
-// "never", and keeps no date for data it no longer draws.
-//
-// Run with: npm test
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { createState } from './state.js';
-import { createControls } from './controls.js';
-import { createModel } from './model.js';
-import { createViewport } from './viewport.js';
-import { GBFS_CITY_REGISTRY } from './registry.js';
-
-const LONDON = { lat: 51.5072, lon: -0.1276 };
-
-function makeLayer() {
-  const services = {
-    overlays: {
-      setOverlayEntries() {},
-      setOverlaySourceVisible() {},
-      clearOverlaySource() {},
-    },
-    render: { governorRequestRender() {} },
-  };
-  const state = createState({ services });
-  const parts = {
-    queries: { collectDetectableStations: () => [] },
-    model: createModel({ state, services, parts: {}, source: null }),
-    ingestion: { abortInFlight() {} },
-    rendering: { removeCityPoints() {} },
-  };
-  parts.viewport = createViewport({ state, services, parts, source: null });
-  const { methods } = createControls({ state, services, parts, source: {} });
-  state._enabled = true;
-  return { state, methods, viewport: parts.viewport };
-}
-
-/** A viewer looking straight down at `at` from `height` metres. */
-function viewerAt(at, height) {
-  const rad = Math.PI / 180;
-  return {
-    camera: {
-      positionCartographic: {
-        height,
-        latitude: at.lat * rad,
-        longitude: at.lon * rad,
-      },
-      computeViewRectangle: () => undefined,
-    },
-    scene: { globe: {} },
-  };
-}
-
-test('above the altitude gate the row says how low to fly', async () => {
-  const { state, methods, viewport } = makeLayer();
-  state._viewer = viewerAt(LONDON, 2_000_000);
-  await viewport.runProximityCheck();
-
-  const stats = methods.getStats();
-  assert.equal(stats.status, 'zoom-in');
-  assert.equal(stats.statusMessage, 'Fly below 48 km to a covered city');
-  assert.equal(stats.error, undefined);
-});
-
-test('a city with no system says so and counts the ones there are', async () => {
-  const { state, methods, viewport } = makeLayer();
-  state._viewer = viewerAt(LONDON, 8_000);
-  await viewport.runProximityCheck();
-
-  const stats = methods.getStats();
-  assert.equal(stats.status, 'zoom-in');
-  assert.equal(
-    stats.statusMessage,
-    `No bike share here yet · ${GBFS_CITY_REGISTRY.length} systems available`,
-  );
-  assert.equal(stats.count, 0);
-});
-
-test('a city with a system in range is not given the prompt', () => {
-  const { state, methods } = makeLayer();
-  state._altitudeGateEnabled = true;
-  state._activeCityIds.add('boston-bluebikes');
-
-  assert.equal(methods.getStats().status, undefined);
-});
-
-test('a loading or failed city reports itself, not the prompt', () => {
-  const { state, methods } = makeLayer();
-  state._altitudeGateEnabled = true;
-  state._loading = true;
-  assert.equal(methods.getStats().status, undefined);
-
-  // A city that failed is dropped from range, and still owns the row.
-  state._loading = false;
-  state._failedCityIds.add('boston-bluebikes');
-  const stats = methods.getStats();
-  assert.equal(stats.status, undefined);
-  assert.equal(stats.error, 'GBFS fetch error');
-});
-
-test('a disabled layer reports no prompt', () => {
-  const { state, methods } = makeLayer();
-  state._enabled = false;
-  assert.equal(methods.getStats().status, undefined);
-});
-
-test('leaving every system behind drops the date of the data it drew', async () => {
-  for (const height of [8_000, 2_000_000]) {
-    const { state, methods, viewport } = makeLayer();
-    state._lastUpdate = Date.now();
-    // Boston's stations were drawn and dated; the camera moves to London.
-    state._activeCityIds.add('boston-bluebikes');
-    state._cityRuntime.set('boston-bluebikes', {});
-    state._viewer = viewerAt(LONDON, height);
-    await viewport.runProximityCheck();
-
-    assert.equal(state._activeCityIds.size, 0);
-    assert.equal(methods.getStats().lastUpdate, null, `at ${height} m`);
-  }
-});
diff --git a/src/layers/bikeshare/rowRepaint.test.mjs b/src/layers/bikeshare/rowRepaint.test.mjs
index 5f5538168..4bfea999c 100644
--- a/src/layers/bikeshare/rowRepaint.test.mjs
+++ b/src/layers/bikeshare/rowRepaint.test.mjs
@@ -1,11 +1,13 @@
-// Bike Share: after the camera settles, the last row the panel painted must
-// match what the layer reports now. Each case drives the real viewport,
+// Bike Share's Layers row. With no system in range it says why instead of
+// "never" and keeps no date for data it no longer draws. After the camera
+// settles, the last row the panel painted must match what the layer reports
+// now. Each case drives the real viewport,
 // ingestion, rendering and controls; the manager is a spy that records the
 // row text (LayerPanel._buildMetaText) at every refreshLayerStats() call.
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import * as Cesium from 'cesium';
-import { CITY_BY_ID } from './registry.js';
+import { CITY_BY_ID, GBFS_CITY_REGISTRY } from './registry.js';
 import { createState } from './state.js';
 import { createControls } from './controls.js';
 import { createIngestion } from './ingestion.js';
@@ -175,6 +177,7 @@ function makeLiveLayer() {
     source,
     painted,
     lastPainted: () => painted.at(-1),
+    stats: () => controls.getStats(),
     live: () => rowText(controls.getStats()),
     moveTo(place, height = LOW_M) {
       Object.assign(camera, place, { height });
@@ -291,3 +294,73 @@ test('leaving the failed city of two repaints DEGRADED away', async () => {
   assert.doesNotMatch(layer.live(), /^degraded/);
   assert.equal(layer.lastPainted(), layer.live());
 });
+
+test('above the altitude gate the row says how low to fly', async () => {
+  const layer = makeLiveLayer();
+  await layer.enable();
+  await layer.moveTo(LONDON, 2_000_000);
+  const stats = layer.stats();
+  assert.equal(stats.status, 'zoom-in');
+  assert.equal(stats.statusMessage, 'Fly below 48 km to a covered city');
+  assert.equal(stats.error, undefined);
+});
+
+test('a city with no system says so and counts the ones there are', async () => {
+  const layer = makeLiveLayer();
+  await layer.enable();
+  const stats = layer.stats();
+  assert.equal(stats.status, 'zoom-in');
+  assert.equal(
+    stats.statusMessage,
+    `No bike share here yet · ${GBFS_CITY_REGISTRY.length} systems available`,
+  );
+  assert.equal(stats.count, 0);
+});
+
+test('a city in range, loading, failed or a disabled layer gets no prompt', async () => {
+  const layer = makeLiveLayer();
+  assert.equal(layer.stats().status, undefined, 'disabled');
+
+  const info = deferred();
+  layer.source.gates.set(`${BOSTON_ID}:info`, info);
+  await layer.enable();
+  const entering = layer.moveTo(BOSTON);
+  assert.equal(layer.stats().status, undefined, 'loading');
+  info.resolve();
+  await entering;
+  await settle();
+  assert.equal(layer.stats().status, undefined, 'loaded');
+
+  // Left mid-load: range is empty, but the aborted load still owns the row.
+  const leaving = makeLiveLayer();
+  leaving.source.gates.set(`${BOSTON_ID}:info`, deferred());
+  await leaving.enable();
+  const loading = leaving.moveTo(BOSTON);
+  await settle();
+  const left = leaving.moveTo(LONDON);
+  assert.equal(leaving.state._activeCityIds.size, 0);
+  assert.equal(leaving.stats().loading, true);
+  assert.equal(leaving.stats().status, undefined, 'leaving mid-load');
+  await Promise.all([loading, left]);
+
+  const failed = makeLiveLayer();
+  failed.source.dead.add(BOSTON_ID);
+  await failed.enable();
+  await failed.moveTo(BOSTON);
+  await settle();
+  assert.equal(failed.stats().status, undefined, 'failed');
+  assert.equal(failed.stats().error, 'GBFS fetch error');
+});
+
+test('leaving every system behind drops the date of the data it drew', async () => {
+  for (const height of [LOW_M, 2_000_000]) {
+    const layer = makeLiveLayer();
+    await layer.enable();
+    await layer.moveTo(BOSTON);
+    await settle();
+    assert.ok(layer.stats().lastUpdate, 'Boston is dated');
+
+    await layer.moveTo(LONDON, height);
+    assert.equal(layer.stats().lastUpdate, null, `at ${height} m`);
+  }
+});
diff --git a/src/layers/bikeshare/viewport.js b/src/layers/bikeshare/viewport.js
index d4cc44cb6..46b6b7d12 100644
--- a/src/layers/bikeshare/viewport.js
+++ b/src/layers/bikeshare/viewport.js
@@ -243,11 +243,9 @@ export function createViewport({ state: layerState, services, parts, source }) {
       nextActive.size !== layerState._activeCityIds.size ||
       [...nextActive].some((cityId) => !layerState._activeCityIds.has(cityId));
     layerState._activeCityIds = nextActive;
-    if (layerState._activeCityIds.size === 0) {
+    if (nextActive.size === 0) {
       layerState._count = 0;
       layerState._lastUpdate = null;
-      if (changed) refreshRow();
-      return;
     }
     if (changed) refreshRow();
 
diff --git a/src/layers/promptRepaint.test.mjs b/src/layers/promptRepaint.test.mjs
deleted file mode 100644
index 38193ca72..000000000
--- a/src/layers/promptRepaint.test.mjs
+++ /dev/null
@@ -1,120 +0,0 @@
-// A camera move that changes a Transit or Bike Share coverage prompt repaints
-// the row at once, not at the next manager tick (15 s, 60 s).
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { createState as createBikeState } from './bikeshare/state.js';
-import { createControls as createBikeControls } from './bikeshare/controls.js';
-import { createModel as createBikeModel } from './bikeshare/model.js';
-import { createViewport as createBikeViewport } from './bikeshare/viewport.js';
-import { createState as createTransitState } from './transit/state.js';
-import { createViewport as createTransitViewport } from './transit/viewport.js';
-import { createQueries as createTransitQueries } from './transit/queries.js';
-
-const rad = Math.PI / 180;
-const LONDON = { lat: 51.5072, lon: -0.1276 };
-const BOSTON = { lat: 42.3601, lon: -71.0589 };
-
-const services = () => ({
-  overlays: {
-    setOverlayEntries() {},
-    setOverlaySourceVisible() {},
-    clearOverlaySource() {},
-  },
-  render: { governorRequestRender() {} },
-});
-
-function viewer(at, height) {
-  return {
-    camera: {
-      positionCartographic: {
-        height,
-        latitude: at.lat * rad,
-        longitude: at.lon * rad,
-      },
-      computeViewRectangle: () => undefined,
-    },
-    scene: { globe: {} },
-  };
-}
-
-function spyManager() {
-  const dm = { repaints: 0 };
-  dm.refreshLayerStats = () => {
-    dm.repaints++;
-  };
-  return dm;
-}
-
-test('Bike Share: flying from London into Boston repaints the prompt row', async () => {
-  const svc = services();
-  const state = createBikeState({ services: svc });
-  const parts = {
-    queries: { collectDetectableStations: () => [] },
-    model: createBikeModel({ state, services: svc, parts: {}, source: null }),
-    ingestion: {
-      abortInFlight() {},
-      loadCityStationInfo: async () => new Map(),
-      loadCityStationStatus: async () => new Map(),
-    },
-    rendering: {
-      removeCityPoints() {},
-      ensureCityPoints() {},
-      applyStatusToPoints() {},
-    },
-  };
-  parts.viewport = createBikeViewport({
-    state,
-    services: svc,
-    parts,
-    source: null,
-  });
-  const { methods } = createBikeControls({
-    state,
-    services: svc,
-    parts,
-    source: {},
-  });
-  state._enabled = true;
-  const dm = spyManager();
-  methods.attachDataManager(dm);
-
-  state._viewer = viewer(LONDON, 8_000);
-  await parts.viewport.runProximityCheck();
-  assert.equal(methods.getStats().status, 'zoom-in');
-
-  const before = dm.repaints;
-  state._viewer = viewer(BOSTON, 3_000);
-  await parts.viewport.runProximityCheck();
-  assert.equal(methods.getStats().status, undefined, 'Boston is covered');
-  assert.ok(dm.repaints > before, 'the row was asked to repaint');
-});
-
-test('Transit: leaving Boston for London repaints the row', () => {
-  const svc = services();
-  const state = createTransitState({ services: svc });
-  const parts = {
-    ingestion: {
-      feedStatus: () => ({ count: 0 }),
-      pollFeed() {},
-      removeFeedVehicles() {},
-      sweepAgedVehicles() {},
-    },
-    rendering: { requestVisibility() {}, syncRenderHold() {} },
-  };
-  parts.viewport = createTransitViewport({ state, services: svc, parts });
-  const queries = createTransitQueries({ state, parts }).methods;
-  state._enabled = true;
-  const dm = spyManager();
-  state._dataManager = dm;
-
-  state._viewer = viewer(BOSTON, 4_000);
-  parts.viewport.runProximityCheck();
-  assert.ok(state._activeFeeds.size > 0, 'Boston has a feed');
-  state._lastUpdate = Date.now();
-
-  const before = dm.repaints;
-  state._viewer = viewer(LONDON, 4_000);
-  parts.viewport.runProximityCheck();
-  assert.equal(queries.getStats().status, 'zoom-in');
-  assert.ok(dm.repaints > before, 'the row was asked to repaint');
-});
diff --git a/src/layers/transit/gatePrompt.test.mjs b/src/layers/transit/gatePrompt.test.mjs
deleted file mode 100644
index dc4c3e863..000000000
--- a/src/layers/transit/gatePrompt.test.mjs
+++ /dev/null
@@ -1,64 +0,0 @@
-// The Transit prompt names the altitude the gate opens at: at 2,900 km over
-// Boston (under 3,000 km, above the 2,850 km enter threshold) nothing loads.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { createState } from './state.js';
-import { createViewport } from './viewport.js';
-import { createQueries } from './queries.js';
-import { ACTIVATION_ENTER_ALTITUDE_M } from './policy.js';
-
-const BOSTON = { lat: 42.3601, lon: -71.0589 };
-
-function makeLayer() {
-  const services = {
-    overlays: {
-      setOverlayEntries() {},
-      setOverlaySourceVisible() {},
-      clearOverlaySource() {},
-    },
-    render: { governorRequestRender() {} },
-  };
-  const state = createState({ services });
-  const polled = [];
-  const parts = {
-    ingestion: {
-      feedStatus: () => ({ count: 0 }),
-      pollFeed: (feed) => polled.push(feed.id),
-      removeFeedVehicles() {},
-      sweepAgedVehicles() {},
-    },
-    rendering: { requestVisibility() {}, syncRenderHold() {} },
-  };
-  parts.viewport = createViewport({ state, services, parts });
-  const queries = createQueries({ state, parts }).methods;
-  state._enabled = true;
-  const rad = Math.PI / 180;
-  state._viewer = {
-    camera: {
-      positionCartographic: {
-        height: 0,
-        latitude: BOSTON.lat * rad,
-        longitude: BOSTON.lon * rad,
-      },
-      computeViewRectangle: () => undefined,
-    },
-    scene: { globe: {} },
-  };
-  return { state, queries, viewport: parts.viewport, polled };
-}
-
-test('below the prompted altitude but above the gate, the prompt names the gate', () => {
-  const { state, queries, viewport, polled } = makeLayer();
-  state._viewer.camera.positionCartographic.height = 2_900_000;
-  viewport.runProximityCheck();
-
-  // Nothing loads at 2,900 km: the gate opens at the enter threshold.
-  assert.equal(state._altitudeGateOpen, false);
-  assert.deepEqual(polled, []);
-
-  const km = Math.round(ACTIVATION_ENTER_ALTITUDE_M / 1000).toLocaleString(
-    'en-US',
-  );
-  const { statusMessage } = queries.getStats();
-  assert.equal(statusMessage, `Fly below ${km} km to a covered region`);
-});
diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs
index dc18fd6f0..4711eebdf 100644
--- a/src/layers/transit/lifecycle.test.mjs
+++ b/src/layers/transit/lifecycle.test.mjs
@@ -4021,3 +4021,15 @@ test('a view with no feed reads its coverage prompt, not an undated feed', async
     'Fly below 2,850 km to a covered region',
   );
 });
+
+test('the prompt names the altitude the gate opens at, not 3,000 km', async (t) => {
+  // 2,900 km is under ACTIVATION_ALTITUDE_M but above the enter threshold.
+  const app = harness(t, { altitude: 2_900_000 });
+  app.layer.enable(app.viewer);
+  await app.layer.update();
+  assert.deepEqual(app.requested, [], 'nothing loads over Boston');
+  assert.equal(
+    app.layer.getStats().statusMessage,
+    'Fly below 2,850 km to a covered region',
+  );
+});
diff --git a/src/layers/transit/refreshErrorRepaint.test.mjs b/src/layers/transit/refreshErrorRepaint.test.mjs
index d1a5c16b8..d85a4a375 100644
--- a/src/layers/transit/refreshErrorRepaint.test.mjs
+++ b/src/layers/transit/refreshErrorRepaint.test.mjs
@@ -91,8 +91,10 @@ test('leaving a feed whose tick failed repaints its error away', async () => {
   await lifecycle.refreshLayer('transit');
   assert.match(row(), /feed unavailable/, 'the tick recorded the failure');
 
+  const before = painted.length;
   state._viewer = viewer(LONDON, 4_000);
   parts.viewport.runProximityCheck();
   assert.equal(queries.getStats().status, 'zoom-in');
+  assert.ok(painted.length > before, 'leaving Boston repainted the row');
   assert.doesNotMatch(painted.at(-1), /feed unavailable/);
 });

From 4c62435910a191403dc7368ed9d31b5cbafd759e Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Fri, 6 Nov 2026 22:01:39 +0400
Subject: [PATCH 26/71] Drop the duplicate callout test and the card id cache

---
 src/data/aisLiveVessels.test.mjs |  1 -
 src/data/detection.js            |  1 -
 src/data/detectionHost.test.mjs  | 65 +++-----------------------------
 src/layers/vessels/cards.js      |  8 ----
 src/layers/vessels/records.js    |  2 -
 5 files changed, 5 insertions(+), 72 deletions(-)

diff --git a/src/data/aisLiveVessels.test.mjs b/src/data/aisLiveVessels.test.mjs
index e1c2fcc5a..edb3505f2 100644
--- a/src/data/aisLiveVessels.test.mjs
+++ b/src/data/aisLiveVessels.test.mjs
@@ -1821,7 +1821,6 @@ test('detection objects name the vessel card their callout gives way to', () =>
       'vessel:unkeyed:NO MMSI:37.80000:-122.40000',
       'the same identity the vessel card is published under',
     );
-    assert.equal(keyed.overlayEntryId, 'vessel:200', 'cached on the record for later frames');
   } finally {
     _setVesselStateForTest({ enabled: false });
   }
diff --git a/src/data/detection.js b/src/data/detection.js
index b4dc29522..0ec9e9ba2 100644
--- a/src/data/detection.js
+++ b/src/data/detection.js
@@ -1114,7 +1114,6 @@ function _stashCallout(entry, acquireFade, keyhole) {
   row.alpha = alpha;
   row.cardSourceId = candidate.cardSourceId;
   row.cardEntryId = candidate.cardEntryId;
-  row.paintAlpha = alpha;
   _calloutCount++;
 }
 
diff --git a/src/data/detectionHost.test.mjs b/src/data/detectionHost.test.mjs
index f479869f9..db01ed18a 100644
--- a/src/data/detectionHost.test.mjs
+++ b/src/data/detectionHost.test.mjs
@@ -19,12 +19,10 @@ import {
   suspendDetection,
 } from './detection.js';
 import {
-  clearOverlaySource,
   destroyWorldOverlay,
   getOverlayPaintRect,
   initWorldOverlay,
   setOverlayEntries,
-  setOverlaySourceVisible,
 } from '../overlays/worldOverlay.js';
 import { applyVesselOverlayPolicy } from './vesselLabels.js';
 import {
@@ -588,64 +586,6 @@ test('every style paints its OWN plate token through the production callout path
   }
 });
 
-test('a callout gives way to its contact\'s own card only while that card paints', () => {
-  // The callout shows through its card's plate. The host paints only some
-  // published cards (budget, collisions, UI chrome); an unpainted one keeps it.
-  const env = installEnvironment({ width: 900, height: 600, dpr: 1 });
-  try {
-    const ships = [
-      { x: -0.3, sourceId: 'carded', id: 'SHIP-CARDED', card: 'vessel:carded' },
-      { x: 0.3, sourceId: 'dropped', id: 'SHIP-DROPPED', card: 'vessel:dropped' },
-    ].map(({ x, sourceId, id, card }) => ({
-      position: new Cesium.Cartesian3(x, 0, 6_356_752),
-      sourceId,
-      id,
-      metric: '6 kn',
-      type: 'SEA',
-      cardSourceId: card === 'vessel:carded' ? 'vessel-cards' : 'dropped-cards',
-      cardEntryId: card,
-    }));
-    initWorldOverlay(env.viewer);
-    initDetection(env.viewer, [{ id: 'ais-live-vessels', getDetectableObjects: () => ships }], () => {});
-    const card = (id, title, x) => ({
-      id,
-      position: new Cesium.Cartesian3(x, 0, 6_356_752),
-      variant: 'label',
-      title,
-      selected: true,
-      protected: true,
-      horizonCull: false,
-      edgeFade: 'none',
-    });
-    setOverlayEntries('vessel-cards', [card('vessel:carded', 'CARD-CARDED', -0.3)]);
-    // Published, but the host does not paint it this frame.
-    setOverlayEntries('dropped-cards', [card('vessel:dropped', 'CARD-DROPPED', 0.3)]);
-    setOverlaySourceVisible('dropped-cards', false);
-    setMode('DENSE');
-    settleFrame(env);
-    env.ctx.calls.length = 0;
-    settleFrame(env);
-
-    const painted = (text) => env.ctx.calls.some(([name, value]) => name === 'fillText' && value === text);
-    assert.ok(painted('CARD-CARDED'), 'the fixture card reached the frame');
-    assert.ok(!painted('CARD-DROPPED'), 'the hidden source paints no card');
-    assert.ok(!painted('SHIP-CARDED'), 'no callout under the painted card');
-    assert.ok(painted('SHIP-DROPPED'), 'the contact whose card did not paint keeps its callout');
-    assert.equal(getDetectionDiagnostics().calloutRects.length, 1,
-      'only the callout that painted is reported');
-
-    // The card leaves the host: the callout comes back on the next frame.
-    clearOverlaySource('vessel-cards');
-    env.ctx.calls.length = 0;
-    settleFrame(env);
-    assert.ok(painted('SHIP-CARDED'), 'the callout returns once its card stops painting');
-  } finally {
-    destroyDetection();
-    destroyWorldOverlay();
-    env.cleanup();
-  }
-});
-
 /** A vessel detection contact that names its ambient card, like the AIS layer does. */
 function shipWithCard(mmsi, position) {
   return {
@@ -776,6 +716,11 @@ test('a vessel whose ambient card loses the collision keeps its callout', () =>
         carded ? `${ship.id} draws no callout under its card` : `${ship.id} keeps its callout`,
       );
     }
+    assert.equal(
+      getDetectionDiagnostics().calloutRects.length,
+      ships.length - winners.length,
+      'only the callouts that painted are reported',
+    );
   } finally {
     destroyDetection();
     destroyWorldOverlay();
diff --git a/src/layers/vessels/cards.js b/src/layers/vessels/cards.js
index 2563bf420..bcf3459f1 100644
--- a/src/layers/vessels/cards.js
+++ b/src/layers/vessels/cards.js
@@ -117,14 +117,6 @@ export function createCards({
   /** Stable overlay identity for MMSI-keyed and source-retained unkeyed rows. */
 
   function vesselOverlayEntryId(record) {
-    // Cached on the record: detection asks for it every frame for every vessel.
-    if (record?.overlayEntryId) return record.overlayEntryId;
-    const id = composeVesselOverlayEntryId(record);
-    if (record) record.overlayEntryId = id;
-    return id;
-  }
-
-  function composeVesselOverlayEntryId(record) {
     const mmsi = String(record?.mmsi || '').trim();
     if (mmsi) return `vessel:${mmsi}`;
     const name = String(record?.name || 'VESSEL').trim() || 'VESSEL';
diff --git a/src/layers/vessels/records.js b/src/layers/vessels/records.js
index f6f581784..ad6d85cbd 100644
--- a/src/layers/vessels/records.js
+++ b/src/layers/vessels/records.js
@@ -23,8 +23,6 @@ export function normalizeVessel(row) {
     lastPositionUtc: String(row.last_position_UTC || ''),
     lastPositionEpoch: finiteNumber(row.last_position_epoch),
     missedRefreshes: 0,
-    // Cached by `vesselOverlayEntryId`; the fields it reads never change.
-    overlayEntryId: null,
   };
 }
 

From e0ba12e5a9db5835c6cfed2ace11aefaea47ada6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Itallo=20Brand=C3=A3o?=
 <45429643+IMBrandao@users.noreply.github.com>
Date: Sat, 7 Nov 2026 19:38:24 -0300
Subject: [PATCH 27/71] feat(transit): add Lisbon's Carris Metropolitana buses

Keyless GTFS-Realtime feed from Carris Metropolitana, documented in the
operator's public API repository. No licence is stated for the realtime
endpoint (the static GTFS is CC BY 4.0), so it is credited as a courtesy on
the same basis as the Metro Transit and OVapi feeds. The feed publishes km/h,
so a new `speedUnit` registry field lets the proxy convert to m/s. Route ids
wrap the GTFS route id in an area prefix and are read as the line number.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 DATA_SOURCES.md                        |  3 +-
 README.md                              |  2 +-
 changelog.d/szczecin-lisbon-transit.md |  6 ++++
 changelog.d/szczecin-transit.md        |  3 --
 docs/CURRENT-STATE.md                  |  4 +--
 src/data/transitFeeds.js               | 39 ++++++++++++++++++++++++++
 src/data/transitFeeds.test.mjs         | 33 ++++++++++++++++++++++
 src/data/transitProxy.js               |  6 +++-
 src/data/transitProxy.test.mjs         | 21 ++++++++++++++
 9 files changed, 109 insertions(+), 8 deletions(-)
 create mode 100644 changelog.d/szczecin-lisbon-transit.md
 delete mode 100644 changelog.d/szczecin-transit.md

diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index 6532837d8..2dc33dad5 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -100,6 +100,7 @@ How to read this:
 | **Burlington Transit** (opendata.burlington.ca) | Transit layer live vehicles, Burlington ON | Burlington Transit realtime data under the City of Burlington Open Data Terms of Use, which permit any lawful purpose. The terms are revocable and must travel with the data, so the credit links them. Route ids are internal keys and are joined to the City’s published GTFS. | Credit to the City of Burlington plus a link to its Open Data Terms of Use, which the licence requires |
 | **SMTR Rio de Janeiro** (dados.mobilidade.rio) | Transit layer live vehicles, Rio de Janeiro: municipal buses (SPPO) and the Mobi-Rio BRT, as two feeds | CC BY 4.0, stated on both data.rio catalog pages. Keyless GTFS-Realtime published by the Secretaria Municipal de Transportes, labelled beta, with a gateway limit of 5 requests a second and 60 a minute. Line names come from SMTR’s GTFS `routes.txt` (dados.mobilidade.rio/gtfs/schedule), under the same licence. | Attribution to SMTR / Prefeitura da Cidade do Rio de Janeiro under CC BY 4.0 |
 | **ZDiTM Szczecin** (zditm.szczecin.pl) | Transit layer live vehicles, Szczecin, Poland: buses and trams as one feed | CC0 1.0, stated on the ZDiTM developer page: “The data are provided free of charge under the CC0 1.0 licence, for use in any context, with no prior notification required.” Keyless GTFS-Realtime; the page says one update a minute, measured at about every 20 seconds. The feed carries no route id, so every vehicle takes the default bus mode. | None required (CC0); credited to ZDiTM Szczecin as a courtesy |
+| **Carris Metropolitana** (api.carrismetropolitana.pt) | Transit layer live vehicles, Lisbon Metropolitan Area, Portugal | Keyless GTFS-Realtime documented in the operator’s public API repository (github.com/carrismetropolitana/api). No licence is stated for the realtime endpoint; the operator’s static GTFS is CC BY 4.0. Included on the same basis as the Metro Transit and OVapi feeds and credited as a courtesy; it can be switched off if Carris objects. Speeds are published in km/h and converted to m/s by the proxy. Route ids are read as the line number per the operator’s `/v2/routes`. | Courtesy credit to Carris Metropolitana |
 | **Radio Browser**                                                     | Geolocated internet-radio station directory and station-level tags                                                                  | Public-domain directory data under PDDL 1.0; individual broadcaster stream terms apply                                                                                                                                                                                                                                                                | "Radio Browser" plus a link to the selected broadcaster                                                                                     |
 | **Re:Earth Terrain** (Mapterhorn)                                     | Terrain (keyless globe stacks — OSM etc. — + `/api/terrain/heights` ellipsoidal-height lookups)                                     | Terrain mesh: CC BY 4.0; geoid: EGM2008 (NGA, public domain)                                                                                                                                                                                                                                                                                          | "Terrain (keyless globe stacks): Re:Earth Terrain / Mapterhorn (CC BY 4.0) / EGM2008 (NGA)"                                                 |
 | **OpenSeaMap** (`tiles.openseamap.org`) | Sea Marks layer: raster overlay of buoys, lighthouses and ports (#10) | Chart tiles CC BY-SA 2.0; data ODbL 1.0 via OpenStreetMap | "Sea marks © OpenSeaMap contributors (CC BY-SA 2.0) · Data © OpenStreetMap contributors (ODbL)" |
@@ -187,7 +188,7 @@ The optional Local ADS-B layer and the broadcast-FM receiver use radio you recei
 - **Houston TranStar cameras.** Keyless. The camera list is the public `traffic.houstontranstar.org/data/layers/cctvSnapshots_json.js` catalog (~1,000 cameras across Greater Houston); frames are stills at `www.houstontranstar.org/snapshots/cctv/<id>.jpg`, synthesized from a validated numeric id rather than taken from the payload, and only that host is registered. Cameras whose catalog id is `0` (a different, non-snapshot class) and cameras outside Greater Houston are dropped. TranStar's `dir` field is the side of the freeway the camera sits on, not the way it faces: TranStar's own map shows it as "Traffic closest to the camera is traveling …" (South → eastbound, North → westbound, West → southbound, East → northbound). That travel direction (90°, 270°, 180°, 0°) seeds the heading as a low-confidence prior with the low-confidence pose; `None` or an unknown value uses the shared id-hash fallback at low confidence. Headings are corrected with the in-app calibration gizmo. Off by default. TranStar's [Content Usage terms](https://traffic.houstontranstar.org/disclaimer.aspx) prohibit copying or distributing the site's information, and external framing or linking to specific images, without TxDOT's prior written permission; its FAQ grants permission-free use only for the RSS feeds. This project does not hold that permission for downstream installations, so the pack loads only when an operator who holds TxDOT's written permission sets `CCTV_HOUSTON_ENABLED=1`; with the flag unset, empty or any other value, the server makes no request to TranStar. Once enabled, it loads the 250 cameras nearest downtown, Uptown, the Medical Center, IAH and Galveston; `CCTV_HOUSTON_MAX_SOURCES` (8–400) changes the cap. Snapshots update about every 3 minutes, which is also the ambient still cadence. Frames are fetched from TranStar and relayed to the browser on demand, buffered only transiently per request, sent with `Cache-Control: no-store`, and not archived.
 - **Autostrada del Brennero (A22) webcams.** Keyless. The camera list is one request to the Open Data Hub tourism API (`tourism.api.opendatahub.com/v1/WebcamInfo?source=a22`), run by NOI Techpark in South Tyrol, which republishes Autobrennero's own list of 13 motorway webcams with coordinates and kilometre markers. Frames are the operator's stills on `www.autobrennero.it/WebCamImg/km<N>.jpg`, refreshed about once a minute, and only the exact image for each camera's kilometre is registered. The feed names no bearing, so headings use the id-hash fallback at low confidence. The road climbs from about 20 m in the Po valley to about 1,370 m at the Brenner Pass, so each camera's ground elevation comes from a per-kilometre table sampled from the Copernicus GLO-90 DEM (via Open-Meteo's elevation API); a camera not in the table uses a 200 m prior. The Open Data Hub tags every record CC0 (`ClosedData: false`, Autobrennero as licence holder), but that tag is the aggregator's metadata and Autobrennero publishes no terms of its own for the images, so they are credited to the operator as a courtesy and are not redistributed. Frames are fetched at request time and never stored. Disable with `CCTV_A22_ENABLED=0`.
 - **Camera frame content.** Public camera frames can contain people, vehicles and license plates, and the camera layer does nothing with them beyond putting them on the map. A successful upstream response is relayed as the provider served it: nothing in the camera pipeline blurs, redacts, enhances or restores it, and nothing there runs face, plate or object detection or otherwise recognises or classifies what is in the picture. (The ALPR layer described below maps where plate-reader cameras are, from locations contributors tagged in OpenStreetMap; it reads nothing from any camera frame.) When an upstream has no frame for a camera, what you see instead is a Google Street View still or the app's own placeholder card; the panel's source badge names which of them you are looking at, and a refresh that fails after a frame has arrived leaves the last good picture on screen rather than replacing it. The browser resamples each frame for display: onto a fixed 1920x1080 surface for the camera's projection plane in the scene, and onto a 192x108 canvas for the small ambient card. That scaling is the only change made to the picture, and the only pixels the camera layer reads back are a 64x36 downscale hashed to tell whether the picture has changed. Live streams are piped through; the still path reads the image into memory to pass it on — TxDOT wraps its JPEG in a JSON envelope, which is decoded there — and no frame is written to disk (the disk cache, `.gev-cache/`, holds feed JSON for other layers and never camera imagery). Outside that pipeline, the voice assistant is the one feature that sends imagery anywhere: when it answers a question about what is in view it may attach a downscaled screenshot of the rendered scene — including any camera plane on screen — to the request it sends to the voice model. Frames are fetched only from server-registered camera URLs — a client cannot hand the proxy a URL (see [SECURITY.md](SECURITY.md)). What the app does stays inside the line README draws: no named-person search, no face recognition, no tracking individuals.
-- **Transit (GTFS-Realtime).** The proxy requests only registered operator feeds, validates redirects, bounds responses, and uses conditional requests, short snapshot caching and failure backoff. All nineteen registered feeds, covering eighteen regions, are live-enabled; each can be disabled independently. Vehicles use delayed playback between reports, with report age and waiting states shown separately. Session-local selected trails are available for every feed. MBTA additionally retains up to 15 minutes of recently observed positions in the running proxy, so available history can survive a browser reload; server restart clears it. History reads never fetch upstream, and other feeds have no proxy retention. Nothing is archived to disk or collected in the background. Operator text credits are included as a courtesy and do not imply endorsement. Heights are aligned to work with Google 3D tiles; subway markers are shown at street level because these feeds do not supply depth. The TTC feed is BusTime, the surface system: it carries buses and streetcars and no subway at all. About four in ten of its vehicles report no route at all (unassigned or deadheading), and those are shown with the feed default rather than a route-established mode. It sends no ETag or Last-Modified, so its conditional requests fall through to the ordinary snapshot cache. Three Golden Horseshoe neighbours run alongside it — MiWay, Hamilton HSR and Durham Region Transit — each bus-only and each polled only near its own region. Durham Region Transit publishes no bearing on any vehicle, so those sprites take their heading from observed movement like any other feed that omits it. Guelph, Kingston and Barrie extend the same pattern eastward and north. Hamilton, Guelph, Burlington, YRT and Rio’s SMTR publish route ids that are not the number on the vehicle, so those entries carry a route-name table taken from each operator’s own published GTFS; any id missing from a table renders unchanged rather than blank. A label is never invented: YRT runs a route `9101` that appears nowhere in its published routes, so it stays as the feed sends it. Burlington’s is the one that cannot be shortcut: `351` is route 1 while `3510` is route 10, so the table is a real join rather than a trimmed prefix. GO Transit / Metrolinx is deliberately absent: its REALTIME feed requires an API key issued by manual review, which the keyless admission rule excludes (its static schedule download is keyless, but carries no vehicle positions). Barrie and YRT/Viva each invite acceptance of their licence through a form, and each licence also states that using the data is itself acceptance; this deployment relies on that clause, which is recorded in both entries. Grand River Transit in Waterloo is absent for a different reason: it answers, but its feed header was months stale and it publishes no per-vehicle timestamps, so it would render vehicles that look live and are not. Ottawa’s OC Transpo falls to the same keyless admission rule as GO Transit — its realtime feed requires an API key. London Transit and Thunder Bay Transit publish vehicle positions over plain HTTP with no HTTPS endpoint available. Every other Ontario system — Brampton, Oakville, Niagara, Milton, Windsor, Greater Sudbury, UP Express and a dozen smaller operators — publishes static GTFS schedules only, with no realtime vehicle positions to register. Between the nine included and these exclusions, every Ontario realtime vehicle-position feed catalogued in the Mobility Database is accounted for.
+- **Transit (GTFS-Realtime).** The proxy requests only registered operator feeds, validates redirects, bounds responses, and uses conditional requests, short snapshot caching and failure backoff. All twenty registered feeds, covering nineteen regions, are live-enabled; each can be disabled independently. Vehicles use delayed playback between reports, with report age and waiting states shown separately. Session-local selected trails are available for every feed. MBTA additionally retains up to 15 minutes of recently observed positions in the running proxy, so available history can survive a browser reload; server restart clears it. History reads never fetch upstream, and other feeds have no proxy retention. Nothing is archived to disk or collected in the background. Operator text credits are included as a courtesy and do not imply endorsement. Heights are aligned to work with Google 3D tiles; subway markers are shown at street level because these feeds do not supply depth. The TTC feed is BusTime, the surface system: it carries buses and streetcars and no subway at all. About four in ten of its vehicles report no route at all (unassigned or deadheading), and those are shown with the feed default rather than a route-established mode. It sends no ETag or Last-Modified, so its conditional requests fall through to the ordinary snapshot cache. Three Golden Horseshoe neighbours run alongside it — MiWay, Hamilton HSR and Durham Region Transit — each bus-only and each polled only near its own region. Durham Region Transit publishes no bearing on any vehicle, so those sprites take their heading from observed movement like any other feed that omits it. Guelph, Kingston and Barrie extend the same pattern eastward and north. Hamilton, Guelph, Burlington, YRT and Rio’s SMTR publish route ids that are not the number on the vehicle, so those entries carry a route-name table taken from each operator’s own published GTFS; any id missing from a table renders unchanged rather than blank. A label is never invented: YRT runs a route `9101` that appears nowhere in its published routes, so it stays as the feed sends it. Burlington’s is the one that cannot be shortcut: `351` is route 1 while `3510` is route 10, so the table is a real join rather than a trimmed prefix. GO Transit / Metrolinx is deliberately absent: its REALTIME feed requires an API key issued by manual review, which the keyless admission rule excludes (its static schedule download is keyless, but carries no vehicle positions). Barrie and YRT/Viva each invite acceptance of their licence through a form, and each licence also states that using the data is itself acceptance; this deployment relies on that clause, which is recorded in both entries. Grand River Transit in Waterloo is absent for a different reason: it answers, but its feed header was months stale and it publishes no per-vehicle timestamps, so it would render vehicles that look live and are not. Ottawa’s OC Transpo falls to the same keyless admission rule as GO Transit — its realtime feed requires an API key. London Transit and Thunder Bay Transit publish vehicle positions over plain HTTP with no HTTPS endpoint available. Every other Ontario system — Brampton, Oakville, Niagara, Milton, Windsor, Greater Sudbury, UP Express and a dozen smaller operators — publishes static GTFS schedules only, with no realtime vehicle positions to register. Between the nine included and these exclusions, every Ontario realtime vehicle-position feed catalogued in the Mobility Database is accounted for.
 - **Radio country coverage (optional).** Set `RADIO_PRIORITY_COUNTRIES=IN,PL` in the local `.env` and restart to include stations beyond the global click charts. The operator may choose up to eight unique ISO alpha-2 country codes; no key is needed. Each country adds one bounded query (at most 200 rows) and reserves up to 40 unique, usable stations inside the existing 750-station catalog. Country seeds precede specialist-tag seeds and global popularity fill; unused slots return to the shared pool. This is a coverage preference, not an exhaustive national directory or a guarantee of stations in every city. Countries with no eligible HTTPS MP3/AAC geolocated stations remain empty. An unset list preserves global selection. Country requests share the directory cache and three-worker pool; failed country queries are reported in coverage without blocking a healthy global refresh. Failed/degraded refreshes back off for one minute, with at most three mirrors per query.
 
 - **Radio Browser.** In every installation, including when `RADIO_PRIORITY_COUNTRIES` is unset, each request tries at most three mirror candidates (later fallback candidates are skipped), and failed or partial catalog refreshes back off for 60 seconds. A cold-start failure therefore continues returning 503 during that delay even if upstream recovers. `/api/radio/stations` discovers official API mirrors, makes bounded and coalesced healthy/geolocated HTTPS-station queries, caches the normalized public-domain directory for 45 minutes, and may serve the last good catalog for up to seven days during an outage. Refreshes must meet minimum accepted-query and station coverage before replacing a warm catalog; broad/specialist responses whose rows all fail the product's health policy do not count as successful queries. Optional priority-country outcomes are advisory: valid, in-limit responses with no eligible stations succeed as empty results, while failed or malformed country queries report unsuccessful coverage without degrading the global catalog. A usable partial cold catalog is explicitly `DEGRADED`, and non-array or empty broad/specialist payloads are rejected atomically. Individual structurally malformed rows are skipped rather than failing the whole query; the response carries their bounded `rejectedStationCount` (at most 10,000), which the client adds to its own rejected rows and reports as degraded coverage without discarding the accepted generation. Every directory and click-count request rejects redirects, validates all resolved addresses as globally routable (including reserved/documentation IPv4 and special/non-global IPv6 exclusions), and pins the TLS connection to a validated address. Only MP3/AAC non-HLS directory rows with public HTTPS stream targets are returned; favicons are intentionally omitted. Pressing play connects one browser audio element directly to the selected broadcaster and calls the directory's click counter through known-ID-only `POST /api/radio/click/:uuid`. GEV never proxies, caches, records, bundles, or redistributes audio. Radio Browser supplies station-level tags, not dependable current-song or upcoming-program metadata, so Radio filtering never claims either. Direct playback exposes the listener's IP address to the broadcaster, whose own stream terms apply.
diff --git a/README.md b/README.md
index 6c8de0d79..fff61fd9f 100644
--- a/README.md
+++ b/README.md
@@ -444,7 +444,7 @@ Twenty-one layers and map sources. **Nineteen have a keyless path.** Some offer
 | 📷 **Mapped ALPR Cameras**  | License-plate-reader camera locations tagged by OpenStreetMap contributors, loaded one city-sized view at a time, with **SHOW NEAREST**. Locations and tags only: no plate data, no video                                                                                                                                                                                           | OpenStreetMap (incl. DeFlock mapping)   | 🟢                                                                                                  |
 | 📷 **Street Level**         | Street-level photos behind one panel, one chip per provider: coverage on the streets, image cones, an embedded viewer with full-screen **EXPAND**. Mapillary, Google Street View, KartaView and Panoramax | Mapillary · Google · KartaView · Panoramax | 🟢 KartaView, Panoramax · 🟡 Mapillary token · 🔴 Google Maps key |
 | 📻 **Radio**                | Geolocated world radio with an **analog tuner** — drag the needle across up to 750 stations and the globe flies to each broadcaster                                                                                                                                                                                                                                                 | Radio Browser / broadcasters            | 🟢                                                                                                  |
-| 🚌 **Transit**              | Live buses, trams, metros, trains and ferries with delayed playback between reports, selected-vehicle trails, and mode-coloured DETECT labels — Boston, Austin, Minneapolis, Helsinki, the Netherlands, Norway, South East Queensland, Rio de Janeiro (buses and BRT), Szczecin, and nine in Ontario: Toronto (surface vehicles; the subway publishes no positions), Mississauga, Hamilton, Durham Region, York Region, Guelph, Burlington, Barrie and Kingston                                                                                                                                               | Operator GTFS-Realtime feeds            | 🟢                                                                                                  |
+| 🚌 **Transit**              | Live buses, trams, metros, trains and ferries with delayed playback between reports, selected-vehicle trails, and mode-coloured DETECT labels — Boston, Austin, Minneapolis, Helsinki, the Netherlands, Norway, South East Queensland, Rio de Janeiro (buses and BRT), Szczecin, Lisbon, and nine in Ontario: Toronto (surface vehicles; the subway publishes no positions), Mississauga, Hamilton, Durham Region, York Region, Guelph, Burlington, Barrie and Kingston                                                                                                                                               | Operator GTFS-Realtime feeds            | 🟢                                                                                                  |
 | 🚲 **Bikeshare**            | Live station availability                                                                                                                                                                                                                                                                                                                                                           | GBFS                                    | 🟢                                                                                                  |
 | 🧭 **Directions**           | Click A and B on the globe for a street-following drive, walk or cycle route draped on the terrain with turn-by-turn steps — then FLY the camera along it. No key, no geocoder, no mic                                                                                                                                                                                              | OSRM on FOSSGIS servers (OpenStreetMap) | 🟢                                                                                                  |
 | ⌖ **OSM Places**           | Voice place search ("hospitals in Kathmandu") from OpenStreetMap, drawn as numbered points that follow-up questions can filter. Needs your own Overpass server (`OVERPASS_UPSTREAMS`); off otherwise                                                                                                                                                                                                                                                                                                                               |
diff --git a/changelog.d/szczecin-lisbon-transit.md b/changelog.d/szczecin-lisbon-transit.md
new file mode 100644
index 000000000..103657e8f
--- /dev/null
+++ b/changelog.d/szczecin-lisbon-transit.md
@@ -0,0 +1,6 @@
+- Add Szczecin, Poland and the Lisbon Metropolitan Area to the Transit layer.
+  Szczecin's buses and trams come from ZDiTM's keyless feed under CC0 1.0; it
+  carries no route ids, so vehicles show as buses. Lisbon's buses come from
+  Carris Metropolitana's keyless feed, which states no licence of its own and
+  is credited as a courtesy like Metro Transit and OVapi; its km/h speeds are
+  converted to m/s and its route ids read as the line number (IMBrandao).
diff --git a/changelog.d/szczecin-transit.md b/changelog.d/szczecin-transit.md
deleted file mode 100644
index 5b2411211..000000000
--- a/changelog.d/szczecin-transit.md
+++ /dev/null
@@ -1,3 +0,0 @@
-- Add Szczecin, Poland to the Transit layer: buses and trams from ZDiTM's
-  keyless GTFS-Realtime feed, published under CC0 1.0. The feed carries no
-  route ids, so vehicles show as buses (IMBrandao).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 85bfd2e92..b5820c6b5 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4644,9 +4644,9 @@ Transit is off by default, and share links use token `j`. The movement panel ord
 places Transit directly after Street Traffic and before Bike Share. Cameras and
 utilities retain their own groups. The layer polls
 registered feeds near the camera every 15 seconds, below a 3,000 km altitude
-gate. Eighteen keyless regions are available: Boston, Austin, Minneapolis–St Paul,
+gate. Nineteen keyless regions are available: Boston, Austin, Minneapolis–St Paul,
 Helsinki, the Netherlands, Norway, South East Queensland, Rio de Janeiro
-(municipal buses and the Mobi-Rio BRT, two feeds), Szczecin, and nine in
+(municipal buses and the Mobi-Rio BRT, two feeds), Szczecin, the Lisbon Metropolitan Area, and nine in
 Ontario — Toronto (TTC surface vehicles; the subway publishes no
 positions), MiWay, Hamilton HSR, Durham Region, YRT/Viva, Guelph,
 Burlington, Barrie and Kingston. Mode silhouettes
diff --git a/src/data/transitFeeds.js b/src/data/transitFeeds.js
index 76b2764a6..7515b8417 100644
--- a/src/data/transitFeeds.js
+++ b/src/data/transitFeeds.js
@@ -389,6 +389,19 @@ function rioRouteLabel(routeId) {
     : routeId;
 }
 
+/**
+ * Carris Metropolitana realtime route ids wrap the GTFS route id in an
+ * operator-area prefix and keep its pattern suffix: `[LA77N]1708_0` is GTFS
+ * route `1708_0`, whose `short_name` (the number on the bus) is `1708`, per
+ * the operator's own `/v2/routes` API. Anything else passes through.
+ * @param {string|null} routeId
+ * @returns {string|null}
+ */
+function carrisMetropolitanaRouteLabel(routeId) {
+  const match = /^\[[A-Z0-9]+\](\d{4})_\d+$/.exec(routeId ?? '');
+  return match ? match[1] : routeId;
+}
+
 /**
  * Registry of feeds. Order is presentation order in the stats/credit text.
  * `loadRadiusKm` is the distance from `center` inside which the feed is polled.
@@ -398,7 +411,10 @@ function rioRouteLabel(routeId) {
  *   url: string, headers?: Record<string, string>,
  *   license: string, licenseUrl: string, attribution: string,
  *   defaultMode: string, routeMode?: (routeId: string|null) => string,
+ *   speedUnit?: 'km/h',
  * }>>}
+ * `speedUnit` marks a feed that publishes km/h where the spec requires m/s;
+ * the proxy converts it before the snapshot leaves the server.
  */
 export const TRANSIT_FEED_REGISTRY = Object.freeze([
   Object.freeze({
@@ -811,6 +827,29 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     }),
     defaultMode: 'bus',
   }),
+  Object.freeze({
+    id: 'carris-metropolitana-lisboa',
+    name: 'Carris Metropolitana',
+    operator: 'Carris Metropolitana (TML), Lisbon Metropolitan Area',
+    region: 'Lisbon Metropolitan Area, Portugal',
+    // Every vehicle in a 2026-11-07 snapshot, from Mafra to Setúbal, sat
+    // between 38.47–39.00 N and 9.47–8.79 W, inside 40 km of this point.
+    center: Object.freeze({ lat: 38.73, lon: -9.13 }),
+    loadRadiusKm: 45,
+    url: 'https://api.carrismetropolitana.pt/v2/vehicles.pb',
+    license: 'No separate licence for the realtime feed',
+    licenseUrl: 'https://github.com/carrismetropolitana/api',
+    attribution: 'Carris Metropolitana',
+    defaultEnabled: true,
+    terms: Object.freeze({
+      quote:
+        'GET /vehicles.pb — Returns vehicle locations in Protobuf format, following the GTFS-RT Vehicle Locations standard.',
+      note: 'The operator publishes this feed keyless and documented for developers in its public API repository, but states no licence for the realtime endpoint; its static GTFS (github.com/carrismetropolitana/gtfs) is CC BY 4.0. Credited as a courtesy, on the same basis as the Metro Transit and OVapi feeds; switch it off if Carris objects. The quote above is the API README, not a licence. `/vehicles.pb` answers with a 307 to `/v2/vehicles.pb`, so the registry points at the target. Speeds are km/h, not the m/s the spec requires: 2026-11-07 readings of 31–33 matched 6–9 m/s of measured movement, so the proxy converts them. Vehicle reports arrive every 30–50 seconds. Route ids are the GTFS route id inside an area prefix and are read as the line number.',
+    }),
+    defaultMode: 'bus',
+    routeLabel: carrisMetropolitanaRouteLabel,
+    speedUnit: 'km/h',
+  }),
 ]);
 
 /**
diff --git a/src/data/transitFeeds.test.mjs b/src/data/transitFeeds.test.mjs
index 5fab7c27d..0e3d4ab37 100644
--- a/src/data/transitFeeds.test.mjs
+++ b/src/data/transitFeeds.test.mjs
@@ -578,3 +578,36 @@ test('Szczecin is CC0, live, covers the city and not Berlin', () => {
     'Szczecin has a DATA_SOURCES row',
   );
 });
+
+test('Carris Metropolitana covers Lisbon from Mafra to Setúbal, not Porto', () => {
+  const feed = getTransitFeed('carris-metropolitana-lisboa');
+  assert.equal(feed.defaultEnabled, true);
+  assert.equal(feed.url, 'https://api.carrismetropolitana.pt/v2/vehicles.pb');
+  assert.equal(feed.speedUnit, 'km/h');
+  assert.match(feed.terms.note, /no licence for the realtime endpoint/);
+  const ids = (lat, lon) => transitFeedsInRange(lat, lon).map((f) => f.id);
+  for (const [place, lat, lon] of [
+    ['Lisbon', 38.7223, -9.1393],
+    ['Mafra', 38.9369, -9.3277],
+    ['Setúbal', 38.5244, -8.8882],
+  ]) {
+    assert.ok(ids(lat, lon).includes(feed.id), place);
+  }
+  assert.ok(!ids(41.1579, -8.6291).includes(feed.id), 'Porto');
+  const sources = readFileSync(
+    new URL('../../DATA_SOURCES.md', import.meta.url),
+    'utf8',
+  );
+  assert.ok(
+    sources.split('\n').some((l) => l.startsWith('| **Carris Metropolitana')),
+    'Lisbon has a DATA_SOURCES row',
+  );
+});
+
+test('Carris Metropolitana route ids read as the line number on the bus', () => {
+  const feed = getTransitFeed('carris-metropolitana-lisboa');
+  assert.equal(transitRouteLabel(feed, '[LA77N]1708_0'), '1708');
+  assert.equal(transitRouteLabel(feed, '[BNA17]2772_1'), '2772');
+  assert.equal(transitRouteLabel(feed, 'unexpected'), 'unexpected');
+  assert.equal(transitRouteLabel(feed, null), null);
+});
diff --git a/src/data/transitProxy.js b/src/data/transitProxy.js
index 458240e9d..68280d132 100644
--- a/src/data/transitProxy.js
+++ b/src/data/transitProxy.js
@@ -257,7 +257,11 @@ export function buildTransitSnapshot(feed, bytes, now = Date.now()) {
     truncated: decoded.truncated,
     count: decoded.vehicles.length,
     vehicles: repairVehicleTimestamps(
-      decoded.vehicles,
+      feed.speedUnit === 'km/h'
+        ? decoded.vehicles.map((v) =>
+            v.speedMps === null ? v : { ...v, speedMps: v.speedMps / 3.6 },
+          )
+        : decoded.vehicles,
       decoded.timestamp,
       Math.floor(now / 1000),
     ),
diff --git a/src/data/transitProxy.test.mjs b/src/data/transitProxy.test.mjs
index f03ea2e30..7c173cb5f 100644
--- a/src/data/transitProxy.test.mjs
+++ b/src/data/transitProxy.test.mjs
@@ -294,6 +294,27 @@ test('Rio speeds pass through as the m/s they are published in', () => {
   assert.equal(rio.vehicles[0].speedMps, 10);
 });
 
+test('Carris Metropolitana km/h speeds leave the proxy as m/s', () => {
+  // 2026-11-07: readings of 31-33 matched 6-9 m/s of measured movement.
+  const bytes = encodeFeed({
+    entities: [
+      { id: 'moving', lat: 38.72, lon: -9.14, speed: 36 },
+      { id: 'parked', lat: 38.73, lon: -9.15 },
+    ],
+  });
+  const feed = getTransitFeed('carris-metropolitana-lisboa');
+  const lisbon = buildTransitSnapshot(feed, bytes, 1);
+  const byId = Object.fromEntries(lisbon.vehicles.map((v) => [v.id, v]));
+  assert.ok(Math.abs(byId.moving.speedMps - 10) < 1e-6);
+  assert.equal(byId.parked.speedMps, null, 'no speed stays no speed');
+  const szczecin = buildTransitSnapshot(
+    getTransitFeed('zditm-szczecin'),
+    encodeFeed({ entities: [{ id: 'm', lat: 53.43, lon: 14.55, speed: 10 }] }),
+    1,
+  );
+  assert.equal(szczecin.vehicles[0].speedMps, 10, 'm/s feeds are untouched');
+});
+
 test('conditional-request validators and gzip ride along with feed identification', () => {
   const entur = getTransitFeed('entur-norway');
   const plain = transitUpstreamHeaders(entur);

From 71b694ab6245dc91ec20562acd2394ba65c8edd2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Itallo=20Brand=C3=A3o?=
 <45429643+IMBrandao@users.noreply.github.com>
Date: Sun, 8 Nov 2026 02:50:32 -0300
Subject: [PATCH 28/71] feat(transit): add 32 more keyless cities across
 Europe, Asia, Oceania and North America
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Prague, Warsaw, Kraków (buses and trams), Poznań, Gdańsk, Rzeszów, Vilnius,
Bucharest, Cluj-Napoca, Iași, Rome, Turin, Venice (buses and waterbuses),
Bordeaux, Montpellier, Rouen, Toulon, Le Havre, Tours, Málaga, Lisbon's city
Carris, Sendai, Johor Bahru, Kota Bharu, Adelaide, Atlanta, Denver, Edmonton,
Halifax and Victoria.

Each entry records its licence, or that none is stated and the Metro
Transit/OVapi basis it ships on. Montpellier and Toulon publish km/h and are
converted. Route ids are read as the rider-facing line; Prague, Bordeaux and
Le Havre trams and Venice waterbuses take their own mode. Adelaide needs
`Accept: */*` to get binary protobuf. Every feed was fetched through the dev
proxy on 2026-11-08.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 DATA_SOURCES.md                        |  34 +-
 README.md                              |   2 +-
 changelog.d/szczecin-lisbon-transit.md |   6 -
 changelog.d/transit-more-cities.md     |  11 +
 docs/CURRENT-STATE.md                  |   4 +-
 src/data/transitFeeds.js               | 636 +++++++++++++++++++++++++
 src/data/transitFeeds.test.mjs         | 108 +++++
 src/data/transitProxy.test.mjs         |  10 +
 8 files changed, 801 insertions(+), 10 deletions(-)
 delete mode 100644 changelog.d/szczecin-lisbon-transit.md
 create mode 100644 changelog.d/transit-more-cities.md

diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index 2dc33dad5..5ef902c0c 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -101,6 +101,38 @@ How to read this:
 | **SMTR Rio de Janeiro** (dados.mobilidade.rio) | Transit layer live vehicles, Rio de Janeiro: municipal buses (SPPO) and the Mobi-Rio BRT, as two feeds | CC BY 4.0, stated on both data.rio catalog pages. Keyless GTFS-Realtime published by the Secretaria Municipal de Transportes, labelled beta, with a gateway limit of 5 requests a second and 60 a minute. Line names come from SMTR’s GTFS `routes.txt` (dados.mobilidade.rio/gtfs/schedule), under the same licence. | Attribution to SMTR / Prefeitura da Cidade do Rio de Janeiro under CC BY 4.0 |
 | **ZDiTM Szczecin** (zditm.szczecin.pl) | Transit layer live vehicles, Szczecin, Poland: buses and trams as one feed | CC0 1.0, stated on the ZDiTM developer page: “The data are provided free of charge under the CC0 1.0 licence, for use in any context, with no prior notification required.” Keyless GTFS-Realtime; the page says one update a minute, measured at about every 20 seconds. The feed carries no route id, so every vehicle takes the default bus mode. | None required (CC0); credited to ZDiTM Szczecin as a courtesy |
 | **Carris Metropolitana** (api.carrismetropolitana.pt) | Transit layer live vehicles, Lisbon Metropolitan Area, Portugal | Keyless GTFS-Realtime documented in the operator’s public API repository (github.com/carrismetropolitana/api). No licence is stated for the realtime endpoint; the operator’s static GTFS is CC BY 4.0. Included on the same basis as the Metro Transit and OVapi feeds and credited as a courtesy; it can be switched off if Carris objects. Speeds are published in km/h and converted to m/s by the proxy. Route ids are read as the line number per the operator’s `/v2/routes`. | Courtesy credit to Carris Metropolitana |
+| **Prague PID** (api.golemio.cz) | Transit layer live vehicles, Prague and Central Bohemia, Czechia | CC BY (https://pid.cz/o-systemu/opendata/). Stated: “Data, která lze stáhnout přímo zde z webu, jsou stejně jako celý obsah webu opatřena licencí CC-BY” The PID open-data page lists this realtime feed and licenses the data it publishes under CC BY, crediting the author and any changes. The same page says data served from other sources follows that source’s licence; the feed is served by Golemio, the city’s data platform, which states none of its own. Keyless since the catalogue moved it off the X-Access-Token endpoint. Speeds are m/s, checked against movement on 2026-11-07. Route ids are `L` plus the line number; lines below 100 are trams. | Pražská integrovaná doprava (PID) / Golemio |
+| **Warsaw buses and trams** (mkuran.pl) | Transit layer live vehicles, Warsaw, Poland | Warsaw Open Data Project Usage Terms (https://mkuran.pl/gtfs/). Stated: “The City Hall requires a credit by providing the name Miasto Stołeczne Warszawa, data download date (use the timestamp from the FeedHeader) and link to http://api.um.warszawa.pl.” Positions come from the Warsaw City Hall API, repackaged as GTFS-RT by Mikołaj Kuranowski’s unofficial feed. The credit names the city and its API; the download date it asks for is the feed timestamp the layer already shows with each snapshot. Vehicle timestamps ran about two minutes old on 2026-11-07, which the delayed playback absorbs. | Miasto Stołeczne Warszawa (api.um.warszawa.pl) |
+| **Bordeaux TBM** (bdx.mecatran.com) | Transit layer live vehicles, Bordeaux, France | Licence Ouverte / Etalab 2.0 (https://transport.data.gouv.fr/datasets/offres-de-services-bus-tram-et-scolaire-au-format-gtfs-netex-gtfs-rt-siri-lite). The quote is the licence field of the national access point’s dataset record (fr-lo is the Licence Ouverte), which asks only for credit. The `apiKey` in the URL is not a credential: it is the same fixed string printed in the open-data listing for everyone. Speeds are m/s. Trams run on lettered lines A–D; numbered lines are buses. | Bordeaux Métropole (TBM) |
+| **Sendai City Bus** (api-public.odpt.org) | Transit layer live vehicles, Sendai, Japan | CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Served by the Open Data Challenge for Public Transportation (ODPT) public API, which needs no key for this feed; the catalogue records CC BY 4.0 as its licence. Vehicle timestamps ran about two minutes old on 2026-11-07. Speeds are m/s. | 仙台市交通局 (Sendai City Transportation Bureau) / ODPT |
+| **Poznań buses and trams** (ztm.poznan.pl) | Transit layer live vehicles, Poznań, Poland | ZTM Poznań open-data terms (https://www.ztm.poznan.pl/otwarte-dane/dla-deweloperow/). Stated: “Treści udostępniane są bezwnioskowo i bezpłatnie, na zasadach powszechnego dostępu i stanowią źródło informacji.” Reuse is free on three conditions: name the source, give the date of the last update, and say the data were processed. The credit names ZTM and says processed; the snapshot timestamp is the update date. The feed carries no bearing, so heading comes from movement between fixes. | Zarząd Transportu Miejskiego w Poznaniu (processed) |
+| **Gdańsk buses and trams** (ckan2.multimediagdansk.pl) | Transit layer live vehicles, Gdańsk, Poland | CC BY 4.0 (https://dane.gov.pl/pl/dataset/38599,rozklady-jazdy-i-lokalizacja-przystankow-gtfs-rt). The national catalogue (dane.gov.pl) lists this dataset under CC BY 4.0. No bearing; heading comes from movement. Speeds are m/s. | Zarząd Transportu Miejskiego w Gdańsku |
+| **Edmonton Transit Service** (gtfs.edmonton.ca) | Transit layer live vehicles, Edmonton, AB | City of Edmonton Open Data Agreement (https://www.edmonton.ca/transportation/Web-version2.1-OpenDataAgreement.pdf). The agreement is the same municipal template as Mississauga and Burlington: a licence to use, modify and distribute for any lawful purpose, in any medium. It was read from search excerpts; the PDF itself would not extract here. Route ids are zero-padded. Speeds are m/s. | Contains information licensed under the Open Data Agreement – City of Edmonton |
+| **Halifax Transit** (gtfs.halifax.ca) | Transit layer live vehicles, Halifax, NS | Halifax Open Data Licence (https://www.halifax.ca/home/open-data/open-data-licence). The catalogue points at Halifax’s open-data licence; the licence page renders only in a browser and was not quoted. Speeds are m/s. | Halifax Regional Municipality (Halifax Transit) |
+| **Victoria Regional Transit** (bct.tmix.se) | Transit layer live vehicles, Victoria, BC | BC Transit Open Data Terms of Use (https://www.bctransit.com/open-data/terms-of-use). Stated: “BC Transit grants you a limited, revocable and non-exclusive license to use, reproduce, and redistribute the Data in accordance with these Terms.” The grant is revocable, like the Ontario municipal templates. Route ids carry a `-VIC` system suffix. Speeds are m/s. | BC Transit |
+| **Montpellier TaM** (gtfsproxy.e-tam.fr) | Transit layer live vehicles, Montpellier, France | ODbL (https://transport.data.gouv.fr/datasets/offre-de-transport-tam-en-temps-reel-gtfs-rt-urbain-et-suburbain). The quote is the dataset record’s licence field. ODbL asks for credit and share-alike on a derived database; the layer redistributes no database, it draws the positions. Speeds are km/h: readings ran 3.3 times the measured movement on 2026-11-07, so the proxy converts them. | Montpellier Méditerranée Métropole (TaM) |
+| **Kraków buses** (gtfs.ztp.krakow.pl) | Transit layer live vehicles, Kraków, Poland | No licence stated (https://gtfs.ztp.krakow.pl/). ZTP publishes this feed keyless on its own GTFS server and lists it in the Mobility Database, but states no licence there or on dane.gov.pl. Shipped on the same basis as Metro Transit and OVapi; switch it off if ZTP objects. | Zarząd Transportu Publicznego w Krakowie |
+| **Kraków trams** (gtfs.ztp.krakow.pl) | Transit layer live vehicles, Kraków, Poland | No licence stated (https://gtfs.ztp.krakow.pl/). Same server and basis as the bus feed. | Zarząd Transportu Publicznego w Krakowie |
+| **Vilnius public transport** (stops.lt) | Transit layer live vehicles, Vilnius, Lithuania | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2383). Published keyless by the city transport agency on stops.lt; no licence found. Shipped on the same basis as Metro Transit and OVapi. Answered 522 once on 2026-11-07 and normally since. | SĮ Susisiekimo paslaugos (stops.lt) |
+| **Bucharest public transport** (gtfs.tpbi.ro) | Transit layer live vehicles, Bucharest, Romania | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2104). Keyless public endpoint from the metropolitan transport authority; no licence found. Same basis as Metro Transit and OVapi. | TPBI (Transport Public București–Ilfov) |
+| **Rome public transport** (romamobilita.it) | Transit layer live vehicles, Rome, Italy | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1776). Keyless file on the agency’s own site; the catalogue’s older `/sites/default/files/` path now 404s. No licence found; same basis as Metro Transit and OVapi. Fewer than one vehicle in five carries a bearing, so most headings come from movement. | Roma Servizi per la Mobilità |
+| **Turin GTT** (percorsieorari.gtt.to.it) | Transit layer live vehicles, Turin, Italy | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2696). Official keyless endpoint; no licence found. Same basis as Metro Transit and OVapi. Route ids append `U` for urban lines. | Gruppo Torinese Trasporti (GTT) |
+| **Venice ACTV buses** (tpl.actv.it) | Transit layer live vehicles, Venice, Italy | ACTV open-data catalogue (https://actv.avmspa.it/it/content/catalogo-dei-dati-metadati-e-banche-dati-actv). ACTV lists this feed in its own open-data catalogue; that page would not render for a script, so its licence is not quoted. Same basis as Metro Transit and OVapi. Route ids append a two-letter network code (`_UM`, `_ES`, `_UN`). | ACTV S.p.A. |
+| **Venice ACTV waterbuses** (tpl.actv.it) | Transit layer live vehicles, Venice, Italy | ACTV open-data catalogue (https://actv.avmspa.it/it/content/catalogo-dei-dati-metadati-e-banche-dati-actv). Same catalogue and basis as the ACTV bus feed. | ACTV S.p.A. |
+| **Adelaide Metro** (gtfs.adelaidemetro.com.au) | Transit layer live vehicles, Adelaide, SA | No licence stated for the realtime feed (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1772). Official keyless endpoint; the state catalogue page refused automated reads, so no licence is quoted. Same basis as Metro Transit and OVapi. Speeds are m/s. The server picks its encoding from Accept, hence the override. | Adelaide Metro |
+| **MARTA buses** (gtfs-rt.itsmarta.com) | Transit layer live vehicles, Atlanta, GA | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1601). Official keyless endpoint; no licence found. Same basis as Metro Transit and OVapi. Speeds are m/s. | MARTA |
+| **Denver RTD** (open-data.rtd-denver.com) | Transit layer live vehicles, Denver, CO | RTD GTFS-realtime licence agreement (https://www.rtd-denver.com/business-center/open-spatial-data/gtfs-realtime-license-agreement). RTD links a licence agreement for its realtime feeds; the page refused automated reads (403), so it is not quoted. The feed itself is keyless. Speeds are m/s. | Regional Transportation District (RTD) |
+| **Cluj-Napoca CTP** (cluj-rt-feed.gtfs.ro) | Transit layer live vehicles, Cluj-Napoca, Romania | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2614). Keyless; no licence found. Same basis as Metro Transit and OVapi. | Compania de Transport Public Cluj-Napoca |
+| **Iași CTP** (iasi-rt-feed.gtfs.ro) | Transit layer live vehicles, Iași, Romania | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2118). Keyless; no licence found. Same basis as Metro Transit and OVapi. | Compania de Transport Public Iași |
+| **Rzeszów city transport** (mpkrzeszow.pl) | Transit layer live vehicles, Rzeszów, Poland | MPK Rzeszów open data (https://www.mpkrzeszow.pl/otwartedane/). Listed on the operator’s open-data page, which names no licence. No bearing; heading comes from movement. | MPK Rzeszów |
+| **Málaga EMT** (gtfs.emtmalaga.es) | Transit layer live vehicles, Málaga, Spain | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2213). Keyless; no licence found. Same basis as Metro Transit and OVapi. No bearing; heading comes from movement. | EMT Málaga |
+| **Carris (Lisbon city)** (gateway.carris.pt) | Transit layer live vehicles, Lisbon, Portugal | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2930). Keyless official gateway; no licence found. Same basis as Metro Transit and OVapi. Carries neither bearing nor speed, and vehicle reports run about a minute old. Route ids append a variant. | Carris |
+| **BAS.MY Johor Bahru** (api.data.gov.my) | Transit layer live vehicles, Johor Bahru, Malaysia | No licence stated for the feed (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-3174). Served keyless by Malaysia’s national open-data API; no licence for the feed was found. Same basis as Metro Transit and OVapi. Without the trailing slash the API redirects. Route ids append an operator code. | BAS.MY / data.gov.my |
+| **BAS.MY Kota Bharu** (api.data.gov.my) | Transit layer live vehicles, Kota Bharu, Malaysia | No licence stated for the feed (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-3169). Same API and basis as Johor Bahru. | BAS.MY / data.gov.my |
+| **Rouen Astuce** (gtfs.bus-tracker.fr) | Transit layer live vehicles, Rouen, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/donnees-statiques-et-temps-reel-du-reseau-astuce-metropole-rouen-normandie). The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted); this registry reads it through bus-tracker.fr, an unofficial relay that merges the city’s networks into one GTFS-RT file. Route ids carry the network prefix (`TCAR:`). | Métropole Rouen Normandie (Astuce) / bus-tracker.fr |
+| **Toulon Mistral** (feed-rdtpm-toulon.ratpdev.com) | Transit layer live vehicles, Toulon, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/reseau-de-transport-urbain-de-la-metropole-toulon-provence-mediterranee). Dataset record’s licence field quoted. Speeds are km/h: readings ran 3.5 times the measured movement on 2026-11-07, so the proxy converts them. Route ids are zero-padded. | Métropole Toulon Provence Méditerranée (Mistral) |
+| **Le Havre LiA** (gtfs.bus-tracker.fr) | Transit layer live vehicles, Le Havre, France | ODbL (https://transport.data.gouv.fr/datasets/reseau-de-transport-en-commun-lia-gtfs-siri). The network publishes under ODbL (dataset record quoted); read through the bus-tracker.fr relay, which converts its SIRI feed to GTFS-RT. The layer draws positions and redistributes no database. Lines A and B are the tramway. | Le Havre Seine Métropole (LiA) / bus-tracker.fr |
+| **Tours Fil Bleu** (data.filbleu.fr) | Transit layer live vehicles, Tours, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/fil-bleu-syndicat-des-mobilites-gtfs-gtfs-rt). Dataset record’s licence field quoted. | Fil Bleu – Syndicat des Mobilités de Touraine |
 | **Radio Browser**                                                     | Geolocated internet-radio station directory and station-level tags                                                                  | Public-domain directory data under PDDL 1.0; individual broadcaster stream terms apply                                                                                                                                                                                                                                                                | "Radio Browser" plus a link to the selected broadcaster                                                                                     |
 | **Re:Earth Terrain** (Mapterhorn)                                     | Terrain (keyless globe stacks — OSM etc. — + `/api/terrain/heights` ellipsoidal-height lookups)                                     | Terrain mesh: CC BY 4.0; geoid: EGM2008 (NGA, public domain)                                                                                                                                                                                                                                                                                          | "Terrain (keyless globe stacks): Re:Earth Terrain / Mapterhorn (CC BY 4.0) / EGM2008 (NGA)"                                                 |
 | **OpenSeaMap** (`tiles.openseamap.org`) | Sea Marks layer: raster overlay of buoys, lighthouses and ports (#10) | Chart tiles CC BY-SA 2.0; data ODbL 1.0 via OpenStreetMap | "Sea marks © OpenSeaMap contributors (CC BY-SA 2.0) · Data © OpenStreetMap contributors (ODbL)" |
@@ -188,7 +220,7 @@ The optional Local ADS-B layer and the broadcast-FM receiver use radio you recei
 - **Houston TranStar cameras.** Keyless. The camera list is the public `traffic.houstontranstar.org/data/layers/cctvSnapshots_json.js` catalog (~1,000 cameras across Greater Houston); frames are stills at `www.houstontranstar.org/snapshots/cctv/<id>.jpg`, synthesized from a validated numeric id rather than taken from the payload, and only that host is registered. Cameras whose catalog id is `0` (a different, non-snapshot class) and cameras outside Greater Houston are dropped. TranStar's `dir` field is the side of the freeway the camera sits on, not the way it faces: TranStar's own map shows it as "Traffic closest to the camera is traveling …" (South → eastbound, North → westbound, West → southbound, East → northbound). That travel direction (90°, 270°, 180°, 0°) seeds the heading as a low-confidence prior with the low-confidence pose; `None` or an unknown value uses the shared id-hash fallback at low confidence. Headings are corrected with the in-app calibration gizmo. Off by default. TranStar's [Content Usage terms](https://traffic.houstontranstar.org/disclaimer.aspx) prohibit copying or distributing the site's information, and external framing or linking to specific images, without TxDOT's prior written permission; its FAQ grants permission-free use only for the RSS feeds. This project does not hold that permission for downstream installations, so the pack loads only when an operator who holds TxDOT's written permission sets `CCTV_HOUSTON_ENABLED=1`; with the flag unset, empty or any other value, the server makes no request to TranStar. Once enabled, it loads the 250 cameras nearest downtown, Uptown, the Medical Center, IAH and Galveston; `CCTV_HOUSTON_MAX_SOURCES` (8–400) changes the cap. Snapshots update about every 3 minutes, which is also the ambient still cadence. Frames are fetched from TranStar and relayed to the browser on demand, buffered only transiently per request, sent with `Cache-Control: no-store`, and not archived.
 - **Autostrada del Brennero (A22) webcams.** Keyless. The camera list is one request to the Open Data Hub tourism API (`tourism.api.opendatahub.com/v1/WebcamInfo?source=a22`), run by NOI Techpark in South Tyrol, which republishes Autobrennero's own list of 13 motorway webcams with coordinates and kilometre markers. Frames are the operator's stills on `www.autobrennero.it/WebCamImg/km<N>.jpg`, refreshed about once a minute, and only the exact image for each camera's kilometre is registered. The feed names no bearing, so headings use the id-hash fallback at low confidence. The road climbs from about 20 m in the Po valley to about 1,370 m at the Brenner Pass, so each camera's ground elevation comes from a per-kilometre table sampled from the Copernicus GLO-90 DEM (via Open-Meteo's elevation API); a camera not in the table uses a 200 m prior. The Open Data Hub tags every record CC0 (`ClosedData: false`, Autobrennero as licence holder), but that tag is the aggregator's metadata and Autobrennero publishes no terms of its own for the images, so they are credited to the operator as a courtesy and are not redistributed. Frames are fetched at request time and never stored. Disable with `CCTV_A22_ENABLED=0`.
 - **Camera frame content.** Public camera frames can contain people, vehicles and license plates, and the camera layer does nothing with them beyond putting them on the map. A successful upstream response is relayed as the provider served it: nothing in the camera pipeline blurs, redacts, enhances or restores it, and nothing there runs face, plate or object detection or otherwise recognises or classifies what is in the picture. (The ALPR layer described below maps where plate-reader cameras are, from locations contributors tagged in OpenStreetMap; it reads nothing from any camera frame.) When an upstream has no frame for a camera, what you see instead is a Google Street View still or the app's own placeholder card; the panel's source badge names which of them you are looking at, and a refresh that fails after a frame has arrived leaves the last good picture on screen rather than replacing it. The browser resamples each frame for display: onto a fixed 1920x1080 surface for the camera's projection plane in the scene, and onto a 192x108 canvas for the small ambient card. That scaling is the only change made to the picture, and the only pixels the camera layer reads back are a 64x36 downscale hashed to tell whether the picture has changed. Live streams are piped through; the still path reads the image into memory to pass it on — TxDOT wraps its JPEG in a JSON envelope, which is decoded there — and no frame is written to disk (the disk cache, `.gev-cache/`, holds feed JSON for other layers and never camera imagery). Outside that pipeline, the voice assistant is the one feature that sends imagery anywhere: when it answers a question about what is in view it may attach a downscaled screenshot of the rendered scene — including any camera plane on screen — to the request it sends to the voice model. Frames are fetched only from server-registered camera URLs — a client cannot hand the proxy a URL (see [SECURITY.md](SECURITY.md)). What the app does stays inside the line README draws: no named-person search, no face recognition, no tracking individuals.
-- **Transit (GTFS-Realtime).** The proxy requests only registered operator feeds, validates redirects, bounds responses, and uses conditional requests, short snapshot caching and failure backoff. All twenty registered feeds, covering nineteen regions, are live-enabled; each can be disabled independently. Vehicles use delayed playback between reports, with report age and waiting states shown separately. Session-local selected trails are available for every feed. MBTA additionally retains up to 15 minutes of recently observed positions in the running proxy, so available history can survive a browser reload; server restart clears it. History reads never fetch upstream, and other feeds have no proxy retention. Nothing is archived to disk or collected in the background. Operator text credits are included as a courtesy and do not imply endorsement. Heights are aligned to work with Google 3D tiles; subway markers are shown at street level because these feeds do not supply depth. The TTC feed is BusTime, the surface system: it carries buses and streetcars and no subway at all. About four in ten of its vehicles report no route at all (unassigned or deadheading), and those are shown with the feed default rather than a route-established mode. It sends no ETag or Last-Modified, so its conditional requests fall through to the ordinary snapshot cache. Three Golden Horseshoe neighbours run alongside it — MiWay, Hamilton HSR and Durham Region Transit — each bus-only and each polled only near its own region. Durham Region Transit publishes no bearing on any vehicle, so those sprites take their heading from observed movement like any other feed that omits it. Guelph, Kingston and Barrie extend the same pattern eastward and north. Hamilton, Guelph, Burlington, YRT and Rio’s SMTR publish route ids that are not the number on the vehicle, so those entries carry a route-name table taken from each operator’s own published GTFS; any id missing from a table renders unchanged rather than blank. A label is never invented: YRT runs a route `9101` that appears nowhere in its published routes, so it stays as the feed sends it. Burlington’s is the one that cannot be shortcut: `351` is route 1 while `3510` is route 10, so the table is a real join rather than a trimmed prefix. GO Transit / Metrolinx is deliberately absent: its REALTIME feed requires an API key issued by manual review, which the keyless admission rule excludes (its static schedule download is keyless, but carries no vehicle positions). Barrie and YRT/Viva each invite acceptance of their licence through a form, and each licence also states that using the data is itself acceptance; this deployment relies on that clause, which is recorded in both entries. Grand River Transit in Waterloo is absent for a different reason: it answers, but its feed header was months stale and it publishes no per-vehicle timestamps, so it would render vehicles that look live and are not. Ottawa’s OC Transpo falls to the same keyless admission rule as GO Transit — its realtime feed requires an API key. London Transit and Thunder Bay Transit publish vehicle positions over plain HTTP with no HTTPS endpoint available. Every other Ontario system — Brampton, Oakville, Niagara, Milton, Windsor, Greater Sudbury, UP Express and a dozen smaller operators — publishes static GTFS schedules only, with no realtime vehicle positions to register. Between the nine included and these exclusions, every Ontario realtime vehicle-position feed catalogued in the Mobility Database is accounted for.
+- **Transit (GTFS-Realtime).** The proxy requests only registered operator feeds, validates redirects, bounds responses, and uses conditional requests, short snapshot caching and failure backoff. All fifty-two registered feeds, covering forty-nine regions, are live-enabled; each can be disabled independently. Vehicles use delayed playback between reports, with report age and waiting states shown separately. Session-local selected trails are available for every feed. MBTA additionally retains up to 15 minutes of recently observed positions in the running proxy, so available history can survive a browser reload; server restart clears it. History reads never fetch upstream, and other feeds have no proxy retention. Nothing is archived to disk or collected in the background. Operator text credits are included as a courtesy and do not imply endorsement. Heights are aligned to work with Google 3D tiles; subway markers are shown at street level because these feeds do not supply depth. The TTC feed is BusTime, the surface system: it carries buses and streetcars and no subway at all. About four in ten of its vehicles report no route at all (unassigned or deadheading), and those are shown with the feed default rather than a route-established mode. It sends no ETag or Last-Modified, so its conditional requests fall through to the ordinary snapshot cache. Three Golden Horseshoe neighbours run alongside it — MiWay, Hamilton HSR and Durham Region Transit — each bus-only and each polled only near its own region. Durham Region Transit publishes no bearing on any vehicle, so those sprites take their heading from observed movement like any other feed that omits it. Guelph, Kingston and Barrie extend the same pattern eastward and north. Hamilton, Guelph, Burlington, YRT and Rio’s SMTR publish route ids that are not the number on the vehicle, so those entries carry a route-name table taken from each operator’s own published GTFS; any id missing from a table renders unchanged rather than blank. A label is never invented: YRT runs a route `9101` that appears nowhere in its published routes, so it stays as the feed sends it. Burlington’s is the one that cannot be shortcut: `351` is route 1 while `3510` is route 10, so the table is a real join rather than a trimmed prefix. GO Transit / Metrolinx is deliberately absent: its REALTIME feed requires an API key issued by manual review, which the keyless admission rule excludes (its static schedule download is keyless, but carries no vehicle positions). Barrie and YRT/Viva each invite acceptance of their licence through a form, and each licence also states that using the data is itself acceptance; this deployment relies on that clause, which is recorded in both entries. Grand River Transit in Waterloo is absent for a different reason: it answers, but its feed header was months stale and it publishes no per-vehicle timestamps, so it would render vehicles that look live and are not. Ottawa’s OC Transpo falls to the same keyless admission rule as GO Transit — its realtime feed requires an API key. London Transit and Thunder Bay Transit publish vehicle positions over plain HTTP with no HTTPS endpoint available. Every other Ontario system — Brampton, Oakville, Niagara, Milton, Windsor, Greater Sudbury, UP Express and a dozen smaller operators — publishes static GTFS schedules only, with no realtime vehicle positions to register. Between the nine included and these exclusions, every Ontario realtime vehicle-position feed catalogued in the Mobility Database is accounted for.
 - **Radio country coverage (optional).** Set `RADIO_PRIORITY_COUNTRIES=IN,PL` in the local `.env` and restart to include stations beyond the global click charts. The operator may choose up to eight unique ISO alpha-2 country codes; no key is needed. Each country adds one bounded query (at most 200 rows) and reserves up to 40 unique, usable stations inside the existing 750-station catalog. Country seeds precede specialist-tag seeds and global popularity fill; unused slots return to the shared pool. This is a coverage preference, not an exhaustive national directory or a guarantee of stations in every city. Countries with no eligible HTTPS MP3/AAC geolocated stations remain empty. An unset list preserves global selection. Country requests share the directory cache and three-worker pool; failed country queries are reported in coverage without blocking a healthy global refresh. Failed/degraded refreshes back off for one minute, with at most three mirrors per query.
 
 - **Radio Browser.** In every installation, including when `RADIO_PRIORITY_COUNTRIES` is unset, each request tries at most three mirror candidates (later fallback candidates are skipped), and failed or partial catalog refreshes back off for 60 seconds. A cold-start failure therefore continues returning 503 during that delay even if upstream recovers. `/api/radio/stations` discovers official API mirrors, makes bounded and coalesced healthy/geolocated HTTPS-station queries, caches the normalized public-domain directory for 45 minutes, and may serve the last good catalog for up to seven days during an outage. Refreshes must meet minimum accepted-query and station coverage before replacing a warm catalog; broad/specialist responses whose rows all fail the product's health policy do not count as successful queries. Optional priority-country outcomes are advisory: valid, in-limit responses with no eligible stations succeed as empty results, while failed or malformed country queries report unsuccessful coverage without degrading the global catalog. A usable partial cold catalog is explicitly `DEGRADED`, and non-array or empty broad/specialist payloads are rejected atomically. Individual structurally malformed rows are skipped rather than failing the whole query; the response carries their bounded `rejectedStationCount` (at most 10,000), which the client adds to its own rejected rows and reports as degraded coverage without discarding the accepted generation. Every directory and click-count request rejects redirects, validates all resolved addresses as globally routable (including reserved/documentation IPv4 and special/non-global IPv6 exclusions), and pins the TLS connection to a validated address. Only MP3/AAC non-HLS directory rows with public HTTPS stream targets are returned; favicons are intentionally omitted. Pressing play connects one browser audio element directly to the selected broadcaster and calls the directory's click counter through known-ID-only `POST /api/radio/click/:uuid`. GEV never proxies, caches, records, bundles, or redistributes audio. Radio Browser supplies station-level tags, not dependable current-song or upcoming-program metadata, so Radio filtering never claims either. Direct playback exposes the listener's IP address to the broadcaster, whose own stream terms apply.
diff --git a/README.md b/README.md
index fff61fd9f..f8b280c6d 100644
--- a/README.md
+++ b/README.md
@@ -444,7 +444,7 @@ Twenty-one layers and map sources. **Nineteen have a keyless path.** Some offer
 | 📷 **Mapped ALPR Cameras**  | License-plate-reader camera locations tagged by OpenStreetMap contributors, loaded one city-sized view at a time, with **SHOW NEAREST**. Locations and tags only: no plate data, no video                                                                                                                                                                                           | OpenStreetMap (incl. DeFlock mapping)   | 🟢                                                                                                  |
 | 📷 **Street Level**         | Street-level photos behind one panel, one chip per provider: coverage on the streets, image cones, an embedded viewer with full-screen **EXPAND**. Mapillary, Google Street View, KartaView and Panoramax | Mapillary · Google · KartaView · Panoramax | 🟢 KartaView, Panoramax · 🟡 Mapillary token · 🔴 Google Maps key |
 | 📻 **Radio**                | Geolocated world radio with an **analog tuner** — drag the needle across up to 750 stations and the globe flies to each broadcaster                                                                                                                                                                                                                                                 | Radio Browser / broadcasters            | 🟢                                                                                                  |
-| 🚌 **Transit**              | Live buses, trams, metros, trains and ferries with delayed playback between reports, selected-vehicle trails, and mode-coloured DETECT labels — Boston, Austin, Minneapolis, Helsinki, the Netherlands, Norway, South East Queensland, Rio de Janeiro (buses and BRT), Szczecin, Lisbon, and nine in Ontario: Toronto (surface vehicles; the subway publishes no positions), Mississauga, Hamilton, Durham Region, York Region, Guelph, Burlington, Barrie and Kingston                                                                                                                                               | Operator GTFS-Realtime feeds            | 🟢                                                                                                  |
+| 🚌 **Transit**              | Live buses, trams, metros, trains and ferries with delayed playback between reports, selected-vehicle trails, and mode-coloured DETECT labels — Boston, Austin, Minneapolis, Helsinki, the Netherlands, Norway, South East Queensland, Rio de Janeiro (buses and BRT), Szczecin, Lisbon (Carris Metropolitana and the city’s Carris), Prague, Warsaw, Kraków, Poznań, Gdańsk, Rzeszów, Vilnius, Bucharest, Cluj-Napoca, Iași, Rome, Turin, Venice (buses and waterbuses), Bordeaux, Montpellier, Rouen, Toulon, Le Havre, Tours, Málaga, Sendai, Johor Bahru, Kota Bharu, Adelaide, Atlanta, Denver, Edmonton, Halifax, Victoria, and nine in Ontario: Toronto (surface vehicles; the subway publishes no positions), Mississauga, Hamilton, Durham Region, York Region, Guelph, Burlington, Barrie and Kingston                                                                                                                                               | Operator GTFS-Realtime feeds            | 🟢                                                                                                  |
 | 🚲 **Bikeshare**            | Live station availability                                                                                                                                                                                                                                                                                                                                                           | GBFS                                    | 🟢                                                                                                  |
 | 🧭 **Directions**           | Click A and B on the globe for a street-following drive, walk or cycle route draped on the terrain with turn-by-turn steps — then FLY the camera along it. No key, no geocoder, no mic                                                                                                                                                                                              | OSRM on FOSSGIS servers (OpenStreetMap) | 🟢                                                                                                  |
 | ⌖ **OSM Places**           | Voice place search ("hospitals in Kathmandu") from OpenStreetMap, drawn as numbered points that follow-up questions can filter. Needs your own Overpass server (`OVERPASS_UPSTREAMS`); off otherwise                                                                                                                                                                                                                                                                                                                               |
diff --git a/changelog.d/szczecin-lisbon-transit.md b/changelog.d/szczecin-lisbon-transit.md
deleted file mode 100644
index 103657e8f..000000000
--- a/changelog.d/szczecin-lisbon-transit.md
+++ /dev/null
@@ -1,6 +0,0 @@
-- Add Szczecin, Poland and the Lisbon Metropolitan Area to the Transit layer.
-  Szczecin's buses and trams come from ZDiTM's keyless feed under CC0 1.0; it
-  carries no route ids, so vehicles show as buses. Lisbon's buses come from
-  Carris Metropolitana's keyless feed, which states no licence of its own and
-  is credited as a courtesy like Metro Transit and OVapi; its km/h speeds are
-  converted to m/s and its route ids read as the line number (IMBrandao).
diff --git a/changelog.d/transit-more-cities.md b/changelog.d/transit-more-cities.md
new file mode 100644
index 000000000..3e72ebebb
--- /dev/null
+++ b/changelog.d/transit-more-cities.md
@@ -0,0 +1,11 @@
+- Add 34 keyless feeds to the Transit layer, the first in Central and Eastern
+  Europe, Italy, Spain, France, Japan and Malaysia: Szczecin, Lisbon (Carris
+  Metropolitana and the city's Carris), Prague, Warsaw, Kraków, Poznań,
+  Gdańsk, Rzeszów, Vilnius, Bucharest, Cluj-Napoca, Iași, Rome, Turin, Venice
+  (buses and waterbuses), Bordeaux, Montpellier, Rouen, Toulon, Le Havre,
+  Tours, Málaga, Sendai, Johor Bahru, Kota Bharu, Adelaide, Atlanta, Denver,
+  Edmonton, Halifax and Victoria. Each feed records its licence, or that none
+  is stated, in the registry and DATA_SOURCES.md. Speeds published in km/h
+  (Lisbon, Montpellier, Toulon) are converted to m/s by the proxy; route ids
+  read as the line on the vehicle; Prague, Bordeaux and Le Havre trams and
+  Venice waterbuses take their own mode (IMBrandao).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index b5820c6b5..f9f1f8d30 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4644,9 +4644,9 @@ Transit is off by default, and share links use token `j`. The movement panel ord
 places Transit directly after Street Traffic and before Bike Share. Cameras and
 utilities retain their own groups. The layer polls
 registered feeds near the camera every 15 seconds, below a 3,000 km altitude
-gate. Nineteen keyless regions are available: Boston, Austin, Minneapolis–St Paul,
+gate. Forty-nine keyless regions are available: Boston, Austin, Minneapolis–St Paul,
 Helsinki, the Netherlands, Norway, South East Queensland, Rio de Janeiro
-(municipal buses and the Mobi-Rio BRT, two feeds), Szczecin, the Lisbon Metropolitan Area, and nine in
+(municipal buses and the Mobi-Rio BRT, two feeds), Szczecin, the Lisbon Metropolitan Area and the city of Lisbon, Prague and Central Bohemia, Warsaw, Kraków (buses and trams, two feeds), Poznań, Gdańsk, Rzeszów, Vilnius, Bucharest, Cluj-Napoca, Iași, Rome, Turin, Venice (buses and waterbuses, two feeds), Bordeaux, Montpellier, Rouen, Toulon, Le Havre, Tours, Málaga, Sendai, Johor Bahru, Kota Bharu, Adelaide, Atlanta, Denver, Edmonton, Halifax, Victoria, and nine in
 Ontario — Toronto (TTC surface vehicles; the subway publishes no
 positions), MiWay, Hamilton HSR, Durham Region, YRT/Viva, Guelph,
 Burlington, Barrie and Kingston. Mode silhouettes
diff --git a/src/data/transitFeeds.js b/src/data/transitFeeds.js
index 7515b8417..5ac28d5da 100644
--- a/src/data/transitFeeds.js
+++ b/src/data/transitFeeds.js
@@ -402,6 +402,86 @@ function carrisMetropolitanaRouteLabel(routeId) {
   return match ? match[1] : routeId;
 }
 
+/**
+ * Route ids that wrap the rider-facing line in a fixed prefix, suffix or
+ * zero-padding. The returned function yields the captured line, or the id
+ * unchanged when it does not match the operator's pattern.
+ * @param {RegExp} pattern One capture group: the line a rider would say.
+ * @returns {(routeId: string|null) => string|null}
+ */
+function routeIdPattern(pattern) {
+  return (routeId) => {
+    const match = pattern.exec(routeId ?? '');
+    return match ? match[1] : routeId;
+  };
+}
+
+/** Prague PID: `L125` is line 125. */
+const pidRouteLabel = routeIdPattern(/^L(\d+)$/);
+/** Zero-padded numbers (Edmonton `005`, Toulon `0002`, Bordeaux `01`). */
+const unpaddedRouteLabel = routeIdPattern(/^0+(\d+\w*)$/);
+/** Turin GTT appends `U` (urban) to the line: `10NU` is night line 10N. */
+const gttRouteLabel = routeIdPattern(/^(\w+?)U$/);
+/** Venice ACTV appends the network: `5.1_UN` is waterbus line 5.1, `53E_ES` bus 53E. */
+const actvRouteLabel = routeIdPattern(/^(.+)_[A-Z]{2}$/);
+/** BC Transit appends the system: `95-VIC` is Victoria route 95. */
+const bcTransitRouteLabel = routeIdPattern(/^(.+)-VIC$/);
+/** Carris (Lisbon city) appends a variant: `172_1` is route 172. */
+const carrisRouteLabel = routeIdPattern(/^(\w+)_\d+$/);
+/** bus-tracker.fr prefixes the network: `TCAR:93` is Rouen line 93. */
+const busTrackerRouteLabel = routeIdPattern(/^[A-Z]+:(.+)$/);
+/** BAS.MY Johor appends a fixed operator code: `J33CWLMYJB` is route J33. */
+const mybasJohorRouteLabel = routeIdPattern(/^(.+?)CWLMYJB$/);
+
+/**
+ * Le Havre LiA runs its two tram lines as A and B; every other line is a bus.
+ * @param {string|null} routeId
+ * @returns {string}
+ */
+function liaRouteMode(routeId) {
+  if (!routeId) return 'unknown';
+  return /^(?:[A-Z]+:)?[AB]$/.test(routeId) ? 'tram' : 'bus';
+}
+
+/**
+ * Prague PID numbers its day and night trams below 100 and its buses from 100
+ * up; anything else (rail, ferries, the funicular) is left unresolved.
+ * @param {string|null} routeId
+ * @returns {string}
+ */
+function pidRouteMode(routeId) {
+  const match = /^L(\d+)$/.exec(routeId ?? '');
+  if (!match) return 'unknown';
+  return Number(match[1]) < 100 ? 'tram' : 'bus';
+}
+
+/**
+ * Bordeaux TBM runs trams on lettered lines A–D; every numbered line is a bus.
+ * @param {string|null} routeId
+ * @returns {string}
+ */
+function tbmRouteMode(routeId) {
+  if (!routeId) return 'unknown';
+  return /^[A-D]$/.test(routeId) ? 'tram' : 'bus';
+}
+
+/**
+ * A registry entry, frozen with its centre and terms, and switched on.
+ * @param {object} fields
+ * @returns {Readonly<object>}
+ */
+function transitFeed(fields) {
+  return Object.freeze({
+    defaultEnabled: true,
+    ...fields,
+    center: Object.freeze({ ...fields.center }),
+    terms: Object.freeze({ ...fields.terms }),
+    ...(fields.headers
+      ? { headers: Object.freeze({ ...fields.headers }) }
+      : {}),
+  });
+}
+
 /**
  * Registry of feeds. Order is presentation order in the stats/credit text.
  * `loadRadiusKm` is the distance from `center` inside which the feed is polled.
@@ -850,6 +930,562 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     routeLabel: carrisMetropolitanaRouteLabel,
     speedUnit: 'km/h',
   }),
+  transitFeed({
+    id: 'pid-praha',
+    name: 'Prague PID',
+    operator: 'Pražská integrovaná doprava (PID), via Golemio',
+    region: 'Prague and Central Bohemia, Czechia',
+    // PID reaches across Central Bohemia: on 2026-11-08, 95% of 923 vehicles
+    // sat within 58 km of Prague, the farthest at 98 km.
+    center: { lat: 50.08, lon: 14.45 },
+    loadRadiusKm: 60,
+    url: 'https://api.golemio.cz/v2/vehiclepositions/gtfsrt/vehicle_positions.pb',
+    license: 'CC BY',
+    licenseUrl: 'https://pid.cz/o-systemu/opendata/',
+    attribution: 'Pražská integrovaná doprava (PID) / Golemio',
+    terms: {
+      quote:
+        'Data, která lze stáhnout přímo zde z webu, jsou stejně jako celý obsah webu opatřena licencí CC-BY',
+      note: 'The PID open-data page lists this realtime feed and licenses the data it publishes under CC BY, crediting the author and any changes. The same page says data served from other sources follows that source’s licence; the feed is served by Golemio, the city’s data platform, which states none of its own. Keyless since the catalogue moved it off the X-Access-Token endpoint. Speeds are m/s, checked against movement on 2026-11-07. Route ids are `L` plus the line number; lines below 100 are trams.',
+    },
+    defaultMode: 'bus',
+    routeLabel: pidRouteLabel,
+    routeMode: pidRouteMode,
+  }),
+  transitFeed({
+    id: 'ztm-warszawa',
+    name: 'Warsaw buses and trams',
+    operator: 'Miasto Stołeczne Warszawa, relayed by mkuran.pl',
+    region: 'Warsaw, Poland',
+    center: { lat: 52.25, lon: 21.02 },
+    loadRadiusKm: 30,
+    url: 'https://mkuran.pl/gtfs/warsaw/vehicles.pb',
+    license: 'Warsaw Open Data Project Usage Terms',
+    licenseUrl: 'https://mkuran.pl/gtfs/',
+    attribution: 'Miasto Stołeczne Warszawa (api.um.warszawa.pl)',
+    terms: {
+      quote:
+        'The City Hall requires a credit by providing the name Miasto Stołeczne Warszawa, data download date (use the timestamp from the FeedHeader) and link to http://api.um.warszawa.pl.',
+      note: 'Positions come from the Warsaw City Hall API, repackaged as GTFS-RT by Mikołaj Kuranowski’s unofficial feed. The credit names the city and its API; the download date it asks for is the feed timestamp the layer already shows with each snapshot. Vehicle timestamps ran about two minutes old on 2026-11-07, which the delayed playback absorbs.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'tbm-bordeaux',
+    name: 'Bordeaux TBM',
+    operator: 'Transports Bordeaux Métropole (TBM), Bordeaux Métropole',
+    region: 'Bordeaux, France',
+    center: { lat: 44.85, lon: -0.65 },
+    loadRadiusKm: 20,
+    url: 'https://bdx.mecatran.com/utw/ws/gtfsfeed/vehicles/bordeaux?apiKey=opendata-bordeaux-metropole-flux-gtfs-rt',
+    license: 'Licence Ouverte / Etalab 2.0',
+    licenseUrl:
+      'https://transport.data.gouv.fr/datasets/offres-de-services-bus-tram-et-scolaire-au-format-gtfs-netex-gtfs-rt-siri-lite',
+    attribution: 'Bordeaux Métropole (TBM)',
+    terms: {
+      quote: 'licence: fr-lo',
+      note: 'The quote is the licence field of the national access point’s dataset record (fr-lo is the Licence Ouverte), which asks only for credit. The `apiKey` in the URL is not a credential: it is the same fixed string printed in the open-data listing for everyone. Speeds are m/s. Trams run on lettered lines A–D; numbered lines are buses.',
+    },
+    defaultMode: 'bus',
+    routeLabel: unpaddedRouteLabel,
+    routeMode: tbmRouteMode,
+  }),
+  transitFeed({
+    id: 'sendai-city-bus',
+    name: 'Sendai City Bus',
+    operator: 'Sendai City Transportation Bureau (仙台市交通局), via ODPT',
+    region: 'Sendai, Japan',
+    center: { lat: 38.27, lon: 140.82 },
+    loadRadiusKm: 22,
+    url: 'https://api-public.odpt.org/api/v4/gtfs/realtime/odpt_SendaiMunicipal_bus_realtime_information_vehicle',
+    license: 'CC BY 4.0',
+    licenseUrl: 'https://creativecommons.org/licenses/by/4.0/',
+    attribution: '仙台市交通局 (Sendai City Transportation Bureau) / ODPT',
+    terms: {
+      quote: 'https://creativecommons.org/licenses/by/4.0/',
+      note: 'Served by the Open Data Challenge for Public Transportation (ODPT) public API, which needs no key for this feed; the catalogue records CC BY 4.0 as its licence. Vehicle timestamps ran about two minutes old on 2026-11-07. Speeds are m/s.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'ztm-poznan',
+    name: 'Poznań buses and trams',
+    operator: 'Zarząd Transportu Miejskiego w Poznaniu (ZTM Poznań)',
+    region: 'Poznań, Poland',
+    center: { lat: 52.39, lon: 16.92 },
+    loadRadiusKm: 20,
+    url: 'https://www.ztm.poznan.pl/pl/dla-deweloperow/getGtfsRtFile/?file=vehicle_positions.pb',
+    license: 'ZTM Poznań open-data terms',
+    licenseUrl: 'https://www.ztm.poznan.pl/otwarte-dane/dla-deweloperow/',
+    attribution: 'Zarząd Transportu Miejskiego w Poznaniu (processed)',
+    terms: {
+      quote:
+        'Treści udostępniane są bezwnioskowo i bezpłatnie, na zasadach powszechnego dostępu i stanowią źródło informacji.',
+      note: 'Reuse is free on three conditions: name the source, give the date of the last update, and say the data were processed. The credit names ZTM and says processed; the snapshot timestamp is the update date. The feed carries no bearing, so heading comes from movement between fixes.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'ztm-gdansk',
+    name: 'Gdańsk buses and trams',
+    operator: 'Zarząd Transportu Miejskiego w Gdańsku (ZTM Gdańsk)',
+    region: 'Gdańsk, Poland',
+    center: { lat: 54.35, lon: 18.6 },
+    loadRadiusKm: 20,
+    url: 'https://ckan2.multimediagdansk.pl/gtfs-rt?feed=vehiclePositions',
+    license: 'CC BY 4.0',
+    licenseUrl:
+      'https://dane.gov.pl/pl/dataset/38599,rozklady-jazdy-i-lokalizacja-przystankow-gtfs-rt',
+    attribution: 'Zarząd Transportu Miejskiego w Gdańsku',
+    terms: {
+      note: 'The national catalogue (dane.gov.pl) lists this dataset under CC BY 4.0. No bearing; heading comes from movement. Speeds are m/s.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'ets-edmonton',
+    name: 'Edmonton Transit Service',
+    operator: 'City of Edmonton (Edmonton Transit Service)',
+    region: 'Edmonton, AB',
+    center: { lat: 53.53, lon: -113.52 },
+    loadRadiusKm: 25,
+    url: 'https://gtfs.edmonton.ca/TMGTFSRealTimeWebService/Vehicle/VehiclePositions.pb',
+    license: 'City of Edmonton Open Data Agreement',
+    licenseUrl:
+      'https://www.edmonton.ca/transportation/Web-version2.1-OpenDataAgreement.pdf',
+    attribution:
+      'Contains information licensed under the Open Data Agreement – City of Edmonton',
+    terms: {
+      note: 'The agreement is the same municipal template as Mississauga and Burlington: a licence to use, modify and distribute for any lawful purpose, in any medium. It was read from search excerpts; the PDF itself would not extract here. Route ids are zero-padded. Speeds are m/s.',
+    },
+    defaultMode: 'bus',
+    routeLabel: unpaddedRouteLabel,
+  }),
+  transitFeed({
+    id: 'halifax-transit',
+    name: 'Halifax Transit',
+    operator: 'Halifax Regional Municipality (Halifax Transit)',
+    region: 'Halifax, NS',
+    center: { lat: 44.7, lon: -63.6 },
+    loadRadiusKm: 22,
+    url: 'https://gtfs.halifax.ca/realtime/Vehicle/VehiclePositions.pb',
+    license: 'Halifax Open Data Licence',
+    licenseUrl: 'https://www.halifax.ca/home/open-data/open-data-licence',
+    attribution: 'Halifax Regional Municipality (Halifax Transit)',
+    terms: {
+      note: 'The catalogue points at Halifax’s open-data licence; the licence page renders only in a browser and was not quoted. Speeds are m/s.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'bc-transit-victoria',
+    name: 'Victoria Regional Transit',
+    operator: 'BC Transit (Victoria Regional Transit System)',
+    region: 'Victoria, BC',
+    center: { lat: 48.53, lon: -123.43 },
+    loadRadiusKm: 28,
+    url: 'https://bct.tmix.se/gtfs-realtime/vehicleupdates.pb?operatorIds=48',
+    license: 'BC Transit Open Data Terms of Use',
+    licenseUrl: 'https://www.bctransit.com/open-data/terms-of-use',
+    attribution: 'BC Transit',
+    terms: {
+      quote:
+        'BC Transit grants you a limited, revocable and non-exclusive license to use, reproduce, and redistribute the Data in accordance with these Terms.',
+      note: 'The grant is revocable, like the Ontario municipal templates. Route ids carry a `-VIC` system suffix. Speeds are m/s.',
+    },
+    defaultMode: 'bus',
+    routeLabel: bcTransitRouteLabel,
+  }),
+  transitFeed({
+    id: 'tam-montpellier',
+    name: 'Montpellier TaM',
+    operator: 'Montpellier Méditerranée Métropole (TaM)',
+    region: 'Montpellier, France',
+    center: { lat: 43.61, lon: 3.87 },
+    loadRadiusKm: 20,
+    url: 'https://gtfsproxy.e-tam.fr/COMMON/VehiclePosition.pb',
+    license: 'ODbL',
+    licenseUrl:
+      'https://transport.data.gouv.fr/datasets/offre-de-transport-tam-en-temps-reel-gtfs-rt-urbain-et-suburbain',
+    attribution: 'Montpellier Méditerranée Métropole (TaM)',
+    terms: {
+      quote: 'licence: odc-odbl',
+      note: 'The quote is the dataset record’s licence field. ODbL asks for credit and share-alike on a derived database; the layer redistributes no database, it draws the positions. Speeds are km/h: readings ran 3.3 times the measured movement on 2026-11-07, so the proxy converts them.',
+    },
+    defaultMode: 'bus',
+    speedUnit: 'km/h',
+  }),
+  transitFeed({
+    id: 'ztp-krakow-bus',
+    name: 'Kraków buses',
+    operator: 'Zarząd Transportu Publicznego w Krakowie (ZTP Kraków)',
+    region: 'Kraków, Poland',
+    center: { lat: 50.06, lon: 19.94 },
+    loadRadiusKm: 22,
+    url: 'https://gtfs.ztp.krakow.pl/VehiclePositions_A.pb',
+    license: 'No licence stated',
+    licenseUrl: 'https://gtfs.ztp.krakow.pl/',
+    attribution: 'Zarząd Transportu Publicznego w Krakowie',
+    terms: {
+      note: 'ZTP publishes this feed keyless on its own GTFS server and lists it in the Mobility Database, but states no licence there or on dane.gov.pl. Shipped on the same basis as Metro Transit and OVapi; switch it off if ZTP objects.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'ztp-krakow-tram',
+    name: 'Kraków trams',
+    operator: 'Zarząd Transportu Publicznego w Krakowie (ZTP Kraków)',
+    region: 'Kraków, Poland',
+    center: { lat: 50.06, lon: 19.94 },
+    loadRadiusKm: 22,
+    url: 'https://gtfs.ztp.krakow.pl/VehiclePositions_T.pb',
+    license: 'No licence stated',
+    licenseUrl: 'https://gtfs.ztp.krakow.pl/',
+    attribution: 'Zarząd Transportu Publicznego w Krakowie',
+    terms: { note: 'Same server and basis as the bus feed.' },
+    defaultMode: 'tram',
+  }),
+  transitFeed({
+    id: 'vilnius-transport',
+    name: 'Vilnius public transport',
+    operator: 'SĮ Susisiekimo paslaugos, Vilnius',
+    region: 'Vilnius, Lithuania',
+    center: { lat: 54.69, lon: 25.28 },
+    loadRadiusKm: 20,
+    url: 'https://www.stops.lt/vilnius/vehicle_positions.pb',
+    license: 'No licence stated',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2383',
+    attribution: 'SĮ Susisiekimo paslaugos (stops.lt)',
+    terms: {
+      note: 'Published keyless by the city transport agency on stops.lt; no licence found. Shipped on the same basis as Metro Transit and OVapi. Answered 522 once on 2026-11-07 and normally since.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'tpbi-bucuresti',
+    name: 'Bucharest public transport',
+    operator: 'Asociația de Dezvoltare Intercomunitară TPBI, Bucharest–Ilfov',
+    region: 'Bucharest, Romania',
+    center: { lat: 44.43, lon: 26.1 },
+    loadRadiusKm: 25,
+    url: 'https://gtfs.tpbi.ro/api/gtfs-rt/vehiclePositions',
+    license: 'No licence stated',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2104',
+    attribution: 'TPBI (Transport Public București–Ilfov)',
+    terms: {
+      note: 'Keyless public endpoint from the metropolitan transport authority; no licence found. Same basis as Metro Transit and OVapi.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'roma-mobilita',
+    name: 'Rome public transport',
+    operator: 'Roma Servizi per la Mobilità',
+    region: 'Rome, Italy',
+    center: { lat: 41.89, lon: 12.5 },
+    loadRadiusKm: 35,
+    url: 'https://romamobilita.it/wp-content/uploads/shared/rome_rtgtfs_vehicle_positions_feed.pb',
+    license: 'No licence stated',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1776',
+    attribution: 'Roma Servizi per la Mobilità',
+    terms: {
+      note: 'Keyless file on the agency’s own site; the catalogue’s older `/sites/default/files/` path now 404s. No licence found; same basis as Metro Transit and OVapi. Fewer than one vehicle in five carries a bearing, so most headings come from movement.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'gtt-torino',
+    name: 'Turin GTT',
+    operator: 'Gruppo Torinese Trasporti (GTT)',
+    region: 'Turin, Italy',
+    center: { lat: 45.07, lon: 7.68 },
+    loadRadiusKm: 20,
+    url: 'https://percorsieorari.gtt.to.it/das_gtfsrt/vehicle_position.aspx',
+    license: 'No licence stated',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2696',
+    attribution: 'Gruppo Torinese Trasporti (GTT)',
+    terms: {
+      note: 'Official keyless endpoint; no licence found. Same basis as Metro Transit and OVapi. Route ids append `U` for urban lines.',
+    },
+    defaultMode: 'bus',
+    routeLabel: gttRouteLabel,
+  }),
+  transitFeed({
+    id: 'actv-venezia-bus',
+    name: 'Venice ACTV buses',
+    operator: 'Azienda del Consorzio Trasporti Veneziano (ACTV)',
+    region: 'Venice, Italy',
+    center: { lat: 45.4, lon: 12.2 },
+    loadRadiusKm: 38,
+    url: 'https://tpl.actv.it/aut/GTFSRT/vehiclePositions',
+    license: 'ACTV open-data catalogue',
+    licenseUrl:
+      'https://actv.avmspa.it/it/content/catalogo-dei-dati-metadati-e-banche-dati-actv',
+    attribution: 'ACTV S.p.A.',
+    terms: {
+      note: 'ACTV lists this feed in its own open-data catalogue; that page would not render for a script, so its licence is not quoted. Same basis as Metro Transit and OVapi. Route ids append a two-letter network code (`_UM`, `_ES`, `_UN`).',
+    },
+    defaultMode: 'bus',
+    routeLabel: actvRouteLabel,
+  }),
+  transitFeed({
+    id: 'actv-venezia-waterbus',
+    name: 'Venice ACTV waterbuses',
+    operator: 'Azienda del Consorzio Trasporti Veneziano (ACTV) Navigazione',
+    region: 'Venice, Italy',
+    center: { lat: 45.43, lon: 12.33 },
+    loadRadiusKm: 15,
+    url: 'https://tpl.actv.it/nav/GTFSRT/vehiclePositions',
+    license: 'ACTV open-data catalogue',
+    licenseUrl:
+      'https://actv.avmspa.it/it/content/catalogo-dei-dati-metadati-e-banche-dati-actv',
+    attribution: 'ACTV S.p.A.',
+    terms: { note: 'Same catalogue and basis as the ACTV bus feed.' },
+    defaultMode: 'ferry',
+    routeLabel: actvRouteLabel,
+  }),
+  transitFeed({
+    id: 'adelaide-metro',
+    name: 'Adelaide Metro',
+    operator: 'Adelaide Metro (Government of South Australia)',
+    region: 'Adelaide, SA',
+    center: { lat: -34.93, lon: 138.6 },
+    loadRadiusKm: 35,
+    url: 'https://gtfs.adelaidemetro.com.au/v1/realtime/vehicle_positions',
+    // Any Accept naming a protobuf type gets base64 text labelled JSON; only
+    // */* returns the binary feed (checked 2026-11-08).
+    headers: { Accept: '*/*' },
+    license: 'No licence stated for the realtime feed',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1772',
+    attribution: 'Adelaide Metro',
+    terms: {
+      note: 'Official keyless endpoint; the state catalogue page refused automated reads, so no licence is quoted. Same basis as Metro Transit and OVapi. Speeds are m/s. The server picks its encoding from Accept, hence the override.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'marta-atlanta',
+    name: 'MARTA buses',
+    operator: 'Metropolitan Atlanta Rapid Transit Authority (MARTA)',
+    region: 'Atlanta, GA',
+    center: { lat: 33.78, lon: -84.39 },
+    loadRadiusKm: 35,
+    url: 'https://gtfs-rt.itsmarta.com/TMGTFSRealTimeWebService/vehicle/vehiclepositions.pb',
+    license: 'No licence stated',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1601',
+    attribution: 'MARTA',
+    terms: {
+      note: 'Official keyless endpoint; no licence found. Same basis as Metro Transit and OVapi. Speeds are m/s.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'rtd-denver',
+    name: 'Denver RTD',
+    operator: 'Regional Transportation District (RTD), Denver',
+    region: 'Denver, CO',
+    center: { lat: 39.75, lon: -104.99 },
+    loadRadiusKm: 55,
+    url: 'https://open-data.rtd-denver.com/files/gtfs-rt/rtd/VehiclePosition.pb',
+    license: 'RTD GTFS-realtime licence agreement',
+    licenseUrl:
+      'https://www.rtd-denver.com/business-center/open-spatial-data/gtfs-realtime-license-agreement',
+    attribution: 'Regional Transportation District (RTD)',
+    terms: {
+      note: 'RTD links a licence agreement for its realtime feeds; the page refused automated reads (403), so it is not quoted. The feed itself is keyless. Speeds are m/s.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'ctp-cluj',
+    name: 'Cluj-Napoca CTP',
+    operator: 'Compania de Transport Public Cluj-Napoca',
+    region: 'Cluj-Napoca, Romania',
+    center: { lat: 46.77, lon: 23.59 },
+    loadRadiusKm: 15,
+    url: 'https://cluj-rt-feed.gtfs.ro/vehiclePositions',
+    license: 'No licence stated',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2614',
+    attribution: 'Compania de Transport Public Cluj-Napoca',
+    terms: {
+      note: 'Keyless; no licence found. Same basis as Metro Transit and OVapi.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'ctp-iasi',
+    name: 'Iași CTP',
+    operator: 'Compania de Transport Public Iași',
+    region: 'Iași, Romania',
+    center: { lat: 47.16, lon: 27.59 },
+    loadRadiusKm: 15,
+    url: 'https://iasi-rt-feed.gtfs.ro/vehiclePositions',
+    license: 'No licence stated',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2118',
+    attribution: 'Compania de Transport Public Iași',
+    terms: {
+      note: 'Keyless; no licence found. Same basis as Metro Transit and OVapi.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'mpk-rzeszow',
+    name: 'Rzeszów city transport',
+    operator: 'Rzeszowski Transport Miejski (MPK Rzeszów)',
+    region: 'Rzeszów, Poland',
+    center: { lat: 50.04, lon: 22.0 },
+    loadRadiusKm: 15,
+    url: 'https://www.mpkrzeszow.pl/gtfs/rt/gtfsrt.pb',
+    license: 'MPK Rzeszów open data',
+    licenseUrl: 'https://www.mpkrzeszow.pl/otwartedane/',
+    attribution: 'MPK Rzeszów',
+    terms: {
+      note: 'Listed on the operator’s open-data page, which names no licence. No bearing; heading comes from movement.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'emt-malaga',
+    name: 'Málaga EMT',
+    operator: 'Empresa Malagueña de Transportes (EMT)',
+    region: 'Málaga, Spain',
+    center: { lat: 36.72, lon: -4.42 },
+    loadRadiusKm: 15,
+    url: 'https://gtfs.emtmalaga.es/GTFSRTapi/api/vehicleposition',
+    license: 'No licence stated',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2213',
+    attribution: 'EMT Málaga',
+    terms: {
+      note: 'Keyless; no licence found. Same basis as Metro Transit and OVapi. No bearing; heading comes from movement.',
+    },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'carris-lisboa',
+    name: 'Carris (Lisbon city)',
+    operator: 'Carris – Companhia Carris de Ferro de Lisboa',
+    region: 'Lisbon, Portugal',
+    center: { lat: 38.74, lon: -9.15 },
+    loadRadiusKm: 15,
+    url: 'https://gateway.carris.pt/gateway/gtfs/api/v2.11/GTFS/realtime/vehiclepositions',
+    license: 'No licence stated',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2930',
+    attribution: 'Carris',
+    terms: {
+      note: 'Keyless official gateway; no licence found. Same basis as Metro Transit and OVapi. Carries neither bearing nor speed, and vehicle reports run about a minute old. Route ids append a variant.',
+    },
+    defaultMode: 'bus',
+    routeLabel: carrisRouteLabel,
+  }),
+  transitFeed({
+    id: 'mybas-johor',
+    name: 'BAS.MY Johor Bahru',
+    operator: 'BAS.MY, via data.gov.my',
+    region: 'Johor Bahru, Malaysia',
+    center: { lat: 1.51, lon: 103.75 },
+    loadRadiusKm: 35,
+    url: 'https://api.data.gov.my/gtfs-realtime/vehicle-position/mybas-johor/',
+    license: 'No licence stated for the feed',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-3174',
+    attribution: 'BAS.MY / data.gov.my',
+    terms: {
+      note: 'Served keyless by Malaysia’s national open-data API; no licence for the feed was found. Same basis as Metro Transit and OVapi. Without the trailing slash the API redirects. Route ids append an operator code.',
+    },
+    defaultMode: 'bus',
+    routeLabel: mybasJohorRouteLabel,
+  }),
+  transitFeed({
+    id: 'mybas-kota-bharu',
+    name: 'BAS.MY Kota Bharu',
+    operator: 'BAS.MY, via data.gov.my',
+    region: 'Kota Bharu, Malaysia',
+    // Routes run south into Kelantan: 95% of vehicles within 58 km on 2026-11-08.
+    center: { lat: 6.06, lon: 102.22 },
+    loadRadiusKm: 60,
+    url: 'https://api.data.gov.my/gtfs-realtime/vehicle-position/mybas-kota-bharu/',
+    license: 'No licence stated for the feed',
+    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-3169',
+    attribution: 'BAS.MY / data.gov.my',
+    terms: { note: 'Same API and basis as Johor Bahru.' },
+    defaultMode: 'bus',
+  }),
+  transitFeed({
+    id: 'astuce-rouen',
+    name: 'Rouen Astuce',
+    operator: 'Métropole Rouen Normandie (Astuce), relayed by bus-tracker.fr',
+    region: 'Rouen, France',
+    center: { lat: 49.44, lon: 1.1 },
+    loadRadiusKm: 20,
+    url: 'https://gtfs.bus-tracker.fr/gtfs-rt/tcar/?tcar=1&tae=1&tni=1',
+    license: 'Licence Ouverte 2.0',
+    licenseUrl:
+      'https://transport.data.gouv.fr/datasets/donnees-statiques-et-temps-reel-du-reseau-astuce-metropole-rouen-normandie',
+    attribution: 'Métropole Rouen Normandie (Astuce) / bus-tracker.fr',
+    terms: {
+      quote: 'licence: lov2',
+      note: 'The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted); this registry reads it through bus-tracker.fr, an unofficial relay that merges the city’s networks into one GTFS-RT file. Route ids carry the network prefix (`TCAR:`).',
+    },
+    defaultMode: 'bus',
+    routeLabel: busTrackerRouteLabel,
+  }),
+  transitFeed({
+    id: 'mpm-toulon',
+    name: 'Toulon Mistral',
+    operator: 'Métropole Toulon Provence Méditerranée (réseau Mistral)',
+    region: 'Toulon, France',
+    center: { lat: 43.12, lon: 5.94 },
+    loadRadiusKm: 18,
+    url: 'https://feed-rdtpm-toulon.ratpdev.com/VehiclePosition/GTFS-RT',
+    license: 'Licence Ouverte 2.0',
+    licenseUrl:
+      'https://transport.data.gouv.fr/datasets/reseau-de-transport-urbain-de-la-metropole-toulon-provence-mediterranee',
+    attribution: 'Métropole Toulon Provence Méditerranée (Mistral)',
+    terms: {
+      quote: 'licence: lov2',
+      note: 'Dataset record’s licence field quoted. Speeds are km/h: readings ran 3.5 times the measured movement on 2026-11-07, so the proxy converts them. Route ids are zero-padded.',
+    },
+    defaultMode: 'bus',
+    routeLabel: unpaddedRouteLabel,
+    speedUnit: 'km/h',
+  }),
+  transitFeed({
+    id: 'lia-le-havre',
+    name: 'Le Havre LiA',
+    operator: 'Le Havre Seine Métropole (LiA), relayed by bus-tracker.fr',
+    region: 'Le Havre, France',
+    center: { lat: 49.49, lon: 0.11 },
+    loadRadiusKm: 18,
+    url: 'https://gtfs.bus-tracker.fr/gtfs-rt/lia/vehicle-positions',
+    license: 'ODbL',
+    licenseUrl:
+      'https://transport.data.gouv.fr/datasets/reseau-de-transport-en-commun-lia-gtfs-siri',
+    attribution: 'Le Havre Seine Métropole (LiA) / bus-tracker.fr',
+    terms: {
+      quote: 'licence: odc-odbl',
+      note: 'The network publishes under ODbL (dataset record quoted); read through the bus-tracker.fr relay, which converts its SIRI feed to GTFS-RT. The layer draws positions and redistributes no database. Lines A and B are the tramway.',
+    },
+    defaultMode: 'bus',
+    routeLabel: busTrackerRouteLabel,
+    routeMode: liaRouteMode,
+  }),
+  transitFeed({
+    id: 'filbleu-tours',
+    name: 'Tours Fil Bleu',
+    operator: 'Syndicat des Mobilités de Touraine (Fil Bleu)',
+    region: 'Tours, France',
+    center: { lat: 47.39, lon: 0.69 },
+    loadRadiusKm: 18,
+    url: 'https://data.filbleu.fr/ws-tr/gtfs-rt/opendata/vehicle-positions',
+    license: 'Licence Ouverte 2.0',
+    licenseUrl:
+      'https://transport.data.gouv.fr/datasets/fil-bleu-syndicat-des-mobilites-gtfs-gtfs-rt',
+    attribution: 'Fil Bleu – Syndicat des Mobilités de Touraine',
+    terms: {
+      quote: 'licence: lov2',
+      note: 'Dataset record’s licence field quoted.',
+    },
+    defaultMode: 'bus',
+  }),
 ]);
 
 /**
diff --git a/src/data/transitFeeds.test.mjs b/src/data/transitFeeds.test.mjs
index 0e3d4ab37..8afe6ea8b 100644
--- a/src/data/transitFeeds.test.mjs
+++ b/src/data/transitFeeds.test.mjs
@@ -611,3 +611,111 @@ test('Carris Metropolitana route ids read as the line number on the bus', () =>
   assert.equal(transitRouteLabel(feed, 'unexpected'), 'unexpected');
   assert.equal(transitRouteLabel(feed, null), null);
 });
+
+// The 2026-11 batch: one landmark per feed, inside its own radius.
+const NEW_CITY_LANDMARKS = {
+  'pid-praha': [50.0875, 14.4213],
+  'ztm-warszawa': [52.2297, 21.0122],
+  'tbm-bordeaux': [44.8378, -0.5792],
+  'sendai-city-bus': [38.2602, 140.8824],
+  'ztm-poznan': [52.4064, 16.9252],
+  'ztm-gdansk': [54.352, 18.6466],
+  'ets-edmonton': [53.5461, -113.4938],
+  'halifax-transit': [44.6488, -63.5752],
+  'bc-transit-victoria': [48.4284, -123.3656],
+  'tam-montpellier': [43.6108, 3.8767],
+  'ztp-krakow-bus': [50.0614, 19.9366],
+  'ztp-krakow-tram': [50.0614, 19.9366],
+  'vilnius-transport': [54.6872, 25.2797],
+  'tpbi-bucuresti': [44.4268, 26.1025],
+  'roma-mobilita': [41.9028, 12.4964],
+  'gtt-torino': [45.0703, 7.6869],
+  'actv-venezia-bus': [45.4408, 12.3155],
+  'actv-venezia-waterbus': [45.4408, 12.3155],
+  'adelaide-metro': [-34.9285, 138.6007],
+  'marta-atlanta': [33.749, -84.388],
+  'rtd-denver': [39.7392, -104.9903],
+  'ctp-cluj': [46.7712, 23.6236],
+  'ctp-iasi': [47.1585, 27.6014],
+  'mpk-rzeszow': [50.0412, 21.9991],
+  'emt-malaga': [36.7213, -4.4214],
+  'carris-lisboa': [38.7223, -9.1393],
+  'mybas-johor': [1.4927, 103.7414],
+  'mybas-kota-bharu': [6.1254, 102.2381],
+  'astuce-rouen': [49.4432, 1.0999],
+  'mpm-toulon': [43.1242, 5.928],
+  'lia-le-havre': [49.4944, 0.1079],
+  'filbleu-tours': [47.3941, 0.6848],
+};
+
+test('every city in the 2026-11 batch is live, licensed and covers its own centre', () => {
+  for (const [id, [lat, lon]] of Object.entries(NEW_CITY_LANDMARKS)) {
+    const feed = getTransitFeed(id);
+    assert.ok(feed, `${id} is routable`);
+    assert.ok(
+      publicTransitCatalog().some((f) => f.id === id),
+      `${id} is offered to the browser`,
+    );
+    assert.ok(feed.terms?.note, `${id} records the basis it ships on`);
+    assert.ok(
+      transitFeedsInRange(lat, lon).some((f) => f.id === id),
+      `${id} covers its city`,
+    );
+  }
+  // A feed's radius stays local: Warsaw is not polled for Kraków.
+  assert.ok(
+    !transitFeedsInRange(50.0614, 19.9366).some((f) => f.id === 'ztm-warszawa'),
+  );
+});
+
+test('feeds with no stated licence say so and name the basis they ship on', () => {
+  for (const feed of TRANSIT_FEED_REGISTRY.filter((f) =>
+    /^No licence stated/.test(f.license),
+  )) {
+    assert.match(
+      feed.terms.note,
+      /Metro Transit and OVapi|Same .*basis/,
+      `${feed.id} names its basis`,
+    );
+  }
+});
+
+test('route ids in the 2026-11 batch read as the line on the vehicle', () => {
+  const label = (id, routeId) => transitRouteLabel(getTransitFeed(id), routeId);
+  assert.equal(label('pid-praha', 'L135'), '135');
+  assert.equal(label('ets-edmonton', '009'), '9');
+  assert.equal(label('mpm-toulon', '0002'), '2');
+  assert.equal(label('gtt-torino', '10NU'), '10N');
+  assert.equal(label('actv-venezia-waterbus', '5.1_UN'), '5.1');
+  assert.equal(label('actv-venezia-bus', '53E_ES'), '53E');
+  assert.equal(label('bc-transit-victoria', '95-VIC'), '95');
+  assert.equal(label('carris-lisboa', '172_1'), '172');
+  assert.equal(label('astuce-rouen', 'TCAR:93'), '93');
+  assert.equal(label('mybas-johor', 'J33CWLMYJB'), 'J33');
+  // Unmatched and absent ids pass through untouched.
+  assert.equal(label('pid-praha', 'S4'), 'S4');
+  assert.equal(label('gtt-torino', null), null);
+});
+
+test('trams, waterbuses and buses are told apart where the ids allow it', () => {
+  const mode = (id, routeId) => transitModeFor(getTransitFeed(id), routeId);
+  assert.equal(mode('pid-praha', 'L22'), 'tram');
+  assert.equal(mode('pid-praha', 'L135'), 'bus');
+  assert.equal(mode('tbm-bordeaux', 'A'), 'tram');
+  assert.equal(mode('tbm-bordeaux', '16'), 'bus');
+  assert.equal(mode('lia-le-havre', 'B'), 'tram');
+  assert.equal(mode('lia-le-havre', '3'), 'bus');
+  assert.equal(mode('ztp-krakow-tram', null), 'tram');
+  assert.equal(mode('actv-venezia-waterbus', '1_UN'), 'ferry');
+});
+
+test('feeds that publish km/h are marked for conversion, and only those', () => {
+  const kmh = TRANSIT_FEED_REGISTRY.filter((f) => f.speedUnit === 'km/h')
+    .map((f) => f.id)
+    .sort();
+  assert.deepEqual(kmh, [
+    'carris-metropolitana-lisboa',
+    'mpm-toulon',
+    'tam-montpellier',
+  ]);
+});
diff --git a/src/data/transitProxy.test.mjs b/src/data/transitProxy.test.mjs
index 7c173cb5f..1c9f6679f 100644
--- a/src/data/transitProxy.test.mjs
+++ b/src/data/transitProxy.test.mjs
@@ -396,3 +396,13 @@ test('client history validates response bounds, epochs and cancellation through
     { name: 'AbortError' },
   );
 });
+
+test('Adelaide asks for */* because a protobuf Accept gets base64 text back', () => {
+  const headers = transitUpstreamHeaders(getTransitFeed('adelaide-metro'));
+  assert.equal(headers.Accept, '*/*');
+  // Every other feed keeps the protobuf-first Accept.
+  assert.match(
+    transitUpstreamHeaders(getTransitFeed('mbta')).Accept,
+    /protobuf/,
+  );
+});

From 923287eb92df38b24df9ff2b5b2f1913e5a638ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Itallo=20Brand=C3=A3o?=
 <45429643+IMBrandao@users.noreply.github.com>
Date: Sun, 8 Nov 2026 02:56:19 -0300
Subject: [PATCH 29/71] chore(changelog): name the transit fragment after PR
 #1628

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../{transit-more-cities.md => 1628-transit-more-cities.md}       | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename changelog.d/{transit-more-cities.md => 1628-transit-more-cities.md} (100%)

diff --git a/changelog.d/transit-more-cities.md b/changelog.d/1628-transit-more-cities.md
similarity index 100%
rename from changelog.d/transit-more-cities.md
rename to changelog.d/1628-transit-more-cities.md

From e631839a4eee48bbcccc9fb39cd05dff5e4b5d7a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Itallo=20Brand=C3=A3o?=
 <45429643+IMBrandao@users.noreply.github.com>
Date: Sun, 8 Nov 2026 03:08:40 -0300
Subject: [PATCH 30/71] fix(transit): quote Halifax's Open Government Licence

The licence page refuses automated requests; its text was read in a browser.
Credit now uses the licence's own attribution statement.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 DATA_SOURCES.md          |  2 +-
 src/data/transitFeeds.js | 11 +++++++----
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index 68f58b067..6a963c653 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -112,7 +112,7 @@ How to read this:
 | **Poznań buses and trams** (ztm.poznan.pl) | Transit layer live vehicles, Poznań, Poland | ZTM Poznań open-data terms (https://www.ztm.poznan.pl/otwarte-dane/dla-deweloperow/). Stated: “Treści udostępniane są bezwnioskowo i bezpłatnie, na zasadach powszechnego dostępu i stanowią źródło informacji.” Reuse is free on three conditions: name the source, give the date of the last update, and say the data were processed. The credit names ZTM and says processed; the snapshot timestamp is the update date. The feed carries no bearing, so heading comes from movement between fixes. | Zarząd Transportu Miejskiego w Poznaniu (processed) |
 | **Gdańsk buses and trams** (ckan2.multimediagdansk.pl) | Transit layer live vehicles, Gdańsk, Poland | CC BY 4.0 (https://dane.gov.pl/pl/dataset/38599,rozklady-jazdy-i-lokalizacja-przystankow-gtfs-rt). The national catalogue (dane.gov.pl) lists this dataset under CC BY 4.0. No bearing; heading comes from movement. Speeds are m/s. | Zarząd Transportu Miejskiego w Gdańsku |
 | **Edmonton Transit Service** (gtfs.edmonton.ca) | Transit layer live vehicles, Edmonton, AB | City of Edmonton Open Data Agreement (https://www.edmonton.ca/transportation/Web-version2.1-OpenDataAgreement.pdf). The agreement is the same municipal template as Mississauga and Burlington: a licence to use, modify and distribute for any lawful purpose, in any medium. It was read from search excerpts; the PDF itself would not extract here. Route ids are zero-padded. Speeds are m/s. | Contains information licensed under the Open Data Agreement – City of Edmonton |
-| **Halifax Transit** (gtfs.halifax.ca) | Transit layer live vehicles, Halifax, NS | Halifax Open Data Licence (https://www.halifax.ca/home/open-data/open-data-licence). The catalogue points at Halifax’s open-data licence; the licence page renders only in a browser and was not quoted. Speeds are m/s. | Halifax Regional Municipality (Halifax Transit) |
+| **Halifax Transit** (gtfs.halifax.ca) | Transit layer live vehicles, Halifax, NS | Open Government Licence – Halifax v1.0 (https://www.halifax.ca/home/open-data/open-data-license), modelled on OGL – Canada 2.0. Stated: “The information provider grants you a worldwide, royalty-free, perpetual, non-exclusive licence to use the Information, including for commercial purposes, subject to the terms below.” No logos or implied endorsement. Speeds are m/s. | Contains information licenced under the Open Government Licence – Halifax |
 | **Victoria Regional Transit** (bct.tmix.se) | Transit layer live vehicles, Victoria, BC | BC Transit Open Data Terms of Use (https://www.bctransit.com/open-data/terms-of-use). Stated: “BC Transit grants you a limited, revocable and non-exclusive license to use, reproduce, and redistribute the Data in accordance with these Terms.” The grant is revocable, like the Ontario municipal templates. Route ids carry a `-VIC` system suffix. Speeds are m/s. | BC Transit |
 | **Montpellier TaM** (gtfsproxy.e-tam.fr) | Transit layer live vehicles, Montpellier, France | ODbL (https://transport.data.gouv.fr/datasets/offre-de-transport-tam-en-temps-reel-gtfs-rt-urbain-et-suburbain). The quote is the dataset record’s licence field. ODbL asks for credit and share-alike on a derived database; the layer redistributes no database, it draws the positions. Speeds are km/h: readings ran 3.3 times the measured movement on 2026-11-07, so the proxy converts them. | Montpellier Méditerranée Métropole (TaM) |
 | **Kraków buses** (gtfs.ztp.krakow.pl) | Transit layer live vehicles, Kraków, Poland | No licence stated (https://gtfs.ztp.krakow.pl/). ZTP publishes this feed keyless on its own GTFS server and lists it in the Mobility Database, but states no licence there or on dane.gov.pl. Shipped on the same basis as Metro Transit and OVapi; switch it off if ZTP objects. | Zarząd Transportu Publicznego w Krakowie |
diff --git a/src/data/transitFeeds.js b/src/data/transitFeeds.js
index 5ac28d5da..bb2642d07 100644
--- a/src/data/transitFeeds.js
+++ b/src/data/transitFeeds.js
@@ -1069,11 +1069,14 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     center: { lat: 44.7, lon: -63.6 },
     loadRadiusKm: 22,
     url: 'https://gtfs.halifax.ca/realtime/Vehicle/VehiclePositions.pb',
-    license: 'Halifax Open Data Licence',
-    licenseUrl: 'https://www.halifax.ca/home/open-data/open-data-licence',
-    attribution: 'Halifax Regional Municipality (Halifax Transit)',
+    license: 'Open Government Licence – Halifax',
+    licenseUrl: 'https://www.halifax.ca/home/open-data/open-data-license',
+    attribution:
+      'Contains information licenced under the Open Government Licence – Halifax',
     terms: {
-      note: 'The catalogue points at Halifax’s open-data licence; the licence page renders only in a browser and was not quoted. Speeds are m/s.',
+      quote:
+        'The information provider grants you a worldwide, royalty-free, perpetual, non-exclusive licence to use the Information, including for commercial purposes, subject to the terms below.',
+      note: 'Version 1.0, modelled on the Open Government Licence – Canada 2.0. The attribution is the licence’s own standard statement, with a link to the licence where possible. Logos and crests are excluded and no endorsement may be implied, so the credit stays plain text. The page refuses automated requests (403); its text was read in a browser on 2026-11-08. Speeds are m/s.',
     },
     defaultMode: 'bus',
   }),

From 9f2dfdf8208efdd831b0f0743edb12f76774c809 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Valdez?=
 <762946+avaldini@users.noreply.github.com>
Date: Mon, 9 Nov 2026 07:34:33 +0000
Subject: [PATCH 31/71] fix(voice): send OpenAI Realtime tool schemas the API
 accepts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

OpenAI Realtime now answers 400 invalid_function_parameters for a whole
session whose tool schema uses Unicode property classes, as resolve_area's
area-id pattern does, so voice never connects ("Failed to create Realtime
token"). The session sends its tools through chatSchema, the filter typed
chat adopted in #1616, which leaves out only \p{…} patterns; area ids are
still checked against the action's own contract before the tool runs.

Fixes #1618
---
 server/providers/openai/chat.js     |  2 +-
 server/providers/openai/realtime.js | 17 +++++++++++-
 src/tooling/localServices.test.mjs  | 41 ++++++++++++++++++++++-------
 3 files changed, 49 insertions(+), 11 deletions(-)

diff --git a/server/providers/openai/chat.js b/server/providers/openai/chat.js
index 6ca4648d6..b0f7fe211 100644
--- a/server/providers/openai/chat.js
+++ b/server/providers/openai/chat.js
@@ -69,7 +69,7 @@ function validMessages(messages) {
  * 400 for a whole request whose tool uses Unicode property classes (`\p{L}`),
  * as `resolve_area`'s area ids do. Every argument is still checked against
  * the action's own contract before the tool runs, so the model loses a hint,
- * not a rule. Realtime voice accepts these patterns and keeps them.
+ * not a rule. Realtime voice refuses them too now (#1618) and uses this as well.
  */
 export function chatSchema(schema) {
   if (Array.isArray(schema)) return schema.map(chatSchema);
diff --git a/server/providers/openai/realtime.js b/server/providers/openai/realtime.js
index 73ac8d2cf..4412eb331 100644
--- a/server/providers/openai/realtime.js
+++ b/server/providers/openai/realtime.js
@@ -14,6 +14,7 @@ import {
 } from './constants.js';
 import { realtimeInstructions } from './instructions.js';
 import { GEV_REALTIME_TOOLS, offeredTools } from './tools.js';
+import { chatSchema } from './chat.js';
 import { resolveOverpassUpstreams } from '../overpass/constants.js';
 import {
   preferCodexOAuth,
@@ -128,6 +129,19 @@ function createRealtimeOAuthLoginHandler({
   };
 }
 
+/**
+ * The tools one Realtime session is offered, as OpenAI accepts them: it now
+ * refuses a whole session whose tool schema uses `\p{…}` patterns (#1618), as
+ * Chat Completions did (#1616), so voice drops the same pattern hints chat does.
+ */
+function realtimeSessionTools(tools, { overpass = false } = {}) {
+  return offeredTools(tools, { overpass }).map((tool) =>
+    tool.parameters
+      ? { ...tool, parameters: chatSchema(tool.parameters) }
+      : tool,
+  );
+}
+
 function createRealtimeTokenHandler({
   annotationGuidance,
   endpoint = 'https://api.openai.com/v1/realtime/client_secrets',
@@ -303,7 +317,7 @@ function createRealtimeTokenHandler({
           output: { voice },
         },
         instructions: realtimeInstructions(annotationGuidance, { overpass }),
-        tools: offeredTools(tools, { overpass }),
+        tools: realtimeSessionTools(tools, { overpass }),
         tool_choice: 'auto',
       },
     };
@@ -370,4 +384,5 @@ export {
   createRealtimeOAuthLoginHandler,
   createRealtimeOAuthStatusHandler,
   createRealtimeTokenHandler,
+  realtimeSessionTools,
 };
diff --git a/src/tooling/localServices.test.mjs b/src/tooling/localServices.test.mjs
index 84a2f6926..7a69b5e7f 100644
--- a/src/tooling/localServices.test.mjs
+++ b/src/tooling/localServices.test.mjs
@@ -20,12 +20,9 @@ import {
 import { openAiRealtimeProxy } from 'gods-eye-view/server/providers/openai';
 import { keySetupEndpoint } from 'gods-eye-view/server/standalone/key-setup';
 import { realtimeInstructions } from '../../server/providers/openai/instructions.js';
-import {
-  GEV_REALTIME_TOOLS,
-  offeredTools,
-  realtimeTools,
-} from '../../server/providers/openai/tools.js';
+import { GEV_REALTIME_TOOLS } from '../../server/providers/openai/tools.js';
 import { createDebugLogHandler } from '../../server/providers/openai/debug-log.js';
+import { realtimeSessionTools } from '../../server/providers/openai/realtime.js';
 import { attachVoiceResult } from '../voice/speech.js';
 import { sanitizeDebugValue } from '../voice/realtimeDiagnostics.js';
 import { standaloneVoiceTools } from '../../server/standalone/voiceTools.js';
@@ -199,7 +196,10 @@ test('Realtime handler preserves tools and default instructions, isolates suppli
       sent.at(-1).session.instructions,
       realtimeInstructions(guidance),
     );
-    assert.deepEqual(sent.at(-1).session.tools, realtimeTools());
+    assert.deepEqual(
+      sent.at(-1).session.tools,
+      realtimeSessionTools(GEV_REALTIME_TOOLS),
+    );
   }
   assert.notEqual(sent[0].session.instructions, sent[1].session.instructions);
   assert.equal(sent[0].session.instructions, sent[2].session.instructions);
@@ -607,7 +607,10 @@ test('osm_query is offered only when an operator configured Overpass', async (t)
   assert.doesNotMatch(plain.instructions, /osm_query/);
   assert.ok(names(plain).includes('resolve_area'));
   assert.ok(names(plain).includes('find_imagery'));
-  assert.deepEqual(configured.tools, GEV_REALTIME_TOOLS);
+  assert.deepEqual(
+    configured.tools,
+    realtimeSessionTools(GEV_REALTIME_TOOLS, { overpass: true }),
+  );
   assert.match(configured.instructions, /osm_query/);
   assert.equal(
     configured.instructions,
@@ -656,7 +659,7 @@ test('Realtime sessions carry supplied tools, and the standalone voice adds the
   );
   assert.equal(response.status, 200);
   // Without an operator Overpass, osm_query is left out of the session.
-  assert.deepEqual(sent.at(-1).session.tools, offeredTools(tools));
+  assert.deepEqual(sent.at(-1).session.tools, realtimeSessionTools(tools));
   assert.ok(
     !sent.at(-1).session.tools.some(({ name }) => name === 'osm_query'),
   );
@@ -740,6 +743,26 @@ test('key setup writes only the supplied application root, retains request guard
   assert.equal(existsSync(path.join(untouched, '.env')), false);
 });
 
+test('Realtime sessions leave out the Unicode property patterns OpenAI refuses (#1618)', async (t) => {
+  // OpenAI answers 400 invalid_function_parameters for a whole Realtime session
+  // whose tool schema uses `\p{…}`, as resolve_area's area ids do, so voice
+  // never connects. The session drops only those patterns, as typed chat does.
+  env(t, 'OPENAI_API_KEY', 'fixture-upstream-secret');
+  env(t, 'GEV_RATELIMIT_OPENAI_PER_MIN', undefined);
+  const sent = [];
+  t.mock.method(globalThis, 'fetch', async (_url, options) => {
+    sent.push(JSON.parse(options.body).session);
+    return Response.json({ value: 'fixture-ephemeral' });
+  });
+  const response = await request(
+    install(openAiRealtimeProxy({})).get('/api/realtime/token'),
+  );
+  assert.equal(response.status, 200);
+  const { tools } = sent.at(-1);
+  assert.ok(tools.some(({ name }) => name === 'resolve_area'));
+  assert.doesNotMatch(JSON.stringify(tools), /\\\\[pP]\{/);
+});
+
 test('Realtime service configuration selects compatible endpoint/model without forwarding request model IDs or keys', async () => {
   const handler = install(
     openAiRealtimeProxy({
@@ -757,7 +780,7 @@ test('Realtime service configuration selects compatible endpoint/model without f
           assert.equal(payload.session.model, 'configured-model');
           assert.deepEqual(
             payload.session.tools,
-            realtimeTools({ overpass: false }),
+            realtimeSessionTools(GEV_REALTIME_TOOLS),
           );
           return Response.json({ value: 'short-lived-fixture' });
         },

From d52c719ef645657aea470b8c6aa3b2f2bd791c2d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Valdez?=
 <762946+avaldini@users.noreply.github.com>
Date: Mon, 9 Nov 2026 07:52:24 +0000
Subject: [PATCH 32/71] docs(changelog): OpenAI Realtime voice tool patterns
 (#1638)

---
 changelog.d/1638-openai-realtime-tool-patterns.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 changelog.d/1638-openai-realtime-tool-patterns.md

diff --git a/changelog.d/1638-openai-realtime-tool-patterns.md b/changelog.d/1638-openai-realtime-tool-patterns.md
new file mode 100644
index 000000000..20e167112
--- /dev/null
+++ b/changelog.d/1638-openai-realtime-tool-patterns.md
@@ -0,0 +1,5 @@
+- Voice on OpenAI connects again: OpenAI Realtime refused every session, so
+  the mic failed with "Failed to create Realtime token", because
+  `resolve_area`'s area-id pattern uses Unicode classes it no longer accepts.
+  Voice leaves those patterns out, as typed chat does; area ids are still
+  checked before the tool runs (avaldini, #1638).

From 7a053c640d53e6453715d29dc71e4916d7e97db3 Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Mon, 9 Nov 2026 13:50:14 +0000
Subject: [PATCH 33/71] =?UTF-8?q?fix(transit):=20real=20route-id=20modes?=
 =?UTF-8?q?=20for=20Prague,=20Bordeaux=20and=20Rouen;=20dated=20Warsaw/Poz?=
 =?UTF-8?q?na=C5=84=20credits;=20data.gov.my=20refresh?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Prague PID: map route-id ranges from PID's GTFS (metro L991-993, S/R trains
  L1000s/L1100s, P ferries L1800s, trolleybuses 50-59, X lines, funicular LD)
  instead of 'below 100 is a tram, rest bus'.
- Bordeaux TBM: trams ride numbered ids 59-62/163/164 (A-F), boats 951-953;
  the old letter match never fired.
- Rouen Astuce: TCAR:90 Metro as tram, TCAR:99 Calypso as ferry; Le Havre FUNI.
- Warsaw and Poznan: credit carries the data date (and Warsaw links its API),
  as their terms require.
- data.gov.my feeds: CC BY 4.0, refreshMs 30 s to stay under 4 requests/min;
  proxy honours per-feed refreshMs.
- Denver: quote the RTD agreement; tests use the feeds' real route ids.
---
 DATA_SOURCES.md                         |  16 +--
 changelog.d/1628-transit-more-cities.md |   7 +-
 src/data/dataCredits.js                 |  28 +++-
 src/data/dataCredits.test.mjs           |  28 +++-
 src/data/transitFeeds.js                | 168 ++++++++++++++++++------
 src/data/transitFeeds.test.mjs          |  57 +++++++-
 src/data/transitProxy.js                |  19 ++-
 src/data/transitProxy.test.mjs          |  12 ++
 src/layers/transit/ingestion.js         |   8 +-
 src/sources/transitService.js           |   3 +-
 10 files changed, 287 insertions(+), 59 deletions(-)

diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index 6a963c653..a302235fd 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -105,11 +105,11 @@ How to read this:
 | **SMTR Rio de Janeiro** (dados.mobilidade.rio) | Transit layer live vehicles, Rio de Janeiro: municipal buses (SPPO) and the Mobi-Rio BRT, as two feeds | CC BY 4.0, stated on both data.rio catalog pages. Keyless GTFS-Realtime published by the Secretaria Municipal de Transportes, labelled beta, with a gateway limit of 5 requests a second and 60 a minute. Line names come from SMTR’s GTFS `routes.txt` (dados.mobilidade.rio/gtfs/schedule), under the same licence. | Attribution to SMTR / Prefeitura da Cidade do Rio de Janeiro under CC BY 4.0 |
 | **ZDiTM Szczecin** (zditm.szczecin.pl) | Transit layer live vehicles, Szczecin, Poland: buses and trams as one feed | CC0 1.0, stated on the ZDiTM developer page: “The data are provided free of charge under the CC0 1.0 licence, for use in any context, with no prior notification required.” Keyless GTFS-Realtime; the page says one update a minute, measured at about every 20 seconds. The feed carries no route id, so every vehicle takes the default bus mode. | None required (CC0); credited to ZDiTM Szczecin as a courtesy |
 | **Carris Metropolitana** (api.carrismetropolitana.pt) | Transit layer live vehicles, Lisbon Metropolitan Area, Portugal | Keyless GTFS-Realtime documented in the operator’s public API repository (github.com/carrismetropolitana/api). No licence is stated for the realtime endpoint; the operator’s static GTFS is CC BY 4.0. Included on the same basis as the Metro Transit and OVapi feeds and credited as a courtesy; it can be switched off if Carris objects. Speeds are published in km/h and converted to m/s by the proxy. Route ids are read as the line number per the operator’s `/v2/routes`. | Courtesy credit to Carris Metropolitana |
-| **Prague PID** (api.golemio.cz) | Transit layer live vehicles, Prague and Central Bohemia, Czechia | CC BY (https://pid.cz/o-systemu/opendata/). Stated: “Data, která lze stáhnout přímo zde z webu, jsou stejně jako celý obsah webu opatřena licencí CC-BY” The PID open-data page lists this realtime feed and licenses the data it publishes under CC BY, crediting the author and any changes. The same page says data served from other sources follows that source’s licence; the feed is served by Golemio, the city’s data platform, which states none of its own. Keyless since the catalogue moved it off the X-Access-Token endpoint. Speeds are m/s, checked against movement on 2026-11-07. Route ids are `L` plus the line number; lines below 100 are trams. | Pražská integrovaná doprava (PID) / Golemio |
-| **Warsaw buses and trams** (mkuran.pl) | Transit layer live vehicles, Warsaw, Poland | Warsaw Open Data Project Usage Terms (https://mkuran.pl/gtfs/). Stated: “The City Hall requires a credit by providing the name Miasto Stołeczne Warszawa, data download date (use the timestamp from the FeedHeader) and link to http://api.um.warszawa.pl.” Positions come from the Warsaw City Hall API, repackaged as GTFS-RT by Mikołaj Kuranowski’s unofficial feed. The credit names the city and its API; the download date it asks for is the feed timestamp the layer already shows with each snapshot. Vehicle timestamps ran about two minutes old on 2026-11-07, which the delayed playback absorbs. | Miasto Stołeczne Warszawa (api.um.warszawa.pl) |
-| **Bordeaux TBM** (bdx.mecatran.com) | Transit layer live vehicles, Bordeaux, France | Licence Ouverte / Etalab 2.0 (https://transport.data.gouv.fr/datasets/offres-de-services-bus-tram-et-scolaire-au-format-gtfs-netex-gtfs-rt-siri-lite). The quote is the licence field of the national access point’s dataset record (fr-lo is the Licence Ouverte), which asks only for credit. The `apiKey` in the URL is not a credential: it is the same fixed string printed in the open-data listing for everyone. Speeds are m/s. Trams run on lettered lines A–D; numbered lines are buses. | Bordeaux Métropole (TBM) |
+| **Prague PID** (api.golemio.cz) | Transit layer live vehicles, Prague and Central Bohemia, Czechia | CC BY (https://pid.cz/o-systemu/opendata/). Stated: “Data, která lze stáhnout přímo zde z webu, jsou stejně jako celý obsah webu opatřena licencí CC-BY” The PID open-data page lists this realtime feed and licenses the data it publishes under CC BY, crediting the author and any changes. The same page says data served from other sources follows that source’s licence; the feed is served by Golemio, the city’s data platform, which states none of its own. Keyless since the catalogue moved it off the X-Access-Token endpoint. Speeds are m/s, checked against movement on 2026-11-07. Route ids are `L` plus a number whose range gives the mode and the line (metro `L991` is A, train `L1004` is S4, ferry `L1801` is P1), read from PID’s GTFS routes.txt. | Pražská integrovaná doprava (PID) / Golemio |
+| **Warsaw buses and trams** (mkuran.pl) | Transit layer live vehicles, Warsaw, Poland | Warsaw Open Data Project Usage Terms (https://mkuran.pl/gtfs/). Stated: “The City Hall requires a credit by providing the name Miasto Stołeczne Warszawa, data download date (use the timestamp from the FeedHeader) and link to http://api.um.warszawa.pl.” Positions come from the Warsaw City Hall API, repackaged as GTFS-RT by Mikołaj Kuranowski’s unofficial feed. The credit names the city, links its API and carries the date of the feed timestamp, the three things the terms ask for. Vehicle timestamps ran about two minutes old on 2026-11-07, which the delayed playback absorbs. | Miasto Stołeczne Warszawa (api.um.warszawa.pl) |
+| **Bordeaux TBM** (bdx.mecatran.com) | Transit layer live vehicles, Bordeaux, France | Licence Ouverte / Etalab 2.0 (https://transport.data.gouv.fr/datasets/offres-de-services-bus-tram-et-scolaire-au-format-gtfs-netex-gtfs-rt-siri-lite). The quote is the licence field of the national access point’s dataset record (fr-lo is the Licence Ouverte), which asks only for credit. The `apiKey` in the URL is not a credential: it is the same fixed string printed in the open-data listing for everyone. Speeds are m/s. The trams (A–F) and BAT³ boats ride numbered route ids (tram A is `59`), mapped from TBM’s static GTFS; other numbered lines are buses. | Bordeaux Métropole (TBM) |
 | **Sendai City Bus** (api-public.odpt.org) | Transit layer live vehicles, Sendai, Japan | CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Served by the Open Data Challenge for Public Transportation (ODPT) public API, which needs no key for this feed; the catalogue records CC BY 4.0 as its licence. Vehicle timestamps ran about two minutes old on 2026-11-07. Speeds are m/s. | 仙台市交通局 (Sendai City Transportation Bureau) / ODPT |
-| **Poznań buses and trams** (ztm.poznan.pl) | Transit layer live vehicles, Poznań, Poland | ZTM Poznań open-data terms (https://www.ztm.poznan.pl/otwarte-dane/dla-deweloperow/). Stated: “Treści udostępniane są bezwnioskowo i bezpłatnie, na zasadach powszechnego dostępu i stanowią źródło informacji.” Reuse is free on three conditions: name the source, give the date of the last update, and say the data were processed. The credit names ZTM and says processed; the snapshot timestamp is the update date. The feed carries no bearing, so heading comes from movement between fixes. | Zarząd Transportu Miejskiego w Poznaniu (processed) |
+| **Poznań buses and trams** (ztm.poznan.pl) | Transit layer live vehicles, Poznań, Poland | ZTM Poznań open-data terms (https://www.ztm.poznan.pl/otwarte-dane/dla-deweloperow/). Stated: “Treści udostępniane są bezwnioskowo i bezpłatnie, na zasadach powszechnego dostępu i stanowią źródło informacji.” Reuse is free on three conditions: name the source, give the date of the last update, and say the data were processed. The credit names ZTM, says processed, and carries the date of the feed timestamp as the update date. The feed carries no bearing, so heading comes from movement between fixes. | Zarząd Transportu Miejskiego w Poznaniu (processed) |
 | **Gdańsk buses and trams** (ckan2.multimediagdansk.pl) | Transit layer live vehicles, Gdańsk, Poland | CC BY 4.0 (https://dane.gov.pl/pl/dataset/38599,rozklady-jazdy-i-lokalizacja-przystankow-gtfs-rt). The national catalogue (dane.gov.pl) lists this dataset under CC BY 4.0. No bearing; heading comes from movement. Speeds are m/s. | Zarząd Transportu Miejskiego w Gdańsku |
 | **Edmonton Transit Service** (gtfs.edmonton.ca) | Transit layer live vehicles, Edmonton, AB | City of Edmonton Open Data Agreement (https://www.edmonton.ca/transportation/Web-version2.1-OpenDataAgreement.pdf). The agreement is the same municipal template as Mississauga and Burlington: a licence to use, modify and distribute for any lawful purpose, in any medium. It was read from search excerpts; the PDF itself would not extract here. Route ids are zero-padded. Speeds are m/s. | Contains information licensed under the Open Data Agreement – City of Edmonton |
 | **Halifax Transit** (gtfs.halifax.ca) | Transit layer live vehicles, Halifax, NS | Open Government Licence – Halifax v1.0 (https://www.halifax.ca/home/open-data/open-data-license), modelled on OGL – Canada 2.0. Stated: “The information provider grants you a worldwide, royalty-free, perpetual, non-exclusive licence to use the Information, including for commercial purposes, subject to the terms below.” No logos or implied endorsement. Speeds are m/s. | Contains information licenced under the Open Government Licence – Halifax |
@@ -125,15 +125,15 @@ How to read this:
 | **Venice ACTV waterbuses** (tpl.actv.it) | Transit layer live vehicles, Venice, Italy | ACTV open-data catalogue (https://actv.avmspa.it/it/content/catalogo-dei-dati-metadati-e-banche-dati-actv). Same catalogue and basis as the ACTV bus feed. | ACTV S.p.A. |
 | **Adelaide Metro** (gtfs.adelaidemetro.com.au) | Transit layer live vehicles, Adelaide, SA | No licence stated for the realtime feed (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1772). Official keyless endpoint; the state catalogue page refused automated reads, so no licence is quoted. Same basis as Metro Transit and OVapi. Speeds are m/s. The server picks its encoding from Accept, hence the override. | Adelaide Metro |
 | **MARTA buses** (gtfs-rt.itsmarta.com) | Transit layer live vehicles, Atlanta, GA | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1601). Official keyless endpoint; no licence found. Same basis as Metro Transit and OVapi. Speeds are m/s. | MARTA |
-| **Denver RTD** (open-data.rtd-denver.com) | Transit layer live vehicles, Denver, CO | RTD GTFS-realtime licence agreement (https://www.rtd-denver.com/business-center/open-spatial-data/gtfs-realtime-license-agreement). RTD links a licence agreement for its realtime feeds; the page refused automated reads (403), so it is not quoted. The feed itself is keyless. Speeds are m/s. | Regional Transportation District (RTD) |
+| **Denver RTD** (open-data.rtd-denver.com) | Transit layer live vehicles, Denver, CO | RTD GTFS-realtime licence agreement (https://www.rtd-denver.com/business-center/open-spatial-data/gtfs-realtime-license-agreement). Stated: “RTD hereby grants you non-exclusive, limited and revocable rights to use, reproduce, and redistribute the Data”. Read 2026-11-09: a click-through agreement that RTD may change without notice; it permits redistribution, asks for no credit wording, and bars RTD trademarks from use with the data, so the credit stays plain text. The feed itself is keyless. Speeds are m/s. | Regional Transportation District (RTD) |
 | **Cluj-Napoca CTP** (cluj-rt-feed.gtfs.ro) | Transit layer live vehicles, Cluj-Napoca, Romania | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2614). Keyless; no licence found. Same basis as Metro Transit and OVapi. | Compania de Transport Public Cluj-Napoca |
 | **Iași CTP** (iasi-rt-feed.gtfs.ro) | Transit layer live vehicles, Iași, Romania | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2118). Keyless; no licence found. Same basis as Metro Transit and OVapi. | Compania de Transport Public Iași |
 | **Rzeszów city transport** (mpkrzeszow.pl) | Transit layer live vehicles, Rzeszów, Poland | MPK Rzeszów open data (https://www.mpkrzeszow.pl/otwartedane/). Listed on the operator’s open-data page, which names no licence. No bearing; heading comes from movement. | MPK Rzeszów |
 | **Málaga EMT** (gtfs.emtmalaga.es) | Transit layer live vehicles, Málaga, Spain | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2213). Keyless; no licence found. Same basis as Metro Transit and OVapi. No bearing; heading comes from movement. | EMT Málaga |
 | **Carris (Lisbon city)** (gateway.carris.pt) | Transit layer live vehicles, Lisbon, Portugal | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2930). Keyless official gateway; no licence found. Same basis as Metro Transit and OVapi. Carries neither bearing nor speed, and vehicle reports run about a minute old. Route ids append a variant. | Carris |
-| **BAS.MY Johor Bahru** (api.data.gov.my) | Transit layer live vehicles, Johor Bahru, Malaysia | No licence stated for the feed (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-3174). Served keyless by Malaysia’s national open-data API; no licence for the feed was found. Same basis as Metro Transit and OVapi. Without the trailing slash the API redirects. Route ids append an operator code. | BAS.MY / data.gov.my |
-| **BAS.MY Kota Bharu** (api.data.gov.my) | Transit layer live vehicles, Kota Bharu, Malaysia | No licence stated for the feed (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-3169). Same API and basis as Johor Bahru. | BAS.MY / data.gov.my |
-| **Rouen Astuce** (gtfs.bus-tracker.fr) | Transit layer live vehicles, Rouen, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/donnees-statiques-et-temps-reel-du-reseau-astuce-metropole-rouen-normandie). The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted); this registry reads it through bus-tracker.fr, an unofficial relay that merges the city’s networks into one GTFS-RT file. Route ids carry the network prefix (`TCAR:`). | Métropole Rouen Normandie (Astuce) / bus-tracker.fr |
+| **BAS.MY Johor Bahru** (api.data.gov.my) | Transit layer live vehicles, Johor Bahru, Malaysia | CC BY 4.0 (https://developer.data.gov.my/realtime-api/gtfs-realtime). Stated: “All GTFS Realtime feeds are licensed under CC BY 4.0.” Served keyless by Malaysia’s national open-data API, which caps GTFS Realtime at 4 requests a minute and refreshes positions every 30 seconds, so the proxy caches this feed for 30 seconds. Without the trailing slash the API redirects. Route ids append an operator code. | BAS.MY / data.gov.my |
+| **BAS.MY Kota Bharu** (api.data.gov.my) | Transit layer live vehicles, Kota Bharu, Malaysia | CC BY 4.0 (https://developer.data.gov.my/realtime-api/gtfs-realtime). Same API, licence and rate limit as Johor Bahru. | BAS.MY / data.gov.my |
+| **Rouen Astuce** (gtfs.bus-tracker.fr) | Transit layer live vehicles, Rouen, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/donnees-statiques-et-temps-reel-du-reseau-astuce-metropole-rouen-normandie). The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted); this registry reads it through bus-tracker.fr, an unofficial relay that merges the city’s networks into one GTFS-RT file. Route ids carry the network prefix (`TCAR:`); line 90 is the Métro (a street-running light rail, drawn as a tram) and 99 the Calypso boat. | Métropole Rouen Normandie (Astuce) / bus-tracker.fr |
 | **Toulon Mistral** (feed-rdtpm-toulon.ratpdev.com) | Transit layer live vehicles, Toulon, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/reseau-de-transport-urbain-de-la-metropole-toulon-provence-mediterranee). Dataset record’s licence field quoted. Speeds are km/h: readings ran 3.5 times the measured movement on 2026-11-07, so the proxy converts them. Route ids are zero-padded. | Métropole Toulon Provence Méditerranée (Mistral) |
 | **Le Havre LiA** (gtfs.bus-tracker.fr) | Transit layer live vehicles, Le Havre, France | ODbL (https://transport.data.gouv.fr/datasets/reseau-de-transport-en-commun-lia-gtfs-siri). The network publishes under ODbL (dataset record quoted); read through the bus-tracker.fr relay, which converts its SIRI feed to GTFS-RT. The layer draws positions and redistributes no database. Lines A and B are the tramway. | Le Havre Seine Métropole (LiA) / bus-tracker.fr |
 | **Tours Fil Bleu** (data.filbleu.fr) | Transit layer live vehicles, Tours, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/fil-bleu-syndicat-des-mobilites-gtfs-gtfs-rt). Dataset record’s licence field quoted. | Fil Bleu – Syndicat des Mobilités de Touraine |
diff --git a/changelog.d/1628-transit-more-cities.md b/changelog.d/1628-transit-more-cities.md
index 3e72ebebb..24e55817e 100644
--- a/changelog.d/1628-transit-more-cities.md
+++ b/changelog.d/1628-transit-more-cities.md
@@ -7,5 +7,8 @@
   Edmonton, Halifax and Victoria. Each feed records its licence, or that none
   is stated, in the registry and DATA_SOURCES.md. Speeds published in km/h
   (Lisbon, Montpellier, Toulon) are converted to m/s by the proxy; route ids
-  read as the line on the vehicle; Prague, Bordeaux and Le Havre trams and
-  Venice waterbuses take their own mode (IMBrandao).
+  read as the line on the vehicle; Prague metro, trains, trams and ferries,
+  Bordeaux trams and boats, the Rouen Métro, Le Havre trams and Venice
+  waterbuses take their own mode. The Warsaw and Poznań credits carry the
+  data date their terms ask for, and the data.gov.my feeds are fetched at
+  most twice a minute to stay inside the API's rate limit (IMBrandao).
diff --git a/src/data/dataCredits.js b/src/data/dataCredits.js
index 82184b6dd..e0b70558c 100644
--- a/src/data/dataCredits.js
+++ b/src/data/dataCredits.js
@@ -660,20 +660,40 @@ export const OSM_PLACES_CREDIT = {
 /**
  * Per-feed transit credit, registered the first time that feed's vehicles
  * render (see `src/data/transitFeeds.js` for the license of each).
- * @param {{ id: string, attribution: string, license: string, licenseUrl: string }} feed
+ *
+ * Two optional registry fields serve licences that ask for more than a name:
+ * `sourceUrl` links the attribution to the publisher (Warsaw asks for a link
+ * to its API), and `creditDated` adds the UTC date of the data, from the feed
+ * header or else the fetch time (Warsaw and Poznań ask for the download or
+ * update date). A dated credit is keyed by its date, so a new day registers a
+ * new line instead of keeping yesterday's.
+ * @param {{ id: string, attribution: string, license: string, licenseUrl: string,
+ *   sourceUrl?: string, creditDated?: boolean }} feed
+ * @param {{ feedTimestamp?: number|null, fetchedAt?: number|null }} [snapshot]
+ *   `feedTimestamp` in epoch seconds, `fetchedAt` in epoch ms.
  * @returns {{ key: string, html: string }}
  */
-export function transitFeedCredit(feed) {
+export function transitFeedCredit(feed, snapshot = null) {
   const escape = (text) =>
     String(text)
       .replaceAll('&', '&amp;')
       .replaceAll('<', '&lt;')
       .replaceAll('>', '&gt;')
       .replaceAll('"', '&quot;');
+  const source = feed.sourceUrl
+    ? `<a href="${escape(feed.sourceUrl)}" target="_blank" rel="noopener">${escape(feed.attribution)}</a>`
+    : escape(feed.attribution);
+  const dataMs = Number.isFinite(snapshot?.feedTimestamp)
+    ? snapshot.feedTimestamp * 1000
+    : snapshot?.fetchedAt;
+  const date =
+    feed.creditDated === true && Number.isFinite(dataMs) && dataMs > 0
+      ? new Date(dataMs).toISOString().slice(0, 10)
+      : null;
   return {
-    key: `transit-${feed.id}`,
+    key: date ? `transit-${feed.id}-${date}` : `transit-${feed.id}`,
     html:
-      `Transit (${escape(feed.attribution)}): ` +
+      `Transit (${source}${date ? `, data of ${date}` : ''}): ` +
       `<a href="${escape(feed.licenseUrl)}" target="_blank" rel="noopener">${escape(feed.license)}</a>`,
   };
 }
diff --git a/src/data/dataCredits.test.mjs b/src/data/dataCredits.test.mjs
index 79305ad6f..3a83d04d7 100644
--- a/src/data/dataCredits.test.mjs
+++ b/src/data/dataCredits.test.mjs
@@ -1,6 +1,11 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { DATA_CREDITS, NYC_DOT_DISCLAIMER } from './dataCredits.js';
+import {
+  DATA_CREDITS,
+  NYC_DOT_DISCLAIMER,
+  transitFeedCredit,
+} from './dataCredits.js';
+import { getTransitFeed } from './transitFeeds.js';
 
 test('every credit carries a unique key and some markup to render', () => {
   const keys = DATA_CREDITS.map((entry) => entry.key);
@@ -167,3 +172,24 @@ test('the PR #1506 camera packs are credited with their sources and terms', () =
     /href="https:\/\/www\.river\.go\.jp\//,
   );
 });
+
+test('Warsaw and Poznań credits carry the data date their licences ask for', () => {
+  const warsaw = getTransitFeed('ztm-warszawa');
+  // 2026-11-09T06:00:00Z as a GTFS-RT header timestamp (seconds).
+  const credit = transitFeedCredit(warsaw, { feedTimestamp: 1_794_204_000 });
+  assert.match(credit.html, /, data of 2026-11-09\)/);
+  assert.match(credit.html, /href="http:\/\/api\.um\.warszawa\.pl"/);
+  assert.equal(credit.key, 'transit-ztm-warszawa-2026-11-09');
+  // Without a feed timestamp the fetch time is the download date.
+  const poznan = transitFeedCredit(getTransitFeed('ztm-poznan'), {
+    feedTimestamp: null,
+    fetchedAt: Date.UTC(2026, 10, 10, 12),
+  });
+  assert.match(poznan.html, /data of 2026-11-10/);
+  // Undated feeds keep one credit line for the session.
+  const mbta = transitFeedCredit(getTransitFeed('mbta'), {
+    feedTimestamp: 1_794_204_000,
+  });
+  assert.equal(mbta.key, 'transit-mbta');
+  assert.doesNotMatch(mbta.html, /data of/);
+});
diff --git a/src/data/transitFeeds.js b/src/data/transitFeeds.js
index bb2642d07..7f2d79a02 100644
--- a/src/data/transitFeeds.js
+++ b/src/data/transitFeeds.js
@@ -416,8 +416,6 @@ function routeIdPattern(pattern) {
   };
 }
 
-/** Prague PID: `L125` is line 125. */
-const pidRouteLabel = routeIdPattern(/^L(\d+)$/);
 /** Zero-padded numbers (Edmonton `005`, Toulon `0002`, Bordeaux `01`). */
 const unpaddedRouteLabel = routeIdPattern(/^0+(\d+\w*)$/);
 /** Turin GTT appends `U` (urban) to the line: `10NU` is night line 10N. */
@@ -434,35 +432,110 @@ const busTrackerRouteLabel = routeIdPattern(/^[A-Z]+:(.+)$/);
 const mybasJohorRouteLabel = routeIdPattern(/^(.+?)CWLMYJB$/);
 
 /**
- * Le Havre LiA runs its two tram lines as A and B; every other line is a bus.
+ * Le Havre LiA runs its two tram lines as A and B and the funicular as
+ * `FUNI`; every other line is a bus.
  * @param {string|null} routeId
  * @returns {string}
  */
 function liaRouteMode(routeId) {
   if (!routeId) return 'unknown';
+  if (routeId === 'FUNI') return 'rail';
   return /^(?:[A-Z]+:)?[AB]$/.test(routeId) ? 'tram' : 'bus';
 }
 
 /**
- * Prague PID numbers its day and night trams below 100 and its buses from 100
- * up; anything else (rail, ferries, the funicular) is left unresolved.
- * @param {string|null} routeId
- * @returns {string}
+ * Rouen Astuce lines that are not buses, by bus-tracker.fr route id, from the
+ * relay's own `astuce-tcar.zip` routes.txt (checked 2026-11-09): line 90 is
+ * the Métro (GTFS type 1, a light rail that runs mostly on the street) and 99
+ * the Calypso river boat.
  */
-function pidRouteMode(routeId) {
-  const match = /^L(\d+)$/.exec(routeId ?? '');
-  if (!match) return 'unknown';
-  return Number(match[1]) < 100 ? 'tram' : 'bus';
+const ASTUCE_ROUTES = Object.freeze({
+  'TCAR:90': Object.freeze({ mode: 'tram', label: 'Métro' }),
+  'TCAR:99': Object.freeze({ mode: 'ferry', label: 'Calypso' }),
+});
+
+/** @param {string|null} routeId @returns {string} */
+function astuceRouteMode(routeId) {
+  if (!routeId) return 'unknown';
+  return ASTUCE_ROUTES[routeId]?.mode ?? 'bus';
+}
+
+/** `TCAR:93` is Rouen line 93; the Métro and Calypso keep their names. */
+function astuceRouteLabel(routeId) {
+  return ASTUCE_ROUTES[routeId ?? '']?.label ?? busTrackerRouteLabel(routeId);
 }
 
 /**
- * Bordeaux TBM runs trams on lettered lines A–D; every numbered line is a bus.
+ * Prague PID route ids are `L` plus a number whose range says what runs it,
+ * per PID's GTFS routes.txt (data.pid.cz, checked 2026-11-09): 1–99 trams
+ * (50–59 trolleybuses, 49 the Petřín funicular `LD`), 100–990 buses (the
+ * 800s are the X replacement lines, `L803` is X3), 991–993 metro A–C,
+ * 1000s and 1100s the S and R trains (`L1004` is S4, `L1109` R9), the rest
+ * of 1200–1399 other trains, 1700s town buses, 1800s the P ferries, and from
+ * 2000 more buses (`L2841` is 841). A label the range cannot give stays the
+ * route id.
+ * @param {string|null} routeId
+ * @returns {{mode: string, label: string|null}}
+ */
+function pidRoute(routeId) {
+  const match = /^L(\d+)$/.exec(routeId ?? '');
+  if (!match) return { mode: 'unknown', label: routeId };
+  const n = Number(match[1]);
+  if (n === 49) return { mode: 'rail', label: 'LD' };
+  if (n >= 50 && n <= 59) return { mode: 'bus', label: String(n) };
+  if (n < 100) return { mode: 'tram', label: String(n) };
+  if (n >= 800 && n < 900) return { mode: 'bus', label: `X${n - 800}` };
+  if (n < 991) return { mode: 'bus', label: String(n) };
+  if (n <= 993) return { mode: 'subway', label: 'ABC'[n - 991] };
+  if (n >= 1000 && n < 1100) return { mode: 'rail', label: `S${n - 1000}` };
+  if (n >= 1100 && n < 1200) return { mode: 'rail', label: `R${n - 1100}` };
+  if (n >= 1200 && n < 1400) return { mode: 'rail', label: routeId };
+  if (n >= 1800 && n < 1900) return { mode: 'ferry', label: `P${n - 1800}` };
+  if (n >= 2800 && n < 2900) return { mode: 'bus', label: String(n - 2000) };
+  return { mode: n >= 1700 ? 'bus' : 'unknown', label: routeId };
+}
+
+/** @param {string|null} routeId @returns {string} */
+function pidRouteMode(routeId) {
+  return pidRoute(routeId).mode;
+}
+
+/** @param {string|null} routeId @returns {string|null} */
+function pidRouteLabel(routeId) {
+  return pidRoute(routeId).label;
+}
+
+/**
+ * Bordeaux TBM tram and boat lines by route id, from TBM's static GTFS
+ * routes.txt (checked 2026-11-09): the trams are numbered ids, not letters.
+ */
+const TBM_TRAM_LINES = Object.freeze({
+  59: 'A',
+  60: 'B',
+  61: 'C',
+  62: 'D',
+  163: 'E',
+  164: 'F',
+});
+const TBM_BOAT_LINES = new Set(['951', '952', '953']);
+
+/**
+ * Bordeaux TBM: trams A–F and the BAT³ river shuttles; every other line is a
+ * bus.
  * @param {string|null} routeId
  * @returns {string}
  */
 function tbmRouteMode(routeId) {
   if (!routeId) return 'unknown';
-  return /^[A-D]$/.test(routeId) ? 'tram' : 'bus';
+  if (Object.hasOwn(TBM_TRAM_LINES, routeId)) return 'tram';
+  return TBM_BOAT_LINES.has(routeId) ? 'ferry' : 'bus';
+}
+
+/** `59` is tram A; zero-padded bus ids lose their padding (`01` is 1). */
+function tbmRouteLabel(routeId) {
+  return Object.hasOwn(TBM_TRAM_LINES, routeId ?? '')
+    ? TBM_TRAM_LINES[routeId]
+    : unpaddedRouteLabel(routeId);
 }
 
 /**
@@ -491,10 +564,14 @@ function transitFeed(fields) {
  *   url: string, headers?: Record<string, string>,
  *   license: string, licenseUrl: string, attribution: string,
  *   defaultMode: string, routeMode?: (routeId: string|null) => string,
- *   speedUnit?: 'km/h',
+ *   speedUnit?: 'km/h', refreshMs?: number, sourceUrl?: string,
+ *   creditDated?: boolean,
  * }>>}
  * `speedUnit` marks a feed that publishes km/h where the spec requires m/s;
- * the proxy converts it before the snapshot leaves the server.
+ * the proxy converts it before the snapshot leaves the server. `refreshMs`
+ * stretches the proxy's cache for an upstream that rate-limits below one
+ * request per 15 s TTL. `sourceUrl` and `creditDated` add a link and a date
+ * to the credit for licences that ask for them (`transitFeedCredit`).
  */
 export const TRANSIT_FEED_REGISTRY = Object.freeze([
   Object.freeze({
@@ -884,7 +961,7 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     defaultMode: 'bus',
     routeLabel: rioRouteLabel,
   }),
-  Object.freeze({
+  transitFeed({
     id: 'zditm-szczecin',
     name: 'Szczecin buses and trams',
     operator:
@@ -892,40 +969,38 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     region: 'Szczecin, Poland',
     // Every vehicle in a 2026-11-05 snapshot sat between 53.34–53.55 N and
     // 14.44–14.77 E, inside 20 km of this point.
-    center: Object.freeze({ lat: 53.44, lon: 14.56 }),
+    center: { lat: 53.44, lon: 14.56 },
     loadRadiusKm: 25,
     url: 'https://www.zditm.szczecin.pl/storage/gtfs/gtfs-rt-vehicles.pb',
     license: 'CC0 1.0',
     licenseUrl: 'https://www.zditm.szczecin.pl/en/zditm/for-developers',
     attribution:
       'Zarząd Dróg i Transportu Miejskiego w Szczecinie (ZDiTM Szczecin)',
-    defaultEnabled: true,
-    terms: Object.freeze({
+    terms: {
       quote:
         'The data are provided free of charge under the CC0 1.0 licence, for use in any context, with no prior notification required.',
       note: 'CC0 needs no credit; it is given anyway as a courtesy. ZDiTM gives no guarantee of accuracy or completeness. The developer page says the feed updates every minute; measured on 2026-11-05 the file changed about every 20 seconds, with vehicle timestamps up to 50 seconds old. Speeds are m/s: checked against vehicle movement between two snapshots. The feed carries no route id at all, so every vehicle takes the feed default mode even though the city also runs trams.',
-    }),
+    },
     defaultMode: 'bus',
   }),
-  Object.freeze({
+  transitFeed({
     id: 'carris-metropolitana-lisboa',
     name: 'Carris Metropolitana',
     operator: 'Carris Metropolitana (TML), Lisbon Metropolitan Area',
     region: 'Lisbon Metropolitan Area, Portugal',
     // Every vehicle in a 2026-11-07 snapshot, from Mafra to Setúbal, sat
     // between 38.47–39.00 N and 9.47–8.79 W, inside 40 km of this point.
-    center: Object.freeze({ lat: 38.73, lon: -9.13 }),
+    center: { lat: 38.73, lon: -9.13 },
     loadRadiusKm: 45,
     url: 'https://api.carrismetropolitana.pt/v2/vehicles.pb',
     license: 'No separate licence for the realtime feed',
     licenseUrl: 'https://github.com/carrismetropolitana/api',
     attribution: 'Carris Metropolitana',
-    defaultEnabled: true,
-    terms: Object.freeze({
+    terms: {
       quote:
         'GET /vehicles.pb — Returns vehicle locations in Protobuf format, following the GTFS-RT Vehicle Locations standard.',
       note: 'The operator publishes this feed keyless and documented for developers in its public API repository, but states no licence for the realtime endpoint; its static GTFS (github.com/carrismetropolitana/gtfs) is CC BY 4.0. Credited as a courtesy, on the same basis as the Metro Transit and OVapi feeds; switch it off if Carris objects. The quote above is the API README, not a licence. `/vehicles.pb` answers with a 307 to `/v2/vehicles.pb`, so the registry points at the target. Speeds are km/h, not the m/s the spec requires: 2026-11-07 readings of 31–33 matched 6–9 m/s of measured movement, so the proxy converts them. Vehicle reports arrive every 30–50 seconds. Route ids are the GTFS route id inside an area prefix and are read as the line number.',
-    }),
+    },
     defaultMode: 'bus',
     routeLabel: carrisMetropolitanaRouteLabel,
     speedUnit: 'km/h',
@@ -946,7 +1021,7 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     terms: {
       quote:
         'Data, která lze stáhnout přímo zde z webu, jsou stejně jako celý obsah webu opatřena licencí CC-BY',
-      note: 'The PID open-data page lists this realtime feed and licenses the data it publishes under CC BY, crediting the author and any changes. The same page says data served from other sources follows that source’s licence; the feed is served by Golemio, the city’s data platform, which states none of its own. Keyless since the catalogue moved it off the X-Access-Token endpoint. Speeds are m/s, checked against movement on 2026-11-07. Route ids are `L` plus the line number; lines below 100 are trams.',
+      note: 'The PID open-data page lists this realtime feed and licenses the data it publishes under CC BY, crediting the author and any changes. The same page says data served from other sources follows that source’s licence; the feed is served by Golemio, the city’s data platform, which states none of its own. Keyless since the catalogue moved it off the X-Access-Token endpoint. Speeds are m/s, checked against movement on 2026-11-07. Route ids are `L` plus a number whose range gives the mode and the line (metro `L991` is A, train `L1004` is S4, ferry `L1801` is P1); `pidRoute` holds the table, read from PID’s GTFS routes.txt on 2026-11-09.',
     },
     defaultMode: 'bus',
     routeLabel: pidRouteLabel,
@@ -963,10 +1038,12 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     license: 'Warsaw Open Data Project Usage Terms',
     licenseUrl: 'https://mkuran.pl/gtfs/',
     attribution: 'Miasto Stołeczne Warszawa (api.um.warszawa.pl)',
+    sourceUrl: 'http://api.um.warszawa.pl',
+    creditDated: true,
     terms: {
       quote:
         'The City Hall requires a credit by providing the name Miasto Stołeczne Warszawa, data download date (use the timestamp from the FeedHeader) and link to http://api.um.warszawa.pl.',
-      note: 'Positions come from the Warsaw City Hall API, repackaged as GTFS-RT by Mikołaj Kuranowski’s unofficial feed. The credit names the city and its API; the download date it asks for is the feed timestamp the layer already shows with each snapshot. Vehicle timestamps ran about two minutes old on 2026-11-07, which the delayed playback absorbs.',
+      note: 'Positions come from the Warsaw City Hall API, repackaged as GTFS-RT by Mikołaj Kuranowski’s unofficial feed. The credit names the city, links its API (`sourceUrl`) and carries the date of the feed timestamp (`creditDated`), the three things the terms ask for. Vehicle timestamps ran about two minutes old on 2026-11-07, which the delayed playback absorbs.',
     },
     defaultMode: 'bus',
   }),
@@ -984,10 +1061,10 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     attribution: 'Bordeaux Métropole (TBM)',
     terms: {
       quote: 'licence: fr-lo',
-      note: 'The quote is the licence field of the national access point’s dataset record (fr-lo is the Licence Ouverte), which asks only for credit. The `apiKey` in the URL is not a credential: it is the same fixed string printed in the open-data listing for everyone. Speeds are m/s. Trams run on lettered lines A–D; numbered lines are buses.',
+      note: 'The quote is the licence field of the national access point’s dataset record (fr-lo is the Licence Ouverte), which asks only for credit. The `apiKey` in the URL is not a credential: it is the same fixed string printed in the open-data listing for everyone. Speeds are m/s. The trams (A–F) and BAT³ boats ride numbered route ids (tram A is `59`), so `tbmRouteMode` and `tbmRouteLabel` map them from TBM’s static GTFS; other numbered lines are buses.',
     },
     defaultMode: 'bus',
-    routeLabel: unpaddedRouteLabel,
+    routeLabel: tbmRouteLabel,
     routeMode: tbmRouteMode,
   }),
   transitFeed({
@@ -1018,10 +1095,11 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     license: 'ZTM Poznań open-data terms',
     licenseUrl: 'https://www.ztm.poznan.pl/otwarte-dane/dla-deweloperow/',
     attribution: 'Zarząd Transportu Miejskiego w Poznaniu (processed)',
+    creditDated: true,
     terms: {
       quote:
         'Treści udostępniane są bezwnioskowo i bezpłatnie, na zasadach powszechnego dostępu i stanowią źródło informacji.',
-      note: 'Reuse is free on three conditions: name the source, give the date of the last update, and say the data were processed. The credit names ZTM and says processed; the snapshot timestamp is the update date. The feed carries no bearing, so heading comes from movement between fixes.',
+      note: 'Reuse is free on three conditions: name the source, give the date of the last update, and say the data were processed. The credit names ZTM, says processed, and carries the date of the feed timestamp (`creditDated`) as the update date. The feed carries no bearing, so heading comes from movement between fixes.',
     },
     defaultMode: 'bus',
   }),
@@ -1295,7 +1373,9 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
       'https://www.rtd-denver.com/business-center/open-spatial-data/gtfs-realtime-license-agreement',
     attribution: 'Regional Transportation District (RTD)',
     terms: {
-      note: 'RTD links a licence agreement for its realtime feeds; the page refused automated reads (403), so it is not quoted. The feed itself is keyless. Speeds are m/s.',
+      quote:
+        'RTD hereby grants you non-exclusive, limited and revocable rights to use, reproduce, and redistribute the Data',
+      note: 'Read 2026-11-09. The agreement is a click-through (“By clicking to download the Data files, you confirm that you have read and agree”) that RTD may change without notice; it permits redistribution, asks for no credit wording, and bars RTD trademarks from being used with the data, so the credit stays plain text. The feed itself is keyless. Speeds are m/s.',
     },
     defaultMode: 'bus',
   }),
@@ -1388,11 +1468,16 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     center: { lat: 1.51, lon: 103.75 },
     loadRadiusKm: 35,
     url: 'https://api.data.gov.my/gtfs-realtime/vehicle-position/mybas-johor/',
-    license: 'No licence stated for the feed',
-    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-3174',
+    license: 'CC BY 4.0',
+    licenseUrl: 'https://developer.data.gov.my/realtime-api/gtfs-realtime',
     attribution: 'BAS.MY / data.gov.my',
+    // data.gov.my allows 4 GTFS-Realtime requests a minute and refreshes
+    // vehicle positions every 30 seconds, so the proxy asks half as often as
+    // the default 15 s TTL would.
+    refreshMs: 30_000,
     terms: {
-      note: 'Served keyless by Malaysia’s national open-data API; no licence for the feed was found. Same basis as Metro Transit and OVapi. Without the trailing slash the API redirects. Route ids append an operator code.',
+      quote: 'All GTFS Realtime feeds are licensed under CC BY 4.0.',
+      note: 'Served keyless by Malaysia’s national open-data API (developer.data.gov.my, read 2026-11-09). Its rate-limit page caps GTFS Realtime at 4 requests a minute and answers 429 above that; the feed updates every 30 seconds, hence `refreshMs`. Without the trailing slash the API redirects. Route ids append an operator code.',
     },
     defaultMode: 'bus',
     routeLabel: mybasJohorRouteLabel,
@@ -1406,10 +1491,14 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     center: { lat: 6.06, lon: 102.22 },
     loadRadiusKm: 60,
     url: 'https://api.data.gov.my/gtfs-realtime/vehicle-position/mybas-kota-bharu/',
-    license: 'No licence stated for the feed',
-    licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-3169',
+    license: 'CC BY 4.0',
+    licenseUrl: 'https://developer.data.gov.my/realtime-api/gtfs-realtime',
     attribution: 'BAS.MY / data.gov.my',
-    terms: { note: 'Same API and basis as Johor Bahru.' },
+    refreshMs: 30_000,
+    terms: {
+      quote: 'All GTFS Realtime feeds are licensed under CC BY 4.0.',
+      note: 'Same API, licence and rate limit as Johor Bahru.',
+    },
     defaultMode: 'bus',
   }),
   transitFeed({
@@ -1426,10 +1515,11 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     attribution: 'Métropole Rouen Normandie (Astuce) / bus-tracker.fr',
     terms: {
       quote: 'licence: lov2',
-      note: 'The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted); this registry reads it through bus-tracker.fr, an unofficial relay that merges the city’s networks into one GTFS-RT file. Route ids carry the network prefix (`TCAR:`).',
+      note: 'The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted); this registry reads it through bus-tracker.fr, an unofficial relay that merges the city’s networks into one GTFS-RT file. Route ids carry the network prefix (`TCAR:`); `TCAR:90` is the Métro (a street-running light rail, drawn as a tram) and `TCAR:99` the Calypso boat.',
     },
     defaultMode: 'bus',
-    routeLabel: busTrackerRouteLabel,
+    routeLabel: astuceRouteLabel,
+    routeMode: astuceRouteMode,
   }),
   transitFeed({
     id: 'mpm-toulon',
diff --git a/src/data/transitFeeds.test.mjs b/src/data/transitFeeds.test.mjs
index 8afe6ea8b..3867b1225 100644
--- a/src/data/transitFeeds.test.mjs
+++ b/src/data/transitFeeds.test.mjs
@@ -701,7 +701,6 @@ test('trams, waterbuses and buses are told apart where the ids allow it', () =>
   const mode = (id, routeId) => transitModeFor(getTransitFeed(id), routeId);
   assert.equal(mode('pid-praha', 'L22'), 'tram');
   assert.equal(mode('pid-praha', 'L135'), 'bus');
-  assert.equal(mode('tbm-bordeaux', 'A'), 'tram');
   assert.equal(mode('tbm-bordeaux', '16'), 'bus');
   assert.equal(mode('lia-le-havre', 'B'), 'tram');
   assert.equal(mode('lia-le-havre', '3'), 'bus');
@@ -719,3 +718,59 @@ test('feeds that publish km/h are marked for conversion, and only those', () =>
     'tam-montpellier',
   ]);
 });
+
+// Route ids as the live feeds and the operators' own GTFS routes.txt carried
+// them on 2026-11-09: the ranges and numbered tram ids are not guessable from
+// the line names riders see.
+test('Prague route-id ranges give metro, trains, ferries and trolleybuses their mode', () => {
+  const feed = getTransitFeed('pid-praha');
+  const read = (routeId) => [
+    transitModeFor(feed, routeId),
+    transitRouteLabel(feed, routeId),
+  ];
+  assert.deepEqual(read('L22'), ['tram', '22']);
+  assert.deepEqual(read('L58'), ['bus', '58'], 'trolleybus');
+  assert.deepEqual(read('L49'), ['rail', 'LD'], 'Petřín funicular');
+  assert.deepEqual(read('L135'), ['bus', '135']);
+  assert.deepEqual(read('L803'), ['bus', 'X3']);
+  assert.deepEqual(read('L991'), ['subway', 'A']);
+  assert.deepEqual(read('L993'), ['subway', 'C']);
+  assert.deepEqual(read('L1004'), ['rail', 'S4']);
+  assert.deepEqual(read('L1109'), ['rail', 'R9']);
+  assert.deepEqual(read('L1204'), ['rail', 'L1204'], 'no label to derive');
+  assert.deepEqual(read('L1801'), ['ferry', 'P1']);
+  assert.deepEqual(read('L1703'), ['bus', 'L1703']);
+  assert.deepEqual(read('L2841'), ['bus', '841']);
+  assert.deepEqual(read('S4'), ['bus', 'S4'], 'unknown ids keep the default');
+});
+
+test('Bordeaux trams ride numbered route ids and keep their letters', () => {
+  const feed = getTransitFeed('tbm-bordeaux');
+  for (const [routeId, line] of [
+    ['59', 'A'],
+    ['62', 'D'],
+    ['163', 'E'],
+  ]) {
+    assert.equal(transitModeFor(feed, routeId), 'tram', routeId);
+    assert.equal(transitRouteLabel(feed, routeId), line);
+  }
+  assert.equal(transitModeFor(feed, '952'), 'ferry');
+  assert.equal(transitModeFor(feed, '01'), 'bus');
+  assert.equal(transitRouteLabel(feed, '01'), '1');
+});
+
+test('Rouen Métro and Calypso are not buses', () => {
+  const feed = getTransitFeed('astuce-rouen');
+  assert.equal(transitModeFor(feed, 'TCAR:90'), 'tram');
+  assert.equal(transitRouteLabel(feed, 'TCAR:90'), 'Métro');
+  assert.equal(transitModeFor(feed, 'TCAR:99'), 'ferry');
+  assert.equal(transitModeFor(feed, 'TCAR:93'), 'bus');
+  assert.equal(transitRouteLabel(feed, 'TAE:F'), 'F');
+  assert.equal(transitModeFor(getTransitFeed('lia-le-havre'), 'FUNI'), 'rail');
+});
+
+test('data.gov.my feeds ask the proxy for no more than its 4 a minute', () => {
+  for (const id of ['mybas-johor', 'mybas-kota-bharu']) {
+    assert.ok(getTransitFeed(id).refreshMs >= 30_000, id);
+  }
+});
diff --git a/src/data/transitProxy.js b/src/data/transitProxy.js
index 68280d132..6b328e5a5 100644
--- a/src/data/transitProxy.js
+++ b/src/data/transitProxy.js
@@ -268,17 +268,32 @@ export function buildTransitSnapshot(feed, bytes, now = Date.now()) {
   };
 }
 
+/**
+ * Fresh window for one feed's cached snapshot: the shared TTL, stretched by a
+ * registry `refreshMs` for upstreams that rate-limit below one request per
+ * TTL (data.gov.my allows 4 a minute). Never shorter than the shared TTL.
+ * @param {{ refreshMs?: number }|null|undefined} feed Registry entry.
+ * @returns {number}
+ */
+export function transitFeedTtlMs(feed) {
+  const refresh = feed?.refreshMs;
+  return Number.isFinite(refresh) && refresh > TRANSIT_PROXY_TTL_MS
+    ? refresh
+    : TRANSIT_PROXY_TTL_MS;
+}
+
 /**
  * Classify a cache entry for the request policy.
  * @param {{ at: number }|null|undefined} entry Cached snapshot (`at` = fetch ms).
  * @param {number} now
+ * @param {number} [ttlMs] Fresh window; `transitFeedTtlMs(feed)` for a feed.
  * @returns {'none'|'fresh'|'stale'|'expired'}
  */
-export function transitCacheState(entry, now) {
+export function transitCacheState(entry, now, ttlMs = TRANSIT_PROXY_TTL_MS) {
   if (!entry || !Number.isFinite(entry.at)) return 'none';
   const age = now - entry.at;
   if (age < 0) return 'fresh';
-  if (age < TRANSIT_PROXY_TTL_MS) return 'fresh';
+  if (age < ttlMs) return 'fresh';
   if (age < TRANSIT_PROXY_STALE_MAX_MS) return 'stale';
   return 'expired';
 }
diff --git a/src/data/transitProxy.test.mjs b/src/data/transitProxy.test.mjs
index 1c9f6679f..63f950f58 100644
--- a/src/data/transitProxy.test.mjs
+++ b/src/data/transitProxy.test.mjs
@@ -12,6 +12,7 @@ import {
   repairVehicleTimestamps,
   resolveTransitRoute,
   transitCacheState,
+  transitFeedTtlMs,
   transitRedirectDecision,
   transitResponseHeaders,
   transitUpstreamHeaders,
@@ -406,3 +407,14 @@ test('Adelaide asks for */* because a protobuf Accept gets base64 text back', ()
     /protobuf/,
   );
 });
+
+test('a feed refreshMs stretches its fresh window, never shortens it', () => {
+  const johor = getTransitFeed('mybas-johor');
+  assert.equal(transitFeedTtlMs(johor), 30_000);
+  assert.equal(transitFeedTtlMs(getTransitFeed('mbta')), TRANSIT_PROXY_TTL_MS);
+  assert.equal(transitFeedTtlMs({ refreshMs: 1_000 }), TRANSIT_PROXY_TTL_MS);
+  const now = 1_000_000;
+  const entry = { at: now - 20_000 };
+  assert.equal(transitCacheState(entry, now), 'stale');
+  assert.equal(transitCacheState(entry, now, transitFeedTtlMs(johor)), 'fresh');
+});
diff --git a/src/layers/transit/ingestion.js b/src/layers/transit/ingestion.js
index 22b179120..afce6a4aa 100644
--- a/src/layers/transit/ingestion.js
+++ b/src/layers/transit/ingestion.js
@@ -401,7 +401,13 @@ export function createIngestion({ state, services, parts, source }) {
       );
     }
     if (state._viewer)
-      registerDynamicCredit(state._viewer, transitFeedCredit(feed));
+      registerDynamicCredit(
+        state._viewer,
+        transitFeedCredit(feed, {
+          feedTimestamp: snapshot?.feedTimestamp,
+          fetchedAt,
+        }),
+      );
     if (
       state._selectedKey &&
       state._vehicles.get(state._selectedKey)?.feedId === feed.id
diff --git a/src/sources/transitService.js b/src/sources/transitService.js
index 1b6b46d78..328b82711 100644
--- a/src/sources/transitService.js
+++ b/src/sources/transitService.js
@@ -25,6 +25,7 @@ import {
   nextTransitBackoffMs,
   resolveTransitRoute,
   transitCacheState,
+  transitFeedTtlMs,
   transitRedirectDecision,
   transitResponseHeaders,
   transitUpstreamHeaders,
@@ -266,7 +267,7 @@ export function createTransitService({ fetchImpl = fetch } = {}) {
       );
     }
     const cached = cache.get(feed.id);
-    const state = transitCacheState(cached, now);
+    const state = transitCacheState(cached, now, transitFeedTtlMs(feed));
     if (state === 'fresh') {
       return reply(
         200,

From 2c1b2c278ddabf7eda6536558d60a37a6d52ac16 Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Mon, 9 Nov 2026 13:58:20 +0000
Subject: [PATCH 34/71] fix(transit): read Rouen and Le Havre from the
 operators' own feeds
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rouen now reads Métropole Rouen Normandie's TCAR vehicle feed
(api.mrn.cityway.fr) and Le Havre LiA's own GTFS-RT
(opendata.transports-lia.fr), both listed in their transport.data.gouv.fr
records, instead of the unofficial bus-tracker.fr relay. LiA ids carry an
8- prefix, so a new liaRouteLabel strips it and liaRouteMode reads the line.
---
 DATA_SOURCES.md                |  4 ++--
 src/data/transitFeeds.js       | 39 ++++++++++++++++++----------------
 src/data/transitFeeds.test.mjs | 12 +++++++----
 3 files changed, 31 insertions(+), 24 deletions(-)

diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index a302235fd..31753ade5 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -133,9 +133,9 @@ How to read this:
 | **Carris (Lisbon city)** (gateway.carris.pt) | Transit layer live vehicles, Lisbon, Portugal | No licence stated (https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2930). Keyless official gateway; no licence found. Same basis as Metro Transit and OVapi. Carries neither bearing nor speed, and vehicle reports run about a minute old. Route ids append a variant. | Carris |
 | **BAS.MY Johor Bahru** (api.data.gov.my) | Transit layer live vehicles, Johor Bahru, Malaysia | CC BY 4.0 (https://developer.data.gov.my/realtime-api/gtfs-realtime). Stated: “All GTFS Realtime feeds are licensed under CC BY 4.0.” Served keyless by Malaysia’s national open-data API, which caps GTFS Realtime at 4 requests a minute and refreshes positions every 30 seconds, so the proxy caches this feed for 30 seconds. Without the trailing slash the API redirects. Route ids append an operator code. | BAS.MY / data.gov.my |
 | **BAS.MY Kota Bharu** (api.data.gov.my) | Transit layer live vehicles, Kota Bharu, Malaysia | CC BY 4.0 (https://developer.data.gov.my/realtime-api/gtfs-realtime). Same API, licence and rate limit as Johor Bahru. | BAS.MY / data.gov.my |
-| **Rouen Astuce** (gtfs.bus-tracker.fr) | Transit layer live vehicles, Rouen, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/donnees-statiques-et-temps-reel-du-reseau-astuce-metropole-rouen-normandie). The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted); this registry reads it through bus-tracker.fr, an unofficial relay that merges the city’s networks into one GTFS-RT file. Route ids carry the network prefix (`TCAR:`); line 90 is the Métro (a street-running light rail, drawn as a tram) and 99 the Calypso boat. | Métropole Rouen Normandie (Astuce) / bus-tracker.fr |
+| **Rouen Astuce** (api.mrn.cityway.fr) | Transit layer live vehicles, Rouen, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/donnees-statiques-et-temps-reel-du-reseau-astuce-metropole-rouen-normandie). The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted); and this is its own TCAR vehicle feed from that record; the suburban TAE and TNI networks are separate feeds and are not read. Route ids carry the network prefix (`TCAR:`); line 90 is the Métro (a street-running light rail, drawn as a tram) and 99 the Calypso boat. | Métropole Rouen Normandie (Astuce) |
 | **Toulon Mistral** (feed-rdtpm-toulon.ratpdev.com) | Transit layer live vehicles, Toulon, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/reseau-de-transport-urbain-de-la-metropole-toulon-provence-mediterranee). Dataset record’s licence field quoted. Speeds are km/h: readings ran 3.5 times the measured movement on 2026-11-07, so the proxy converts them. Route ids are zero-padded. | Métropole Toulon Provence Méditerranée (Mistral) |
-| **Le Havre LiA** (gtfs.bus-tracker.fr) | Transit layer live vehicles, Le Havre, France | ODbL (https://transport.data.gouv.fr/datasets/reseau-de-transport-en-commun-lia-gtfs-siri). The network publishes under ODbL (dataset record quoted); read through the bus-tracker.fr relay, which converts its SIRI feed to GTFS-RT. The layer draws positions and redistributes no database. Lines A and B are the tramway. | Le Havre Seine Métropole (LiA) / bus-tracker.fr |
+| **Le Havre LiA** (opendata.transports-lia.fr) | Transit layer live vehicles, Le Havre, France | ODbL (https://transport.data.gouv.fr/datasets/reseau-de-transport-en-commun-lia-gtfs-siri). The network publishes under ODbL (dataset record quoted); and this is its own GTFS-RT vehicle feed from that record; route ids carry the network prefix `8-`. The layer draws positions and redistributes no database. Lines A and B are the tramway. | Le Havre Seine Métropole (LiA) |
 | **Tours Fil Bleu** (data.filbleu.fr) | Transit layer live vehicles, Tours, France | Licence Ouverte 2.0 (https://transport.data.gouv.fr/datasets/fil-bleu-syndicat-des-mobilites-gtfs-gtfs-rt). Dataset record’s licence field quoted. | Fil Bleu – Syndicat des Mobilités de Touraine |
 | **Radio Browser**                                                     | Geolocated internet-radio station directory and station-level tags                                                                  | Public-domain directory data under PDDL 1.0; individual broadcaster stream terms apply                                                                                                                                                                                                                                                                | "Radio Browser" plus a link to the selected broadcaster                                                                                     |
 | **Re:Earth Terrain** (Mapterhorn)                                     | Terrain (keyless globe stacks — OSM etc. — + `/api/terrain/heights` ellipsoidal-height lookups)                                     | Terrain mesh: CC BY 4.0; geoid: EGM2008 (NGA, public domain)                                                                                                                                                                                                                                                                                          | "Terrain (keyless globe stacks): Re:Earth Terrain / Mapterhorn (CC BY 4.0) / EGM2008 (NGA)"                                                 |
diff --git a/src/data/transitFeeds.js b/src/data/transitFeeds.js
index 7f2d79a02..e9aeb4359 100644
--- a/src/data/transitFeeds.js
+++ b/src/data/transitFeeds.js
@@ -426,11 +426,14 @@ const actvRouteLabel = routeIdPattern(/^(.+)_[A-Z]{2}$/);
 const bcTransitRouteLabel = routeIdPattern(/^(.+)-VIC$/);
 /** Carris (Lisbon city) appends a variant: `172_1` is route 172. */
 const carrisRouteLabel = routeIdPattern(/^(\w+)_\d+$/);
-/** bus-tracker.fr prefixes the network: `TCAR:93` is Rouen line 93. */
-const busTrackerRouteLabel = routeIdPattern(/^[A-Z]+:(.+)$/);
+/** Astuce prefixes the network: `TCAR:93` is Rouen line 93. */
+const astuceNetworkLabel = routeIdPattern(/^[A-Z]+:(.+)$/);
 /** BAS.MY Johor appends a fixed operator code: `J33CWLMYJB` is route J33. */
 const mybasJohorRouteLabel = routeIdPattern(/^(.+?)CWLMYJB$/);
 
+/** LiA prefixes its network: `8-C3` is Le Havre line C3, `8-09` line 9. */
+const liaRouteLabel = routeIdPattern(/^8-0*(\w.*)$/);
+
 /**
  * Le Havre LiA runs its two tram lines as A and B and the funicular as
  * `FUNI`; every other line is a bus.
@@ -439,15 +442,15 @@ const mybasJohorRouteLabel = routeIdPattern(/^(.+?)CWLMYJB$/);
  */
 function liaRouteMode(routeId) {
   if (!routeId) return 'unknown';
-  if (routeId === 'FUNI') return 'rail';
-  return /^(?:[A-Z]+:)?[AB]$/.test(routeId) ? 'tram' : 'bus';
+  const line = liaRouteLabel(routeId);
+  if (line === 'FUNI') return 'rail';
+  return /^[AB]$/.test(line) ? 'tram' : 'bus';
 }
 
 /**
- * Rouen Astuce lines that are not buses, by bus-tracker.fr route id, from the
- * relay's own `astuce-tcar.zip` routes.txt (checked 2026-11-09): line 90 is
- * the Métro (GTFS type 1, a light rail that runs mostly on the street) and 99
- * the Calypso river boat.
+ * Rouen Astuce lines that are not buses, by route id, from the TCAR
+ * routes.txt (checked 2026-11-09): line 90 is the Métro (GTFS type 1, a light
+ * rail that runs mostly on the street) and 99 the Calypso river boat.
  */
 const ASTUCE_ROUTES = Object.freeze({
   'TCAR:90': Object.freeze({ mode: 'tram', label: 'Métro' }),
@@ -462,7 +465,7 @@ function astuceRouteMode(routeId) {
 
 /** `TCAR:93` is Rouen line 93; the Métro and Calypso keep their names. */
 function astuceRouteLabel(routeId) {
-  return ASTUCE_ROUTES[routeId ?? '']?.label ?? busTrackerRouteLabel(routeId);
+  return ASTUCE_ROUTES[routeId ?? '']?.label ?? astuceNetworkLabel(routeId);
 }
 
 /**
@@ -1504,18 +1507,18 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
   transitFeed({
     id: 'astuce-rouen',
     name: 'Rouen Astuce',
-    operator: 'Métropole Rouen Normandie (Astuce), relayed by bus-tracker.fr',
+    operator: 'Métropole Rouen Normandie (Astuce), réseau TCAR',
     region: 'Rouen, France',
     center: { lat: 49.44, lon: 1.1 },
     loadRadiusKm: 20,
-    url: 'https://gtfs.bus-tracker.fr/gtfs-rt/tcar/?tcar=1&tae=1&tni=1',
+    url: 'https://api.mrn.cityway.fr/dataflow/vehicle-tc-tr/download?provider=TCAR&dataFormat=gtfs-rt',
     license: 'Licence Ouverte 2.0',
     licenseUrl:
       'https://transport.data.gouv.fr/datasets/donnees-statiques-et-temps-reel-du-reseau-astuce-metropole-rouen-normandie',
-    attribution: 'Métropole Rouen Normandie (Astuce) / bus-tracker.fr',
+    attribution: 'Métropole Rouen Normandie (Astuce)',
     terms: {
       quote: 'licence: lov2',
-      note: 'The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted); this registry reads it through bus-tracker.fr, an unofficial relay that merges the city’s networks into one GTFS-RT file. Route ids carry the network prefix (`TCAR:`); `TCAR:90` is the Métro (a street-running light rail, drawn as a tram) and `TCAR:99` the Calypso boat.',
+      note: 'The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted), and this is its own TCAR vehicle feed from that record (178 vehicles on 2026-11-09). The suburban TAE and TNI networks are separate feeds in the same record and are not read here. Route ids carry the network prefix (`TCAR:`); `TCAR:90` is the Métro (a street-running light rail, drawn as a tram) and `TCAR:99` the Calypso boat.',
     },
     defaultMode: 'bus',
     routeLabel: astuceRouteLabel,
@@ -1544,21 +1547,21 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
   transitFeed({
     id: 'lia-le-havre',
     name: 'Le Havre LiA',
-    operator: 'Le Havre Seine Métropole (LiA), relayed by bus-tracker.fr',
+    operator: 'Le Havre Seine Métropole (LiA)',
     region: 'Le Havre, France',
     center: { lat: 49.49, lon: 0.11 },
     loadRadiusKm: 18,
-    url: 'https://gtfs.bus-tracker.fr/gtfs-rt/lia/vehicle-positions',
+    url: 'https://opendata.transports-lia.fr/gtfs-rt/VehiclePosition.pb',
     license: 'ODbL',
     licenseUrl:
       'https://transport.data.gouv.fr/datasets/reseau-de-transport-en-commun-lia-gtfs-siri',
-    attribution: 'Le Havre Seine Métropole (LiA) / bus-tracker.fr',
+    attribution: 'Le Havre Seine Métropole (LiA)',
     terms: {
       quote: 'licence: odc-odbl',
-      note: 'The network publishes under ODbL (dataset record quoted); read through the bus-tracker.fr relay, which converts its SIRI feed to GTFS-RT. The layer draws positions and redistributes no database. Lines A and B are the tramway.',
+      note: 'The network publishes under ODbL (dataset record quoted), and this is its own GTFS-RT vehicle feed from that record (105 vehicles on 2026-11-09). The layer draws positions and redistributes no database. Route ids carry the network prefix `8-`; lines A and B are the tramway.',
     },
     defaultMode: 'bus',
-    routeLabel: busTrackerRouteLabel,
+    routeLabel: liaRouteLabel,
     routeMode: liaRouteMode,
   }),
   transitFeed({
diff --git a/src/data/transitFeeds.test.mjs b/src/data/transitFeeds.test.mjs
index 3867b1225..75a902728 100644
--- a/src/data/transitFeeds.test.mjs
+++ b/src/data/transitFeeds.test.mjs
@@ -702,8 +702,8 @@ test('trams, waterbuses and buses are told apart where the ids allow it', () =>
   assert.equal(mode('pid-praha', 'L22'), 'tram');
   assert.equal(mode('pid-praha', 'L135'), 'bus');
   assert.equal(mode('tbm-bordeaux', '16'), 'bus');
-  assert.equal(mode('lia-le-havre', 'B'), 'tram');
-  assert.equal(mode('lia-le-havre', '3'), 'bus');
+  assert.equal(mode('lia-le-havre', '8-B'), 'tram');
+  assert.equal(mode('lia-le-havre', '8-C3'), 'bus');
   assert.equal(mode('ztp-krakow-tram', null), 'tram');
   assert.equal(mode('actv-venezia-waterbus', '1_UN'), 'ferry');
 });
@@ -759,14 +759,18 @@ test('Bordeaux trams ride numbered route ids and keep their letters', () => {
   assert.equal(transitRouteLabel(feed, '01'), '1');
 });
 
-test('Rouen Métro and Calypso are not buses', () => {
+test('Rouen Métro and Calypso are not buses; Le Havre reads its own ids', () => {
   const feed = getTransitFeed('astuce-rouen');
   assert.equal(transitModeFor(feed, 'TCAR:90'), 'tram');
   assert.equal(transitRouteLabel(feed, 'TCAR:90'), 'Métro');
   assert.equal(transitModeFor(feed, 'TCAR:99'), 'ferry');
   assert.equal(transitModeFor(feed, 'TCAR:93'), 'bus');
   assert.equal(transitRouteLabel(feed, 'TAE:F'), 'F');
-  assert.equal(transitModeFor(getTransitFeed('lia-le-havre'), 'FUNI'), 'rail');
+  const lia = getTransitFeed('lia-le-havre');
+  assert.equal(transitModeFor(lia, '8-FUNI'), 'rail');
+  assert.equal(transitRouteLabel(lia, '8-C3'), 'C3');
+  assert.equal(transitRouteLabel(lia, '8-09'), '9');
+  assert.equal(transitRouteLabel(lia, '8-A'), 'A');
 });
 
 test('data.gov.my feeds ask the proxy for no more than its 4 a minute', () => {

From 3e630cf34fbefe4deb63d46432e983dd975f9c0b Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Mon, 9 Nov 2026 14:34:33 +0000
Subject: [PATCH 35/71] fix(transit): mark route line names as kept for i18n
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Métro, Calypso, LD and the metro letters are line names as signed, not UI
copy; the i18n catalog check flagged them.
---
 src/data/transitFeeds.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/data/transitFeeds.js b/src/data/transitFeeds.js
index e9aeb4359..42f399d77 100644
--- a/src/data/transitFeeds.js
+++ b/src/data/transitFeeds.js
@@ -453,7 +453,9 @@ function liaRouteMode(routeId) {
  * rail that runs mostly on the street) and 99 the Calypso river boat.
  */
 const ASTUCE_ROUTES = Object.freeze({
+  // i18n-ignore: line name, as on the vehicle
   'TCAR:90': Object.freeze({ mode: 'tram', label: 'Métro' }),
+  // i18n-ignore: line name, as on the vehicle
   'TCAR:99': Object.freeze({ mode: 'ferry', label: 'Calypso' }),
 });
 
@@ -484,11 +486,13 @@ function pidRoute(routeId) {
   const match = /^L(\d+)$/.exec(routeId ?? '');
   if (!match) return { mode: 'unknown', label: routeId };
   const n = Number(match[1]);
+  // i18n-ignore: line code, as signed
   if (n === 49) return { mode: 'rail', label: 'LD' };
   if (n >= 50 && n <= 59) return { mode: 'bus', label: String(n) };
   if (n < 100) return { mode: 'tram', label: String(n) };
   if (n >= 800 && n < 900) return { mode: 'bus', label: `X${n - 800}` };
   if (n < 991) return { mode: 'bus', label: String(n) };
+  // i18n-ignore: metro line letters, as signed
   if (n <= 993) return { mode: 'subway', label: 'ABC'[n - 991] };
   if (n >= 1000 && n < 1100) return { mode: 'rail', label: `S${n - 1000}` };
   if (n >= 1100 && n < 1200) return { mode: 'rail', label: `R${n - 1100}` };

From c3738c0fdb8dfeb0e2add30bbbd79f03915c2af5 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Mon, 9 Nov 2026 19:07:14 +0400
Subject: [PATCH 36/71] docs(server): tighten the method-guard comments and
 changelog

---
 changelog.d/794-api-method-guard.md   | 11 ++++-------
 docs/CURRENT-STATE.md                 |  2 +-
 server/providers/aircraft/adsb-lol.js |  4 +---
 server/providers/aircraft/opensky.js  |  5 +----
 server/providers/places/routes.js     |  2 --
 src/tooling/liveProviders.test.mjs    | 13 ++++---------
 src/tooling/placeProviders.test.mjs   |  6 ++----
 7 files changed, 13 insertions(+), 30 deletions(-)

diff --git a/changelog.d/794-api-method-guard.md b/changelog.d/794-api-method-guard.md
index 530be060e..97801e091 100644
--- a/changelog.d/794-api-method-guard.md
+++ b/changelog.d/794-api-method-guard.md
@@ -1,7 +1,4 @@
-- The read-only query proxies state their method contract. `/api/flights`,
-  `/api/military` and `/api/route` answered any verb with the same body
-  while ignoring the request; they now answer `405 Method Not Allowed` to
-  anything but `GET`, the way `/api/geocode` and the other query proxies
-  already did, and declare `Allow: GET` with it the way `/api/radio/stations`
-  does. The refusal precedes rate limiting and any upstream call
-  (daikaginza, #794).
+- Answer `405 Method Not Allowed` with `Allow: GET` to anything but `GET` on
+  `/api/flights`, `/api/military` and `/api/route`, as the other query proxies
+  do. They answered every verb with the same body. The refusal comes before
+  rate limiting and any upstream call (daikaginza, #794).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index f2569f363..6a3b07c5d 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -6491,7 +6491,7 @@ apply to `public/` assets or built-preview serving.
 - `/api/overpass` is bounded by body/response caps, per-client/global rate limits, concurrency limits, operator-configured upstreams, in-flight dedupe, cache bounds, and static validation that every selector is spatially bounded.
 - `/api/military-installations` uses an independent limiter with the same 90-per-client/300-global one-minute bounds, so viewport installation refreshes never consume `/api/overpass` annotation capacity.
 - `/api/route` proxies bounded OSRM route requests for annotation routes, with profile allowlisting, distance caps, response caps, caching, and sanitized "no route found" errors.
-- `/api/flights`, `/api/military`, and `/api/route` are read-only query proxies and answer `405 Method Not Allowed` to anything but `GET`, as `/api/geocode` and the other query proxies already did, declaring `Allow: GET` with it as `/api/radio/stations` does. The refusal precedes rate limiting and any upstream call.
+- `/api/flights`, `/api/military`, and `/api/route` answer `405 Method Not Allowed` with `Allow: GET` to anything but `GET`, before rate limiting and any upstream call.
 - `/api/flights` negotiates gzip. The cached global snapshot and the regional adsb.lol fallback are each gzipped once per refresh (about 860 KB becomes about 250 KB). Clients that offer gzip get that frame; other clients, and bodies under 1 KiB or that gzip cannot shrink, get identity bytes. Both answers carry `Vary: Accept-Encoding`. Uncached bodies, such as auth failures, are never sent under a cached frame's encoding.
 - Track endpoints: `/api/vessels/track?mmsi=` (server-accumulated ring buffers; sub-route handled before the rows snapshot), `/api/flights/track?icao24=` (OAuth, 60s cache, sanitized errors, independent OpenSky credit bucket), `/api/military/track?hex=` (400 for an invalid hex, otherwise `503 history_unavailable` with `Retry-After: 1800` and `Cache-Control: no-store`, no upstream request; military tracking uses its locally accumulated trail).
 - Realtime debug logs redact API keys, bearer tokens, client secrets, and image data URLs before writing to disk; request bodies are size-capped.
diff --git a/server/providers/aircraft/adsb-lol.js b/server/providers/aircraft/adsb-lol.js
index 80aacc7c4..6bdc65e9f 100644
--- a/server/providers/aircraft/adsb-lol.js
+++ b/server/providers/aircraft/adsb-lol.js
@@ -83,9 +83,7 @@ export function adsbLolProxy() {
         // This mount also matches its /track route, served by its own handler.
         if (new URL(req.url || '/', 'http://localhost').pathname !== '/')
           return next();
-        // Read-only snapshot endpoint; match the method contract its sibling
-        // query proxies already declare instead of serving every verb alike.
-        // Checked after the /track hand-off, so that route keeps its own.
+        // After the /track hand-off, so /track keeps its own method handling.
         if (req.method !== 'GET') {
           res.writeHead(405, {
             'Content-Type': 'application/json',
diff --git a/server/providers/aircraft/opensky.js b/server/providers/aircraft/opensky.js
index 0a23978a5..1cc30a482 100644
--- a/server/providers/aircraft/opensky.js
+++ b/server/providers/aircraft/opensky.js
@@ -496,10 +496,7 @@ export function openSkyProxy() {
         // This mount also matches its /track route, served by its own handler.
         if (new URL(req.url || '/', 'http://localhost').pathname !== '/')
           return next();
-        // Read-only snapshot endpoint: state the method contract the way
-        // /api/geocode and the other query proxies state it, rather than
-        // answering any verb with the same body and ignoring the request body.
-        // Checked after the /track hand-off, so that route keeps its own.
+        // After the /track hand-off, so /track keeps its own method handling.
         if (req.method !== 'GET') {
           res.writeHead(405, {
             'Content-Type': 'application/json',
diff --git a/server/providers/places/routes.js b/server/providers/places/routes.js
index 2c67f1f5c..7b0a81449 100644
--- a/server/providers/places/routes.js
+++ b/server/providers/places/routes.js
@@ -227,8 +227,6 @@ export function installRouteMiddleware(
   // only shape that asks the upstream for them. A response WITHOUT steps is
   // byte for byte what this endpoint has always returned.
   middlewares.use('/api/route', async (req, res) => {
-    // The documented shape above is a GET with query parameters; say so,
-    // the way the other query proxies do, instead of answering any verb.
     if (req.method !== 'GET') {
       res.writeHead(405, { 'Content-Type': 'application/json', Allow: 'GET' });
       res.end(JSON.stringify({ error: 'Method Not Allowed' }));
diff --git a/src/tooling/liveProviders.test.mjs b/src/tooling/liveProviders.test.mjs
index e40e4079c..df71ec9a7 100644
--- a/src/tooling/liveProviders.test.mjs
+++ b/src/tooling/liveProviders.test.mjs
@@ -586,10 +586,7 @@ test('track backfill proxy returns 502 on an oversized upstream body and caches
 });
 
 test('the aircraft snapshot routes decline a non-GET before any upstream work', async (t) => {
-  // Both routes answered every verb with the full snapshot, unlike the query
-  // proxies beside them, so nothing said whether a body was read or ignored.
-  // A stubbed fetch that throws proves the refusal happens before the handler
-  // reaches upstream, rather than after paying for the work and discarding it.
+  // A fetch that throws proves the refusal comes before any upstream call.
   t.mock.method(globalThis, 'fetch', async (url) => {
     throw new Error(`upstream must not be reached: ${url}`);
   });
@@ -601,8 +598,7 @@ test('the aircraft snapshot routes decline a non-GET before any upstream work',
     for (const method of ['POST', 'PUT', 'DELETE', 'PATCH']) {
       const response = await request(route, '/', method);
       assert.equal(response.statusCode, 405, `${method} ${route}`);
-      // RFC 9110 section 15.5.6 requires a 405 to name the methods it does
-      // accept, which is what `/api/radio/stations` already does in-tree.
+      // RFC 9110 section 15.5.6: a 405 names the methods it accepts.
       assert.equal(response.headers.allow, 'GET', `${method} ${route}`);
       assert.deepEqual(JSON.parse(response.body), {
         error: 'Method Not Allowed',
@@ -612,9 +608,8 @@ test('the aircraft snapshot routes decline a non-GET before any upstream work',
 });
 
 test('the snapshot method check hands each /track route on to its own handler', async () => {
-  // Each snapshot mount is a prefix of its /track route, so the snapshot
-  // handler sees /track requests first and must hand them on before it
-  // judges the method; otherwise the 405 would answer for the other route.
+  // The snapshot mount also matches /track, so it must hand /track on
+  // before it checks the method.
   for (const [plugin, route] of [
     [providers.openSkyProxy(), '/api/flights'],
     [providers.adsbLolProxy(), '/api/military'],
diff --git a/src/tooling/placeProviders.test.mjs b/src/tooling/placeProviders.test.mjs
index 4b728b6ac..4ae9558ff 100644
--- a/src/tooling/placeProviders.test.mjs
+++ b/src/tooling/placeProviders.test.mjs
@@ -502,9 +502,7 @@ test('the upstream host is pinned: a redirect is refused, not followed', async (
 });
 
 test('the routing proxy declines a non-GET before rate limiting or upstream', async (t) => {
-  // The documented shape is a GET with query parameters, but every verb was
-  // answered alike. Refuse first: a stubbed fetch that throws shows the
-  // rejection costs neither an upstream call nor a rate-limit slot.
+  // A fetch that throws proves the refusal comes before any upstream call.
   const request = install(installRouteMiddleware);
   t.mock.method(globalThis, 'fetch', async () => {
     throw new Error('upstream must not be reached');
@@ -516,7 +514,7 @@ test('the routing proxy declines a non-GET before rate limiting or upstream', as
       method,
     );
     assert.equal(response.statusCode, 405, method);
-    // RFC 9110 section 15.5.6 requires a 405 to name the methods it accepts.
+    // RFC 9110 section 15.5.6: a 405 names the methods it accepts.
     assert.equal(response.headers.allow, 'GET', method);
     assert.deepEqual(response.body, { error: 'Method Not Allowed' });
   }

From cdf52ab290497bda4ff23cc00cfba156524e5389 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Mon, 9 Nov 2026 19:07:14 +0400
Subject: [PATCH 37/71] test(server): drop unused fields from the /track
 hand-off stub

---
 src/tooling/liveProviders.test.mjs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/tooling/liveProviders.test.mjs b/src/tooling/liveProviders.test.mjs
index df71ec9a7..070a6f997 100644
--- a/src/tooling/liveProviders.test.mjs
+++ b/src/tooling/liveProviders.test.mjs
@@ -620,8 +620,6 @@ test('the snapshot method check hands each /track route on to its own handler',
     });
     const res = {
       statusCode: 200,
-      headers: {},
-      setHeader() {},
       writeHead(s) {
         this.statusCode = s;
       },

From 4da477a654e64333930bb74d2cf5b047d7c464f1 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 9 Nov 2026 07:16:14 -0800
Subject: [PATCH 38/71] feat(draw): hand one drawn area or line back to the
 application

createApplicationTools returns drawShape({ shape, signal }): it opens Draw
for one area or line and resolves with its Polygon or LineString without
placing a mark, or null when draw mode is left, the signal aborts, a newer
request replaces it, the pointer is held elsewhere or the tool goes. The
shape controls cannot change the asked-for shape, and a shape across the
antimeridian is refused as a row's actions refuse it and drawn again. It
also returns pointerFree, so an application's own click handlers yield to a
tool holding the pointer, as the layers' do.
---
 CHANGELOG.md                               |   5 +
 docs/CURRENT-STATE.md                      |   1 +
 src/annotations/drawTool.js                |  66 ++++++++-
 src/annotations/drawToolBehaviour.test.mjs | 152 +++++++++++++++++++++
 src/app/tools.js                           |  15 +-
 5 files changed, 237 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 356289841..89ae0e1e5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+- Applications can ask Draw for one area or line and get its geometry back
+  without placing a mark (`drawShape` from `createApplicationTools`), and their
+  own click handlers can yield while a tool holds the pointer, as the layers'
+  do (`pointerFree`) (samehkhamis).
+
 ## [0.3.0] — 2026-10-27 — Street Level, On Your Phone, in Your Language
 
 - Show a Street Level view facing 359.5° or more as 0°. The viewer caption
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 08dc69d1f..b70dc1d92 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -6311,6 +6311,7 @@ request viewbox and continues searching without that geographic preference.
 - UTILITIES ▸ **Draw** turns the globe into a whiteboard drawn by hand. Pick a shape (icon buttons for Area, Line and Pin) and a colour swatch for the next shape, click the vertices on the real world, and finish. **Keyboard contract, live only while Draw is on and never while you are typing in another field:** Enter finishes the shape (as does a double-click, and the two cannot both submit it — the session is replaced before the annotate call is awaited); Backspace removes the last vertex; Esc cancels the shape in progress, and a second Esc — Esc on an empty session — leaves draw mode. **Clear** wipes the board (the shape in progress and every placed mark), so removing marks does not require the console or the microphone.
 - **Drawn shapes are listed under Draw like Import's files** (`src/ui/views/panels/DrawMarkList.vue`, rows worded by `presentDrawMarks` in `src/annotations/drawMarks.js`): one row per hand-drawn mark (`manual: true`; voice marks are not listed) with its colour swatch, its name, and show/hide, fly-to and remove. The draw tool publishes the rows with the rest of its controls and answers the row actions (`renameDrawMark`, `recolorDrawMark`, `toggleDrawMark`, `flyToDrawMark`, `removeDrawMark`) through the display store; it republishes on the engine's `onChange`, so a voice clear or an expiry updates the list. Rows are keyed and updated in place: a board change never takes a name being typed (the field keeps its draft while focused) or the button under a click. The name is saved on Enter or on leaving the field, once; Esc restores it, before anything else and with the row's colours open too. Both keep focus in the field, so neither drops it to the page or leaves Draw. The swatch opens the five colours right after it (shown at the end of the row), with the current colour focused; the arrows, Home and End try another, and a click or Esc closes them and returns focus to the swatch. Both colour groups (the next shape's and a row's) are one `DrawSwatches` radio group with a single tab stop, coloured from `DRAW_COLOR_CSS`; on touch screens each dot answers a 24 px target. An unnamed shape shows its kind, and an unnamed line its length; a renamed line keeps its length (`Ridge walk — 950 m`). **Hidden** keeps a mark on the board at alpha 0, and the world renderer takes every one of its entities out (`show = false`), so no material that keeps its own colour (the line's flowing stroke) still paints it; the screen renderer does not project a hidden callout, so it cannot push a visible label aside; `fly_route` skips a hidden route; and with every mark hidden the annotations render hold is released. **Fly to** is an immediate navigation (`runImmediateNavigation('drawing', …)`), like Import's: Cockpit refuses it and a running orbit, follow or track lets go first. A line is framed by its whole path, across the antimeridian too.
 - Runtime entry: `createApplicationTools` (`src/app/tools.js`, behind the `src/standalone/tools.js` shim) calls `initDrawTool({ viewer, annotations, navigation, publish, connect, markActions })` after `initAnnotations` and defers its `destroy()`, so disposing the shell returns every DOM listener, the Cesium handler, the preview data source, the borrowed click actions and the `window.__gevDrawTool` handle. Its controls are Vue views in the UTILITIES panel (`DrawControls.vue`, `DrawMarkList.vue`) that render what the tool publishes to the display store and call its actions. That handle (`setActive`, `setShape`, `addVertex(lon, lat)`, `finish`, `cancel`, `clearAll`, `marks`, `setColor`, `diagnostics`) is the no-mouse test seam.
+- **One shape, handed back.** `createApplicationTools` also returns `drawShape({ shape, signal })` (`drawTool.drawShape`): it opens draw mode for one `area` or `line` and resolves with its geometry, a closed `[lon, lat]` `Polygon` or a `LineString`, without placing a mark; the shape chosen before comes back and draw mode ends. While it is open the controls cannot change the shape, and one across the antimeridian is refused as a row's actions refuse it ("That shape could not be placed.") and drawn again. It resolves `null` when the drawing is cancelled (the second Escape), draw mode is left, `signal` aborts, another request replaces it, the pointer is held elsewhere, the tool is destroyed, or the page has no Draw controls. It returns `pointerFree` (`data/inputOwnership.js` `isPointerFree`) too, so an application's own click handlers yield to the tool holding the pointer, as the layers' do.
 - **Row actions are an application's own.** `createApplicationTools({ drawMarkActions })` hands `initDrawTool` buttons for drawn areas' and lines' rows; the standalone shell passes none, so the open-source build shows no new button and makes no new request. Each action (`drawMarkActions` in `src/annotations/drawMarks.js`) is `{ id, icon, label(name), shapes: ['area', 'line'], accepts?(geometry, shape), run({ id, shape, name, title, geometry }) }`: the icon a Material Symbols name, the label worded by the application, `name` the person's own and `title` the row's (the name, else `Area` or `Line · 950 m`), the geometry `drawMarkGeometry`'s `[lon, lat]` `Polygon` (closed; a `MultiPolygon` for an area handle with several parts) or `LineString`, longitudes wrapped into [-180, 180]. A pin, and a shape that crosses the antimeridian or has a part that cannot be given whole, has no geometry and is offered nothing. Malformed actions and repeated ids are dropped once, at construction. What `run` returns or resolves to is a note under the row (`role=status`; past 200 characters it is cut at a word with an ellipsis); the row is busy (`aria-disabled`, no second press) until it settles, a rejection or a throw clears the note and is logged (so an action words its own refusals and resolves with them), and a shape's note goes with the shape, so a late answer never lands on a removed one.
 - Contract: a finished shape is submitted through the SAME `annotationEngine.annotate()` the voice agent uses, with geometry supplied and `manual: true` (`type: area` + `ring`, `type: route` + `path`, `type: pin` + coordinates). `resolveSpec` short-circuits manual specs (`resolveManualSpec`) so no geocoder, Places or Overpass call is made. A drawn area is a real (not synthesized) outline and drapes solid; a drawn line is a `route` with `mode: 'manual'`, labelled with its length and never a travel time; a pin is a point. Drawn marks therefore render with the whiteboard look, persist, appear in `.list()`, and clear with `clear_annotations` / `.clear()`. A drawn shape is never merged with another as a duplicate: every one is drawn on purpose, and every one is unnamed until its row names it, so two pins dropped close together are two pins.
 - **A vertex is a lon/lat, and the mark is DRAPED.** Clicks are picked through `pickWorldFromScreen` — one of two scene helpers the annotation resolver factory (`src/annotations/resolver.js`) exposes alongside `sampleGroundHeight`, so the app has ONE depth-aware pick cascade rather than a second written beside it — which returns the height the pick landed on as well as the coordinate, so the live preview hangs on the roof or hillside under the pointer instead of sinking to sea level. The world renderer draws areas and routes with `clampToGround`, so the height is dropped at finish in one place (`finishSpec`) rather than being carried downstream and discarded silently: what you get is the outline you drew, lying on the surface beneath it.
diff --git a/src/annotations/drawTool.js b/src/annotations/drawTool.js
index f44d30753..14a5929eb 100644
--- a/src/annotations/drawTool.js
+++ b/src/annotations/drawTool.js
@@ -54,6 +54,7 @@ import {
   DRAW_COLORS,
   DRAW_COLOR_CSS,
   drawMarkActions,
+  drawMarkGeometry,
   drawMarkActionsFor,
   drawMarkFallbackName,
   presentDrawMarks,
@@ -120,6 +121,9 @@ export function initDrawTool({
   let savedDoubleClick = null;
   let savedSingleClick = null;
   let cursor = null; // last mouse position on the canvas, for the rubber band
+  // One shape asked for by `drawShape`: `{ resolve, restoreShape, off }`. Its
+  // finish hands the geometry back instead of placing a mark.
+  let request = null;
   // Bumped by anything that supersedes an in-flight finish: cancelling, clearing
   // the board, leaving draw mode, teardown. An `annotate()` that resolves after
   // one of those must not write its outcome over the newer state.
@@ -280,6 +284,20 @@ export function initDrawTool({
     // Named afterwards, in the shape's row.
     const spec = finishSpec(session, { label: '', color });
     if (!spec) return null;
+    if (request) {
+      // As a row's actions get it: a shape across the antimeridian has none,
+      // and is drawn again rather than handed back wrapped round the world.
+      const geometry = drawMarkGeometry(spec);
+      if (!geometry) {
+        session = createDrawSession(shape);
+        cursor = null;
+        syncPreview();
+        setHint(() => t('That shape could not be placed.'));
+        return null;
+      }
+      endRequest(geometry);
+      return geometry;
+    }
     // Start a fresh session BEFORE awaiting, so a second Enter or the second
     // half of a double-click cannot submit the same shape twice.
     session = createDrawSession(shape);
@@ -407,6 +425,7 @@ export function initDrawTool({
       generation += 1;
       session = null;
       cursor = null;
+      endRequest(null);
       releaseSceneHandler();
       releasePointer(lease);
       lease = null;
@@ -532,6 +551,46 @@ export function initDrawTool({
     return true;
   }
 
+  /**
+   * Close the asked-for shape with `geometry` (null when there is none): the
+   * shape chosen before it comes back, and draw mode ends.
+   */
+  function endRequest(geometry) {
+    const open = request;
+    if (!open) return;
+    request = null;
+    open.off();
+    chooseShape(open.restoreShape);
+    open.resolve(geometry);
+    if (active) setActive(false);
+  }
+
+  /**
+   * Draw one area or line and hand back its geometry (a Polygon or a
+   * LineString) without placing a mark. Escape works as in Draw: the first
+   * clears a shape in progress, and one on an empty shape leaves. Resolves null
+   * when draw mode is left, `signal` aborts, or the pointer is taken.
+   * A second request ends the first with null.
+   * @param {{shape?: 'area'|'line', signal?: AbortSignal}} [options]
+   * @returns {Promise<{type: 'Polygon', coordinates: number[][][]}|{type: 'LineString', coordinates: number[][]}|null>}
+   */
+  function drawShape({ shape: wanted = 'area', signal } = {}) {
+    if (destroyed || signal?.aborted) return Promise.resolve(null);
+    endRequest(null);
+    const restoreShape = shape;
+    return new Promise((resolve) => {
+      const abort = () => endRequest(null);
+      signal?.addEventListener('abort', abort, { once: true });
+      request = {
+        resolve,
+        restoreShape,
+        off: () => signal?.removeEventListener('abort', abort),
+      };
+      chooseShape(normalizeShape(wanted) === 'line' ? 'line' : 'area');
+      if (!active && !setActive(true)) endRequest(null);
+    });
+  }
+
   /** Draw `next` from now on; an open shape starts over in it. */
   function chooseShape(next) {
     shape = normalizeShape(next);
@@ -545,7 +604,10 @@ export function initDrawTool({
   }
   const disconnect = connect({
     toggleDraw: () => setActive(!active),
-    setDrawShape: chooseShape,
+    // An asked-for shape is the one asked for.
+    setDrawShape: (next) => {
+      if (!request) chooseShape(next);
+    },
     setDrawColor: (value) => {
       color = DRAW_COLORS.includes(value) ? value : 'primary';
       present();
@@ -602,6 +664,7 @@ export function initDrawTool({
     finish,
     cancel,
     clearAll,
+    drawShape,
     shapes: DRAW_SHAPES,
     /** What this tool currently holds — for teardown and leak assertions. */
     diagnostics() {
@@ -638,6 +701,7 @@ export function initDrawTool({
       if (destroyed) return attaching;
       // Supersede any finish still in flight before anything is torn down.
       generation += 1;
+      endRequest(null);
       if (active) setActive(false);
       destroyed = true;
       offLocale();
diff --git a/src/annotations/drawToolBehaviour.test.mjs b/src/annotations/drawToolBehaviour.test.mjs
index 4cef4d4fe..276852248 100644
--- a/src/annotations/drawToolBehaviour.test.mjs
+++ b/src/annotations/drawToolBehaviour.test.mjs
@@ -704,6 +704,158 @@ test('what a row action answers is its row\'s note; the row is busy until then,
   }
 });
 
+test('drawShape hands back the drawn area as a polygon and places no mark', async () => {
+  const h = harness();
+  try {
+    h.act('setDrawShape', 'line');
+    const drawn = h.tool.drawShape({ shape: 'area' });
+    assert.equal(h.tool.active, true, 'it opens draw mode');
+    assert.equal(h.tool.shape, 'area');
+    h.tool.addVertex(-97.75, 30.26);
+    h.tool.addVertex(-97.74, 30.26);
+    h.tool.addVertex(-97.74, 30.27);
+    h.documentDouble.emit('keydown', {
+      key: 'Enter',
+      target: h.documentDouble.body,
+    });
+    const geometry = await drawn;
+    assert.deepEqual(geometry, {
+      type: 'Polygon',
+      coordinates: [
+        [
+          [-97.75, 30.26],
+          [-97.74, 30.26],
+          [-97.74, 30.27],
+          [-97.75, 30.26],
+        ],
+      ],
+    });
+    assert.equal(h.annotations.calls.annotate.length, 0, 'no mark is placed');
+    assert.equal(h.tool.active, false, 'draw mode ends');
+    assert.equal(isPointerFree(), true);
+    assert.equal(h.tool.shape, 'line', 'the shape chosen before comes back');
+  } finally {
+    h.restore();
+  }
+});
+
+test('drawShape hands back a line as a LineString', async () => {
+  const h = harness();
+  try {
+    const drawn = h.tool.drawShape({ shape: 'line' });
+    h.tool.addVertex(-97.75, 30.26);
+    h.tool.addVertex(-97.74, 30.26);
+    h.documentDouble.emit('keydown', {
+      key: 'Enter',
+      target: h.documentDouble.body,
+    });
+    assert.deepEqual(await drawn, {
+      type: 'LineString',
+      coordinates: [
+        [-97.75, 30.26],
+        [-97.74, 30.26],
+      ],
+    });
+  } finally {
+    h.restore();
+  }
+});
+
+test('drawShape resolves null on Escape, on abort, on a newer request and when the pointer is taken', async () => {
+  const h = harness();
+  try {
+    // Escape with a shape started clears it; a second Escape leaves.
+    const escaped = h.tool.drawShape({ shape: 'area' });
+    h.tool.addVertex(-97.75, 30.26);
+    h.documentDouble.emit('keydown', {
+      key: 'Escape',
+      target: h.documentDouble.body,
+    });
+    assert.equal(h.tool.active, true, 'the first Escape only clears the shape');
+    h.documentDouble.emit('keydown', {
+      key: 'Escape',
+      target: h.documentDouble.body,
+    });
+    assert.equal(await escaped, null);
+    assert.equal(h.tool.active, false);
+
+    const controller = new AbortController();
+    const aborted = h.tool.drawShape({
+      shape: 'area',
+      signal: controller.signal,
+    });
+    controller.abort();
+    assert.equal(await aborted, null);
+    assert.equal(isPointerFree(), true, 'an abort gives the pointer back');
+
+    const first = h.tool.drawShape({ shape: 'area' });
+    const second = h.tool.drawShape({ shape: 'line' });
+    assert.equal(await first, null, 'a newer request ends the older one');
+    h.act('toggleDraw');
+    assert.equal(await second, null, 'leaving draw mode ends it');
+
+    const done = new AbortController();
+    done.abort();
+    assert.equal(await h.tool.drawShape({ signal: done.signal }), null);
+
+    const other = claimPointer('directions');
+    assert.equal(
+      await h.tool.drawShape({ shape: 'area' }),
+      null,
+      'a held pointer refuses it',
+    );
+    releasePointer(other);
+
+    // Drawing by hand afterwards places marks as before.
+    h.act('toggleDraw');
+    h.tool.addVertex(-97.75, 30.26);
+    h.tool.addVertex(-97.74, 30.26);
+    h.tool.addVertex(-97.74, 30.27);
+    h.documentDouble.emit('keydown', {
+      key: 'Enter',
+      target: h.documentDouble.body,
+    });
+    await Promise.resolve();
+    assert.equal(h.annotations.calls.annotate.length, 1);
+  } finally {
+    h.restore();
+  }
+});
+
+test('drawShape keeps its shape, and a shape across the antimeridian is drawn again', async () => {
+  const h = harness();
+  try {
+    const drawn = h.tool.drawShape({ shape: 'line' });
+    h.act('setDrawShape', 'pin');
+    assert.equal(h.tool.shape, 'line', 'the controls cannot change the asked-for shape');
+    h.tool.addVertex(179.5, 10);
+    h.tool.addVertex(-179.5, 10);
+    h.documentDouble.emit('keydown', { key: 'Enter', target: h.documentDouble.body });
+    assert.equal(h.tool.active, true, 'still drawing');
+    assert.equal(h.tool.session.vertices.length, 0, 'drawn again from the start');
+    assert.equal(h.shown.view.hint, 'That shape could not be placed.');
+    h.tool.addVertex(29, 41);
+    h.tool.addVertex(29.1, 41);
+    h.documentDouble.emit('keydown', { key: 'Enter', target: h.documentDouble.body });
+    assert.equal((await drawn).type, 'LineString');
+    h.act('setDrawShape', 'pin');
+    assert.equal(h.tool.shape, 'pin', 'after it, the controls choose again');
+  } finally {
+    h.restore();
+  }
+});
+
+test('destroy ends a drawShape request with null', async () => {
+  const h = harness();
+  try {
+    const drawn = h.tool.drawShape({ shape: 'area' });
+    h.tool.destroy();
+    assert.equal(await drawn, null);
+  } finally {
+    h.restore();
+  }
+});
+
 test('Backspace on the page removes the last vertex', () => {
   const h = harness();
   try {
diff --git a/src/app/tools.js b/src/app/tools.js
index 8925151ad..9ecb3559a 100644
--- a/src/app/tools.js
+++ b/src/app/tools.js
@@ -1,6 +1,7 @@
 import { SceneDirector } from '../scenes/director.js';
 import { initAnnotations } from '../annotations/index.js';
 import { initDrawTool } from '../annotations/drawTool.js';
+import { isPointerFree } from '../data/inputOwnership.js';
 import { initGeoFileImport } from '../ui/geoFileImport.js';
 import { useDisplayStore } from '../ui/stores/display.js';
 import { applicationPinia } from '../ui/vueRuntime.js';
@@ -245,5 +246,17 @@ export function createApplicationTools({
       signal,
     }),
   );
-  return { sceneDirector, annotations, voiceCommands };
+  // Draw one area or line and get its geometry back, without placing a mark
+  // (annotations/drawTool.js `drawShape`); null without the Draw controls.
+  const drawShape = (options) =>
+    drawTool ? drawTool.drawShape(options) : Promise.resolve(null);
+  // An application's own click handlers yield while a tool holds the pointer,
+  // as the layers' do (data/inputOwnership.js).
+  return {
+    sceneDirector,
+    annotations,
+    voiceCommands,
+    drawShape,
+    pointerFree: isPointerFree,
+  };
 }

From 0600d8658401bbafdd945344da18e3debbf4e460 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 9 Nov 2026 07:16:52 -0800
Subject: [PATCH 39/71] docs(changelog): Draw hands one shape back (#1641)

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 89ae0e1e5..7c425d0b6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,7 @@
 - Applications can ask Draw for one area or line and get its geometry back
   without placing a mark (`drawShape` from `createApplicationTools`), and their
   own click handlers can yield while a tool holds the pointer, as the layers'
-  do (`pointerFree`) (samehkhamis).
+  do (`pointerFree`) (samehkhamis, #1641).
 
 ## [0.3.0] — 2026-10-27 — Street Level, On Your Phone, in Your Language
 

From 75e8e7ddbdb68c01616ed074b00b80bfd1734274 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Mon, 9 Nov 2026 19:41:51 +0400
Subject: [PATCH 40/71] refactor(data): describe tile budgets per period, drop
 a duplicate test, add the changelog entry

---
 changelog.d/762-tile-budget-module.md |  4 ++++
 src/data/tileBudget.js                | 22 +++++++++++-----------
 src/data/tileBudget.test.mjs          | 16 ----------------
 src/data/tomtomTiles.js               |  5 +++--
 4 files changed, 18 insertions(+), 29 deletions(-)
 create mode 100644 changelog.d/762-tile-budget-module.md

diff --git a/changelog.d/762-tile-budget-module.md b/changelog.d/762-tile-budget-module.md
new file mode 100644
index 000000000..6d000d357
--- /dev/null
+++ b/changelog.d/762-tile-budget-module.md
@@ -0,0 +1,4 @@
+- Move the tile budget helpers `utcDayKey`, `normalizeBudget` and
+  `isOverBudget` out of the TomTom module into `src/data/tileBudget.js`, so
+  other keyed tile proxies can share them. `src/data/tomtomTiles.js`
+  re-exports them; behaviour does not change (monwiss, #762).
diff --git a/src/data/tileBudget.js b/src/data/tileBudget.js
index dcc44a28c..83cf9b693 100644
--- a/src/data/tileBudget.js
+++ b/src/data/tileBudget.js
@@ -22,29 +22,29 @@ export function utcDayKey(epochMs = Date.now()) {
 }
 
 /**
- * Normalize a persisted budget state against today's UTC day key.
- * Rolls the counter to zero on day change; replaces missing/corrupt state.
- * Returns the SAME object when it is already valid for `dayKey` (cheap to
- * call on every request).
+ * Normalize a persisted budget state against the current period key.
+ * Rolls the counter to zero when the period changes; replaces missing/corrupt
+ * state. Returns the SAME object when it is already valid for `periodKey`
+ * (cheap to call on every request).
  *
  * @param {{date:string, count:number}|null|undefined} state - Persisted state.
- * @param {string} dayKey - Today's UTC day key (from `utcDayKey`).
- * @returns {{date:string, count:number}} Valid state for `dayKey`.
+ * @param {string} periodKey - Current period key, e.g. from `utcDayKey`.
+ * @returns {{date:string, count:number}} Valid state for `periodKey`.
  */
-export function normalizeBudget(state, dayKey) {
+export function normalizeBudget(state, periodKey) {
   const valid =
     Boolean(state) &&
-    state.date === dayKey &&
+    state.date === periodKey &&
     Number.isFinite(state.count) &&
     state.count >= 0;
-  return valid ? state : { date: dayKey, count: 0 };
+  return valid ? state : { date: periodKey, count: 0 };
 }
 
 /**
- * Whether the daily soft cap has been reached.
+ * Whether the soft cap for the current period has been reached.
  *
  * @param {{count:number}} state - Normalized budget state.
- * @param {number} limit - Daily tile budget; non-positive/invalid never blocks.
+ * @param {number} limit - Budget per period; non-positive/invalid never blocks.
  * @returns {boolean} True when `count >= limit`.
  */
 export function isOverBudget(state, limit) {
diff --git a/src/data/tileBudget.test.mjs b/src/data/tileBudget.test.mjs
index fa48440bb..c1baa4235 100644
--- a/src/data/tileBudget.test.mjs
+++ b/src/data/tileBudget.test.mjs
@@ -8,19 +8,3 @@ test('tile budget helpers live in one module and TomTom re-exports them', () =>
   assert.equal(tomtom.normalizeBudget, normalizeBudget);
   assert.equal(tomtom.isOverBudget, isOverBudget);
 });
-
-test('normalizeBudget keeps a valid state and resets another period', () => {
-  const state = { date: '2026-09-24', count: 3 };
-  assert.equal(normalizeBudget(state, '2026-09-24'), state);
-  assert.deepEqual(normalizeBudget(state, '2026-09-25'), {
-    date: '2026-09-25',
-    count: 0,
-  });
-  assert.deepEqual(
-    normalizeBudget({ date: '2026-09-24', count: -1 }, '2026-09-24'),
-    {
-      date: '2026-09-24',
-      count: 0,
-    },
-  );
-});
diff --git a/src/data/tomtomTiles.js b/src/data/tomtomTiles.js
index 9f3b1f0b9..14101c831 100644
--- a/src/data/tomtomTiles.js
+++ b/src/data/tomtomTiles.js
@@ -1,9 +1,10 @@
 /**
- * @file Pure tile math + budget accounting for the TomTom traffic-flow proxy.
+ * @file Pure tile math for the TomTom traffic-flow proxy; budget helpers are
+ * re-exported from `./tileBudget.js`.
  *
  * Shared by the `/api/tomtom` vite plugin (server-side: coordinate validation,
  * daily budget governor) and `src/layers/traffic/flowSource.js` (client-side: which tiles
- * cover the current traffic fetch bounds). Zero dependencies, Cesium-free, so
+ * cover the current traffic fetch bounds). No external dependencies, Cesium-free, so
  * both sides can unit-test against it with node:test.
  *
  * Slippy scheme: standard Web Mercator XYZ, y grows southward

From b04fcf191cbaf781cde1db1ff08072dd819f1c5f Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Mon, 9 Nov 2026 21:38:07 +0400
Subject: [PATCH 41/71] docs(firms): count two VIIRS sources in the layer table
 and test note

---
 docs/CURRENT-STATE.md              | 2 +-
 src/data/firmsInteraction.test.mjs | 7 ++++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 102efb997..6346c1db6 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4152,7 +4152,7 @@ its criteria cannot be silently ignored.
 | Datacenters ▣          | OSM extract (bundled)                                                                                                                                                                           | `src/data/infrastructure.js`                          | —                                                        | static                                                                            |
 | Dams ▰                 | OpenInfraMap/OSM extract (bundled)                                                                                                                                                              | `src/data/infrastructure.js`                          | —                                                        | static                                                                            |
 | Submarine Cables ◠     | TeleGeography public map (bundled)                                                                                                                                                              | `src/data/telegeographySubmarineCables.js`            | —                                                        | static                                                                            |
-| FIRMS Active Fires ▲   | NASA FIRMS live (VIIRS ×3 NRT + MODIS NRT, trailing 24h)                                                                                                                                        | `src/data/firmsHeatmap.js`                            | `/api/firms` (`FIRMS_MAP_KEY`)                           | 10 min (proxy TTL 30 min)                                                         |
+| FIRMS Active Fires ▲   | NASA FIRMS live (VIIRS ×2 NRT + MODIS NRT, trailing 24h)                                                                                                                                        | `src/data/firmsHeatmap.js`                            | `/api/firms` (`FIRMS_MAP_KEY`)                           | 10 min (proxy TTL 30 min)                                                         |
 | Street Level 📷 | Mapillary street-level imagery (vector tiles, Graph API, MapillaryJS) | `src/layers/streetLevel/` via `src/app/layers/streetLevel.js` | `/api/mapillary/status`, `/api/mapillary/tiles/coverage/{z}/{x}/{y}` (`MAPILLARY_CLIENT_TOKEN`) | camera-driven (320 ms debounce, ≤9 tiles, server memory cache 24 h) |
 | Wind 🌬                 | NOAA GFS 10 m wind (keyless, 0.25°→1° grid; animated particles)                                                                                                                                 | `src/data/wind.js`                                    | `/api/wind`                                              | 1 h (forecast cycle)                                                              |
 | GNSS Integrity 📡 (`gnss-integrity`) | adsb.lol point snapshot, low navigation accuracy binned per 0.5° cell (GEV NIC/NACp threshold + gpsjam.org formula and bands, keyless, ODbL) | `src/layers/gnss/` via `src/app/layers/gnss.js` | `/api/gnss-integrity` | camera-driven (600 ms debounce, minimum 2.5 s between reads) + 60s poll (server cache 60 s; 30 min rolling window) |
diff --git a/src/data/firmsInteraction.test.mjs b/src/data/firmsInteraction.test.mjs
index d735df3f8..9931c8b32 100644
--- a/src/data/firmsInteraction.test.mjs
+++ b/src/data/firmsInteraction.test.mjs
@@ -119,9 +119,10 @@ test('fire detection key survives a refetch that renumbers the index', () => {
 });
 
 test('two satellites over the same pixel at the same time stay distinct', () => {
-  // The proxy merges SNPP + NOAA-20 + NOAA-21 without dedup and their orbits
-  // overlap, so position and time alone are NOT unique. Collapsing them let a
-  // restored selection land on the other satellite's record.
+  // The proxy merges NOAA-20 + NOAA-21 without dedup and their orbits overlap,
+  // so position and time alone are NOT unique. Collapsing them let a restored
+  // selection land on the other satellite's record. Archived Suomi NPP (`N`)
+  // rows must stay distinct too.
   const base = makeFire({ satellite: 'N20' });
   const twin = makeFire({ satellite: 'N21' });
   const suomi = makeFire({ satellite: 'N' });

From fce5ee6381b948db2f263e1090a19b77d74dd164 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Mon, 9 Nov 2026 21:44:09 +0400
Subject: [PATCH 42/71] docs(firms): tighten the Suomi NPP notes

---
 DATA_SOURCES.md              | 2 +-
 docs/CURRENT-STATE.md        | 4 +---
 server/providers/firms.js    | 7 +++----
 src/data/firmsProxy.test.mjs | 6 +++---
 4 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index 8ceb94e84..ba231df31 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -329,7 +329,7 @@ and MODIS NRT (Terra + Aqua), clamped to the trailing 24 h, cached 30 min to res
 transaction quota. Requires a free `FIRMS_MAP_KEY`
 (https://firms.modaps.eosdis.nasa.gov/api/map_key/); the layer is empty without it.
 The former bundled 2026-05-25 snapshot was removed 2026-07-16. Suomi NPP (`VIIRS_SNPP_NRT`)
-is no longer requested: NASA stopped delivering its data on 2026-11-02.
+is not requested: NASA stopped delivering it on 2026-11-02.
 
 ### UCS Satellite Database (`ucs_satellites/`)
 
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 417e81551..05240d922 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -2860,9 +2860,7 @@ reporting are unchanged.
 ## FIRMS source status
 
 The FIRMS proxy requests VIIRS NOAA-20, VIIRS NOAA-21 and MODIS NRT (Terra and
-Aqua). It no longer requests VIIRS Suomi NPP: NASA stopped delivering Suomi NPP
-data on 2026-11-02, and the source returned no rows while still costing one
-MAP_KEY transaction per refresh.
+Aqua). It skips VIIRS Suomi NPP, which NASA stopped delivering on 2026-11-02.
 
 The FIRMS CSV parser rejects impossible acquisition calendar dates before the proxy filters records to the trailing 24 hours, while retaining valid UTC acquisition times.
 The `get_active_fires` tool reports acquisition times as UTC ISO timestamps,
diff --git a/server/providers/firms.js b/server/providers/firms.js
index 51ea4fc56..d21dc296e 100644
--- a/server/providers/firms.js
+++ b/server/providers/firms.js
@@ -132,8 +132,8 @@ export async function fetchFirms(
  * Upstream: https://firms.modaps.eosdis.nasa.gov/api/area/csv/{KEY}/{SOURCE}/world/2
  *
  * Merges two VIIRS NRT sources (NOAA-20, NOAA-21 — independent satellites, no
- * cross-source dedup) plus MODIS_NRT (combined Terra+Aqua,
- * ~1 km, numeric 0-100 confidence), fetched sequentially (quota courtesy)
+ * cross-source dedup) plus MODIS_NRT (combined Terra+Aqua, ~1 km, numeric
+ * 0-100 confidence), fetched sequentially (quota courtesy)
  * with `days=2` (`days=1` means "current UTC day", nearly empty just after
  * 00:00Z) and clamps to the trailing 24 h via src/data/firmsCsv.js. FIRMS
  * quota is 5,000 transactions / 10 min per MAP_KEY, so the cache is the point:
@@ -141,8 +141,7 @@ export async function fetchFirms(
  * fresh-enough disk cache (.gev-cache/firms.json) prevents ANY upstream
  * fetch across dev-server restarts. Pattern mirrors celestrakProxy.
  *
- * VIIRS_SNPP_NRT is not requested: NASA stopped delivering Suomi NPP data on
- * 2026-11-02, so that source only spent a transaction per refresh (#849).
+ * VIIRS_SNPP_NRT is left out: NASA stopped delivering Suomi NPP on 2026-11-02.
  *
  * Routes:
  *   GET /api/firms        → {fetchedAt, stale, ttlMs, sources, count, fires}
diff --git a/src/data/firmsProxy.test.mjs b/src/data/firmsProxy.test.mjs
index dc9ed8144..71c0af4d6 100644
--- a/src/data/firmsProxy.test.mjs
+++ b/src/data/firmsProxy.test.mjs
@@ -21,7 +21,7 @@ assert.notEqual(start, -1, 'FIRMS refresh function exists');
 const end = config.indexOf('\n  }', start);
 assert.notEqual(end, -1, 'FIRMS refresh function closes');
 const refreshSource = config.slice(start, end + 4);
-// Read the source list from production so these tests share one source of truth.
+// Read the list from production so these tests follow it.
 const listed = config.match(/const SOURCES = \[([^\]]*)\];/);
 assert.ok(listed, 'FIRMS source list exists');
 const SOURCES = [...listed[1].matchAll(/'([A-Z0-9_]+)'/g)].map((m) => m[1]);
@@ -312,7 +312,7 @@ test('every FIRMS upstream request goes through the IPv4 fallback', async () =>
 });
 
 test('FIRMS requests only the satellites NASA still delivers', () => {
-  // NASA stopped delivering Suomi NPP data on 2026-11-02 (#849): requesting it
-  // returns no rows and still spends a MAP_KEY transaction on every refresh.
+  // NASA stopped delivering Suomi NPP on 2026-11-02; asking for it only spends
+  // a MAP_KEY transaction.
   assert.ok(!SOURCES.includes('VIIRS_SNPP_NRT'));
 });

From 584732c3ecea2e1b4e472e5dbcdae58c229650fe Mon Sep 17 00:00:00 2001
From: Meir Michanie <meirm@cyborg.fi>
Date: Thu, 5 Nov 2026 22:09:09 -0600
Subject: [PATCH 43/71] i18n(he): complete and ship Hebrew

- Add the full catalog (2940 entries keyed by the English text; 75 plural
  entries carry one/two/other per Intl.PluralRules('he')), reviewed for
  meaning, terms, separators and label length.
- Register he: he-IL and he map to it; it joins RTL_LOCALES so <html
  dir=rtl> mirrors the chrome through logical properties and rtl.css.
- rtl.css: Noto Sans Hebrew (loaded with the other Google fonts) leads the
  mono and sans stacks, tracking released like Arabic, HUDs keep JetBrains
  Mono for Latin telemetry.
- same-as-english: instrument codes and HUD readouts stay as printed
  (HDG/BRG/CRS/FOV/CRT/NVG/FLIR/CAL/SRC, MW units, Sentinel-2, km/h...).
- docs/translations/he.md: style, plurals and glossary.
- docs: TRANSLATORS.md and CURRENT-STATE.md updated; normalizeLocale test
  covers he-IL.
---
 docs/CURRENT-STATE.md           |   24 +-
 docs/TRANSLATORS.md             |    4 +-
 docs/translations/he.md         |   65 +
 index.html                      |    2 +-
 scripts/package-boundaries.json |   46 +
 src/i18n/i18n.test.mjs          |    3 +
 src/i18n/index.js               |    2 +
 src/i18n/locale.js              |    6 +-
 src/i18n/locales/he.json        | 3242 +++++++++++++++++++++++++++++++
 src/i18n/same-as-english.json   |   89 +
 src/ui/localePicker.test.mjs    |    4 +
 src/ui/styles/rtl.css           |   37 +
 12 files changed, 3509 insertions(+), 15 deletions(-)
 create mode 100644 docs/translations/he.md
 create mode 100644 src/i18n/locales/he.json

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 05240d922..8ebabaf61 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4589,7 +4589,9 @@ test:track` 43 tracking invariants · headless QA harnesses under
 
 ### Interface localization (October 2026)
 
-Shipped locales: **en** (source and fallback), **ar**, **de**, **es**, **fr**, **it**, **ja**, **pt** (Brazilian Portuguese), **ru**, **uk**, **zh-CN** and **zh-Hant**. The code lives in
+Shipped locales: **en** (source and fallback), **ar**, **de**, **es**, **fr**, **he**,
+**it**, **ja**, **pt** (Brazilian Portuguese), **ru**, **uk**, **zh-CN** and
+**zh-Hant**. The code lives in
 `src/i18n/`. How to mark UI text: [`docs/I18N.md`](./I18N.md); translator workflow:
 [`docs/TRANSLATORS.md`](./TRANSLATORS.md).
 
@@ -4603,19 +4605,21 @@ Shipped locales: **en** (source and fallback), **ar**, **de**, **es**, **fr**, *
   `navigator.languages` → English. Any `pt` tag (`pt-BR`, `pt-PT`) selects `pt`. Chinese tags default to `zh-CN`; Traditional Chinese tags
   select `zh-Hant`. Explicit `Hans` selects `zh-CN` regardless of region. `?lang=` is not stored, and share links drop
   it, so a recipient keeps their own language. The globe picker in the
-  bottom-right corner (bottom-left in Arabic) (`src/ui/localePicker.js`) stores the choice, drops
+  bottom-right corner (bottom-left in Arabic and Hebrew)
+(`src/ui/localePicker.js`) stores the choice, drops
   `?lang=` (keeps it only when storage is blocked) and switches in place:
   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.
-- **Right to left.** Arabic (`ar`) is 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-*`, `margin-inline-*`), the
-  dock and corner row reverse their order, and `src/ui/styles/rtl.css` holds
-  the rest: no letter-spacing on Arabic text, Noto Sans Arabic in the font
-  stacks, the intel HUD kept as a left-to-right instrument overlay, FM seek
-  and the radio dial kept left to right. Intl formatters get `ar-u-nu-latn`,
-  so numbers and dates keep Western digits.
+- **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-*`,
+  `margin-inline-*`), the dock and corner row reverse their order, and
+  `src/ui/styles/rtl.css` holds the rest: no letter-spacing on Arabic and
+  Hebrew text, Noto Sans Arabic and Noto Sans Hebrew in the font stacks, the
+  intel HUD kept as a left-to-right instrument overlay, FM seek and the radio
+  dial kept left to right. Intl formatters get `ar-u-nu-latn`, so numbers and
+  dates keep Western digits.
 - **Gate.** `npm run i18n` (and `src/i18n/catalog.test.mjs` under `npm test`)
   extracts every message and fails on missing, empty, unused,
   placeholder-mismatched, still-English (plural forms included) or
diff --git a/docs/TRANSLATORS.md b/docs/TRANSLATORS.md
index f83316c7a..d08711193 100644
--- a/docs/TRANSLATORS.md
+++ b/docs/TRANSLATORS.md
@@ -1,6 +1,6 @@
 # Translating God's Eye View
 
-Shipped languages: **English** (source and fallback), **Arabic** (`ar`), **German** (`de`), **Spanish** (`es`), **French** (`fr`), **Italian** (`it`), **Japanese** (`ja`), **Brazilian Portuguese** (`pt`), **Russian** (`ru`), **Ukrainian** (`uk`), **Simplified Chinese** (`zh-CN`) and **Traditional Chinese** (`zh-Hant`).
+Shipped languages: **English** (source and fallback), **Arabic** (`ar`), **German** (`de`), **Spanish** (`es`), **French** (`fr`), **Hebrew** (`he`), **Italian** (`it`), **Japanese** (`ja`), **Brazilian Portuguese** (`pt`), **Russian** (`ru`), **Ukrainian** (`uk`), **Simplified Chinese** (`zh-CN`) and **Traditional Chinese** (`zh-Hant`).
 
 ## How it works
 
@@ -63,4 +63,4 @@ These are contracts, not copy: layer ids and registry keys, status enums and oth
 
 ## Language notes
 
-Each language keeps its glossary, plural forms, units and style in its own file, `docs/translations/<code>.md`: [Arabic](./translations/ar.md), [German](./translations/de.md), [Spanish](./translations/es.md), [French](./translations/fr.md), [Italian](./translations/it.md), [Japanese](./translations/ja.md), [Brazilian Portuguese](./translations/pt.md), [Russian](./translations/ru.md), [Ukrainian](./translations/uk.md), [Simplified Chinese](./translations/zh-CN.md), [Traditional Chinese](./translations/zh-Hant.md). Read it before translating, and add a term there when you settle on one.
+Each language keeps its glossary, plural forms, units and style in its own file, `docs/translations/<code>.md`: [Arabic](./translations/ar.md), [German](./translations/de.md), [Spanish](./translations/es.md), [French](./translations/fr.md), [Hebrew](./translations/he.md), [Italian](./translations/it.md), [Japanese](./translations/ja.md), [Brazilian Portuguese](./translations/pt.md), [Russian](./translations/ru.md), [Ukrainian](./translations/uk.md), [Simplified Chinese](./translations/zh-CN.md), [Traditional Chinese](./translations/zh-Hant.md). Read it before translating, and add a term there when you settle on one.
diff --git a/docs/translations/he.md b/docs/translations/he.md
new file mode 100644
index 000000000..6d531cab5
--- /dev/null
+++ b/docs/translations/he.md
@@ -0,0 +1,65 @@
+# Hebrew (`he`)
+
+Catalog: `src/i18n/locales/he.json`. General rules: [TRANSLATORS.md](../TRANSLATORS.md).
+
+## Style
+
+- Address the user with a masculine imperative, Google style: הסתר, הצג, נסה שוב, התקרב. Menu items and tooltips take the noun form: הסרת {name}, הרחבת {name}, שינוי הצבע של {name}.
+- Sentence case: Hebrew has no case forms, so UPPERCASE English is normal sentence style here; short HUD labels stay short, favor an abbreviation over a wrapped line.
+- Keep the `·`, `—`, `→`, `↗`, `…` separators. Latin codes read inside RTL text because the app isolates interpolated values; leave them alone.
+- Units follow the catalog: ק"מ, מ׳, קמ"ש, שנ', דק', שע'; instrument chips keep the Latin unit (MW, KM, FT, KTS, kn) and codes (HDG, FOV, CAL, SRC, REC) exactly as in English — see `same-as-english.json`.
+
+## Digits and direction
+
+- Western digits 0–9 only, like every catalog: "5 מטוסים", "26.08.2026". Dates in scene labels use dd.mm.yyyy.
+- `{direction}` values are adverbs (שמאלה, ימינה, ישר); maneuver templates are written to place them after the verb: פנה {direction} אל {road}.
+- Values inserted by t() are isolated (U+2068…U+2069); do not add manual RTL marks — write the sentence as natural Hebrew and let isolation do the rest.
+
+## Plurals
+
+A `tn()` entry needs three forms under `Intl.PluralRules('he')`:
+
+| Form    | Counts                    | Example        |
+| ------- | ------------------------- | -------------- |
+| `one`   | 1                         | 1 מצלמה        |
+| `two`   | 2                         | 2 מצלמות       |
+| `other` | 0, 3, 10, 100, fractions… | 5 מצלמות       |
+
+With {count} shown as a digit, `two` and `other` share the plural noun (2 מצלמות, 5 מצלמות); `one` takes the singular (1 מצלמה). For constructs that resist agreement with a noun (אין, הכול, זמין), phrase around the number: "{count} תחנות מדווחות" is fine, but prefer "ממתין: {count}" over a mismatched genitive chain.
+
+## Glossary
+
+| English                                        | עברית                                                 |
+| ---------------------------------------------- | ----------------------------------------------------- |
+| layer / data layer                             | שכבה / שכבת נתונים                                    |
+| feed                                           | פיד                                                   |
+| source / data source / Provider Settings       | מקור / מקור נתונים / הגדרות הספקים                    |
+| LIVE / live data / LIVE TRACK                  | חי / נתונים חיים / מעקב חי                            |
+| SIMULATED                                      | מדומה                                                 |
+| stale / degraded / unavailable                 | מיושן / מופחת / לא זמין                               |
+| key (API key) / POWER UP                       | מפתח / אתחול                                          |
+| globe / map / map source / basemap             | גלובוס / מפה / מקור מפה / מפת בסיס                    |
+| aircraft / flight / military flight            | מטוס (כלי טיס in class lists) / טיסה / טיסה צבאית     |
+| vessel / ship / ships                          | אונייה / אוניות                                       |
+| satellite                                      | לוויין                                                |
+| launch (rocket) / space mission                | שיגור / משימת חלל                                     |
+| contact / tracking                             | מגע / עקיבה                                           |
+| installation / site                            | מתקן / אתר                                            |
+| camera / CCTV camera / ALPR camera             | מצלמה / מצלמת CCTV / מצלמת ALPR                       |
+| earthquake / active fire / cyclone             | רעידת אדמה / שרפה פעילה / ציקלון                      |
+| scene / shot                                   | סצנה / שוט                                            |
+| briefing / panel / dock                        | דיווח / פאנל / עגינה                                  |
+| visual preset / style                          | ערכת ראייה / סגנון                                   |
+| Scope (circular viewport mask) / keyhole       | סקופ / חור המנעול                                    |
+| heading (compass °) / course                   | כיוון / מסלול                                         |
+| HDG / BRG / CRS / FOV / DEST / SPD / RANGE     | בלי שינוי — קודי מכשיר                               |
+| advisory (NHC/CPHC cyclone)                    | ייעוץ; Advisory center — מרכז הייעוץ                  |
+| Street View (Google)                           | Street View, בלי תרגום                                |
+| Street Level / Street Level layer              | Street Level, בלי תרגום (שם שכבה)                    |
+| WHOT/BHOT, Ironbow, CRT, NVG, FLIR             | בלי שינוי — קודים ושמות מצבים                        |
+| PREV / NEXT                                    | הקודם / הבא                                           |
+| anchor / data pack / asset bundle (scene)      | עוגן / חבילת נתונים / חבילת נכסים                   |
+| witness / geolocated source                    | עד ראייה / מקור נתון גיאוגרפית                        |
+| contained (wildland fire) / FRP                | הכלה / FRP, בלי שינוי                                 |
+
+Latin product, provider and dataset names stay as printed: Google Maps, Cesium ion, OpenSky, ADS-B, AIS, KartaView, Mapillary, Panoramax, Overpass, InciWeb, iNaturalist, Acartia, NASA FIRMS, NOAA, USGS, CelesTrak, TomTom, Sentinel-2, Landsat, VIIRS, HLS, S2 GhostMaps, TeleGeography.
diff --git a/index.html b/index.html
index 291b99708..5cfee67ea 100644
--- a/index.html
+++ b/index.html
@@ -21,7 +21,7 @@
   <link rel="stylesheet" href="/style.css" />
   <link rel="preconnect" href="https://fonts.googleapis.com" />
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-  <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;600;700&family=Inter:wght@300;400;500;600&family=Noto+Sans+Arabic:wght@400;500;600;700&display=swap" rel="stylesheet" />
+  <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;600;700&family=Inter:wght@300;400;500;600&family=Noto+Sans+Arabic:wght@400;500;600;700&family=Noto+Sans+Hebrew:wght@400;500;600;700&display=swap" rel="stylesheet" />
   <!-- Icon font subset to the glyphs this app renders. Keep `icon_names` in sync
        with the sources: src/materialSymbolsSubset.test.mjs fails when a source
        names a glyph this list is missing, because a missing glyph does not draw
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index 703aca438..9e577cd0d 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -73,6 +73,7 @@
       "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",
@@ -651,6 +652,7 @@
       "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",
@@ -699,6 +701,7 @@
       "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",
@@ -740,6 +743,7 @@
       "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",
@@ -783,6 +787,7 @@
       "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",
@@ -810,6 +815,7 @@
       "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",
@@ -840,6 +846,7 @@
       "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",
@@ -877,6 +884,7 @@
       "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",
@@ -946,6 +954,7 @@
       "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",
@@ -973,6 +982,7 @@
       "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",
@@ -1175,6 +1185,7 @@
       "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",
@@ -1367,6 +1378,7 @@
       "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",
@@ -1453,6 +1465,7 @@
       "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",
@@ -1514,6 +1527,7 @@
       "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",
@@ -1591,6 +1605,7 @@
       "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",
@@ -1628,6 +1643,7 @@
       "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",
@@ -1669,6 +1685,7 @@
       "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",
@@ -1709,6 +1726,7 @@
       "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",
@@ -1757,6 +1775,7 @@
       "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",
@@ -1809,6 +1828,7 @@
       "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",
@@ -1856,6 +1876,7 @@
       "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",
@@ -1919,6 +1940,7 @@
       "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",
@@ -1956,6 +1978,7 @@
       "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",
@@ -2013,6 +2036,7 @@
       "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",
@@ -2084,6 +2108,7 @@
       "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",
@@ -2124,6 +2149,7 @@
       "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",
@@ -2174,6 +2200,7 @@
       "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",
@@ -2204,6 +2231,7 @@
       "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",
@@ -2268,6 +2296,7 @@
       "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",
@@ -2346,6 +2375,7 @@
       "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",
@@ -3295,6 +3325,7 @@
       "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",
@@ -4031,6 +4062,7 @@
       "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",
@@ -4214,6 +4246,7 @@
       "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",
@@ -4247,6 +4280,7 @@
       "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",
@@ -4301,6 +4335,7 @@
       "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",
@@ -4339,6 +4374,7 @@
       "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",
@@ -4445,6 +4481,7 @@
       "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",
@@ -4518,6 +4555,7 @@
       "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",
@@ -4809,6 +4847,7 @@
       "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",
@@ -4864,6 +4903,7 @@
       "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",
@@ -4927,6 +4967,7 @@
       "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",
@@ -4951,6 +4992,7 @@
       "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",
@@ -5021,6 +5063,7 @@
       "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",
@@ -5070,6 +5113,7 @@
       "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",
@@ -5275,6 +5319,7 @@
       "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",
@@ -5321,6 +5366,7 @@
       "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",
diff --git a/src/i18n/i18n.test.mjs b/src/i18n/i18n.test.mjs
index 366dc42b9..f0b9645c7 100644
--- a/src/i18n/i18n.test.mjs
+++ b/src/i18n/i18n.test.mjs
@@ -41,6 +41,9 @@ test('normalizeLocale folds regional variants and rejects unshipped tags', () =>
   assert.equal(normalizeLocale('de'), 'de');
   assert.equal(normalizeLocale('de-AT'), 'de');
   assert.equal(normalizeLocale('de_CH'), 'de');
+  // Hebrew keeps Western digits like its catalog; regional tags fold to he.
+  assert.equal(normalizeLocale('he'), 'he');
+  assert.equal(normalizeLocale('he-IL'), 'he');
   assert.equal(normalizeLocale('fr'), 'fr');
   assert.equal(normalizeLocale('fr-CA'), 'fr');
   assert.equal(normalizeLocale('FR_be'), 'fr');
diff --git a/src/i18n/index.js b/src/i18n/index.js
index 8bffca8bc..9d697e72a 100644
--- a/src/i18n/index.js
+++ b/src/i18n/index.js
@@ -22,6 +22,7 @@ import ar from './locales/ar.json' with { type: 'json' };
 import de from './locales/de.json' with { type: 'json' };
 import es from './locales/es.json' with { type: 'json' };
 import fr from './locales/fr.json' with { type: 'json' };
+import he from './locales/he.json' with { type: 'json' };
 import it from './locales/it.json' with { type: 'json' };
 import ja from './locales/ja.json' with { type: 'json' };
 import pt from './locales/pt.json' with { type: 'json' };
@@ -35,6 +36,7 @@ const CATALOGS = Object.freeze({
   de,
   es,
   fr,
+  he,
   it,
   ja,
   pt,
diff --git a/src/i18n/locale.js b/src/i18n/locale.js
index 7356ea8f8..9b73444ec 100644
--- a/src/i18n/locale.js
+++ b/src/i18n/locale.js
@@ -14,6 +14,7 @@ export const LOCALES = Object.freeze([
   'de',
   'es',
   'fr',
+  'he',
   'it',
   'ja',
   'pt',
@@ -30,6 +31,7 @@ export const LOCALE_NAMES = Object.freeze({
   de: 'Deutsch',
   es: 'Español',
   fr: 'Français',
+  he: 'עברית',
   it: 'Italiano',
   ja: '日本語',
   pt: 'Português (Brasil)',
@@ -40,7 +42,7 @@ export const LOCALE_NAMES = Object.freeze({
 });
 
 /** Right-to-left locales. */
-const RTL_LOCALES = Object.freeze(['ar']);
+const RTL_LOCALES = Object.freeze(['ar', 'he']);
 
 /** Whether a shipped locale reads right to left. */
 export function isRtlLocale(locale) {
@@ -62,7 +64,7 @@ export function intlLocale(locale) {
 
 /**
  * Map any language tag to a shipped locale: 'ru-RU' and 'RU' → 'ru',
- * 'ar-EG' and 'ar-SA' → 'ar',
+ * 'ar-EG' and 'ar-SA' → 'ar', 'he-IL' and 'he' → 'he',
  * 'de-AT' and 'de_CH' → 'de', 'ja-JP' → 'ja',
  * 'pt-BR' and 'pt-PT' → 'pt' (Brazilian Portuguese),
  * 'zh', 'zh-CN' and 'zh-Hans-SG' → 'zh-CN';
diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json
new file mode 100644
index 000000000..030a8fb26
--- /dev/null
+++ b/src/i18n/locales/he.json
@@ -0,0 +1,3242 @@
+{
+  "Primary": "ראשי",
+  "Amber": "ענבר",
+  "Cyan": "טורקיז",
+  "Green": "ירוק",
+  "Red": "אדום",
+  "Area": "שטח",
+  "Line": "קו",
+  "Pin": "סיכה",
+  "Name of {name}": "השם של {name}",
+  "Change the colour of {name}": "שינוי הצבע של {name}",
+  "Colour of {name}": "הצבע של {name}",
+  "Hide {name}": "הסתרת {name}",
+  "Show {name}": "הצגת {name}",
+  "Fly to {name}": "טוס אל {name}",
+  "Remove {name}": "הסרת {name}",
+  "Pick a shape, then click the map.": "בחר צורה ואז לחץ על המפה.",
+  "Enter to place the pin, Esc to cancel.": "Enter להצבת הסיכה, Esc לביטול.",
+  "Click where the pin goes.": "לחץ היכן שהסיכה תוצב.",
+  "Click {count} more points.": {
+    "one": "{count} נקודה נוספת ללחיצה.",
+    "two": "{count} נקודות נוספות ללחיצה.",
+    "other": "{count} נקודות נוספות ללחיצה."
+  },
+  "Those points are in a line — move one off it to enclose an area.": "הנקודות האלה נמצאות על קו אחד — הזז אחת ממנו כדי לסגור שטח.",
+  "That line has no length — click somewhere further away.": "לקו הזה אין אורך — לחץ רחוק יותר.",
+  " · {max}-point limit reached": " · הגעת למגבלה של {max} נקודות",
+  "{measure} · double-click or Enter to finish, Backspace undoes, Esc cancels.{full}": "{measure} · לחיצה כפולה או Enter לסיום, Backspace מבטל פעולה אחרונה, Esc מבטל.{full}",
+  "That shape already has {count} points — finish it or press Backspace.": "לצורה הזאת כבר יש {count} נקודות — סיים אותה או הקש Backspace.",
+  "That point is off the globe — click on the world.": "הנקודה הזאת מחוץ לגלובוס — לחץ בתוך העולם.",
+  "That shape could not be placed.": "לא היתה אפשרות למקם את הצורה.",
+  "Could not place the shape: {error}": "לא ניתן למקם את הצורה: {error}",
+  "Board cleared.": "הלוח נוקה.",
+  "{owner} is using the pointer — close it first.": "{owner} משתמש במצביע — סגור אותו תחילה.",
+  "{label} · Detailed outline unavailable": "{label} · קו המתאר המפורט אינו זמין",
+  "Flying to Austin, TX...": "טס אל Austin, TX...",
+  "Restoring shared view...": "משחזר תצוגה משותפת...",
+  "Configuring viewer...": "מגדיר צפייה...",
+  "Loading Google 3D Tiles...": "טוען Google 3D Tiles...",
+  "Loading the keyless globe...": "טוען גלובוס ללא מפתח...",
+  "Google 3D Tiles unavailable ({detail}). Loading the keyless globe...": "Google 3D Tiles אינם זמינים ({detail}). טוען גלובוס ללא מפתח...",
+  "Initializing systems...": "מאתחל מערכות...",
+  "Space Missions isolates replay data. Exit the mode to enable {layer}.": "Space Missions מנתק את נתוני השמעה חוזרת. צא מהמצב כדי להפעיל את {layer}.",
+  "Data attribution": "ייחוס נתונים",
+  "Data provided by:": "הנתונים מסופקים על ידי:",
+  "Close data attribution": "סגירת ייחוס הנתונים",
+  "Light aircraft": "מטוס קל",
+  "Glider": "דאון",
+  "Turboprop": "מטוס טורבו-פרופ",
+  "Airliner": "מטוס נוסעים",
+  "Widebody": "מטוס גוף רחב",
+  "Four-engine jet": "מטוס סילון ארבע-מנועי",
+  "Helicopter": "מסוק",
+  "Fast jet": "מטוס סילון מהיר",
+  "Business jet": "מטוס מנהלים",
+  "Drone": "רחפן",
+  "General emergency": "חירום כללי",
+  "Unlawful interference": "התערבות בלתי חוקית",
+  "Radio failure": "כשל קשר",
+  "Downed aircraft": "מטוס שהתרסק",
+  "Minimum fuel": "דלק מינימלי",
+  "Lifeguard (medical priority)": "עדיפות רפואית (Lifeguard)",
+  "Rasuwagadhi witness video": "סרטון עד Rasuwagadhi",
+  "Bhote Koshi valley footage": "צילומי עמק Bhote Koshi",
+  "Flood footage": "צילומי שיטפון",
+  "Compilation and casualty claims": "אוסף וטענות נפגעים",
+  "SOURCE GEOCONFIRMED · WORLD-PINNED": "מקור אומת גיאוגרפית · מוצב בעולם",
+  "SOURCE CREDITED · LOCATION UNRESOLVED": "מקור מיוחס · מיקום לא הוכרע",
+  "REFERENCE ONLY · CLAIMS UNVERIFIED": "לעיון בלבד · טענות לא אומתו",
+  "SOURCE GEOCONFIRMED": "מקור אומת גיאוגרפית",
+  "2021 historical reference versus 2026 post-event imagery; changes are cumulative and include the July 2025 Rasuwagadhi flood. Schematic downstream progression, not modeled arrival time; not an official hazard model.": "מקור היסטורי של 2021 מול צילומי 2026 שאחרי האירוע; השינויים מצטברים וכוללים את השיטפון ב-Rasuwagadhi יולי 2025. ההתקדמות במורד הזרם סכמטית, אינה זמן הגעה ממודל; אינו מודל סיכונים רשמי.",
+  "Immediate collapse viewpoint": "נקודת תצפית — הקריסה המיידית",
+  "Collapse viewpoint": "נקודת תצפית — הקריסה",
+  "Debris-dammed lake": "אגם סכור במפולת",
+  "Dammed lake": "אגם סכור",
+  "Second landslide": "מפולת שנייה",
+  "Gyirong border gate": "מעבר הגבול Gyirong",
+  "Border gate": "מעבר גבול",
+  "Timure evidence cluster": "מקבץ ראיות Timure",
+  "Mailung / Upper Trishuli bridge": "גשר Mailung / Trishuli העליון",
+  "Dandagaun viewpoint restaurant": "מסעדת נקודת התצפית Dandagaun",
+  "Dandagaun viewpoint": "נקודת התצפית Dandagaun",
+  "Bidur - Trishuli bridge": "גשר Bidur - Trishuli",
+  "Bidur bridge": "גשר Bidur",
+  "Devighat / Taadi Khola Bridge": "גשר Devighat / Taadi Khola",
+  "Devighat bridge": "גשר Devighat",
+  "Facebook player API did not initialize.": "ה-API של נגן Facebook לא אותחל.",
+  "Facebook player API could not load.": "ה-API של נגן Facebook לא נטען.",
+  "Facebook player API timed out.": "ה-API של נגן Facebook חרג מהזמן הקצוב.",
+  "X embed API did not initialize.": "ה-API של הטמעת X לא אותחל.",
+  "X embed could not load.": "ההטמעה של X לא נטענה.",
+  "X embed timed out.": "ההטמעה של X חרגה מהזמן הקצוב.",
+  "UNAVAILABLE": "לא זמין",
+  "TIMEOUT": "פג זמן",
+  "BLOCKED": "נחסם",
+  "SOURCE": "מקור",
+  "Facebook embed unavailable. The post may be private, removed, region-restricted, or blocked.": "הטמעת Facebook אינה זמינה. ייתכן שהפוסט פרטי, הוסר, מוגבל לאזור או נחסם.",
+  "Preloading {provider} media": "טוען מראש מדיה של {provider}",
+  "LOADING X POST…": "טוען פוסט X…",
+  "The X post is unavailable or cannot be embedded.": "הפוסט של X אינו זמין או שאין אפשרות להטמיע אותו.",
+  "X POST · PROVIDER CONTROLS": "פוסט X · פקדי ספק",
+  "{reason} OPEN ORIGINAL.": "{reason} פתח את המקור.",
+  "X embed unavailable": "הטמעת X אינה זמינה",
+  "FACEBOOK · PROVIDER CONTROLS": "FACEBOOK · פקדי ספק",
+  "Facebook embed unavailable": "הטמעת Facebook אינה זמינה",
+  "AUTOPLAY BLOCKED · USE PROVIDER CONTROLS": "נגינה אוטומטית נחסמה · השתמש בפקדי הספק",
+  "Embedded {provider} media for {source}": "מדיה מוטמעת של {provider} עבור {source}",
+  "witness source": "מקור עד ראייה",
+  "Witness source": "מקור עד ראייה",
+  "{provider} · EMBEDDED SOURCE": "{provider} · מקור מוטמע",
+  "OPEN ORIGINAL ↗": "פתח את המקור ↗",
+  "{provider} media: {source}": "מדיה של {provider}: {source}",
+  "{provider} · PROVIDER CONTROLS": "{provider} · פקדי ספק",
+  "YOUTUBE {state} · OPEN ORIGINAL": "YOUTUBE {state} · פתח את המקור",
+  "INITIATION": "התחלה",
+  "DAMMING": "סכירה",
+  "SECONDARY FAILURE": "כשל משני",
+  "BORDER ARRIVAL": "הגעה לגבול",
+  "PROPAGATION": "התפשטות",
+  "DOWNSTREAM PASSAGE": "מעבר במורד הזרם",
+  "CONSEQUENCE": "תוצאה",
+  "DOWNSTREAM CONSEQUENCE": "תוצאה במורד הזרם",
+  "EVIDENCE": "ראיות",
+  "{year} HISTORICAL REFERENCE": "{year} מקור היסטורי",
+  "{year} POST-EVENT": "{year} אחרי האירוע",
+  "{count} GEOLOCATED SOURCE-MAP PLACEMENTS": {
+    "one": "{count} מיקום מקור נתון גיאוגרפית על המפה",
+    "two": "{count} מיקומי מקור נתונים גיאוגרפית על המפה",
+    "other": "{count} מיקומי מקור נתונים גיאוגרפית על המפה"
+  },
+  "NO PREVIEW": "אין תצוגה מקדימה",
+  "YouTube source": "מקור YouTube",
+  "Facebook source": "מקור Facebook",
+  "SOURCE LINK": "קישור המקור",
+  "{publisher} / OPEN": "{publisher} / פתח",
+  "▶ PLAY": "▶ נגן",
+  "▶ PLAY SCENE": "▶ נגן סצנה",
+  "◉ CINEMATIC": "◉ קינמטי",
+  "↺ FULL STORY": "↺ הסיפור המלא",
+  "Previous story beat": "קטע הסיפור הקודם",
+  "Next story beat": "קטע הסיפור הבא",
+  "Schematic downstream progression": "התקדמות סכמטית במורד הזרם",
+  "RECONSTRUCTION CLOCK": "שעון השחזור",
+  "CAUSE": "סיבה",
+  "CAPTURE TIME UNVERIFIED": "זמן הצילום לא אומת",
+  "Rasuwagadhi witness": "עד Rasuwagadhi",
+  "Open original source for {source}; capture time unverified": "פתיחת המקור המקורי של {source}; זמן הצילום לא אומת",
+  "Historical reference and post-event image divider": "מפריד בין תמונת המקור ההיסטורי לתמונה שאחרי האירוע",
+  "A historical reference {before} percent, B post-event {after} percent": "A מקור היסטורי {before} אחוזים, B אחרי האירוע {after} אחוזים",
+  "■ RELEASE CAMERA": "■ שחרר מצלמה",
+  "Seek Nepal scene clock": "גרירה בשעון סצנת נפאל",
+  "NEPAL SCENE CLOCK": "שעון סצנת נפאל",
+  "… PLAYING SHOT": "… שוט בנגינה",
+  "▶ PLAY SHOT": "▶ נגן שוט",
+  "Ⅱ PAUSE": "Ⅱ השהה",
+  "↺ REPLAY CINEMATIC": "↺ נגן קינמטי שוב",
+  "↺ REPLAY": "↺ נגן שוב",
+  "… PLAYING SCENE": "… סצנה בנגינה",
+  "Continue {scene} from next shot": "המשך את {scene} מהשוט הבא",
+  "current scene": "הסצנה הנוכחית",
+  "Replay the full reconstruction": "נגן את השחזור המלא מחדש",
+  "SCENE SHOT": "שוט הסצנה",
+  "TIME UNVERIFIED": "זמן לא אומת",
+  "{count} SOURCES": {
+    "one": "{count} מקור",
+    "two": "{count} מקורות",
+    "other": "{count} מקורות"
+  },
+  "OUTSIDE IMAGERY SWIPE": "החלקת צילומי חוץ",
+  "{scene} / AUTHORED SHOT": "{scene} / שוט ידני",
+  "NEPAL FLOOD INCIDENT": "אירוע השיטפון בנפאל",
+  "Play {shot}": "נגן את {shot}",
+  "current scene shot": "השוט הנוכחי בסצנה",
+  "Play reconstruction": "נגן שחזור",
+  "Load previous scene shot": "טען את השוט הקודם בסצנה",
+  "Load next scene shot": "טען את השוט הבא בסצנה",
+  "SCHEMATIC CORRIDOR, NOT MODELED ARRIVAL TIME.": "מסדרון סכמטי, לא זמן הגעה ממודל.",
+  "Rasuwa · 26 Aug 2026": "Rasuwa · 26.08.2026",
+  "Event reconstruction": "שחזור האירוע",
+  "BHOTE KOSHI FLOOD INCIDENT": "אירוע השיטפון ב-Bhote Koshi",
+  "NEPAL · 26 AUG 2026": "נפאל · 26.08.2026",
+  "USGS INITIAL REPORT": "דיווח ראשוני של USGS",
+  "26 AUG 2026 · 08:37 NPT": "26.08.2026 · 08:37 NPT",
+  "28.2710° N · 85.5150° E": "28.2710° N · 85.5150° E",
+  "INITIAL M4.4 · RECLASSIFIED M5.2 LANDSLIDE": "ראשוני M4.4 · סווג מחדש כמפולת M5.2",
+  "USGS EVENT us7000tbwb · OPEN SOURCE": "אירוע USGS us7000tbwb · פתח מקור",
+  "Open the USGS initial report for the 26 August 2026 Nepal landslide": "פתיחת הדיווח הראשוני של USGS למפולת בנפאל ב-26 באוגוסט 2026",
+  "Show the Nepal context callout without a border or country fill": "הצגת הערת ההקשר של נפאל ללא גבול או מילוי מדינה",
+  "Introduce Nepal, draw its border, then reveal the Bhote Koshi incident": "הצגת נפאל, שרטוט הגבול שלה ואז חשיפת אירוע Bhote Koshi",
+  "CITIES": "ערים",
+  "Keep the regional incident context and introduce nearby city labels": "שמירת ההקשר האזורי של האירוע והצגת תוויות ערים סמוכות",
+  "PLACES": "מקומות",
+  "Introduce the reconstruction scene key places from trigger to downstream": "הצגת המקומות המרכזיים בסצנת השחזור, מהגורם ועד במורד הזרם",
+  "PATH": "מסלול",
+  "Animate the sourced cyan river-centerline route to Trishuli Bazaar": "הנפשת מסלול קו האמצע של הנהר בטורקיז עד Trishuli Bazaar, לפי המקורות",
+  "OVERVIEW": "סקירה",
+  "Keep the completed flood path and location labels visible": "השארת מסלול השיטפון המושלם ותוויות המיקומים גלויים",
+  "RECORD": "הקלטה",
+  "Reveal the trigger record while making a slow camera approach": "חשיפת רשומת הטריגר תוך התקרבות אטית של המצלמה",
+  "{speed} kn": "{speed} kn",
+  "That file is not valid JSON.": "הקובץ אינו JSON תקין.",
+  "That JSON file is not GeoJSON.": "קובץ ה-JSON אינו GeoJSON.",
+  "That FeatureCollection has no features list.": "ב-FeatureCollection אין רשימת אובייקטים.",
+  "Every GeoJSON feature must have type Feature.": "לכל אובייקט GeoJSON חייב להיות סוג Feature.",
+  "That GeoJSON has invalid geometries.": "ה-GeoJSON מכיל גאומטריות בלתי תקינות.",
+  "That GeoJSON contains an unsupported geometry.": "ה-GeoJSON מכיל גאומטריה שאינה נתמכת.",
+  "That GeoJSON has invalid coordinates.": "ה-GeoJSON מכיל קואורדינטות בלתי תקינות.",
+  "That file creates more than {limit} map objects (the limit).": "הקובץ יוצר יותר מ-{limit} אובייקטי מפה (המגבלה).",
+  "That file has more than {limit} style definitions and image links after cleanup (the limit).": "הקובץ מכיל יותר מ-{limit} הגדרות סגנון וקישורי תמונה לאחר הניקוי (המגבלה).",
+  "That file has more than {limit} features (the limit).": "הקובץ מכיל יותר מ-{limit} אובייקטים (המגבלה).",
+  "That file has more than {limit} points (the limit) across {features} features.": "הקובץ מכיל יותר מ-{limit} נקודות (המגבלה) על פני {features} אובייקטים.",
+  "That file has more than {limit} points (the limit).": "הקובץ מכיל יותר מ-{limit} נקודות (המגבלה).",
+  "That KMZ unpacks to more than the import limit.": "ה-KMZ מתפרק ליותר ממגבלת הייבוא.",
+  "That KMZ is damaged and could not be unpacked.": "ה-KMZ פגום ולא ניתן לפרוק אותו.",
+  "That KMZ is not a readable zip archive.": "ה-KMZ אינו ארכיון zip קריא.",
+  "That KMZ uses a zip format this import does not read.": "ה-KMZ משתמש בתבנית zip שהייבוא הזה אינו קורא.",
+  "That KMZ is encrypted.": "ה-KMZ מוצפן.",
+  "That KMZ uses a compression method this import does not read.": "ה-KMZ משתמש בשיטת דחיסה שהייבוא הזה אינו קורא.",
+  "That KML has invalid geometry bounds.": "ל-KML יש גבולות גאומטריה בלתי תקינים.",
+  "That KML has invalid coordinates.": "ה-KML מכיל קואורדינטות בלתי תקינות.",
+  "That GPX file has no <gpx> document.": "לקובץ ה-GPX אין מסמך <gpx>.",
+  "That {format} file is not valid XML.": "קובץ ה-{format} אינו XML תקין.",
+  "That file has an unreadable image or exceeds the 16-megapixel image limit.": "הקובץ מכיל תמונה שלא ניתן לקרוא או חורג ממגבלת 16 מגה-פיקסל.",
+  "That KML could not be read.": "את ה-KML לא ניתן לקרוא.",
+  "That file has invalid point coordinates.": "הקובץ מכיל קואורדינטות נקודה בלתי תקינות.",
+  "Ground heights are not available for that file. Try again when the map has loaded.": "גבהי הקרקע אינם זמינים עבור הקובץ הזה. נסה שוב אחרי שהמפה נטענת.",
+  "That file took too long to read.": "קריאת הקובץ ארכה יותר מדי זמן.",
+  "Nothing to import.": "אין מה לייבא.",
+  "That file is larger than {size} MiB.": "הקובץ גדול מ-{size} MiB.",
+  "Only GeoJSON, KML, KMZ and GPX files can be imported.": "ניתן לייבא רק קבצי GeoJSON, KML, KMZ ו-GPX.",
+  "That file has nothing to draw.": "אין בקובץ מה לצייר.",
+  "That KMZ holds no KML document.": "ב-KMZ אין מסמך KML.",
+  "That {format} file could not be read.": "את קובץ ה-{format} לא ניתן לקרוא.",
+  "That file has {count} map objects; the limit is {limit}.": "הקובץ מכיל {count} אובייקטי מפה; המגבלה {limit}.",
+  "Ground heights could not be read. Try that file again.": "את גבהי הקרקע לא ניתן לקרוא. נסה שוב את הקובץ הזה.",
+  "That file has invalid point graphics.": "הקובץ מכיל גרפיקת נקודות בלתי תקינה.",
+  "Overpass rate-limited": "Overpass מוגבל בקצב",
+  "Overpass timed out": "Overpass חרג מהזמן הקצוב",
+  "Overpass could not complete the query": "Overpass לא השלים את השאילתה",
+  "Map tiles temporarily unavailable": "אריחי המפה אינם זמינים זמנית",
+  "Mapped names temporarily unavailable": "שמות ממופים אינם זמינים זמנית",
+  "Overpass temporarily unavailable": "Overpass אינו זמין זמנית",
+  "Retrying mapped sites…": "מנסה שוב אתרים ממופים…",
+  "Fetching mapped sites…": "שולף אתרים ממופים…",
+  "{reason} — retrying in {seconds}s": "{reason} — מנסה שוב בעוד {seconds} שניות",
+  "{reason} — retry pending": "{reason} — ניסיון חוזר בתור",
+  "Zoom in to search mapped installations": "התקרב כדי לחפש מתקנים ממופים",
+  "Showing cached mapped sites": "מציג אתרים ממופים מהמטמון",
+  "Mapped sites not loaded": "אתרים ממופים לא נטענו",
+  "Mapped sites loaded": "אתרים ממופים נטענו",
+  "Military airfield": "שדה תעופה צבאי",
+  "Naval base": "בסיס ימי",
+  "Firing range": "שטח אש",
+  "Military land": "שטח צבאי",
+  "Mapped installation": "מתקן ממופה",
+  "Military area": "אזור צבאי",
+  "flight": "טיסה",
+  "military flight": "טיסה צבאית",
+  "satellite": "לוויין",
+  "feed unavailable": "פיד אינו זמין",
+  "feed stale": "פיד מיושן",
+  "observed or mapped nearby context": "הקשר סמוך נצפה או ממופה",
+  "no observed or mapped objects in current feeds": "אין עצמים נצפים או ממופים בפידים הנוכחיים",
+  "Draw": "שרטוט",
+  "Directions": "דרכי הגעה",
+  "Recent imagery": "צילומים אחרונים",
+  "STATION": "תחנות",
+  "Crewed stations and their visiting vehicles": "תחנות מאוישות והחלליות המבקרות בהן",
+  "NAV": "ניווט",
+  "GNSS navigation — GPS, GLONASS, Galileo": "ניווט GNSS — GPS, GLONASS, Galileo",
+  "GEO": "GEO",
+  "Geostationary belt — comms and weather, fixed over the equator": "חגורה גיאו-סטציונרית — תקשורת ומזג אוויר, קבועים מעל קו המשווה",
+  "VISUAL": "ויזואלי",
+  "Brightest naked-eye objects — CelesTrak visual group": "העצמים הבהירים ביותר לעין בלתי מזוינת — קבוצת הויזואל של CelesTrak",
+  "COMMS": "תקשורת",
+  "Broadband constellation shell — shown only in DENSE mode": "מעטפת קונסטלציית פס רחב — מוצגת במצב DENSE בלבד",
+  "FISHING": "דיג",
+  "TOWING": "גרירה",
+  "DREDGER": "מחפר",
+  "DIVE OPS": "פעולות צלילה",
+  "MILITARY": "צבאי",
+  "SAILING": "שייט",
+  "PLEASURE": "פנאי",
+  "PILOT": "נחייה",
+  "SAR": "SAR",
+  "TUG": "גוררת",
+  "PORT TENDER": "אוניית שירות נמל",
+  "ANTI-POLLUTION": "נגד זיהום",
+  "LAW ENFORCE": "אכיפת חוק",
+  "MEDICAL": "רפואי",
+  "HIGH-SPEED": "מהירות גבוהה",
+  "PASSENGER": "נוסעים",
+  "CARGO": "מטען",
+  "TANKER": "מכלית",
+  "OTHER": "אחר",
+  "Included in bundle": "כלול בחבילה",
+  "Missing bundle file — reimport its bundle": "קובץ חבילה חסר — ייבא את החבילה שוב",
+  "Source configured; file checked when loaded": "המקור מוגדר; הקובץ נבדק בעת הטעינה",
+  "Source unavailable": "מקור אינו זמין",
+  "ENVIRONMENTAL": "סביבתי",
+  "EARTH WATCH": "EARTH WATCH",
+  "ACTIVE EVENTS": "אירועים פעילים",
+  "Tip: the GEV MIC button in the dock lets you talk to the map.": "טיפ: לחצן ה-MIC של GEV בעגינה מאפשר לדבר עם המפה.",
+  "Starting live contacts…": "מתחיל מגעים חיים…",
+  "Opening space missions…": "פותח משימות חלל…",
+  "Scanning active events…": "סורק אירועים פעילים…",
+  "Live earthquakes and active fires, from USGS and NASA": "רעידות אדמה חיות ושרפות פעילות, מ-USGS ו-NASA",
+  "It feels like a forbidden cockpit—then you realize the sources are public and the data is real.": "מרגיש כמו תא טייס אסור — ואז מבינים שהמקורות פומביים והנתונים אמיתיים.",
+  "Working…": "מבצע…",
+  "Could not open that mission{detail}. Retry or explore manually.": "לא ניתן לפתוח את המשימה הזאת{detail}. נסה שוב או חקור בידנית.",
+  "This browser is blocking storage, so that could not be saved.": "הדפדפן הזה חוסם אחסון, ולכן לא ניתן היה לשמור.",
+  "NORMAL": "רגיל",
+  "CRT": "CRT",
+  "NVG": "NVG",
+  "FLIR": "FLIR",
+  "ANIME": "אנימה",
+  "NOIR": "נואר",
+  "ARCTIC": "ארקטי",
+  "ANTARCTIC": "אנטארקטי",
+  "NORTH AMERICA": "אמריקה הצפונית",
+  "SOUTH AMERICA": "אמריקה הדרומית",
+  "EUROPE": "אירופה",
+  "AFRICA": "אפריקה",
+  "ASIA": "אסיה",
+  "OCEANIA": "אוקיאניה",
+  "NORTHERN OCEANIC GRID": "רשת אוקיינית צפונית",
+  "SOUTHERN OCEANIC GRID": "רשת אוקיינית דרומית",
+  "LOADING": "טוען",
+  "DEGRADED": "מופחת",
+  "STALE": "מיושן",
+  "PARTIAL": "חלקי",
+  "FALLBACK": "חלופה",
+  "view band|STREET": "רחוב",
+  "view band|CITY": "עיר",
+  "view band|METRO": "מטרו",
+  "view band|REGIONAL": "אזורי",
+  "view band|GLOBAL": "גלובלי",
+  "AIS: --": "AIS: --",
+  "SUMMARY": "סיכום",
+  "REC": "REC",
+  "Awaiting telemetry...": "ממתין לטלמטריה...",
+  "N/A": "לא זמין",
+  "{mode} {band} {locality} | {region} | ALT {alt} | WINDOW {window} | SUN {sun}° | ONA {ona}° | {zone}": "{mode} {band} {locality} | {region} | גובה {alt} | חלון {window} | שמש {sun}° | ONA {ona}° | {zone}",
+  "NEAR {poi} ({city}) {distance}": "קרוב אל {poi} ({city}) {distance}",
+  "SECTOR {lat} {lon}": "סקטור {lat} {lon}",
+  "hemisphere|N": "N",
+  "hemisphere|S": "S",
+  "hemisphere|E": "E",
+  "hemisphere|W": "W",
+  "POWER UP · {count} KEYS WAITING": {
+    "one": "אתחול · {count} מפתח בהמתנה",
+    "two": "אתחול · {count} מפתחות בהמתנה",
+    "other": "אתחול · {count} מפתחות בהמתנה"
+  },
+  "POWERED UP": "מופעל",
+  "Provider Settings does not answer proxied requests": "הגדרות הספקים אינן עונות על בקשות פרוקסי",
+  "Provider Settings is disabled while sharing is enabled": "הגדרות הספקים אינן זמינות במסגרת שיתוף פעיל",
+  "Provider Settings answers only the machine running the server": "הגדרות הספקים עונות רק למכונה שמריצה את השרת",
+  "Provider Settings answers only local hostnames": "הגדרות הספקים עונות רק לשמות מחשב מקומיים",
+  "Provider Settings requires an exact local Origin": "הגדרות הספקים דורשות Origin מקומי מדויק",
+  "Unrecognized Origin refused": "Origin בלתי מזוהה נדחה",
+  "Cross-origin requests are refused": "בקשות חוצות מקור נדחות",
+  "Content-Type must be application/json": "Content-Type חייב להיות application/json",
+  "Method not allowed": "השיטה אינה מותרת",
+  "Request too large": "הבקשה גדולה מדי",
+  "Invalid JSON": "JSON בלתי תקין",
+  "Body must be a JSON object of {ENV_VAR: value}": "הגוף חייב להיות אובייקט JSON של {ENV_VAR: value}",
+  "No keys provided": "לא סופקו מפתחות",
+  "At most {limit} keys per save": "{limit} מפתחות לכל היותר בכל שמירה",
+  "Unknown key: {name}": "מפתח בלתי ידוע: {name}",
+  "{name} must be a string": "{name} חייב להיות מחרוזת",
+  "{name} is empty": "{name} ריק",
+  "{name} is longer than any real key ({limit} max)": "{name} ארוך מכל מפתח אמיתי ({limit} לכל היותר)",
+  "{name} may only contain printable characters with no spaces": "{name} עשוי להכיל רק תווים שניתנים להדפסה ללא רווחים",
+  "{name} contains a character that is not valid in a key (#, quotes, $, \\, or backtick)": "{name} מכיל תו שאינו תקין במפתח (#, מירכאות, $, \\, או בק-טיק)",
+  "{name} is configured outside Provider Settings and can only be changed where it was set": "{name} מוגדר מחוץ להגדרות הספקים וניתן לשינוי רק במקום שבו הוגדר",
+  "The key was not saved: could not restrict the credential file to your account; nothing was saved": "המפתח לא נשמר: לא הצליח להגביל את קובץ הפרטים לחשבון שלך; לא נשמר דבר",
+  "The key was not saved: the existing configuration could not be read, so nothing was changed": "המפתח לא נשמר: לא ניתן לקרוא את התצורה הקיימת, ולכן לא נעשה שינוי",
+  "Could not write the {store} store": "לא ניתן לכתוב את מחסן {store}",
+  "Save failed ({status}).": "השמירה נכשלה ({status}).",
+  "OAuth check failed: {detail}": "בדיקת OAuth נכשלה: {detail}",
+  "Could not check ChatGPT sign-in. Try again.": "לא ניתן לבדוק את ההתחברות ל-ChatGPT. נסה שוב.",
+  "Metered — a billing-enabled account": "מדוד — חשבון מופעל חיוב",
+  "Optional paid token — public access works without one": "אסימון בתשלום אופציונלי — הגישה הציבורית עובדת בלעדיו",
+  "Free key — register, paste, done": "מפתח חינמי — להירשם, להדביק, סיימת",
+  "Project keys: {status}": "מפתחות פרויקט: {status}",
+  "your app configuration": "תצורת האפליקציה שלך",
+  "your local .env": "קובץ ה-.env המקומי שלך",
+  "Saving…": "שומר…",
+  "Save failed: {detail}": "השמירה נכשלה: {detail}",
+  "Paste at least one key first.": "הדבק קודם מפתח אחד לפחות.",
+  "Saved to {store}. Restarting — this page reloads itself.": "נשמר ב-{store}. מאתחל — העמוד הזה יטען את עצמו.",
+  "Remove this key from your saved configuration?": "להסיר את המפתח הזה מהתצורה השמורה שלך?",
+  "Removed from {store}. Restarting — this page reloads itself.": "הוסר מ-{store}. מאתחל — העמוד הזה יטען את עצמו.",
+  "Cloud voice will use OPENAI_API_KEY on the next session.": "הקול בענן ישתמש ב-OPENAI_API_KEY בהפעלה הבאה.",
+  "Checking local ChatGPT OAuth sign-in…": "בודק התחברות OAuth מקומית ל-ChatGPT…",
+  "Could not check ChatGPT sign-in.": "לא ניתן לבדוק את ההתחברות ל-ChatGPT.",
+  "ChatGPT OAuth selected for cloud voice. Your API key stays saved and available.": "נבחר OAuth של ChatGPT לקול בענן. מפתח ה-API שלך נשאר שמור וזמין.",
+  "ChatGPT sign-in expired. Opening sign-in again…": "התחברות ChatGPT פגה. פותח התחברות מחדש…",
+  "Opening ChatGPT sign-in in your browser…": "פותח התחברות ChatGPT בדפדפן שלך…",
+  "Could not start ChatGPT sign-in on this machine.": "לא ניתן להתחיל התחברות ChatGPT במכונה הזאת.",
+  "Finish ChatGPT sign-in in the browser. Waiting for it to complete…": "השלם את התחברות ChatGPT בדפדפן. ממתין להשלמתה…",
+  "ChatGPT sign-in timed out. Click {button} to try again.": "התחברות ChatGPT חרגה מהזמן הקצוב. לחץ על {button} לניסיון חוזר.",
+  "USE CHATGPT OAUTH": "השתמש ב-CHATGPT OAUTH",
+  "ChatGPT sign-in complete. OAuth will be used for the next cloud voice session.": "התחברות ChatGPT הושלמה. OAuth ישמש בהפעלת הקול בענן הבאה.",
+  "The photorealistic 3D planet, place search + Street View": "כוכב הלכת התלת-הממדי הפוטוריאליסטי, חיפוש מקומות + Street View",
+  "Places context + Street View fallback; optional separate key": "הקשר מקומות + גיבוי Street View; מפתח נפרד אופציונלי",
+  "Voice control — API key or ChatGPT OAuth": "שליטה קולית — מפתח API או OAuth של ChatGPT",
+  "Gemini Live voice control": "שליטה קולית של Gemini Live",
+  "Live ships, worldwide": "אוניות חיים, בכל העולם",
+  "Live active-fire detections": "זיהויי שרפות חיים",
+  "Real live traffic (keyless runs a simulation)": "תנועה חיה אמיתית (ללא מפתח רצה סימולציה)",
+  "Bing imagery map stacks + world terrain": "ערמות מפות צילומים של Bing + טופוגרפיה עולמית",
+  "More flight-polling credits (anonymous works without)": "אשראי דגימת טיסות נוסף (אנונימי עובד בלעדיו)",
+  "Street-level imagery and coverage in the Street Level layer. Free: register an app in the Mapillary developer dashboard and paste its Client Token": "צילומי רחוב וכיסוי בשכבת Street Level. חינם: רשמו אפליקציה במרכז השליטה המפתחים של Mapillary והדביקו את ה-Client Token שלה",
+  "Public space-missions access needs no key. Leave blank for standard use; paid tokens only raise request limits.": "הגישה הציבורית למשימות החלל אינה דורשת מפתח. השאר לריקה לשימוש הרגיל; אסימונים בתשלום מעלים רק מגבלות בקשות.",
+  "Air quality request failed": "בקשת איכות האוויר נכשלה",
+  "No readings available": "אין מדידות זמינות",
+  "No current readings": "אין מדידות נוכחיות",
+  "{count} stations reporting": {
+    "one": "{count} תחנה מדווחת",
+    "two": "{count} תחנות מדווחות",
+    "other": "{count} תחנות מדווחות"
+  },
+  "Highest air-quality readings in view": "מדידות איכות האוויר הגבוהות בתצוגה",
+  "Low": "נמוך",
+  "Low health risk": "סיכון בריאותי נמוך",
+  "Moderate": "בינוני",
+  "Moderate health risk": "סיכון בריאותי בינוני",
+  "High": "גבוה",
+  "High health risk": "סיכון בריאותי גבוה",
+  "Very High": "גבוה מאוד",
+  "Very High health risk": "סיכון בריאותי גבוה מאוד",
+  "Air quality": "איכות אוויר",
+  "Canada only · ECCC AQHI network": "קנדה בלבד · רשת AQHI של ECCC",
+  "ECCC request timed out": "בקשת ECCC חרגה מהזמן הקצוב",
+  "Malformed AQHI station response": "תשובת תחנות AQHI פגומה",
+  "No AQHI stations available": "אין תחנות AQHI זמינות",
+  "Malformed AQHI observation response": "תשובת תצפיות AQHI פגומה",
+  "Camera source temporarily unavailable": "מקור המצלמות אינו זמין זמנית",
+  "Mapped camera locations": "מיקומי מצלמות ממופים",
+  "SHOW NEAREST": "הצג את הקרוב",
+  "Stop following the current object before navigating to a camera": "הפסק עקיבה אחר העצם הנוכחי לפני ניווט אל מצלמה",
+  "Move to the nearest loaded camera and show its details": "מעבר אל המצלמה הקרובה שנטענה והצגת פרטיה",
+  "Camera badges": "תגי מצלמות",
+  "Cyan cameras turn coral when selected. Wedges illustrate mapped direction, not measured coverage. Nearby cameras may be outside the screen.": "מצלמות בטורקיז הופכות לאלמוג כשהן נבחרות. המקטעים ממחישים כיוון ממופה, לא כיסוי נמדד. מצלמות סמוכות עשויות להימצא מחוץ למסך.",
+  "{count} nearby · {onScreen} on screen": {
+    "one": "{count} בקרבה · {onScreen} על המסך",
+    "two": "{count} בקרבה · {onScreen} על המסך",
+    "other": "{count} בקרבה · {onScreen} על המסך"
+  },
+  "{count} nearby": {
+    "one": "{count} בקרבה",
+    "two": "{count} בקרבה",
+    "other": "{count} בקרבה"
+  },
+  "retrying mapped ALPR cameras": "מנסה שוב מצלמות ALPR ממופות",
+  "loading mapped ALPR cameras": "טוען מצלמות ALPR ממופות",
+  "No ALPR data for this area — US and Canada only": "אין נתוני ALPR לאזור הזה — ארה\"ב וקנדה בלבד",
+  "Zoom in to load mapped cameras": "התקרב כדי לטעון מצלמות ממופות",
+  "Showing cached locations": "מציג מיקומים מהמטמון",
+  "Coverage limited — zoom in": "כיסוי מוגבל — התקרב",
+  "No ALPR data for this area": "אין נתוני ALPR לאזור הזה",
+  "None on screen — nearby cameras are outside the view": "אין על המסך — המצלמות הסמוכות מחוץ לתצוגה",
+  "ALPR camera": "מצלמת ALPR",
+  "Camera coverage unavailable": "כיסוי מצלמות אינו זמין",
+  "OpenStreetMap · community mapped": "OpenStreetMap · ממופה על ידי הקהילה",
+  "Overpass returned an incomplete camera response": "Overpass החזיר תשובת מצלמות חלקית",
+  "At least {count}": "{count} לפחות",
+  "CONTEXT READY": "ההקשר מוכן",
+  "GLOBAL CONTEXT OFF": "ההקשר הגלובלי כבוי",
+  "SELECT A FLIGHT, VESSEL, OR MAPPED INSTALLATION": "בחר טיסה, כלי שיט או מתקן ממופה",
+  "ENABLE TO LOAD OBSERVED / MAPPED PROXIMITY": "הפעל כדי לטעון קרבה נצפית / ממופה",
+  "Unavailable": "לא זמין",
+  "Focus {label}": "התמקד ב-{label}",
+  "Global Context navigation": "ניווט ההקשר הגלובלי",
+  "PREVIOUS": "הקודם",
+  "Previous — prior visited contact in the 250 km window": "הקודם — מגע שכבר ביקרת בו בחלון של 250 ק\"מ",
+  "FOCUS": "התמקד",
+  "NEXT": "הבא",
+  "Next — nearest unvisited contact in the 250 km window": "הבא — המגע הקרוב ביותר שלא ביקרת בו בחלון של 250 ק\"מ",
+  "Named areas ({n})": "אזורים בעלי שם ({n})",
+  "{distance} FLIGHT / VESSEL WINDOW": "חלון טיסות / כלי שיט של {distance}",
+  "Open-source mapped/observed context. Missing broadcasts, unloaded map areas, or unmapped sites are not evidence of absence.": "הקשר ממופה/נצפה בקוד פתח. שידורים חסרים, אזורי מפה שלא נטענו או אתרים שלא ממופו אינם הוכחה להיעדר.",
+  "mapped matches within {km} km of the subject": "התאמות ממופות בטווח {km} ק\"מ מהעצם",
+  "none mapped within {km} km; not a complete 250 km survey": "אין התאמות ממופות בטווח {km} ק\"מ; אינו מיפוי מלא של 250 ק\"מ",
+  "mapped matches from the loaded viewport": "התאמות ממופות מתוך התצוגה שנטענה",
+  "viewport feed is not a complete 250 km survey": "פיד התצוגה אינו מיפוי מלא של 250 ק\"מ",
+  "HDG {value}°": "HDG {value}°",
+  "BRG {value}°": "BRG {value}°",
+  "BRG —": "BRG —",
+  "CRS {value}°": "CRS {value}°",
+  "CURRENT VIEWPORT ONLY": "התצוגה הנוכחית בלבד",
+  "WITHIN {km} KM": "בטווח {km} ק\"מ",
+  "Flights": "טיסות",
+  "Military flights": "טיסות צבאיות",
+  "AIS vessels": "כלי שיט AIS",
+  "Mapped installations": "מתקנים ממופים",
+  "syncing {count} city feeds...": "מסנכרן {count} פידי ערים...",
+  "scanning nearby systems...": "סורק מערכות סמוכות...",
+  "GBFS fetch error": "שגיאת אחזור GBFS",
+  "Station {id}": "תחנה {id}",
+  "Station": "תחנה",
+  "🚲 {bikes} avail · {docks} docks · {capacity} cap": "🚲 {bikes} זמינות · {docks} עמדות · {capacity} קיבולת",
+  "⚠️ Not installed": "⚠️ לא מותקנת",
+  "⚠️ Not renting": "⚠️ לא משכירה",
+  "⚠️ Not returning": "⚠️ לא מקבלת החזרות",
+  "HDG {value}° (ESTIMATED)": "HDG {value}° (מוערך)",
+  "CALIBRATED": "מכויל",
+  "CURATED": "קוראטד",
+  "RAW PRIOR": "הערכה ראשונית",
+  "SNAPSHOT": "תמונת מצב",
+  "LIVE": "חי",
+  "UPSTREAM": "מקור",
+  "SYNTHETIC": "סינתטי",
+  "CONFIGURED": "מוגדר",
+  "SEED": "קטלוג",
+  "IMAGE": "תמונה",
+  "UNKNOWN": "לא ידוע",
+  "{count} CAMERAS STANDING BY · NO CAMERA SELECTED · CLICK A CAMERA TO ACTIVATE": "{count} מצלמות במצב המתנה · לא נבחרה מצלמה · לחץ על מצלמה להפעלה",
+  "No cameras available in catalog.": "אין מצלמות זמינות בקטלוג.",
+  "{city} CCTV": "{city} · CCTV",
+  "FOV {value}° (DATASHEET)": "FOV {value}° (דף נתונים)",
+  "FOV {value}°": "FOV {value}°",
+  "SPEC FOV {span}° (CAPABILITY)": "FOV מפרט {span}° (יכולת)",
+  "COVERAGE {value}km²": "כיסוי {value} קמ\"ר",
+  "OVERLAP {count} cams": "חפיפה: {count} מצלמות",
+  "ISOLATED VIEW": "תצוגה מבודדת",
+  "PROJ MONITOR": "הקרנה — מסך",
+  "PROJ OFF": "הקרנה כבויה",
+  "VIEWSHED": "שדה ראייה",
+  "CAL {value}": "CAL {value}",
+  "SRC {value}": "SRC {value}",
+  "{value} CONTEXT": "הקשר {value}",
+  "{spec} · SPECS: CCTV-DATABASE.COM": "{spec} · מפרט: CCTV-DATABASE.COM",
+  "Atlantic and eastern/central North Pacific; not worldwide cyclone coverage.": "האטלנטי והפסיפיק הצפוני המזרחי/מרכזי; אין כיסוי ציקלונים עולמי.",
+  "Cyclone advisories unavailable": "ייעוצי ציקלונים אינם זמינים",
+  "Cyclone data unavailable": "נתוני ציקלונים אינם זמינים",
+  "Potential tropical cyclone": "ציקלון טרופי פוטנציאלי",
+  "Post-tropical cyclone": "ציקלון פוסט-טרופי",
+  "Hurricane": "הוריקן",
+  "Tropical storm": "סערה טרופית",
+  "Tropical depression": "דיפרסיה טרופית",
+  "Subtropical storm": "סערה סובטרופית",
+  "Subtropical depression": "דיפרסיה סובטרופית",
+  "Track and cone match this advisory": "המסלול והחרוט תואמים לייעוץ הזה",
+  "Track/cone awaiting advisory {number}": "מסלול/חרוט ממתין לייעוץ {number}",
+  "Track/cone unavailable": "מסלול/חרוט אינם זמינים",
+  "Cached advisory · stale source": "ייעוץ מהמטמון · מקור מיושן",
+  "Loading advisories…": "טוען ייעוצים…",
+  "{count} active storms": {
+    "one": "{count} סערה פעילה",
+    "two": "{count} סערות פעילות",
+    "other": "{count} סערות פעילות"
+  },
+  "Position as of {time}": "מיקום נכון ל-{time}",
+  "Maximum sustained wind: {wind} · Pressure: {pressure}": "רוח מתמשכת מרבית: {wind} · לחץ: {pressure}",
+  "{name} · {classification} · Advisory {number} · issued {time}": "{name} · {classification} · ייעוץ {number} · פורסם {time}",
+  "No active NHC/CPHC systems": "אין מערכות NHC/CPHC פעילות",
+  "Advisories unavailable": "ייעוצים אינם זמינים",
+  "Cyclones · NHC / CPHC": "ציקלונים · NHC / CPHC",
+  "Atlantic · E/C Pacific": "האטלנטי · הפסיפיק מ/צ",
+  "{storms} · {name} selected": "{storms} · {name} נבחר",
+  "Official advisory ↗": "ייעוץ רשמי ↗",
+  "Active NHC and CPHC cyclone advisories": "ייעוצי ציקלונים פעילים של NHC ו-CPHC",
+  "Wind unavailable": "רוח אינה זמינה",
+  "Advisory center / forecast track": "מרכז הייעוץ / מסלול חזוי",
+  "Center-track uncertainty cone": "חרוט אי-ודאות של מסלול המרכז",
+  "Select a storm on the map, or choose a storm in the list to select it and move the camera. Click empty map space to clear the selection. NOAA NHC/CPHC advisory context. The cone describes forecast center-track uncertainty, not storm size or the full hazard area. Forecast point labels are source lead hours, not times computed from advisory issuance. Geometry follows the surface; height is not weather altitude. Consult the official advisory.": "בחר סערה במפה, או בחר סערה ברשימה כדי לבחור אותה ולהזיז את המצלמה. לחץ בשטח ריק במפה כדי לבטל את הבחירה. הקשר ייעוצים של NOAA NHC/CPHC. החרוט מתאר אי-ודאות של מסלול המרכז בחזוי, לא את גודל הסערה ולא את מלוא אזור הסכנה. תוויות נקודות החזוי הן שעות חיזוי של המקור, לא זמנים שחושבו מפרסום הייעוץ. הגאומטריה נצמדת לפני הקרקע; הגובה אינו גובה מטאורולוגי. היווע בייעוץ הרשמי.",
+  "Malformed cyclone snapshot": "תמונת מצב של ציקלון פגומה",
+  "Cyclone request timed out": "בקשת הציקלון חרגה מהזמן הקצוב",
+  "DRIVE": "נסיעה",
+  "Drive": "נסיעה",
+  "WALK": "הליכה",
+  "Walk": "הליכה",
+  "BIKE": "אופניים",
+  "Bike": "אופניים",
+  "Routing is rate limited — try again in a moment": "הניתוב מוגבל בקצב — נסה שוב בעוד רגע",
+  "Routing unavailable": "ניתוב אינו זמין",
+  "direction|left": "שמאלה",
+  "direction|right": "ימינה",
+  "direction|slightly left": "שמאלה קלות",
+  "direction|slightly right": "ימינה קלות",
+  "direction|sharply left": "שמאלה בחדות",
+  "direction|sharply right": "ימינה בחדות",
+  "direction|straight": "ישר",
+  "direction|around": "דרך המעגל",
+  "fork direction|left": "שמאלה",
+  "fork direction|right": "ימינה",
+  "fork direction|slightly left": "שמאלה קלות",
+  "fork direction|slightly right": "ימינה קלות",
+  "fork direction|sharply left": "שמאלה בחדות",
+  "fork direction|sharply right": "ימינה בחדות",
+  "fork direction|straight": "ישר",
+  "lane direction|left": "שמאלה",
+  "lane direction|right": "ימינה",
+  "lane direction|slightly left": "שמאלה קלות",
+  "lane direction|slightly right": "ימינה קלות",
+  "lane direction|sharply left": "שמאלה בחדות",
+  "lane direction|sharply right": "ימינה בחדות",
+  "lane direction|straight": "ישר",
+  "ordinal|{number}st": "{number}.",
+  "ordinal|{number}nd": "{number}.",
+  "ordinal|{number}rd": "{number}.",
+  "ordinal|{number}th": "{number}.",
+  "Head out on {road}": "צא אל {road}",
+  "Head out": "צא לדרך",
+  "Arrive at your destination, on the left": "הגעה ליעד, בצד שמאל",
+  "Arrive at your destination, on the right": "הגעה ליעד, בצד ימין",
+  "Arrive at your destination": "הגעה ליעד",
+  "Make a U-turn onto {road}": "בצע פניית פרסה אל {road}",
+  "Make a U-turn": "בצע פניית פרסה",
+  "Continue straight onto {road}": "המשך ישר אל {road}",
+  "Continue straight": "המשך ישר",
+  "Turn {direction} onto {road}": "פנה {direction} אל {road}",
+  "Turn {direction}": "פנה {direction}",
+  "Turn onto {road}": "פנה אל {road}",
+  "maneuver|Turn": "פנייה",
+  "Continue {direction} onto {road}": "המשך {direction} אל {road}",
+  "Continue {direction}": "המשך {direction}",
+  "At the end of the road, turn {direction} onto {road}": "בקצה הכביש, פנה {direction} אל {road}",
+  "At the end of the road, turn {direction}": "בקצה הכביש, פנה {direction}",
+  "At the end of the road, continue onto {road}": "בקצה הכביש, המשך אל {road}",
+  "At the end of the road, continue": "בקצה הכביש, המשך",
+  "Keep {direction} at the fork onto {road}": "הישאר {direction} בפיצול אל {road}",
+  "Keep {direction} at the fork": "הישאר {direction} בפיצול",
+  "Continue at the fork onto {road}": "המשך בפיצול אל {road}",
+  "Continue at the fork": "המשך בפיצול",
+  "Merge {direction} onto {road}": "השתלב {direction} אל {road}",
+  "Merge {direction}": "השתלב {direction}",
+  "Merge onto {road}": "השתלב אל {road}",
+  "maneuver|Merge": "שילוב",
+  "Take the ramp on the {direction} onto {road}": "היכנס לכביש הגישה {direction} אל {road}",
+  "Take the ramp on the {direction}": "היכנס לכביש הגישה {direction}",
+  "Take the ramp {direction} onto {road}": "היכנס לכביש הגישה {direction} אל {road}",
+  "Take the ramp {direction}": "היכנס לכביש הגישה {direction}",
+  "Take the ramp onto {road}": "היכנס לכביש הגישה אל {road}",
+  "Take the ramp": "היכנס לכביש הגישה",
+  "Take the exit on the {direction} onto {road}": "קח את היציאה {direction} אל {road}",
+  "Take the exit on the {direction}": "קח את היציאה {direction}",
+  "Take the exit {direction} onto {road}": "קח את היציאה {direction} אל {road}",
+  "Take the exit {direction}": "קח את היציאה {direction}",
+  "Take the exit onto {road}": "קח את היציאה אל {road}",
+  "Take the exit": "קח את היציאה",
+  "At the roundabout, take the {exit} exit onto {road}": "במעגל התנועה, היכנס ליציאה {exit} אל {road}",
+  "At the roundabout, take the {exit} exit": "במעגל התנועה, היכנס ליציאה {exit}",
+  "Enter the roundabout onto {road}": "היכנס למעגל התנועה אל {road}",
+  "Enter the roundabout": "היכנס למעגל התנועה",
+  "At the roundabout, turn {direction} onto {road}": "במעגל התנועה, פנה {direction} אל {road}",
+  "At the roundabout, turn {direction}": "במעגל התנועה, פנה {direction}",
+  "At the roundabout, continue onto {road}": "במעגל התנועה, המשך אל {road}",
+  "At the roundabout, continue": "במעגל התנועה, המשך",
+  "Exit the roundabout onto {road}": "צא ממעגל התנועה אל {road}",
+  "Exit the roundabout": "צא ממעגל התנועה",
+  "Use the {direction} lane onto {road}": "השתמש בנתיב {direction} אל {road}",
+  "Use the {direction} lane": "השתמש בנתיב {direction}",
+  "Continue onto {road}": "המשך אל {road}",
+  "maneuver|Continue": "המשך",
+  "{mode} — reroute for {modeLower}": "{mode} — ניתוב מחדש עבור {modeLower}",
+  "CLICK MAP": "לחץ על המפה",
+  "SET A": "קבע A",
+  "Click a spot on the globe to place A (click again to cancel)": "לחץ על נקודה בגלובוס כדי לקבוע את A (לחיצה נוספת מבטלת)",
+  "Then click the globe to place the start": "ואז לחץ על הגלובוס להצבת ההתחלה",
+  "SET B": "קבע B",
+  "Click a spot on the globe to place B (click again to cancel)": "לחץ על נקודה בגלובוס כדי לקבוע את B (לחיצה נוספת מבטלת)",
+  "Then click the globe to place the destination": "ואז לחץ על הגלובוס להצבת היעד",
+  "Swap A and B": "החלפה בין A ל-B",
+  "FLY ···": "עף ···",
+  "FLYING": "בטיסה",
+  "FLY": "עף",
+  "Fly the camera along the route": "עיפה את המצלמה לאורך המסלול",
+  "Place A and B first": "קבע קודם את A ו-B",
+  "action|CLEAR": "נקה",
+  "Remove the route and both markers": "הסרת המסלול ושני הסמנים",
+  "press Escape twice to leave Draw": "הקש Escape פעמיים כדי לצאת משרטוט",
+  "{name} is active — turn {name} off, then set {endpoint}": "{name} פעיל — כבה את {name} ואז קבע את {endpoint}",
+  "{name} is active — {leave}, then set {endpoint}": "{name} פעיל — {leave} ואז קבע את {endpoint}",
+  "Only the first {count} turns of this route are shown": "מוצגים רק {count} הפניות הראשונות של המסלול הזה",
+  "Turn-by-turn directions": "הכוונה צעד אחר צעד",
+  "Another map tool is using clicks — close it, then SET A again": "כלי מפה אחר משתמש בלחיצות — סגור אותו ואז קבע A שוב",
+  "Routing…": "מחשב מסלול…",
+  "No route found": "לא נמצא מסלול",
+  "{distance} · {duration} · {mode} · first {count} turns": "{distance} · {duration} · {mode} · {count} הפניות הראשונות",
+  "{distance} · {duration} · {mode}": "{distance} · {duration} · {mode}",
+  "Click the globe to place {endpoint}": "לחץ על הגלובוס כדי לקבוע את {endpoint}",
+  "SET B, then click the globe": "קבע B ואז לחץ על הגלובוס",
+  "SET A, then click the globe": "קבע A ואז לחץ על הגלובוס",
+  "Step {step} of {total} · then {leg}": "שלב {step} מתוך {total} · ואז {leg}",
+  "Step {step} of {total}": "שלב {step} מתוך {total}",
+  "Then: {instruction}": "ואז: {instruction}",
+  "No route found between A and B": "לא נמצא מסלול בין A ל-B",
+  "Routing timed out": "חישוב המסלול חרג מהזמן הקצוב",
+  "Routing unavailable — no response from the routing service": "ניתוב אינו זמין — אין תשובה משירות הניתוב",
+  "{lower} to {upper}": "{lower} עד {upper}",
+  "Up to {upper}": "עד {upper}",
+  "From {lower}": "מ-{lower}",
+  "Informational only · not for flight planning": "למידע בלבד · לא לתכנון טיסה",
+  "Unnamed zone": "אזור ללא שם",
+  "Restricted airspace source unavailable": "מקור שמורות הטיס אינו זמין",
+  "Prohibited (P)": "אסור (P)",
+  "Restricted (R)": "שמור (R)",
+  "FAA prohibited and restricted special-use airspace only, not the UAS Facility Map or UAS flight restrictions. Informational only — not a substitute for official UAS flight-planning tools (B4UFLY / LAANC).": "שמורות טיס ושמיים מיוחדים אסורים של ה-FAA בלבד, לא מפת ה-UAS Facility או מגבלות טיסה של UAS. למידע בלבד — אינו תחליף לכלי תכנון טיסה רשמיים של UAS (B4UFLY / LAANC).",
+  "Prohibited": "אסור",
+  "Restricted": "שמור",
+  "Earthquake source unavailable": "מקור רעידות האדמה אינו זמין",
+  "Focus fire detection {title}, {details}": "התמקדות בזיהוי שריפה {title}, {details}",
+  "live feed unavailable": "פיד חי אינו זמין",
+  "{value} conf": "ודאות {value}",
+  "{value} ago": "לפני {value}",
+  "sensor n/a": "חיישן לא זמין",
+  "FIRE · {frp} MW": "שריפה · {frp} MW",
+  "NIGHT": "לילה",
+  "▲ {frp} MW": "▲ {frp} MW",
+  "max {value} MW": "מקס {value} MW",
+  "new {value}": "חדש לפני {value}",
+  "{n} fires": {
+    "one": "{n} שריפות",
+    "two": "{n} שריפות",
+    "other": "{n} שריפות"
+  },
+  "{value}°N": "{value}°N",
+  "{value}°S": "{value}°S",
+  "{value}°E": "{value}°E",
+  "{value}°W": "{value}°W",
+  "just now": "כרגע",
+  "<1m ago": "לפני פחות מדקה",
+  "{count}m ago": "לפני {count} דק'",
+  "{count}h ago": "לפני {count} שע'",
+  "fire confidence|high": "גבוהה",
+  "fire confidence|nominal": "רגילה",
+  "fire confidence|low": "נמוכה",
+  "age|<1h": "פחות משעה",
+  "age|{count}h": "{count} שעות",
+  "age|{count}d": "{count} ימים",
+  "fire confidence filter|All": "הכול",
+  "fire confidence filter|Nominal+": "רגילה+",
+  "fire confidence filter|High": "גבוהה",
+  "Every detection — many of the strongest fires are rated low confidence": "כל זיהוי — חלק מהשריפות החזקות ביותר מדורגות בוודאות נמוכה",
+  "Nominal and high confidence detections": "זיהויים בוודאות רגילה וגבוהה",
+  "High confidence detections only": "זיהויים בוודאות גבוהה בלבד",
+  "Fire intensity (FRP)": "עוצמת השריפה (FRP)",
+  "Minimum fire radiative power, megawatts": "ספק קרינת שריפה מינימלי, מגה-ואט",
+  "≥ {value} MW": "≥ {value} MW",
+  "fire intensity filter|All": "הכול",
+  "Confidence": "ודאות",
+  "Detection confidence": "ודאת הזיהוי",
+  "{shown} of {total} shown": "{shown} מתוך {total} מוצגים",
+  "STALE · cached {age}": "מיושן · מהמטמון לפני {age}",
+  "refreshing...": "מרענן...",
+  "loading...": "טוען...",
+  "KEY REQUIRED": "נדרש מפתח",
+  "LIVE · updated {age}": "חי · עודכן לפני {age}",
+  "FIRE": "שריפה",
+  "Source snapshot time unavailable": "זמן תמונת המצב של המקור אינו זמין",
+  "Live data unavailable": "נתונים חיים אינם זמינים",
+  "Intel Picture": "Intel Picture",
+  "Kinetic 30d": "Kinetic 30d",
+  "Border Crisis": "Border Crisis",
+  "Iran Picture": "Iran Picture",
+  "Iran Kinetic": "Iran Kinetic",
+  "Yemen FLOT": "Yemen FLOT",
+  "Latest Drop": "Latest Drop",
+  "GhostMaps file could not be read": "קובץ GhostMaps לא ניתן לקריאה",
+  "{count} source links ↗ · click card to open the first": {
+    "one": "{count} קישור מקור ↗ · לחץ על הכרטיס לפתיחת הראשון",
+    "two": "{count} קישורי מקור ↗ · לחץ על הכרטיס לפתיחת הראשון",
+    "other": "{count} קישורי מקור ↗ · לחץ על הכרטיס לפתיחת הראשון"
+  },
+  "S2 · {name}": "S2 · {name}",
+  "Report": "דוח",
+  "Open the source for {title}": "פתיחת המקור של {title}",
+  "GhostMaps catalog unavailable": "קטלוג GhostMaps אינו זמין",
+  "LIVE · GitHub {commit} · {message} · checked every {seconds}s": "חי · GitHub {commit} · {message} · בדיקה כל {seconds} שניות",
+  "GitHub {commit} · {message} · reconnecting for live updates": "GitHub {commit} · {message} · מתחבר מחדש לעדכונים חיים",
+  "Connecting to the S2 GhostMaps repository…": "מתחבר למאגר S2 GhostMaps…",
+  "{count} placemarks": {
+    "one": "{count} סימון מקום",
+    "two": "{count} סימני מקום",
+    "other": "{count} סימני מקום"
+  },
+  "S2 Underground publishes these KMZ products to GitHub. New uploads are detected within seconds and replace the previous edition automatically. Click a marker for its report.": "S2 Underground מפרסם את מוצרי ה-KMZ האלה ב-GitHub. העלאות חדשות מזוהות בתוך שניות ומחליפות אוטומטית את המהדורה הקודמת. לחץ על סמן לדוח שלו.",
+  "Malformed GhostMaps catalog": "קטלוג GhostMaps פגום",
+  "Low-accuracy score < 2%": "ציון דיוק נמוך פחות מ-2%",
+  "Low-accuracy score 2–10%": "ציון דיוק נמוך 2–10%",
+  "Low-accuracy score > 10%": "ציון דיוק נמוך מעל 10%",
+  "GNSS integrity source unavailable": "מקור שלמות ה-GNSS אינו זמין",
+  "Regional sample · 250 nm radius · cells from visited views over {minutes} min": "דגימה אזורית · רדיוס 250 מייל ימי · תאים מתצפיות שביקרת על פני {minutes} דק",
+  "Retrying automatically at {time} UTC": "מנסה שוב אוטומטית ב-{time} UTC",
+  "Retrying automatically after provider cooldown": "מנסה שוב אוטומטית אחרי קירור הספק",
+  "Updates automatically after pan or zoom and once a minute. The public feed covers a 250-nautical-mile circle around the view centre; zooming out does not make it a worldwide snapshot. Blank cells are outside sampled coverage or have insufficient observations.": "מתעדכן אוטומטית אחרי הזזה או זום ופעם בדקה. הפיד הציבורי מכסה מעגל של 250 מייל ימי סביב מרכז התצוגה; זום החוצה לא הופך אותו לתמונת-מצב עולמית. תאים ריקים נמצאים מחוץ לדגימה או חסרי תצפיות דיין.",
+  "Low-accuracy score = 100 × max(0, bad − 1) / total: one aircraft is discounted, so this is not the raw share. Cells need {aircraft} aircraft over {minutes} minutes. Navigation-integrity anomalies are not a detection of jamming or spoofing.": "ציון דיוק נמוך = 100 × מקס(0, פגומים − 1) / סה\"כ: מטוס אחד מנוכה, ולכן זה אינו השבר הגולמי. לתאים דרושים {aircraft} מטוסים על פני {minutes} דקות. אנומליות שלמות ניווט אינן זיהוי של שיבוש או הטעיה.",
+  "GNSS snapshot needs a view anchor": "תמונת מצב GNSS דורשת עוגן תצוגה",
+  "GNSS feed rate limited (HTTP 429)": "פיד GNSS מוגבל בקצב (HTTP 429)",
+  "Malformed GNSS integrity snapshot": "תמונת מצב שלמות GNSS פגומה",
+  "GNSS integrity snapshot has no observation time": "תמונת מצב שלמות GNSS חסרה זמן תצפית",
+  "installation class|AIRFIELD": "שדה תעופה",
+  "installation class|NAVAL BASE": "בסיס ימי",
+  "installation class|RANGE": "שטח אש",
+  "installation class|MILITARY LAND": "שטח צבאי",
+  "installation class|BASE": "בסיס",
+  "installation class|BARRACKS": "מחנה",
+  "installation class|TRAINING AREA": "שטח אימונים",
+  "installation class|PLACES CANDIDATE": "מועמד למקומות",
+  "installation class|INSTALLATION": "מתקן",
+  "No mapped sites within {km} km of the contact": "אין אתרים ממופים בטווח {km} ק\"מ מהמגע",
+  "{count} mapped sites within {km} km of the contact": {
+    "one": "{count} אתרים ממופים בטווח {km} ק\"מ מהמגע",
+    "two": "{count} אתרים ממופים בטווח {km} ק\"מ מהמגע",
+    "other": "{count} אתרים ממופים בטווח {km} ק\"מ מהמגע"
+  },
+  "No mapped sites in view": "אין אתרים ממופים בתצוגה",
+  "{count} mapped sites in view": {
+    "one": "{count} אתרים ממופים בתצוגה",
+    "two": "{count} אתרים ממופים בתצוגה",
+    "other": "{count} אתרים ממופים בתצוגה"
+  },
+  "loading mapped installation context": "טוען הקשר מתקנים ממופים",
+  "Too many mapped sites in view to list them all": "יותר מדי אתרים ממופים בתצוגה מכדי להציג את כולם",
+  "Installation context unavailable": "הקשר המתקן אינו זמין",
+  "MAPPED INSTALLATION": "מתקן ממופה",
+  "Unknown": "לא ידוע",
+  "LAUNCH SITE · {site}": "אתר שיגור · {site}",
+  "LAUNCH SITE": "אתר שיגור",
+  "T−{time} · {mission}": "T−{time} · {mission}",
+  "LAUNCH STANDBY": "המתנה לשיגור",
+  "LIFTOFF · {mission}": "ניתוק מהקרקע · {mission}",
+  "ASCENT REPLAY · {mission}": "שחזור עלייה · {mission}",
+  "ASCENT ESTIMATE · {mission}": "הערכת עלייה · {mission}",
+  "STAGE RE-ENTRY / RECOVERY · {mission}": "חדירה חזרה / שחזור שלב · {mission}",
+  "ORBIT REPLAY · {mission}": "שחזור מסלול · {mission}",
+  "PAUSED · {title}": "מושהה · {title}",
+  "CONFIRMED": "מאושר",
+  "PAD / RTLS": "פלטפורמה / RTLS",
+  "UNSPECIFIED": "לא צוין",
+  "{value} KM DOWNRANGE": "{value} ק\"מ במורד הטווח",
+  "POSITION UNAVAILABLE": "מיקום אינו זמין",
+  "FLIGHT {count}": "טיסה {count}",
+  "REUSED": "משומש",
+  "+{count} additional payload records": "+{count} רשומות מטען נוספות",
+  "Select {mission}": "בחר את {mission}",
+  "UNSPECIFIED OPERATOR": "מפעיל לא צוין",
+  "DATE UNAVAILABLE": "תאריך אינו זמין",
+  "{count} / 30D": "{count} / 30D",
+  "NO MISSIONS AVAILABLE IN THE CURRENT 30-DAY WINDOW": "אין משימות זמינות בחלון 30 הימים הנוכחי",
+  "{value} KM": "{value} ק\"מ",
+  "{value} KM/S": "{value} ק\"מ/ש",
+  "EST. DOWNRANGE": "הערכה במורד הטווח",
+  "PLANNED · ": "מתוכנן · ",
+  "SUPPLIED TRAJECTORY POINTS": "נקודות מסלול שסופקו",
+  "RECONSTRUCTED ESTIMATE": "הערכת שחזור",
+  "Resume replay": "המשך השמעה חוזרת",
+  "Pause replay": "השהה השמעה חוזרת",
+  "T minus {seconds}": "נותרו {seconds} שניות לשיגור",
+  "Preparing launch site": "מכין את אתר השיגור",
+  "Liftoff": "ניתוק",
+  "Ascent replay": "שחזור עלייה",
+  "Orbit replay": "שחזור מסלול",
+  ", paused": ", מושהה",
+  "Malformed launch snapshot": "תמונת מצב שיגור פגומה",
+  "Heard by your receiver": "נקלט במקלט שלך",
+  "1090 MHz": "1090 MHz",
+  "978 MHz UAT": "978 MHz UAT",
+  "browser SDR": "SDR דפדפן",
+  "decoder feed": "פיד דקודר",
+  "Your RTL-SDR receiver and decoder feed": "מקלט ה-RTL-SDR שלך ופיד הדקודר",
+  "Your decoder feed": "פיד הדקודר שלך",
+  "Your RTL-SDR receiver": "מקלט ה-RTL-SDR שלך",
+  "NO CALLSIGN": "אין קריאת קוד",
+  "ALT {altitude} FT · GS {speed} KT · TRK {track}": "ALT {altitude} FT · GS {speed} KT · TRK {track}",
+  "V/S {rate}": "V/S {rate}",
+  "V/S {rate} FPM": "V/S {rate} FPM",
+  "POSITION {age}": "מיקום לפני {age}",
+  "POSITION {seconds} S AGO": "מיקום לפני {seconds} שניות",
+  "{count} MSGS": {
+    "one": "{count} הודעות",
+    "two": "{count} הודעות",
+    "other": "{count} הודעות"
+  },
+  "Decoder feeds": "פידי דקודר",
+  "WebUSB + decoder feeds": "WebUSB + פידי דקודר",
+  "opening receiver": "פותח מקלט",
+  "checking decoder feeds": "בודק פידי דקודר",
+  "WebUSB needs desktop Chrome or Edge": "WebUSB דורש Chrome או Edge במחשב",
+  "connect a receiver in Radio": "חבר מקלט ברדיו",
+  "receiver is in FM mode": "המקלט במצב FM",
+  "listening": "מקשיב",
+  "USB error": "שגיאת USB",
+  "Alt unknown": "גובה לא ידוע",
+  "Type unknown": "סוג לא ידוע",
+  "Reg unknown": "רישום לא ידוע",
+  "Operator unknown": "מפעיל לא ידוע",
+  "Voice place search (needs an Overpass server)": "חיפוש מקומות בקול (דורש שרת Overpass)",
+  "${amount}K": "${amount}K",
+  "${amount}M": "${amount}M",
+  "${amount}B": "${amount}B",
+  "fire cause|Human": "אנושית",
+  "fire cause|Natural": "טבעית",
+  "fire cause|Undetermined": "לא נקבעה",
+  "fire cause|Unknown": "לא ידועה",
+  "fire behavior|Minimal": "מינימלי",
+  "fire behavior|Moderate": "בינוני",
+  "fire behavior|Active": "פעיל",
+  "fire behavior|Extreme": "קיצוני",
+  "Type {level} Incident": "אירוע מדרגה {level}",
+  "age|{count}m": "{count} דקות",
+  "{acres} ac": {
+    "one": "{acres} אקר",
+    "two": "{acres} אקר",
+    "other": "{acres} אקר"
+  },
+  "{percent}% contained": "{percent}% בהכלה",
+  "containment unknown": "הכלה לא ידועה",
+  "{cause} cause": "סיבה {cause}",
+  "{personnel} personnel": {
+    "one": "{personnel} כוח אדם",
+    "two": "{personnel} כוח אדם",
+    "other": "{personnel} כוח אדם"
+  },
+  "{county} County": "מחוז {county}",
+  "{cost} to date": "{cost} עד כה",
+  "discovered {age} ago": "התגלה לפני {age}",
+  "updated {age} ago": "עודכן לפני {age}",
+  "part of {complex}": "חלק מ-{complex}",
+  "InciWeb ↗ · click card to open": "InciWeb ↗ · לחץ על הכרטיס לפתיחה",
+  "FIRE · {name}": "שריפה · {name}",
+  "Unnamed incident": "אירוע ללא שם",
+  "Open {title} on InciWeb": "פתיחת {title} ב-InciWeb",
+  "Perimeter source unavailable": "מקור ההיקף אינו זמין",
+  "Not contained or unknown": "לא הוכל או לא ידוע",
+  "Under 50% contained": "הכלה מתחת ל-50%",
+  "50–99% contained": "הכלה 50–99%",
+  "Fully contained": "הכלה מלאה",
+  "Colour shows reported containment. Perimeters are simplified to about 100 m.": "הצבע מציג את ההכלה שדווחה. ההיקפים מפושטים לכ-100 מ׳.",
+  "Malformed perimeter snapshot": "תמונת מצב היקף פגומה",
+  "radio tag|All": "הכול",
+  "News": "חדשות",
+  "Talk": "שיחות",
+  "Weather / Emergency": "מזג אוויר / חירום",
+  "Public Safety": "ביטחון הפנים",
+  "Aviation / Marine": "תעופה / ימי",
+  "Traffic / Transit": "תנועה / תחבורה",
+  "Music": "מוזיקה",
+  "Other": "אחר",
+  "Directory refresh degraded; showing the previous station catalog.": "רענון המדריך בהידרדרות; מציג את קטלוג התחנות הקודם.",
+  "Radio directory coverage is degraded.": "כיסוי מדריך הרדיו מופחת.",
+  "Directory refresh failed; showing the previous station catalog.": "רענון המדריך נכשל; מציג את קטלוג התחנות הקודם.",
+  "Radio directory is temporarily unavailable.": "מדריך הרדיו אינו זמין כרגע.",
+  "radio|NEWS": "חדשות",
+  "radio|TALK": "שיחות",
+  "radio|WEATHER": "מזג אוויר",
+  "radio|SAFETY": "ביטחון",
+  "radio|AIR / SEA": "אוויר / ים",
+  "radio|TRANSIT": "תחבורה",
+  "radio|MUSIC": "מוזיקה",
+  "radio|OTHER": "אחר",
+  "Broadcaster stream is unavailable or blocked by the browser.": "הזרמת המשדר אינה זמינה או נחסמת על ידי הדפדפן.",
+  "Playback requires a direct click or tap.": "ההשמעה דורשת לחיצה או הקשה ישירה.",
+  "Broadcaster stream could not be started.": "לא ניתן להתחיל הזרמה מהמשדר.",
+  "Alternative": "אלטרנטיבי",
+  "Ambient": "אמביינט",
+  "Blues": "בלוז",
+  "Classical": "קלאסי",
+  "Country": "קאנטרי",
+  "Dance": "דאנס",
+  "Electronic": "אלקטרוני",
+  "Folk": "פולק",
+  "Funk": "פאנק",
+  "Hip-Hop": "היפ-הופ",
+  "House": "האוס",
+  "Indie": "אינדי",
+  "Jazz": "ג׳אז",
+  "Latin": "לטיני",
+  "Metal": "מטאל",
+  "Oldies": "קלאסיקות",
+  "Pop": "פופ",
+  "Punk": "פאנק",
+  "R&B": "R&B",
+  "Reggae": "רגאיי",
+  "Rock": "רוק",
+  "Soul": "סול",
+  "Techno": "טכנו",
+  "Trance": "טראנס",
+  "World": "עולמית",
+  "overview": "סקירה",
+  "cloud unknown": "עננות לא ידועה",
+  "{percent}% scene cloud": "{percent}% עננות בסצנה",
+  "{min}–{max}% scene cloud": "{min}–{max}% עננות בסצנה",
+  "Comparison in use by another scene": "ההשוואה בשימוש של סצנה אחרת",
+  "Esri map unavailable · no swipe": "מפת Esri אינה זמינה · אין החלקה",
+  "Swipe needs a globe map": "ההחלקה דורשת מפת גלובוס",
+  "Imagery stays on Esri · CLEAR to use Google 3D": "הצילומים נשארים ב-Esri · נקה כדי להשתמש ב-Google 3D",
+  "Imagery catalog unavailable": "קטלוג הצילומים אינו זמין",
+  "Catalog truncated · a newer clear day may exist": "הקטלוג נחתך · ייתכן שקיים יום בהיר חדש יותר",
+  "{label} catalog unavailable · {detail}": "קטלוג {label} אינו זמין · {detail}",
+  "Daily overview for today may still be empty until the pass": "הסקירה היומית של היום עשויה להישאר ריקה עד המעבר",
+  "Search cancelled": "החיפוש בוטל",
+  "Box and images cleared": "התיבה והתמונות נוקו",
+  "MORE DETAIL · 30 m": "יותר פירוט · 30 מ׳",
+  "Sentinel-2 and Landsat via HLS, 30 m, every 2–6 days": "Sentinel-2 ו-Landsat דרך HLS, 30 מ׳, כל 2–6 ימים",
+  "DAILY OVERVIEW · 250 m": "סקירה יומית · 250 מ׳",
+  "VIIRS daily mosaic, 250 m, follows broad changes; little detail under 25 km": "פסיפס יומי של VIIRS, 250 מ׳, עוקב אחר שינויים רחבים; פירוט מעט מתחת ל-25 ק\"מ",
+  "Sentinel-2": "Sentinel-2",
+  "Sentinel-2 via HLS": "Sentinel-2 דרך HLS",
+  "Landsat 8/9": "Landsat 8/9",
+  "Landsat 8/9 via HLS": "Landsat 8/9 דרך HLS",
+  "Daily overview": "סקירה יומית",
+  "Box edges must be finite": "קצוות התיבה חייבים להיות סופיים",
+  "Longitudes must be within ±180°": "קווי האורך חייבים להיות בתוך ±180°",
+  "Select one side of the dateline": "בחר צד אחד של קו התאריך",
+  "Box must enclose an area": "התיבה חייבת לכלול שטח",
+  "Add the full Starlink broadband shell (thousands of extra points)": "הוספת מעטפת הפס-הרחב המלאה של Starlink (אלפי נקודות נוספות)",
+  "Loading the Starlink shell…": "טוען את מעטפת Starlink…",
+  "Starlink {detail} — click to retry": "Starlink {detail} — לחץ לניסיון חוזר",
+  "load failed": "הטעינה נכשלה",
+  "Showing the full Starlink shell — click for the core catalog only": "מציג את מעטפת Starlink המלאה — לחץ לקטלוג הליבה בלבד",
+  "DENSE ···": "דחוס ···",
+  "DENSE ✕": "דחוס ✕",
+  "DENSE": "דחוס",
+  "CelesTrak unreachable": "CelesTrak אינו נגיש",
+  "DOCKED · {name} · +{extra}": "עגן · {name} · +{extra}",
+  "DOCKED · {name}": "עגן · {name}",
+  "{name} needs the Google 3D map: choose it under MAP SOURCE": "{name} דורש את מפת Google 3D: בחר בה תחת מקור המפה",
+  "zoom in to a street to open {name}": "התקרב לרחוב כדי לפתוח {name}",
+  "loading coverage...": "טוען כיסוי...",
+  "No street-level imagery within {radius} m of that point": "אין צילומי רחוב בטווח {radius} מ׳ מאותה נקודה",
+  "No street-level imagery within {radius} m of the view centre": "אין צילומי רחוב בטווח {radius} מ׳ ממרכז התצוגה",
+  "Zoom in to see street-level coverage": "התקרב כדי לראות כיסוי רחוב",
+  "Point the camera at the ground for street-level coverage": "כוון את המצלמה אל הקרקע כדי לראות כיסוי רחוב",
+  "Coverage tile failed": "אריח הכיסוי נכשל",
+  "The photo could not be loaded": "את התמונה לא ניתן לטעון",
+  "{name} photo. ← and → step along the sequence. On a 360° photo, drag or use Shift+← →, ↑ ↓ to look around, and + − to zoom": "תמונה של {name}. ← ו-→ דורכים ברצף. בתמונת 360°, גרור או השתמש ב-Shift+← →, ↑ ↓ להבט מסביב, ו-+ − לזום",
+  "{name} street-level photo": "תמונת רחוב של {name}",
+  "Previous photo in this sequence (←)": "התמונה הקודמת ברצף הזה (←)",
+  "Next photo in this sequence (→)": "התמונה הבאה ברצף הזה (→)",
+  "Aim the middle of the view at a street to look for imagery there": "כוון את מרכז התצוגה אל רחוב כדי לחפש בו צילומים",
+  "KEY REJECTED": "המפתח נדחה",
+  "GOOGLE_MAPS_API_KEY is not set": "GOOGLE_MAPS_API_KEY אינו מוגדר",
+  "The Google Maps JavaScript API could not load": "Google Maps JavaScript API לא נטען",
+  "Google Street View": "Google Street View",
+  "GOOGLE STREET VIEW": "GOOGLE STREET VIEW",
+  "Google refused GOOGLE_MAPS_API_KEY for Street View — check that the Maps JavaScript API is enabled for it and this site is an allowed referrer": "Google דחה את GOOGLE_MAPS_API_KEY עבור Street View — ודא ש-Maps JavaScript API מופעל עבורו ושהאתר הזה הוא מפנה מורשה",
+  "Street View did not answer — check the network, and that the Maps JavaScript API is enabled for GOOGLE_MAPS_API_KEY": "Street View לא ענה — בדוק את הרשת, וש-Maps JavaScript API מופעל עבור GOOGLE_MAPS_API_KEY",
+  "click a street to open Street View": "לחץ על רחוב לפתיחת Street View",
+  "Street View has no imagery for this place": "אין צילום Street View למקום הזה",
+  "KartaView has no position for this photo": "לתמונת KartaView הזאת אין מיקום",
+  "The KartaView photo could not be loaded": "את תמונת KartaView לא ניתן לטעון",
+  "zoom in to see KartaView coverage": "התקרב לצפייה בכיסוי KartaView",
+  "no KartaView photos in view": "אין תמונות KartaView בתצוגה",
+  "KartaView is rate-limiting requests — they resume on their own": "KartaView מגביל את קצב הבקשות — הן חוזרות מעצמן",
+  "KartaView’s photos here are archived and cannot be shown": "תמונות KartaView כאן בארכיון ולא ניתן להציגן",
+  "KartaView did not filter this area in time — move the map to ask again": "KartaView לא סינן את האזור בזמן — הזז את המפה כדי לשאול שוב",
+  "None of KartaView’s photos here pass the imagery filter": "אף תמונת KartaView כאן לא עוברת את מסנן הצילומים",
+  "KartaView did not answer in time — try again": "KartaView לא ענה בזמן — נסה שוב",
+  "KartaView could not be reached — check the network": "KartaView לא נגיש — בדוק את הרשת",
+  "KartaView sent an answer that could not be read": "KartaView שלח תשובה שלא ניתן לקרוא",
+  "KartaView is rate-limiting requests": "KartaView מגביל את קצב הבקשות",
+  "KartaView sent too much data": "KartaView שלח יותר מדי נתונים",
+  "KartaView is rate-limiting requests — try again in a moment": "KartaView מגביל את קצב הבקשות — נסה שוב בעוד רגע",
+  "KartaView has no such photo": "אין ל-KartaView את התמונה הזאת",
+  "Mapillary rejected MAPILLARY_CLIENT_TOKEN — replace it in Provider Settings": "Mapillary דחה את MAPILLARY_CLIENT_TOKEN — החלף אותו בהגדרות הספקים",
+  "Coverage requests are being rate-limited — they resume on their own": "בקשות הכיסוי מוגבלות בקצב — הן חוזרות מעצמן",
+  "The Panoramax photo could not be loaded": "את תמונת Panoramax לא ניתן לטעון",
+  "Panoramax is busy — coverage resumes on its own": "Panoramax עסוק — הכיסוי חוזר מעצמו",
+  "no Panoramax photos in view": "אין תמונות Panoramax בתצוגה",
+  "no Panoramax photos here match the filters": "אין תמונות Panoramax כאן שתואמות את המסננים",
+  "Panoramax sent a map tile that could not be read": "Panoramax שלח אריח מפה שלא ניתן לקרוא",
+  "This Panoramax photo is no longer available": "תמונת ה-Panoramax הזאת כבר אינה זמינה",
+  "zoom in to see Panoramax coverage": "התקרב לצפייה בכיסוי Panoramax",
+  "Panoramax did not answer in time — try again": "Panoramax לא ענה בזמן — נסה שוב",
+  "Panoramax could not be reached — check the connection": "Panoramax אינו נגיש — בדוק את החיבור",
+  "Panoramax sent too much data": "Panoramax שלח יותר מדי נתונים",
+  "Panoramax is busy": "Panoramax עסוק",
+  "Panoramax sent an unreadable answer": "Panoramax שלח תשובה שלא ניתן לקרוא",
+  "Sequence images unavailable": "תמונות הרצף אינן זמינות",
+  "No street-level imagery providers configured": "לא הוגדרו ספקי צילומי רחוב",
+  "(by upload date)": "(לפי תאריך העלאה)",
+  "Open the Street Level panel to view imagery": "פתח את פאנל Street Level לצפייה בצילומים",
+  "Image could not be opened": "את התמונה לא ניתן לפתוח",
+  "TeleGeography load failed": "טעינת TeleGeography נכשלה",
+  "UNAVAILABLE · {source} · Roads unavailable": "לא זמין · {source} · כבישים אינם זמינים",
+  "Roads: {source}": "כבישים: {source}",
+  "TomTom roads unavailable while the traffic service is unreachable": "כבישי TomTom אינם זמינים בזמן ששירות התנועה אינו נגיש",
+  "Hybrid unavailable while the traffic service is unreachable": "היברידי אינו זמין בזמן ששירות התנועה אינו נגיש",
+  "TomTom roads need a TomTom key": "כבישי TomTom דורשים מפתח TomTom",
+  "Hybrid needs a TomTom key": "היברידי דורש מפתח TomTom",
+  "Local surface still loading": "המשטח המקומי עדיין בטעינה",
+  "Partial coverage": "כיסוי חלקי",
+  "Detailed roads unavailable": "כבישים מפורטים אינם זמינים",
+  "Reduced detail coverage": "כיסוי בפירוט מופחת",
+  "TomTom roads only, each with its live flow": "כבישי TomTom בלבד, לכל אחד זרימה חיה משלו",
+  "TomTom roads only, each with its live flow (needs a TomTom key)": "כבישי TomTom בלבד, לכל אחד זרימה חיה משלו (דורש מפתח TomTom)",
+  "OpenStreetMap roads, with TomTom flow matched when available": "כבישי OpenStreetMap, עם התאמת זרימת TomTom כשזמינה",
+  "TomTom roads first; OpenStreetMap fills the rest, simulated": "כבישי TomTom קודם; OpenStreetMap משלים את היתר, מדומים",
+  "TomTom roads first; OpenStreetMap fills the rest, simulated (needs a TomTom key)": "כבישי TomTom קודם; OpenStreetMap משלים את היתר, מדומים (דורש מפתח TomTom)",
+  "Hybrid": "היברידי",
+  "TomTom key unavailable": "מפתח TomTom אינו זמין",
+  "TomTom daily budget reached": "תקציב TomTom היומי אזל",
+  "TomTom upstream unreachable": "שירות TomTom אינו נגיש",
+  "TomTom flow unavailable": "זרימת TomTom אינה זמינה",
+  "SIMULATED — {reason}": "מדומה — {reason}",
+  "STALE · Roads: {source} · Flow: cached TomTom tiles": "מיושן · כבישים: {source} · זרימה: אריחי TomTom מהמטמון",
+  "Syncing flow · Roads: {source}": "מסנכרן זרימה · כבישים: {source}",
+  "LIVE · Roads: {source} · Roads without flow hidden": "חי · כבישים: {source} · כבישים ללא זרימה מוסתרים",
+  "LIVE · Roads: {source} · No flow roads in view": "חי · כבישים: {source} · אין כבישי זרימה בתצוגה",
+  "LIVE · Roads: {source} · Flow {percent}%": "חי · כבישים: {source} · זרימה {percent}%",
+  "SIMULATED · Roads: {source} · Flow {percent}%": "מדומה · כבישים: {source} · זרימה {percent}%",
+  "Syncing flow · Roads: OpenStreetMap · Flow: TomTom · Unmatched: simulated": "מסנכרן זרימה · כבישים: OpenStreetMap · זרימה: TomTom · בלתי מתואמים: מדומים",
+  "LIVE · Roads: OpenStreetMap · Flow: TomTom · {percent}% cov · Unmatched: simulated": "חי · כבישים: OpenStreetMap · זרימה: TomTom · {percent}% כיסוי · בלתי מתואמים: מדומים",
+  "LIVE · Roads: OpenStreetMap · Flow: TomTom · {percent}% cov": "חי · כבישים: OpenStreetMap · זרימה: TomTom · {percent}% כיסוי",
+  "SIMULATED · Roads: OpenStreetMap · Flow: TomTom (no matches)": "מדומה · כבישים: OpenStreetMap · זרימה: TomTom (אין התאמות)",
+  "SIMULATED — traffic service unreachable": "מדומה — שירות התנועה אינו נגיש",
+  "SIMULATED — add TomTom key for live": "מדומה — הוסף מפתח TomTom לחי",
+  "OpenFreeMap tiles rate-limited": "אריחי OpenFreeMap מוגבלים בקצב",
+  "OpenFreeMap tiles timed out": "אריחי OpenFreeMap חרגו מהזמן הקצוב",
+  "OpenFreeMap tiles unavailable": "אריחי OpenFreeMap אינם זמינים",
+  "occupancy|empty": "פנויה",
+  "occupancy|many seats available": "מקומות פנויים רבים",
+  "occupancy|few seats available": "מעט מקומות פנויים",
+  "occupancy|standing room only": "עמידה בלבד",
+  "occupancy|crushed standing room only": "עמידה צפופה בלבד",
+  "occupancy|full": "מלאה",
+  "occupancy|not accepting passengers": "אינה מקבלת נוסעים",
+  "occupancy|not boardable": "אין אפשרות עלייה",
+  "Route {route}": "קו {route}",
+  "Vehicle {vehicle}": "רכב {vehicle}",
+  "vehicle motion|Stopped": "עצור",
+  "No recent fix": "אין קביעת מיקום אחרונה",
+  "Waiting for update": "ממתין לעדכון",
+  "Moving": "נע",
+  "reported {speed} km/h": "דווח {speed} קמ\"ש",
+  "reported hdg {heading}°": "דווח כיוון {heading}°",
+  "Last report: stopped at stop {stop}": "דיווח אחרון: עצר בתחנה {stop}",
+  "Last report: arriving at stop {stop}": "דיווח אחרון: מגיע לתחנה {stop}",
+  "Last report: next stop {stop}": "דיווח אחרון: התחנה הבאה {stop}",
+  "Shown at street level · depth not in the feed": "מוצג בגובה הרחוב · המפלס אינו כלול בפיד",
+  "Reported {seconds} s ago": "דווח לפני {seconds} שניות",
+  "Reported {minutes} min ago": "דווח לפני {minutes} דק",
+  "shown {seconds} s behind": "מוצג {seconds} שניות מאחור",
+  "{reported} (feed time)": "{reported} (זמן הפיד)",
+  "Available trail: {minutes} min (limited)": "שובל זמין: {minutes} דק (מוגבל)",
+  "Available trail: {minutes} min": "שובל זמין: {minutes} דק",
+  "Bus": "אוטובוס",
+  "Tram": "חשמלית",
+  "Subway": "רכבת תחתית",
+  "Train": "רכבת",
+  "Ferry": "מעבורת",
+  "Transit vehicle": "רכב תחבורה ציבורית",
+  "AIS: {name}": "AIS: {name}",
+  "{type}  SPD: {speed}  HDG: {heading}": "{type}  SPD: {speed}  HDG: {heading}",
+  "VESSEL": "אונייה",
+  "{speed}KT": "{speed} קשר",
+  "{heading}DEG": "{heading}°",
+  "POS: LIVE": "POS: חי",
+  "POS: {time}Z": "POS: {time}Z",
+  "AIS live load failed": "טעינת AIS חיה נכשלה",
+  "awaiting first AIS position…": "ממתין למיקום AIS ראשון…",
+  "awaiting usable AIS positions…": "ממתין למיקומי AIS שימושיים…",
+  "awaiting first AIS message…": "ממתין להודעת AIS ראשונה…",
+  "AISSTREAM_API_KEY not set": "AISSTREAM_API_KEY אינו מוגדר",
+  "live feed unsupported": "פיד חי אינו נתמך",
+  "connecting to feed…": "מתחבר לפיד…",
+  "feed disconnected": "הפיד נותק",
+  "feed down": "הפיד מושבת",
+  "feed idle": "פיד בחוסר פעילות",
+  "API key rejected — check AISSTREAM_API_KEY": "מפתח ה-API נדחה — בדוק את AISSTREAM_API_KEY",
+  "feed silent {seconds}s — no AIS data": "פיד שקט {seconds} שניות — אין נתוני AIS",
+  "feed silent — no AIS data": "פיד שקט — אין נתוני AIS",
+  "feed down — retrying slowly (attempt {attempt})": "הפיד מושבת — מנסה שוב לאט (ניסיון {attempt})",
+  "reconnecting to feed… (attempt {attempt})": "מתחבר מחדש לפיד… (ניסיון {attempt})",
+  "feed down — retrying slowly": "הפיד מושבת — מנסה שוב לאט",
+  "reconnecting to feed…": "מתחבר מחדש לפיד…",
+  "Focus vessel {name}, MMSI {mmsi}": "התמקדות באונייה {name}, MMSI {mmsi}",
+  "Hidden by this map source · choose a globe map": "מוסתר על ידי מקור המפה הזה · בחר מפת גלובוס",
+  "Weather image HTTP {status}": "תמונת מזג אוויר HTTP {status}",
+  "Weather HTTP {status}": "מזג אוויר HTTP {status}",
+  "Frame unavailable; previous observation retained": "השקופית אינה זמינה; התצפית הקודמת נשמרה",
+  "Weather imagery unavailable": "תצוגת מזג האוויר אינה זמינה",
+  "Weather source unavailable; previous observation retained": "מקור מזג האוויר אינו זמין; התצפית הקודמת נשמרה",
+  "Weather unavailable": "מזג האוויר אינו זמין",
+  "No frame within {gap} min of {time}": "אין שקופית בטווח {gap} דק מ-{time}",
+  "No frame within {gap} h of {time}": "אין שקופית בטווח {gap} שע מ-{time}",
+  "{hours}h {minutes}m ago": "לפני {hours} שע {minutes} דק",
+  "{minutes}m ago": "לפני {minutes} דק",
+  "{state} · {time} · {lag}": "{state} · {time} · {lag}",
+  "Observed": "נצפה",
+  "History": "היסטוריה",
+  "Observation unavailable": "תצפית אינה זמינה",
+  "Waiting for observation": "ממתין לתצפית",
+  "{detail} · synced": "{detail} · מסונכרן",
+  "{detail} · nearest": "{detail} · הקרוב",
+  "RADAR · {units}": "רדאר · {units}",
+  "RADAR REFLECTIVITY · dBZ": "רפלקטיביות רדאר · dBZ",
+  "LIGHTNING DENSITY · 15 min accumulation": "צפיפות מכות · צבירה של 15 דק",
+  "GLOBAL INFRARED · hourly": "אינפרא-אדום גלובלי · לכל שעה",
+  "GOES INFRARED · ~5 min": "אינפרא-אדום GOES · ~5 דק",
+  "{state}: {time}": "{state}: {time}",
+  "Latest observation": "התצפית האחרונה",
+  "frame {index}/{total}": "שקופית {index}/{total}",
+  "loading": "טוען",
+  "Observation: unavailable": "תצפית: לא זמינה",
+  "Contiguous US · gaps ≠ no rain": "ארה\"ב הרציפה · פערים ≠ אין גשם",
+  "Americas + Pacific · not individual strikes": "האמריקות + הפסיפיק · לא מכות בודדות",
+  "60°S–60°N · typically 2–3 h delayed": "60°S–60°N · בדרך כלל בפער 2–3 שע",
+  "North America · infrared imagery": "אמריקה הצפונית · צילומי אינפרא-אדום",
+  "Color: strikes/km²/min ×10³": "צבע: מכות/קמ\"ר/דק ×10³",
+  "Color: {units}": "צבע: {units}",
+  "Reduced motion · history playback unavailable": "תנועה מופחתת · הצגת ההיסטוריה אינה זמינה",
+  "Reduced motion · manual history available": "תנועה מופחתת · היסטוריה ידנית זמינה",
+  "Rain radar · US": "רדאר גשם · ארה\"ב",
+  "Lightning density · 15 min": "צפיפות מכות · 15 דק",
+  "Satellite clouds": "עננים מלוויין",
+  "Americas + Pacific": "האמריקות + הפסיפיק",
+  "Global · 60°S–60°N": "גלובלית · 60°S–60°N",
+  "North America": "אמריקה הצפונית",
+  "Source observations delayed": "תצפיות המקור מאחרות",
+  "Stale source": "מקור מיושן",
+  "Loading next frame…": "טוען את השקופית הבאה…",
+  "Map center outside coverage": "מרכז המפה מחוץ לכיסוי",
+  "strikes/km²/min ×10³": "מכות/קמ\"ר/דק ×10³",
+  "N. America": "צפ. אמריקה",
+  "Global": "גלובלי",
+  "Hourly global mosaic; usually 2–3 hours delayed": "פסיפס גלובלי של שעה; בדרך כלל בפער 2–3 שעות",
+  "GOES regional clouds; approximately 5-minute updates": "עננים אזוריים של GOES; עדכונים בערך כל 5 דק",
+  "Clouds only": "עננים בלבד",
+  "Apply the full cloud brightness key; 100% filter strength": "החל את מפתח בהירות העננים המלא; עוצמת סינון 100%",
+  "Full": "מלא",
+  "Show the complete infrared image; 0% filter strength": "הצג את תמונת האינפרא-אדום המלאה; עוצמת סינון 0%",
+  "Soft": "רך",
+  "Vivid": "חי",
+  "Image opacity; does not alter the observed values": "אטימות התמונה; אינה משנה את הערכים הנצפים",
+  "View coverage": "הצג כיסוי",
+  "View US radar": "הצג רדאר ארה\"ב",
+  "View Americas & Pacific": "הצג האמריקות והפסיפיק",
+  "{value} strikes/km²/min ×10³ (15-minute density)": "{value} מכות/קמ\"ר/דק ×10³ (צפיפות 15 דק)",
+  "{value} dBZ radar reflectivity": "{value} dBZ רפלקטיביות רדאר",
+  "STALE · cached source metadata": "מיושן · מידע המקור מהמטמון",
+  "Map center is outside source coverage": "מרכז המפה מחוץ לכיסוי המקור",
+  "NOAA/NWS 15-minute lightning density derived from Vaisala NLDN/GLD360. Coverage 110°E across the Pacific/Americas to 0°, 25°S–80°N. Not a live strike count, global coverage or a safety warning.": "צפיפות מכות של 15 דק מ-NOAA/NWS, נגזרת מ-Vaisala NLDN/GLD360. כיסוי מ-110°צ דרך הפסיפיק/אמריקות עד 0°, בין 25°S–80°N. אינו מנייה חיה של מכות, כיסוי גלובלי, ולא אזהרת בטיחות.",
+  "NOAA MRMS radar echoes indicate precipitation patterns, not rain rate, a storm warning or a future forecast. Native source approximately 1 km; display is limited to level 6. Frames use exact advertised observation times.": "הדי הרדאר של NOAA MRMS מציינים דפוסי משקעים, לא קצב גשם, אזהרת סערה או חזוי עתידי. המקור הילידי בערך 1 ק\"מ; התצוגה מוגבלת לרמה 6. השקופיות משתמשות בזמני התצפית שהוכרזו, במדויק.",
+  "GOES-19/18 longwave infrared Band 14 regional; NESDIS global longwave mosaic. Clouds only dims everything but bright, cold cloud tops; a brightness filter, not a cloud mask. Coverage and freshness differ by region.": "אינפרא-אדום גלים ארוכים מוכ״ס 14 של GOES-19/18, אזורי; פסיפס גלים ארוכים גלובלי של NESDIS. „עננים בלבד“ מעמעם הכול מלבד ראשי עננים קרים ובהירים; זהו מסנן בהירות, לא מסך עננים. הכיסוי והרעננות משתנים לפי אזור.",
+  "REGION": "אזור",
+  "FILTER": "מסנן",
+  "Cloud filter strength": "עוצמת סינון עננים",
+  "OPACITY": "אטימות",
+  "Infrared decode failed": "פענוח אינפרא-אדום נכשל",
+  "Weather prefetch unavailable": "טעינה מראש של מזג האוויר אינה זמינה",
+  "Weather tiles unavailable · previous frame retained": "אריחי מזג האוויר אינם זמינים · השקופית הקודמת נשמרה",
+  "Some weather tiles unavailable": "חלק מאריחי מזג האוויר אינם זמינים",
+  "Malformed weather manifest": "רישום מזג האוויר פגום",
+  "Weather request timed out": "בקשת מזג האוויר חרגה מהזמן הקצוב",
+  "SIGHTING": "תצפית",
+  "Show {name} sighting": "הצג תצפית {name}",
+  "Birds": "עופות",
+  "Mammals": "יונקים",
+  "Reptiles": "זוחלים",
+  "Amphibians": "דו-חיים",
+  "Ray-finned fishes": "דגי סנפיר",
+  "Insects": "חרקים",
+  "Arachnids": "עכבישנים",
+  "Plants": "צמחים",
+  "Fungi": "פטריות",
+  "Other animals": "חיות אחרות",
+  "Other or unknown": "אחר או לא ידוע",
+  "{label} {detail} — click to retry": "{label} {detail} — לחץ לניסיון חוזר",
+  "Wildlife sightings source unavailable": "מקור תצפיות חיות הבר אינו זמין",
+  "Show only community-confirmed (research-grade) sightings": "הצג תצפיות מאושרות קהילה בלבד (בדרגת מחקר)",
+  "Wildlife observed within 48 h (whales 7 d). Color and badge glyph show the taxon group. Sensitive species are shown only as 0.2° cells; Salish Sea marine mammal reports via Acartia are rounded to 0.01°. Not a census.": "חיות בר נצפו ב-48 השעות האחרונות (לווייתנים · 7 ימים). הצבע וגליף התג מציגים את קבוצת הטקסון. מינים רגישים מוצגים כתאי 0.2° בלבד; דיווחי יונקי הים של Salish Sea דרך Acartia מעוגלים ל-0.01°. אינו מפקד אוכלוסין.",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "תורמי iNaturalist · Acartia {count} (Salish Sea) · רישיונות לכל רשומה",
+  "iNaturalist contributors · licences per record": "תורמי iNaturalist · רישיונות לכל רשומה",
+  "{count} sightings in view": "{count} תצפיות בתצוגה",
+  "Zoom in for local sightings": "התקרב לתצפיות מקומיות",
+  "No recent sightings in view": "אין תצפיות אחרונות בתצוגה",
+  "Acartia feed unavailable": "פיד Acartia אינו זמין",
+  "ALL": "הכול",
+  "Show all taxa": "הצג את כל הקבוצות",
+  "BIRDS": "עופות",
+  "Show only birds": "הצג עופות בלבד",
+  "MAMMALS": "יונקים",
+  "Show only mammals": "הצג יונקים בלבד",
+  "WHALES": "לווייתנים",
+  "Show only whales and dolphins (7 days)": "הצג לווייתנים ודולפינים בלבד (7 ימים)",
+  "INSECTS": "חרקים",
+  "Show only insects": "הצג חרקים בלבד",
+  "PLANTS": "צמחים",
+  "Show only plants": "הצג צמחים בלבד",
+  "All rights reserved": "כל הזכויות שמורות",
+  "Cetacean": "לווייתנאי",
+  "Wildlife Sightings": "תצפיות חיות בר",
+  "Temperature field unavailable": "שדה הטמפרטורה אינו זמין",
+  "Mean sea level pressure field unavailable": "שדה לחץ בגובה פני הים אינו זמין",
+  "Wind upstream unavailable": "מקור הרוח במעלה הזרם אינו זמין",
+  "{source} HTTP {status}": "{source} HTTP {status}",
+  "Wind": "רוח",
+  "Wind source unavailable": "מקור הרוח אינו זמין",
+  "Forecast · does not follow history": "חזוי · אינו מתאים להיסטוריה",
+  "Wind motion": "תנועת רוח",
+  "Wind speed": "מהירות רוח",
+  "Sea-level pressure": "לחץ בגובה פני הים",
+  "Air temperature · 2 m": "טמפרטורת אוויר · 2 מ׳",
+  "Global · 1° grid": "גלובלי · סריג 1°",
+  "{model} forecast · {time}": "חזוי {model} · {time}",
+  "Loading forecast": "טוען חזוי",
+  "Preparing flow": "מכין זרימה",
+  "Selected field unavailable": "השדה הנבחר אינו זמין",
+  "Cached forecast · stale": "חזוי מהמטמון · מיושן",
+  "ECMWF IFS surface forecast": "חזוי פני קרקע ECMWF IFS",
+  "NOAA GFS surface forecast": "חזוי פני קרקע NOAA GFS",
+  "Reduced motion": "תנועה מופחתת",
+  "Resume": "המשך",
+  "Pause": "השהה",
+  "Pause visual flow; forecast time does not advance with animation": "השהה את הזרימה החזותית; זמן החזוי אינו מתקדם עם ההנפשה",
+  "None": "ללא",
+  "Speed": "מהירות",
+  "Pressure": "לחץ",
+  "Temperature": "טמפרטורה",
+  "Wind trails with no field shading": "שובלי רוח ללא הצללת שדה",
+  "How hard the surface wind is blowing": "עד כמה חזקה נושבת הרוח בגובה הקרקע",
+  "Sea-level air pressure: broad highs and lows": "לחץ אוויר בגובה פני הים: אזורי לחץ גבוהים ונמוכים רחבים",
+  "Air temperature two meters above the surface": "טמפרטורת אוויר שני מטרים מעל הקרקע",
+  "Wind speed units": "יחידות מהירות רוח",
+  "Read wind at map center": "קרא רוח במרכז המפה",
+  "Read the forecast at the center of the map without changing selection": "קרא את החזוי במרכז המפה מבלי לשנות את הבחירה",
+  "{model} forecast · {field} ({unit})": "חזוי {model} · {field} ({unit})",
+  "Valid: {time}": "תקף: {time}",
+  "preparing": "בהכנה",
+  "Issued: {time}": "פורסם: {time}",
+  "Selected field unavailable · wind remains visible": "השדה הנבחר אינו זמין · הרוח נשארת גלויה",
+  "{error} · wind remains visible": "{error} · הרוח נשארת גלויה",
+  "Surface wind at 10 m. Approximately 1° global grid. Curves follow the 10 m wind field, lifted 12 km for visibility; display height is not weather altitude. View lighting is for readability. Animation shows flow through one fixed forecast; it does not advance time. Color fields drape the globe basemap or the active photorealistic 3D Tiles.": "רוח פני קרקע בגובה 10 מ׳. סריג גלובלי בערך 1°. העקומות עוקבות שדה הרוח ב-10 מ׳, מוגבהות 12 ק\"מ לראות; גובה התצוגה אינו גובה מטאורולוגי. תאורת הצפייה לצורך קריאות. ההנפשה מציגה זרימה בחזוי קבוע אחד; היא מתקה מעט זמן. שדות הצבע מכסים את מפת בסיס הגלובלי, או את Google 3D Tiles הפעיל.",
+  "MODEL": "מודל",
+  "FIELD": "שדה",
+  "UNITS": "יחידות",
+  "MOTION": "תנועה",
+  "Forecast": "חזוי",
+  "N": "N",
+  "NNE": "NNE",
+  "NE": "NE",
+  "ENE": "ENE",
+  "E": "E",
+  "ESE": "ESE",
+  "SE": "SE",
+  "SSE": "SSE",
+  "S": "S",
+  "SSW": "SSW",
+  "SW": "SW",
+  "WSW": "WSW",
+  "W": "W",
+  "WNW": "WNW",
+  "NW": "NW",
+  "NNW": "NNW",
+  "No surface reading": "אין קריאת שטח",
+  "Aim the map center at Earth": "כוון את מרכז המפה אל העולם",
+  "A location reading needs a loaded forecast and the Earth at the center of the view.": "קריאת מיקום דורשת חזוי נטען וכדור הארץ במרכז התצוגה.",
+  "Interpolated model forecast on an approximately 1° grid. Broad weather patterns, not a street-level measurement.": "חזוי מודל באינטרפולציה על סריג של כ-1°. דפוסי מזג אוויר רחבים, לא מדידה ברמת הרחוב.",
+  " · calm": " · שקטה",
+  " from {direction}": " מ-{direction}",
+  "WIND AT {coordinates}": "רוח ב-{coordinates}",
+  "{model} · valid {time}": "{model} · תקף {time}",
+  "Wind speed field unavailable": "שדה מהירות הרוח אינו זמין",
+  "Globe imagery unavailable": "צילומי הגלובוס אינם זמינים",
+  "Globe field image unavailable": "תמונת שדה הגלובוס אינה זמינה",
+  "Unknown wind model": "מודל רוח לא ידוע",
+  "Unknown weather overlay": "שכבת מזג אוויר לא ידועה",
+  "Wind request timed out": "בקשת הרוח חרגה מהזמן הקצוב",
+  "Malformed wind manifest": "רישום הרוח פגום",
+  "Malformed wind grid": "סריג הרוח פגום",
+  "Error: {message}": "שגיאה: {message}",
+  "Needs {envVars} — add it in Provider Settings": "דורש {envVars} — הוסף בהגדרות הספקים",
+  "{label} is unavailable": "{label} אינו זמין",
+  "This map stack": "ערמת מפה זו",
+  "Google 3D tiles unavailable — check the key's API restrictions, quota, or network": "ה-Google 3D tiles אינם זמינים — בדוק את מגבלות ה-API של המפתח, את מכסה או את הרשת",
+  "Needs {envVars} — add it in Provider Settings — or a Cesium ion token for the ion-hosted route": "דורש {envVars} — הוסף בהגדרות הספקים — או אסימון Cesium ion לנתיב המתארח ב-ion",
+  "Exit cockpit to fly to a camera": "צא מתא הטייס כדי לעוף אל מצלמה",
+  "Exit cockpit to fly to a location": "צא מתא הטייס כדי לעוף אל מקום",
+  "Exit cockpit to fly to a photo": "צא מתא הטייס כדי לעוף אל תמונה",
+  "Exit cockpit to fly to a shared view": "צא מתא הטייס כדי לעוף אל תצוגה משותפת",
+  "Exit cockpit to fly to a target": "צא מתא הטייס כדי לעוף אל מטרה",
+  "Exit cockpit to fly to a vessel": "צא מתא הטייס כדי לעוף אל אונייה",
+  "Exit cockpit to fly to a fire": "צא מתא הטייס כדי לעוף אל שריפה",
+  "Exit cockpit to fly to a sighting": "צא מתא הטייס כדי לעוף אל תצפית",
+  "Exit cockpit to fly to a sighting area": "צא מתא הטייס כדי לעוף אל אזור תצפית",
+  "Exit cockpit to fly to a route": "צא מתא הטייס כדי לעוף אל מסלול",
+  "Exit cockpit to fly to a file": "צא מתא הטייס כדי לעוף אל קובץ",
+  "Exit cockpit to fly to a drawing": "צא מתא הטייס כדי לעוף אל שרטוט",
+  "Exit cockpit to fly to a scene": "צא מתא הטייס כדי לעוף אל סצנה",
+  "Exit cockpit to view weather coverage": "צא מתא הטייס כדי לצפות בכיסוי מזג האוויר",
+  "Exit cockpit to fly to a cyclone": "צא מתא הטייס כדי לעוף אל ציקלון",
+  "Exit cockpit to fly to an aircraft": "צא מתא הטייס כדי לעוף אל מטוס",
+  "Exit cockpit to fly to a satellite": "צא מתא הטייס כדי לעוף אל לוויין",
+  "Exit cockpit to frame contacts": "צא מתא הטייס כדי לסגור מגעים בתצוגה",
+  "Focusing {label}": "מתמקד ב-{label}",
+  "Camera ownership changed": "בעלות המצלמה השתנתה",
+  "Saved project could not be read; storage preserved. Import a valid file to resume saving.": "לא ניתן לקרוא את הפרויקט השמור; האחסון נשמר. ייבא קובץ תקין כדי לחדש שמירה.",
+  "Ready": "מוכן",
+  "Scene layer turned off": "שכבת הסצנה כבויה",
+  "Stopped": "עצר",
+  "Scene not saved — existing saved project could not be read. Export edits or import a valid file.": "הסצנה לא נשמרה — לא ניתן לקרוא את הפרויקט השמור הקיים. ייצא עריכות או ייבא קובץ תקין.",
+  "Scene not saved — {reason}": "הסצנה לא נשמרה — {reason}",
+  "Scene not saved — browser storage unavailable": "הסצנה לא נשמרה — אחסון הדפדפן אינו זמין",
+  "Loaded: {scene} / {shot}": "נטען: {scene} / {shot}",
+  "Cannot update {scene}: shot inventory changed": "לא ניתן לעדכן את {scene}: מלאי השוטים השתנה",
+  "Cannot update {scene}: evidence beats changed": "לא ניתן לעדכן את {scene}: קטעי הראיות השתנו",
+  "Cannot update {scene}: shot bindings are incomplete": "לא ניתן לעדכן את {scene}: קשירות השוטים אינן שלמות",
+  "Updated {count} shots: {scene}": {
+    "one": "עודכנו {count} שוטים: {scene}",
+    "two": "עודכנו {count} שוטים: {scene}",
+    "other": "עודכנו {count} שוטים: {scene}"
+  },
+  "Appended {count} shots: {scene}": {
+    "one": "צורפו {count} שוטים: {scene}",
+    "two": "צורפו {count} שוטים: {scene}",
+    "other": "צורפו {count} שוטים: {scene}"
+  },
+  "Cannot capture shot: camera not ready": "לא ניתן ללכוד שוט: המצלמה אינה מוכנה",
+  "Captured: {scene} / {shot}": "נלכד: {scene} / {shot}",
+  "Select a shot first": "בחר קודם שוט",
+  "Updated: {scene} / {shot}": "עודכן: {scene} / {shot}",
+  "Could not leave scene: {scene}": "לא ניתן לצאת מהסצנה: {scene}",
+  "Seeked: {scene} / {shot}": "הוסט: {scene} / {shot}",
+  "Seeking scene clock": "מסיט את שעון הסצנה",
+  "Camera unavailable — exit cockpit first": "המצלמה אינה זמינה — צא קודם מתא הטייס",
+  "No shots to run": "אין שוטים להרצה",
+  "Scene transition limit reached — load a shot to reset": "מגבלת מעברי הסצנות הושגה — טען שוט כדי לאפס",
+  "Export failed: {error}": "הייצוא נכשל: {error}",
+  "Project exported": "הפרויקט יוצא",
+  "Importing project": "מייבא פרויקט",
+  "Imported {file}": "יובא {file}",
+  "Import failed: {error}": "הייבוא נכשל: {error}",
+  "Import failed (could not read JSON file)": "הייבוא נכשל (לא ניתן לקרוא קובץ JSON)",
+  "Layers refused: {layers}": "שכבות שסירבו: {layers}",
+  "Could not exit {mode} — scene layers may be refused": "לא ניתן לצאת מ-{mode} — שכבות הסצנה עשויות להיסרב",
+  "Camera move interrupted": "תנועת המצלמה הופסקה",
+  "Scene media timed out": "מדיית הסצנה חרגה מהזמן הקצוב",
+  "Action complete": "הפעולה הושלמה",
+  "Action unavailable or cancelled": "הפעולה אינה זמינה או בוטלה",
+  "Select a feature or use Tab and Enter to choose an action.": "בחר אובייקט, או השתמש ב-Tab ו-Enter לבחירת פעולה.",
+  "Selected feature: {feature}. Choose an action.": "נבחר אובייקט: {feature}. בחר פעולה.",
+  "Running {index}/{total}: {scene} / {shot}": "מריץ {index}/{total}: {scene} / {shot}",
+  "Scene run complete": "ריצת הסצנה הושלמה",
+  "Bhote Koshi Evidence Sequence": "רצף הראיות של Bhote Koshi",
+  "Nepal Flood Incident": "אירוע השיטפון בנפאל",
+  "Global Flights Radar": "מכ\"ם טיסות עולמי",
+  "Orbital Watch": "צפי מסלולי",
+  "Thermal Threat Board": "לוח איומים תרמיים",
+  "City Overload": "עומס עירוני",
+  "Omniscience Pullback": "נסיגת ראייה כוללת",
+  "Global Incident Context": "הקשר אירועים עולמי",
+  "Nepal-Focused Globe Rotation": "סיבוב גלובוס ממוקד נפאל",
+  "Bhote Koshi Regional Approach": "גישה אזורית ל-Bhote Koshi",
+  "Bhote Koshi Nearby Cities": "ערים סמוכות ל-Bhote Koshi",
+  "Bhote Koshi Incident Corridor": "מסדרון אירוע Bhote Koshi",
+  "Bhote Koshi Flood Path": "מסלול שיטפון Bhote Koshi",
+  "Bhote Koshi Corridor Overview": "סקירת מסדרון Bhote Koshi",
+  "Bhote Koshi Upper Valley": "העמק העליון של Bhote Koshi",
+  "Upper Valley Collapse": "קריסת העמק העליון",
+  "Debris-Dammed Lake": "אגם סכור מפולת",
+  "Nepal-China Border Gate": "מעבר הגבול נפאל-סין",
+  "Timure Evidence Cluster": "מקבץ הראיות Timure",
+  "Syabru Besi Passage": "מעבר Syabru Besi",
+  "Bidur / Trishuli Consequence": "תוצאת Bidur / Trishuli",
+  "Final view": "התצוגה הסופית",
+  "Scene {n}": "סצנה {n}",
+  "Shot {n}": "שוט {n}",
+  "the title of scene {scene} is empty or longer than {max} characters": "כותרת הסצנה {scene} ריקה או ארוכה מ-{max} תווים",
+  "the title of shot {shot} in scene {scene} is empty or longer than {max} characters": "כותרת השוט {shot} בסצנה {scene} ריקה או ארוכה מ-{max} תווים",
+  "the project is larger than 5 MiB": "הפרויקט גדול מ-5 MiB",
+  "the project has too many shots": "בפרויקט יותר מדי שוטים",
+  "the scene data failed validation": "נתוני הסצנה נכשלו באימות",
+  "Could not complete this action. Check the file, references and selected assets.": "לא ניתן להשלים את הפעולה הזאת. בדוק את הקובץ, ההתייחסויות והנכסים הנבחרים.",
+  "{count} scenes": {
+    "one": "{count} סצנות",
+    "two": "{count} סצנות",
+    "other": "{count} סצנות"
+  },
+  "{count} shots": {
+    "one": "{count} שוטים",
+    "two": "{count} שוטים",
+    "other": "{count} שוטים"
+  },
+  "{count} data packs": {
+    "one": "{count} חבילות נתונים",
+    "two": "{count} חבילות נתונים",
+    "other": "{count} חבילות נתונים"
+  },
+  "{scene} / {pack}: {status}. File: {path}. {attribution} · {license}": "{scene} / {pack}: {status}. קובץ: {path}. {attribution} · {license}",
+  "Unavailable layers: {layers}": "שכבות בלתי זמינות: {layers}",
+  "Uses registered content or linked media. Those external files are not included in a scene bundle. Their original notices still apply.": "משתמש בתוכן רשום או במדיה מקושרת. הקבצים החיצוניים האלה אינם נכללים בחבילת סצנה. הודעות המקור שלהם חלות בעינם.",
+  "{bytes} bundled bytes verified. Files stay in memory for this session. Reimport the bundle after reloading the app.": "{bytes} בתי החבילה מאומתים. הקבצים נשארים בזיכרון להפעלה הזאת. ייבא מחדש את החבילה אחרי טעינת האפליקציה.",
+  "Review scene import": "סקירת ייבוא סצנה",
+  "Nothing is loaded or changed until you apply this file.": "עד שתאשר את הקובץ לא נטען ולא משתנה דבר.",
+  "Ready to import": "מוכן לייבוא",
+  "Apply replaces the current project. Export your current project first if you want to keep both.": "ההחלה מחליפה את הפרויקט הנוכחי. ייצא קודם את הפרויקט הנוכחי אם ברצונך לשמור את שניהם.",
+  "Apply import": "החל ייבוא",
+  "Import was not applied. The current project may have changed.": "הייבוא לא הוחל. ייתכן שהפרויקט הנוכחי השתנה.",
+  "Select a scene and shot first": "בחר קודם סצנה ושוט",
+  "Edit scene details": "עריכת פרטי הסצנה",
+  "Camera positions use degrees and meters above the ellipsoid. Drafts are validated before they replace your saved scene.": "מיקומי מצלמה במעלות ובמטרים מעל האליפסואיד. טיוטות נבדקות לפני שהן מחליפות את הסצנה השמורה שלך.",
+  "Anchors and data packs": "עוגנים וחבילות נתונים",
+  "Shot camera, timing, packs and actions": "מצלמת השוט, תזמון, חבילות ופעולות",
+  "New anchor ID": "מזהה עוגן חדש",
+  "Capture camera as anchor": "לכידת המצלמה כעוגן",
+  "Anchor added to draft": "העוגן נוסף לטיוטה",
+  "Set move start to current camera": "הצבת התחלת התנועה במצלמה הנוכחית",
+  "Move added to draft; destination remains the shot camera": "התנועה נוספה לטיוטה; היעד נשאר מצלמת השוט",
+  "Use ordinary flight": "שימוש בטיסה רגילה",
+  "Invalid shot JSON": "JSON שוט בלתי תקין",
+  "Apply details": "החלת פרטים",
+  "Select a scene first": "בחר קודם סצנה",
+  "Share selected scene": "שיתוף הסצנה הנבחרת",
+  "Scene JSON preserves authored settings and attribution. It does not include asset files. Bundles include only pack files you choose here or previously imported bundle files.": "JSON הסצנה שומר הגדרות שנוצרו ידנית וייחוס. אינו כולל קבצי נכסים. חבילות כוללות רק קבצי חבילות שבחרת כאן או קבצי חבילות שיובאו בעבר.",
+  "Download scene JSON": "הורדת קובץ JSON הסצנה",
+  "Choose data-pack files": "בחירת קבצי חבילת נתונים",
+  "Or choose a data-pack folder": "או בחירת תיקיית חבילת נתונים",
+  "Download asset bundle": "הורדת חבילת הנכסים",
+  "Asset bundle downloaded": "חבילת הנכסים ירדה",
+  "No RTL-SDR device selected": "לא נבחר מקלט RTL-SDR",
+  "WebUSB requires desktop Chrome or Edge on localhost/HTTPS": "WebUSB דורש Chrome או Edge שולחני ב-localhost/HTTPS",
+  "RTL-SDR access failed; close other SDR apps and check USB permissions": "הגישה ל-RTL-SDR נכשלה; סגור אפליקציות SDR אחרות ובדוק הרשאות USB",
+  "RTL-SDR connection failed": "החיבור ל-RTL-SDR נכשל",
+  "Receiving 1090 MHz ADS-B": "קולט 1090 MHz ADS-B",
+  "Receiving broadcast FM": "קולט שידור FM",
+  "Connect an RTL-SDR to begin.": "חבר RTL-SDR כדי להתחיל.",
+  "WebUSB is unavailable in this browser": "WebUSB אינו זמין בדפדפן הזה",
+  "USB work abandoned after a stalled transfer": "עבודת ה-USB ננטשה אחרי העברה שנתקעה",
+  "SDR decoder worker failed": "מנוע פענוח ה-SDR נכשל",
+  "SDR decoder did not start; receiver stopped": "פענוח ה-SDR לא התחיל; המקלט נעצר",
+  "SDR decoder stopped responding; receiver stopped": "פענוח ה-SDR הפסיק להגיב; המקלט נעצר",
+  "SDR decoder fell behind; receiver stopped": "פענוח ה-SDR נשאר מאחור; המקלט נעצר",
+  "WebUSB requires desktop Chrome or Edge": "WebUSB דורש Chrome או Edge שולחני",
+  "Waiting for an RTL-SDR device…": "ממתין למקלט RTL-SDR…",
+  "Browser audio is suspended; press Connect again to resume it": "שמע הדפדפן מושהה; הקש Connect שוב כדי לחדש אותו",
+  "RTL-SDR sample stream stopped": "זרימת הדגימות של RTL-SDR נעצרה",
+  "Switching to {mode}…": "עובר אל {mode}…",
+  "Browser audio is suspended; select FM again to resume it": "שמע הדפדפן מושהה; בחר FM שוב כדי לחדש אותו",
+  "RTL-SDR gain change failed": "שינוי הגבר RTL-SDR נכשל",
+  "Tuned to {mhz} MHz FM": "מכוון אל {mhz} MHz FM",
+  "Seeking up…": "מחפש תדר מעלה…",
+  "Seeking down…": "מחפש תדר מטה…",
+  "Seek stopped": "החיפוש נעצר",
+  "Scanning {mhz} MHz…": "סורק {mhz} MHz…",
+  "Found {mhz} MHz · {snr} dB": "נמצא {mhz} MHz · {snr} dB",
+  "FM signal found at {mhz} MHz": "נמצא אות FM ב-{mhz} MHz",
+  "No FM signal found": "לא נמצא אות FM",
+  "Browser location is unavailable": "מיקום הדפדפן אינו זמין",
+  "Receiver location was not granted": "אישור מיקום המקלט לא ניתן",
+  "RTL-SDR disconnected": "RTL-SDR מנותק",
+  "Upstream response too large": "תשובת המקור גדולה מדי",
+  "Vector tile request timed out": "בקשת אריח וקטורי חרגה מהזמן הקצוב",
+  "Vector tiles unavailable": "אריחים וקטוריים אינם זמינים",
+  "Vector tile metadata unavailable": "מידע המטא-נתונים של אריחים וקטוריים אינו זמין",
+  "Zoom in for vector tile coverage": "התקרב לכיסוי אריחים וקטוריים",
+  "Saturation": "רוויה",
+  "Edge Thickness": "עובי גבולות",
+  "Contrast": "ניגודיות",
+  "Grain": "גרעיניות",
+  "Vignette": "וינייטה",
+  "Pixelation": "פיקסול",
+  "Distortion": "עיוות",
+  "Instability": "חוסר יציבות",
+  "Gain": "הגבר",
+  "Bloom": "זוהר",
+  "Scanlines": "קווי סריקה",
+  "Sensitivity": "רגישות",
+  "WHOT/BHOT": "WHOT/BHOT",
+  "Ironbow": "קשת ברזל",
+  "Left panels": "פאנלים שמאליים",
+  "Right panels": "פאנלים ימניים",
+  "Contacts could not complete the requested transition; try again": "המגעים לא השלימו את המעבר המבוקש; נסה שוב",
+  "CCTV layer unavailable": "שכבת CCTV אינה זמינה",
+  "Link shared": "הקישור שותף",
+  "Link copied!": "הקישור הועתק!",
+  "Copy failed": "ההעתקה נכשלה",
+  "Tilted view": "תצוגה משופעת",
+  "Straight-down view": "תצוגה ישרה מלמעלה",
+  "North up": "צפון מעלה",
+  "CCTV calibration saved": "כיול CCTV נשמר",
+  "HDG": "HDG",
+  "PITCH": "הטייה",
+  "FOV": "FOV",
+  "RANGE": "טווח",
+  "HGT": "HGT",
+  "ΔN": "ΔN",
+  "ΔE": "ΔE",
+  "{value}m": "{value} מ׳",
+  "CCTV calibration reset": "כיול CCTV אופס",
+  "ADJUST ON": "התאמה פעילה",
+  "ADJUST": "התאמה",
+  "OK": "אישור",
+  "ERROR": "שגיאה",
+  "Live HLS connected": "HLS חי מחובר",
+  "Live HLS unavailable": "HLS חי אינו זמין",
+  "No stream URL configured": "לא הוגדרה כתובת זרימה",
+  "Live stream connected": "זרימה חיה מחוברת",
+  "Snapshot feed connected": "פיד תמונות מחובר",
+  "Media fetch failed": "שליפת המדיה נכשלה",
+  "Upstream snapshot active": "פיד תמונות מהמקור פעיל",
+  "Fallback Street View frame": "שקופית Street View חלופית",
+  "Upstream unavailable": "המקור אינו זמין",
+  "No source configured": "לא הוגדר מקור",
+  "Configured source": "מקור מוגדר",
+  "Configured Source": "מקור מוגדר",
+  "Synthetic fallback": "גיבוי סינתטי",
+  "Upstream HTTP {status}": "HTTP {status} מהמקור",
+  "Unexpected media type {type}": "סוג מדיה בלתי צפוי: {type}",
+  "SOURCE · UNKNOWN": "מקור · לא ידוע",
+  "FRAME · LOADING": "שקופית · בטעינה",
+  "FRAME · UNAVAILABLE": "שקופית · לא זמינה",
+  "{count} more cameras outside this view · pan or zoom out": {
+    "one": "{count} מצלמות נוספות מחוץ לתצוגה הזאת · הזז או זום החוצה",
+    "two": "{count} מצלמות נוספות מחוץ לתצוגה הזאת · הזז או זום החוצה",
+    "other": "{count} מצלמות נוספות מחוץ לתצוגה הזאת · הזז או זום החוצה"
+  },
+  "VIEWSHED ON": "שדה ראייה פעיל",
+  "COVERAGE ON": "כיסוי פעיל",
+  "COVERAGE OFF": "כיסוי כבוי",
+  "AUTO HOP ON": "קפיצה אוטומטית פעילה",
+  "AUTO HOP OFF": "קפיצה אוטומטית כבויה",
+  "PROJECTION ON": "הקרנה פעילה",
+  "PROJECTION OFF": "הקרנה כבויה",
+  "CAL · EDITED (UNSAVED)": "CAL · נערך (לא נשמר)",
+  "CAL · {badge}": "CAL · {badge}",
+  "MONITOR": "מוניטור",
+  "OFF": "כבוי",
+  "{city} · HDG {heading} · FOV {fov} · RANGE {range}m · {projection}{calBadge} · {provider}{status}": "{city} · HDG {heading} · FOV {fov} · טווח {range} מ׳ · {projection}{calBadge} · {provider}{status}",
+  "{count} cameras loaded · click a camera to activate": {
+    "one": "{count} מצלמות נטענו · לחץ על מצלמה להפעלה",
+    "two": "{count} מצלמות נטענו · לחץ על מצלמה להפעלה",
+    "other": "{count} מצלמות נטענו · לחץ על מצלמה להפעלה"
+  },
+  "{count} cameras loaded · enable CCTV to activate": {
+    "one": "{count} מצלמות נטענו · הפעל CCTV להפעלה",
+    "two": "{count} מצלמות נטענו · הפעל CCTV להפעלה",
+    "other": "{count} מצלמות נטענו · הפעל CCTV להפעלה"
+  },
+  "Enable CCTV to load camera intersections": "הפעל CCTV לטעינת חיתוכי מצלמות",
+  "Enable CCTV to start camera-linked intelligence summaries.": "הפעל CCTV להתחלת סיכומי מודיעין הקשורים למצלמות.",
+  "No summary available.": "אין סיכום זמין.",
+  "loading frames": "טוען שקופיות",
+  "camera grid ready": "רשת המצלמות מוכנה",
+  "Clearing selected data layers": "מנקה שכבות נתונים נבחרות",
+  "Clear selected data layers": "ניקוי שכבות נתונים נבחרות",
+  "LIVE SIGNALS": "אותות חיים",
+  "OBSERVED / MAPPED PINGS": "פינגים נצפים / ממופים",
+  "SOURCE-BACKED EVENTS · NO SYNTHETIC NEWS": "אירועים נתמכי מקור · ללא חדשות סינתטיות",
+  "REGIONAL NEWS": "חדשות אזוריות",
+  "LATEST LOCATION-MATCHED REPORTING": "הדיווחים תואמי המיקום האחרונים",
+  "{source} · LOCATION QUERY · RECENT": "{source} · שאילתת מיקום · אחרונים",
+  "LOCAL INFO": "מידע מקומי",
+  "PLACE / CONDITIONS / POSITION": "מקום / מצב / עמדה",
+  "Stop automatic page cycling. Previous, Next, and the SIG/NEWS/LOCAL tabs stay available.": "הפסק את מחזור העמודים האוטומטי. קודם, הבא, והלשוניות אותות/חדשות/מקומי נשארות זמינות.",
+  "Cycle briefing pages automatically every 9 seconds (Signals → News → Local). Pauses while you hover or focus the panel. Live signal data refreshes continuously either way.": "מחזר את עמודי הדיווח אוטומטית כל 9 שניות (אותות → חדשות → מקומי). מושהה בזמן ריחוף או מיקוד הפאנל. נתוני האותות החיים מתרעננים כל הזמן בכל מקרה.",
+  "CYCLE OFF": "מחזור כבוי",
+  "ACQUIRING REGIONAL NEWS": "אוסף חדשות אזוריות",
+  "RESOLVING REGION": "מזהה אזור",
+  "CONDITIONS UNKNOWN": "מחיזים לא ידועים",
+  "CLEAR": "בהיר",
+  "PARTLY CLOUDY": "חלקי מעונן",
+  "OVERCAST": "מעונן",
+  "FOG": "ערפל",
+  "DRIZZLE": "טפטוף",
+  "RAIN": "גשם",
+  "SNOW": "שלג",
+  "RAIN SHOWERS": "ממטרים",
+  "SNOW SHOWERS": "ממטרי שלג",
+  "THUNDERSTORM": "סופת רעמים",
+  "MIXED CONDITIONS": "תנאים מעורבים",
+  "CYCLE ON": "מחזור פעיל",
+  "REGIONAL NEWS UNAVAILABLE": "חדשות אזוריות אינן זמינות",
+  "REGION UNAVAILABLE": "אזור אינו זמין",
+  "NO RECENT LOCATION MATCHES": "אין התאמות מיקום אחרונות",
+  "{domain} · {age}": "{domain} · לפני {age}",
+  "{value} KM/H": "{value} קמ\"ש",
+  "CLOUD {pct}%": "עננות {pct}%",
+  "CLOUD UNKNOWN": "עננות לא ידועה",
+  "{source} · LOCATION QUERY": "{source} · שאילתת מיקום",
+  "{label} · {radius} AIR/SEA WINDOW": "{label} · חלון אוויר/ים {radius}",
+  "{scope} · INSTALLATIONS {coverage}": "{scope} · מתקנים {coverage}",
+  "MILITARY FEED OFF · PARTIAL PICTURE": "פיד צבאי כבוי · תמונה חלקית",
+  "FLIGHTS FEED OFF · PARTIAL PICTURE": "פיד טיסות כבוי · תמונה חלקית",
+  "NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR": "מטוסים סמוכים חלקיים · ללא אישור מלא",
+  "CONTEXT STANDBY": "ההקשר בהמתנה",
+  "ENABLE GLOBAL CONTEXT FOR PROXIMITY PINGS": "הפעל הקשר גלובלי לפינגים של קרבה",
+  "CONTACT LOST · LAST KNOWN READOUT · NOT AN ALL-CLEAR": "המגע אבד · הקריאה האחרונה הידועה · ללא אישור מלא",
+  "CONTACT LOST · {subject}": "המגע אבד · {subject}",
+  "SUBJECT LEFT ITS FEED · READOUT HOLDING LAST KNOWN": "העצם יצא מהפיד · הקריאה מחזיקה את האחרון הידוע",
+  "{cohort} · {contact}": "{cohort} · {contact}",
+  "NO AVAILABLE EXAMPLE": "אין דוגמה זמינה",
+  "{cohort}, Unavailable": "{cohort}, לא זמין",
+  "AHEAD": "לפנים",
+  "{side} {angle}": "{side} {angle}",
+  "L": "L",
+  "R": "R",
+  "{count} INPUTS UNKNOWN · NOT AN ALL-CLEAR": {
+    "one": "{count} קלטים לא ידועים · ללא אישור מלא",
+    "two": "{count} קלטים לא ידועים · ללא אישור מלא",
+    "other": "{count} קלטים לא ידועים · ללא אישור מלא"
+  },
+  "AVAILABLE INPUTS CURRENT · NOT AN ALL-CLEAR": "הקלטים הזמינים עדכניים · ללא אישור מלא",
+  "CONTACTS · 250 KM": "מגעים · 250 ק\"מ",
+  "AVAILABLE INPUTS ONLY · NOT AN ALL-CLEAR": "קלטים זמינים בלבד · ללא אישור מלא",
+  "Normal": "רגיל",
+  "Night vision": "ראיית לילה",
+  "Thermal": "תרמי",
+  "Anime": "אנימה",
+  "Noir": "נואר",
+  "AIRCRAFT": "מטוס",
+  "LIVE TRACK · COURSE ALIGNED": "מעקב חי · מסלול תואם",
+  "ROUTE DATA UNAVAILABLE": "נתוני המסלול אינם זמינים",
+  "DEST ---°": "DEST ---°",
+  "SQUAWK {code} · {status}": "SQUAWK {code} · {status}",
+  "ADS-B PRIORITY · {status}": "עדיפות ADS-B · {status}",
+  "ADS-B EMERGENCY · {status}": "חירום ADS-B · {status}",
+  "ACQUIRING SURFACE": "אוסף משטח",
+  "SURFACE FALLBACK": "משטח חלופי",
+  "STALE FEED": "פיד מיושן",
+  "LIVE TRACK": "מעקב חי",
+  "COMMERCIAL": "מסחרי",
+  "{aircraftClass} · {emergency} · {feedState}": "{aircraftClass} · {emergency} · {feedState}",
+  "{aircraftClass} · {feedState} · COURSE ALIGNED": "{aircraftClass} · {feedState} · מסלול תואם",
+  "ARROW · ESTIMATED DIRECTION": "חץ · כיוון מוערך",
+  "DEST {bearing}": "DEST {bearing}",
+  "TIME UNKNOWN": "זמן לא ידוע",
+  "{count}M AGO": "לפני {count} דק'",
+  "{count}H AGO": "לפני {count} שע'",
+  "{count}D AGO": "לפני {count} יום",
+  "DIR UNKNOWN": "כיוון לא ידוע",
+  "COCKPIT": "תא טייס",
+  "Select flight {title}": "בחירת הטיסה {title}",
+  "{aircraftClass} · CURRENT": "{aircraftClass} · נוכחי",
+  "MILITARY FLIGHT": "טיסה צבאית",
+  "COMMERCIAL FLIGHT": "טיסה מסחרית",
+  "{aircraftClass} · {distance}": "{aircraftClass} · {distance}",
+  "DISTANCE UNKNOWN": "מרחק לא ידוע",
+  "{count} INPUTS UNKNOWN": {
+    "one": "{count} קלטים לא ידועים",
+    "two": "{count} קלטים לא ידועים",
+    "other": "{count} קלטים לא ידועים"
+  },
+  "SOURCE STATUS UNAVAILABLE": "מצב המקור אינו זמין",
+  "TRACK ACQUIRED": "המעקב נתפס",
+  "{label} · COURSE {heading}°": "{label} · מסלול {heading}°",
+  "Context could not restore every layer; try again": "ההקשר לא שיחזר את כל השכבות; נסה שוב",
+  "No selected data layers": "אין שכבות נתונים נבחרות",
+  "{count} data layers could not be cleared": {
+    "one": "{count} שכבות נתונים לא נוקו",
+    "two": "{count} שכבות נתונים לא נוקו",
+    "other": "{count} שכבות נתונים לא נוקו"
+  },
+  "Cleared {count} data layers": {
+    "one": "נוקו {count} שכבות נתונים",
+    "two": "נוקו {count} שכבות נתונים",
+    "other": "נוקו {count} שכבות נתונים"
+  },
+  "Selected data layers could not be cleared": "שכבות הנתונים הנבחרות לא נוקו",
+  "Space Missions could not complete the requested transition; try again": "Space Missions לא השלים את המעבר המבוקש; נסה שוב",
+  "Nearby installations refreshed": "המתקנים הסמוכים התרעננו",
+  "Nearby installations could not be refreshed; try again": "לא ניתן לרענן את המתקנים הסמוכים; נסה שוב",
+  "Space Missions cancellation could not restore the previous layer state": "ביטול Space Missions לא שיחזר את מצב השכבה הקודם",
+  "That layer is unavailable in the current Context mode": "השכבה הזאת אינה זמינה במצב ההקשר הנוכחי",
+  "{layerId} could not {action} cleanly": "{layerId} — הפעולה {action} לא הסתיימה בנקיון",
+  "start": "התחלה",
+  "stop": "עצירה",
+  "{mode} could not start because another layer did not stop cleanly": "{mode} לא החל כי שכבה אחרת לא נעצרה בנקיון",
+  "Space Missions": "Space Missions",
+  "Context": "ההקשר",
+  "Ground heights could not be refreshed. Try the file again when the map has loaded.": "את גבהי הקרקע לא ניתן לרענן. נסה שוב את הקובץ כשהמפה נטענת.",
+  "{count} map objects": {
+    "one": "{count} אובייקטי מפה",
+    "two": "{count} אובייקטי מפה",
+    "other": "{count} אובייקטי מפה"
+  },
+  ", drawn with its own styles": ", צויר בסגנונות משלו",
+  "At most {count} files at once — remove one first.": "{count} קבצים לכל היותר בכל פעם — הסר קודם אחד.",
+  "Reading {name}…": "קורא את {name}…",
+  "That file could not be read.": "את הקובץ לא ניתן לקרוא.",
+  "Added {count} files.": {
+    "one": "נוספו {count} קבצים.",
+    "two": "נוספו {count} קבצים.",
+    "other": "נוספו {count} קבצים."
+  },
+  "{count} files could not be added ({name}: {error})": {
+    "one": "{count} קבצים לא התווספו ({name}: {error})",
+    "two": "{count} קבצים לא התווספו ({name}: {error})",
+    "other": "{count} קבצים לא התווספו ({name}: {error})"
+  },
+  "Some KML content was left out.": "חלק מתוכן ה-KML הושמט.",
+  "Press on the ground, not the sky": "הקש על הקרקע, לא על השמים",
+  "Drag to size the box": "גרור כדי לעצב את גודל התיבה",
+  "light {source} to use your {name} key": "הדלק את {source} לשימוש במפתח ה-{name} שלך",
+  "light {source}": "הדלק את {source}",
+  ", or ": ", או ",
+  "{requirement}, or {offer}": "{requirement}, או {offer}",
+  "Expand {name}": "הרחבת {name}",
+  "Collapse {name}": "קיפול {name}",
+  "panel": "פאנל",
+  "Live Flights": "טיסות חיות",
+  "Military Flights": "טיסות צבאיות",
+  "Earthquakes (24h)": "רעידות אדמה (24 שע)",
+  "Satellites": "לוויינים",
+  "Space Missions (30d)": "משימות חלל (30 יום)",
+  "Street Traffic": "תנועה ברחובות",
+  "CCTV": "CCTV",
+  "Radio": "רדיו",
+  "Bikeshare": "אופניים שיתופיים",
+  "Live AIS Vessels": "אוניות AIS חיות",
+  "Mapped Installations": "מתקנים ממופים",
+  "Global Context": "הקשר גלובלי",
+  "Datacenters": "מרכזי נתונים",
+  "Dams": "סכרים",
+  "Submarine Cables": "כבלים תת-ימיים",
+  "FIRMS Active Fires": "שרפות פעילות FIRMS",
+  "Local ADS-B": "ADS-B מקומי",
+  "OSM Places": "מקומות OSM",
+  "Transit": "תחבורה ציבורית",
+  "Recent Imagery": "צילומים אחרונים",
+  "Fire Perimeters": "היקפי שרפות",
+  "GNSS Integrity": "שלמות GNSS",
+  "Prohibited & Restricted Airspace": "שמיים אסורים ושמורים",
+  "S2 GhostMaps": "S2 GhostMaps",
+  "Rain radar": "רדאר גשם",
+  "Lightning density": "צפיפות מכות",
+  "Cyclone advisories": "ייעוצי ציקלונים",
+  "ALPR Cameras": "מצלמות ALPR",
+  "Sea Marks": "סימני ים",
+  "Ski Pistes": "מסלולי סקי",
+  "Live Vessels": "אוניות חיות",
+  "Bike Share": "אופניים שיתופיים",
+  "Cameras": "מצלמות",
+  "Street Level": "Street Level",
+  "Mapped ALPR Cameras": "מצלמות ALPR ממופות",
+  "Data Centers": "מרכזי נתונים",
+  "Active Fires": "שרפות פעילות",
+  "Military aircraft": "מטוס צבאי",
+  "Vessels": "אוניות",
+  "CCTV + Street View fallback": "CCTV + גיבוי Street View",
+  "OpenStreetMap + optional Google Maps Places": "OpenStreetMap + Google Maps Places אופציונלי",
+  "GFS / ECMWF IFS · FORECAST": "GFS / ECMWF IFS · חזוי",
+  "NOAA nowCOAST · OBSERVED": "NOAA nowCOAST · נצפה",
+  "NASA FIRMS · LIVE": "NASA FIRMS · חי",
+  "OSM routing": "ניתוב OSM",
+  "data source|Local": "מקומי",
+  "ON": "פעיל",
+  "ENABLING": "מפעיל",
+  "DISABLING": "מכבה",
+  "Movement": "תנועה",
+  "Infrastructure": "תשתיות",
+  "Events": "אירועים",
+  "Wildlife": "חיות בר",
+  "Weather": "מזג אוויר",
+  "Utilities": "כלי עזר",
+  "Audio": "שמע",
+  "UNCERTAIN": "לא ודאי",
+  "Data source unavailable": "מקור הנתונים אינו זמין",
+  "{name}: {state}": "{name}: {state}",
+  "status chip|UNAVAILABLE": "לא זמין",
+  "Other layers": "שכבות אחרות",
+  "{state} · {source}": "{state} · {source}",
+  "UNCERTAIN · {source} · lifecycle state requires reconciliation": "לא ודאי · {source} · מצב מחזור החיים מצריך התאמה",
+  "{state} · {source} · {detail} · retry {seconds}s": "{state} · {source} · {detail} · ניסיון חוזר בעוד {seconds} שנ'",
+  "{state} · {source} · {detail}": "{state} · {source} · {detail}",
+  "never": "לעולם לא",
+  "{source} · {loadingLabel}": "{source} · {loadingLabel}",
+  "{accepted} of {raw} records accepted": "התקבלו {accepted} מתוך {raw} רשומות",
+  "incomplete snapshot": "תמונת מצב שאינה שלמה",
+  "{state} · {source} · {detail} · {ago}": "{state} · {source} · {detail} · {ago}",
+  "{state} · {source} · {ago} · retrying in {seconds}s": "{state} · {source} · {ago} · מנסה שוב בעוד {seconds} שנ'",
+  "{state} · {source} · {ago}": "{state} · {source} · {ago}",
+  "{source} · {ago}": "{source} · {ago}",
+  "{count}s ago": "לפני {count} שנ'",
+  "Local FM stopped: internet radio started": "FM מקומי נעצר: רדיו אינטרנט החל",
+  "IDLE": "אין פעילות",
+  "CONNECTING": "מתחבר",
+  "TUNING": "מכוון",
+  "STREAMING": "זורם",
+  "UNSUPPORTED": "אינו נתמך",
+  "idle": "רדום",
+  "running": "רץ",
+  "suspended": "מושהה",
+  "closed": "סגור",
+  "feed status|live": "חי",
+  "feed status|stale": "מיושן",
+  "feed status|unreachable": "בלתי נגיש",
+  "feed status|invalid": "בלתי תקין",
+  "waiting for IQ": "ממתין ל-IQ",
+  "{count} messages": {
+    "one": "{count} הודעות",
+    "two": "{count} הודעות",
+    "other": "{count} הודעות"
+  },
+  "DSP {count} blocks": {
+    "one": "{count} בלוקים DSP",
+    "two": "{count} בלוקים DSP",
+    "other": "{count} בלוקים DSP"
+  },
+  "DSP waiting": "DSP ממתין",
+  "{level} dBFS audio": "{level} dBFS שמע",
+  "audio signal --": "אות שמע --",
+  "audio {state}": "שמע {state}",
+  "{count} HEARD": {
+    "one": "{count} נשמעו",
+    "two": "{count} נשמעו",
+    "other": "{count} נשמעו"
+  },
+  "DISCONNECT": "נתק",
+  "CONNECT": "חבר",
+  "LOCATING…": "מאתר…",
+  "LOCATED": "אותר",
+  "LOCATE": "אתר",
+  " · read while Local ADS-B is on": " · נקרא בזמן ש-Local ADS-B פעיל",
+  "Decoder feeds: {feeds}": "פידי דקודר: {feeds}",
+  "📍 Location: --": "📍 מיקום: --",
+  "Landmark: --": "ציון דרך: --",
+  "Searched location": "המקום שנחפש",
+  "Location not found": "המקום לא נמצא",
+  "Check the spelling and press Enter to search again.": "בדוק את האיות והקש Enter כדי לחפש שוב.",
+  "Search failed": "החיפוש נכשל",
+  "Press Enter to try again.": "הקש Enter לניסיון חוזר.",
+  "Detailed outline unavailable": "קו המתאר המפורט אינו זמין",
+  "Fly to a POI first": "עוף קודם אל נקודת עניין",
+  "{label} unavailable: {hint}": "{label} אינו זמין: {hint}",
+  "MAP": "מפה",
+  "Layers": "שכבות",
+  "Search": "חיפוש",
+  "More": "עוד",
+  "Panel layout updated — positions reset to new defaults": "פריסת הפאנלים עודכנה — המקומות אופסו לברירות המחדל החדשות",
+  "DATA LAYERS": "שכבות נתונים",
+  "UTILITIES": "כלי עזר",
+  "AUTHORING": "יצירה",
+  "DISPLAY": "תצוגה",
+  "WEATHER": "מזג אוויר",
+  "RECENT IMAGERY": "צילומים אחרונים",
+  "STREET LEVEL": "STREET LEVEL",
+  "CONTEXT": "הקשר",
+  "Austin": "אוסטין",
+  "San Francisco": "סן פרנסיסקו",
+  "New York": "ניו יורק",
+  "Tokyo": "טוקיו",
+  "London": "לונדון",
+  "Paris": "פריז",
+  "Dubai": "דובאי",
+  "Washington DC": "וושינגטון די. סי.",
+  "Tallinn": "טאלין",
+  "Los Angeles": "לוס אנג׳לס",
+  "CH {index} / {total}": "ערוץ {index} / {total}",
+  "NO STATIONS": "אין תחנות",
+  "NO STATION AVAILABLE": "אין תחנה זמינה",
+  "{name}, station {index} of {total}": "{name}, תחנה {index} מתוך {total}",
+  "No station available": "אין תחנה זמינה",
+  "OFF AIR": "מחוץ לשידור",
+  "STATION UNAVAILABLE": "התחנה אינה זמינה",
+  "Station unavailable after directory refresh": "התחנה אינה זמינה אחרי רענון המדריך",
+  "Radio could not {action} cleanly": "הרדיו לא השלים את {action} בנקיון",
+  "SYNC": "סנכרון",
+  "RECONCILE": "התאמה",
+  "DISABLE": "כיבוי",
+  "ENABLE": "הפעלה",
+  "Reconcile Radio — lifecycle uncertain": "התאמת הרדיו — מחזור חיים לא ודאי",
+  "Disable Radio": "כיבוי הרדיו",
+  "Enable Radio": "הפעלת הרדיו",
+  "{category} ({count})": "{category} ({count})",
+  "DIRECTORY BAND": "פס המדריך",
+  "{category} BAND": "פס {category}",
+  "Directory metadata only": "רק מידע מהמדריך",
+  "Loading station directory…": "טוען את מדריך התחנות…",
+  "Choose a globe marker or use next.": "בחר סמן על הגלובוס או השתמש בהבא.",
+  "Play": "נגן",
+  "PAUSE": "השהה",
+  "RESUME": "המשך",
+  "PLAY": "נגינה",
+  "selected": "נבחר",
+  "nearest": "הקרוב",
+  "{action} {target} radio station": "{action} את תחנת הרדיו {target}",
+  "station": "תחנה",
+  " · stale/degraded directory": " · מדריך מיושן/מופחת",
+  " · degraded directory": " · מדריך מופחת",
+  " · stale directory": " · מדריך מיושן",
+  " · outside current filter": " · מחוץ למסנן הנוכחי",
+  "Ready — playback starts only from your action": "מוכן — ההשמעה תחל רק מהפעולה שלך",
+  "Radio off": "הרדיו כבוי",
+  "Connecting directly to broadcaster…": "מתחבר ישירות למשדר…",
+  "Buffering broadcaster stream…": "אוגר את זרימת המשדר…",
+  "Playing {station}": "מנגן {station}",
+  "Paused {station}": "הושהתה {station}",
+  "Broadcaster stream unavailable": "זרימת המשדר אינה זמינה",
+  " · muted during voice interaction": " · מושתק בזמן אינטראקציה קולית",
+  " · restoring volume after voice": " · מחזיר עוצמה אחרי הקול",
+  " · static indicates no broadcaster audio": " · רקע רק מעיד שאין שמע מהמשדר",
+  " · tuning static until broadcaster starts": " · רקע עד לתחילת השידור של המשדר",
+  "Station unavailable after directory refresh — choose another channel": "התחנה אינה זמינה אחרי רענון המדריך — בחר ערוץ אחר",
+  "Radio is enabling…": "הרדיו במהלך הפעלה…",
+  "Radio is disabling…": "הרדיו במהלך כיבוי…",
+  "Radio lifecycle is uncertain — use Enable or Disable to reconcile": "מחזור חיי הרדיו אינו ודאי — השתמש בהפעלה או בכיבוי כדי להתאים",
+  "NO STATION SELECTED": "לא נבחרה תחנה",
+  "TAGS · {tags}": "תגיות · {tags}",
+  "SYNCING": "מסנכרן",
+  "READY": "מוכן",
+  "Clear reading": "ניקוי הקריאה",
+  "Observed history": "היסטוריה נצפית",
+  "Earlier observation": "תצפית קודמת",
+  "Later observation": "תצפית מאוחרת",
+  "Newest frame per product": "השקופית החדשה לכל מוצר",
+  "Latest": "האחרונה",
+  "Replay observed history": "הצגת ההיסטוריה הנצפית שוב",
+  "Imagery on Esri · Google 3D returns when cleared": "צילומים ב-Esri · Google 3D חוזר כשמנקים",
+  "Point the camera at the ground to use the view": "כוון את המצלמה אל הקרקע כדי להשתמש בתצוגה",
+  "That point cannot anchor a box": "אין אפשרות לעגן תיבה באותה נקודה",
+  "Imagery stops at ±{limit}° latitude": "הצילומים נעצרים ברוחב ±{limit}°",
+  "{owner} is using the pointer — close it first": "{owner} משתמש במצביע — סגור אותו תחילה",
+  "Box is {size} wide · limit {limit}": "רוחב התיבה {size} · מגבלה {limit}",
+  "View is {size} wide · limit {limit}": "רוחב התצוגה {size} · מגבלה {limit}",
+  "VS BASEMAP": "מול מפת הבסיס",
+  "A / B": "A / B",
+  "Newest low-cloud day for this box · scene cloud, not box cloud": "היום החדש ביותר בעל עננות נמוכה לתיבה הזאת · עננות הסצנה, לא עננות התיבה",
+  "Newest day covering this box · cloudier than 20%": "היום החדש ביותר המכסה את התיבה הזאת · מעונן מ-20%",
+  "Newest day with imagery for this box · partial coverage": "היום החדש ביותר עם צילומים לתיבה הזאת · כיסוי חלקי",
+  "Newest daily overview for this box": "הסקירה היומית החדשה ביותר לתיבה הזאת",
+  "newest clear day": "היום הבהיר החדש ביותר",
+  "newest day (cloudy)": "היום החדש ביותר (מעונן)",
+  "newest day (partial coverage)": "היום החדש ביותר (כיסוי חלקי)",
+  "newest overview": "הסקירה החדשה ביותר",
+  "No imagery": "אין צילומים",
+  "Loading": "בטעינה",
+  "coverage|full": "מלא",
+  "coverage|partial": "חלקי",
+  "unknown": "לא ידוע",
+  "no imagery": "אין צילומים",
+  "{percent}% cloud": "{percent}% עננות",
+  "{min}–{max}% cloud": "{min}–{max}% עננות",
+  "NO BOX": "אין תיבה",
+  "SEARCHING": "מחפש",
+  "{count} DAYS": {
+    "one": "{count} ימים",
+    "two": "{count} ימים",
+    "other": "{count} ימים"
+  },
+  "Zoom in or draw a smaller box": "התקרב או שרטט תיבה קטנה יותר",
+  "Select a box or use the view": "בחר תיבה או השתמש בתצוגה",
+  "Searching the last 30 days": "מחפש ב-30 הימים האחרונים",
+  "No days to show for this box": "אין ימים להצגה לתיבה הזאת",
+  "Drag the divider · SWAP trades sides": "גרור את המפריד · SWAP מחליף צדדים",
+  "← → preview · A or B pins the focused day": "← → תצוגה מקדימה · A או B מקבע את היום במוקד",
+  "← → preview the other side · A or B pins it": "← → הצצת הצד השני · A או B מקבעים אותו",
+  "S on another day replaces it · × unpins": "S ביום אחר מחליף אותו · × מסיר את הקיבוע",
+  "← → preview · S shows the focused day": "← → תצוגה מקדימה · S מציג את היום במוקד",
+  "SELECT BOX": "בחירת תיבה",
+  "Drag a box on the map (Esc cancels)": "שרטט תיבה במפה (Esc מבטל)",
+  "USE VIEW": "שימוש בתצוגה",
+  "Use the current view as the box": "שימוש בתצוגה הנוכחית כתיבה",
+  "Forget the box and its images": "שכחת התיבה ותמונותיה",
+  "PREVIEW": "תצוגה מקדימה",
+  "SHOW": "הצגה",
+  "Pin {day} as {slot}": "קיבוע {day} כ-{slot}",
+  "Show {day}": "הצגת {day}",
+  "pinned {slot}": "מקובע {slot}",
+  "shown": "מוצג",
+  "preview": "תצוגה מקדימה",
+  "Checking": "בודק",
+  "Newest day with imagery for this box": "היום החדש ביותר עם צילומים לתיבה הזאת",
+  "start here": "התחל כאן",
+  "No box": "אין תיבה",
+  "Searching": "מחפש",
+  "Every day is empty here": "כל הימים ריקים כאן",
+  "Sources off": "המקורות כבויים",
+  "Not set": "לא הוגדר",
+  "Basemap": "מפת בסיס",
+  "Source off": "מקור כבוי",
+  "VS": "מול",
+  "Unpin {slot}": "הסרת קיבוע {slot}",
+  "Unpin the image": "הסרת קיבוע התמונה",
+  "EXPORT {slot}": "ייצוא {slot}",
+  "EXPORT": "ייצוא",
+  "Download {slot} as a PNG": "הורדת {slot} כקובץ PNG",
+  "Download the image as a PNG": "הורדת התמונה כקובץ PNG",
+  "Box {width} × {height} km": "תיבה {width} × {height} ק\"מ",
+  "Acquired {time}": "נאסף {time}",
+  "Coverage {coverage}": "כיסוי {coverage}",
+  "START HERE · {reason}": "התחלה כאן · {reason}",
+  "Daily overview shows little detail in a box this small": "הסקירה היומית מציגה מעט פירוט בתיבה קטנה כל כך",
+  "Imagery: NASA GIBS and Worldview · HLS (Sentinel-2, Landsat 8/9) and VIIRS": "צילומים: NASA GIBS ו-Worldview · HLS (Sentinel-2, Landsat 8/9) ו-VIIRS",
+  "Details": "פרטים",
+  "Times, coverage, sources": "זמנים, כיסוי, מקורות",
+  "HIDE EMPTY DAYS": "הסתרת ימים ריקים",
+  "SHOW EMPTY DAYS · {count}": "הצגת ימים ריקים · {count}",
+  "Days the probe found empty in this box": "הימים שהבדיקה מצאה ריקים בתיבה הזאת",
+  "image": "תמונה",
+  "BASEMAP": "מפת בסיס",
+  "The basemap": "מפת הבסיס",
+  "basemap": "מפת בסיס",
+  "Recent imagery against the basemap divider": "המפריד בין צילומים אחרונים למפת הבסיס",
+  "Recent imagery A and B divider": "המפריד בין צילומים אחרונים A ו-B",
+  "{before} {left} percent, {after} {right} percent": "{before} {left} אחוזים, {after} {right} אחוזים",
+  "Export failed · {error}": "הייצוא נכשל · {error}",
+  "START HERE": "התחלה כאן",
+  "Fly in until the view fits the 1,000 km limit": "עוף פנימה עד שהתצוגה נכנסת למגבלה של 1,000 ק\"מ",
+  "ZOOM IN": "התקרבות",
+  "Imagery days, newest first · arrows move, S or A and B pin": "ימי צילומים, חדש בראש · החצים מזיזים, S או A ו-B מקבעים",
+  "On the map": "על המפה",
+  "Mode": "מצב",
+  "Imagery opacity": "אטימות הצילומים",
+  "Trade the two sides of the divider": "החלפת שני צדי המפריד",
+  "SWAP": "החלפה",
+  "scene|PLAY": "נגן",
+  "Scene action failed": "פעולת הסצנה נכשלה",
+  "New scene name": "שם סצנה חדש",
+  "Delete scene \"{scene}\" and all shots?": "למחוק את הסצנה \"{scene}\" ואת כל השוטים?",
+  "Delete shot \"{shot}\"?": "למחוק את השוט \"{shot}\"?",
+  "Stopped (Esc)": "נעצר (Esc)",
+  "SPARSE": "דליל",
+  "BALANCED": "מאוזן",
+  "{duration}s + {hold}s": "{duration} שנ + {hold} שנ",
+  "Cancel": "ביטול",
+  "Shared flight follow expired": "עקיבת הטיסה המשותפת פגה",
+  "Shared military flight follow expired": "עקיבת הטיסה הצבאית המשותפת פגה",
+  "Shared satellite follow expired": "עקיבת הלוויין המשותפת פגה",
+  "Shared flight could not be restored — feed unavailable": "לא ניתן לשחזר את הטיסה המשותפת — הפיד אינו זמין",
+  "Shared military flight could not be restored — feed unavailable": "לא ניתן לשחזר את הטיסה הצבאית המשותפת — הפיד אינו זמין",
+  "Shared satellite could not be restored — feed unavailable": "לא ניתן לשחזר את הלוויין המשותף — הפיד אינו זמין",
+  "Shared flight is unavailable": "הטיסה המשותפת אינה זמינה",
+  "Shared military flight is unavailable": "הטיסה הצבאית המשותפת אינה זמינה",
+  "Shared satellite is unavailable": "הלוויין המשותף אינו זמין",
+  "entity": "עצם",
+  "Shared {subject} follow expired": "עקיבת {subject} המשותף פגה",
+  "Shared {subject} could not be restored — feed unavailable": "לא ניתן לשחזר את {subject} המשותף — הפיד אינו זמין",
+  "Shared {subject} is unavailable": "{subject} המשותף אינו זמין",
+  "{id} isn't reporting now — showing where it was last seen": "{id} לא מדווח עכשיו — מציג היכן נראה לאחרונה",
+  "{id} isn't reporting now — showing where it was at {time}": "{id} לא מדווח עכשיו — מציג היכן היה ב-{time}",
+  "This share link can't be opened": "לא ניתן לפתוח את קישור השיתוף הזה",
+  "Shared vessel is unavailable": "האונייה המשותפת אינה זמינה",
+  "ACQUIRING": "אוסף",
+  "SHARED {subject}": "{subject} משותף",
+  "subject": "עצם",
+  "LOADING LIVE DATA": "טוען נתונים חיים",
+  "LOAD COMPLETE": "הטעינה הושלמה",
+  "LOAD CANCELLED": "הטעינה בוטלה",
+  "LOAD FAILED": "הטעינה נכשלה",
+  "LIVE DATA OFF": "נתונים חיים כבויים",
+  "MAPPED SITES LOADED": "אתרים ממופים נטענו",
+  "RETRYING MAPPED SITES": "מנסה שוב אתרים ממופים",
+  "FETCHING MAPPED SITES": "שולף אתרים ממופים",
+  "RETRYING ALPR CAMERAS": "מנסה שוב מצלמות ALPR",
+  "FETCHING ALPR CAMERAS": "שולף מצלמות ALPR",
+  "OVERPASS TEMPORARILY UNAVAILABLE": "OVERPASS אינו זמין זמנית",
+  "OVERPASS RATE-LIMITED": "OVERPASS מוגבל בקצב",
+  "OVERPASS TIMED OUT": "OVERPASS חרג מהזמן הקצוב",
+  "OVERPASS COULD NOT COMPLETE THE QUERY": "OVERPASS לא השלים את השאילתה",
+  "MAP TILES TEMPORARILY UNAVAILABLE": "אריחי המפה אינם זמינים זמנית",
+  "MAPPED NAMES TEMPORARILY UNAVAILABLE": "השמות הממופים אינם זמינים זמנית",
+  "TURNING OFF LIVE DATA": "מכבה נתונים חיים",
+  "REFRESHING LIVE DATA": "מרענן נתונים חיים",
+  "syncing road network": "מסנכרן את רשת הכבישים",
+  "retry pending": "ניסיון חוזר בתור",
+  "retrying in {seconds}s": "מנסה שוב בעוד {seconds} שנ'",
+  "ALPR cameras": "מצלמות ALPR",
+  "OpenSky OAuth client missing/invalid": "לקוח ה-OAuth של OpenSky חסר או בלתי תקין",
+  "OpenSky OAuth rejected credentials": "אישורי ה-OAuth של OpenSky נדחו",
+  "OpenSky username/password rejected": "שם המשתמש/סיסמה של OpenSky נדחו",
+  "OpenSky auth missing": "חסר אימות OpenSky",
+  "OpenSky auth required": "נדרש אימות OpenSky",
+  "OpenSky auth invalid": "אימות OpenSky בלתי תקין",
+  "OpenSky auth failed": "אימות OpenSky נכשל",
+  "KartaView answered HTTP {status}": "KartaView השיב HTTP {status}",
+  "Panoramax answered HTTP {status}": "Panoramax השיב HTTP {status}",
+  "KartaView refused the request (code {code})": "KartaView סירב לבקשה (קוד {code})",
+  "Vector tiles unavailable (HTTP {status})": "אריחים וקטוריים אינם זמינים (HTTP {status})",
+  "GNSS feed unavailable (HTTP {status})": "פיד GNSS אינו זמין (HTTP {status})",
+  "{count} CelesTrak groups unavailable": {
+    "one": "{count} קבוצות CelesTrak אינן זמינות",
+    "two": "{count} קבוצות CelesTrak אינן זמינות",
+    "other": "{count} קבוצות CelesTrak אינן זמינות"
+  },
+  "{feed} feed unavailable": "הפיד {feed} אינו זמין",
+  "Source snapshot {minutes} min old": "תמונת המצב של המקור בת {minutes} דק",
+  "{source} rate limited (anonymous)": "{source} מוגבל בקצב (אנונימי)",
+  "{source} rate limited": "{source} מוגבל בקצב",
+  "{source} network error": "שגיאת רשת ב-{source}",
+  "Malformed {source} aircraft rows": "שורות המטוסים של {source} פגומות",
+  "Malformed {source} response": "תשובת {source} פגומה",
+  "rate limited": "מוגבל בקצב",
+  "routing service is rate limited": "שירות הניתוב מוגבל בקצב",
+  "route leg too long": "מקטע מסלול ארוך מדי",
+  "route too long": "המסלול ארוך מדי",
+  "routing busy — too many routes at once": "הניתוב עמוס — יותר מדי מסלולים בבת אחת",
+  "route proxy error": "שגיאת פרוקסי בניתוב",
+  "Routing unavailable (HTTP {status})": "הניתוב אינו זמין (HTTP {status})",
+  "Routing failed: {error}": "הניתוב נכשל: {error}",
+  "{error} — try again in a moment": "{error} — נסה שוב בעוד רגע",
+  "entry {n}": "פריט {n}",
+  "feeds {names} stale": {
+    "one": "הפידים {names} מיושנים",
+    "two": "הפידים {names} מיושנים",
+    "other": "הפידים {names} מיושנים"
+  },
+  "feeds {names} unreachable": {
+    "one": "הפידים {names} בלתי נגישים",
+    "two": "הפידים {names} בלתי נגישים",
+    "other": "הפידים {names} בלתי נגישים"
+  },
+  "feeds {names} invalid": {
+    "one": "הפידים {names} בלתי תקינים",
+    "two": "הפידים {names} בלתי תקינים",
+    "other": "הפידים {names} בלתי תקינים"
+  },
+  "Loading {feeds}": "טוען {feeds}",
+  "{count} heard": {
+    "one": "{count} נשמעו",
+    "two": "{count} נשמעו",
+    "other": "{count} נשמעו"
+  },
+  "USB {rate} msg/s": "USB {rate} הודעות/שנ",
+  "{rate} msg/s": "{rate} הודעות/שנ",
+  "{count} feeds live": {
+    "one": "{count} פידים חיים",
+    "two": "{count} פידים חיים",
+    "other": "{count} פידים חיים"
+  },
+  "{feed} {count} ({seconds}s old)": "{feed} {count} (בן {seconds} שנ)",
+  "Street Level toggle failed": "החלפת Street Level נכשלה",
+  "Street Level could not start": "Street Level לא הצליח להתחיל",
+  "ANY DATE": "תאריך כלשהו",
+  "LAST 10 YEARS": "10 השנים האחרונות",
+  "LAST 5 YEARS": "5 השנים האחרונות",
+  "LAST 3 YEARS": "3 השנים האחרונות",
+  "LAST 2 YEARS": "השנתיים האחרונות",
+  "LAST YEAR": "השנה האחרונה",
+  "LAST 6 MONTHS": "6 החודשים האחרונים",
+  "LAST 3 MONTHS": "3 החודשים האחרונים",
+  "LAST MONTH": "החודש האחרון",
+  "LAST {count} DAYS": {
+    "one": "{count} הימים האחרונים",
+    "two": "{count} הימים האחרונים",
+    "other": "{count} הימים האחרונים"
+  },
+  "{window} · SINCE {date}": "{window} · מאז {date}",
+  "Turn Street Level off": "כיבוי Street Level",
+  "Turn Street Level on": "הפעלת Street Level",
+  "{name} imagery on": "צילומי {name} פעילים",
+  "{name} imagery off": "צילומי {name} כבויים",
+  "Image by {creator}": "תמונה מאת {creator}",
+  " or ": " או ",
+  "OPEN {labels}": "פתח {labels}",
+  "Open {names} at the centre of the view": "פתח את {names} במרכז התצוגה",
+  "Zoom in to a street to open {names} here": "התקרב לרחוב כדי לפתוח את {names} כאן",
+  "Switch Street Level on to draw its coverage.": "הפעל Street Level כדי לצייר את כיסויו.",
+  "Every provider is switched off: light a chip to draw its coverage.": "כל הספקים כבויים: הדלק שבב כדי לצייר את כיסויו.",
+  "Loading this sequence…": "טוען את הרצף הזה…",
+  "{n} images in this sequence · Esc clears": {
+    "one": "{n} תמונות ברצף הזה · Esc מנקה",
+    "two": "{n} תמונות ברצף הזה · Esc מנקה",
+    "other": "{n} תמונות ברצף הזה · Esc מנקה"
+  },
+  "No sequences in view match the filter": "אין רצפים בתצוגה שתואמים את המסנן",
+  "No coverage in view": "אין כיסוי בתצוגה",
+  "{n} streets in view · click a line for its nearest photo": {
+    "one": "{n} רחובות בתצוגה · לחץ על קו לתמונתו הקרובה",
+    "two": "{n} רחובות בתצוגה · לחץ על קו לתמונתו הקרובה",
+    "other": "{n} רחובות בתצוגה · לחץ על קו לתמונתו הקרובה"
+  },
+  "{n} sequences in view · click a line for its nearest photo": {
+    "one": "{n} רצפים בתצוגה · לחץ על קו לתמונתו הקרובה",
+    "two": "{n} רצפים בתצוגה · לחץ על קו לתמונתו הקרובה",
+    "other": "{n} רצפים בתצוגה · לחץ על קו לתמונתו הקרובה"
+  },
+  "{n} sequences in view · click a line for its photos": {
+    "one": "{n} רצפים בתצוגה · לחץ על קו לתמונותיו",
+    "two": "{n} רצפים בתצוגה · לחץ על קו לתמונותיו",
+    "other": "{n} רצפים בתצוגה · לחץ על קו לתמונותיו"
+  },
+  "km/h": "km/h",
+  "m/s": "m/s",
+  "mph": "mph",
+  "hPa": "hPa",
+  "kt": "kt",
+  "kts": "kts",
+  "ft": "ft",
+  "km": "km",
+  "m": "m",
+  "h": "h",
+  "min": "min",
+  "s": "s",
+  "dB": "dB",
+  "Current cockpit vision style: {style}. Activate for next style.": "סגנון הראייה הנוכחי בתא הטייס: {style}. הפעל למעבר לסגנון הבא.",
+  "Current style: {style} — click for next": "הסגנון הנוכחי: {style} — לחץ לסגנון הבא",
+  "Aircraft cockpit view": "תצוגת תא הטייס",
+  "LEVEL": "LEVEL",
+  "Estimated destination direction": "הכיוון המוערך אל היעד",
+  "OPTICAL PLANE · 01": "מישור אופטי · 01",
+  "VISOR LOCK · ACTIVE": "ויזור נעול · פעיל",
+  "GROUND SPEED · KTS": "מהירות קרקע · KTS",
+  "ALTITUDE · FT": "גובה · FT",
+  "FIRST PERSON": "גוף ראשון",
+  "Cockpit vision style": "סגנון הראייה בתא הטייס",
+  "Previous cockpit vision style": "סגנון הראייה הקודם בתא הטייס",
+  "Previous vision style": "סגנון הראייה הקודם",
+  "PREV": "הקודם",
+  "CURRENT": "נוכחי",
+  "Next cockpit vision style": "סגנון הראייה הבא בתא הטייס",
+  "Next vision style": "סגנון הראייה הבא",
+  "Current aircraft heading": "כיוון המטוס הנוכחי",
+  "GROUND SPEED": "מהירות קרקע",
+  "KTS": "KTS",
+  "ALTITUDE": "גובה",
+  "FT": "FT",
+  "ESC EXIT": "יציאה ESC",
+  "C TOGGLE": "מקש C להחלפה",
+  "View switcher": "מחליף התצוגות",
+  "Resetting cockpit to full globe view": "מאפס את תא הטייס לתצוגת הגלובוס המלאה",
+  "Reset cockpit to full globe view": "איפוס תא הטייס אל תצוגת הגלובוס המלאה",
+  "Exit cockpit and return to full globe view": "יציאה מתא הטייס וחזרה אל תצוגת הגלובוס המלאה",
+  "RESET": "איפוס",
+  "Exit cockpit view": "יציאה מתצוגת תא הטייס",
+  "EXIT COCKPIT": "יציאה מתא הטייס",
+  "Navigation, voice, and visual preset controls": "פקדי ניווט, קול וערכות ראייה",
+  "VISUAL PRESETS": "ערכות ראייה",
+  "Expand Visual Presets": "הרחבת ערכות הראייה",
+  "Pin visual presets": "הצמדת ערכות הראייה",
+  "Keep visual presets open": "השארת ערכות הראייה פתוחות",
+  "Show the globe without a visual filter.": "הצגת הגלובוס ללא מסנן ראייה.",
+  "Emulate a green phosphor CRT with scanlines and screen curvature.": "הדמיית CRT פוספור ירוק עם קווי סריקה ועקמומיות מסך.",
+  "Simulate night-vision goggles with green intensification and a tube vignette.": "הדמיית משקפי ראיית לילה עם הבהרה ירוקה ווינייטת צינור.",
+  "Simulate FLIR-style thermal contrast. Turn up Ironbow for color.": "הדמיית ניגודיות תרמית דמוית FLIR. הגדל את Ironbow לצבע.",
+  "Apply bright cel-shaded color and illustrated outlines.": "החלת צבע מובלט בסגנון אנימציה וקווי מתאר מומחשים.",
+  "Apply high-contrast monochrome film-noir grading.": "החלת גיוון חד-צבעי ניגודי בסגנון פילם-נואר.",
+  "MAP SOURCE": "מקור מפה",
+  "Map source": "מקור מפה",
+  "Style": "סגנון",
+  "LOCATION": "מיקום",
+  "Expand LOCATION": "הרחבת מיקום",
+  "Collapse panel": "קיפול הפאנל",
+  "Pin location tray": "הצמדת מגש המיקום",
+  "Keep location tray open": "השארת מגש המיקום פתוח",
+  "Search any location": "חיפוש כל מקום",
+  "Search any location...": "חיפוש כל מקום...",
+  "Search location by name or coordinates": "חיפוש מקום לפי שם או קואורדינטות",
+  "Active weather products": "מוצרי מזג אוויר פעילים",
+  "Imagery days in the box": "ימי הצילומים בתיבה",
+  "Context mode": "מצב ההקשר",
+  "CONTACTS": "מגעים",
+  "Cycles the nearest contacts of whatever type you select — planes, vessels, installations. Satellites track independently.": "מחזר את המגעים הקרובים מהסוג שתבחר — מטוסים, אוניות, מתקנים. לוויינים נעקבים בנפרד.",
+  "SPACE MISSIONS": "משימות חלל",
+  "SELECT CONTEXT": "בחירת ההקשר",
+  "CONTACTS — nearest planes · vessels · sites": "מגעים — המטוסים הקרובים · אוניות · אתרים",
+  "SPACE MISSIONS — launches & orbital assets": "משימות חלל — שיגורים ונכסים במסלול",
+  "Contact Context actions": "פעולות הקשר של מגעים",
+  "SEARCH NEARBY SITES": "חיפוש אתרים סמוכים",
+  "Reclassify tracked contact as TR-3B": "סיווג מחדש של המגע הנעקב כ-TR-3B",
+  "Restore real aircraft": "שחזור המטוס האמיתי",
+  "Reclassify as TR-3B": "סיווג מחדש כ-TR-3B",
+  "Return UI controls": "החזרת פקדי הממשק",
+  "EXIT CLEAN VIEW": "יציאה מהתצוגה הנקייה",
+  "Directions, drawing and your own files": "דרכי הגעה, שרטוט והקבצים שלך",
+  "Create and edit scenes": "יצירה ועריכה של סצנות",
+  "SCENE": "סצנה",
+  "Scene": "סצנה",
+  "Start a new, empty scene": "התחלת סצנה חדשה וריקה",
+  "NEW SCENE": "סצנה חדשה",
+  "Delete this scene and all of its shots": "מחיקת סצנה זו וכל שוטיה",
+  "DELETE": "מחיקה",
+  "SHOTS": "שוטים",
+  "Add the current view, style and layers as the next shot": "הוספת התצוגה, הסגנון והשכבות הנוכחיים כשוט הבא",
+  "+ CAPTURE SHOT": "+ לכידת שוט",
+  "Replace the selected shot with the current view": "החלפת השוט הנבחר בתצוגה הנוכחית",
+  "UPDATE SHOT": "עדכון שוט",
+  "Click a shot to select it, double-click to rename.": "לחץ על שוט לבחירתו, לחיצה כפולה לשינוי שם.",
+  "Play from this scene through the rest of the project": "נגינה מהסצנה הזאת ועד סוף הפרויקט",
+  "Stop playback (Esc)": "עצירת ההשמעה (Esc)",
+  "STOP": "עצירה",
+  "Play the shot after the selected one, moving on to the next scene when needed": "ניגון השוט שאחרי הנבחר, עם מעבר לסצנה הבאה כשצריך",
+  "SAVE & SHARE": "שמירה ושיתוף",
+  "Download every scene as a JSON file you can import later": "הורדת כל סצנה כקובץ JSON לייבוא בהמשך",
+  "Load scenes from an exported JSON file": "טעינת סצנות מקובץ JSON שיוצא",
+  "IMPORT": "ייבוא",
+  "Download the timing log of the last play": "הורדת יומן התזמון של הנגינה האחרונה",
+  "RUN LOG": "יומן הריצה",
+  "Edit anchors, data packs and shot details": "עריכת עוגנים, חבילות נתונים ופרטי שוט",
+  "EDIT DETAILS": "עריכת פרטים",
+  "Download this scene as JSON or an asset bundle": "הורדת סצנה זו כ-JSON או כחבילת נכסים",
+  "SHARE SCENE": "שיתוף הסצנה",
+  "The Google Maps key buys the photorealistic planet — everything else stacks on top.": "מפתח Google Maps קונה את כוכב הלכת הפוטוריאליסטי — כל היתר נבנה עליו.",
+  "Remove {title} from this app's saved keys": "הסרת {title} מהמפתחות השמורים של האפליקציה",
+  "POWER UP": "אתחול",
+  "GROUND STATION · PROVIDER SETTINGS": "תחנת קרקע · הגדרות ספקים",
+  "Close key setup": "סגירת הגדרת המפתח",
+  "Power up the globe": "אתחול הגלובוס",
+  "The globe already flies keyless. Every key below switches on another real feed — paste one and it's saved into this app's local configuration, then the server restarts itself. Server-side keys stay on this machine; Google Maps and Cesium ion run in the browser and must be provider-restricted. Keys you configured elsewhere are shown but never touched.": "הגלובוס כבר עף ללא מפתחות. לכל מפתח להלן הזנה אמיתית נוספת — הדבק אחד והוא נשמר לתצורה המקומית של האפליקציה, ואז השרת מאתחל את עצמו. מפתחות של שרת נשארים במכונה הזאת; Google Maps ו-Cesium ion רצים בדפדפן וחייבים הגבלה אצל הספק. מפתחות שהגדרת במקום אחר מוצגים אך לא נעולים.",
+  "This key runs in the browser by design — restrict it at the provider (see SECURITY.md)": "מפתח זה רץ בדפדפן מתוך תכנון — הגבל אותו אצל הספק (ראה SECURITY.md)",
+  "browser-side": "בצד הדפדפן",
+  "Supplied by your environment, Keychain, or launcher — change it where it was set": "מסופק על ידי הסביבה, ה-Keychain או מריץ ההפעלה — שנה אותו במקום שבו הוגדר",
+  "configured externally": "מוגדר במקום אחר",
+  "MANAGE ↗": "ניהול ↗",
+  "GET KEY ↗": "השגת מפתח ↗",
+  "{envVar} saved — paste to replace": "נשמר {envVar} — הדבק כדי להחליף",
+  "paste {envVar}": "הדבקת {envVar}",
+  "REMOVE": "הסרה",
+  "VOICE AUTH · CHATGPT OAUTH": "אימות קול · CHATGPT OAUTH",
+  "VOICE AUTH · API KEY": "אימות קול · מפתח API",
+  "Use OPENAI_API_KEY for the next cloud voice session": "שימוש ב-OPENAI_API_KEY להפעלת הקול בענן הבאה",
+  "Use the signed-in local ChatGPT/Codex OAuth session for the next cloud voice session": "שימוש בהפעלת ה-OAuth המקומית המחוברת של ChatGPT/Codex להפעלת הקול בענן הבאה",
+  "USE API KEY": "שימוש במפתח API",
+  "SAVE KEYS": "שמירת מפתחות",
+  "ESC to close": "Esc לסגירה",
+  "Visible map targets": "היעדים הגלויים במפה",
+  "NO PLACE LEFT BEHIND": "בלי מקום שנשאר מאחור",
+  "Rendered globe frames per second · toggle with `": "פריימי גלובוס לשנייה · החלפה עם `",
+  "ACTIVE STYLE": "הסגנון הפעיל",
+  "ORBIT": "הקפה",
+  "No shots yet. Use CAPTURE SHOT to save current look.": "אין עדיין שוטים. השתמש בלכידת שוט כדי לשמור את המראה הנוכחי.",
+  "Double-click to rename": "לחיצה כפולה לשינוי שם",
+  "Shot name": "שם השוט",
+  "LOAD": "טעינה",
+  "DEL": "מחיקה",
+  "MISSION CONTROL · FIRST LAUNCH": "חדר בקרה · שיגור ראשון",
+  "Choose your first view": "בחירת התצוגה הראשונה",
+  "LIVE CONTACTS": "מגעים חיים",
+  "Aircraft, vessels and nearby intelligence": "מטוסים, אוניות ומודיעין סמוך",
+  "Launches, spacecraft and orbital context": "שיגורים, חלליות והקשר המסלולי",
+  "EXPLORE MANUALLY": "חקירה ידנית",
+  "Begin with a clean globe": "התחלה מגלובוס נקי",
+  "Don't show this again": "אל תציג זאת שוב",
+  "ESC to dismiss": "Esc להסתרה",
+  "DISMISS": "הסתרה",
+  "CONTACTS CONTEXT OFF": "הקשר המגעים כבוי",
+  "SELECT CONTACTS TO LOAD OBSERVED / MAPPED PROXIMITY": "בחר מגעים לטעינת קרבה נצפית / ממופה",
+  "Bhote Koshi flood reconstruction controls": "פקדי שחזור השיטפון ב-Bhote Koshi",
+  "EVENT RECONSTRUCTION · 26 AUG 2026": "שחזור האירוע · 26.08.2026",
+  "BHOTE KOSHI OUTBURST FLOOD": "שיטפון ההתפרצות ב-Bhote Koshi",
+  "Close event layer": "סגירת שכבת האירוע",
+  "OBSERVED IMAGERY": "צילומים נצפים",
+  "SCHEMATIC CORRIDOR": "מסדרון סכמטי",
+  "2021 HISTORICAL REFERENCE / 2026 POST-EVENT": "מקור היסטורי 2021 / אחרי האירוע 2026",
+  "Historical reference and post-event image split": "הפיצול בין תמונת המקור ההיסטורי לתמונה שאחרי האירוע",
+  "Story beat navigation": "ניווט קטעי הסיפור",
+  "Play the next shot and continue through this scene": "נגינת השוט הבא והמשך לאורך הסצנה הזאת",
+  "↗ OPEN ORIGINAL": "↗ פתח את המקור",
+  "⌖ LOWER GORGE": "⌖ הקניון התחתון",
+  "FIELD REPORTS · {count}": "דוחות שטח · {count}",
+  "GEOLOCATIONS · {credit}": "מיקומים גיאוגרפיים · {credit}",
+  "↗ OPEN PUBLIC MAP": "↗ פתח מפה ציבורית",
+  " Clouds are preserved from the source imagery.": " העננים נשמרו מצילומי המקור.",
+  "ACQUIRING FRAME": "אוסף שקופית",
+  "CCTV ON": "CCTV פעיל",
+  "CCTV OFF": "CCTV כבוי",
+  "NEAREST": "הקרוב",
+  "CCTV camera": "מצלמת CCTV",
+  "CALIBRATION": "כיול",
+  "Drag the camera in the world: rings rotate, arrows move, handles set range/FOV": "גרור את המצלמה בעולם: טבעות מסובבות, חצים מזיזים, נקודות אחיזה קובעות טווח/FOV",
+  "Camera pose — click a value to type": "מצב המצלמה — לחץ על ערך להקלדה",
+  "Heading (compass °) — click to type": "כיוון (מעלות מצפן) — לחץ להקלדה",
+  "Pitch (° up/down) — click to type": "הטיה (° למעלה/למטה) — לחץ להקלדה",
+  "Horizontal FOV (°) — click to type": "FOV אופקי (°) — לחץ להקלדה",
+  "Range / monitor-plane distance (m) — click to type": "טווח / מרחק למישור המוניטור (מ׳) — לחץ להקלדה",
+  "Mount height above ground (m) — click to type": "גובה ההרכבה מעל הקרקע (מ׳) — לחץ להקלדה",
+  "North offset from catalog position (m) — click to type": "היסט צפונה ממיקום הקטלוג (מ׳) — לחץ להקלדה",
+  "East offset from catalog position (m) — click to type": "היסט מזרחה ממיקום הקטלוג (מ׳) — לחץ להקלדה",
+  "SAVE CAL": "שמירת כיול",
+  "RESET CAL": "איפוס כיול",
+  "SCENE SUMMARY": "סיכום הסצנה",
+  "Fly to Tokyo": "עיפה אל טוקיו",
+  "Show live flights": "הצגת טיסות חיות",
+  "AI chat": "צ׳אט AI",
+  "GEV CHAT": "צ׳אט GEV",
+  "Ask about the map. Tell it where to go.": "שאל על המפה. הגד לה לאן ללכת.",
+  "Settings": "הגדרות",
+  "Close chat": "סגירת הצ׳אט",
+  "Conversation": "שיחה",
+  "Explore with a question": "חקור באמצעות שאלה",
+  "Find a place, explore live data, or change your view.": "מצא מקום, חקור נתונים חיים, או שנה את תצוגתך.",
+  "YOU": "אתה",
+  "Attachments": "קבצים מצורפים",
+  "Remove attachment": "הסרת קובץ מצורף",
+  "Attach a map layer": "צירוף שכבת מפה",
+  "Choose a layer…": "בחר שכבה…",
+  "Attach layer": "צירוף שכבה",
+  "Attach a file": "צירוף קובץ",
+  "TXT, Markdown, CSV, JSON or GeoJSON · up to 10 KB in total. Attachments are sent to your AI provider with your message.": "TXT, Markdown, CSV, JSON או GeoJSON · עד 10 ק\"ב בסך הכול. הקבצים המצורפים נשלחים לספק ה-AI שלך עם ההודעה.",
+  "Latest AI response": "התשובה האחרונה מה-AI",
+  "Expand conversation": "הרחבת השיחה",
+  "Command suggestions": "הצעות פקודות",
+  "Expand chat": "הרחבת הצ׳אט",
+  "Add attachment": "הוספת קובץ מצורף",
+  "Message GEV": "כתוב אל GEV",
+  "Ask GEV anything about the map…": "שאל את GEV כל דבר על המפה…",
+  "Stop reply": "עצירת תשובה",
+  "Send message": "שליחת הודעה",
+  "Cockpit briefing carousel": "קרוסלת דיווחי תא הטייס",
+  "Cockpit briefing controls": "פקדי דיווחי תא הטייס",
+  "Previous briefing page": "עמוד הדיווח הקודם",
+  "Next briefing page": "עמוד הדיווח הבא",
+  "Expand cockpit briefing panel": "הרחבת פאנל דיווחי תא הטייס",
+  "Collapse cockpit briefing panel": "קיפול פאנל דיווחי תא הטייס",
+  "Expand briefing panel": "הרחבת פאנל הדיווח",
+  "Collapse briefing panel": "קיפול פאנל הדיווח",
+  "Live signals": "אותות חיים",
+  "Latest regional news": "חדשות אזוריות אחרונות",
+  "Location-based information": "מידע לפי מקום",
+  "TEMP": "טמפ",
+  "WIND": "רוח",
+  "SKY": "שמיים",
+  "PRECIP": "משקעים",
+  "MM": "מ״מ",
+  "Weather data by Open-Meteo.com": "נתוני מזג אוויר מאת Open-Meteo.com",
+  "Cockpit briefing pages": "עמודי הדיווח של תא הטייס",
+  "Show Live Signals": "הצגת אותות חיים",
+  "SIG": "אות",
+  "Show Regional News": "הצגת חדשות אזוריות",
+  "NEWS": "חדשות",
+  "Show Local Info": "הצגת מידע מקומי",
+  "LOCAL": "מקומי",
+  "Disable cockpit weather effects": "כיבוי אפקטי מזג האוויר של תא הטייס",
+  "Enable cockpit weather effects": "הפעלת אפקטי מזג האוויר של תא הטייס",
+  "Contact cockpit summary": "סיכום מגע בתא הטייס",
+  "CONTACT": "מגע",
+  "Contact navigation": "ניווט המגע",
+  "Expand Contact panel": "הרחבת פאנל המגע",
+  "Collapse Contact panel": "קיפול פאנל המגע",
+  "Expand contact panel": "הרחבת פאנל המגע",
+  "Collapse contact panel": "קיפול פאנל המגע",
+  "CONTEXT ONLY": "הקשר בלבד",
+  "Nearby cohort counts": "מניין הקבוצות הסמוכות",
+  "FLT": "FLT",
+  "MIL": "MIL",
+  "SITE": "אתר",
+  "NEAREST OBSERVED / MAPPED": "הנצפים / הממופים הקרובים",
+  "WX": "WX",
+  "Estimated flight plan": "תכנון הטיסה המשוער",
+  "ESTIMATED FLIGHT PLAN": "תוכנית טיסה משוערת",
+  "FROM": "מ-",
+  "TO": "אל",
+  "Collapse Cockpit display options": "קיפול אפשרויות התצוגה של תא הטייס",
+  "Expand Cockpit display options": "הרחבת אפשרויות התצוגה של תא הטייס",
+  "Collapse Cockpit Radio controls": "קיפול פקדי הרדיו של תא הטייס",
+  "Expand Cockpit Radio controls": "הרחבת פקדי הרדיו של תא הטייס",
+  "Cockpit display and Radio controls": "פקדי התצוגה והרדיו של תא הטייס",
+  "Cockpit display options": "אפשרויות תצוגה בתא הטייס",
+  "RADIO": "רדיו",
+  "Cockpit compact Radio controls": "פקדי רדיו קומפקטיים בתא הטייס",
+  "Previous filtered radio station": "התחנה הקודמת לפי המסנן",
+  "Play selected radio station": "נגינת התחנה הנבחרת",
+  "Next filtered radio station": "התחנה הבאה לפי המסנן",
+  "VOLUME": "עוצמה",
+  "Cockpit Radio volume": "עוצמת הרדיו בתא הטייס",
+  "Source": "מקור",
+  "Celestial ring — available in Normal style": "הטבעת השמיימית — זמינה בסגנון הרגיל",
+  "Celestial ring — reveal the full globe": "הטבעת השמיימית — חשיפת הגלובוס המלא",
+  "Proximity": "קרבה",
+  "All": "הכול",
+  "Elastic": "גמישה",
+  "Weighted": "משוקללת",
+  "Intelligence HUD (H)": "HUD מודיעין (H)",
+  "Layout": "פריסה",
+  "HUD layout": "פריסת ה-HUD",
+  "Tactical": "טקטי",
+  "Minimal": "מינימלי",
+  "Cyber": "סייבר",
+  "Sonar": "סונאר",
+  "Cyber sonar contact scanner": "סורק הסונאר הסייברי למגעים",
+  "Rings": "טבעות",
+  "Sonar ring count": "מניין טבעות הסונאר",
+  "Range": "טווח",
+  "Sonar ring range": "טווח הטבעות של הסונאר",
+  "Power": "עוצמה",
+  "Sonar intensity": "עצמת הסונאר",
+  "Opacity": "אטימות",
+  "Cyber contact and label opacity": "אטימות המגעים והתוויות הסייבריים",
+  "Minimum opacity for map dots, icons, models, brackets, and labels between sonar passes": "האטימות המזערית לנקודות המפה, סמלים, דגמים, סוגריים ותוויות בין מעברי הסונאר",
+  "Sector": "סקטור",
+  "Sonar sector width": "רוחב סקטור הסונאר",
+  "Detection Overlay (D)": "שכבת הזיהוי (D)",
+  "Detection overlay": "שכבת הזיהוי",
+  "DETECT": "זיהוי",
+  "Density": "צפיפות",
+  "Detection label density": "צפיפות תוויות הזיהוי",
+  "Allocation": "חלוקת המכסה",
+  "Detection label allocation": "חלוקת המכסה לתוויות הזיהוי",
+  "Fade": "התפוגגות",
+  "Detection fade distance": "מרחק התפוגגות הזיהוי",
+  "World-overlay fade distance outside the keyhole as a percentage of its radius": "מרחק התפוגגות שכבות העולם מחוץ לחור המנעול, כאחוז מרדיוסו",
+  "Outside": "מחוץ",
+  "Detection opacity outside the keyhole": "אטימות הזיהוי מחוץ לחור המנעול",
+  "World-overlay label and card opacity beyond the fade distance": "אטימות התוויות והכרטיסים של שכבות העולם מעבר למרחק ההתפוגגות",
+  "PARAMETERS": "פרמטרים",
+  "3D aircraft — flat icons zoomed out, 3D models up close": "מטוסים תלת-הממדיים — סמלים שטוחים בזום החוצה, דגמים תלת-הממדיים מקרוב",
+  "Models": "דגמים",
+  "3D model coverage": "כיסוי דגמים תלת-הממדיים",
+  "Scope — the circular viewport mask": "סקופ — מסכת התצוגה העגולה",
+  "Scope": "סקופ",
+  "Feather": "ריכוך",
+  "Scope edge feather": "ריכוך שפת הסקופ",
+  "Scope edge feather as a percentage of the keyhole radius": "ריכוך שפת הסקופ כאחוז מרדיוס חור המנעול",
+  "Celestial": "שמיימי",
+  "Hide UI chrome": "הסתרת מסגרת הממשק",
+  "Clean UI": "ממשק נקי",
+  "Bloom / Glow": "זוהר",
+  "Bloom intensity": "עוצמת הזוהר",
+  "Sharpening": "חידוד",
+  "Sharpen": "חידוד",
+  "Sharpen intensity": "עוצמת החידוד",
+  "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "שרטוט על העולם — לחץ על קודקודים, לחיצה כפולה או Enter לסיום, Esc לביטול",
+  "Shape to draw": "הצורה לשרטוט",
+  "Colour of the next shape": "הצבע של הצורה הבאה",
+  "Remove every mark from the board": "הסרת כל סימן מהלוח",
+  "Clear": "ניקוי",
+  "Drawn shapes": "צורות ששורטטו",
+  "Show your own GeoJSON, KML, KMZ or GPX files on the globe (or drop them onto it). File bytes stay on this device; overlays can appear in map screenshots shared with voice.": "הצגת קבצי GeoJSON, KML, KMZ או GPX משלך על הגלובוס (או גרירתם אליו). בתי הקבצים נשארים במכשיר הזה; שכבות-על עשויות להופיע בצילומי מסך המשותפים עם הקול.",
+  "Import": "ייבוא",
+  "Choose GeoJSON, KML, KMZ or GPX files": "בחירת קבצי GeoJSON, KML, KMZ או GPX",
+  "Imported files": "קבצים שיובאו",
+  "Globe actions": "פעולות גלובוס",
+  "Turn off all selected data layers": "כיבוי כל שכבות הנתונים הנבחרות",
+  "Copy share link": "העתקת קישור השיתוף",
+  "Return map to straight-down view": "החזרת המפה לתצוגה ישרה מלמעלה",
+  "Tilt map to oblique view": "הטיית המפה לתצוגה אלכסונית",
+  "Toggle straight-down and tilted map views": "החלפה בין תצוגה ישרה מלמעלה ותצוגה מוטה",
+  "Resetting to full globe view": "מאפס לתצוגת הגלובוס המלאה",
+  "Reset to full globe view": "איפוס לתצוגת הגלובוס המלאה",
+  "Reset camera and return to full globe view": "איפוס המצלמה וחזרה לתצוגת הגלובוס המלאה",
+  "Reset map to north up": "איפוס המפה אל צפון מעלה",
+  "Reset map to north up. Current heading {heading} degrees": "איפוס המפה אל צפון מעלה. הכיוון הנוכחי {heading} מעלות",
+  "Reset map bearing to north": "איפוס כיוון המפה לצפון",
+  "Language: {language}": "שפה: {language}",
+  "Change the interface language": "שינוי שפת הממשק",
+  "Interface language": "שפת הממשק",
+  "Search languages": "חיפוש שפות",
+  "No matching languages": "אין שפות תואמות",
+  "Selected Space Mission": "משימת החלל הנבחרת",
+  "SELECTED SPACE MISSION": "משימת החלל הנבחרת",
+  "Show all missions": "הצגת כל המשימות",
+  "Deselect mission": "ביטול בחירת המשימה",
+  "MISSION": "משימה",
+  "STATUS · ": "מצב · ",
+  "LAUNCH SITE · ": "אתר שיגור · ",
+  "LAUNCH TIME · ": "זמן שיגור · ",
+  "ORBIT · ": "מסלול · ",
+  "ASCENT PATH · ": "מסלול עלייה · ",
+  "CURRENT DISTANCE FROM EARTH · ": "המרחק הנוכחי מכדור הארץ · ",
+  "SATELLITE SPEED · ": "מהירות הלוויין · ",
+  "PAYLOAD": "מטען",
+  "NAME": "שם",
+  "TYPE": "סוג",
+  "DESTINATION": "יעד",
+  "PAYLOAD DATA UNAVAILABLE": "נתוני המטען אינם זמינים",
+  "STAGE / RE-ENTRY / RECOVERY": "שלב / חדירה / שחזור",
+  "STAGE": "שלב",
+  "STATUS": "מצב",
+  "FINAL POSITION": "המיקום הסופי",
+  "NO STAGE RE-ENTRY / RECOVERY DATA": "אין נתוני חדירה / שחזור שלב",
+  "REPLAY SPEED": "מהירות ההצגה החוזרת",
+  "Replay speed multiplier": "מכפיל מהירות ההצגה החוזרת",
+  "Replay the estimated ascent with a following camera": "הצגת העלייה המשוערת שוב, עם מצלמה עוקבת",
+  "REPLAY ASCENT": "הצגת העלייה שוב",
+  "Cancel replay": "ביטול ההצגה החוזרת",
+  "Previous mission": "המשימה הקודמת",
+  "Next mission": "המשימה הבאה",
+  "SHOW ALL / DESELECT": "הצגת הכול / ביטול הבחירה",
+  "Available Space Missions": "משימות החלל הזמינות",
+  "AVAILABLE MISSIONS": "המשימות הזמינות",
+  "SELECT A MISSION TO INSPECT": "בחר משימה לבחינה",
+  "LOADING 30-DAY MISSION INDEX": "טוען את מפתח המשימות ל-30 יום",
+  "TAB PREVIEWS · ENTER / SPACE SELECTS": "TAB מראה פרצים · Enter / מקש הרווח בוחר",
+  "Panel position": "מקום הפאנל",
+  "Move above the dock": "מעבר מעל העגינה",
+  "Dock to the right": "עגינה מימין",
+  "Expand panel": "הרחבת הפאנל",
+  "Minimize panel": "מזעור הפאנל",
+  "Panels": "פאנלים",
+  "Expand Radio section": "הרחבת מדור הרדיו",
+  "Collapse Radio section": "קיפול מדור הרדיו",
+  "Expand Radio": "הרחבת הרדיו",
+  "Collapse Radio": "קיפול הרדיו",
+  "Internet radio and local SDR": "רדיו אינטרנט ו-SDR מקומי",
+  "STATION TAG": "תגי תחנה",
+  "Filter stations by station tag": "סינון תחנות לפי תגית התחנה",
+  "Enable Radio, then choose a globe marker or use next.": "הפעל את הרדיו, ואז בחר סמן על הגלובוס או השתמש בהבא.",
+  "Radio playback": "נגינת הרדיו",
+  "Previous filtered station": "התחנה הקודמת לפי המסנן",
+  "Play selected station": "נגינת התחנה הנבחרת",
+  "Next filtered station": "התחנה הבאה לפי המסנן",
+  "Stop radio playback": "עצירת נגינת הרדיו",
+  "Radio volume": "עוצמת רדיו",
+  "STATION SITE": "אתר התחנה",
+  "DIRECTORY: RADIO BROWSER": "מדריך: RADIO BROWSER",
+  "Audio connects directly to the broadcaster when you press play, choose a station on the globe or ask voice to play. Your IP is visible to that broadcaster.": "השמע מתחבר ישירות למשדר כשלוחצים על נגן, בוחרים תחנה בגלובוס או מבקשים בקול לנגן. ה-IP שלך גלוי למשדר הזה.",
+  "DRAG TO TUNE": "גרירה לכיוון",
+  "Tune available internet radio stations": "כוונון תחנות הרדיו הזמינות באינטרנט",
+  "ALL · DRAG THE NEEDLE": "הכול · גרור את המחט",
+  "SNAPS TO AVAILABLE STATIONS": "נצמד לתחנות הזמינות",
+  "{count} files selected": {
+    "one": "נבחרו {count} קבצים",
+    "two": "נבחרו {count} קבצים",
+    "other": "נבחרו {count} קבצים"
+  },
+  "No file chosen": "לא נבחר קובץ",
+  "Choose files": "בחירת קבצים",
+  "Scene actions": "פעולות סצנה",
+  "Local RTL-SDR receiver": "מקלט RTL-SDR מקומי",
+  "LOCAL RTL-SDR": "RTL-SDR מקומי",
+  "Chrome/Edge · WebUSB · one local tuner shared by FM and the Local ADS-B layer.": "Chrome/Edge · WebUSB · מכוון מקומי אחד המשותף ל-FM ולשכבת Local ADS-B.",
+  "Use your location for faster ADS-B position decoding": "שימוש במיקומך לפענוח מהיר יותר של מיקומי ADS-B",
+  "Choose a different RTL-SDR or receiver channel": "בחירת RTL-SDR או ערוץ מקלט אחר",
+  "CHANGE DEVICE": "החלפת מכשיר",
+  "RTL-SDR receiver mode": "מצב מקלן ה-RTL-SDR",
+  "GAIN": "הגברה",
+  "RTL-SDR tuner gain for the current mode": "הגברת מכוון ה-RTL-SDR למצב הנוכחי",
+  "AUTO": "אוטומטי",
+  "MSG/S": "MSG/S",
+  "HEARD": "נשמעו",
+  "POSITIONED": "הוגדר מקום",
+  "FM MHZ": "FM MHZ",
+  "TUNE": "כוונון",
+  "Seek broadcast FM stations": "חיפוש תחנות FM שידוריות",
+  "◀ SEEK": "◀ חיפוש",
+  "SEEK ▶": "חיפוש ▶",
+  "SDR VOL": "עוצמת SDR",
+  "Local SDR volume": "עוצמת ה-SDR המקומי",
+  "Turn Street Level on or off": "הפעלה או כיבוי של Street Level",
+  "FIT": "התאמה",
+  "Fit: show the whole photo, with dark bars where its shape differs from the frame": "התאמה: הצגת התמונה המלאה, בפסים כהים היכן שיחס הצורה שלה שונה מהמסגרת",
+  "FILL": "מילוי",
+  "Fill: fill the frame edge to edge, cropping the photo": "מילוי: מילוי המסגרת מקצה לקצה, תוך חיתוך התמונה",
+  "FLAT": "שטוחה",
+  "Shrink": "כיווץ",
+  "Expand": "הרחבה",
+  "Show the street-level view full screen (Esc shrinks it)": "הצגת תצוגת הרחוב במסך מלא (Esc מכווץ אותה)",
+  "SHRINK": "כיווץ",
+  "EXPAND": "הרחבה",
+  "Image fit": "התאמת התמונה",
+  "Close the image and deselect it on the map": "סגירת התמונה וביטול בחירתה במפה",
+  "Close the street-level image": "סגירת תמונת הרחוב",
+  "Street-level viewer": "מציג תמונות הרחוב",
+  "Open this image on the provider's site": "פתיחת התמונה באתר הספק",
+  "Imagery providers": "ספקי הצילומים",
+  "PROVIDERS": "ספקים",
+  "Imagery filters": "מסנני צילומים",
+  "IMAGERY": "צילומים",
+  "Panorama filter": "מסנן פנורמות",
+  "SINCE": "מאז",
+  "Voice assistant": "עוזר הקול",
+  "VOICE": "קול",
+  "Dismiss voice card": "הסתרת כרטיס הקול",
+  "Plan": "תוכנית",
+  "Referenced items": "הפריטים המוזכרים",
+  "NOTES & SOURCES": "הערות ומקורות",
+  "Voice provider": "ספק הקול",
+  "AI AGENT": "סוכן AI",
+  "Open AI chat": "פתיחת צ׳אט ה-AI",
+  "CHAT": "צ׳אט",
+  "VOICE CONTROL": "שליטה קולית",
+  "Voice Settings": "הגדרות הקול",
+  "Back to chat": "חזרה לצ׳אט",
+  "Back to voice": "חזרה לקול",
+  "Preview": "תצוגה מקדימה",
+  "Close voice panel": "סגירת פאנל הקול",
+  "Latest voice exchange": "חילופי הקול האחרונים",
+  "Try saying": "נסה לומר",
+  "What am I looking at?": "מה עיני רואות?",
+  "AI Provider": "ספק AI",
+  "The selected AI provider is shared by voice and chat.": "ספק ה-AI הנבחר משותף לקול ולצ׳אט.",
+  "Show quick commands": "הצגת פקודות מהירות",
+  "Chat replies are silent. No microphone access is needed.": "תשובות הצ׳אט שקטות. אין צורך בגישה למיקרופון.",
+  "Show Voice Preview": "הצגת תצוגה מקדימה לקול",
+  "Voice inactivity timeout": "תם זמן המנוחה של הקול",
+  "Custom": "מותאם",
+  "Minutes": "דקות",
+  "Voice model tier — applies next session": "דרגת מודל הקול — חלה מההפעלה הבאה",
+  "Estimated session cost": "העלות המוערכת של ההפעלה",
+  "Chat": "צ׳אט",
+  "voice|ERROR": "שגיאה",
+  "VOICE SYSTEM ERROR": "שגיאה במערכת הקול",
+  "Check microphone permission and network access, then try again.": "בדוק הרשאת המיקרופון וגישת הרשת, ואז נסה שוב.",
+  "seen {age} ago": "נראה לפני {age}",
+  "observed {age} ago": "נצפה לפני {age}",
+  "Reported by {name} ({entity})": "דווח על ידי {name} ({entity})",
+  "Reported by {name}": "דווח על ידי {name}",
+  "Open {name} on Acartia": "פתיחת {name} ב-Acartia",
+  "Open {name} on iNaturalist": "פתיחת {name} ב-iNaturalist",
+  "Close sighting": "סגירת התצפית",
+  "Loading photo...": "טוען תמונה...",
+  "Photo unavailable": "התמונה אינה זמינה",
+  "Photo of {name}": "תמונה של {name}",
+  "Location obscured to a 0.2° cell": "המיקום מטושטש לתא של 0.2°",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "Salish Sea": "Salish Sea",
+  "iNaturalist": "iNaturalist",
+  "Be Whale Wise": "Be Whale Wise",
+  "Detection overlay: {mode}": "שכבת הזיהוי: {mode}",
+  "Detection overlay: off": "שכבת הזיהוי: כבויה",
+  "Active weather": "מזג אוויר פעיל",
+  "{time} · {minutes} min ago": "{time} · לפני {minutes} דק",
+  "LATEST · newest per product": "האחרון · החדש ביותר לכל מוצר",
+  "Forecast · valid {valid} · issued {issued}": "חזוי · תקף {valid} · פורסם {issued}",
+  "{detail} · Does not follow history": "{detail} · אינו נע עם ההיסטוריה",
+  "Forecast · valid {valid}": "חזוי · תקף {valid}",
+  "You can attach up to four items.": "ניתן לצרף עד ארבעה פריטים.",
+  "Attachments are too large together. Use smaller files.": "הקבצים המצורפים גדולים יחד. השתמש בקבצים קטנים יותר.",
+  "Choose a TXT, Markdown, CSV, JSON or GeoJSON file.": "בחר קובץ TXT, Markdown, CSV, JSON או GeoJSON.",
+  "Each file must be 10 KB or smaller.": "כל קובץ חייב להיות בן 10 ק\"ב לכל היותר.",
+  "Choose a non-empty UTF-8 text file.": "בחר קובץ טקסט UTF-8 לא ריק.",
+  "Connecting…": "מתחבר…",
+  "Thinking…": "חושב…",
+  "voice|LISTENING": "מקשיב",
+  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "צ׳אט בהקלדה משתמש במפתח ה-OpenAI API שלך. התחברות ChatGPT מכסה קול בלבד.",
+  "Working on the map…": "עובד על המפה…",
+  "Silent chat · microphone off": "צ׳אט שקט · מיקרופון כבוי",
+  "Reply interrupted. You can try again.": "התשובה הופסקה. אפשר לנסות שוב.",
+  "Could not connect. Try again.": "לא ניתן היה להתחבר. נסה שוב.",
+  "Session ended. Send a message to start a new conversation.": "ההפעלה הסתיימה. שלח הודעה כדי להתחיל שיחה חדשה.",
+  "Connection timed out. Try again.": "החיבור חרג מהזמן הקצוב. נסה שוב.",
+  "Chat closed.": "הצ׳אט נסגר.",
+  "Connection stopped.": "החיבור הופסק.",
+  "Message and attachments are too large. Remove an attachment or shorten your message.": "ההודעה והקבצים המצורפים גדולים יחד. הסר קובץ מצורף או קצר את ההודעה.",
+  "Message was not sent. Try again.": "ההודעה לא נשלחה. נסה שוב.",
+  "Reply stopped.": "התשובה נעצרה.",
+  "Reset to globe view": "איפוס לתצוגת הגלובוס",
+  "Show earthquakes": "הצגת רעידות האדמה",
+  "Suggestions": "הצעות",
+  "Recent": "אחרונים",
+  "Quick commands": "פקודות מהירות",
+  "voice|OFF": "כבוי",
+  "voice|CONNECTING": "מתחבר",
+  "voice|EXECUTING": "מבצע",
+  "THIS": "זה",
+  "Changing provider reconnects voice if it is on.": "החלפת הספק מחברת מחדש את הקול אם הוא פעיל.",
+  "STD": "רגיל",
+  "Voice control — activate to toggle voice; hold Space to speak": "שליטה קולית — הפעל להחלפת קול; החזק Space כדי לדבר",
+  "ON/OFF": "פעיל/כבוי",
+  "VOICE STANDBY": "הקול בהמתנה",
+  "Hold Space to speak · tap Space to activate focused controls": "החזק Space לדיבור · הקש Space להפעלת הפקדים במוקד",
+  "Voice replies appear here.": "תשובות הקול מופיעות כאן.",
+  "These preferences stay in this browser.": "העדפות אלה נשארות בדפדפן הזה.",
+  "Gemini returned an oversized audio chunk": "Gemini החזיר מקטע שמע עצום",
+  "Gemini returned an unsupported audio format": "Gemini החזיר תבנית שמע שאינה נתמכת",
+  "Gemini returned an invalid audio sample rate": "Gemini החזיר קצב דגימת שמע בלתי תקין",
+  "Gemini returned incomplete PCM audio": "Gemini החזיר שמע PCM שאינו שלם",
+  "This browser does not support Gemini microphone audio": "הדפדפן הזה אינו תומך בשמע המיקרופון של Gemini",
+  "Microphone audio processing failed": "עיבוד שמע המיקרופון נכשל",
+  "Gemini audio playback fell behind. Reconnect to continue.": "השמעת האודיו של Gemini נשארה מאחור. חבר מחדש כדי להמשיך.",
+  "Gemini token response did not include an ephemeral credential": "תשובת האסימון של Gemini לא כללה פרטי גישה זנים",
+  "Invalid Gemini connection endpoint": "נקודת החיבור של Gemini בלתי תקינה",
+  "Gemini voice could not connect. Try again.": "הקול של Gemini לא הצליח להתחבר. נסה שוב.",
+  "Gemini voice requires a same-origin app request": "הקול של Gemini דורש בקשה ממקור אחיד",
+  "Add a Gemini API key in Provider Settings": "הוסף מפתח Gemini API בהגדרות הספקים",
+  "The Gemini Live model configuration is invalid": "תצורת מודל Gemini Live בלתי תקינה",
+  "Gemini voice is starting too often. Try again shortly.": "הקול של Gemini מופעל בתדירות גבוהה מדי. נסה שוב בקרוב.",
+  "Gemini quota is unavailable. Try again later.": "המכסה של Gemini אינה זמינה. נסה שוב מאוחר יותר.",
+  "Gemini access was refused. Check the API key and model access.": "הגישה ל-Gemini נדחתה. בדוק את מפתח ה-API ואת גישת המודל.",
+  "Gemini Live is unavailable for the configured model.": "Gemini Live אינו זמין למודל המוגדר.",
+  "Token request is too large": "בקשת האסימון גדולה מדי",
+  "Use an empty JSON token request": "שימוש בבקשת אסימון JSON ריקה",
+  "Release Space to send": "שחרר את Space כדי לשלוח",
+  "Hold Space to talk": "החזק את Space כדי לדבר",
+  "Voice command context is too large": "הקשר פקודת הקול גדול מדי",
+  "Gemini reliable transport exceeded its queue limit. Start voice again.": "הערוץ האמין של Gemini חרג ממגבלת התור. הפעל את הקול שוב.",
+  "Gemini reliable transport did not drain. Start voice again.": "הערוץ האמין של Gemini לא התרוקן. הפעל את הקול שוב.",
+  "Gemini token request failed (HTTP {status})": "בקשת האסימון של Gemini נכשלה (HTTP {status})",
+  "Gemini token response did not include a valid model": "תשובת האסימון של Gemini לא כללה מודל תקין",
+  "Gemini token response did not include session settings": "תשובת האסימון של Gemini לא כללה הגדרות הפעלה",
+  "Gemini session settings do not match the input mode": "הגדרות ההפעלה של Gemini אינן תואמות את מצב הקלט",
+  "Requesting microphone": "מבקש מיקרופון",
+  "Gemini could not submit this input. Start voice again.": "Gemini לא הצליח להגיש את הקלט הזה. הפעל את הקול שוב.",
+  "Connecting to Gemini": "מתחבר ל-Gemini",
+  "Ask or command": "שאל או פקד",
+  "Gemini returned an oversized message": "Gemini החזיר הודעה עצומה",
+  "Gemini Live connection failed. Check network access, then start voice again.": "חיבור Gemini Live נכשל. בדוק גישת רשת, ואז הפעל את הקול שוב.",
+  "Gemini Live connection ended. Start voice again for a new conversation.": "חיבור Gemini Live הסתיים. הפעל את הקול שוב לשיחה חדשה.",
+  "Gemini Live could not start. Start voice again to request a fresh session.": "Gemini Live לא התחיל. הפעל את הקול שוב כדי לבקש הפעלה חדשה.",
+  "Start voice again for a fresh token and a new conversation.": "הפעל את הקול שוב לאסימון חדש ולשיחה חדשה.",
+  "Start voice again to request a fresh session credential.": "הפעל את הקול שוב כדי לבקש פרטי גישה חדשים להפעלה.",
+  "Microphone permission was denied. Allow microphone access and try again.": "הרשאת המיקרופון נדחתה. אפשר גישה למיקרופון ונסה שוב.",
+  "Gemini connection timed out. Try again.": "חיבור Gemini חרג מהזמן הקצוב. נסה שוב.",
+  "Gemini voice could not start": "הקול של Gemini לא הצליח להתחיל",
+  "Gemini did not finish the interrupted reply. Start voice again.": "Gemini לא סיים את התשובה שהופסקה. הפעל את הקול שוב.",
+  "Gemini session expiring; finishing the current reply": "הפעלת Gemini עומדת לפוג; מסיים את התשובה הנוכחית",
+  "Gemini rejected the voice session. Start voice again to request a fresh session.": "Gemini דחה את הפעלת הקול. הפעל את הקול שוב לבקשת הפעלה חדשה.",
+  "Start voice again for a fresh session credential. If it repeats, check Gemini model and API access.": "הפעל את הקול שוב לפרטי גישה חדשים. אם זה חוזר, בדוק את גישת המודל וה-API של Gemini.",
+  "Gemini action history is full. Start voice again for a fresh session.": "היסטוריית הפעולות של Gemini מלאה. הפעל את הקול שוב להפעלה חדשה.",
+  "Gemini requested too many simultaneous actions": "Gemini ביקש יותר מדי פעולות במקביל",
+  "Running command": "מריץ פקודה",
+  "Voice text command is too long": "פקודת הטקסט הקולית ארוכה מדי",
+  "Gemini voice is not connected": "הקול של Gemini אינו מחובר",
+  "Gemini interrupted input exceeded its buffer or wait limit. Start voice again.": "הקלט שהופסק של Gemini חרג מהחוצץ או ממגבלת ההמתנה. הפעל את הקול שוב.",
+  "Gemini Live connection is expiring. Start voice again for a new conversation.": "חיבור Gemini Live עומד לפוג. הפעל את הקול שוב לשיחה חדשה.",
+  "Voice off": "הקול כבוי",
+  "Gemini voice sessions have a time limit. When a session expires, start voice again for a new conversation.": "הפעלות הקול של Gemini מוגבלות בזמן. כשההפעלה פגה, הפעל את הקול שוב לשיחה חדשה.",
+  "Stopped by voice": "נעצר בקול",
+  "Automatic stop is unavailable for this voice connection.": "העצירה האוטומטית אינה זמינה לחיבור קול זה.",
+  "Preview is off.": "התצוגה המקדימה כבויה.",
+  "Your choice applies now, but could not be saved.": "הבחירה שלך חלה עכשיו, אך לא נשמרה.",
+  "WebRTC microphone support unavailable": "תמיכת מיקרופון WebRTC אינה זמינה",
+  "VOICE UNAVAILABLE": "הקול אינו זמין",
+  "VOICE ACTIVE": "הקול פעיל",
+  "Voice session could not be started.": "לא ניתן היה להתחיל את הפעלת הקול.",
+  "MINI": "מיני",
+  "Next session: {pendingId} — this session stays on {modelId}": "ההפעלה הבאה: {pendingId} — ההפעלה הזאת נשארת על {modelId}",
+  "Voice model: {pendingId} — click to switch to {target}; applies next session": "מודל הקול: {pendingId} — לחץ למעבר אל {target}; חל מההפעלה הבאה",
+  "standard": "רגיל",
+  "mini": "מיני",
+  "COST UNKNOWN": "העלות לא ידועה",
+  "ChatGPT OAuth session: {responses} response(s), {input} input and {output} output tokens, {captions} caption transcription(s) reported.": "הפעלת OAuth של ChatGPT: {responses} תשובות, {input} אסימוני קלט ו-{output} אסימוני פלט, {captions} תמלולי כתוביות שדווחו.",
+  "USD cost and the API spend cap are unavailable for this auth mode.": "העלות ב-USD ותקרת ההוצאה של ה-API אינם זמינים לאימות הזה.",
+  "Usage is incomplete because a response was still in flight when the session ended.": "השימוש חסר כי תשובה עוד הייתה בעיצומה כשההפעלה הסתיימה.",
+  "Estimated session cost on {modelId} — {responses} response(s). Warns at {warn}, ends the session at {cap}.": "עלות ההפעלה המוערכת על {modelId} — {responses} תשובות. מזהיר ב-{warn}, מסיים את ההפעלה ב-{cap}.",
+  "Estimate is incomplete — a response was still in flight when the session ended, so its usage was never reported.": "ההערכה חסרה — תשובה עוד הייתה בעיצומה כשההפעלה הסתיימה, ולכן השימוש שלה לא דווח מעולם.",
+  "STANDARD": "רגיל",
+  "{tier} applies next session": "{tier} חל מההפעלה הבאה",
+  "Session ended — cost cap {cost}": "ההפעלה הסתיימה — תקרת עלות {cost}",
+  "MIC": "MIC",
+  "Radio did not start": "הרדיו לא החל",
+  "state or province": "מדינה או מחוז",
+  "county or district": "נפה או פלך",
+  "neighbourhood": "שכונה",
+  "natural region": "אזור טבעי",
+  "Which {place}?": "איזו {place}?",
+  "Which place?": "איזה מקום?",
+  "{n} aircraft": {
+    "one": "{n} מטוסים",
+    "two": "{n} מטוסים",
+    "other": "{n} מטוסים"
+  },
+  "{n} military aircraft": {
+    "one": "{n} מטוסים צבאיים",
+    "two": "{n} מטוסים צבאיים",
+    "other": "{n} מטוסים צבאיים"
+  },
+  "{n} ships": {
+    "one": "{n} אוניות",
+    "two": "{n} אוניות",
+    "other": "{n} אוניות"
+  },
+  "{n} satellites": {
+    "one": "{n} לוויינים",
+    "two": "{n} לוויינים",
+    "other": "{n} לוויינים"
+  },
+  "{n} launches": {
+    "one": "{n} שיגורים",
+    "two": "{n} שיגורים",
+    "other": "{n} שיגורים"
+  },
+  "{n} earthquakes": {
+    "one": "{n} רעידות אדמה",
+    "two": "{n} רעידות אדמה",
+    "other": "{n} רעידות אדמה"
+  },
+  "{n} fire perimeters": {
+    "one": "{n} היקפי שרפות",
+    "two": "{n} היקפי שרפות",
+    "other": "{n} היקפי שרפות"
+  },
+  "{n} cyclones": {
+    "one": "{n} ציקלונים",
+    "two": "{n} ציקלונים",
+    "other": "{n} ציקלונים"
+  },
+  "{n} buses": {
+    "one": "{n} אוטובוסים",
+    "two": "{n} אוטובוסים",
+    "other": "{n} אוטובוסים"
+  },
+  "{n} bike share": {
+    "one": "{n} אופניים שיתופיים",
+    "two": "{n} אופניים שיתופיים",
+    "other": "{n} אופניים שיתופיים"
+  },
+  "{n} flock cameras": {
+    "one": "{n} מצלמות Flock",
+    "two": "{n} מצלמות Flock",
+    "other": "{n} מצלמות Flock"
+  },
+  "{n} military bases": {
+    "one": "{n} בסיסים צבאיים",
+    "two": "{n} בסיסים צבאיים",
+    "other": "{n} בסיסים צבאיים"
+  },
+  "{n} datacenters": {
+    "one": "{n} מרכזי נתונים",
+    "two": "{n} מרכזי נתונים",
+    "other": "{n} מרכזי נתונים"
+  },
+  "{n} dams": {
+    "one": "{n} סכרים",
+    "two": "{n} סכרים",
+    "other": "{n} סכרים"
+  },
+  "{n} air quality": {
+    "one": "{n} תחנות אוויר נקי",
+    "two": "{n} תחנות אוויר נקי",
+    "other": "{n} תחנות אוויר נקי"
+  },
+  "{n} results": {
+    "one": "{n} תוצאות",
+    "two": "{n} תוצאות",
+    "other": "{n} תוצאות"
+  },
+  "anywhere in the loaded data": "בכל רחבי הנתונים שנטענו",
+  "in view": "בתצוגה",
+  "within {radius} of the view centre": "בטווח {radius} ממרכז התצוגה",
+  "within {radius} of {place} (Contacts window)": "בטווח {radius} מ-{place} (חלון המגעים)",
+  "within {radius} of {place}": "בטווח {radius} מ-{place}",
+  "within {radius}": "בטווח {radius}",
+  "over {region}": "מעל {region}",
+  "At least {items}": "לפחות {items}",
+  "{items} {scope}": "{items} {scope}",
+  "last 24 h": "24 השעות האחרונות",
+  "past 30 d and upcoming": "30 הימים האחרונים והקרובים",
+  "the flights layer loads by viewport": "שכבת הטיסות נטענת לרוחב התצוגה",
+  "distance is ground distance, not overhead": "המרחק הוא מרחק קרקע, לא ישירות מלמעלה",
+  "the count is a lower bound because at least one layer reached its retained limit.": "המניין הוא גבול תחתון כי לפחות שכבה אחת הגיעה למגבלת השמירה שלה.",
+  "buffer sized to the place": "חיץ בגודל המקום",
+  "enclosing mapped area": "מקיף את הסביבה הממופה",
+  "the map was cleared while looking it up": "המפה נוקתה בזמן החיפוש",
+  "OpenStreetMap coverage varies by place": "כיסוי OpenStreetMap משתנה ממקום למקום",
+  "the catalog covers the last 30 days": "הקטלוג מכסה את 30 הימים האחרונים",
+  "there are more": "יש נוספים",
+  "{label} off": "{label} כבוי",
+  "{label} loading": "{label} בטעינה",
+  "{label} error": "{label} שגיאה",
+  "{radius} m around the landmark": "{radius} מ׳ סביב ציון הדרך",
+  "{count} parts": {
+    "one": "{count} חלקים",
+    "two": "{count} חלקים",
+    "other": "{count} חלקים"
+  },
+  "{drawn} of {total} parts drawn": {
+    "one": "שורטטו {drawn} מתוך {total} חלקים",
+    "two": "שורטטו {drawn} מתוך {total} חלקים",
+    "other": "שורטטו {drawn} מתוך {total} חלקים"
+  },
+  "{count} duplicate mappings merged": {
+    "one": "מוזגו {count} מיפויים כפולים",
+    "two": "מוזגו {count} מיפויים כפולים",
+    "other": "מוזגו {count} מיפויים כפולים"
+  },
+  "listed the first {limit}": "הוצגו הראשונים {limit}",
+  "counted over the bounding box of {area}, not its outline": "נספר לפי תיבת ההקפה של {area}, לא לפי קו המתאר שלה",
+  "counted the first {returned} loaded records": "נספרו {returned} הרשומות הראשונות הטעונות",
+  "counted {returned} of {total} loaded records": "נספרו {returned} מתוך {total} רשומות טעונות",
+  "{layers} just turned on — still loading, counts will rise": "{layers} הופעלו זה עתה — עדיין בטעינה, המניינים יגדלו",
+  "Contacts panel snapshot at {time} — the same retained cohort supplies the card, speech, and follow-up memory": "תמונת מצב של פאנל המגעים ב-{time} — אותה קבוצה נשמרת מספקת את הכרטיס, הדיבור והזיכרון להמשך",
+  "Contacts panel snapshot — the same retained cohort supplies the card, speech, and follow-up memory": "תמונת מצב של פאנל המגעים — אותה קבוצה נשמרת מספקת את הכרטיס, הדיבור והזיכרון להמשך",
+  "Fly below {km} km to a covered region": "עוף מטה מתחת ל-{km} ק\"מ אל אזור הזנה",
+  "No feed here yet · {n} regions available": {
+    "one": "אין עדיין הזנה כאן · {n} אזורים זמינים",
+    "two": "אין עדיין הזנה כאן · {n} אזורים זמינים",
+    "other": "אין עדיין הזנה כאן · {n} אזורים זמינים"
+  },
+  "degraded": "מופחת",
+  "stale": "מיושן",
+  "partial": "חלקי",
+  "fallback": "חלופה",
+  "unavailable": "לא זמין",
+  "Not answered: {layers}": "לא נענו: {layers}",
+  "voice area|Area": "אזור",
+  "Not drawn: {parts}": "לא שורטטו: {parts}",
+  "approximate": "משוער",
+  "{pct}% cloud": "{pct}% עננות",
+  "Over {area}": "מעל {area}",
+  "{count} of {total} acquisitions match": {
+    "one": "{count} מתוך {total} אחזורים תואמים",
+    "two": "{count} מתוך {total} אחזורים תואמים",
+    "other": "{count} מתוך {total} אחזורים תואמים"
+  },
+  "{n} acquisitions searched": {
+    "one": "נחפשו {n} אחזורים",
+    "two": "נחפשו {n} אחזורים",
+    "other": "נחפשו {n} אחזורים"
+  },
+  "No matching imagery": "אין צילומים תואמים",
+  "Unknown number of {kind}": "מספר לא ידוע של {kind}",
+  "About {count} {kind}": "כ-{count} {kind}",
+  "At least {count} {kind}": "לפחות {count} {kind}",
+  "{count} {kind}": "{count} {kind}",
+  "In {area}": "ב-{area}",
+  "Toggle voice control": "החלפת שליטה קולית",
+  "Activate to toggle voice": "הפעל להחלפת הקול",
+  "Voice active": "הקול פעיל",
+  "Voice could not be started.": "לא ניתן היה להתחיל את הקול.",
+  "{value} feet": "{value} רגל",
+  "Fire · FRP {frp} MW": "שריפה · FRP {frp} MW",
+  "The flights layer is not enabled": "שכבת הטיסות אינה מופעלת",
+  "The military layer is not enabled": "שכבת הטיסות הצבאיות אינה מופעלת",
+  "The satellites layer is not enabled": "שכבת הלוויינים אינה מופעלת",
+  "The ais-live-vessels layer is not enabled": "שכבת אוניות ה-AIS החיות אינה מופעלת",
+  "Could not enable the requested layer": "לא ניתן להפעיל את השכבה המבוקשת",
+  "Could not disable the requested layer": "לא ניתן לכבות את השכבה המבוקשת",
+  "Radio layer unavailable": "שכבת הרדיו אינה זמינה",
+  "Camera navigation is unavailable in the current view": "ניווט המצלמה אינו זמין בתצוגה הנוכחית",
+  "Camera navigation policy unavailable": "מדיניות ניווט המצלמה אינה זמינה",
+  "Nearest-aircraft selection supports Flights or Military Flights only": "בחירת המטוס הקרוב תומכת בטיסות או בטיסות צבאיות בלבד",
+  "Nearest-aircraft selection needs a preset, place name, or latitude and longitude": "בחירת המטוס הקרוב דורשת ערך מוגדר מראש, שם מקום, או קו רוחב וקו אורך",
+  "Could not arrive at the requested place": "לא ניתן להגיע למקום המבוקש",
+  "The nearest airborne aircraft could not be selected": "לא ניתן לבחור את המטוס הקרוב באוויר",
+  "No flights within {radius} of the current view": "אין טיסות בטווח {radius} מהתצוגה הנוכחית",
+  "No military within {radius} of the current view": "אין טיסות צבאיות בטווח {radius} מהתצוגה הנוכחית",
+  "No satellites within {radius} of the current view": "אין לוויינים בטווח {radius} מהתצוגה הנוכחית",
+  "No vessels within {radius} of the current view": "אין אוניות בטווח {radius} מהתצוגה הנוכחית",
+  "{layer} is enabled on the {source} feed, but no airborne aircraft is loaded in the {place} view yet": "{layer} מופעל בהזנת {source}, אך אין עדיין מטוסים באוויר טעונים בתצוגת {place}",
+  "{layer} is enabled, but no airborne aircraft is loaded in the {place} view yet": "{layer} מופעל, אך אין עדיין מטוסים באוויר טעונים בתצוגת {place}",
+  "{layer} is enabled, but its aircraft feed is unavailable": "{layer} מופעל, אך הזנת המטוסים שלו אינה זמינה",
+  "{layer} is enabled, but its destination refresh did not complete": "{layer} מופעל, אך רענון היעד שלו לא הושלם",
+  "{layer} is enabled, but {source} is unavailable": "{layer} מופעל, אך {source} אינו זמין",
+  "Could not arrive at {place}": "לא ניתן להגיע אל {place}",
+  "{name} is no longer loaded": "{name} אינו טעון עוד",
+  "Unknown target layer: {target}": "שכבת יעד בלתי מוכרת: {target}",
+  "nominal": "רגיל",
+  "{label} on": "{label} פעיל",
+  "Frame aircraft": "מסגור המטוסים",
+  "Frame military aircraft": "מסגור המטוסים הצבאיים",
+  "Frame ships": "מסגור האוניות",
+  "Frame satellites": "מסגור הלוויינים",
+  "Frame contacts": "מסגור המגעים",
+  "{count} aircraft in frame": {
+    "one": "{count} מטוסים במסגרת",
+    "two": "{count} מטוסים במסגרת",
+    "other": "{count} מטוסים במסגרת"
+  },
+  "{count} military aircraft in frame": {
+    "one": "{count} מטוסים צבאיים במסגרת",
+    "two": "{count} מטוסים צבאיים במסגרת",
+    "other": "{count} מטוסים צבאיים במסגרת"
+  },
+  "{count} ships in frame": {
+    "one": "{count} אוניות במסגרת",
+    "two": "{count} אוניות במסגרת",
+    "other": "{count} אוניות במסגרת"
+  },
+  "{count} satellites in frame": {
+    "one": "{count} לוויינים במסגרת",
+    "two": "{count} לוויינים במסגרת",
+    "other": "{count} לוויינים במסגרת"
+  },
+  "{count} contacts in frame": {
+    "one": "{count} מגעים במסגרת",
+    "two": "{count} מגעים במסגרת",
+    "other": "{count} מגעים במסגרת"
+  },
+  "Nearest military aircraft": "המטוס הצבאי הקרוב",
+  "Nearest ships": "האוניות הקרובות",
+  "Nearest satellites": "הלוויינים הקרובים",
+  "Nearest aircraft": "המטוס הקרוב",
+  "{first} and {second}": "{first} ו-{second}",
+  "Layer": "שכבה",
+  "there": "שם",
+  "Camera range {range}": "טווח המצלמה {range}",
+  "Within {radius} of the view": "בטווח {radius} מהתצוגה",
+  "Labels on": "התוויות פעילות",
+  "Framing uses the nearest 80 loaded contacts": "המסגור משתמש ב-80 המגעים הקרובים הטעונים",
+  "{distance} from {location}": "{distance} מ-{location}",
+  "Altitude {altitude}": "גובה {altitude}",
+  "{origin} to {destination}": "מ-{origin} אל {destination}",
+  "from {origin}": "מ-{origin}",
+  "to {destination}": "אל {destination}",
+  "Registration {registration}": "רישום {registration}",
+  "View state": "מצב התצוגה",
+  "Marked {count} places": {
+    "one": "סומנו {count} מקומות",
+    "two": "סומנו {count} מקומות",
+    "other": "סומנו {count} מקומות"
+  },
+  "Nothing marked": "לא סומן דבר",
+  "Not found: {places}": "לא נמצאו: {places}",
+  "Tracing outlines": "משרטט קווי מתאר",
+  "Frame flights": "מסגור הטיסות",
+  "Frame military": "מסגור הצבאיים",
+  "Frame vessels": "מסגור האוניות",
+  "Frame {target}": "מסגור {target}",
+  "Zoom out to globe": "זום החוצה אל הגלובוס",
+  "Open data layers": "פתיחת שכבות נתונים",
+  "Open or close a panel": "פתיחה או סגירה של פאנל",
+  "Change context mode": "שינוי מצב ההקשר",
+  "Control cockpit": "שליטה בתא הטייס",
+  "Change visual style": "שינוי סגנון הראייה",
+  "Adjust HUD": "כיוון ה-HUD",
+  "Adjust cyber sonar": "כיוון הסונאר הסייברי",
+  "Adjust detection overlay": "כיוון שכבת הזיהוי",
+  "Change map stack": "שינוי ערמת המפות",
+  "Adjust post-processing": "כיוון עיבוד שלאחר",
+  "Control scene": "שליטה בסצנה",
+  "Control CCTV": "שליטה ב-CCTV",
+  "Control radio": "שליטה ברדיו",
+  "Track contact": "עקיבה אחר המגע",
+  "Stop tracking": "עצירת העקיבה",
+  "Clear marks": "ניקוי סימונים",
+  "Move camera": "הזזת המצלמה",
+  "Fly route": "טיסה לאורך המסלול",
+  "Analyst query": "שאילתת אנליסט",
+  "Next ISS pass": "המעבר הבא של ISS",
+  "Next satellite pass": "המעבר הבא של הלוויין",
+  "Mark the map": "סימון המפה",
+  "Mark {targets} +{more}": "סימון {targets} +{more}",
+  "Mark {targets}": "סימון {targets}",
+  "Fly to {place}": "טיסה אל {place}",
+  "Fly to Location": "טיסה אל המיקום",
+  "Nearest aircraft to {place}": "המטוס הקרוב ביותר אל {place}",
+  "Nearest aircraft to Here": "המטוס הקרוב ביותר אל כאן",
+  "Layer on": "השכבה פעילה",
+  "Layer off": "השכבה כבויה",
+  "Zoom out": "התרחקות",
+  "Zoom in": "התקרבות",
+  "Read the view": "קריאת התצוגה",
+  "Check view state": "בדיקת מצב התצוגה",
+  "Area around {place}": "האזור סביב {place}",
+  "Area around landmark": "האזור סביב ציון הדרך",
+  "Outline {place}": "קו המתאר של {place}",
+  "Outline area": "קו המתאר של האזור",
+  "Find {place}": "חיפוש {place}",
+  "Find area": "חיפוש אזור",
+  "Find recent imagery": "חיפוש צילומים אחרונים",
+  "Find {what}": "חיפוש {what}",
+  "Find places": "חיפוש מקומות",
+  "Action": "פעולה",
+  "Finding places": "מחפש מקומות",
+  "Tracing outline": "משרטט קו מתאר",
+  "Looking up place": "מאתר מקום",
+  "Flying": "עף",
+  "Turning on layer": "מפעיל את השכבה",
+  "Loading aircraft": "טוען מטוסים",
+  "Picking nearest": "בוחר את הקרוב",
+  "Drawing outline": "מצייר קו מתאר",
+  "Searching imagery catalog": "מחפש בקטלוג הצילומים",
+  "Loading imagery": "טוען צילומים",
+  "Searching OpenStreetMap": "מחפש ב-OpenStreetMap",
+  "Working": "עובד",
+  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "צ׳אט בהקלדה אינו זמין בזמן ש-GEV_PREFER_CODEX_OAUTH דורש OAuth של ChatGPT.",
+  "The provider rejected the API key. Check it in Provider Settings.": "הספק דחה את מפתח ה-API. בדוק אותו בהגדרות הספקים.",
+  "The provider refused access for this key. Check the key's project, region or permissions.": "הספק סירב לאשר גישה למפתח הזה. בדוק את הפרויקט, האזור או ההרשאות של המפתח.",
+  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "לחשבון הספק נגמר האשראי. בדוק את החיוב שלו, או בחר ספק AI אחר בהגדרות.",
+  "Too many chat requests. Try again in {seconds} s.": "יותר מדי בקשות צ׳אט. נסה שוב בעוד {seconds} שנ.",
+  "That request needed too many steps. Changes already made to the map stay in place.": "הבקשה הזאת דרשה יותר מדי צעדים. השינויים שכבר בוצעו במפה נשארים במקומם.",
+  "That request needed too many steps. Try a simpler request.": "הבקשה הזאת דרשה יותר מדי צעדים. נסה בקשה פשוטה יותר.",
+  "in progress": "בעבודה",
+  "done": "הושלם",
+  "failed": "נכשל",
+  "cancelled": "בוטל",
+  "Outline traced": "קו המתאר שורטט",
+  "Outline unavailable": "קו המתאר אינו זמין",
+  "Source: {label}": "מקור: {label}",
+  "WORKING": "עובד",
+  "DONE": "הושלם",
+  "Recent speech": "דיבור אחרון",
+  "HERE": "כאן",
+  "Initializing photorealistic world...": "מאתחל את העולם הפוטוריאליסטי..."
+}
diff --git a/src/i18n/same-as-english.json b/src/i18n/same-as-english.json
index 8c2a2bd75..f22accadf 100644
--- a/src/i18n/same-as-english.json
+++ b/src/i18n/same-as-english.json
@@ -1189,5 +1189,94 @@
     "acartia.io ↗",
     "iNaturalist ↗",
     "iNaturalist"
+  ],
+  "he": [
+    "{speed} kn",
+    "GEO",
+    "SAR",
+    "EARTH WATCH",
+    "CRT",
+    "NVG",
+    "FLIR",
+    "AIS: --",
+    "REC",
+    "HDG {value}°",
+    "BRG {value}°",
+    "BRG —",
+    "CRS {value}°",
+    "FOV {value}°",
+    "CAL {value}",
+    "SRC {value}",
+    "▲ {frp} MW",
+    "≥ {value} MW",
+    "Intel Picture",
+    "Kinetic 30d",
+    "Border Crisis",
+    "Iran Picture",
+    "Iran Kinetic",
+    "Yemen FLOT",
+    "Latest Drop",
+    "1090 MHz",
+    "978 MHz UAT",
+    "ALT {altitude} FT · GS {speed} KT · TRK {track}",
+    "V/S {rate} FPM",
+    "Sentinel-2",
+    "Landsat 8/9",
+    "Google Street View",
+    "GOOGLE STREET VIEW",
+    "AIS: {name}",
+    "{type}  SPD: {speed}  HDG: {heading}",
+    "POS: {time}Z",
+    "{source} HTTP {status}",
+    "NNE",
+    "NE",
+    "ENE",
+    "ESE",
+    "SE",
+    "SSE",
+    "SSW",
+    "SW",
+    "WSW",
+    "WNW",
+    "NW",
+    "NNW",
+    "WHOT/BHOT",
+    "HDG",
+    "FOV",
+    "HGT",
+    "ΔN",
+    "ΔE",
+    "CAL · {badge}",
+    "DEST ---°",
+    "SQUAWK {code} · {status}",
+    "DEST {bearing}",
+    "Space Missions",
+    "CCTV",
+    "S2 GhostMaps",
+    "Street Level",
+    "STREET LEVEL",
+    "km/h",
+    "mph",
+    "hPa",
+    "kt",
+    "kts",
+    "ft",
+    "km",
+    "min",
+    "dB",
+    "LEVEL",
+    "KTS",
+    "FT",
+    "FLT",
+    "MIL",
+    "WX",
+    "MSG/S",
+    "FM MHZ",
+    "Acartia",
+    "CC BY 4.0",
+    "Salish Sea",
+    "iNaturalist",
+    "Be Whale Wise",
+    "MIC"
   ]
 }
diff --git a/src/ui/localePicker.test.mjs b/src/ui/localePicker.test.mjs
index d59c9926b..5e25fb01f 100644
--- a/src/ui/localePicker.test.mjs
+++ b/src/ui/localePicker.test.mjs
@@ -52,6 +52,7 @@ test('the current language comes first, the rest by their own names', () => {
       'fr',
       'it',
       'pt',
+      'he',
       'ar',
       'zh-CN',
       'zh-Hant',
@@ -75,6 +76,7 @@ test('the current language comes first, the rest by their own names', () => {
       'pt',
       'ru',
       'uk',
+      'he',
       'ar',
       'zh-CN',
       'zh-Hant',
@@ -98,6 +100,7 @@ test('the current language comes first, the rest by their own names', () => {
       'pt',
       'ru',
       'uk',
+      'he',
       'ar',
       'zh-CN',
       'zh-Hant',
@@ -122,6 +125,7 @@ test('the current language comes first, the rest by their own names', () => {
       'pt',
       'ru',
       'uk',
+      'he',
       'zh-CN',
       'zh-Hant',
       'ja',
diff --git a/src/ui/styles/rtl.css b/src/ui/styles/rtl.css
index 10b5c13bd..8e7288b3e 100644
--- a/src/ui/styles/rtl.css
+++ b/src/ui/styles/rtl.css
@@ -60,6 +60,43 @@ html:lang(ar) :is(#intel-hud, #cockpit-hud) {
     Tahoma, monospace;
 }
 
+/* Hebrew: JetBrains Mono and Inter also lack Hebrew glyphs. Noto Sans Hebrew
+   (loaded with the other Google fonts; its files download only when the page
+   shows Hebrew) leads the stack so the body text keeps one proportional
+   Hebrew face across platforms. Hebrew letters do not join like Arabic, but
+   tracking still reads as gaps inside a word, so the body is released from it
+   the same way; Latin marked translate="no" keeps its tracking. The intel and
+   cockpit HUDs keep JetBrains Mono for their Latin telemetry. */
+html:lang(he) {
+  --font-mono:
+    'Noto Sans Hebrew', 'JetBrains Mono', 'SF Mono', 'Fira Code', Tahoma,
+    monospace;
+  --font-sans:
+    'Inter', 'Noto Sans Hebrew', -apple-system, BlinkMacSystemFont, Tahoma,
+    sans-serif;
+}
+html:lang(he)
+  :is(
+    #military-awareness-panel,
+    .military-awareness-controls button,
+    .military-awareness-standby button,
+    .military-awareness-compass-label,
+    .military-awareness-compass-heading,
+    .military-awareness-direction-label,
+    .tr3b-toggle
+  ) {
+  font-family: var(--font-mono);
+}
+html:lang(he) :is(#intel-hud, #cockpit-hud) {
+  --font-mono:
+    'JetBrains Mono', 'SF Mono', 'Fira Code', 'Noto Sans Hebrew', Tahoma,
+    monospace;
+}
+html:lang(he) body
+  :not(#intel-hud, #intel-hud *, [translate='no'], [translate='no'] *) {
+  letter-spacing: 0 !important;
+}
+
 /* The Display/Context rail moves to the left edge. It keeps a physical
    `right` in layers.css because the attribution-clearance model
    (creditAttribution.test.mjs) reads that rule; the swap only applies above

From 25229a8e4ead0d71700a4c7ba63eb51489b78523 Mon Sep 17 00:00:00 2001
From: Meir Michanie <meirm@cyborg.fi>
Date: Thu, 5 Nov 2026 22:30:34 -0600
Subject: [PATCH 44/71] changelog: Hebrew (#1594)

---
 changelog.d/1594-hebrew.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 changelog.d/1594-hebrew.md

diff --git a/changelog.d/1594-hebrew.md b/changelog.d/1594-hebrew.md
new file mode 100644
index 000000000..83b54c51e
--- /dev/null
+++ b/changelog.d/1594-hebrew.md
@@ -0,0 +1,5 @@
+- Add Hebrew (he), the second right-to-left language: the title, rails, dock
+  and corner row mirror, numbers keep Western digits, and plurals use the
+  one/two/other Hebrew forms. Noto Sans Hebrew joins the font stacks and the
+  style, plural and glossary notes arrive in docs/translations/he.md
+  (Hebrew, @meirm, #1594).

From e35f38df8ce44dc46b293c2d60a89023f2892c09 Mon Sep 17 00:00:00 2001
From: Meir Michanie <meirm@cyborg.fi>
Date: Sun, 8 Nov 2026 19:21:28 -0600
Subject: [PATCH 45/71] i18n(he): follow main's satellite classes, orbital and
 bridge views

- Rebase on origin/main and translate the 130 new strings: event-age
  filter, satellite class groups (STATIONS/IMAGING/TELECOM/STARLINK/
  PROBES/DEBRIS) with CelesTrak SATCAT context, TomTom traffic limits,
  the ship bridge view (look/hold/radar/SOG/COG), the orbital view
  (swath, off-nadir, TLE, sub-satellite point, nadir/track-up) and the
  world-time play speeds.
- Instrument readouts keep the Latin codes (LOOK/STBD/PORT, NM, NORAD,
  EPOCH, TLE, OFF-NADIR, STARLINK, EYE, SWATH variants) via
  same-as-english.
- Prune 3 entries whose English main replaced.
---
 src/i18n/locales/he.json      | 139 +++++++++++++++++++++++++++++++++-
 src/i18n/same-as-english.json |  15 +++-
 2 files changed, 149 insertions(+), 5 deletions(-)

diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json
index 030a8fb26..5278e9b5c 100644
--- a/src/i18n/locales/he.json
+++ b/src/i18n/locales/he.json
@@ -1013,8 +1013,6 @@
   "Starlink {detail} — click to retry": "Starlink {detail} — לחץ לניסיון חוזר",
   "load failed": "הטעינה נכשלה",
   "Showing the full Starlink shell — click for the core catalog only": "מציג את מעטפת Starlink המלאה — לחץ לקטלוג הליבה בלבד",
-  "DENSE ···": "דחוס ···",
-  "DENSE ✕": "דחוס ✕",
   "DENSE": "דחוס",
   "CelesTrak unreachable": "CelesTrak אינו נגיש",
   "DOCKED · {name} · +{extra}": "עגן · {name} · +{extra}",
@@ -2301,7 +2299,6 @@
   "ALTITUDE": "גובה",
   "FT": "FT",
   "ESC EXIT": "יציאה ESC",
-  "C TOGGLE": "מקש C להחלפה",
   "View switcher": "מחליף התצוגות",
   "Resetting cockpit to full globe view": "מאפס את תא הטייס לתצוגת הגלובוס המלאה",
   "Reset cockpit to full globe view": "איפוס תא הטייס אל תצוגת הגלובוס המלאה",
@@ -3238,5 +3235,139 @@
   "DONE": "הושלם",
   "Recent speech": "דיבור אחרון",
   "HERE": "כאן",
-  "Initializing photorealistic world...": "מאתחל את העולם הפוטוריאליסטי..."
+  "Initializing photorealistic world...": "מאתחל את העולם הפוטוריאליסטי...",
+  "Event age": "גיל האירוע",
+  "event age filter|All": "הכול",
+  "{days}d": "{days} יום",
+  "Show markers of every age": "הצגת סמנים בכל גיל",
+  "Maximum event age: {days}d; undated markers are kept": "גיל אירוע מרבי: {days} יום; סמנים ללא תאריך נשמרים",
+  "All markers": "כל הסמנים",
+  "Event age: {days}d · undated kept": "גיל האירוע: {days} יום · ללא תאריך נשמרים",
+  "30-DAY MISSION INDEX UNAVAILABLE": "מפתח המשימות ל-30 יום אינו זמין",
+  "STATIONS": "תחנות",
+  "Crewed stations and the craft that visit them": "תחנות מאוישות והחלליות המבקרות בהן",
+  "IMAGING": "צילום",
+  "Earth observation: optical, radar, weather and science": "תצפית כדור הארץ: אופטי, רדאר, מזג אוויר ומדע",
+  "TELECOM": "תקשורת",
+  "Communications and navigation satellites, Starlink excepted": "לווייני תקשורת וניווט, למעט Starlink",
+  "STARLINK": "STARLINK",
+  "The Starlink constellation (thousands of extra points)": "קונסטלציית Starlink (אלפי נקודות נוספות)",
+  "PROBES": "גשושיות",
+  "Space science, technology demonstration and other payloads": "מדע בחלל, הדגמות טכנולוגיה ומטענים אחרים",
+  "DEBRIS": "פסולת חלל",
+  "Rocket bodies, fragments and dead satellites": "גופי משגרים, שברים ולוויינים מתים",
+  "Classes may lag: SATCAT is a cached copy": "הקבוצות עשויות להשתהות: SATCAT הוא תמונת מצב במטמון",
+  "Classes may lag: SATCAT unavailable": "הקבוצות עשויות להשתהות: SATCAT אינו זמין",
+  "CelesTrak SATCAT gives each object's type and status. Without a current copy the classes rest on the UCS database, names and CelesTrak groups, so a satellite that has died since may still show as working.": "CelesTrak SATCAT נותן לכל עצם סוג ומצב. בלי תמונת מצב עדכנית הקבוצות נשענות על מאגר UCS, השמות וקבוצות CelesTrak, ולכן לוויין שמת מאז עשוי עדיין להיראות פעיל.",
+  "Lines": "קווים",
+  "Road lines colored by live flow: green to red": "קווי כבישים בצבע לפי זרימה חיה: מירוק לאדום",
+  "Dots": "נקודות",
+  "Moving dots colored by live flow": "נקודות נעות בצבע לפי זרימה חיה",
+  "Moving dots": "נקודות נעות",
+  "Monthly traffic allowance used": "הקצבה החודשית לתנועה נוצלה",
+  "Traffic rate limit reached": "הגעת למגבלת הקצב של שירות התנועה",
+  "Traffic service unavailable": "שירות התנועה אינו זמין",
+  "LOOK STBD {bearing}°": "LOOK STBD {bearing}°",
+  "LOOK PORT {bearing}°": "LOOK PORT {bearing}°",
+  "LOOK ASTERN": "LOOK ASTERN",
+  "UP {angle}°": "מעלה {angle}°",
+  "DOWN {angle}°": "מטה {angle}°",
+  "{direction} · {elevation}": "{direction} · {elevation}",
+  "LOOK {elevation}": "LOOK {elevation}",
+  "{vesselType} · {feedState} · EYE {height}": "{vesselType} · {feedState} · EYE {height}",
+  "LIVE AIS": "AIS חי",
+  "CONTACT NAVIGATION OFF": "ניווט המגעים כבוי",
+  "THE BRIDGE STAYS WITH THE SELECTED VESSEL": "הגשר נשאר עם האונייה הנבחרת",
+  "{range} NM": "{range} NM",
+  "AIS DESTINATION · CREW REPORTED": "יעד AIS · דווח על ידי הצוות",
+  "FWD": "קדימה",
+  "AFT": "אחורה",
+  "RIGHT": "ימין",
+  "LEFT": "שמאל",
+  "{direction} {angle}°": "{direction} {angle}°",
+  "OFF-NADIR {angle}° · {offset}": "OFF-NADIR {angle}° · {offset}",
+  "BRIDGE": "גשר",
+  "{label} · NADIR VIEW": "{label} · תצוגת נדיר",
+  "{label} · HEADING {heading}°": "{label} · כיוון {heading}°",
+  "{label} · NO HEADING": "{label} · ללא כיוון",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "Space Missions אינן זמינות: טעינת מפתח המשימות נכשלה. נסה שוב מאוחר יותר.",
+  "Close camera preview": "סגירת תצוגת המצלמה",
+  "Refresh map still": "רענון תמונת המפה",
+  "The map still uses a separate request and may show a different moment.": "תמונת המפה נשלפת בבקשה נפרדת ועשויה להראות רגע שונה.",
+  "Video plays from Québec 511, which sees your IP address.": "הווידאו זורם מ-Québec 511, שרואה את כתובת ה-IP שלך.",
+  "Ship bridge view": "תצוגת גשר האונייה",
+  "Satellite orbital view": "התצוגה המסלולית של הלוויין",
+  "Exit bridge view": "יציאה מתצוגת הגשר",
+  "Exit orbital view": "יציאה מהתצוגה המסלולית",
+  "EXIT BRIDGE": "יציאה מהגשר",
+  "EXIT ORBIT": "יציאה מהמסלול",
+  "BRIDGE WINDOW · FWD": "חלון הגשר · קדימה",
+  "COURSE HOLD · AIS": "החזקת מהלך · AIS",
+  "HEADING HOLD · AIS": "החזקת כיוון · AIS",
+  "NO HEADING · AIS": "ללא כיוון · AIS",
+  "SPEED OVER GROUND · KTS": "מהירות מעל הקרקע · KTS",
+  "BRIDGE VIEW": "תצוגת הגשר",
+  "Look ahead: turn the bridge view back to the bow": "מבט קדימה: החזרת תצוגת הגשר אל החרטום",
+  "Look ahead (Home or 0)": "מבט קדימה (Home או 0)",
+  "LOOK AHEAD": "מבט קדימה",
+  "Current vessel heading": "הכיוון הנוכחי של האונייה",
+  "SPEED OVER GROUND": "מהירות מעל הקרקע",
+  "COURSE OVER GROUND": "מהלך מעל הקרקע",
+  "ARROWS LOOK": "חצים למבט",
+  "HOME RESET": "Home מאפס",
+  "+/− ZOOM": "+/− זום",
+  "ARROWS TILT": "חצים להטיה",
+  "HOME NADIR": "Home אל הנדיר",
+  "ZOOM {zoom}×": "זום {zoom}×",
+  "SENSOR SWATH ≈ {value} KM": "רוחב חיישן ≈ {value} ק\"מ",
+  "SENSOR SWATH {value} KM": "רוחב חיישן {value} ק\"מ",
+  "SWATH ≈ {value} KM": "רוחב ≈ {value} ק\"מ",
+  "SWATH {value} KM": "רוחב {value} ק\"מ",
+  "{division}, {country}": "{division}, {country}",
+  "{region} · near {place}": "{region} · קרוב אל {place}",
+  "NORAD {id}": "NORAD {id}",
+  "EPOCH {time}": "EPOCH {time}",
+  "<1 H OLD": "פחות משעה",
+  "{value} H OLD": "{value} שעות",
+  "{value} D OLD": "{value} ימים",
+  "Orbital view": "תצוגה מסלולית",
+  "CURRENTLY OVER": "כעת מעל",
+  "ORBITAL VIEW · OFF-NADIR": "תצוגה מסלולית · OFF-NADIR",
+  "ORBITAL VIEW · NADIR": "תצוגה מסלולית · נדיר",
+  "Hide the two-line element set": "הסתרת ערכת האלמנטים הדו-הקווית",
+  "Show the two-line element set": "הצגת ערכת האלמנטים הדו-הקווית",
+  "TLE": "TLE",
+  "Two-line element set": "ערכת אלמנטים דו-הקווית",
+  "ORBITAL VELOCITY": "מהירות מסלולית",
+  "SUB-SATELLITE POINT": "נקודת תת-הלוויין",
+  "TRACK UP": "המעקב מעלה",
+  "NORTH UP": "צפון מעלה",
+  "Return the view to nadir": "החזרת התצוגה אל הנדיר",
+  "Return to nadir (Home or 0)": "חזרה אל הנדיר (Home או 0)",
+  "NADIR": "נדיר",
+  "Zoom out (−)": "התרחקות (−)",
+  "Zoom in (+)": "התקרבות (+)",
+  "Zoom to the imaging sensor swath": "זום אל רוחב חיישן הצילום",
+  "SENSOR": "חיישן",
+  "RINGS {spacing} NM": "טבעות {spacing} NM",
+  "{count} CONTACTS": {
+    "one": "{count} מגע",
+    "two": "{count} מגעים",
+    "other": "{count} מגעים"
+  },
+  "Radar range {range}. Select for the next range.": "טווח הרדאר {range}. בחר כדי לעבור לטווח הבא.",
+  "Bridge radar": "רדאר הגשר",
+  "Reported voyage": "הפלגה שדווחה",
+  "REPORTED VOYAGE": "הפלגה שדווחה",
+  "1 min/s": "דקה/שנ",
+  "1 h/s": "שעה/שנ",
+  "1 d/s": "יום/שנ",
+  "1 wk/s": "שבוע/שנ",
+  "World time": "הזמן העולמי",
+  "Play speed": "מהירות הנגינה",
+  "Scroll or pinch to zoom, drag to move along · double-click to see it all": "גלילה או צביטה לזום, גרירה להזזה לאורך · לחיצה כפולה לתצוגה המלאה",
+  "Live": "חי",
+  "Back to live": "חזרה לחי",
+  "STARLINK ···": "STARLINK ···",
+  "STARLINK ✕": "STARLINK ✕"
 }
diff --git a/src/i18n/same-as-english.json b/src/i18n/same-as-english.json
index f22accadf..1a07458b1 100644
--- a/src/i18n/same-as-english.json
+++ b/src/i18n/same-as-english.json
@@ -1277,6 +1277,19 @@
     "Salish Sea",
     "iNaturalist",
     "Be Whale Wise",
-    "MIC"
+    "MIC",
+    "STARLINK",
+    "STARLINK ···",
+    "STARLINK ✕",
+    "LOOK STBD {bearing}°",
+    "LOOK PORT {bearing}°",
+    "LOOK ASTERN",
+    "LOOK {elevation}",
+    "{vesselType} · {feedState} · EYE {height}",
+    "{range} NM",
+    "OFF-NADIR {angle}° · {offset}",
+    "NORAD {id}",
+    "EPOCH {time}",
+    "TLE"
   ]
 }

From 3dd89af354e61c5f8fea66fc6e255abcab92ad17 Mon Sep 17 00:00:00 2001
From: Meir Michanie <meirm@cyborg.fi>
Date: Sun, 8 Nov 2026 19:23:55 -0600
Subject: [PATCH 46/71] i18n(he): follow main's orbital site focus

- Translate the 12 new strings: site standby and Live-Signal pings,
  releasing and keeping the camera on a subject, riding a satellite,
  the focus and return chips, unnamed mapped sites.
- OFF-NADIR stays as printed via same-as-english.
---
 src/i18n/locales/he.json      | 14 +++++++++++++-
 src/i18n/same-as-english.json |  3 ++-
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json
index 5278e9b5c..9f8d02315 100644
--- a/src/i18n/locales/he.json
+++ b/src/i18n/locales/he.json
@@ -3369,5 +3369,17 @@
   "Live": "חי",
   "Back to live": "חזרה לחי",
   "STARLINK ···": "STARLINK ···",
-  "STARLINK ✕": "STARLINK ✕"
+  "STARLINK ✕": "STARLINK ✕",
+  "SITES STANDBY": "האתרים בהמתנה",
+  "ENABLE MAPPED INSTALLATIONS FOR SITE PINGS": "הפעל את המתקנים הממופים כדי לקבל צפצופי אתרים",
+  "Unnamed site": "אתר ללא שם",
+  "OFF-NADIR {angle}°": "OFF-NADIR {angle}°",
+  "Release the camera from {name}": "שחרור המצלמה מ-{name}",
+  "Keep the camera on {name}": "השארת המצלמה על {name}",
+  "RETURN · {name}": "חזרה · {name}",
+  "PREVIOUS SATELLITE": "הלוויין הקודם",
+  "Return to {name}": "חזרה אל {name}",
+  "SATELLITE": "לוויין",
+  "Ride {name}": "רכיבה על {name}",
+  "FOCUS · {name}": "מוקד · {name}"
 }
diff --git a/src/i18n/same-as-english.json b/src/i18n/same-as-english.json
index 1a07458b1..3e24182df 100644
--- a/src/i18n/same-as-english.json
+++ b/src/i18n/same-as-english.json
@@ -1290,6 +1290,7 @@
     "OFF-NADIR {angle}° · {offset}",
     "NORAD {id}",
     "EPOCH {time}",
-    "TLE"
+    "TLE",
+    "OFF-NADIR {angle}°"
   ]
 }

From 23609b94b68c97b5a41ccad8df196ce3a81107fe Mon Sep 17 00:00:00 2001
From: Meir Michanie <meirm@cyborg.fi>
Date: Mon, 9 Nov 2026 05:54:28 -0600
Subject: [PATCH 47/71] i18n(he): follow main's place names

---
 src/i18n/locales/he.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json
index 9f8d02315..a864840f8 100644
--- a/src/i18n/locales/he.json
+++ b/src/i18n/locales/he.json
@@ -3381,5 +3381,6 @@
   "Return to {name}": "חזרה אל {name}",
   "SATELLITE": "לוויין",
   "Ride {name}": "רכיבה על {name}",
-  "FOCUS · {name}": "מוקד · {name}"
+  "FOCUS · {name}": "מוקד · {name}",
+  "Place names": "שמות מקומות"
 }

From f79ceb690f818dc93619dc74311433b3c67898a1 Mon Sep 17 00:00:00 2001
From: Meir Michanie <meirm@cyborg.fi>
Date: Mon, 9 Nov 2026 12:04:40 -0600
Subject: [PATCH 48/71] i18n(he): apply review (#1594)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Before merging: singular 'one' forms from the review table (44 entries),
counters keep their order across the slash (מתוך, as Arabic المن), the
lightning layer says ברקים (the legend now counts ברק strikes, the help
text keeps 110°E Latin), configured-elsewhere keys are promised
untouched, Punk is פאנק רוק, dock/panel side labels follow the mirrored
layout, and the HUD-summary English guard covers he (NON_LATIN_LOCALES,
tested) — documented in Adding a language along with format-scope.

Suggestions and nits: restricted is מוגבל, stage recovery is החבה not
שחזור, voice-inactivity names the behavior, lane directions use
attributes (השמאלי) and around is לאחור, Ironbow and KM/S stay Latin in
same-as-english, {age} no longer doubles לפני, typos and garbled words
fixed (תנאים, ידנית, ודאות, מקלט, זמניים, ערוץ 14, מעונן חלקית, אין אות
קריאה, Tab לתצוגה מקדימה, השאר ריק, היוועץ), counted units shortened
(שנ' דק' שע' ימ'), terminology unified (briefing תדריך, forecast תחזית,
course מהלך, אונייה, שריפה), rtl.css shares the mono redirect under
:is(:lang(ar), :lang(he)) and its comments match the rules,
worldOverlayTokens adds Noto Sans Hebrew to the canvas card fonts, he.md
gets the fraction-aware plural table, iw/iw-IL map to he (tested).
---
 docs/TRANSLATORS.md                |   5 +-
 docs/translations/he.md            |  20 +-
 scripts/format-scope.json          |   1 +
 src/hudSummaryLine.test.mjs        |   1 +
 src/hudSummaryResponse.js          |   2 +-
 src/i18n/i18n.test.mjs             |   5 +-
 src/i18n/locale.js                 |   4 +-
 src/i18n/locales/he.json           | 350 +++++++++++++++--------------
 src/i18n/same-as-english.json      |  10 +-
 src/overlays/worldOverlayTokens.js |  28 ++-
 src/ui/styles/rtl.css              |  26 ++-
 11 files changed, 240 insertions(+), 212 deletions(-)

diff --git a/docs/TRANSLATORS.md b/docs/TRANSLATORS.md
index d08711193..ed94fbcbe 100644
--- a/docs/TRANSLATORS.md
+++ b/docs/TRANSLATORS.md
@@ -45,9 +45,10 @@ Edit `src/i18n/locales/<code>.json` and run `npm run i18n`. To see your change,
 1. Create `src/i18n/locales/<code>.json`, fill it from `npm run i18n -- --missing <code>` (start from `{}`), and translate every entry.
 2. Import it in `src/i18n/index.js` and add it to `CATALOGS`.
 3. Add the code to `LOCALES` and its own-language name to `LOCALE_NAMES` in `src/i18n/locale.js`. Right-to-left languages also go in `RTL_LOCALES`; the chrome mirrors through logical CSS properties (`inset-inline-*`, `margin-inline-*`), and `src/ui/styles/rtl.css` holds what those cannot express (see the Arabic notes). If the language should keep Western digits, map it in `INTL_TAGS` in `locale.js`.
-4. Add `src/i18n/locales/<code>.json` next to `ru.json` in `scripts/package-boundaries.json`.
+4. Add `src/i18n/locales/<code>.json` next to `ru.json` in `scripts/package-boundaries.json` and in `scripts/format-scope.json`.
 5. Write `docs/translations/<code>.md`: glossary, plural forms, units and style (copy the structure of `ru.md`).
-6. Run `npm run i18n` and `npm test`, then check the panels in the app at narrow widths.
+6. If the language is not written in Latin letters, also add it to `NON_LATIN_LOCALES` in `src/hudSummaryResponse.js` — that guard falls back to the translated text when a summary provider answers in English.
+7. Run `npm run i18n` and `npm test`, then check the panels in the app at narrow widths.
 
 ## Rules
 
diff --git a/docs/translations/he.md b/docs/translations/he.md
index 6d531cab5..44bb6f0c6 100644
--- a/docs/translations/he.md
+++ b/docs/translations/he.md
@@ -7,7 +7,7 @@ Catalog: `src/i18n/locales/he.json`. General rules: [TRANSLATORS.md](../TRANSLAT
 - Address the user with a masculine imperative, Google style: הסתר, הצג, נסה שוב, התקרב. Menu items and tooltips take the noun form: הסרת {name}, הרחבת {name}, שינוי הצבע של {name}.
 - Sentence case: Hebrew has no case forms, so UPPERCASE English is normal sentence style here; short HUD labels stay short, favor an abbreviation over a wrapped line.
 - Keep the `·`, `—`, `→`, `↗`, `…` separators. Latin codes read inside RTL text because the app isolates interpolated values; leave them alone.
-- Units follow the catalog: ק"מ, מ׳, קמ"ש, שנ', דק', שע'; instrument chips keep the Latin unit (MW, KM, FT, KTS, kn) and codes (HDG, FOV, CAL, SRC, REC) exactly as in English — see `same-as-english.json`.
+- Units follow the catalog: ק"מ, מ׳, קמ"ש, שנ', דק', שע'. Instrument readouts and formatted shared-unit labels keep the Latin units (km, NM, FT, KTS, MW, KM/S); catalog prose outside those readouts keeps ק"מ/מ׳. Codes like HDG, FOV, CAL, SRC, REC stay exactly as in English — see `same-as-english.json`.
 
 ## Digits and direction
 
@@ -19,11 +19,11 @@ Catalog: `src/i18n/locales/he.json`. General rules: [TRANSLATORS.md](../TRANSLAT
 
 A `tn()` entry needs three forms under `Intl.PluralRules('he')`:
 
-| Form    | Counts                    | Example        |
-| ------- | ------------------------- | -------------- |
-| `one`   | 1                         | 1 מצלמה        |
-| `two`   | 2                         | 2 מצלמות       |
-| `other` | 0, 3, 10, 100, fractions… | 5 מצלמות       |
+| Form    | Counts                       | Example        |
+| ------- | ---------------------------- | -------------- |
+| `one`   | 1 and fractions below 1      | 1 מצלמה · 0.5  |
+| `two`   | 2                            | 2 מצלמות       |
+| `other` | 0, 3, 10, 100, integers…     | 5 מצלמות       |
 
 With {count} shown as a digit, `two` and `other` share the plural noun (2 מצלמות, 5 מצלמות); `one` takes the singular (1 מצלמה). For constructs that resist agreement with a noun (אין, הכול, זמין), phrase around the number: "{count} תחנות מדווחות" is fine, but prefer "ממתין: {count}" over a mismatched genitive chain.
 
@@ -37,7 +37,7 @@ With {count} shown as a digit, `two` and `other` share the plural noun (2 מצל
 | LIVE / live data / LIVE TRACK                  | חי / נתונים חיים / מעקב חי                            |
 | SIMULATED                                      | מדומה                                                 |
 | stale / degraded / unavailable                 | מיושן / מופחת / לא זמין                               |
-| key (API key) / POWER UP                       | מפתח / אתחול                                          |
+| key (API key) / POWER UP                       | מפתח / שדרוג                                          |
 | globe / map / map source / basemap             | גלובוס / מפה / מקור מפה / מפת בסיס                    |
 | aircraft / flight / military flight            | מטוס (כלי טיס in class lists) / טיסה / טיסה צבאית     |
 | vessel / ship / ships                          | אונייה / אוניות                                       |
@@ -48,10 +48,10 @@ With {count} shown as a digit, `two` and `other` share the plural noun (2 מצל
 | camera / CCTV camera / ALPR camera             | מצלמה / מצלמת CCTV / מצלמת ALPR                       |
 | earthquake / active fire / cyclone             | רעידת אדמה / שרפה פעילה / ציקלון                      |
 | scene / shot                                   | סצנה / שוט                                            |
-| briefing / panel / dock                        | דיווח / פאנל / עגינה                                  |
+| briefing / panel / dock                        | תדריך / פאנל / עגינה                                  |
 | visual preset / style                          | ערכת ראייה / סגנון                                   |
 | Scope (circular viewport mask) / keyhole       | סקופ / חור המנעול                                    |
-| heading (compass °) / course                   | כיוון / מסלול                                         |
+| heading (compass °) / course                   | כיוון / מהלך                                         |
 | HDG / BRG / CRS / FOV / DEST / SPD / RANGE     | בלי שינוי — קודי מכשיר                               |
 | advisory (NHC/CPHC cyclone)                    | ייעוץ; Advisory center — מרכז הייעוץ                  |
 | Street View (Google)                           | Street View, בלי תרגום                                |
@@ -59,7 +59,7 @@ With {count} shown as a digit, `two` and `other` share the plural noun (2 מצל
 | WHOT/BHOT, Ironbow, CRT, NVG, FLIR             | בלי שינוי — קודים ושמות מצבים                        |
 | PREV / NEXT                                    | הקודם / הבא                                           |
 | anchor / data pack / asset bundle (scene)      | עוגן / חבילת נתונים / חבילת נכסים                   |
+| forecast (weather)                             | תחזית                                                 |
 | witness / geolocated source                    | עד ראייה / מקור נתון גיאוגרפית                        |
 | contained (wildland fire) / FRP                | הכלה / FRP, בלי שינוי                                 |
 
-Latin product, provider and dataset names stay as printed: Google Maps, Cesium ion, OpenSky, ADS-B, AIS, KartaView, Mapillary, Panoramax, Overpass, InciWeb, iNaturalist, Acartia, NASA FIRMS, NOAA, USGS, CelesTrak, TomTom, Sentinel-2, Landsat, VIIRS, HLS, S2 GhostMaps, TeleGeography.
diff --git a/scripts/format-scope.json b/scripts/format-scope.json
index 7dbd9d2b7..7c78179de 100644
--- a/scripts/format-scope.json
+++ b/scripts/format-scope.json
@@ -1293,6 +1293,7 @@
   "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",
diff --git a/src/hudSummaryLine.test.mjs b/src/hudSummaryLine.test.mjs
index 2e8845e88..ae4f15b43 100644
--- a/src/hudSummaryLine.test.mjs
+++ b/src/hudSummaryLine.test.mjs
@@ -143,6 +143,7 @@ for (const [locale, summary] of [
   ['ja', '東京上空のLive Flights'],
   ['zh-CN', '北京航班stale数据'],
   ['ru', 'Остин Live-Flights частично'],
+  ['he', 'תל אביב stale טיסות'],
 ]) {
   test(`English flush against other text is an echo: ${summary}`, () => {
     assert.ok(hudSummaryHasEnglish(summary, locale, ['stale', 'Live Flights']));
diff --git a/src/hudSummaryResponse.js b/src/hudSummaryResponse.js
index 1f41b994d..b12daf4f4 100644
--- a/src/hudSummaryResponse.js
+++ b/src/hudSummaryResponse.js
@@ -110,7 +110,7 @@ const SUMMARY_LANGUAGES = Object.freeze({
 const UNSPACED_LOCALES = /^(?:ja|zh)(?:-|$)/;
 
 /** Shipped locales not written in Latin letters. */
-const NON_LATIN_LOCALES = /^(?:ar|ja|ru|uk|zh)(?:-|$)/;
+const NON_LATIN_LOCALES = /^(?:ar|ja|ru|uk|zh|he)(?:-|$)/;
 
 /** Scripts whose letters extend a word; any other neighbour ends it. */
 const WORD_SCRIPTS = [
diff --git a/src/i18n/i18n.test.mjs b/src/i18n/i18n.test.mjs
index f0b9645c7..7d44b4f8a 100644
--- a/src/i18n/i18n.test.mjs
+++ b/src/i18n/i18n.test.mjs
@@ -41,9 +41,12 @@ test('normalizeLocale folds regional variants and rejects unshipped tags', () =>
   assert.equal(normalizeLocale('de'), 'de');
   assert.equal(normalizeLocale('de-AT'), 'de');
   assert.equal(normalizeLocale('de_CH'), 'de');
-  // Hebrew keeps Western digits like its catalog; regional tags fold to he.
+  // Hebrew keeps Western digits like its catalog; regional tags fold to he,
+  // and the legacy tag iw is still what some browsers and OSes label Hebrew.
   assert.equal(normalizeLocale('he'), 'he');
   assert.equal(normalizeLocale('he-IL'), 'he');
+  assert.equal(normalizeLocale('iw'), 'he');
+  assert.equal(normalizeLocale('iw-IL'), 'he');
   assert.equal(normalizeLocale('fr'), 'fr');
   assert.equal(normalizeLocale('fr-CA'), 'fr');
   assert.equal(normalizeLocale('FR_be'), 'fr');
diff --git a/src/i18n/locale.js b/src/i18n/locale.js
index 9b73444ec..7e8f37ffc 100644
--- a/src/i18n/locale.js
+++ b/src/i18n/locale.js
@@ -64,7 +64,8 @@ export function intlLocale(locale) {
 
 /**
  * Map any language tag to a shipped locale: 'ru-RU' and 'RU' → 'ru',
- * 'ar-EG' and 'ar-SA' → 'ar', 'he-IL' and 'he' → 'he',
+ * 'ar-EG' and 'ar-SA' → 'ar', 'he-IL' and 'he' → 'he', and the
+ * legacy tag 'iw'/'iw-IL' → 'he',
  * 'de-AT' and 'de_CH' → 'de', 'ja-JP' → 'ja',
  * 'pt-BR' and 'pt-PT' → 'pt' (Brazilian Portuguese),
  * 'zh', 'zh-CN' and 'zh-Hans-SG' → 'zh-CN';
@@ -80,6 +81,7 @@ export function normalizeLocale(candidate) {
       ? 'zh-Hant'
       : 'zh-CN';
   }
+  if (primary === 'iw') return 'he';
   return LOCALES.includes(primary) ? primary : null;
 }
 
diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json
index a864840f8..d614063b4 100644
--- a/src/i18n/locales/he.json
+++ b/src/i18n/locales/he.json
@@ -40,7 +40,7 @@
   "Loading the keyless globe...": "טוען גלובוס ללא מפתח...",
   "Google 3D Tiles unavailable ({detail}). Loading the keyless globe...": "Google 3D Tiles אינם זמינים ({detail}). טוען גלובוס ללא מפתח...",
   "Initializing systems...": "מאתחל מערכות...",
-  "Space Missions isolates replay data. Exit the mode to enable {layer}.": "Space Missions מנתק את נתוני השמעה חוזרת. צא מהמצב כדי להפעיל את {layer}.",
+  "Space Missions isolates replay data. Exit the mode to enable {layer}.": "משימות החלל מנתקות את נתוני ההשמעה החוזרת. צא מהמצב כדי להפעיל את {layer}.",
   "Data attribution": "ייחוס נתונים",
   "Data provided by:": "הנתונים מסופקים על ידי:",
   "Close data attribution": "סגירת ייחוס הנתונים",
@@ -242,7 +242,7 @@
   "Overpass temporarily unavailable": "Overpass אינו זמין זמנית",
   "Retrying mapped sites…": "מנסה שוב אתרים ממופים…",
   "Fetching mapped sites…": "שולף אתרים ממופים…",
-  "{reason} — retrying in {seconds}s": "{reason} — מנסה שוב בעוד {seconds} שניות",
+  "{reason} — retrying in {seconds}s": "{reason} — מנסה שוב בעוד {seconds} שנ",
   "{reason} — retry pending": "{reason} — ניסיון חוזר בתור",
   "Zoom in to search mapped installations": "התקרב כדי לחפש מתקנים ממופים",
   "Showing cached mapped sites": "מציג אתרים ממופים מהמטמון",
@@ -307,7 +307,7 @@
   "Live earthquakes and active fires, from USGS and NASA": "רעידות אדמה חיות ושרפות פעילות, מ-USGS ו-NASA",
   "It feels like a forbidden cockpit—then you realize the sources are public and the data is real.": "מרגיש כמו תא טייס אסור — ואז מבינים שהמקורות פומביים והנתונים אמיתיים.",
   "Working…": "מבצע…",
-  "Could not open that mission{detail}. Retry or explore manually.": "לא ניתן לפתוח את המשימה הזאת{detail}. נסה שוב או חקור בידנית.",
+  "Could not open that mission{detail}. Retry or explore manually.": "לא ניתן לפתוח את המשימה הזאת{detail}. נסה שוב או חקור ידנית.",
   "This browser is blocking storage, so that could not be saved.": "הדפדפן הזה חוסם אחסון, ולכן לא ניתן היה לשמור.",
   "NORMAL": "רגיל",
   "CRT": "CRT",
@@ -348,11 +348,11 @@
   "hemisphere|E": "E",
   "hemisphere|W": "W",
   "POWER UP · {count} KEYS WAITING": {
-    "one": "אתחול · {count} מפתח בהמתנה",
-    "two": "אתחול · {count} מפתחות בהמתנה",
-    "other": "אתחול · {count} מפתחות בהמתנה"
+    "one": "שדרוג · {count} מפתח בהמתנה",
+    "two": "שדרוג · {count} מפתחות בהמתנה",
+    "other": "שדרוג · {count} מפתחות בהמתנה"
   },
-  "POWERED UP": "מופעל",
+  "POWERED UP": "שודרג",
   "Provider Settings does not answer proxied requests": "הגדרות הספקים אינן עונות על בקשות פרוקסי",
   "Provider Settings is disabled while sharing is enabled": "הגדרות הספקים אינן זמינות במסגרת שיתוף פעיל",
   "Provider Settings answers only the machine running the server": "הגדרות הספקים עונות רק למכונה שמריצה את השרת",
@@ -371,7 +371,7 @@
   "{name} must be a string": "{name} חייב להיות מחרוזת",
   "{name} is empty": "{name} ריק",
   "{name} is longer than any real key ({limit} max)": "{name} ארוך מכל מפתח אמיתי ({limit} לכל היותר)",
-  "{name} may only contain printable characters with no spaces": "{name} עשוי להכיל רק תווים שניתנים להדפסה ללא רווחים",
+  "{name} may only contain printable characters with no spaces": "{name} יכול להכיל רק תווים שניתנים להדפסה ללא רווחים",
   "{name} contains a character that is not valid in a key (#, quotes, $, \\, or backtick)": "{name} מכיל תו שאינו תקין במפתח (#, מירכאות, $, \\, או בק-טיק)",
   "{name} is configured outside Provider Settings and can only be changed where it was set": "{name} מוגדר מחוץ להגדרות הספקים וניתן לשינוי רק במקום שבו הוגדר",
   "The key was not saved: could not restrict the credential file to your account; nothing was saved": "המפתח לא נשמר: לא הצליח להגביל את קובץ הפרטים לחשבון שלך; לא נשמר דבר",
@@ -413,7 +413,7 @@
   "Bing imagery map stacks + world terrain": "ערמות מפות צילומים של Bing + טופוגרפיה עולמית",
   "More flight-polling credits (anonymous works without)": "אשראי דגימת טיסות נוסף (אנונימי עובד בלעדיו)",
   "Street-level imagery and coverage in the Street Level layer. Free: register an app in the Mapillary developer dashboard and paste its Client Token": "צילומי רחוב וכיסוי בשכבת Street Level. חינם: רשמו אפליקציה במרכז השליטה המפתחים של Mapillary והדביקו את ה-Client Token שלה",
-  "Public space-missions access needs no key. Leave blank for standard use; paid tokens only raise request limits.": "הגישה הציבורית למשימות החלל אינה דורשת מפתח. השאר לריקה לשימוש הרגיל; אסימונים בתשלום מעלים רק מגבלות בקשות.",
+  "Public space-missions access needs no key. Leave blank for standard use; paid tokens only raise request limits.": "הגישה הציבורית למשימות החלל אינה דורשת מפתח. השאר ריק לשימוש הרגיל; אסימונים בתשלום מעלים רק את מגבלות הבקשות.",
   "Air quality request failed": "בקשת איכות האוויר נכשלה",
   "No readings available": "אין מדידות זמינות",
   "No current readings": "אין מדידות נוכחיות",
@@ -469,7 +469,7 @@
   "At least {count}": "{count} לפחות",
   "CONTEXT READY": "ההקשר מוכן",
   "GLOBAL CONTEXT OFF": "ההקשר הגלובלי כבוי",
-  "SELECT A FLIGHT, VESSEL, OR MAPPED INSTALLATION": "בחר טיסה, כלי שיט או מתקן ממופה",
+  "SELECT A FLIGHT, VESSEL, OR MAPPED INSTALLATION": "בחר טיסה, אונייה או מתקן ממופה",
   "ENABLE TO LOAD OBSERVED / MAPPED PROXIMITY": "הפעל כדי לטעון קרבה נצפית / ממופה",
   "Unavailable": "לא זמין",
   "Focus {label}": "התמקד ב-{label}",
@@ -480,8 +480,8 @@
   "NEXT": "הבא",
   "Next — nearest unvisited contact in the 250 km window": "הבא — המגע הקרוב ביותר שלא ביקרת בו בחלון של 250 ק\"מ",
   "Named areas ({n})": "אזורים בעלי שם ({n})",
-  "{distance} FLIGHT / VESSEL WINDOW": "חלון טיסות / כלי שיט של {distance}",
-  "Open-source mapped/observed context. Missing broadcasts, unloaded map areas, or unmapped sites are not evidence of absence.": "הקשר ממופה/נצפה בקוד פתח. שידורים חסרים, אזורי מפה שלא נטענו או אתרים שלא ממופו אינם הוכחה להיעדר.",
+  "{distance} FLIGHT / VESSEL WINDOW": "חלון טיסות / אוניות של {distance}",
+  "Open-source mapped/observed context. Missing broadcasts, unloaded map areas, or unmapped sites are not evidence of absence.": "הקשר ממופה/נצפה ממקורות פתוחים. שידורים חסרים, אזורי מפה שלא נטענו או אתרים שלא ממופו אינם הוכחה להיעדר.",
   "mapped matches within {km} km of the subject": "התאמות ממופות בטווח {km} ק\"מ מהעצם",
   "none mapped within {km} km; not a complete 250 km survey": "אין התאמות ממופות בטווח {km} ק\"מ; אינו מיפוי מלא של 250 ק\"מ",
   "mapped matches from the loaded viewport": "התאמות ממופות מתוך התצוגה שנטענה",
@@ -494,7 +494,7 @@
   "WITHIN {km} KM": "בטווח {km} ק\"מ",
   "Flights": "טיסות",
   "Military flights": "טיסות צבאיות",
-  "AIS vessels": "כלי שיט AIS",
+  "AIS vessels": "אוניות AIS",
   "Mapped installations": "מתקנים ממופים",
   "syncing {count} city feeds...": "מסנכרן {count} פידי ערים...",
   "scanning nearby systems...": "סורק מערכות סמוכות...",
@@ -564,9 +564,9 @@
   "Official advisory ↗": "ייעוץ רשמי ↗",
   "Active NHC and CPHC cyclone advisories": "ייעוצי ציקלונים פעילים של NHC ו-CPHC",
   "Wind unavailable": "רוח אינה זמינה",
-  "Advisory center / forecast track": "מרכז הייעוץ / מסלול חזוי",
-  "Center-track uncertainty cone": "חרוט אי-ודאות של מסלול המרכז",
-  "Select a storm on the map, or choose a storm in the list to select it and move the camera. Click empty map space to clear the selection. NOAA NHC/CPHC advisory context. The cone describes forecast center-track uncertainty, not storm size or the full hazard area. Forecast point labels are source lead hours, not times computed from advisory issuance. Geometry follows the surface; height is not weather altitude. Consult the official advisory.": "בחר סערה במפה, או בחר סערה ברשימה כדי לבחור אותה ולהזיז את המצלמה. לחץ בשטח ריק במפה כדי לבטל את הבחירה. הקשר ייעוצים של NOAA NHC/CPHC. החרוט מתאר אי-ודאות של מסלול המרכז בחזוי, לא את גודל הסערה ולא את מלוא אזור הסכנה. תוויות נקודות החזוי הן שעות חיזוי של המקור, לא זמנים שחושבו מפרסום הייעוץ. הגאומטריה נצמדת לפני הקרקע; הגובה אינו גובה מטאורולוגי. היווע בייעוץ הרשמי.",
+  "Advisory center / forecast track": "מרכז הייעוץ / מסלול התחזית",
+  "Center-track uncertainty cone": "חרוט אי-הוודאות של מהלך המרכז",
+  "Select a storm on the map, or choose a storm in the list to select it and move the camera. Click empty map space to clear the selection. NOAA NHC/CPHC advisory context. The cone describes forecast center-track uncertainty, not storm size or the full hazard area. Forecast point labels are source lead hours, not times computed from advisory issuance. Geometry follows the surface; height is not weather altitude. Consult the official advisory.": "בחר סערה במפה, או בחר סערה ברשימה כדי לבחור אותה ולהזיז את המצלמה. לחץ בשטח ריק במפה כדי לבטל את הבחירה. הקשר ייעוצים של NOAA NHC/CPHC. החרוט מתאר אי-ודאות של מסלול המרכז בתחזית, לא את גודל הסערה ולא את מלוא אזור הסכנה. תוויות נקודות התחזית הן שעות חיזוי של המקור, לא זמנים שחושבו מפרסום הייעוץ. הגאומטריה נצמדת לפני הקרקע; הגובה אינו גובה מטאורולוגי. היוועץ בייעוץ הרשמי.",
   "Malformed cyclone snapshot": "תמונת מצב של ציקלון פגומה",
   "Cyclone request timed out": "בקשת הציקלון חרגה מהזמן הקצוב",
   "DRIVE": "נסיעה",
@@ -584,7 +584,7 @@
   "direction|sharply left": "שמאלה בחדות",
   "direction|sharply right": "ימינה בחדות",
   "direction|straight": "ישר",
-  "direction|around": "דרך המעגל",
+  "direction|around": "לאחור",
   "fork direction|left": "שמאלה",
   "fork direction|right": "ימינה",
   "fork direction|slightly left": "שמאלה קלות",
@@ -592,13 +592,13 @@
   "fork direction|sharply left": "שמאלה בחדות",
   "fork direction|sharply right": "ימינה בחדות",
   "fork direction|straight": "ישר",
-  "lane direction|left": "שמאלה",
-  "lane direction|right": "ימינה",
-  "lane direction|slightly left": "שמאלה קלות",
-  "lane direction|slightly right": "ימינה קלות",
-  "lane direction|sharply left": "שמאלה בחדות",
-  "lane direction|sharply right": "ימינה בחדות",
-  "lane direction|straight": "ישר",
+  "lane direction|left": "השמאלי",
+  "lane direction|right": "הימני",
+  "lane direction|slightly left": "השמאלי הקל",
+  "lane direction|slightly right": "הימני הקל",
+  "lane direction|sharply left": "השמאלי החד",
+  "lane direction|sharply right": "הימני החד",
+  "lane direction|straight": "הישר",
   "ordinal|{number}st": "{number}.",
   "ordinal|{number}nd": "{number}.",
   "ordinal|{number}rd": "{number}.",
@@ -667,8 +667,8 @@
   "Swap A and B": "החלפה בין A ל-B",
   "FLY ···": "עף ···",
   "FLYING": "בטיסה",
-  "FLY": "עף",
-  "Fly the camera along the route": "עיפה את המצלמה לאורך המסלול",
+  "FLY": "טוס",
+  "Fly the camera along the route": "טוס עם המצלמה לאורך המסלול",
   "Place A and B first": "קבע קודם את A ו-B",
   "action|CLEAR": "נקה",
   "Remove the route and both markers": "הסרת המסלול ושני הסמנים",
@@ -696,12 +696,12 @@
   "From {lower}": "מ-{lower}",
   "Informational only · not for flight planning": "למידע בלבד · לא לתכנון טיסה",
   "Unnamed zone": "אזור ללא שם",
-  "Restricted airspace source unavailable": "מקור שמורות הטיס אינו זמין",
+  "Restricted airspace source unavailable": "מקור השמיים המוגבלים אינו זמין",
   "Prohibited (P)": "אסור (P)",
-  "Restricted (R)": "שמור (R)",
-  "FAA prohibited and restricted special-use airspace only, not the UAS Facility Map or UAS flight restrictions. Informational only — not a substitute for official UAS flight-planning tools (B4UFLY / LAANC).": "שמורות טיס ושמיים מיוחדים אסורים של ה-FAA בלבד, לא מפת ה-UAS Facility או מגבלות טיסה של UAS. למידע בלבד — אינו תחליף לכלי תכנון טיסה רשמיים של UAS (B4UFLY / LAANC).",
+  "Restricted (R)": "מוגבל (R)",
+  "FAA prohibited and restricted special-use airspace only, not the UAS Facility Map or UAS flight restrictions. Informational only — not a substitute for official UAS flight-planning tools (B4UFLY / LAANC).": "השמיים האסורים (P) והמוגבלים (R) לשימוש מיוחד של ה-FAA בלבד, לא מפת ה-UAS Facility ולא מגבלות הטיסה של UAS. למידע בלבד — אינו תחליף לכלי תכנון הטיסה הרשמיים של UAS (B4UFLY / LAANC).",
   "Prohibited": "אסור",
-  "Restricted": "שמור",
+  "Restricted": "מוגבל",
   "Earthquake source unavailable": "מקור רעידות האדמה אינו זמין",
   "Focus fire detection {title}, {details}": "התמקדות בזיהוי שריפה {title}, {details}",
   "live feed unavailable": "פיד חי אינו זמין",
@@ -714,7 +714,7 @@
   "max {value} MW": "מקס {value} MW",
   "new {value}": "חדש לפני {value}",
   "{n} fires": {
-    "one": "{n} שריפות",
+    "one": "{n} שריפה",
     "two": "{n} שריפות",
     "other": "{n} שריפות"
   },
@@ -730,7 +730,7 @@
   "fire confidence|nominal": "רגילה",
   "fire confidence|low": "נמוכה",
   "age|<1h": "פחות משעה",
-  "age|{count}h": "{count} שעות",
+  "age|{count}h": "{count} שע",
   "age|{count}d": "{count} ימים",
   "fire confidence filter|All": "הכול",
   "fire confidence filter|Nominal+": "רגילה+",
@@ -739,17 +739,17 @@
   "Nominal and high confidence detections": "זיהויים בוודאות רגילה וגבוהה",
   "High confidence detections only": "זיהויים בוודאות גבוהה בלבד",
   "Fire intensity (FRP)": "עוצמת השריפה (FRP)",
-  "Minimum fire radiative power, megawatts": "ספק קרינת שריפה מינימלי, מגה-ואט",
+  "Minimum fire radiative power, megawatts": "הספק קרינת השריפה המינימלי, במגה-ואט",
   "≥ {value} MW": "≥ {value} MW",
   "fire intensity filter|All": "הכול",
   "Confidence": "ודאות",
-  "Detection confidence": "ודאת הזיהוי",
+  "Detection confidence": "ודאות הזיהוי",
   "{shown} of {total} shown": "{shown} מתוך {total} מוצגים",
   "STALE · cached {age}": "מיושן · מהמטמון לפני {age}",
   "refreshing...": "מרענן...",
   "loading...": "טוען...",
   "KEY REQUIRED": "נדרש מפתח",
-  "LIVE · updated {age}": "חי · עודכן לפני {age}",
+  "LIVE · updated {age}": "חי · עודכן {age}",
   "FIRE": "שריפה",
   "Source snapshot time unavailable": "זמן תמונת המצב של המקור אינו זמין",
   "Live data unavailable": "נתונים חיים אינם זמינים",
@@ -770,7 +770,7 @@
   "Report": "דוח",
   "Open the source for {title}": "פתיחת המקור של {title}",
   "GhostMaps catalog unavailable": "קטלוג GhostMaps אינו זמין",
-  "LIVE · GitHub {commit} · {message} · checked every {seconds}s": "חי · GitHub {commit} · {message} · בדיקה כל {seconds} שניות",
+  "LIVE · GitHub {commit} · {message} · checked every {seconds}s": "חי · GitHub {commit} · {message} · בדיקה כל {seconds} שנ",
   "GitHub {commit} · {message} · reconnecting for live updates": "GitHub {commit} · {message} · מתחבר מחדש לעדכונים חיים",
   "Connecting to the S2 GhostMaps repository…": "מתחבר למאגר S2 GhostMaps…",
   "{count} placemarks": {
@@ -804,13 +804,13 @@
   "installation class|INSTALLATION": "מתקן",
   "No mapped sites within {km} km of the contact": "אין אתרים ממופים בטווח {km} ק\"מ מהמגע",
   "{count} mapped sites within {km} km of the contact": {
-    "one": "{count} אתרים ממופים בטווח {km} ק\"מ מהמגע",
+    "one": "{count} אתר ממופה בטווח {km} ק\"מ מהמגע",
     "two": "{count} אתרים ממופים בטווח {km} ק\"מ מהמגע",
     "other": "{count} אתרים ממופים בטווח {km} ק\"מ מהמגע"
   },
   "No mapped sites in view": "אין אתרים ממופים בתצוגה",
   "{count} mapped sites in view": {
-    "one": "{count} אתרים ממופים בתצוגה",
+    "one": "{count} אתר ממופה בתצוגה",
     "two": "{count} אתרים ממופים בתצוגה",
     "other": "{count} אתרים ממופים בתצוגה"
   },
@@ -826,7 +826,7 @@
   "LIFTOFF · {mission}": "ניתוק מהקרקע · {mission}",
   "ASCENT REPLAY · {mission}": "שחזור עלייה · {mission}",
   "ASCENT ESTIMATE · {mission}": "הערכת עלייה · {mission}",
-  "STAGE RE-ENTRY / RECOVERY · {mission}": "חדירה חזרה / שחזור שלב · {mission}",
+  "STAGE RE-ENTRY / RECOVERY · {mission}": "כניסה חוזרת / השבת שלב · {mission}",
   "ORBIT REPLAY · {mission}": "שחזור מסלול · {mission}",
   "PAUSED · {title}": "מושהה · {title}",
   "CONFIRMED": "מאושר",
@@ -843,14 +843,14 @@
   "{count} / 30D": "{count} / 30D",
   "NO MISSIONS AVAILABLE IN THE CURRENT 30-DAY WINDOW": "אין משימות זמינות בחלון 30 הימים הנוכחי",
   "{value} KM": "{value} ק\"מ",
-  "{value} KM/S": "{value} ק\"מ/ש",
+  "{value} KM/S": "{value} KM/S",
   "EST. DOWNRANGE": "הערכה במורד הטווח",
   "PLANNED · ": "מתוכנן · ",
   "SUPPLIED TRAJECTORY POINTS": "נקודות מסלול שסופקו",
   "RECONSTRUCTED ESTIMATE": "הערכת שחזור",
   "Resume replay": "המשך השמעה חוזרת",
   "Pause replay": "השהה השמעה חוזרת",
-  "T minus {seconds}": "נותרו {seconds} שניות לשיגור",
+  "T minus {seconds}": "נותרו {seconds} שנ לשיגור",
   "Preparing launch site": "מכין את אתר השיגור",
   "Liftoff": "ניתוק",
   "Ascent replay": "שחזור עלייה",
@@ -865,14 +865,14 @@
   "Your RTL-SDR receiver and decoder feed": "מקלט ה-RTL-SDR שלך ופיד הדקודר",
   "Your decoder feed": "פיד הדקודר שלך",
   "Your RTL-SDR receiver": "מקלט ה-RTL-SDR שלך",
-  "NO CALLSIGN": "אין קריאת קוד",
+  "NO CALLSIGN": "אין אות קריאה",
   "ALT {altitude} FT · GS {speed} KT · TRK {track}": "ALT {altitude} FT · GS {speed} KT · TRK {track}",
   "V/S {rate}": "V/S {rate}",
   "V/S {rate} FPM": "V/S {rate} FPM",
   "POSITION {age}": "מיקום לפני {age}",
-  "POSITION {seconds} S AGO": "מיקום לפני {seconds} שניות",
+  "POSITION {seconds} S AGO": "מקום לפני {seconds} שנ",
   "{count} MSGS": {
-    "one": "{count} הודעות",
+    "one": "{count} הודעה",
     "two": "{count} הודעות",
     "other": "{count} הודעות"
   },
@@ -973,7 +973,7 @@
   "Metal": "מטאל",
   "Oldies": "קלאסיקות",
   "Pop": "פופ",
-  "Punk": "פאנק",
+  "Punk": "פאנק רוק",
   "R&B": "R&B",
   "Reggae": "רגאיי",
   "Rock": "רוק",
@@ -1161,7 +1161,7 @@
   "feed down": "הפיד מושבת",
   "feed idle": "פיד בחוסר פעילות",
   "API key rejected — check AISSTREAM_API_KEY": "מפתח ה-API נדחה — בדוק את AISSTREAM_API_KEY",
-  "feed silent {seconds}s — no AIS data": "פיד שקט {seconds} שניות — אין נתוני AIS",
+  "feed silent {seconds}s — no AIS data": "פיד שקט {seconds} שנ — אין נתוני AIS",
   "feed silent — no AIS data": "פיד שקט — אין נתוני AIS",
   "feed down — retrying slowly (attempt {attempt})": "הפיד מושבת — מנסה שוב לאט (ניסיון {attempt})",
   "reconnecting to feed… (attempt {attempt})": "מתחבר מחדש לפיד… (ניסיון {attempt})",
@@ -1188,24 +1188,24 @@
   "{detail} · nearest": "{detail} · הקרוב",
   "RADAR · {units}": "רדאר · {units}",
   "RADAR REFLECTIVITY · dBZ": "רפלקטיביות רדאר · dBZ",
-  "LIGHTNING DENSITY · 15 min accumulation": "צפיפות מכות · צבירה של 15 דק",
+  "LIGHTNING DENSITY · 15 min accumulation": "צפיפות ברקים · צבירה של 15 דק",
   "GLOBAL INFRARED · hourly": "אינפרא-אדום גלובלי · לכל שעה",
   "GOES INFRARED · ~5 min": "אינפרא-אדום GOES · ~5 דק",
   "{state}: {time}": "{state}: {time}",
   "Latest observation": "התצפית האחרונה",
-  "frame {index}/{total}": "שקופית {index}/{total}",
+  "frame {index}/{total}": "שקופית {index} מתוך {total}",
   "loading": "טוען",
   "Observation: unavailable": "תצפית: לא זמינה",
   "Contiguous US · gaps ≠ no rain": "ארה\"ב הרציפה · פערים ≠ אין גשם",
-  "Americas + Pacific · not individual strikes": "האמריקות + הפסיפיק · לא מכות בודדות",
+  "Americas + Pacific · not individual strikes": "האמריקות + הפסיפיק · לא פגיעות בודדות",
   "60°S–60°N · typically 2–3 h delayed": "60°S–60°N · בדרך כלל בפער 2–3 שע",
   "North America · infrared imagery": "אמריקה הצפונית · צילומי אינפרא-אדום",
-  "Color: strikes/km²/min ×10³": "צבע: מכות/קמ\"ר/דק ×10³",
+  "Color: strikes/km²/min ×10³": "צבע: פגיעות ברק/קמ\"ר/דק ×10³",
   "Color: {units}": "צבע: {units}",
   "Reduced motion · history playback unavailable": "תנועה מופחתת · הצגת ההיסטוריה אינה זמינה",
   "Reduced motion · manual history available": "תנועה מופחתת · היסטוריה ידנית זמינה",
   "Rain radar · US": "רדאר גשם · ארה\"ב",
-  "Lightning density · 15 min": "צפיפות מכות · 15 דק",
+  "Lightning density · 15 min": "צפיפות ברקים · 15 דק",
   "Satellite clouds": "עננים מלוויין",
   "Americas + Pacific": "האמריקות + הפסיפיק",
   "Global · 60°S–60°N": "גלובלית · 60°S–60°N",
@@ -1214,7 +1214,7 @@
   "Stale source": "מקור מיושן",
   "Loading next frame…": "טוען את השקופית הבאה…",
   "Map center outside coverage": "מרכז המפה מחוץ לכיסוי",
-  "strikes/km²/min ×10³": "מכות/קמ\"ר/דק ×10³",
+  "strikes/km²/min ×10³": "פגיעות ברק/קמ\"ר/דק ×10³",
   "N. America": "צפ. אמריקה",
   "Global": "גלובלי",
   "Hourly global mosaic; usually 2–3 hours delayed": "פסיפס גלובלי של שעה; בדרך כלל בפער 2–3 שעות",
@@ -1229,13 +1229,13 @@
   "View coverage": "הצג כיסוי",
   "View US radar": "הצג רדאר ארה\"ב",
   "View Americas & Pacific": "הצג האמריקות והפסיפיק",
-  "{value} strikes/km²/min ×10³ (15-minute density)": "{value} מכות/קמ\"ר/דק ×10³ (צפיפות 15 דק)",
+  "{value} strikes/km²/min ×10³ (15-minute density)": "{value} פגיעות ברק/קמ\"ר/דק ×10³ (צפיפות 15 דק)",
   "{value} dBZ radar reflectivity": "{value} dBZ רפלקטיביות רדאר",
   "STALE · cached source metadata": "מיושן · מידע המקור מהמטמון",
   "Map center is outside source coverage": "מרכז המפה מחוץ לכיסוי המקור",
-  "NOAA/NWS 15-minute lightning density derived from Vaisala NLDN/GLD360. Coverage 110°E across the Pacific/Americas to 0°, 25°S–80°N. Not a live strike count, global coverage or a safety warning.": "צפיפות מכות של 15 דק מ-NOAA/NWS, נגזרת מ-Vaisala NLDN/GLD360. כיסוי מ-110°צ דרך הפסיפיק/אמריקות עד 0°, בין 25°S–80°N. אינו מנייה חיה של מכות, כיסוי גלובלי, ולא אזהרת בטיחות.",
+  "NOAA/NWS 15-minute lightning density derived from Vaisala NLDN/GLD360. Coverage 110°E across the Pacific/Americas to 0°, 25°S–80°N. Not a live strike count, global coverage or a safety warning.": "צפיפות ברקים של 15 דק מ-NOAA/NWS, נגזרת מ-Vaisala NLDN/GLD360. כיסוי מ-110°E דרך הפסיפיק/האמריקות עד 0°, בין 25°S–80°N. אינו מנייה חיה של פגיעות, כיסוי גלובלי, ולא אזהרת בטיחות.",
   "NOAA MRMS radar echoes indicate precipitation patterns, not rain rate, a storm warning or a future forecast. Native source approximately 1 km; display is limited to level 6. Frames use exact advertised observation times.": "הדי הרדאר של NOAA MRMS מציינים דפוסי משקעים, לא קצב גשם, אזהרת סערה או חזוי עתידי. המקור הילידי בערך 1 ק\"מ; התצוגה מוגבלת לרמה 6. השקופיות משתמשות בזמני התצפית שהוכרזו, במדויק.",
-  "GOES-19/18 longwave infrared Band 14 regional; NESDIS global longwave mosaic. Clouds only dims everything but bright, cold cloud tops; a brightness filter, not a cloud mask. Coverage and freshness differ by region.": "אינפרא-אדום גלים ארוכים מוכ״ס 14 של GOES-19/18, אזורי; פסיפס גלים ארוכים גלובלי של NESDIS. „עננים בלבד“ מעמעם הכול מלבד ראשי עננים קרים ובהירים; זהו מסנן בהירות, לא מסך עננים. הכיסוי והרעננות משתנים לפי אזור.",
+  "GOES-19/18 longwave infrared Band 14 regional; NESDIS global longwave mosaic. Clouds only dims everything but bright, cold cloud tops; a brightness filter, not a cloud mask. Coverage and freshness differ by region.": "האינפרא-אדום בגלים ארוכים של GOES-19/18, ערוץ 14, אזורי; פסיפס עולמי של גלים ארוכים מ-NESDIS. „עננים בלבד\" מעמעם הכול מלבד ראשי העננים הקרים והבהירים; זהו מסנן בהירות, לא מסך עננים. הכיסוי והרעננות משתנים לפי האזור.",
   "REGION": "אזור",
   "FILTER": "מסנן",
   "Cloud filter strength": "עוצמת סינון עננים",
@@ -1290,23 +1290,23 @@
   "{source} HTTP {status}": "{source} HTTP {status}",
   "Wind": "רוח",
   "Wind source unavailable": "מקור הרוח אינו זמין",
-  "Forecast · does not follow history": "חזוי · אינו מתאים להיסטוריה",
+  "Forecast · does not follow history": "תחזית · אינה נעה עם ההיסטוריה",
   "Wind motion": "תנועת רוח",
   "Wind speed": "מהירות רוח",
   "Sea-level pressure": "לחץ בגובה פני הים",
   "Air temperature · 2 m": "טמפרטורת אוויר · 2 מ׳",
   "Global · 1° grid": "גלובלי · סריג 1°",
-  "{model} forecast · {time}": "חזוי {model} · {time}",
-  "Loading forecast": "טוען חזוי",
+  "{model} forecast · {time}": "תחזית {model} · {time}",
+  "Loading forecast": "טוען תחזית",
   "Preparing flow": "מכין זרימה",
   "Selected field unavailable": "השדה הנבחר אינו זמין",
-  "Cached forecast · stale": "חזוי מהמטמון · מיושן",
-  "ECMWF IFS surface forecast": "חזוי פני קרקע ECMWF IFS",
-  "NOAA GFS surface forecast": "חזוי פני קרקע NOAA GFS",
+  "Cached forecast · stale": "תחזית מהמטמון · מיושנת",
+  "ECMWF IFS surface forecast": "תחזית פני הקרקע ECMWF IFS",
+  "NOAA GFS surface forecast": "תחזית פני הקרקע NOAA GFS",
   "Reduced motion": "תנועה מופחתת",
   "Resume": "המשך",
   "Pause": "השהה",
-  "Pause visual flow; forecast time does not advance with animation": "השהה את הזרימה החזותית; זמן החזוי אינו מתקדם עם ההנפשה",
+  "Pause visual flow; forecast time does not advance with animation": "השהה את הזרימה החזותית; זמן התחזית אינו מתקדם עם ההנפשה",
   "None": "ללא",
   "Speed": "מהירות",
   "Pressure": "לחץ",
@@ -1317,19 +1317,19 @@
   "Air temperature two meters above the surface": "טמפרטורת אוויר שני מטרים מעל הקרקע",
   "Wind speed units": "יחידות מהירות רוח",
   "Read wind at map center": "קרא רוח במרכז המפה",
-  "Read the forecast at the center of the map without changing selection": "קרא את החזוי במרכז המפה מבלי לשנות את הבחירה",
-  "{model} forecast · {field} ({unit})": "חזוי {model} · {field} ({unit})",
+  "Read the forecast at the center of the map without changing selection": "קריאת התחזית במרכז המפה מבלי לשנות את הבחירה",
+  "{model} forecast · {field} ({unit})": "תחזית {model} · {field} ({unit})",
   "Valid: {time}": "תקף: {time}",
   "preparing": "בהכנה",
   "Issued: {time}": "פורסם: {time}",
   "Selected field unavailable · wind remains visible": "השדה הנבחר אינו זמין · הרוח נשארת גלויה",
   "{error} · wind remains visible": "{error} · הרוח נשארת גלויה",
-  "Surface wind at 10 m. Approximately 1° global grid. Curves follow the 10 m wind field, lifted 12 km for visibility; display height is not weather altitude. View lighting is for readability. Animation shows flow through one fixed forecast; it does not advance time. Color fields drape the globe basemap or the active photorealistic 3D Tiles.": "רוח פני קרקע בגובה 10 מ׳. סריג גלובלי בערך 1°. העקומות עוקבות שדה הרוח ב-10 מ׳, מוגבהות 12 ק\"מ לראות; גובה התצוגה אינו גובה מטאורולוגי. תאורת הצפייה לצורך קריאות. ההנפשה מציגה זרימה בחזוי קבוע אחד; היא מתקה מעט זמן. שדות הצבע מכסים את מפת בסיס הגלובלי, או את Google 3D Tiles הפעיל.",
+  "Surface wind at 10 m. Approximately 1° global grid. Curves follow the 10 m wind field, lifted 12 km for visibility; display height is not weather altitude. View lighting is for readability. Animation shows flow through one fixed forecast; it does not advance time. Color fields drape the globe basemap or the active photorealistic 3D Tiles.": "רוח פני הקרקע בגובה 10 מ׳, על סריג של כ-1°. העקומות עוקבות את שדה הרוח בגובה 10 מ׳, מוגבהות 12 ק\"מ לקריאות; גובה התצוגה אינו גובה מטאורולוגי. תאורת התצוגה נועדה לקריאות. ההנפשה מציגה זרימה בתחזית אחת קבועה; היא אינה מקדמת את הזמן. שדות הצבע נפרשים מעל מפת הבסיס של הגלובוס או מעל ה-3D Tiles הפוטוריאליסטיים הפעילים.",
   "MODEL": "מודל",
   "FIELD": "שדה",
   "UNITS": "יחידות",
   "MOTION": "תנועה",
-  "Forecast": "חזוי",
+  "Forecast": "תחזית",
   "N": "N",
   "NNE": "NNE",
   "NE": "NE",
@@ -1348,8 +1348,8 @@
   "NNW": "NNW",
   "No surface reading": "אין קריאת שטח",
   "Aim the map center at Earth": "כוון את מרכז המפה אל העולם",
-  "A location reading needs a loaded forecast and the Earth at the center of the view.": "קריאת מיקום דורשת חזוי נטען וכדור הארץ במרכז התצוגה.",
-  "Interpolated model forecast on an approximately 1° grid. Broad weather patterns, not a street-level measurement.": "חזוי מודל באינטרפולציה על סריג של כ-1°. דפוסי מזג אוויר רחבים, לא מדידה ברמת הרחוב.",
+  "A location reading needs a loaded forecast and the Earth at the center of the view.": "קריאת מקום דורשת תחזית טעונה ואת כדור הארץ במרכז התצוגה.",
+  "Interpolated model forecast on an approximately 1° grid. Broad weather patterns, not a street-level measurement.": "תחזית מודל באינטרפולציה על סריג של כ-1°. דפוסי מזג אוויר רחבים, לא מדידה ברמת הרחוב.",
   " · calm": " · שקטה",
   " from {direction}": " מ-{direction}",
   "WIND AT {coordinates}": "רוח ב-{coordinates}",
@@ -1400,12 +1400,12 @@
   "Cannot update {scene}: evidence beats changed": "לא ניתן לעדכן את {scene}: קטעי הראיות השתנו",
   "Cannot update {scene}: shot bindings are incomplete": "לא ניתן לעדכן את {scene}: קשירות השוטים אינן שלמות",
   "Updated {count} shots: {scene}": {
-    "one": "עודכנו {count} שוטים: {scene}",
+    "one": "עודכן {count} שוט: {scene}",
     "two": "עודכנו {count} שוטים: {scene}",
     "other": "עודכנו {count} שוטים: {scene}"
   },
   "Appended {count} shots: {scene}": {
-    "one": "צורפו {count} שוטים: {scene}",
+    "one": "צורף {count} שוט: {scene}",
     "two": "צורפו {count} שוטים: {scene}",
     "other": "צורפו {count} שוטים: {scene}"
   },
@@ -1433,7 +1433,7 @@
   "Action unavailable or cancelled": "הפעולה אינה זמינה או בוטלה",
   "Select a feature or use Tab and Enter to choose an action.": "בחר אובייקט, או השתמש ב-Tab ו-Enter לבחירת פעולה.",
   "Selected feature: {feature}. Choose an action.": "נבחר אובייקט: {feature}. בחר פעולה.",
-  "Running {index}/{total}: {scene} / {shot}": "מריץ {index}/{total}: {scene} / {shot}",
+  "Running {index}/{total}: {scene} / {shot}": "מריץ {index} מתוך {total}: {scene} / {shot}",
   "Scene run complete": "ריצת הסצנה הושלמה",
   "Bhote Koshi Evidence Sequence": "רצף הראיות של Bhote Koshi",
   "Nepal Flood Incident": "אירוע השיטפון בנפאל",
@@ -1466,17 +1466,17 @@
   "the scene data failed validation": "נתוני הסצנה נכשלו באימות",
   "Could not complete this action. Check the file, references and selected assets.": "לא ניתן להשלים את הפעולה הזאת. בדוק את הקובץ, ההתייחסויות והנכסים הנבחרים.",
   "{count} scenes": {
-    "one": "{count} סצנות",
+    "one": "{count} סצנה",
     "two": "{count} סצנות",
     "other": "{count} סצנות"
   },
   "{count} shots": {
-    "one": "{count} שוטים",
+    "one": "{count} שוט",
     "two": "{count} שוטים",
     "other": "{count} שוטים"
   },
   "{count} data packs": {
-    "one": "{count} חבילות נתונים",
+    "one": "{count} חבילת נתונים",
     "two": "{count} חבילות נתונים",
     "other": "{count} חבילות נתונים"
   },
@@ -1526,7 +1526,7 @@
   "SDR decoder fell behind; receiver stopped": "פענוח ה-SDR נשאר מאחור; המקלט נעצר",
   "WebUSB requires desktop Chrome or Edge": "WebUSB דורש Chrome או Edge שולחני",
   "Waiting for an RTL-SDR device…": "ממתין למקלט RTL-SDR…",
-  "Browser audio is suspended; press Connect again to resume it": "שמע הדפדפן מושהה; הקש Connect שוב כדי לחדש אותו",
+  "Browser audio is suspended; press Connect again to resume it": "שמע הדפדפן מושהה; הקש \"חבר\" שוב כדי לחדש אותו",
   "RTL-SDR sample stream stopped": "זרימת הדגימות של RTL-SDR נעצרה",
   "Switching to {mode}…": "עובר אל {mode}…",
   "Browser audio is suspended; select FM again to resume it": "שמע הדפדפן מושהה; בחר FM שוב כדי לחדש אותו",
@@ -1560,9 +1560,9 @@
   "Scanlines": "קווי סריקה",
   "Sensitivity": "רגישות",
   "WHOT/BHOT": "WHOT/BHOT",
-  "Ironbow": "קשת ברזל",
-  "Left panels": "פאנלים שמאליים",
-  "Right panels": "פאנלים ימניים",
+  "Ironbow": "Ironbow",
+  "Left panels": "פאנלים ימניים",
+  "Right panels": "פאנלים שמאליים",
   "Contacts could not complete the requested transition; try again": "המגעים לא השלימו את המעבר המבוקש; נסה שוב",
   "CCTV layer unavailable": "שכבת CCTV אינה זמינה",
   "Link shared": "הקישור שותף",
@@ -1604,7 +1604,7 @@
   "FRAME · LOADING": "שקופית · בטעינה",
   "FRAME · UNAVAILABLE": "שקופית · לא זמינה",
   "{count} more cameras outside this view · pan or zoom out": {
-    "one": "{count} מצלמות נוספות מחוץ לתצוגה הזאת · הזז או זום החוצה",
+    "one": "{count} מצלמה נוספת מחוץ לתצוגה הזאת · הזז או זום החוצה",
     "two": "{count} מצלמות נוספות מחוץ לתצוגה הזאת · הזז או זום החוצה",
     "other": "{count} מצלמות נוספות מחוץ לתצוגה הזאת · הזז או זום החוצה"
   },
@@ -1621,12 +1621,12 @@
   "OFF": "כבוי",
   "{city} · HDG {heading} · FOV {fov} · RANGE {range}m · {projection}{calBadge} · {provider}{status}": "{city} · HDG {heading} · FOV {fov} · טווח {range} מ׳ · {projection}{calBadge} · {provider}{status}",
   "{count} cameras loaded · click a camera to activate": {
-    "one": "{count} מצלמות נטענו · לחץ על מצלמה להפעלה",
+    "one": "{count} מצלמה נטענה · לחץ על מצלמה להפעלה",
     "two": "{count} מצלמות נטענו · לחץ על מצלמה להפעלה",
     "other": "{count} מצלמות נטענו · לחץ על מצלמה להפעלה"
   },
   "{count} cameras loaded · enable CCTV to activate": {
-    "one": "{count} מצלמות נטענו · הפעל CCTV להפעלה",
+    "one": "{count} מצלמה נטענה · הפעל CCTV להפעלה",
     "two": "{count} מצלמות נטענו · הפעל CCTV להפעלה",
     "other": "{count} מצלמות נטענו · הפעל CCTV להפעלה"
   },
@@ -1650,9 +1650,9 @@
   "CYCLE OFF": "מחזור כבוי",
   "ACQUIRING REGIONAL NEWS": "אוסף חדשות אזוריות",
   "RESOLVING REGION": "מזהה אזור",
-  "CONDITIONS UNKNOWN": "מחיזים לא ידועים",
+  "CONDITIONS UNKNOWN": "תנאים לא ידועים",
   "CLEAR": "בהיר",
-  "PARTLY CLOUDY": "חלקי מעונן",
+  "PARTLY CLOUDY": "מעונן חלקית",
   "OVERCAST": "מעונן",
   "FOG": "ערפל",
   "DRIZZLE": "טפטוף",
@@ -1666,7 +1666,7 @@
   "REGIONAL NEWS UNAVAILABLE": "חדשות אזוריות אינן זמינות",
   "REGION UNAVAILABLE": "אזור אינו זמין",
   "NO RECENT LOCATION MATCHES": "אין התאמות מיקום אחרונות",
-  "{domain} · {age}": "{domain} · לפני {age}",
+  "{domain} · {age}": "{domain} · {age}",
   "{value} KM/H": "{value} קמ\"ש",
   "CLOUD {pct}%": "עננות {pct}%",
   "CLOUD UNKNOWN": "עננות לא ידועה",
@@ -1689,9 +1689,9 @@
   "L": "L",
   "R": "R",
   "{count} INPUTS UNKNOWN · NOT AN ALL-CLEAR": {
-    "one": "{count} קלטים לא ידועים · ללא אישור מלא",
-    "two": "{count} קלטים לא ידועים · ללא אישור מלא",
-    "other": "{count} קלטים לא ידועים · ללא אישור מלא"
+    "one": "{count} קלט לא ידוע · לא אות הרגעה",
+    "two": "{count} קלטים לא ידועים · לא אות הרגעה",
+    "other": "{count} קלטים לא ידועים · לא אות הרגעה"
   },
   "AVAILABLE INPUTS CURRENT · NOT AN ALL-CLEAR": "הקלטים הזמינים עדכניים · ללא אישור מלא",
   "CONTACTS · 250 KM": "מגעים · 250 ק\"מ",
@@ -1702,7 +1702,7 @@
   "Anime": "אנימה",
   "Noir": "נואר",
   "AIRCRAFT": "מטוס",
-  "LIVE TRACK · COURSE ALIGNED": "מעקב חי · מסלול תואם",
+  "LIVE TRACK · COURSE ALIGNED": "מעקב חי · מהלך תואם",
   "ROUTE DATA UNAVAILABLE": "נתוני המסלול אינם זמינים",
   "DEST ---°": "DEST ---°",
   "SQUAWK {code} · {status}": "SQUAWK {code} · {status}",
@@ -1714,13 +1714,13 @@
   "LIVE TRACK": "מעקב חי",
   "COMMERCIAL": "מסחרי",
   "{aircraftClass} · {emergency} · {feedState}": "{aircraftClass} · {emergency} · {feedState}",
-  "{aircraftClass} · {feedState} · COURSE ALIGNED": "{aircraftClass} · {feedState} · מסלול תואם",
+  "{aircraftClass} · {feedState} · COURSE ALIGNED": "{aircraftClass} · {feedState} · מהלך תואם",
   "ARROW · ESTIMATED DIRECTION": "חץ · כיוון מוערך",
   "DEST {bearing}": "DEST {bearing}",
   "TIME UNKNOWN": "זמן לא ידוע",
-  "{count}M AGO": "לפני {count} דק'",
-  "{count}H AGO": "לפני {count} שע'",
-  "{count}D AGO": "לפני {count} יום",
+  "{count}M AGO": "לפני {count} דק",
+  "{count}H AGO": "לפני {count} שע",
+  "{count}D AGO": "לפני {count} ימ",
   "DIR UNKNOWN": "כיוון לא ידוע",
   "COCKPIT": "תא טייס",
   "Select flight {title}": "בחירת הטיסה {title}",
@@ -1736,34 +1736,34 @@
   },
   "SOURCE STATUS UNAVAILABLE": "מצב המקור אינו זמין",
   "TRACK ACQUIRED": "המעקב נתפס",
-  "{label} · COURSE {heading}°": "{label} · מסלול {heading}°",
+  "{label} · COURSE {heading}°": "{label} · מהלך {heading}°",
   "Context could not restore every layer; try again": "ההקשר לא שיחזר את כל השכבות; נסה שוב",
   "No selected data layers": "אין שכבות נתונים נבחרות",
   "{count} data layers could not be cleared": {
-    "one": "{count} שכבות נתונים לא נוקו",
+    "one": "{count} שכבת נתונים לא נוקתה",
     "two": "{count} שכבות נתונים לא נוקו",
     "other": "{count} שכבות נתונים לא נוקו"
   },
   "Cleared {count} data layers": {
-    "one": "נוקו {count} שכבות נתונים",
+    "one": "נוקתה {count} שכבת נתונים",
     "two": "נוקו {count} שכבות נתונים",
     "other": "נוקו {count} שכבות נתונים"
   },
   "Selected data layers could not be cleared": "שכבות הנתונים הנבחרות לא נוקו",
-  "Space Missions could not complete the requested transition; try again": "Space Missions לא השלים את המעבר המבוקש; נסה שוב",
+  "Space Missions could not complete the requested transition; try again": "משימות החלל לא השלימו את המעבר המבוקש; נסה שוב",
   "Nearby installations refreshed": "המתקנים הסמוכים התרעננו",
   "Nearby installations could not be refreshed; try again": "לא ניתן לרענן את המתקנים הסמוכים; נסה שוב",
-  "Space Missions cancellation could not restore the previous layer state": "ביטול Space Missions לא שיחזר את מצב השכבה הקודם",
+  "Space Missions cancellation could not restore the previous layer state": "ביטול משימות החלל לא שיחזר את מצב השכבה הקודם",
   "That layer is unavailable in the current Context mode": "השכבה הזאת אינה זמינה במצב ההקשר הנוכחי",
   "{layerId} could not {action} cleanly": "{layerId} — הפעולה {action} לא הסתיימה בנקיון",
   "start": "התחלה",
   "stop": "עצירה",
   "{mode} could not start because another layer did not stop cleanly": "{mode} לא החל כי שכבה אחרת לא נעצרה בנקיון",
-  "Space Missions": "Space Missions",
+  "Space Missions": "משימות חלל",
   "Context": "ההקשר",
   "Ground heights could not be refreshed. Try the file again when the map has loaded.": "את גבהי הקרקע לא ניתן לרענן. נסה שוב את הקובץ כשהמפה נטענת.",
   "{count} map objects": {
-    "one": "{count} אובייקטי מפה",
+    "one": "{count} אובייקט מפה",
     "two": "{count} אובייקטי מפה",
     "other": "{count} אובייקטי מפה"
   },
@@ -1772,12 +1772,12 @@
   "Reading {name}…": "קורא את {name}…",
   "That file could not be read.": "את הקובץ לא ניתן לקרוא.",
   "Added {count} files.": {
-    "one": "נוספו {count} קבצים.",
+    "one": "נוסף {count} קובץ.",
     "two": "נוספו {count} קבצים.",
     "other": "נוספו {count} קבצים."
   },
   "{count} files could not be added ({name}: {error})": {
-    "one": "{count} קבצים לא התווספו ({name}: {error})",
+    "one": "{count} קובץ לא התווסף ({name}: {error})",
     "two": "{count} קבצים לא התווספו ({name}: {error})",
     "other": "{count} קבצים לא התווספו ({name}: {error})"
   },
@@ -1806,17 +1806,17 @@
   "Datacenters": "מרכזי נתונים",
   "Dams": "סכרים",
   "Submarine Cables": "כבלים תת-ימיים",
-  "FIRMS Active Fires": "שרפות פעילות FIRMS",
+  "FIRMS Active Fires": "שריפות פעילות FIRMS",
   "Local ADS-B": "ADS-B מקומי",
   "OSM Places": "מקומות OSM",
   "Transit": "תחבורה ציבורית",
   "Recent Imagery": "צילומים אחרונים",
   "Fire Perimeters": "היקפי שרפות",
   "GNSS Integrity": "שלמות GNSS",
-  "Prohibited & Restricted Airspace": "שמיים אסורים ושמורים",
+  "Prohibited & Restricted Airspace": "מרחב אווירי אסור ומוגבל",
   "S2 GhostMaps": "S2 GhostMaps",
   "Rain radar": "רדאר גשם",
-  "Lightning density": "צפיפות מכות",
+  "Lightning density": "צפיפות ברקים",
   "Cyclone advisories": "ייעוצי ציקלונים",
   "ALPR Cameras": "מצלמות ALPR",
   "Sea Marks": "סימני ים",
@@ -1827,12 +1827,12 @@
   "Street Level": "Street Level",
   "Mapped ALPR Cameras": "מצלמות ALPR ממופות",
   "Data Centers": "מרכזי נתונים",
-  "Active Fires": "שרפות פעילות",
+  "Active Fires": "שריפות פעילות",
   "Military aircraft": "מטוס צבאי",
   "Vessels": "אוניות",
   "CCTV + Street View fallback": "CCTV + גיבוי Street View",
   "OpenStreetMap + optional Google Maps Places": "OpenStreetMap + Google Maps Places אופציונלי",
-  "GFS / ECMWF IFS · FORECAST": "GFS / ECMWF IFS · חזוי",
+  "GFS / ECMWF IFS · FORECAST": "GFS / ECMWF IFS · תחזית",
   "NOAA nowCOAST · OBSERVED": "NOAA nowCOAST · נצפה",
   "NASA FIRMS · LIVE": "NASA FIRMS · חי",
   "OSM routing": "ניתוב OSM",
@@ -1854,14 +1854,14 @@
   "Other layers": "שכבות אחרות",
   "{state} · {source}": "{state} · {source}",
   "UNCERTAIN · {source} · lifecycle state requires reconciliation": "לא ודאי · {source} · מצב מחזור החיים מצריך התאמה",
-  "{state} · {source} · {detail} · retry {seconds}s": "{state} · {source} · {detail} · ניסיון חוזר בעוד {seconds} שנ'",
+  "{state} · {source} · {detail} · retry {seconds}s": "{state} · {source} · {detail} · ניסיון חוזר בעוד {seconds} שנ",
   "{state} · {source} · {detail}": "{state} · {source} · {detail}",
   "never": "לעולם לא",
   "{source} · {loadingLabel}": "{source} · {loadingLabel}",
   "{accepted} of {raw} records accepted": "התקבלו {accepted} מתוך {raw} רשומות",
   "incomplete snapshot": "תמונת מצב שאינה שלמה",
   "{state} · {source} · {detail} · {ago}": "{state} · {source} · {detail} · {ago}",
-  "{state} · {source} · {ago} · retrying in {seconds}s": "{state} · {source} · {ago} · מנסה שוב בעוד {seconds} שנ'",
+  "{state} · {source} · {ago} · retrying in {seconds}s": "{state} · {source} · {ago} · מנסה שוב בעוד {seconds} שנ",
   "{state} · {source} · {ago}": "{state} · {source} · {ago}",
   "{source} · {ago}": "{source} · {ago}",
   "{count}s ago": "לפני {count} שנ'",
@@ -1881,12 +1881,12 @@
   "feed status|invalid": "בלתי תקין",
   "waiting for IQ": "ממתין ל-IQ",
   "{count} messages": {
-    "one": "{count} הודעות",
+    "one": "{count} הודעה",
     "two": "{count} הודעות",
     "other": "{count} הודעות"
   },
   "DSP {count} blocks": {
-    "one": "{count} בלוקים DSP",
+    "one": "{count} בלוק DSP",
     "two": "{count} בלוקים DSP",
     "other": "{count} בלוקים DSP"
   },
@@ -1895,7 +1895,7 @@
   "audio signal --": "אות שמע --",
   "audio {state}": "שמע {state}",
   "{count} HEARD": {
-    "one": "{count} נשמעו",
+    "one": "{count} נשמע",
     "two": "{count} נשמעו",
     "other": "{count} נשמעו"
   },
@@ -1939,7 +1939,7 @@
   "Washington DC": "וושינגטון די. סי.",
   "Tallinn": "טאלין",
   "Los Angeles": "לוס אנג׳לס",
-  "CH {index} / {total}": "ערוץ {index} / {total}",
+  "CH {index} / {total}": "ערוץ {index} מתוך {total}",
   "NO STATIONS": "אין תחנות",
   "NO STATION AVAILABLE": "אין תחנה זמינה",
   "{name}, station {index} of {total}": "{name}, תחנה {index} מתוך {total}",
@@ -2027,7 +2027,7 @@
   "NO BOX": "אין תיבה",
   "SEARCHING": "מחפש",
   "{count} DAYS": {
-    "one": "{count} ימים",
+    "one": "{count} יום",
     "two": "{count} ימים",
     "other": "{count} ימים"
   },
@@ -2035,7 +2035,7 @@
   "Select a box or use the view": "בחר תיבה או השתמש בתצוגה",
   "Searching the last 30 days": "מחפש ב-30 הימים האחרונים",
   "No days to show for this box": "אין ימים להצגה לתיבה הזאת",
-  "Drag the divider · SWAP trades sides": "גרור את המפריד · SWAP מחליף צדדים",
+  "Drag the divider · SWAP trades sides": "גרור את המפריד · \"החלפה\" מחליפה צדדים",
   "← → preview · A or B pins the focused day": "← → תצוגה מקדימה · A או B מקבע את היום במוקד",
   "← → preview the other side · A or B pins it": "← → הצצת הצד השני · A או B מקבעים אותו",
   "S on another day replaces it · × unpins": "S ביום אחר מחליף אותו · × מסיר את הקיבוע",
@@ -2147,7 +2147,7 @@
   "REFRESHING LIVE DATA": "מרענן נתונים חיים",
   "syncing road network": "מסנכרן את רשת הכבישים",
   "retry pending": "ניסיון חוזר בתור",
-  "retrying in {seconds}s": "מנסה שוב בעוד {seconds} שנ'",
+  "retrying in {seconds}s": "מנסה שוב בעוד {seconds} שנ",
   "ALPR cameras": "מצלמות ALPR",
   "OpenSky OAuth client missing/invalid": "לקוח ה-OAuth של OpenSky חסר או בלתי תקין",
   "OpenSky OAuth rejected credentials": "אישורי ה-OAuth של OpenSky נדחו",
@@ -2162,7 +2162,7 @@
   "Vector tiles unavailable (HTTP {status})": "אריחים וקטוריים אינם זמינים (HTTP {status})",
   "GNSS feed unavailable (HTTP {status})": "פיד GNSS אינו זמין (HTTP {status})",
   "{count} CelesTrak groups unavailable": {
-    "one": "{count} קבוצות CelesTrak אינן זמינות",
+    "one": "{count} קבוצת CelesTrak אינה זמינה",
     "two": "{count} קבוצות CelesTrak אינן זמינות",
     "other": "{count} קבוצות CelesTrak אינן זמינות"
   },
@@ -2184,30 +2184,30 @@
   "{error} — try again in a moment": "{error} — נסה שוב בעוד רגע",
   "entry {n}": "פריט {n}",
   "feeds {names} stale": {
-    "one": "הפידים {names} מיושנים",
+    "one": "הפיד {names} מיושן",
     "two": "הפידים {names} מיושנים",
     "other": "הפידים {names} מיושנים"
   },
   "feeds {names} unreachable": {
-    "one": "הפידים {names} בלתי נגישים",
+    "one": "הפיד {names} בלתי נגיש",
     "two": "הפידים {names} בלתי נגישים",
     "other": "הפידים {names} בלתי נגישים"
   },
   "feeds {names} invalid": {
-    "one": "הפידים {names} בלתי תקינים",
+    "one": "הפיד {names} אינו תקין",
     "two": "הפידים {names} בלתי תקינים",
     "other": "הפידים {names} בלתי תקינים"
   },
   "Loading {feeds}": "טוען {feeds}",
   "{count} heard": {
-    "one": "{count} נשמעו",
+    "one": "{count} נשמע",
     "two": "{count} נשמעו",
     "other": "{count} נשמעו"
   },
   "USB {rate} msg/s": "USB {rate} הודעות/שנ",
   "{rate} msg/s": "{rate} הודעות/שנ",
   "{count} feeds live": {
-    "one": "{count} פידים חיים",
+    "one": "{count} פיד חי",
     "two": "{count} פידים חיים",
     "other": "{count} פידים חיים"
   },
@@ -2224,7 +2224,7 @@
   "LAST 3 MONTHS": "3 החודשים האחרונים",
   "LAST MONTH": "החודש האחרון",
   "LAST {count} DAYS": {
-    "one": "{count} הימים האחרונים",
+    "one": "היום האחרון ({count})",
     "two": "{count} הימים האחרונים",
     "other": "{count} הימים האחרונים"
   },
@@ -2242,24 +2242,24 @@
   "Every provider is switched off: light a chip to draw its coverage.": "כל הספקים כבויים: הדלק שבב כדי לצייר את כיסויו.",
   "Loading this sequence…": "טוען את הרצף הזה…",
   "{n} images in this sequence · Esc clears": {
-    "one": "{n} תמונות ברצף הזה · Esc מנקה",
+    "one": "{n} תמונה ברצף הזה · Esc מנקה",
     "two": "{n} תמונות ברצף הזה · Esc מנקה",
     "other": "{n} תמונות ברצף הזה · Esc מנקה"
   },
   "No sequences in view match the filter": "אין רצפים בתצוגה שתואמים את המסנן",
   "No coverage in view": "אין כיסוי בתצוגה",
   "{n} streets in view · click a line for its nearest photo": {
-    "one": "{n} רחובות בתצוגה · לחץ על קו לתמונתו הקרובה",
+    "one": "{n} רחוב בתצוגה · לחץ על קו לתמונתו הקרובה",
     "two": "{n} רחובות בתצוגה · לחץ על קו לתמונתו הקרובה",
     "other": "{n} רחובות בתצוגה · לחץ על קו לתמונתו הקרובה"
   },
   "{n} sequences in view · click a line for its nearest photo": {
-    "one": "{n} רצפים בתצוגה · לחץ על קו לתמונתו הקרובה",
+    "one": "{n} רצף בתצוגה · לחץ על קו לתמונתו הקרובה",
     "two": "{n} רצפים בתצוגה · לחץ על קו לתמונתו הקרובה",
     "other": "{n} רצפים בתצוגה · לחץ על קו לתמונתו הקרובה"
   },
   "{n} sequences in view · click a line for its photos": {
-    "one": "{n} רצפים בתצוגה · לחץ על קו לתמונותיו",
+    "one": "{n} רצף בתצוגה · לחץ על קו לתמונותיו",
     "two": "{n} רצפים בתצוגה · לחץ על קו לתמונותיו",
     "other": "{n} רצפים בתצוגה · לחץ על קו לתמונותיו"
   },
@@ -2279,7 +2279,7 @@
   "Current cockpit vision style: {style}. Activate for next style.": "סגנון הראייה הנוכחי בתא הטייס: {style}. הפעל למעבר לסגנון הבא.",
   "Current style: {style} — click for next": "הסגנון הנוכחי: {style} — לחץ לסגנון הבא",
   "Aircraft cockpit view": "תצוגת תא הטייס",
-  "LEVEL": "LEVEL",
+  "LEVEL": "מאוזן",
   "Estimated destination direction": "הכיוון המוערך אל היעד",
   "OPTICAL PLANE · 01": "מישור אופטי · 01",
   "VISOR LOCK · ACTIVE": "ויזור נעול · פעיל",
@@ -2374,11 +2374,11 @@
   "SHARE SCENE": "שיתוף הסצנה",
   "The Google Maps key buys the photorealistic planet — everything else stacks on top.": "מפתח Google Maps קונה את כוכב הלכת הפוטוריאליסטי — כל היתר נבנה עליו.",
   "Remove {title} from this app's saved keys": "הסרת {title} מהמפתחות השמורים של האפליקציה",
-  "POWER UP": "אתחול",
+  "POWER UP": "שדרוג",
   "GROUND STATION · PROVIDER SETTINGS": "תחנת קרקע · הגדרות ספקים",
   "Close key setup": "סגירת הגדרת המפתח",
-  "Power up the globe": "אתחול הגלובוס",
-  "The globe already flies keyless. Every key below switches on another real feed — paste one and it's saved into this app's local configuration, then the server restarts itself. Server-side keys stay on this machine; Google Maps and Cesium ion run in the browser and must be provider-restricted. Keys you configured elsewhere are shown but never touched.": "הגלובוס כבר עף ללא מפתחות. לכל מפתח להלן הזנה אמיתית נוספת — הדבק אחד והוא נשמר לתצורה המקומית של האפליקציה, ואז השרת מאתחל את עצמו. מפתחות של שרת נשארים במכונה הזאת; Google Maps ו-Cesium ion רצים בדפדפן וחייבים הגבלה אצל הספק. מפתחות שהגדרת במקום אחר מוצגים אך לא נעולים.",
+  "Power up the globe": "שדרוג הגלובוס",
+  "The globe already flies keyless. Every key below switches on another real feed — paste one and it's saved into this app's local configuration, then the server restarts itself. Server-side keys stay on this machine; Google Maps and Cesium ion run in the browser and must be provider-restricted. Keys you configured elsewhere are shown but never touched.": "הגלובוס כבר עף בלי מפתחות. לכל מפתח להלן הזנה אמיתית נוספת — הדבק אחד והוא נשמר לתצורה המקומית של האפליקציה, ואז השרת מאתחל את עצמו. מפתחות של שרת נשארים במכונה הזאת; Google Maps ו-Cesium ion רצים בדפדפן וחייבים הגבלה אצל הספק. מפתחות שהגדרת במקום אחר מוצגים, אך האפליקציה לעולם אינה משנה אותם.",
   "This key runs in the browser by design — restrict it at the provider (see SECURITY.md)": "מפתח זה רץ בדפדפן מתוך תכנון — הגבל אותו אצל הספק (ראה SECURITY.md)",
   "browser-side": "בצד הדפדפן",
   "Supplied by your environment, Keychain, or launcher — change it where it was set": "מסופק על ידי הסביבה, ה-Keychain או מריץ ההפעלה — שנה אותו במקום שבו הוגדר",
@@ -2478,14 +2478,14 @@
   "Ask GEV anything about the map…": "שאל את GEV כל דבר על המפה…",
   "Stop reply": "עצירת תשובה",
   "Send message": "שליחת הודעה",
-  "Cockpit briefing carousel": "קרוסלת דיווחי תא הטייס",
-  "Cockpit briefing controls": "פקדי דיווחי תא הטייס",
-  "Previous briefing page": "עמוד הדיווח הקודם",
-  "Next briefing page": "עמוד הדיווח הבא",
-  "Expand cockpit briefing panel": "הרחבת פאנל דיווחי תא הטייס",
-  "Collapse cockpit briefing panel": "קיפול פאנל דיווחי תא הטייס",
-  "Expand briefing panel": "הרחבת פאנל הדיווח",
-  "Collapse briefing panel": "קיפול פאנל הדיווח",
+  "Cockpit briefing carousel": "קרוסלת תדריכי תא הטייס",
+  "Cockpit briefing controls": "פקדי תדריכי תא הטייס",
+  "Previous briefing page": "עמוד התדריך הקודם",
+  "Next briefing page": "עמוד התדריך הבא",
+  "Expand cockpit briefing panel": "הרחבת פאנל תדריכי תא הטייס",
+  "Collapse cockpit briefing panel": "קיפול פאנל תדריכי תא הטייס",
+  "Expand briefing panel": "הרחבת פאנל התדריך",
+  "Collapse briefing panel": "קיפול פאנל התדריך",
   "Live signals": "אותות חיים",
   "Latest regional news": "חדשות אזוריות אחרונות",
   "Location-based information": "מידע לפי מקום",
@@ -2495,7 +2495,7 @@
   "PRECIP": "משקעים",
   "MM": "מ״מ",
   "Weather data by Open-Meteo.com": "נתוני מזג אוויר מאת Open-Meteo.com",
-  "Cockpit briefing pages": "עמודי הדיווח של תא הטייס",
+  "Cockpit briefing pages": "עמודי התדריך של תא הטייס",
   "Show Live Signals": "הצגת אותות חיים",
   "SIG": "אות",
   "Show Regional News": "הצגת חדשות אזוריות",
@@ -2635,11 +2635,11 @@
   "TYPE": "סוג",
   "DESTINATION": "יעד",
   "PAYLOAD DATA UNAVAILABLE": "נתוני המטען אינם זמינים",
-  "STAGE / RE-ENTRY / RECOVERY": "שלב / חדירה / שחזור",
+  "STAGE / RE-ENTRY / RECOVERY": "שלב / כניסה חוזרת / השבה",
   "STAGE": "שלב",
   "STATUS": "מצב",
   "FINAL POSITION": "המיקום הסופי",
-  "NO STAGE RE-ENTRY / RECOVERY DATA": "אין נתוני חדירה / שחזור שלב",
+  "NO STAGE RE-ENTRY / RECOVERY DATA": "אין נתוני כניסה חוזרת / השבת שלב",
   "REPLAY SPEED": "מהירות ההצגה החוזרת",
   "Replay speed multiplier": "מכפיל מהירות ההצגה החוזרת",
   "Replay the estimated ascent with a following camera": "הצגת העלייה המשוערת שוב, עם מצלמה עוקבת",
@@ -2652,10 +2652,10 @@
   "AVAILABLE MISSIONS": "המשימות הזמינות",
   "SELECT A MISSION TO INSPECT": "בחר משימה לבחינה",
   "LOADING 30-DAY MISSION INDEX": "טוען את מפתח המשימות ל-30 יום",
-  "TAB PREVIEWS · ENTER / SPACE SELECTS": "TAB מראה פרצים · Enter / מקש הרווח בוחר",
+  "TAB PREVIEWS · ENTER / SPACE SELECTS": "Tab לתצוגה מקדימה · Enter / מקש הרווח בוחר",
   "Panel position": "מקום הפאנל",
   "Move above the dock": "מעבר מעל העגינה",
-  "Dock to the right": "עגינה מימין",
+  "Dock to the right": "עגינה משמאל",
   "Expand panel": "הרחבת הפאנל",
   "Minimize panel": "מזעור הפאנל",
   "Panels": "פאנלים",
@@ -2681,7 +2681,7 @@
   "ALL · DRAG THE NEEDLE": "הכול · גרור את המחט",
   "SNAPS TO AVAILABLE STATIONS": "נצמד לתחנות הזמינות",
   "{count} files selected": {
-    "one": "נבחרו {count} קבצים",
+    "one": "נבחר {count} קובץ",
     "two": "נבחרו {count} קבצים",
     "other": "נבחרו {count} קבצים"
   },
@@ -2694,7 +2694,7 @@
   "Use your location for faster ADS-B position decoding": "שימוש במיקומך לפענוח מהיר יותר של מיקומי ADS-B",
   "Choose a different RTL-SDR or receiver channel": "בחירת RTL-SDR או ערוץ מקלט אחר",
   "CHANGE DEVICE": "החלפת מכשיר",
-  "RTL-SDR receiver mode": "מצב מקלן ה-RTL-SDR",
+  "RTL-SDR receiver mode": "מצב המקלט RTL-SDR",
   "GAIN": "הגברה",
   "RTL-SDR tuner gain for the current mode": "הגברת מכוון ה-RTL-SDR למצב הנוכחי",
   "AUTO": "אוטומטי",
@@ -2754,7 +2754,7 @@
   "Show quick commands": "הצגת פקודות מהירות",
   "Chat replies are silent. No microphone access is needed.": "תשובות הצ׳אט שקטות. אין צורך בגישה למיקרופון.",
   "Show Voice Preview": "הצגת תצוגה מקדימה לקול",
-  "Voice inactivity timeout": "תם זמן המנוחה של הקול",
+  "Voice inactivity timeout": "כיבוי הקול לאחר חוסר פעילות",
   "Custom": "מותאם",
   "Minutes": "דקות",
   "Voice model tier — applies next session": "דרגת מודל הקול — חלה מההפעלה הבאה",
@@ -2784,9 +2784,9 @@
   "Active weather": "מזג אוויר פעיל",
   "{time} · {minutes} min ago": "{time} · לפני {minutes} דק",
   "LATEST · newest per product": "האחרון · החדש ביותר לכל מוצר",
-  "Forecast · valid {valid} · issued {issued}": "חזוי · תקף {valid} · פורסם {issued}",
+  "Forecast · valid {valid} · issued {issued}": "תחזית · תקפה {valid} · פורסמה {issued}",
   "{detail} · Does not follow history": "{detail} · אינו נע עם ההיסטוריה",
-  "Forecast · valid {valid}": "חזוי · תקף {valid}",
+  "Forecast · valid {valid}": "תחזית · תקפה {valid}",
   "You can attach up to four items.": "ניתן לצרף עד ארבעה פריטים.",
   "Attachments are too large together. Use smaller files.": "הקבצים המצורפים גדולים יחד. השתמש בקבצים קטנים יותר.",
   "Choose a TXT, Markdown, CSV, JSON or GeoJSON file.": "בחר קובץ TXT, Markdown, CSV, JSON או GeoJSON.",
@@ -2831,7 +2831,7 @@
   "This browser does not support Gemini microphone audio": "הדפדפן הזה אינו תומך בשמע המיקרופון של Gemini",
   "Microphone audio processing failed": "עיבוד שמע המיקרופון נכשל",
   "Gemini audio playback fell behind. Reconnect to continue.": "השמעת האודיו של Gemini נשארה מאחור. חבר מחדש כדי להמשיך.",
-  "Gemini token response did not include an ephemeral credential": "תשובת האסימון של Gemini לא כללה פרטי גישה זנים",
+  "Gemini token response did not include an ephemeral credential": "תשובת האסימון של Gemini לא כללה פרטי גישה זמניים",
   "Invalid Gemini connection endpoint": "נקודת החיבור של Gemini בלתי תקינה",
   "Gemini voice could not connect. Try again.": "הקול של Gemini לא הצליח להתחבר. נסה שוב.",
   "Gemini voice requires a same-origin app request": "הקול של Gemini דורש בקשה ממקור אחיד",
@@ -2909,12 +2909,12 @@
   "Which {place}?": "איזו {place}?",
   "Which place?": "איזה מקום?",
   "{n} aircraft": {
-    "one": "{n} מטוסים",
+    "one": "{n} מטוס",
     "two": "{n} מטוסים",
     "other": "{n} מטוסים"
   },
   "{n} military aircraft": {
-    "one": "{n} מטוסים צבאיים",
+    "one": "{n} מטוס צבאי",
     "two": "{n} מטוסים צבאיים",
     "other": "{n} מטוסים צבאיים"
   },
@@ -2939,9 +2939,9 @@
     "other": "{n} רעידות אדמה"
   },
   "{n} fire perimeters": {
-    "one": "{n} היקפי שרפות",
-    "two": "{n} היקפי שרפות",
-    "other": "{n} היקפי שרפות"
+    "one": "{n} היקף שריפה",
+    "two": "{n} היקפי שריפות",
+    "other": "{n} היקפי שריפות"
   },
   "{n} cyclones": {
     "one": "{n} ציקלונים",
@@ -2979,9 +2979,9 @@
     "other": "{n} סכרים"
   },
   "{n} air quality": {
-    "one": "{n} תחנות אוויר נקי",
-    "two": "{n} תחנות אוויר נקי",
-    "other": "{n} תחנות אוויר נקי"
+    "one": "{n} תחנת איכות אוויר",
+    "two": "{n} תחנות איכות אוויר",
+    "other": "{n} תחנות איכות אוויר"
   },
   "{n} results": {
     "one": "{n} תוצאות",
@@ -3013,17 +3013,17 @@
   "{label} error": "{label} שגיאה",
   "{radius} m around the landmark": "{radius} מ׳ סביב ציון הדרך",
   "{count} parts": {
-    "one": "{count} חלקים",
+    "one": "{count} חלק",
     "two": "{count} חלקים",
     "other": "{count} חלקים"
   },
   "{drawn} of {total} parts drawn": {
-    "one": "שורטטו {drawn} מתוך {total} חלקים",
+    "one": "שורטט {drawn} מתוך {total} חלק",
     "two": "שורטטו {drawn} מתוך {total} חלקים",
     "other": "שורטטו {drawn} מתוך {total} חלקים"
   },
   "{count} duplicate mappings merged": {
-    "one": "מוזגו {count} מיפויים כפולים",
+    "one": "מוזג {count} מיפוי כפול",
     "two": "מוזגו {count} מיפויים כפולים",
     "other": "מוזגו {count} מיפויים כפולים"
   },
@@ -3036,7 +3036,7 @@
   "Contacts panel snapshot — the same retained cohort supplies the card, speech, and follow-up memory": "תמונת מצב של פאנל המגעים — אותה קבוצה נשמרת מספקת את הכרטיס, הדיבור והזיכרון להמשך",
   "Fly below {km} km to a covered region": "עוף מטה מתחת ל-{km} ק\"מ אל אזור הזנה",
   "No feed here yet · {n} regions available": {
-    "one": "אין עדיין הזנה כאן · {n} אזורים זמינים",
+    "one": "אין עדיין הזנה כאן · {n} אזור זמין",
     "two": "אין עדיין הזנה כאן · {n} אזורים זמינים",
     "other": "אין עדיין הזנה כאן · {n} אזורים זמינים"
   },
@@ -3106,12 +3106,12 @@
   "Frame satellites": "מסגור הלוויינים",
   "Frame contacts": "מסגור המגעים",
   "{count} aircraft in frame": {
-    "one": "{count} מטוסים במסגרת",
+    "one": "{count} מטוס במסגרת",
     "two": "{count} מטוסים במסגרת",
     "other": "{count} מטוסים במסגרת"
   },
   "{count} military aircraft in frame": {
-    "one": "{count} מטוסים צבאיים במסגרת",
+    "one": "{count} מטוס צבאי במסגרת",
     "two": "{count} מטוסים צבאיים במסגרת",
     "other": "{count} מטוסים צבאיים במסגרת"
   },
@@ -3149,7 +3149,7 @@
   "Registration {registration}": "רישום {registration}",
   "View state": "מצב התצוגה",
   "Marked {count} places": {
-    "one": "סומנו {count} מקומות",
+    "one": "סומן {count} מקום",
     "two": "סומנו {count} מקומות",
     "other": "סומנו {count} מקומות"
   },
@@ -3267,14 +3267,14 @@
   "Monthly traffic allowance used": "הקצבה החודשית לתנועה נוצלה",
   "Traffic rate limit reached": "הגעת למגבלת הקצב של שירות התנועה",
   "Traffic service unavailable": "שירות התנועה אינו זמין",
-  "LOOK STBD {bearing}°": "LOOK STBD {bearing}°",
-  "LOOK PORT {bearing}°": "LOOK PORT {bearing}°",
-  "LOOK ASTERN": "LOOK ASTERN",
+  "LOOK STBD {bearing}°": "מבט ימין {bearing}°",
+  "LOOK PORT {bearing}°": "מבט שמאל {bearing}°",
+  "LOOK ASTERN": "מבט אחורה",
   "UP {angle}°": "מעלה {angle}°",
   "DOWN {angle}°": "מטה {angle}°",
   "{direction} · {elevation}": "{direction} · {elevation}",
   "LOOK {elevation}": "LOOK {elevation}",
-  "{vesselType} · {feedState} · EYE {height}": "{vesselType} · {feedState} · EYE {height}",
+  "{vesselType} · {feedState} · EYE {height}": "{vesselType} · {feedState} · עין {height}",
   "LIVE AIS": "AIS חי",
   "CONTACT NAVIGATION OFF": "ניווט המגעים כבוי",
   "THE BRIDGE STAYS WITH THE SELECTED VESSEL": "הגשר נשאר עם האונייה הנבחרת",
@@ -3290,7 +3290,7 @@
   "{label} · NADIR VIEW": "{label} · תצוגת נדיר",
   "{label} · HEADING {heading}°": "{label} · כיוון {heading}°",
   "{label} · NO HEADING": "{label} · ללא כיוון",
-  "Space Missions unavailable: the mission index could not load. Try again later.": "Space Missions אינן זמינות: טעינת מפתח המשימות נכשלה. נסה שוב מאוחר יותר.",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "משימות החלל אינן זמינות: טעינת מפתח המשימות נכשלה. נסה שוב מאוחר יותר.",
   "Close camera preview": "סגירת תצוגת המצלמה",
   "Refresh map still": "רענון תמונת המפה",
   "The map still uses a separate request and may show a different moment.": "תמונת המפה נשלפת בבקשה נפרדת ועשויה להראות רגע שונה.",
@@ -3328,8 +3328,8 @@
   "NORAD {id}": "NORAD {id}",
   "EPOCH {time}": "EPOCH {time}",
   "<1 H OLD": "פחות משעה",
-  "{value} H OLD": "{value} שעות",
-  "{value} D OLD": "{value} ימים",
+  "{value} H OLD": "{value} שע",
+  "{value} D OLD": "{value} ימ",
   "Orbital view": "תצוגה מסלולית",
   "CURRENTLY OVER": "כעת מעל",
   "ORBITAL VIEW · OFF-NADIR": "תצוגה מסלולית · OFF-NADIR",
@@ -3382,5 +3382,11 @@
   "SATELLITE": "לוויין",
   "Ride {name}": "רכיבה על {name}",
   "FOCUS · {name}": "מוקד · {name}",
-  "Place names": "שמות מקומות"
+  "Place names": "שמות מקומות",
+  "Fly below {km} km to a covered city": "טוס מטה מתחת ל-{km} ק\"מ אל עיר עם הזנה",
+  "No bike share here yet · {n} systems available": {
+    "one": "אין עדיין שיתוף אופניים כאן · {n} מערכת זמינה",
+    "two": "אין עדיין שיתוף אופניים כאן · {n} מערכות זמינות",
+    "other": "אין עדיין שיתוף אופניים כאן · {n} מערכות זמינות"
+  }
 }
diff --git a/src/i18n/same-as-english.json b/src/i18n/same-as-english.json
index 3e24182df..34ca8c016 100644
--- a/src/i18n/same-as-english.json
+++ b/src/i18n/same-as-english.json
@@ -1250,7 +1250,6 @@
     "DEST ---°",
     "SQUAWK {code} · {status}",
     "DEST {bearing}",
-    "Space Missions",
     "CCTV",
     "S2 GhostMaps",
     "Street Level",
@@ -1264,7 +1263,6 @@
     "km",
     "min",
     "dB",
-    "LEVEL",
     "KTS",
     "FT",
     "FLT",
@@ -1281,16 +1279,14 @@
     "STARLINK",
     "STARLINK ···",
     "STARLINK ✕",
-    "LOOK STBD {bearing}°",
-    "LOOK PORT {bearing}°",
-    "LOOK ASTERN",
     "LOOK {elevation}",
-    "{vesselType} · {feedState} · EYE {height}",
     "{range} NM",
     "OFF-NADIR {angle}° · {offset}",
     "NORAD {id}",
     "EPOCH {time}",
     "TLE",
-    "OFF-NADIR {angle}°"
+    "OFF-NADIR {angle}°",
+    "{value} KM/S",
+    "Ironbow"
   ]
 }
diff --git a/src/overlays/worldOverlayTokens.js b/src/overlays/worldOverlayTokens.js
index f00ae5cf4..c03383148 100644
--- a/src/overlays/worldOverlayTokens.js
+++ b/src/overlays/worldOverlayTokens.js
@@ -7,9 +7,10 @@
  */
 
 /** Shared visual tokens used by every world-overlay source. */
-// Map-card fonts: JetBrains Mono has no Arabic glyphs and the generic
-// monospace fallback is a fixed-pitch Arabic face that stretches every word;
-// Arabic text falls through to Noto Sans Arabic (loaded with the page fonts).
+// Map-card fonts: JetBrains Mono has no Arabic or Hebrew glyphs and the
+// generic monospace fallback is a fixed-pitch Arabic face that stretches every
+// word; Arabic falls through to Noto Sans Arabic, Hebrew to Noto Sans Hebrew
+// (both loaded with the page fonts).
 export const WORLD_OVERLAY_STYLE = Object.freeze({
   background: 'rgba(4, 12, 16, 0.82)',
   selectedBackground: 'rgba(5, 18, 24, 0.94)',
@@ -19,13 +20,20 @@ export const WORLD_OVERLAY_STYLE = Object.freeze({
   detail: 'rgba(147, 161, 173, 0.92)',
   leader: 'rgba(147, 213, 228, 0.58)',
   accent: '#6be8ff',
-  fontLabel: '500 10px "JetBrains Mono", "Noto Sans Arabic", monospace',
-  fontTrack: '600 10px "JetBrains Mono", "Noto Sans Arabic", monospace',
-  fontTitle: '600 12px "JetBrains Mono", "Noto Sans Arabic", monospace',
-  fontDetail: '500 10.5px "JetBrains Mono", "Noto Sans Arabic", monospace',
-  fontSelected: '600 13px "JetBrains Mono", "Noto Sans Arabic", monospace',
-  fontTrackedTitle: '600 13px "JetBrains Mono", "Noto Sans Arabic", monospace',
-  fontTrackedDetail: '500 11px "JetBrains Mono", "Noto Sans Arabic", monospace',
+  fontLabel:
+    '500 10px "JetBrains Mono", "Noto Sans Arabic", "Noto Sans Hebrew", monospace',
+  fontTrack:
+    '600 10px "JetBrains Mono", "Noto Sans Arabic", "Noto Sans Hebrew", monospace',
+  fontTitle:
+    '600 12px "JetBrains Mono", "Noto Sans Arabic", "Noto Sans Hebrew", monospace',
+  fontDetail:
+    '500 10.5px "JetBrains Mono", "Noto Sans Arabic", "Noto Sans Hebrew", monospace',
+  fontSelected:
+    '600 13px "JetBrains Mono", "Noto Sans Arabic", "Noto Sans Hebrew", monospace',
+  fontTrackedTitle:
+    '600 13px "JetBrains Mono", "Noto Sans Arabic", "Noto Sans Hebrew", monospace',
+  fontTrackedDetail:
+    '500 11px "JetBrains Mono", "Noto Sans Arabic", "Noto Sans Hebrew", monospace',
   radius: 4,
   anchorDotRadius: 3.2,
   anchorDotStrokeWidth: 1,
diff --git a/src/ui/styles/rtl.css b/src/ui/styles/rtl.css
index 8e7288b3e..2106b1bca 100644
--- a/src/ui/styles/rtl.css
+++ b/src/ui/styles/rtl.css
@@ -1,6 +1,7 @@
-/* Right-to-left languages (Arabic). The chrome mirrors through logical
-   properties in the component sheets (inset-inline-*, margin-inline-*); this
-   sheet holds only what logical properties cannot express. */
+/* Right-to-left languages (Arabic, Hebrew). The chrome mirrors through
+   logical properties in the component sheets (inset-inline-*,
+   margin-inline-*); this sheet holds only what logical properties cannot
+   express. */
 
 /* Arabic letters join: letter-spacing tears every word into separate glyphs.
    Latin marked translate="no" and the intel HUD's Latin telemetry keep their
@@ -63,10 +64,9 @@ html:lang(ar) :is(#intel-hud, #cockpit-hud) {
 /* Hebrew: JetBrains Mono and Inter also lack Hebrew glyphs. Noto Sans Hebrew
    (loaded with the other Google fonts; its files download only when the page
    shows Hebrew) leads the stack so the body text keeps one proportional
-   Hebrew face across platforms. Hebrew letters do not join like Arabic, but
-   tracking still reads as gaps inside a word, so the body is released from it
-   the same way; Latin marked translate="no" keeps its tracking. The intel and
-   cockpit HUDs keep JetBrains Mono for their Latin telemetry. */
+   Hebrew face across platforms. Hebrew letters do not join, so tracking on
+   them only spaces a word out; the body is released the same way, and the
+   HUDs keep their instrument tracking inside. */
 html:lang(he) {
   --font-mono:
     'Noto Sans Hebrew', 'JetBrains Mono', 'SF Mono', 'Fira Code', Tahoma,
@@ -75,7 +75,10 @@ html:lang(he) {
     'Inter', 'Noto Sans Hebrew', -apple-system, BlinkMacSystemFont, Tahoma,
     sans-serif;
 }
-html:lang(he)
+/* The Global Context lines and their buttons set ui-monospace through the
+   `font` shorthand; in both RTL languages the words come from the page's
+   own font stack. */
+html:is(:lang(ar), :lang(he))
   :is(
     #military-awareness-panel,
     .military-awareness-controls button,
@@ -87,6 +90,13 @@ html:lang(he)
   ) {
   font-family: var(--font-mono);
 }
+/* The intel and cockpit HUDs keep JetBrains Mono leading for their Latin
+   telemetry and column-aligned digits, with the language's face behind it. */
+html:lang(ar) :is(#intel-hud, #cockpit-hud) {
+  --font-mono:
+    'JetBrains Mono', 'SF Mono', 'Fira Code', 'Noto Sans Arabic', 'Geeza Pro',
+    Tahoma, monospace;
+}
 html:lang(he) :is(#intel-hud, #cockpit-hud) {
   --font-mono:
     'JetBrains Mono', 'SF Mono', 'Fira Code', 'Noto Sans Hebrew', Tahoma,

From 04b8c856ad8d155cc1f60bfbf61f23ebd6fe22fb Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 9 Nov 2026 01:25:43 -0800
Subject: [PATCH 49/71] Keep vehicles off rooftops and bridge decks: probe the
 mesh where the vehicle is

On the photoreal stack the rendered-mesh floor took one probe at each coarse
cell's centre (0.001 degrees) and kept it for the session. A centre on a roof
passed the +80 m DEM window and lifted every vehicle in the cell to roof height
(a Haymarket bus drew 23.5 m above the street, on the garage roof); a centre in
the river put Red Line trains on the Longfellow Bridge 6-9 m under the deck.

The sampler now probes at the caller's point. A cell with a reading is probed
again only at spots about 17 m apart from earlier ones, eight at most, and a
spot refused only because the cell's DEM prior was cold is tried again later.
The floor keeps each reading that passes the gate at the point it was taken
(two within about 5 m keep the lower; sixteen at most per cell) and answers a
read from the reading nearest the asked point, so a viaduct and the street
beside it in one cell keep their own heights.
---
 docs/CURRENT-STATE.md                   |  23 ++-
 src/data/groundFloor.js                 |   1 +
 src/data/meshFloorSampler.test.mjs      | 179 +++++++++++++++++++++++-
 src/layers/cctv/geometry.js             |   2 +-
 src/layers/flights/snapshotRenderer.js  |   4 +-
 src/layers/military/snapshotRenderer.js |   4 +-
 src/services/groundFloor.js             |  81 +++++++++--
 src/services/groundSnap.js              |   2 +-
 src/services/meshFloorSampler.js        |  61 ++++++--
 9 files changed, 329 insertions(+), 28 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 05240d922..5e7c36be2 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -1347,6 +1347,27 @@ and snapshot source. The standalone adapter keeps the existing USGS daily feed,
 M2.5+ filtering, static discs, magnitude labels and analyst records. Disabling or
 destroying the layer cancels pending work and ignores late results.
 
+## Rendered-mesh floor readings — November 9, 2026
+
+On the photoreal stack the shared floor (`cachedGroundFloor`) answers from
+rendered-mesh readings per coarse cell (0.001°, about 110 × 80 m), sampled by
+`src/services/meshFloorSampler.js` and gated against the DEM by
+`reportValidatedMeshFloorCell` in `src/services/groundFloor.js`. The probe goes
+where the caller's point is (a vehicle or contact), not to the cell's centre;
+the sampler reads a cell at up to eight spots about 12–17 m or more apart, and
+each reading that passes the gate is kept at its point (ground snaps add theirs
+the same way; a cell keeps at most sixteen). A read answers from the cell's
+reading nearest the asked point, so a viaduct and the street beside it in one
+cell keep their own heights; two readings within about 5 m of each other keep
+the lower. A spot refused only because the cell's DEM prior was cold is tried
+again later. Before this, one probe at the cell's centre latched for the
+session, so a centre on a roof lifted everything in the cell (a Haymarket bus
+drew 23.5 m above the street, on the garage roof) and a centre in the river put
+Red Line trains on the Longfellow Bridge 6–9 m under the deck. Residual: the
+probe is vertical, so a vehicle directly under a deck or a roof overhang reads
+the structure above it, and a vehicle between readings takes the nearest one, so
+its floor steps where the nearest reading changes.
+
 ## Vessel components and sources
 
 `src/data/aisLiveVessels.js` assembles `createVesselLayer` from the
@@ -3148,7 +3169,7 @@ This is the current runtime/source-of-truth snapshot for the project.
 >   `HELD_SNAP_CONTRADICTION_M` (5 m) ABOVE the held value drops the hold and the
 >   contact is COLD again, back to the floored 2D billboard. The rule is
 >   ONE-SIDED on purpose — it targets BURIAL. A cell reading BELOW a real sample
->   is the floor chain's expected under-read (one-shot latch over ~111 m,
+>   is the floor chain's expected under-read (a few point readings over ~111 m,
 >   neighbours lean lowest, `displayFloorHeightM` only ever raises), not evidence
 >   of anything, and a two-sided cut was disproved on the track rig by a planted
 >   cell 66.7 m below a real sample at the same spot. Accepted residual, stated
diff --git a/src/data/groundFloor.js b/src/data/groundFloor.js
index fed7a6cd6..978f30218 100644
--- a/src/data/groundFloor.js
+++ b/src/data/groundFloor.js
@@ -22,6 +22,7 @@ export const {
   reportMeshFloorCell,
   meshFloorSampleWithinPrior,
   reportValidatedMeshFloorCell,
+  meshFloorPriorReady,
   cachedMeshFloor,
   _clearMeshFloorCellsForTest,
   cachedGroundFloor,
diff --git a/src/data/meshFloorSampler.test.mjs b/src/data/meshFloorSampler.test.mjs
index f651d72f8..d33c4873d 100644
--- a/src/data/meshFloorSampler.test.mjs
+++ b/src/data/meshFloorSampler.test.mjs
@@ -24,7 +24,7 @@ import { sampleMeshFloorCells } from './meshFloorSampler.js';
 import { resolveEllipsoidalGround } from './terrainHeights.js';
 import {
   cachedGroundFloor, cachedMeshFloor, setMeshFloorPreferred,
-  _clearMeshFloorCellsForTest,
+  _clearMeshFloorCellsForTest, reportValidatedMeshFloorCell,
 } from './groundFloor.js';
 
 /** Distinct site per test — terrainHeights' cache is module-global and warm
@@ -137,3 +137,180 @@ test('sampler: a cell just across the antimeridian is still near the viewer', ()
   sampleMeshFloorCells(scene, [{ lat: -16.81, lon: 179.999 }], { viewerLat: -16.81, viewerLon: -179.999 });
   assert.equal(calls, 2, 'about 200 m apart, so both cells are probed');
 });
+
+test('sampler: the probe goes where the point is, not to the cell centre', async () => {
+  reset();
+  const cell = nextSite();
+  await seedDem(cell, 120.0);
+  const asked = [];
+  const scene = fakeScene((carto) => {
+    asked.push(Cesium.Math.toDegrees(carto.longitude));
+    return 122.0;
+  });
+  const point = { lat: cell.lat + 0.0003, lon: cell.lon + 0.0004 };
+  sampleMeshFloorCells(scene, [point], { viewerLat: cell.lat, viewerLon: cell.lon });
+  assert.equal(asked.length, 1);
+  assert.ok(Math.abs(asked[0] - point.lon) < 1e-9, `probed at ${asked[0]}, not ${point.lon}`);
+});
+
+test('sampler: a viaduct and the street beside it in one cell keep their own heights', async () => {
+  reset();
+  const cell = nextSite();
+  await seedDem(cell, 120.0);
+  // A viaduct deck 9 m up along one line of the cell, the street elsewhere.
+  const deckLat = cell.lat + 0.0003;
+  let calls = 0;
+  const scene = fakeScene((carto) => {
+    calls += 1;
+    return Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0;
+  });
+  const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
+  const onDeck = { lat: deckLat, lon: cell.lon };
+  const street = { lat: cell.lat - 0.0003, lon: cell.lon };
+  sampleMeshFloorCells(scene, [onDeck], opts);
+  sampleMeshFloorCells(scene, [street], opts);
+  assert.equal(calls, 2);
+  assert.equal(cachedMeshFloor(onDeck.lat, onDeck.lon + 0.0001), 129.0, 'the train stays on the deck');
+  assert.equal(cachedMeshFloor(street.lat, street.lon - 0.0001), 121.0, 'the bus stays on the street');
+  assert.equal(cachedGroundFloor(street.lat, street.lon), 121.0);
+  sampleMeshFloorCells(scene, [{ lat: deckLat, lon: cell.lon + 0.00001 }], opts);
+  assert.equal(calls, 2, 'a point next to one already probed is not probed again');
+});
+
+test('sampler: a roof over the cell centre does not lift a bus on the street', async () => {
+  reset();
+  const cell = nextSite();
+  await seedDem(cell, 120.0);
+  // A roof 22 m up covering the cell's centre; the street 30 m west of it.
+  const scene = fakeScene((carto) =>
+    Math.abs(Cesium.Math.toDegrees(carto.longitude) - cell.lon) < 0.0001 ? 142.0 : 121.0);
+  const bus = { lat: cell.lat, lon: cell.lon - 0.0003 };
+  sampleMeshFloorCells(scene, [bus], { viewerLat: cell.lat, viewerLon: cell.lon });
+  assert.equal(cachedGroundFloor(bus.lat, bus.lon), 121.0);
+});
+
+test('sampler: a second reading at the same spot keeps the lower one', async () => {
+  reset();
+  const cell = nextSite();
+  await seedDem(cell, 120.0);
+  assert.equal(reportValidatedMeshFloorCell(cell.lat, cell.lon, 131.0), true);
+  assert.equal(reportValidatedMeshFloorCell(cell.lat + 0.00002, cell.lon, 122.0), true);
+  assert.equal(cachedMeshFloor(cell.lat, cell.lon), 122.0);
+  assert.equal(reportValidatedMeshFloorCell(cell.lat, cell.lon + 0.00002, 140.0), true);
+  assert.equal(cachedMeshFloor(cell.lat, cell.lon), 122.0, 'a higher one never raises it');
+});
+
+test('sampler: a cell with a reading is probed a few times at most', async () => {
+  reset();
+  const cell = nextSite();
+  await seedDem(cell, 120.0);
+  let calls = 0;
+  const scene = fakeScene(() => {
+    calls += 1;
+    return 121.0;
+  });
+  const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
+  for (let i = 0; i < 20; i++)
+    sampleMeshFloorCells(
+      scene,
+      [{ lat: cell.lat - 0.0004 + (i % 5) * 0.0002, lon: cell.lon - 0.00045 + Math.floor(i / 5) * 0.0003 }],
+      opts,
+    );
+  assert.equal(calls, 8);
+});
+
+test('sampler: a cell with no accepted reading is probed again on every call', async () => {
+  reset();
+  const cell = nextSite();
+  let calls = 0;
+  const scene = fakeScene(() => {
+    calls += 1;
+    return 138.0;
+  });
+  const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
+  for (let i = 0; i < 3; i++) sampleMeshFloorCells(scene, [cell], opts);
+  assert.equal(calls, 3, 'no DEM prior yet, so nothing is kept and the cell is retried');
+  await seedDem(cell, 120.0);
+  sampleMeshFloorCells(scene, [cell], opts);
+  assert.equal(cachedMeshFloor(cell.lat, cell.lon), 138.0, 'and lands once the prior is warm');
+});
+
+test('sampler: a spot whose reading is refused does not use up the cell', async () => {
+  reset();
+  const cell = nextSite();
+  await seedDem(cell, 120.0);
+  // A tower 260 m up where the first vehicle waits; the street elsewhere and
+  // a deck 9 m up along one line of the cell.
+  const towerLon = cell.lon + 0.0004;
+  const deckLat = cell.lat + 0.0003;
+  const scene = fakeScene((carto) => {
+    if (Math.abs(Cesium.Math.toDegrees(carto.longitude) - towerLon) < 1e-7) return 380.0;
+    return Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0;
+  });
+  const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
+  for (let i = 0; i < 10; i++) sampleMeshFloorCells(scene, [{ lat: cell.lat, lon: towerLon }], opts);
+  assert.equal(cachedMeshFloor(cell.lat, cell.lon), null, 'the tower is refused every time');
+  sampleMeshFloorCells(scene, [{ lat: cell.lat - 0.0003, lon: cell.lon }], opts);
+  sampleMeshFloorCells(scene, [{ lat: deckLat, lon: cell.lon - 0.0003 }], opts);
+  assert.equal(cachedMeshFloor(deckLat, cell.lon - 0.0003), 129.0, 'the deck is still probed');
+});
+
+test('ground floor: a cell keeps at most sixteen readings', async () => {
+  reset();
+  const cell = nextSite();
+  await seedDem(cell, 120.0);
+  for (let i = 0; i < 40; i++) {
+    const lat = cell.lat - 0.00045 + (i % 8) * 0.0001;
+    const lon = cell.lon - 0.00045 + Math.floor(i / 8) * 0.0002;
+    reportValidatedMeshFloorCell(lat, lon, 121.0 + i);
+  }
+  // Readings 0..15 are kept; reading 39 (at the far corner) is not, so that
+  // spot answers from the nearest kept one.
+  assert.equal(cachedMeshFloor(cell.lat - 0.00045, cell.lon - 0.00045), 121.0);
+  assert.equal(cachedMeshFloor(cell.lat + 0.00025, cell.lon + 0.00035), 121.0 + 15);
+});
+
+test('sampler: a spot refused while the DEM was cold is probed again once it is warm', async () => {
+  reset();
+  const cell = nextSite();
+  const deckLat = cell.lat + 0.0003;
+  let calls = 0;
+  const scene = fakeScene((carto) => {
+    calls += 1;
+    return Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0;
+  });
+  const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
+  const onDeck = { lat: deckLat, lon: cell.lon };
+  sampleMeshFloorCells(scene, [onDeck], opts);
+  assert.equal(cachedMeshFloor(onDeck.lat, onDeck.lon), null, 'no prior, nothing kept');
+  await seedDem(cell, 120.0);
+  sampleMeshFloorCells(scene, [{ lat: cell.lat - 0.0003, lon: cell.lon }], opts);
+  sampleMeshFloorCells(scene, [onDeck], opts);
+  assert.equal(calls, 3);
+  assert.equal(cachedMeshFloor(onDeck.lat, onDeck.lon), 129.0);
+});
+
+test('sampler: a spot refused while the DEM prior was evicted is probed again', async () => {
+  const { createGroundFloor } = await import('../services/groundFloor.js');
+  const { createMeshFloorSampler } = await import('../services/meshFloorSampler.js');
+  let prior = 120.0;
+  const terrain = {
+    cachedRealEllipsoidalGround: () => prior,
+    resolveEllipsoidalGround: async () => {},
+  };
+  const groundFloor = createGroundFloor({ terrain });
+  const sampler = createMeshFloorSampler({ groundFloor });
+  const cell = { lat: 41.5, lon: -97.66 };
+  const deckLat = cell.lat + 0.0003;
+  const scene = fakeScene((carto) =>
+    Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0);
+  const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
+  const onDeck = { lat: deckLat, lon: cell.lon };
+  sampler.sampleMeshFloorCells(scene, [{ lat: cell.lat - 0.0003, lon: cell.lon }], opts);
+  prior = null; // the cell's DEM entry is evicted; the street reading stays
+  sampler.sampleMeshFloorCells(scene, [onDeck], opts);
+  assert.equal(groundFloor.cachedMeshFloor(onDeck.lat, onDeck.lon), 121.0);
+  prior = 120.0;
+  sampler.sampleMeshFloorCells(scene, [onDeck], opts);
+  assert.equal(groundFloor.cachedMeshFloor(onDeck.lat, onDeck.lon), 129.0);
+});
diff --git a/src/layers/cctv/geometry.js b/src/layers/cctv/geometry.js
index 362ad4789..a1402c6c2 100644
--- a/src/layers/cctv/geometry.js
+++ b/src/layers/cctv/geometry.js
@@ -448,7 +448,7 @@ export function createGeometry({ state: layerState, services, parts, source }) {
     }
 
     // Photoreal regime. Sampling is delegated to the shared coarse-cell
-    // sampler. It remains event-driven, one-shot per cell, and keeps its
+    // sampler. It remains event-driven, a few probes per cell, and keeps its
     // existing acceptance window; CCTV adds no rooftop rejection policy.
     if (sampleGround && parts.model.projectionTilesReady()) {
       record.groundMeshSampleRequestCount =
diff --git a/src/layers/flights/snapshotRenderer.js b/src/layers/flights/snapshotRenderer.js
index ec6c2933b..d48d12774 100644
--- a/src/layers/flights/snapshotRenderer.js
+++ b/src/layers/flights/snapshotRenderer.js
@@ -300,8 +300,8 @@ export function createFlightSnapshotRenderer({
     // floor cells collected in the loop (fire-and-forget, single-flight;
     // read synchronously by NEXT poll's clamp — the military-layer pattern).
     warmGroundFloor(floorWarmPoints);
-    // Round 4: sample the RENDERED mesh for those same cells (one-shot per
-    // cell, budget-capped, viewer-proximate, google-3d regime only). Own
+    // Round 4: sample the RENDERED mesh for those same cells (a few probes
+    // per cell, budget-capped, viewer-proximate, google-3d regime only). Own
     // billboards/models are excluded so a vertical probe can't land on an
     // aircraft instead of the pavement.
     sampleMeshFloorCells(flightState._viewer?.scene, floorWarmPoints, {
diff --git a/src/layers/military/snapshotRenderer.js b/src/layers/military/snapshotRenderer.js
index 7ed2b1c1f..eb3a341f8 100644
--- a/src/layers/military/snapshotRenderer.js
+++ b/src/layers/military/snapshotRenderer.js
@@ -228,8 +228,8 @@ export function createMilitarySnapshotRenderer({
       const bbStale = flightState._billboards.get(icao24);
       if (bbStale) bbStale.position = liftedPos;
     }
-    // Round 4: sample the RENDERED mesh for those cells (one-shot per cell,
-    // budget-capped, viewer-proximate, google-3d regime only), excluding
+    // Round 4: sample the RENDERED mesh for those cells (a few probes per
+    // cell, budget-capped, viewer-proximate, google-3d regime only), excluding
     // this layer's own billboards/models from the probe.
     {
       const viewerCarto =
diff --git a/src/services/groundFloor.js b/src/services/groundFloor.js
index 27b7dc5e4..3b4939fc5 100644
--- a/src/services/groundFloor.js
+++ b/src/services/groundFloor.js
@@ -418,13 +418,26 @@ export function createGroundFloor({ terrain, signal }) {
   // is the photogrammetric MESH, which sits above it (measured ~17 m at the
   // Austin airport apron). DEM-flooring therefore still buried sprites/trails
   // inside the mesh. These cells hold the RENDERED surface height, sampled
-  // one-shot per coarse cell near the viewer (scene.sampleHeight — the same
+  // at the callers' points, a few per coarse cell near the viewer, each kept
+  // where it was taken and read back from the nearest (scene.sampleHeight — the same
   // source groundSnap uses, which is why 3D models always looked right) and
   // reported here by meshFloorSampler.js. Design principle (owner): NEVER
   // below the visible surface; slightly above is always fine. The DEM stays
   // the instant global prior/fallback and the sanity gate for samples.
-  /** @type {Map<string, number>} coarse cell key -> rendered-surface height (m, ellipsoidal). */
+  /** @type {Map<string, Array<{lat: number, lon: number, h: number}>>}
+   *  coarse cell key -> rendered-surface readings (m, ellipsoidal), each kept
+   *  at the point it was probed. A read answers from the reading nearest the
+   *  asked point, so a viaduct and the street beside it in one cell keep their
+   *  own heights. */
   const _meshCells = new Map();
+  /** @constant {number} Readings closer than this (degrees, about 5 m) are
+   *  one spot: the lower one is kept there. */
+  const MESH_READING_SAME_SPOT_DEG = 0.00005;
+  /** @constant {number} Readings kept per cell. The sampler probes a cell at
+   *  most eight times, but ground snaps report at each aircraft's position;
+   *  past this many, a reading away from the others is not kept, so a busy
+   *  apron cell stays a short list to scan. */
+  const MESH_READINGS_PER_CELL = 16;
   /** @type {boolean} Whether mesh cells apply — true only in the google-3d
    *  regime (photoreal stack). On globe stacks the rendered surface IS the
    *  terrain provider (Re:Earth on keyless), so the DEM is already correct
@@ -444,7 +457,8 @@ export function createGroundFloor({ terrain, signal }) {
 
   /**
    * Records a sampled rendered-surface height for the cell containing the
-   * coordinate (one-shot latch — first accepted sample wins).
+   * coordinate, unchecked, when the cell has no reading yet. The sampler goes
+   * through `reportValidatedMeshFloorCell`, which keeps a reading per point.
    * @param {number} lat @param {number} lon @param {number} heightM
    */
   function reportMeshFloorCell(lat, lon, heightM) {
@@ -456,7 +470,7 @@ export function createGroundFloor({ terrain, signal }) {
       return;
     const c = coarseFloorCoord(lat, lon);
     const key = `${c.lat},${c.lon}`;
-    if (!_meshCells.has(key)) _meshCells.set(key, heightM);
+    if (!_meshCells.has(key)) _meshCells.set(key, [{ lat, lon, h: heightM }]);
   }
 
   /** Return whether a rendered-mesh sample is plausible against a real DEM prior. */
@@ -471,9 +485,11 @@ export function createGroundFloor({ terrain, signal }) {
 
   /**
    * Validate and record a rendered-mesh floor through the single shared gate.
-   * Callers must not bypass this with raw `reportMeshFloorCell`: a coarse-LOD,
-   * rooftop, or aircraft hit would otherwise win the session-long first-write
-   * latch and poison every floor consumer in the cell.
+   * Callers must not bypass this with raw `reportMeshFloorCell`: a coarse-LOD
+   * or aircraft hit would otherwise poison every floor consumer in the cell.
+   * The reading is kept at the point it was taken; a second reading at the
+   * same spot (within about 5 m) keeps the lower of the two. A cell keeps at
+   * most MESH_READINGS_PER_CELL readings.
    * @returns {boolean} Whether the sample passed and was reported.
    */
   function reportValidatedMeshFloorCell(lat, lon, heightM) {
@@ -481,13 +497,41 @@ export function createGroundFloor({ terrain, signal }) {
     const cell = coarseFloorCoord(lat, lon);
     const prior = cachedRealEllipsoidalGround(cell.lat, cell.lon);
     if (!meshFloorSampleWithinPrior(heightM, prior)) return false;
-    reportMeshFloorCell(cell.lat, cell.lon, heightM);
+    const key = `${cell.lat},${cell.lon}`;
+    const readings = _meshCells.get(key);
+    if (!readings) {
+      _meshCells.set(key, [{ lat, lon, h: heightM }]);
+      return true;
+    }
+    const same = readings.find(
+      (r) =>
+        Math.abs(r.lat - lat) < MESH_READING_SAME_SPOT_DEG &&
+        Math.abs(r.lon - lon) < MESH_READING_SAME_SPOT_DEG,
+    );
+    if (same) {
+      if (heightM < same.h) same.h = heightM;
+    } else if (readings.length < MESH_READINGS_PER_CELL) {
+      readings.push({ lat, lon, h: heightM });
+    }
     return true;
   }
 
   /**
-   * Synchronous mesh-cell read — null when the cell is unsampled OR the
-   * google-3d regime is inactive (globe stacks must floor on the DEM).
+   * Whether the cell holding the point has the real DEM prior that
+   * `reportValidatedMeshFloorCell` judges a reading against.
+   * @param {number} lat @param {number} lon
+   * @returns {boolean}
+   */
+  function meshFloorPriorReady(lat, lon) {
+    if (!Number.isFinite(lat) || !Number.isFinite(lon)) return false;
+    const c = coarseFloorCoord(lat, lon);
+    return cachedRealEllipsoidalGround(c.lat, c.lon) != null;
+  }
+
+  /**
+   * Synchronous mesh-cell read — the cell's reading nearest the point, or
+   * null when the cell is unsampled OR the google-3d regime is inactive (globe
+   * stacks must floor on the DEM).
    * @param {number} lat @param {number} lon
    * @returns {number|null}
    */
@@ -495,8 +539,20 @@ export function createGroundFloor({ terrain, signal }) {
     if (!_meshPreferred) return null;
     if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
     const c = coarseFloorCoord(lat, lon);
-    const h = _meshCells.get(`${c.lat},${c.lon}`);
-    return h != null ? h : null;
+    const readings = _meshCells.get(`${c.lat},${c.lon}`);
+    if (!readings) return null;
+    if (readings.length === 1) return readings[0].h;
+    const k = Math.cos((lat * Math.PI) / 180) ** 2;
+    let best = readings[0],
+      bestD = Infinity;
+    for (const r of readings) {
+      const d = (r.lat - lat) ** 2 + k * (r.lon - lon) ** 2;
+      if (d < bestD) {
+        bestD = d;
+        best = r;
+      }
+    }
+    return best.h;
   }
 
   /** Test hook: clears mesh cells (never called at runtime — cells are valid all session). */
@@ -662,6 +718,7 @@ export function createGroundFloor({ terrain, signal }) {
     reportMeshFloorCell,
     meshFloorSampleWithinPrior,
     reportValidatedMeshFloorCell,
+    meshFloorPriorReady,
     cachedMeshFloor,
     _clearMeshFloorCellsForTest,
     cachedGroundFloor,
diff --git a/src/services/groundSnap.js b/src/services/groundSnap.js
index eecb1fa34..b1d75cfbb 100644
--- a/src/services/groundSnap.js
+++ b/src/services/groundSnap.js
@@ -101,7 +101,7 @@ const HELD_SNAP_MAX_DRIFT_M = 250;
  *  alone, and the asymmetry is not tidiness:
  *
  *   - A cell reading LOW against a real sample is the EXPECTED error here, not a
- *     contradiction. Cells are a one-shot first-write latch over ~111 m, the
+ *     contradiction. Cells hold a few point readings over ~111 m, the
  *     borrowed-neighbour path leans to the LOWEST on purpose (`neighborFloorM`),
  *     and `displayFloorHeightM` only ever RAISES — the whole floor chain is
  *     built to under-read rather than to invent. Releasing on that sign would
diff --git a/src/services/meshFloorSampler.js b/src/services/meshFloorSampler.js
index c967f80c8..083789ea9 100644
--- a/src/services/meshFloorSampler.js
+++ b/src/services/meshFloorSampler.js
@@ -11,6 +11,7 @@ export function createMeshFloorSampler({
     coarseFloorCoord,
     cachedMeshFloor,
     reportValidatedMeshFloorCell,
+    meshFloorPriorReady,
     setMeshFloorPreferred,
     meshFloorPreferred,
     cachedGroundFloor,
@@ -23,13 +24,16 @@ export function createMeshFloorSampler({
   // which sits above the Re:Earth bare-earth DEM (measured ~17 m at the Austin
   // airport apron) — so DEM-floored sprites/trails still buried themselves in
   // the mesh while 3D models (which groundSnap against the mesh) looked right.
-  // This module samples the mesh height ONE-SHOT per coarse cell and reports it
-  // to groundFloor.js, whose cachedGroundFloor() then answers mesh-first.
+  // This module samples the mesh height at the callers' points, a few probes
+  // per coarse cell, and reports them to groundFloor.js, which keeps each
+  // reading that passes its gate at its own point; cachedGroundFloor() then
+  // answers mesh-first, from the reading nearest the asked point.
   //
   // Rationing (the CCTV loading-jitter lesson): scene.sampleHeight forces
   // tile-load prioritization at the probe point, so sampling is (a) gated to
   // cells NEAR the viewer — where tiles are streamed and where an error is
-  // visible at all, (b) capped per call, (c) one-shot per cell for the session,
+  // visible at all, (b) capped per call, (c) at most MAX_PROBES_PER_CELL
+  // readings per cell for the session, each at a point apart from the others,
   // (d) skipped entirely outside the google-3d regime. A returned-undefined
   // probe (tiles not streamed yet) is NOT latched — it retries on a later call.
   //
@@ -49,6 +53,16 @@ export function createMeshFloorSampler({
    *  streamed LOD under a high camera is coarse everywhere, so every probe
    *  would latch junk. */
   const MAX_CAMERA_HEIGHT_M = 25_000;
+  /** @constant {number} Readings per cell: a cell is probed at most this
+   *  many times, each at a point apart from the others, and groundFloor keeps
+   *  each reading at its point (a read answers from the nearest one). */
+  const MAX_PROBES_PER_CELL = 8;
+  /** @constant {number} How far apart (degrees, about 17 m) a new probe must
+   *  be from the cell's earlier ones to be worth taking. */
+  const PROBE_APART_DEG = 0.00015;
+  /** @type {Map<string, Array<{lat: number, lon: number}>>} Points probed
+   *  per cell that returned a reading. */
+  const _probedPoints = new Map();
   /** @type {Cesium.Cartographic} Scratch for probe coordinates. */
   const _scratchProbe = new Cesium.Cartographic();
 
@@ -82,7 +96,7 @@ export function createMeshFloorSampler({
 
   /**
    * Samples the rendered mesh height for the coarse cells containing `points`,
-   * one-shot per cell, budget-capped, viewer-proximity-gated. Call ONCE per
+   * a few probes per cell, budget-capped, viewer-proximity-gated. Call ONCE per
    * layer poll (never per contact, never per frame). Synchronous — Cesium's
    * sampleHeight is a CPU-side query against loaded tiles.
    *
@@ -119,8 +133,21 @@ export function createMeshFloorSampler({
       const cell = coarseFloorCoord(p.lat, p.lon);
       const key = `${cell.lat},${cell.lon}`;
       if (attempted.has(key)) continue;
+      // A cell with a reading is probed again only at a point well apart
+      // from the ones already probed, a few times at most, so the cell's
+      // readings follow where its vehicles actually are.
+      const probes = _probedPoints.get(key);
+      if (
+        cachedMeshFloor(cell.lat, cell.lon) != null &&
+        (probes?.length >= MAX_PROBES_PER_CELL ||
+          probes?.some(
+            (q) =>
+              Math.abs(q.lat - p.lat) < PROBE_APART_DEG &&
+              Math.abs(q.lon - p.lon) < PROBE_APART_DEG,
+          ))
+      )
+        continue;
       attempted.add(key);
-      if (cachedMeshFloor(cell.lat, cell.lon) != null) continue; // one-shot latch
       if (
         Number.isFinite(viewerLat) &&
         Number.isFinite(viewerLon) &&
@@ -131,9 +158,11 @@ export function createMeshFloorSampler({
       }
       let height;
       try {
+        // Probe where the caller's point is, not at the cell's centre: a
+        // centre that falls on a roof would lift everything in the cell.
         const carto = Cesium.Cartographic.fromDegrees(
-          cell.lon,
-          cell.lat,
+          p.lon,
+          p.lat,
           0,
           _scratchProbe,
         );
@@ -171,7 +200,23 @@ export function createMeshFloorSampler({
       // feasible and deliberately deferred — see the P2 in
       // the project roadmap, which bundles it with the fly_route probe so
       // one post-launch pass settles rendered-mesh sampling everywhere.
-      reportValidatedMeshFloorCell(cell.lat, cell.lon, height);
+      const accepted = reportValidatedMeshFloorCell(p.lat, p.lon, height);
+      // A spot counts as probed once the gate has judged it against a real
+      // prior: accepted, or refused with the cell's DEM warm. A spot refused
+      // only because the DEM was still cold is tried again later. Each spot is
+      // recorded once, so a cell retried while it has no reading does not fill
+      // its probe allowance with the same spot.
+      if (!accepted && !meshFloorPriorReady(cell.lat, cell.lon)) continue;
+      if (!probes) _probedPoints.set(key, [{ lat: p.lat, lon: p.lon }]);
+      else if (
+        probes.length < MAX_PROBES_PER_CELL &&
+        !probes.some(
+          (q) =>
+            Math.abs(q.lat - p.lat) < PROBE_APART_DEG &&
+            Math.abs(q.lon - p.lon) < PROBE_APART_DEG,
+        )
+      )
+        probes.push({ lat: p.lat, lon: p.lon });
     }
   }
 

From 9bce41d3c6a83125ac496ad3b6abeea6ca200f3b Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 9 Nov 2026 01:26:01 -0800
Subject: [PATCH 50/71] Read the mesh floor where transit vehicles and grounded
 flights actually are

With readings kept per point, the floor a vehicle gets depends on which point
is probed and where it is read. Transit offered the sampler the first point of
each vehicle's path in a cell, usually its oldest fix there, so a vehicle that
stayed in one cell never had its current spot probed. It now offers the latest
point of the path in each cell, and the newest fix in the vehicle's own cell
(the selected vehicle's history is walked newest first).

The grounded-flight display clamp read the floor at its sticky cell's centre,
which now answers from the reading nearest the centre, not the contact. It
reads at the contact's own position, held inside the sticky cell so boundary
hysteresis still applies.
---
 docs/CURRENT-STATE.md                 |  17 ++--
 src/data/flights.test.mjs             |  35 +++++++++
 src/layers/flights/motion.js          |  29 +++++--
 src/layers/transit/height.js          |  16 +++-
 src/layers/transit/lifecycle.test.mjs | 108 ++++++++++++++++++++++++++
 5 files changed, 192 insertions(+), 13 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 5e7c36be2..0739cf5e1 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -1360,13 +1360,16 @@ the same way; a cell keeps at most sixteen). A read answers from the cell's
 reading nearest the asked point, so a viaduct and the street beside it in one
 cell keep their own heights; two readings within about 5 m of each other keep
 the lower. A spot refused only because the cell's DEM prior was cold is tried
-again later. Before this, one probe at the cell's centre latched for the
-session, so a centre on a roof lifted everything in the cell (a Haymarket bus
-drew 23.5 m above the street, on the garage roof) and a centre in the river put
-Red Line trains on the Longfellow Bridge 6–9 m under the deck. Residual: the
-probe is vertical, so a vehicle directly under a deck or a roof overhang reads
-the structure above it, and a vehicle between readings takes the nearest one, so
-its floor steps where the nearest reading changes.
+again later. Transit offers the sampler the latest point of each vehicle's path
+in a cell (its newest fix in its own cell), and the grounded-flight display
+clamp reads at the contact, held inside its sticky cell. Before this, one probe
+at the cell's centre latched for the session, so a centre on a roof lifted
+everything in the cell (a Haymarket bus drew 23.5 m above the street, on the
+garage roof) and a centre in the river put Red Line trains on the Longfellow
+Bridge 6–9 m under the deck. Residual: the probe is vertical, so a vehicle
+directly under a deck or a roof overhang reads the structure above it, and a
+vehicle between readings takes the nearest one, so its floor steps where the
+nearest reading changes.
 
 ## Vessel components and sources
 
diff --git a/src/data/flights.test.mjs b/src/data/flights.test.mjs
index 7fe197c30..1d6007e8f 100644
--- a/src/data/flights.test.mjs
+++ b/src/data/flights.test.mjs
@@ -20,9 +20,11 @@ import { setMilitaryLayerActive } from './militaryRegistry.js';
 import {
   GROUND_FLOOR_LIFT_M,
   reportMeshFloorCell,
+  reportValidatedMeshFloorCell,
   setMeshFloorPreferred,
   _clearMeshFloorCellsForTest,
 } from './groundFloor.js';
+import { resolveEllipsoidalGround } from './terrainHeights.js';
 import {
   _setTrackedOverlayHostForTest,
   destroyTrackedReadout,
@@ -1181,6 +1183,39 @@ test('display floor: a grounded contact that drifted onto a higher cell is lifte
   assert.ok(Math.abs(Cesium.Math.toDegrees(c.longitude) + 97.6604) < 1e-6);
 });
 
+test('display floor: reads the reading nearest the contact, not the cell centre', async () => {
+  _clearDisplayFloorStateForTest();
+  _clearMeshFloorCellsForTest();
+  setMeshFloorPreferred(true);
+  const realFetch = globalThis.fetch;
+  globalThis.fetch = async () =>
+    new Response(JSON.stringify({ results: [{ ellipsoid: 120 }] }), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  try {
+    await resolveEllipsoidalGround([{ lat: 30.317, lon: -97.717 }]);
+  } finally {
+    globalThis.fetch = realFetch;
+  }
+  // A hangar roof over the cell's centre; the apron where the contact is.
+  assert.equal(reportValidatedMeshFloorCell(30.317, -97.717, 142), true);
+  assert.equal(reportValidatedMeshFloorCell(30.3173, -97.7173, 121), true);
+  const pos = Cesium.Cartesian3.fromDegrees(-97.7173, 30.3173, 100);
+  const out = _floorGroundedDisplayPositionForTest(
+    { onGround: true },
+    pos,
+    false,
+  );
+  const c = _floorCarto(out);
+  assert.ok(
+    Math.abs(c.height - (121 + GROUND_FLOOR_LIFT_M)) < 0.05,
+    `height ${c.height} should be the apron's 121 + lift`,
+  );
+  _clearMeshFloorCellsForTest();
+  _clearDisplayFloorStateForTest();
+});
+
 test('display floor: an AIRBORNE contact over the same cell is never lifted', () => {
   _clearDisplayFloorStateForTest();
   _clearMeshFloorCellsForTest();
diff --git a/src/layers/flights/motion.js b/src/layers/flights/motion.js
index a14c8c4ac..c09522153 100644
--- a/src/layers/flights/motion.js
+++ b/src/layers/flights/motion.js
@@ -37,6 +37,22 @@ import {
   DISPLAY_CORRIDOR_FAIR_SHARE,
 } from './policy.js';
 
+/** Half a coarse floor cell (0.001°), less a margin so rounding keeps a
+ *  clamped coordinate inside the cell. */
+const HALF_CELL_DEG = 0.00049;
+
+/**
+ * A coordinate held within half a cell of the cell's centre (the short way
+ * round for longitude), so a read lands in the given cell.
+ * @param {number} deg @param {number} centreDeg
+ * @returns {number}
+ */
+function clampToCell(deg, centreDeg) {
+  let d = deg - centreDeg;
+  d -= 360 * Math.round(d / 360);
+  return centreDeg + Math.max(-HALF_CELL_DEG, Math.min(HALF_CELL_DEG, d));
+}
+
 export function createMotion({
   flightState,
   services,
@@ -865,12 +881,15 @@ export function createMotion({
     );
     // Boundary hysteresis: a position jittering across a cell edge would flip
     // floors at fleet-tick rate (see stickyFloorCell).
-    const cell = stickyFloorCell(
-      Cesium.Math.toDegrees(carto.latitude),
-      Cesium.Math.toDegrees(carto.longitude),
-      state?.cell,
+    const latDeg = Cesium.Math.toDegrees(carto.latitude);
+    const lonDeg = Cesium.Math.toDegrees(carto.longitude);
+    const cell = stickyFloorCell(latDeg, lonDeg, state?.cell);
+    // A cell holds rendered-surface readings at the points they were taken,
+    // so the floor is read where the contact is, held inside its sticky cell.
+    const floor = cachedGroundFloor(
+      clampToCell(latDeg, cell.lat),
+      clampToCell(lonDeg, cell.lon),
     );
-    const floor = cachedGroundFloor(cell.lat, cell.lon);
     const next = state || {
       cell,
       in: new Cesium.Cartesian3(),
diff --git a/src/layers/transit/height.js b/src/layers/transit/height.js
index 2e2945a88..027dc7d41 100644
--- a/src/layers/transit/height.js
+++ b/src/layers/transit/height.js
@@ -124,7 +124,14 @@ export function createHeight({ state, services, parts }) {
       const cells = new Map();
       const collect = (point, answer) => {
         if (!onGround) return;
-        if (!cells.has(answer.cell))
+        // A cell keeps the last point offered in it: the path is walked
+        // oldest first, so that is where the vehicle is now or about to be,
+        // and the mesh sampler reads the surface there.
+        const held = cells.get(answer.cell);
+        if (held) {
+          held.lat = point.lat;
+          held.lon = point.lon;
+        } else
           cells.set(answer.cell, {
             lat: point.lat,
             lon: point.lon,
@@ -136,6 +143,13 @@ export function createHeight({ state, services, parts }) {
       const newest = entry.fixes.at(-1);
       const answer = requestHeight(newest.lat, newest.lon, entry);
       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.
+      const own = cells.get(answer.cell);
+      if (own) {
+        own.lat = newest.lat;
+        own.lon = newest.lon;
+      }
       if (answer.height !== null) {
         entry.heightM = answer.height;
         entry.heightResolved = true;
diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs
index e36d87de8..fee9a60ed 100644
--- a/src/layers/transit/lifecycle.test.mjs
+++ b/src/layers/transit/lifecycle.test.mjs
@@ -2938,6 +2938,114 @@ test('mesh refinement reaches all 100 retained DEM cells within five poll budget
   assert.equal(probed.size, 100);
 });
 
+test('mesh refinement probes the latest point the path offers in a cell', async (t) => {
+  const { createHeight } = await import('./height.js');
+  // Three points along one cell's stretch of path, oldest first.
+  const path = [
+    { lat: 42.3611, lon: -71.0751 },
+    { lat: 42.3612, lon: -71.0753 },
+    { lat: 42.3614, lon: -71.0754 },
+  ];
+  const entry = { key: 'train', to: path[0], fixes: [path.at(-1)] };
+  const probed = [];
+  const state = {
+    _enabled: true,
+    _selectedKey: null,
+    _visible: new Set([entry]),
+    _vehicles: new Map([[entry.key, entry]]),
+    _floorCursor: 0,
+    _heightDirty: new Set(),
+    _viewer: { camera: { positionCartographic: { height: 100 } } },
+  };
+  const height = createHeight({
+    state,
+    services: {
+      render: { governorRequestRender() {} },
+      ground: {
+        coarseFloorCoord: (lat, lon) => ({
+          lat: Number(lat.toFixed(3)),
+          lon: Number(lon.toFixed(3)),
+        }),
+        cachedGroundFloor: () => 10,
+        GROUND_FLOOR_LIFT_M: 1.5,
+      },
+      mesh: {
+        sampleMeshFloorCells(scene, points) {
+          probed.push(...points.map((p) => [p.lat, p.lon]));
+        },
+      },
+    },
+    parts: {
+      trails: {
+        prepareEntry(e, collect) {
+          if (collect)
+            for (const point of path)
+              collect(point, height.requestHeight(point.lat, point.lon));
+        },
+      },
+      rendering: { requestVisibility() {} },
+    },
+  });
+  t.after(() => height.clear());
+  height.anchorFloors();
+  assert.deepEqual(probed, [[42.3614, -71.0754]]);
+});
+
+test('the selected vehicle is probed at its newest fix in its own cell', async (t) => {
+  const { createHeight } = await import('./height.js');
+  // The selected path offers its active corridor first, then its history
+  // newest segment first, so the last offer in the cell is an older point.
+  const newest = { lat: 42.3614, lon: -71.0754 };
+  const offers = [
+    newest,
+    { lat: 42.3612, lon: -71.0753 },
+    { lat: 42.3611, lon: -71.0751 },
+  ];
+  const entry = { key: 'train', to: offers[0], fixes: [newest] };
+  const probed = [];
+  const state = {
+    _enabled: true,
+    _selectedKey: entry.key,
+    _visible: new Set([entry]),
+    _vehicles: new Map([[entry.key, entry]]),
+    _floorCursor: 0,
+    _heightDirty: new Set(),
+    _viewer: { camera: { positionCartographic: { height: 100 } } },
+  };
+  const height = createHeight({
+    state,
+    services: {
+      render: { governorRequestRender() {} },
+      ground: {
+        coarseFloorCoord: (lat, lon) => ({
+          lat: Number(lat.toFixed(3)),
+          lon: Number(lon.toFixed(3)),
+        }),
+        cachedGroundFloor: () => 10,
+        GROUND_FLOOR_LIFT_M: 1.5,
+      },
+      mesh: {
+        sampleMeshFloorCells(scene, points) {
+          probed.push(...points.map((p) => [p.lat, p.lon]));
+        },
+      },
+    },
+    parts: {
+      trails: {
+        prepareEntry(e, collect) {
+          if (collect)
+            for (const point of offers)
+              collect(point, height.requestHeight(point.lat, point.lon));
+        },
+      },
+      rendering: { requestVisibility() {} },
+    },
+  });
+  t.after(() => height.clear());
+  height.anchorFloors();
+  assert.deepEqual(probed, [[42.3614, -71.0754]]);
+});
+
 test('selection churn releases past geometry on every retained vehicle', async (t) => {
   const app = harness(t, { floorAt: () => 10 });
   const { mergeHistory, seek } = await import('../../data/contactPlayback.js');

From 09520bc34ce262ad208295fc9843146f6dce3330 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 9 Nov 2026 14:54:51 -0800
Subject: [PATCH 51/71] Changelog fragment for #1642

---
 changelog.d/1642-transit-floor-per-point.md | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 changelog.d/1642-transit-floor-per-point.md

diff --git a/changelog.d/1642-transit-floor-per-point.md b/changelog.d/1642-transit-floor-per-point.md
new file mode 100644
index 000000000..04dd59760
--- /dev/null
+++ b/changelog.d/1642-transit-floor-per-point.md
@@ -0,0 +1,7 @@
+- Keep buses and trains off rooftops and out of bridge decks on the photoreal
+  3D tiles: the ground floor probes the rendered mesh where each vehicle is,
+  keeps each reading at the point it was taken (up to sixteen a cell) and
+  answers from the reading nearest the vehicle, instead of one probe at each
+  110 m cell's centre that lifted every vehicle in the cell onto whatever lay
+  there. Transit probes each vehicle's latest point, and grounded flights read
+  the floor at their own position (Sameh Khamis, @samehkhamis, #1642).

From a7f96313e92105e96180d02bfdbf712d79816ff3 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 9 Nov 2026 16:56:59 -0800
Subject: [PATCH 52/71] feat(pointer): an application's own tool can take the
 pointer

createApplicationTools returns pointer: claim(owner) takes the pointer as
Draw does and returns its lease, or null while another tool holds it;
release(lease) gives it back; isFree() lets the application's own click
handlers yield, as the layers' do. This replaces drawShape, which this
branch added: Draw is as it was.
---
 CHANGELOG.md                               |   7 +-
 docs/CURRENT-STATE.md                      |   2 +-
 src/annotations/drawTool.js                |  66 +--------
 src/annotations/drawToolBehaviour.test.mjs | 152 ---------------------
 src/app/tools.js                           |  22 +--
 5 files changed, 18 insertions(+), 231 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7c425d0b6..f49dad02b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,10 +2,9 @@
 
 ## [Unreleased]
 
-- Applications can ask Draw for one area or line and get its geometry back
-  without placing a mark (`drawShape` from `createApplicationTools`), and their
-  own click handlers can yield while a tool holds the pointer, as the layers'
-  do (`pointerFree`) (samehkhamis, #1641).
+- An application's own tool can take the pointer as Draw does, and its click
+  handlers can yield while a tool holds it, as the layers' do (`pointer` from
+  `createApplicationTools`) (samehkhamis, #1641).
 
 ## [0.3.0] — 2026-10-27 — Street Level, On Your Phone, in Your Language
 
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index b70dc1d92..f8914f19f 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -6311,7 +6311,7 @@ request viewbox and continues searching without that geographic preference.
 - UTILITIES ▸ **Draw** turns the globe into a whiteboard drawn by hand. Pick a shape (icon buttons for Area, Line and Pin) and a colour swatch for the next shape, click the vertices on the real world, and finish. **Keyboard contract, live only while Draw is on and never while you are typing in another field:** Enter finishes the shape (as does a double-click, and the two cannot both submit it — the session is replaced before the annotate call is awaited); Backspace removes the last vertex; Esc cancels the shape in progress, and a second Esc — Esc on an empty session — leaves draw mode. **Clear** wipes the board (the shape in progress and every placed mark), so removing marks does not require the console or the microphone.
 - **Drawn shapes are listed under Draw like Import's files** (`src/ui/views/panels/DrawMarkList.vue`, rows worded by `presentDrawMarks` in `src/annotations/drawMarks.js`): one row per hand-drawn mark (`manual: true`; voice marks are not listed) with its colour swatch, its name, and show/hide, fly-to and remove. The draw tool publishes the rows with the rest of its controls and answers the row actions (`renameDrawMark`, `recolorDrawMark`, `toggleDrawMark`, `flyToDrawMark`, `removeDrawMark`) through the display store; it republishes on the engine's `onChange`, so a voice clear or an expiry updates the list. Rows are keyed and updated in place: a board change never takes a name being typed (the field keeps its draft while focused) or the button under a click. The name is saved on Enter or on leaving the field, once; Esc restores it, before anything else and with the row's colours open too. Both keep focus in the field, so neither drops it to the page or leaves Draw. The swatch opens the five colours right after it (shown at the end of the row), with the current colour focused; the arrows, Home and End try another, and a click or Esc closes them and returns focus to the swatch. Both colour groups (the next shape's and a row's) are one `DrawSwatches` radio group with a single tab stop, coloured from `DRAW_COLOR_CSS`; on touch screens each dot answers a 24 px target. An unnamed shape shows its kind, and an unnamed line its length; a renamed line keeps its length (`Ridge walk — 950 m`). **Hidden** keeps a mark on the board at alpha 0, and the world renderer takes every one of its entities out (`show = false`), so no material that keeps its own colour (the line's flowing stroke) still paints it; the screen renderer does not project a hidden callout, so it cannot push a visible label aside; `fly_route` skips a hidden route; and with every mark hidden the annotations render hold is released. **Fly to** is an immediate navigation (`runImmediateNavigation('drawing', …)`), like Import's: Cockpit refuses it and a running orbit, follow or track lets go first. A line is framed by its whole path, across the antimeridian too.
 - Runtime entry: `createApplicationTools` (`src/app/tools.js`, behind the `src/standalone/tools.js` shim) calls `initDrawTool({ viewer, annotations, navigation, publish, connect, markActions })` after `initAnnotations` and defers its `destroy()`, so disposing the shell returns every DOM listener, the Cesium handler, the preview data source, the borrowed click actions and the `window.__gevDrawTool` handle. Its controls are Vue views in the UTILITIES panel (`DrawControls.vue`, `DrawMarkList.vue`) that render what the tool publishes to the display store and call its actions. That handle (`setActive`, `setShape`, `addVertex(lon, lat)`, `finish`, `cancel`, `clearAll`, `marks`, `setColor`, `diagnostics`) is the no-mouse test seam.
-- **One shape, handed back.** `createApplicationTools` also returns `drawShape({ shape, signal })` (`drawTool.drawShape`): it opens draw mode for one `area` or `line` and resolves with its geometry, a closed `[lon, lat]` `Polygon` or a `LineString`, without placing a mark; the shape chosen before comes back and draw mode ends. While it is open the controls cannot change the shape, and one across the antimeridian is refused as a row's actions refuse it ("That shape could not be placed.") and drawn again. It resolves `null` when the drawing is cancelled (the second Escape), draw mode is left, `signal` aborts, another request replaces it, the pointer is held elsewhere, the tool is destroyed, or the page has no Draw controls. It returns `pointerFree` (`data/inputOwnership.js` `isPointerFree`) too, so an application's own click handlers yield to the tool holding the pointer, as the layers' do.
+- **The pointer, for an application's own tool.** `createApplicationTools` also returns `pointer` (`data/inputOwnership.js`): `claim(owner)` takes the pointer as Draw does and returns its lease, or `null` while another tool holds it; `release(lease)` gives it back; `isFree()` lets the application's own click handlers yield, as the layers' do. An owner without a name in `pointerOwnerNames.js` is named by its id when another tool reports who holds the pointer.
 - **Row actions are an application's own.** `createApplicationTools({ drawMarkActions })` hands `initDrawTool` buttons for drawn areas' and lines' rows; the standalone shell passes none, so the open-source build shows no new button and makes no new request. Each action (`drawMarkActions` in `src/annotations/drawMarks.js`) is `{ id, icon, label(name), shapes: ['area', 'line'], accepts?(geometry, shape), run({ id, shape, name, title, geometry }) }`: the icon a Material Symbols name, the label worded by the application, `name` the person's own and `title` the row's (the name, else `Area` or `Line · 950 m`), the geometry `drawMarkGeometry`'s `[lon, lat]` `Polygon` (closed; a `MultiPolygon` for an area handle with several parts) or `LineString`, longitudes wrapped into [-180, 180]. A pin, and a shape that crosses the antimeridian or has a part that cannot be given whole, has no geometry and is offered nothing. Malformed actions and repeated ids are dropped once, at construction. What `run` returns or resolves to is a note under the row (`role=status`; past 200 characters it is cut at a word with an ellipsis); the row is busy (`aria-disabled`, no second press) until it settles, a rejection or a throw clears the note and is logged (so an action words its own refusals and resolves with them), and a shape's note goes with the shape, so a late answer never lands on a removed one.
 - Contract: a finished shape is submitted through the SAME `annotationEngine.annotate()` the voice agent uses, with geometry supplied and `manual: true` (`type: area` + `ring`, `type: route` + `path`, `type: pin` + coordinates). `resolveSpec` short-circuits manual specs (`resolveManualSpec`) so no geocoder, Places or Overpass call is made. A drawn area is a real (not synthesized) outline and drapes solid; a drawn line is a `route` with `mode: 'manual'`, labelled with its length and never a travel time; a pin is a point. Drawn marks therefore render with the whiteboard look, persist, appear in `.list()`, and clear with `clear_annotations` / `.clear()`. A drawn shape is never merged with another as a duplicate: every one is drawn on purpose, and every one is unnamed until its row names it, so two pins dropped close together are two pins.
 - **A vertex is a lon/lat, and the mark is DRAPED.** Clicks are picked through `pickWorldFromScreen` — one of two scene helpers the annotation resolver factory (`src/annotations/resolver.js`) exposes alongside `sampleGroundHeight`, so the app has ONE depth-aware pick cascade rather than a second written beside it — which returns the height the pick landed on as well as the coordinate, so the live preview hangs on the roof or hillside under the pointer instead of sinking to sea level. The world renderer draws areas and routes with `clampToGround`, so the height is dropped at finish in one place (`finishSpec`) rather than being carried downstream and discarded silently: what you get is the outline you drew, lying on the surface beneath it.
diff --git a/src/annotations/drawTool.js b/src/annotations/drawTool.js
index 14a5929eb..f44d30753 100644
--- a/src/annotations/drawTool.js
+++ b/src/annotations/drawTool.js
@@ -54,7 +54,6 @@ import {
   DRAW_COLORS,
   DRAW_COLOR_CSS,
   drawMarkActions,
-  drawMarkGeometry,
   drawMarkActionsFor,
   drawMarkFallbackName,
   presentDrawMarks,
@@ -121,9 +120,6 @@ export function initDrawTool({
   let savedDoubleClick = null;
   let savedSingleClick = null;
   let cursor = null; // last mouse position on the canvas, for the rubber band
-  // One shape asked for by `drawShape`: `{ resolve, restoreShape, off }`. Its
-  // finish hands the geometry back instead of placing a mark.
-  let request = null;
   // Bumped by anything that supersedes an in-flight finish: cancelling, clearing
   // the board, leaving draw mode, teardown. An `annotate()` that resolves after
   // one of those must not write its outcome over the newer state.
@@ -284,20 +280,6 @@ export function initDrawTool({
     // Named afterwards, in the shape's row.
     const spec = finishSpec(session, { label: '', color });
     if (!spec) return null;
-    if (request) {
-      // As a row's actions get it: a shape across the antimeridian has none,
-      // and is drawn again rather than handed back wrapped round the world.
-      const geometry = drawMarkGeometry(spec);
-      if (!geometry) {
-        session = createDrawSession(shape);
-        cursor = null;
-        syncPreview();
-        setHint(() => t('That shape could not be placed.'));
-        return null;
-      }
-      endRequest(geometry);
-      return geometry;
-    }
     // Start a fresh session BEFORE awaiting, so a second Enter or the second
     // half of a double-click cannot submit the same shape twice.
     session = createDrawSession(shape);
@@ -425,7 +407,6 @@ export function initDrawTool({
       generation += 1;
       session = null;
       cursor = null;
-      endRequest(null);
       releaseSceneHandler();
       releasePointer(lease);
       lease = null;
@@ -551,46 +532,6 @@ export function initDrawTool({
     return true;
   }
 
-  /**
-   * Close the asked-for shape with `geometry` (null when there is none): the
-   * shape chosen before it comes back, and draw mode ends.
-   */
-  function endRequest(geometry) {
-    const open = request;
-    if (!open) return;
-    request = null;
-    open.off();
-    chooseShape(open.restoreShape);
-    open.resolve(geometry);
-    if (active) setActive(false);
-  }
-
-  /**
-   * Draw one area or line and hand back its geometry (a Polygon or a
-   * LineString) without placing a mark. Escape works as in Draw: the first
-   * clears a shape in progress, and one on an empty shape leaves. Resolves null
-   * when draw mode is left, `signal` aborts, or the pointer is taken.
-   * A second request ends the first with null.
-   * @param {{shape?: 'area'|'line', signal?: AbortSignal}} [options]
-   * @returns {Promise<{type: 'Polygon', coordinates: number[][][]}|{type: 'LineString', coordinates: number[][]}|null>}
-   */
-  function drawShape({ shape: wanted = 'area', signal } = {}) {
-    if (destroyed || signal?.aborted) return Promise.resolve(null);
-    endRequest(null);
-    const restoreShape = shape;
-    return new Promise((resolve) => {
-      const abort = () => endRequest(null);
-      signal?.addEventListener('abort', abort, { once: true });
-      request = {
-        resolve,
-        restoreShape,
-        off: () => signal?.removeEventListener('abort', abort),
-      };
-      chooseShape(normalizeShape(wanted) === 'line' ? 'line' : 'area');
-      if (!active && !setActive(true)) endRequest(null);
-    });
-  }
-
   /** Draw `next` from now on; an open shape starts over in it. */
   function chooseShape(next) {
     shape = normalizeShape(next);
@@ -604,10 +545,7 @@ export function initDrawTool({
   }
   const disconnect = connect({
     toggleDraw: () => setActive(!active),
-    // An asked-for shape is the one asked for.
-    setDrawShape: (next) => {
-      if (!request) chooseShape(next);
-    },
+    setDrawShape: chooseShape,
     setDrawColor: (value) => {
       color = DRAW_COLORS.includes(value) ? value : 'primary';
       present();
@@ -664,7 +602,6 @@ export function initDrawTool({
     finish,
     cancel,
     clearAll,
-    drawShape,
     shapes: DRAW_SHAPES,
     /** What this tool currently holds — for teardown and leak assertions. */
     diagnostics() {
@@ -701,7 +638,6 @@ export function initDrawTool({
       if (destroyed) return attaching;
       // Supersede any finish still in flight before anything is torn down.
       generation += 1;
-      endRequest(null);
       if (active) setActive(false);
       destroyed = true;
       offLocale();
diff --git a/src/annotations/drawToolBehaviour.test.mjs b/src/annotations/drawToolBehaviour.test.mjs
index 276852248..4cef4d4fe 100644
--- a/src/annotations/drawToolBehaviour.test.mjs
+++ b/src/annotations/drawToolBehaviour.test.mjs
@@ -704,158 +704,6 @@ test('what a row action answers is its row\'s note; the row is busy until then,
   }
 });
 
-test('drawShape hands back the drawn area as a polygon and places no mark', async () => {
-  const h = harness();
-  try {
-    h.act('setDrawShape', 'line');
-    const drawn = h.tool.drawShape({ shape: 'area' });
-    assert.equal(h.tool.active, true, 'it opens draw mode');
-    assert.equal(h.tool.shape, 'area');
-    h.tool.addVertex(-97.75, 30.26);
-    h.tool.addVertex(-97.74, 30.26);
-    h.tool.addVertex(-97.74, 30.27);
-    h.documentDouble.emit('keydown', {
-      key: 'Enter',
-      target: h.documentDouble.body,
-    });
-    const geometry = await drawn;
-    assert.deepEqual(geometry, {
-      type: 'Polygon',
-      coordinates: [
-        [
-          [-97.75, 30.26],
-          [-97.74, 30.26],
-          [-97.74, 30.27],
-          [-97.75, 30.26],
-        ],
-      ],
-    });
-    assert.equal(h.annotations.calls.annotate.length, 0, 'no mark is placed');
-    assert.equal(h.tool.active, false, 'draw mode ends');
-    assert.equal(isPointerFree(), true);
-    assert.equal(h.tool.shape, 'line', 'the shape chosen before comes back');
-  } finally {
-    h.restore();
-  }
-});
-
-test('drawShape hands back a line as a LineString', async () => {
-  const h = harness();
-  try {
-    const drawn = h.tool.drawShape({ shape: 'line' });
-    h.tool.addVertex(-97.75, 30.26);
-    h.tool.addVertex(-97.74, 30.26);
-    h.documentDouble.emit('keydown', {
-      key: 'Enter',
-      target: h.documentDouble.body,
-    });
-    assert.deepEqual(await drawn, {
-      type: 'LineString',
-      coordinates: [
-        [-97.75, 30.26],
-        [-97.74, 30.26],
-      ],
-    });
-  } finally {
-    h.restore();
-  }
-});
-
-test('drawShape resolves null on Escape, on abort, on a newer request and when the pointer is taken', async () => {
-  const h = harness();
-  try {
-    // Escape with a shape started clears it; a second Escape leaves.
-    const escaped = h.tool.drawShape({ shape: 'area' });
-    h.tool.addVertex(-97.75, 30.26);
-    h.documentDouble.emit('keydown', {
-      key: 'Escape',
-      target: h.documentDouble.body,
-    });
-    assert.equal(h.tool.active, true, 'the first Escape only clears the shape');
-    h.documentDouble.emit('keydown', {
-      key: 'Escape',
-      target: h.documentDouble.body,
-    });
-    assert.equal(await escaped, null);
-    assert.equal(h.tool.active, false);
-
-    const controller = new AbortController();
-    const aborted = h.tool.drawShape({
-      shape: 'area',
-      signal: controller.signal,
-    });
-    controller.abort();
-    assert.equal(await aborted, null);
-    assert.equal(isPointerFree(), true, 'an abort gives the pointer back');
-
-    const first = h.tool.drawShape({ shape: 'area' });
-    const second = h.tool.drawShape({ shape: 'line' });
-    assert.equal(await first, null, 'a newer request ends the older one');
-    h.act('toggleDraw');
-    assert.equal(await second, null, 'leaving draw mode ends it');
-
-    const done = new AbortController();
-    done.abort();
-    assert.equal(await h.tool.drawShape({ signal: done.signal }), null);
-
-    const other = claimPointer('directions');
-    assert.equal(
-      await h.tool.drawShape({ shape: 'area' }),
-      null,
-      'a held pointer refuses it',
-    );
-    releasePointer(other);
-
-    // Drawing by hand afterwards places marks as before.
-    h.act('toggleDraw');
-    h.tool.addVertex(-97.75, 30.26);
-    h.tool.addVertex(-97.74, 30.26);
-    h.tool.addVertex(-97.74, 30.27);
-    h.documentDouble.emit('keydown', {
-      key: 'Enter',
-      target: h.documentDouble.body,
-    });
-    await Promise.resolve();
-    assert.equal(h.annotations.calls.annotate.length, 1);
-  } finally {
-    h.restore();
-  }
-});
-
-test('drawShape keeps its shape, and a shape across the antimeridian is drawn again', async () => {
-  const h = harness();
-  try {
-    const drawn = h.tool.drawShape({ shape: 'line' });
-    h.act('setDrawShape', 'pin');
-    assert.equal(h.tool.shape, 'line', 'the controls cannot change the asked-for shape');
-    h.tool.addVertex(179.5, 10);
-    h.tool.addVertex(-179.5, 10);
-    h.documentDouble.emit('keydown', { key: 'Enter', target: h.documentDouble.body });
-    assert.equal(h.tool.active, true, 'still drawing');
-    assert.equal(h.tool.session.vertices.length, 0, 'drawn again from the start');
-    assert.equal(h.shown.view.hint, 'That shape could not be placed.');
-    h.tool.addVertex(29, 41);
-    h.tool.addVertex(29.1, 41);
-    h.documentDouble.emit('keydown', { key: 'Enter', target: h.documentDouble.body });
-    assert.equal((await drawn).type, 'LineString');
-    h.act('setDrawShape', 'pin');
-    assert.equal(h.tool.shape, 'pin', 'after it, the controls choose again');
-  } finally {
-    h.restore();
-  }
-});
-
-test('destroy ends a drawShape request with null', async () => {
-  const h = harness();
-  try {
-    const drawn = h.tool.drawShape({ shape: 'area' });
-    h.tool.destroy();
-    assert.equal(await drawn, null);
-  } finally {
-    h.restore();
-  }
-});
-
 test('Backspace on the page removes the last vertex', () => {
   const h = harness();
   try {
diff --git a/src/app/tools.js b/src/app/tools.js
index 9ecb3559a..9da848c78 100644
--- a/src/app/tools.js
+++ b/src/app/tools.js
@@ -1,7 +1,11 @@
 import { SceneDirector } from '../scenes/director.js';
 import { initAnnotations } from '../annotations/index.js';
 import { initDrawTool } from '../annotations/drawTool.js';
-import { isPointerFree } from '../data/inputOwnership.js';
+import {
+  claimPointer,
+  isPointerFree,
+  releasePointer,
+} from '../data/inputOwnership.js';
 import { initGeoFileImport } from '../ui/geoFileImport.js';
 import { useDisplayStore } from '../ui/stores/display.js';
 import { applicationPinia } from '../ui/vueRuntime.js';
@@ -246,17 +250,17 @@ export function createApplicationTools({
       signal,
     }),
   );
-  // Draw one area or line and get its geometry back, without placing a mark
-  // (annotations/drawTool.js `drawShape`); null without the Draw controls.
-  const drawShape = (options) =>
-    drawTool ? drawTool.drawShape(options) : Promise.resolve(null);
-  // An application's own click handlers yield while a tool holds the pointer,
-  // as the layers' do (data/inputOwnership.js).
+  // An application's own tool takes the pointer as Draw does, and its own
+  // click handlers yield while a tool holds it, as the layers' do
+  // (data/inputOwnership.js).
   return {
     sceneDirector,
     annotations,
     voiceCommands,
-    drawShape,
-    pointerFree: isPointerFree,
+    pointer: {
+      claim: claimPointer,
+      release: releasePointer,
+      isFree: isPointerFree,
+    },
   };
 }

From 4dc51927bc55e88a9a09bd442c8c18fac3d072af Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 9 Nov 2026 18:04:16 -0800
Subject: [PATCH 53/71] perf(traffic): build road lines one set at a time

With Lines on, every progressive paint of a loading city rebuilt all road
lines: up to three ground-line primitives for as many as 1,500 roads, built
asynchronously. Builds started faster than they finished, and each kept the
set it replaced in the scene until it was ready, so sets piled up.

One set now builds at a time. A rebuild asked for while lines are building
replaces the one waiting, and the newest starts when the build finishes.
Lines replaced by a finished build are removed before the next one starts.
Turning Lines off removes the lines at once and drops the waiting rebuild.
---
 docs/CURRENT-STATE.md                   |   2 +-
 scripts/format-scope.json               |   1 +
 src/layers/traffic/lineRebuild.test.mjs | 219 ++++++++++++++++++++++++
 src/layers/traffic/rendering.js         |  52 ++++--
 src/layers/traffic/state.js             |   4 +
 5 files changed, 264 insertions(+), 14 deletions(-)
 create mode 100644 src/layers/traffic/lineRebuild.test.mjs

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 91b7a56a4..03d4efc94 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -134,7 +134,7 @@ existing batch size and one bounded upstream chunk. Larger requests return HTTP
 413 before disk-cache loading or upstream work; malformed coordinates remain 400.
 The browser continues to split larger workloads into sequential 64-point requests.
 
-Traffic holds continuous rendering only while enabled with shown animated dots, a pulsing jam heat-line, or road lines whose geometry is still building (replaced lines stay drawn until their successors are ready, so a rebuild never blinks); hidden dots (`dots` off) and settled flow lines hold nothing. Empty and high-altitude views release the hold. A failed load leaves no hold only when no animated content is retained: if an earlier load succeeded, ingestion keeps its animated points and the hold stays. Population admission reacquires the hold and resets animation time. Clear, disable, and destroy also release it. Retained fading dots keep animation alive until they are removed. When the last point leaves mid height correction, the correction is settled at once, before the hold is released, so it cannot keep the layer reporting loading.
+Traffic holds continuous rendering only while enabled with shown animated dots, a pulsing jam heat-line, or road lines whose geometry is still building (replaced lines stay drawn until their successors are ready, so a rebuild never blinks; one set builds at a time, and of the rebuilds asked for meanwhile only the newest runs, when that build finishes; turning lines off removes them at once); hidden dots (`dots` off) and settled flow lines hold nothing. Empty and high-altitude views release the hold. A failed load leaves no hold only when no animated content is retained: if an earlier load succeeded, ingestion keeps its animated points and the hold stays. Population admission reacquires the hold and resets animation time. Clear, disable, and destroy also release it. Retained fading dots keep animation alive until they are removed. When the last point leaves mid height correction, the correction is settled at once, before the hold is released, so it cannot keep the layer reporting loading.
 
 Shared distance checks use `src/geoDistance.js` with `{ lat, lon }` points and
 the IUGG mean spherical Earth radius, 6371.0088 km. `greatCircleKm` is
diff --git a/scripts/format-scope.json b/scripts/format-scope.json
index 7dbd9d2b7..c82c5ebb3 100644
--- a/scripts/format-scope.json
+++ b/scripts/format-scope.json
@@ -1077,6 +1077,7 @@
   "src/layers/traffic/roadModes.test.mjs",
   "scripts/qa-traffic-motion.mjs",
   "src/layers/traffic/motion.test.mjs",
+  "src/layers/traffic/lineRebuild.test.mjs",
   "scripts/qa-journey-recorder.mjs",
   "scripts/qa-alpr-journey.mjs",
   "scripts/qa-context-arrivals.mjs",
diff --git a/src/layers/traffic/lineRebuild.test.mjs b/src/layers/traffic/lineRebuild.test.mjs
new file mode 100644
index 000000000..b4533b63d
--- /dev/null
+++ b/src/layers/traffic/lineRebuild.test.mjs
@@ -0,0 +1,219 @@
+// Street Traffic road lines build one set at a time: rebuilds asked for while
+// a set is building wait, and only the newest of them runs.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createRendering } from './rendering.js';
+
+// Cesium tests a material's uniforms against these browser classes.
+for (const name of [
+  'HTMLCanvasElement',
+  'HTMLImageElement',
+  'ImageBitmap',
+  'OffscreenCanvas',
+])
+  globalThis[name] ??= class {};
+// A line primitive's render state is checked against the context's limits,
+// which only a WebGL context sets.
+Cesium.ContextLimits._minimumAliasedLineWidth = 1;
+Cesium.ContextLimits._maximumAliasedLineWidth = 1;
+
+/** A road with flow; `level` picks its bucket (0.1 jam, 0.6 slow, 1 free). */
+function road(level = 1) {
+  return {
+    flow: { level, closure: false },
+    segmentDist: [100],
+    waypoints: Cesium.Cartesian3.fromDegreesArray([
+      -97.744, 30.267, -97.742, 30.267,
+    ]),
+  };
+}
+
+/**
+ * Rendering over a scene that records its ground primitives. Each added
+ * primitive is replaced by a stand-in whose `ready` the test sets, as Cesium
+ * sets it once the asynchronous geometry is built.
+ */
+function harness() {
+  const scene = [];
+  const added = [];
+  let linesOn = true;
+  const state = {
+    _viewer: {
+      scene: {
+        globe: { show: true },
+        groundPrimitives: {
+          add(primitive) {
+            const line = {
+              ready: false,
+              roads: primitive.geometryInstances.length,
+            };
+            scene.push(line);
+            added.push(line);
+            return line;
+          },
+          remove(line) {
+            const index = scene.indexOf(line);
+            if (index >= 0) scene.splice(index, 1);
+          },
+        },
+      },
+    },
+    _liveMode: true,
+    _showLines: true,
+    _heatSupported: true,
+    _heatJamPrim: null,
+    _heatSlowPrim: null,
+    _heatFreePrim: null,
+    _heatRetired: [],
+    _heatPendingRoads: null,
+    _heatLineCount: 0,
+  };
+  const rendering = createRendering({
+    state,
+    services: {},
+    source: {},
+    parts: {
+      style: { heatlineOn: () => linesOn },
+      animation: { syncRenderDemand() {} },
+    },
+  });
+  return {
+    state,
+    rendering,
+    scene,
+    added,
+    setLines(on) {
+      linesOn = on;
+      state._showLines = on;
+    },
+    /** Finish every build in the scene, then run a frame. */
+    frame({ built = true } = {}) {
+      if (built) for (const line of scene) line.ready = true;
+      rendering.retireHeatLines();
+    },
+  };
+}
+
+const roads = (count) => Array.from({ length: count }, () => road());
+
+test('rebuilds asked for while lines build do not start more builds', () => {
+  const { rendering, scene, added, frame } = harness();
+  rendering.rebuildHeatLines(roads(1));
+  assert.equal(added.length, 1);
+  // Progressive paints while the first set builds.
+  for (const count of [2, 3, 4]) rendering.rebuildHeatLines(roads(count));
+  frame({ built: false });
+  assert.equal(added.length, 1, 'no build started during a build');
+  assert.equal(scene.length, 1);
+  assert.deepEqual(scene[0].roads, 1);
+});
+
+test('the newest rebuild asked for during a build is the one that runs', () => {
+  const { state, rendering, scene, added, frame } = harness();
+  rendering.rebuildHeatLines(roads(1));
+  for (const count of [2, 3, 4]) rendering.rebuildHeatLines(roads(count));
+  frame();
+  // One build for the three requests, of the last one's roads.
+  assert.deepEqual(
+    added.map((line) => line.roads),
+    [1, 4],
+  );
+  assert.equal(state._heatLineCount, 4);
+  assert.equal(state._heatPendingRoads, null);
+  // The set it replaces stays drawn while it builds, then goes.
+  assert.deepEqual(
+    scene.map((line) => line.roads),
+    [1, 4],
+  );
+  frame();
+  assert.deepEqual(
+    scene.map((line) => line.roads),
+    [4],
+  );
+  // Nothing is waiting, so later frames start nothing.
+  frame();
+  assert.equal(added.length, 2);
+});
+
+test('a rebuild with nothing building starts at once', () => {
+  const { rendering, added, frame } = harness();
+  rendering.rebuildHeatLines(roads(1));
+  frame();
+  rendering.rebuildHeatLines(roads(2));
+  assert.deepEqual(
+    added.map((line) => line.roads),
+    [1, 2],
+  );
+});
+
+test('turning lines off during a build removes them at once and drops the waiting rebuild', () => {
+  const { state, rendering, scene, added, setLines, frame } = harness();
+  rendering.rebuildHeatLines(roads(1));
+  frame();
+  rendering.rebuildHeatLines(roads(2));
+  rendering.rebuildHeatLines(roads(3));
+  assert.equal(scene.length, 2, 'the drawn set and the building one');
+  setLines(false);
+  rendering.rebuildHeatLines(roads(3));
+  assert.deepEqual(scene, [], 'not deferred behind the build');
+  assert.equal(state._heatPendingRoads, null);
+  assert.equal(state._heatLineCount, 0);
+  frame();
+  assert.equal(added.length, 2, 'the waiting rebuild never runs');
+  assert.deepEqual(scene, []);
+});
+
+test('a rebuild right after a build finishes does not keep the lines that build replaced', () => {
+  const { rendering, scene } = harness();
+  rendering.rebuildHeatLines(roads(1));
+  for (const line of scene) line.ready = true;
+  rendering.rebuildHeatLines(roads(2));
+  // The second build finishes, and a third is asked for before a frame ran.
+  for (const line of scene) line.ready = true;
+  rendering.rebuildHeatLines(roads(3));
+  assert.deepEqual(
+    scene.map((line) => line.roads),
+    [2, 3],
+  );
+});
+
+test('removing the lines drops the waiting rebuild', () => {
+  const { state, rendering, scene, added, frame } = harness();
+  rendering.rebuildHeatLines(roads(1));
+  rendering.rebuildHeatLines(roads(2));
+  rendering.removeHeatLines();
+  assert.deepEqual(scene, []);
+  assert.equal(state._heatPendingRoads, null);
+  frame();
+  assert.equal(added.length, 1);
+});
+
+test('a stream of rebuilds never leaves more than two sets in the scene, and ends with one', () => {
+  const { rendering, scene, added, frame } = harness();
+  let most = 0;
+  const lines = [road(0.1), road(0.6), road(1)];
+  // Three primitives per set: one per flow bucket.
+  for (let paint = 0; paint < 40; paint += 1) {
+    rendering.rebuildHeatLines(lines);
+    most = Math.max(most, scene.length);
+    // A build takes several paints.
+    if (paint % 5 === 4) frame();
+    else frame({ built: false });
+    most = Math.max(most, scene.length);
+  }
+  frame();
+  frame();
+  assert.equal(most <= 6, true, `${most} primitives at once`);
+  assert.equal(scene.length, 3, 'only the current set remains');
+  assert.equal(
+    scene.every((line) => line.ready),
+    true,
+  );
+  // Without coalescing every paint builds: 40 sets, 120 primitives.
+  assert.equal(
+    added.length <= 3 * 10,
+    true,
+    `${added.length} primitives built`,
+  );
+});
diff --git a/src/layers/traffic/rendering.js b/src/layers/traffic/rendering.js
index 402cd08b6..49f5af8e9 100644
--- a/src/layers/traffic/rendering.js
+++ b/src/layers/traffic/rendering.js
@@ -59,24 +59,37 @@ export function createRendering({
   /** Remove the heat-line / flow-line ground primitives from the scene. */
 
   function removeHeatLines() {
+    layerState._heatPendingRoads = null;
     removePrimitives(takeHeatLines());
     removePrimitives(layerState._heatRetired || []);
     layerState._heatRetired = [];
     parts.animation.syncRenderDemand?.();
   }
 
+  /** @returns {boolean} Whether a line primitive's geometry is still building. */
+
+  function linesBuilding() {
+    return LINE_KEYS.some((key) => layerState[key] && !layerState[key].ready);
+  }
+
   /**
    * Replaced lines stay drawn until their successors finish building
    * (GroundPolylinePrimitive geometry is asynchronous), so a rebuild never
-   * blinks. Called every held frame.
+   * blinks. Once they have, the replaced lines go and the newest rebuild
+   * asked for in the meantime starts. Called every held frame.
    */
 
   function retireHeatLines() {
-    if (!layerState._heatRetired?.length) return;
-    if (LINE_KEYS.some((key) => layerState[key] && !layerState[key].ready))
-      return;
-    removePrimitives(layerState._heatRetired);
-    layerState._heatRetired = [];
+    if (linesBuilding()) return;
+    if (layerState._heatRetired?.length) {
+      removePrimitives(layerState._heatRetired);
+      layerState._heatRetired = [];
+    }
+    const pending = layerState._heatPendingRoads;
+    if (pending) {
+      layerState._heatPendingRoads = null;
+      rebuildHeatLines(pending);
+    }
   }
 
   /**
@@ -95,24 +108,37 @@ export function createRendering({
    * the globe is hidden (photoreal) and on terrain or tiles otherwise. No-op in
    * sim mode, when both looks are off, or without ground-primitive support.
    *
+   * One build runs at a time. A city loads in progressive paints, each asking
+   * for a rebuild, and every build drapes up to the cap of polylines
+   * asynchronously. A rebuild asked for while lines are building only replaces
+   * the one waiting, which retireHeatLines starts when the build finishes, so
+   * the scene never holds more than the lines drawn and the lines building.
+   * Turning the lines off is never deferred.
+   *
    * @param {Array} roads - Road objects visible in the current render.
    */
 
   function rebuildHeatLines(roads) {
+    const wanted =
+      layerState._viewer && layerState._liveMode && parts.style.heatlineOn();
+    if (wanted && linesBuilding()) {
+      layerState._heatPendingRoads = roads;
+      return;
+    }
+    layerState._heatPendingRoads = null;
+    // No build is left for replaced lines to wait for (it finished, or lines
+    // are going off), so they go first and never pile up behind this rebuild.
+    removePrimitives(layerState._heatRetired || []);
+    layerState._heatRetired = [];
     const previous = takeHeatLines();
     const finish = () => {
-      // Nothing new to wait for: the old lines go now.
       if (LINE_KEYS.some((key) => layerState[key]))
         (layerState._heatRetired ||= []).push(...previous);
+      // Nothing new to wait for: the old lines go now.
       else removePrimitives(previous);
       parts.animation.syncRenderDemand?.();
     };
-    if (
-      !layerState._viewer ||
-      !layerState._liveMode ||
-      !parts.style.heatlineOn()
-    )
-      return finish();
+    if (!wanted) return finish();
     if (layerState._heatSupported === null) {
       layerState._heatSupported = Cesium.GroundPolylinePrimitive.isSupported(
         layerState._viewer.scene,
diff --git a/src/layers/traffic/state.js b/src/layers/traffic/state.js
index 8c2fd9f94..e82cd6191 100644
--- a/src/layers/traffic/state.js
+++ b/src/layers/traffic/state.js
@@ -200,6 +200,10 @@ export function createState({ services, source }) {
 
   layerState._heatRetired = [];
 
+  /** @type {Array|null} Roads of the newest rebuild asked for while the lines were building. */
+
+  layerState._heatPendingRoads = null;
+
   /** @type {number} Heat-lines in the current render (stats). */
 
   layerState._heatLineCount = 0;

From b996e35b0ce86dd62f16d7547a2e0c57c2f5fa64 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 9 Nov 2026 20:31:53 -0800
Subject: [PATCH 54/71] docs(changelog): traffic lines build one set at a time

---
 changelog.d/1645-traffic-lines-one-build.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1645-traffic-lines-one-build.md

diff --git a/changelog.d/1645-traffic-lines-one-build.md b/changelog.d/1645-traffic-lines-one-build.md
new file mode 100644
index 000000000..da1d00be2
--- /dev/null
+++ b/changelog.d/1645-traffic-lines-one-build.md
@@ -0,0 +1,3 @@
+- Street Traffic Lines build one set at a time while a city loads, instead of
+  one per paint, so panning with Lines on no longer piles up line builds
+  (Sameh Khamis, @samehkhamis, #1645).

From 1a8defbfc880a53597410f61679a156cbbfe8b9e Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 9 Nov 2026 20:36:03 -0800
Subject: [PATCH 55/71] feat(flights): show the tracked aircraft's
 Planespotters photo in Contacts

Tracking a civil flight asks Planespotters for that aircraft's photo, once
per aircraft, straight from the browser. The CONTEXT panel's CONTACTS view
shows it under the flight's name with the photographer's credit, as a plain
link to the photo's page. Only images on plnspttrs.net and pages on
www.planespotters.net are ever shown or linked. Military aircraft and a
converted TR-3B are never looked up.

Flight lookups (type, route, photo) whose source failed temporarily are
asked again after a 60-second cool-down; 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.

Browser QA scripts that track a flight answer the photo lookup themselves,
so they never call the third party.
---
 DATA_SOURCES.md                        |   6 +-
 docs/CODE-BOUNDARIES.md                |   3 +
 docs/CURRENT-STATE.md                  |  11 +
 package.json                           |   1 +
 scripts/package-boundaries.json        |  20 +-
 scripts/qa-cockpit-utility.mjs         |   3 +
 scripts/qa-context-arrivals.mjs        |   2 +
 scripts/qa-emergency-squawk.mjs        |   2 +
 scripts/qa-focus-evidence.mjs          |   2 +
 scripts/qa-heading-b3.mjs              |   2 +
 scripts/qa-photo-stub.mjs              |  78 ++++++
 scripts/qa-sprites-b5.mjs              |   2 +
 scripts/track-regression.mjs           |   3 +
 src/data/dataCredits.js                |   7 +
 src/data/dataCredits.test.mjs          |   7 +
 src/data/flights.js                    |   2 +
 src/data/flights.test.mjs              | 260 +++++++++++++++++-
 src/data/militaryAwareness.test.mjs    |  88 +++++-
 src/data/planespottersPhoto.js         | 121 +++++++++
 src/data/planespottersPhoto.test.mjs   | 200 ++++++++++++++
 src/i18n/locales/ar.json               |   3 +-
 src/i18n/locales/de.json               |   3 +-
 src/i18n/locales/es.json               |   3 +-
 src/i18n/locales/fr.json               |   3 +-
 src/i18n/locales/it.json               |   3 +-
 src/i18n/locales/ja.json               |   3 +-
 src/i18n/locales/pt.json               |   3 +-
 src/i18n/locales/ru.json               |   3 +-
 src/i18n/locales/uk.json               |   3 +-
 src/i18n/locales/zh-CN.json            |   3 +-
 src/i18n/locales/zh-Hant.json          |   3 +-
 src/i18n/same-as-english.json          |   3 +-
 src/layers/awareness/panel.js          |  23 ++
 src/layers/awareness/panel.test.mjs    | 117 ++++++++
 src/layers/awareness/state.js          |   2 +
 src/layers/awareness/subject.js        |  60 ++++-
 src/layers/flights/enrichment.js       | 118 ++++++++-
 src/layers/flights/lifecycle.js        |   1 +
 src/layers/flights/ownership.test.mjs  | 354 ++++++++++++++++++++++++-
 src/layers/flights/policy.js           |   5 +
 src/layers/flights/queries.js          |  16 +-
 src/layers/flights/records.js          |  15 +-
 src/layers/flights/records.test.mjs    |  24 ++
 src/layers/flights/snapshotRenderer.js |   7 +
 src/layers/flights/state.js            |   4 +
 src/layers/flights/testing.js          |  15 +-
 src/layers/flights/tracking.js         |   1 +
 src/sources/live/contract.test.mjs     |  74 ++++++
 src/sources/live/standalone.js         |  29 ++
 src/ui/awarenessPanel.test.mjs         |  70 +++++
 src/ui/styles/radio.css                |  25 ++
 src/ui/views/panels/AwarenessPanel.vue |  11 +
 52 files changed, 1781 insertions(+), 46 deletions(-)
 create mode 100644 scripts/qa-photo-stub.mjs
 create mode 100644 src/data/planespottersPhoto.js
 create mode 100644 src/data/planespottersPhoto.test.mjs

diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index ba231df31..03a37ee5a 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -30,6 +30,7 @@ How to read this:
 | **adsb.lol point API**                                                | Bounded live-flight fallback when OpenSky has no usable snapshot; GNSS Integrity layer (aircraft-reported NIC/NACp and GPS-loss integrity facts, via `/api/gnss-integrity`, 60 s server cache)                                                                    | ODbL 1.0                                                                                                                                                                                                                                                                                                                                              | adsb.lol contributors; `api.adsb.lol/v2/lat/{lat}/lon/{lon}/dist/{radius}`                                                                  |
 | **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, linked to its Planespotters page; "Planespotters.net" 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)                                                                                  |
@@ -200,7 +201,8 @@ The optional Local ADS-B layer and the broadcast-FM receiver use radio you recei
   contributors, ODbL 1.0; GPSJAM for aggregation only.
 
 
-- **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, 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.
+- **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`, whose page is an `https://www.planespotters.net` URL, and which names its photographer 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 is visible text next to it ("Photo © {photographer}"), 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.
@@ -538,4 +540,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, 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.
diff --git a/docs/CODE-BOUNDARIES.md b/docs/CODE-BOUNDARIES.md
index e5b337a51..591db02dc 100644
--- a/docs/CODE-BOUNDARIES.md
+++ b/docs/CODE-BOUNDARIES.md
@@ -136,6 +136,9 @@ socket/watchdog on server close and re-reads configuration after restart.
 The portable `gods-eye-view/sources/adsb-lol` export normalizes existing aircraft
 records without importing Node middleware or a renderer. Browser layer/controller
 separation is outside this server extraction.
+The portable `gods-eye-view/sources/planespotters` export reads a Planespotters
+photo answer (upstream or a server's cached shape) into one host-checked,
+credited thumbnail; it has no fetch, DOM or Node dependency.
 
 ## Place-search and routing providers
 
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 91b7a56a4..5a92f2663 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -2812,6 +2812,17 @@ in `ais-store.js`. Common response caps, request coalescing and query parsing
 have their own modules. `server/providers/local.js` composes these with the
 remaining providers and retains existing named compatibility exports.
 
+The tracked flight also gets a photo. The browser asks Planespotters for it
+directly (`src/sources/live/standalone.js`, read by
+`src/data/planespottersPhoto.js`), once per aircraft, and the CONTEXT panel's
+CONTACTS view shows it under the flight's name with the photographer's credit
+and a link to the photo's page. Military aircraft and a converted TR-3B are
+never looked up. A flight lookup (type, route or photo) whose source failed
+temporarily is asked again after a 60-second cool-down while the aircraft
+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`.
+
 `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
diff --git a/package.json b/package.json
index 76808c084..84b34d528 100644
--- a/package.json
+++ b/package.json
@@ -99,6 +99,7 @@
       "node": "./server/providers/live.js"
     },
     "./sources/adsb-lol": "./src/data/adsbLolFallback.js",
+    "./sources/planespotters": "./src/data/planespottersPhoto.js",
     "./server/providers/places": {
       "node": "./server/providers/places.js"
     },
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index 703aca438..85ca44bdd 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -242,6 +242,11 @@
     "modules": ["src/data/adsbLolFallback.js", "src/sources/adsbFields.js"],
     "external": []
   },
+  "planespotters-source": {
+    "exports": ["./sources/planespotters"],
+    "modules": ["src/data/planespottersPhoto.js"],
+    "external": []
+  },
   "place-providers": {
     "runtime": "node",
     "exports": ["./server/providers/places"],
@@ -1395,7 +1400,8 @@
       "src/sources/live/contract.js",
       "src/sources/live/index.js",
       "src/sources/live/standalone.js",
-      "src/sources/live/vessels.js"
+      "src/sources/live/vessels.js",
+      "src/data/planespottersPhoto.js"
     ],
     "external": []
   },
@@ -1462,7 +1468,8 @@
       "src/i18n/locales/zh-Hant.json",
       "src/ui/unitLabels.js",
       "src/time/worldClock.js",
-      "src/time/julian.js"
+      "src/time/julian.js",
+      "src/data/planespottersPhoto.js"
     ],
     "external": ["cesium"]
   },
@@ -3438,7 +3445,8 @@
       "src/layers/satellites/classes.js",
       "src/layers/satellites/sensors.js",
       "src/data/ucsSatellites.js",
-      "src/data/imagingSensors.js"
+      "src/data/imagingSensors.js",
+      "src/data/planespottersPhoto.js"
     ],
     "external": [
       "hls.js",
@@ -4098,7 +4106,8 @@
       "src/layers/satellites/classes.js",
       "src/layers/satellites/sensors.js",
       "src/data/ucsSatellites.js",
-      "src/data/imagingSensors.js"
+      "src/data/imagingSensors.js",
+      "src/data/planespottersPhoto.js"
     ],
     "external": [
       "hls.js",
@@ -5244,7 +5253,8 @@
       "src/layers/satellites/classes.js",
       "src/layers/satellites/sensors.js",
       "src/data/ucsSatellites.js",
-      "src/data/imagingSensors.js"
+      "src/data/imagingSensors.js",
+      "src/data/planespottersPhoto.js"
     ],
     "external": ["@mapbox/vector-tile", "pbf"]
   },
diff --git a/scripts/qa-cockpit-utility.mjs b/scripts/qa-cockpit-utility.mjs
index c5a94018f..a342a5cdf 100644
--- a/scripts/qa-cockpit-utility.mjs
+++ b/scripts/qa-cockpit-utility.mjs
@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import puppeteer from 'puppeteer';
+import { stubPlanespotters } from './qa-photo-stub.mjs';
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const shotsDir = path.join(repoRoot, 'qa-shots', 'cockpit-utility');
@@ -29,6 +30,7 @@ const browser = await puppeteer.launch({
   ],
 });
 const page = await browser.newPage();
+await stubPlanespotters(page);
 const failures = [];
 const consoleErrors = [];
 const localHttpErrors = [];
@@ -825,6 +827,7 @@ try {
   // a legitimate retained snapshot cannot satisfy or invalidate a FIRST-fetch
   // assertion when camera motion supersedes the manager's initial update.
   const readinessPage = await browser.newPage();
+  await stubPlanespotters(readinessPage);
   let deferredInstallationReadiness;
   try {
     await readinessPage.setViewport({ width: 1440, height: 900 });
diff --git a/scripts/qa-context-arrivals.mjs b/scripts/qa-context-arrivals.mjs
index 72a6ffab8..704d34a6b 100644
--- a/scripts/qa-context-arrivals.mjs
+++ b/scripts/qa-context-arrivals.mjs
@@ -28,6 +28,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import puppeteer from 'puppeteer';
+import { stubPlanespotters } from './qa-photo-stub.mjs';
 import { createScreencast, moveCamera } from './qa-journey-recorder.mjs';
 
 const argv = process.argv.slice(2);
@@ -77,6 +78,7 @@ const browser = await puppeteer.launch({
 
 async function openPage({ aircraft = false } = {}) {
   const page = await browser.newPage();
+  await stubPlanespotters(page);
   await page.setViewport({ width: 1440, height: 900 });
   page.on('console', (message) => {
     if (message.type() === 'error') result.consoleErrors.push(message.text());
diff --git a/scripts/qa-emergency-squawk.mjs b/scripts/qa-emergency-squawk.mjs
index f877ea659..aeedd6125 100644
--- a/scripts/qa-emergency-squawk.mjs
+++ b/scripts/qa-emergency-squawk.mjs
@@ -27,6 +27,7 @@
  */
 
 import puppeteer from 'puppeteer';
+import { stubPlanespotters } from './qa-photo-stub.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -223,6 +224,7 @@ async function main() {
   const errors = [];
   try {
     const page = await browser.newPage();
+    await stubPlanespotters(page);
     await page.setViewport({ width: 1440, height: 900 });
     page.on('pageerror', (e) => errors.push(e.message));
     const { lon, lat } = CENTER;
diff --git a/scripts/qa-focus-evidence.mjs b/scripts/qa-focus-evidence.mjs
index 1baaf6083..cae1c5c72 100644
--- a/scripts/qa-focus-evidence.mjs
+++ b/scripts/qa-focus-evidence.mjs
@@ -21,6 +21,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import puppeteer from 'puppeteer';
+import { stubPlanespotters } from './qa-photo-stub.mjs';
 
 const argv = process.argv.slice(2);
 const getOpt = (name, fallback = null) => {
@@ -651,6 +652,7 @@ async function main() {
     ],
   });
   const page = await browser.newPage();
+  await stubPlanespotters(page);
   await page.setViewport(VIEWPORT);
   const consoleMessages = [];
   page.on('console', (message) => {
diff --git a/scripts/qa-heading-b3.mjs b/scripts/qa-heading-b3.mjs
index cbba1b88e..fb33654b1 100644
--- a/scripts/qa-heading-b3.mjs
+++ b/scripts/qa-heading-b3.mjs
@@ -99,6 +99,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import puppeteer from 'puppeteer';
+import { stubPlanespotters } from './qa-photo-stub.mjs';
 
 // ---------------------------------------------------------------------------
 // Args (same shape as track-regression.mjs)
@@ -466,6 +467,7 @@ async function main() {
   const failedResponses = [];
   try {
     const page = await browser.newPage();
+    await stubPlanespotters(page);
     await page.setViewport({ width: 1280, height: 800 });
     page.on('console', (msg) => {
       if (msg.type() === 'error') {
diff --git a/scripts/qa-photo-stub.mjs b/scripts/qa-photo-stub.mjs
new file mode 100644
index 000000000..43dd2becb
--- /dev/null
+++ b/scripts/qa-photo-stub.mjs
@@ -0,0 +1,78 @@
+/**
+ * Keep browser QA off third-party aircraft photo services.
+ *
+ * Tracking a civil flight asks Planespotters for the aircraft's photo. QA
+ * runs track synthetic hexes, so a real request only adds a third-party
+ * dependency and, when the service refuses a headless browser, a console
+ * error that fails the "no console errors" checks. Every photo lookup is
+ * answered with no photos instead, without leaving the browser.
+ */
+
+/** Origin of the aircraft photo lookup. */
+export const PLANESPOTTERS_ORIGIN = 'https://api.planespotters.net';
+
+/** The answer every stubbed lookup gets: no photos for this aircraft. */
+export const PLANESPOTTERS_EMPTY_BODY = JSON.stringify({ photos: [] });
+
+/** Whether a URL is a photo lookup the stub answers. */
+export function isPlanespottersRequest(url) {
+  try {
+    return new URL(String(url)).origin === PLANESPOTTERS_ORIGIN;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Answer an intercepted photo lookup from a page that already uses request
+ * interception. Returns false for any other request, which the caller
+ * handles as before.
+ * @param {import('puppeteer').HTTPRequest} request
+ * @returns {boolean} Whether the request was answered.
+ */
+export function respondToPlanespotters(request) {
+  if (!isPlanespottersRequest(request.url())) return false;
+  request.respond({
+    status: 200,
+    contentType: 'application/json',
+    headers: { 'Access-Control-Allow-Origin': '*' },
+    body: PLANESPOTTERS_EMPTY_BODY,
+  });
+  return true;
+}
+
+/**
+ * Stub photo lookups in a page that does not intercept requests: wraps
+ * `fetch` before any app code runs, so a lookup never reaches the network.
+ * Composes with other `fetch` shims in either order.
+ * @param {import('puppeteer').Page} page
+ * @returns {Promise<void>}
+ */
+export async function stubPlanespotters(page) {
+  await page.evaluateOnNewDocument(
+    (origin, body) => {
+      const original = window.fetch.bind(window);
+      window.fetch = (input, init) => {
+        const href =
+          typeof input === 'string' ? input : input?.url || String(input);
+        let target = '';
+        try {
+          target = new URL(href, location.href).origin;
+        } catch {
+          /* not a URL */
+        }
+        if (target === origin) {
+          return Promise.resolve(
+            new Response(body, {
+              status: 200,
+              headers: { 'Content-Type': 'application/json' },
+            }),
+          );
+        }
+        return original(input, init);
+      };
+    },
+    PLANESPOTTERS_ORIGIN,
+    PLANESPOTTERS_EMPTY_BODY,
+  );
+}
diff --git a/scripts/qa-sprites-b5.mjs b/scripts/qa-sprites-b5.mjs
index a70eb1b2d..7e5b824c0 100644
--- a/scripts/qa-sprites-b5.mjs
+++ b/scripts/qa-sprites-b5.mjs
@@ -32,6 +32,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import puppeteer from 'puppeteer';
+import { stubPlanespotters } from './qa-photo-stub.mjs';
 import { classifyAircraft, CLASS_SCALE_2D, CLASS_SCALE_3D, CLASS_MODEL_REAL } from '../src/data/aircraftClass.js';
 // Hangar fleet (2026-08-16): real per-class GLBs render at scale 1; military
 // heavies (airliner/quadjet/glider) render airplane.glb at 1 x class; only
@@ -186,6 +187,7 @@ async function main() {
   const httpErrors = [];
   try {
     const page = await browser.newPage();
+    await stubPlanespotters(page);
     await page.setViewport({ width: 1280, height: 800 });
     page.on('console', (msg) => {
       if (msg.type() === 'error') {
diff --git a/scripts/track-regression.mjs b/scripts/track-regression.mjs
index 16c345db5..d2e04609b 100644
--- a/scripts/track-regression.mjs
+++ b/scripts/track-regression.mjs
@@ -94,6 +94,7 @@
 
 import fs from 'node:fs';
 import puppeteer from 'puppeteer';
+import { respondToPlanespotters } from './qa-photo-stub.mjs';
 import { arrivalAngleViolated, arrivalRotationPassed } from '../src/tooling/trackArrivalObservation.mjs';
 import { classifyAircraft, CLASS_SCALE_3D, CLASS_MODEL_REAL } from '../src/data/aircraftClass.js';
 import { ensureGeoidReady, geoidHeight } from '../src/data/geoid.js';
@@ -287,6 +288,8 @@ async function main() {
         });
         return;
       }
+      // Aircraft photo lookups never reach the third party: no photos.
+      if (respondToPlanespotters(request)) return;
       if (url.origin === APP_ORIGIN && url.pathname === '/api/openai/hud-summary') {
         request.respond({
           status: 200,
diff --git a/src/data/dataCredits.js b/src/data/dataCredits.js
index 6b972fc28..7413f1bab 100644
--- a/src/data/dataCredits.js
+++ b/src/data/dataCredits.js
@@ -134,6 +134,13 @@ export const DATA_CREDITS = [
       'copied, published, or incorporated into other databases without the ' +
       'explicit permission of David J Taylor, Edinburgh',
   },
+  {
+    key: 'planespotters',
+    html:
+      'Aircraft photos: ' +
+      '<a href="https://www.planespotters.net" target="_blank" rel="noopener">Planespotters.net</a> ' +
+      '· each photo is © its photographer, credited beside it',
+  },
   {
     key: 'aisstream',
     html:
diff --git a/src/data/dataCredits.test.mjs b/src/data/dataCredits.test.mjs
index ef20250fc..e0c85623a 100644
--- a/src/data/dataCredits.test.mjs
+++ b/src/data/dataCredits.test.mjs
@@ -43,6 +43,13 @@ test('adsbdb is credited and carries its published route-data restriction', () =
   assert.match(credit.html, /href="https:\/\/www\.adsbdb\.com"/);
 });
 
+test('Planespotters is credited with a plain followable link', () => {
+  const credit = DATA_CREDITS.find((entry) => entry.key === 'planespotters');
+  assert.ok(credit, 'the tracked aircraft photos come from Planespotters');
+  assert.match(credit.html, /href="https:\/\/www\.planespotters\.net"/);
+  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.
diff --git a/src/data/flights.js b/src/data/flights.js
index 6e2d35dbc..815ae41ed 100644
--- a/src/data/flights.js
+++ b/src/data/flights.js
@@ -40,5 +40,7 @@ export const _driveFleetModelHandoffForTest =
   flightsLayer.testing._driveFleetModelHandoffForTest;
 export const _ensureFleetModelForTest =
   flightsLayer.testing._ensureFleetModelForTest;
+export const _resetEnrichmentForTest =
+  flightsLayer.testing._resetEnrichmentForTest;
 export const mapAnalystRecord = flightsLayer.mapAnalystRecord;
 export default flightsLayer;
diff --git a/src/data/flights.test.mjs b/src/data/flights.test.mjs
index 1d6007e8f..5005723d9 100644
--- a/src/data/flights.test.mjs
+++ b/src/data/flights.test.mjs
@@ -1,7 +1,7 @@
 // src/data/flights.test.mjs
 // Focused tests for the pure analyst-record mapper (analyst query engine seam).
 // Pure function — no viewer/DOM needed; imported directly.
-import { test } from 'node:test';
+import { after, afterEach, before, test } from 'node:test';
 import assert from 'node:assert/strict';
 import * as Cesium from 'cesium';
 import flightsLayer, {
@@ -14,9 +14,14 @@ import flightsLayer, {
   _setTrackedFlightRefreshStateForTest,
   _floorGroundedDisplayPositionForTest,
   _clearDisplayFloorStateForTest,
+  _resetEnrichmentForTest,
   mapAnalystRecord,
 } from './flights.js';
-import { setMilitaryLayerActive } from './militaryRegistry.js';
+import {
+  isMilitaryLayerActive,
+  registerMilitaryIcaos,
+  setMilitaryLayerActive,
+} from './militaryRegistry.js';
 import {
   GROUND_FLOOR_LIFT_M,
   reportMeshFloorCell,
@@ -31,6 +36,31 @@ import {
   initTrackedReadout,
 } from './trackedReadout.js';
 
+// Unit tests never reach the network. A test that tracks a plane queues its
+// enrichment (type, route, photo), so every test ends on an empty queue, and a
+// fetch of any absolute URL fails the test it happened in. A test that needs
+// answers installs its own fetch and restores this one.
+const nodeFetch = globalThis.fetch;
+const networkRequests = [];
+before(() => {
+  globalThis.fetch = async (url) => {
+    const href = String(url?.url ?? url);
+    if (/^https?:\/\//i.test(href)) networkRequests.push(href);
+    throw new TypeError(`Failed to parse URL from ${href}`);
+  };
+});
+afterEach(() => {
+  _resetEnrichmentForTest();
+  assert.deepEqual(
+    networkRequests.splice(0),
+    [],
+    'no test reaches the network',
+  );
+});
+after(() => {
+  globalThis.fetch = nodeFetch;
+});
+
 test('share-Follow absence requires an accepted OpenSky snapshot', async () => {
   _setFlightTrackingRefreshOutcomeForTest({ status: 'source-unavailable' });
   assert.equal(
@@ -404,6 +434,232 @@ test('flights poll refreshes tracked callsign/FL/kts and marks a missed poll STA
   }
 });
 
+test('a tracked plane whose photo lookup failed asks again on the first poll after the cool-down', async (t) => {
+  const icao24 = 'b2c3d4';
+  const realNow = Date.now.bind(Date);
+  let offsetMs = 0;
+  t.mock.method(Date, 'now', () => realNow() + offsetMs);
+  const entity = { gevLabelModel: { title: 'OLD', details: [] } };
+  const viewer = { camera: { positionCartographic: null }, scene: {} };
+  _setTrackedFlightRefreshStateForTest({
+    icao24,
+    entity,
+    billboard: {
+      position: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 9_000),
+      color: Cesium.Color.WHITE,
+      show: false,
+    },
+    billboardCollection: { show: false, remove() {} },
+    viewer,
+    meta: {
+      callsign: 'UAL9',
+      altitude: 9_000,
+      renderAltitudeM: 9_050,
+      velocity: 180,
+      true_track: 80,
+      klass: 'airliner',
+      onGround: false,
+      wasAirborne: true,
+      turnRateDps: 0,
+      rawLat: 30.2,
+      rawLon: -97.7,
+    },
+  });
+  let callsign = 'UAL9 ';
+  const photoRequests = [];
+  const routeRequests = [];
+  const guardFetch = globalThis.fetch;
+  globalThis.fetch = async (url) => {
+    url = String(url);
+    if (url.startsWith('https://api.planespotters.net/')) {
+      photoRequests.push(url);
+      return { ok: false, status: 503, json: async () => ({}) };
+    }
+    if (url.startsWith('/api/adsbdb/route/UAL')) routeRequests.push(url);
+    if (!url.startsWith('/api/flights'))
+      return { ok: true, status: 200, json: async () => ({ found: false }) };
+    const nowSec = Math.floor(Date.now() / 1000);
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      json: async () => ({
+        time: nowSec,
+        states: [
+          [
+            icao24,
+            callsign,
+            'United States',
+            nowSec,
+            nowSec,
+            -97.6,
+            30.3,
+            10_668,
+            false,
+            250,
+            95,
+            5,
+            null,
+            10_700,
+            null,
+            null,
+            null,
+            5,
+          ],
+        ],
+      }),
+    };
+  };
+  // Lookups drip out one per 200 ms. Wait for what must arrive (with a
+  // generous deadline, so a loaded machine cannot fail it), then a little
+  // longer so anything that must NOT arrive would have.
+  const until = async (ready) => {
+    const deadline = realNow() + 5_000;
+    while (!ready() && realNow() < deadline)
+      await new Promise((done) => setTimeout(done, 20));
+    await new Promise((done) => setTimeout(done, 450));
+  };
+  try {
+    await flightsLayer.update(viewer);
+    await until(() => photoRequests.length >= 1 && routeRequests.length >= 1);
+    assert.equal(photoRequests.length, 1, 'the first poll asks for the photo');
+    assert.deepEqual(routeRequests, ['/api/adsbdb/route/UAL9']);
+
+    // Well inside the 60 s cool-down, and well past it below, so real time
+    // spent between polls cannot move either side across the line.
+    offsetMs += 30_000;
+    callsign = 'UAL10 ';
+    await flightsLayer.update(viewer);
+    await until(() => routeRequests.length >= 2);
+    assert.equal(photoRequests.length, 1, 'not within the cool-down');
+    assert.deepEqual(
+      routeRequests,
+      ['/api/adsbdb/route/UAL9', '/api/adsbdb/route/UAL10'],
+      'the route follows the callsign the poll just recorded',
+    );
+
+    offsetMs += 60_000;
+    await flightsLayer.update(viewer);
+    await until(() => photoRequests.length >= 2);
+    assert.deepEqual(
+      photoRequests,
+      [
+        'https://api.planespotters.net/pub/photos/hex/b2c3d4',
+        'https://api.planespotters.net/pub/photos/hex/b2c3d4',
+      ],
+      'asked again on the first poll after the cool-down',
+    );
+  } finally {
+    globalThis.fetch = guardFetch;
+    // The moved clock dated this layer's dispatch and cool-downs into the
+    // future; reset before the real clock comes back.
+    _resetEnrichmentForTest();
+    t.mock.restoreAll();
+  }
+});
+
+test('a known-military aircraft tracked in the flights layer is never looked up and shows no photo', async () => {
+  const icao24 = 'ae5e01';
+  // The registry has no way to forget one hex (only a whole-registry reset,
+  // which would also drop its source), so the test uses a hex no other test
+  // reads and restores the layer-active flag it changes.
+  const militaryWasActive = isMilitaryLayerActive();
+  registerMilitaryIcaos([icao24]);
+  setMilitaryLayerActive(false);
+  const viewer = { camera: { positionCartographic: null }, scene: {} };
+  _setTrackedFlightRefreshStateForTest({
+    icao24,
+    entity: { gevLabelModel: { title: 'OLD', details: [] } },
+    billboard: {
+      position: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 9_000),
+      color: Cesium.Color.WHITE,
+      show: false,
+    },
+    billboardCollection: { show: false, remove() {} },
+    viewer,
+    meta: {
+      callsign: 'RCH123',
+      altitude: 9_000,
+      renderAltitudeM: 9_050,
+      velocity: 180,
+      true_track: 80,
+      klass: 'airliner',
+      onGround: false,
+      wasAirborne: true,
+      turnRateDps: 0,
+      rawLat: 30.2,
+      rawLon: -97.7,
+      // Even a photo already on the record is never shown.
+      photo: {
+        src: 'https://t.plnspttrs.net/1/ae5e01_280.jpg',
+        width: 280,
+        height: 186,
+        photographer: 'Jane Doe',
+        link: 'https://www.planespotters.net/photo/1/x',
+      },
+    },
+  });
+  const photoRequests = [];
+  const routeRequests = [];
+  const guardFetch = globalThis.fetch;
+  globalThis.fetch = async (url) => {
+    url = String(url);
+    if (url.startsWith('https://api.planespotters.net/')) {
+      photoRequests.push(url);
+      return { ok: false, status: 503, json: async () => ({}) };
+    }
+    if (url.startsWith('/api/adsbdb/route/')) routeRequests.push(url);
+    if (!url.startsWith('/api/flights'))
+      return { ok: true, status: 200, json: async () => ({ found: false }) };
+    const nowSec = Math.floor(Date.now() / 1000);
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      json: async () => ({
+        time: nowSec,
+        states: [
+          [
+            icao24,
+            'RCH123 ',
+            'United States',
+            nowSec,
+            nowSec,
+            -97.6,
+            30.3,
+            10_668,
+            false,
+            250,
+            95,
+            5,
+            null,
+            10_700,
+            null,
+            null,
+            null,
+            5,
+          ],
+        ],
+      }),
+    };
+  };
+  try {
+    await flightsLayer.update(viewer);
+    // A photo lookup would go out ahead of the route; wait for the route.
+    const deadline = Date.now() + 5_000;
+    while (!routeRequests.length && Date.now() < deadline)
+      await new Promise((done) => setTimeout(done, 20));
+    assert.deepEqual(routeRequests, ['/api/adsbdb/route/RCH123']);
+    assert.deepEqual(photoRequests, [], 'no photo lookup for a military hex');
+    assert.equal(flightsLayer.getTrackedInfo()?.icao24, icao24);
+    assert.equal(flightsLayer.getTrackedInfo()?.photo, null);
+    assert.equal(flightsLayer.getTrackedSubject()?.photo, null);
+  } finally {
+    globalThis.fetch = guardFetch;
+    setMilitaryLayerActive(militaryWasActive);
+  }
+});
+
 test('real civil track path creates no native label and publishes every cached host line', async () => {
   const icao24 = 'civ001';
   const position = Cesium.Cartesian3.fromDegrees(-97.6699, 30.1945, 10_668);
diff --git a/src/data/militaryAwareness.test.mjs b/src/data/militaryAwareness.test.mjs
index 98743b03c..430ca3362 100644
--- a/src/data/militaryAwareness.test.mjs
+++ b/src/data/militaryAwareness.test.mjs
@@ -425,7 +425,7 @@ test('a dependency the user adopts stays on when Contacts turns off', async () =
     assert.deepEqual(
       released,
       AWARENESS_DEPENDENCIES.filter((layerId) => layerId !== 'flights').sort(),
-      'the adopted layer is the user\'s now; the rest are still released',
+      "the adopted layer is the user's now; the rest are still released",
     );
   } finally {
     runtime.restore();
@@ -1118,6 +1118,92 @@ test('production military tracked-subject label falls back to registration befor
   }
 });
 
+test('the tracked airliner’s photo reaches the Contacts panel when it lands after selection', async () => {
+  const id = 'a1f2c3';
+  const position = Cesium.Cartesian3.fromDegrees(-97.71, 30.21, 10_668);
+  const sourceViewer = { camera: { positionCartographic: null }, scene: {} };
+  const runtime = installAwarenessRuntime();
+  const restores = [];
+  const meta = {
+    callsign: 'AAL100',
+    altitude: 10_668,
+    renderAltitudeM: 10_700,
+    velocity: 250,
+    true_track: 95,
+    klass: 'airliner',
+    onGround: false,
+    wasAirborne: true,
+    turnRateDps: 0,
+    rawLat: 30.21,
+    rawLon: -97.71,
+    photo: null,
+  };
+
+  try {
+    _setTrackedFlightRefreshStateForTest({
+      icao24: id,
+      entity: null,
+      billboard: { position, color: Cesium.Color.WHITE, show: true },
+      billboardCollection: { show: true, remove() {} },
+      viewer: sourceViewer,
+      meta,
+    });
+    runtime.viewer.trackedEntity = { gevTrackedId: `flights:${id}` };
+    replaceMethod(
+      militaryFlightsLayer,
+      'getTrackedSubject',
+      () => null,
+      restores,
+    );
+    replaceMethod(flightsLayer, 'trackById', () => true, restores);
+    replaceMethod(militaryFlightsLayer, 'trackById', () => true, restores);
+
+    militaryAwarenessLayer.setParams({ passive: false });
+    await nextTurn();
+    assert.equal(runtime.panel().view?.kind, 'results');
+    assert.equal(runtime.panel().view.photo, null, 'no photo before it lands');
+
+    // An unchanged refresh stays quiet.
+    const settledPublishes = runtime.panel().publishes;
+    await militaryAwarenessLayer.update();
+    assert.equal(runtime.panel().publishes, settledPublishes);
+
+    // The photo lands while the plane holds still: render-worthy on its own.
+    meta.photo = {
+      src: 'https://t.plnspttrs.net/1/a1f2c3_280.jpg',
+      width: 280,
+      height: 186,
+      photographer: 'Jane Doe',
+      link: 'https://www.planespotters.net/photo/1/n100aa',
+    };
+    await militaryAwarenessLayer.update();
+    assert.deepEqual(runtime.panel().view.photo, {
+      src: 'https://t.plnspttrs.net/1/a1f2c3_280.jpg',
+      width: 280,
+      height: 186,
+      link: 'https://www.planespotters.net/photo/1/n100aa',
+      credit: 'Photo © Jane Doe',
+    });
+
+    // And it repaints once, not on every refresh.
+    const shownPublishes = runtime.panel().publishes;
+    await militaryAwarenessLayer.update();
+    assert.equal(runtime.panel().publishes, shownPublishes);
+  } finally {
+    restores.reverse().forEach((restore) => restore());
+    _setTrackedFlightRefreshStateForTest({
+      icao24: id,
+      entity: null,
+      billboard: { position, show: true },
+      billboardCollection: { show: false, remove() {} },
+      viewer: sourceViewer,
+      meta: {},
+      tracked: false,
+    });
+    runtime.restore();
+  }
+});
+
 test('a cached Context subject re-reads its label when enrichment lands after selection', async () => {
   // The subject snapshot is captured once at selection. Selecting a
   // callsign-less aircraft BEFORE adsbdb enrichment answers used to freeze the
diff --git a/src/data/planespottersPhoto.js b/src/data/planespottersPhoto.js
new file mode 100644
index 000000000..8346df49f
--- /dev/null
+++ b/src/data/planespottersPhoto.js
@@ -0,0 +1,121 @@
+/**
+ * @module planespottersPhoto
+ * @description Reads a Planespotters photo answer into the one credited
+ * thumbnail every surface shows. Planespotters lets the thumbnail be hotlinked
+ * on the condition that the photographer is credited next to it and the image
+ * links back to the photo's page, so a photo without a photographer, or whose
+ * image or page is not on Planespotters' own hosts, is "no photo": nothing
+ * arbitrary is ever shown or linked.
+ *
+ * Accepts the upstream answer (`GET https://api.planespotters.net/pub/photos/hex/{hex}`,
+ * `{photos: [...]}`), the cached server shape
+ * (`{found, thumbnail_large?, thumbnail: {src, width, height}, photographer,
+ * link}`), and an
+ * already-read photo (`{found, src, width, height, photographer, link}`).
+ * Pure: no fetch, no DOM.
+ */
+
+/** The image host: Planespotters' thumbnail CDN and its subdomains. */
+const IMAGE_HOST = 'plnspttrs.net';
+/** The only page host a photo may link to. */
+const PAGE_HOST = 'www.planespotters.net';
+
+const NO_PHOTO = Object.freeze({ found: false });
+
+const isObject = (value) => Boolean(value) && typeof value === 'object';
+
+/** The parsed `https:` URL, or null for anything else or with userinfo/port. */
+function httpsUrl(value) {
+  if (typeof value !== 'string' || !value) return null;
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== 'https:' || url.username || url.password || url.port)
+    return null;
+  return url;
+}
+
+function imageSrc(value) {
+  const url = httpsUrl(value);
+  return url &&
+    (url.hostname === IMAGE_HOST || url.hostname.endsWith(`.${IMAGE_HOST}`))
+    ? url.href
+    : null;
+}
+
+function pageLink(value) {
+  const url = httpsUrl(value);
+  return url && url.hostname === PAGE_HOST ? url.href : null;
+}
+
+function dimension(value) {
+  const number = Number(value);
+  return value != null && Number.isFinite(number) && number > 0
+    ? Math.round(number)
+    : null;
+}
+
+/** One candidate `{src, width, height, photographer, link}`, checked. */
+function checked({ src, width, height, photographer, link }) {
+  const credit = typeof photographer === 'string' ? photographer.trim() : '';
+  const image = imageSrc(src);
+  const page = pageLink(link);
+  if (!credit || !image || !page) return null;
+  return {
+    found: true,
+    src: image,
+    width: dimension(width),
+    height: dimension(height),
+    photographer: credit,
+    link: page,
+  };
+}
+
+/** The upstream photo's candidates, large thumbnail first. */
+function upstreamCandidates(photo) {
+  if (!photo || typeof photo !== 'object') return [];
+  return [photo.thumbnail_large, photo.thumbnail]
+    .filter((thumb) => thumb && typeof thumb === 'object')
+    .map((thumb) => ({
+      src: thumb.src,
+      width: thumb.size?.width,
+      height: thumb.size?.height,
+      photographer: photo.photographer,
+      link: photo.link,
+    }));
+}
+
+/**
+ * Read a Planespotters answer into the first photo that passes the checks.
+ * @param {*} payload Upstream, cached-server, or already-read photo.
+ * @returns {{found: true, src: string, width: ?number, height: ?number,
+ *   photographer: string, link: string} | {found: false}}
+ */
+export function parsePlanespottersPhoto(payload) {
+  if (!payload || typeof payload !== 'object') return NO_PHOTO;
+  let candidates;
+  if (Array.isArray(payload.photos)) {
+    candidates = payload.photos.flatMap(upstreamCandidates);
+  } else if (payload.found !== true) {
+    return NO_PHOTO;
+  } else if (isObject(payload.thumbnail) || isObject(payload.thumbnail_large)) {
+    // Large first, as for the upstream answer; each must pass the checks.
+    candidates = [payload.thumbnail_large, payload.thumbnail]
+      .filter(isObject)
+      .map((thumb) => ({
+        ...thumb,
+        photographer: payload.photographer,
+        link: payload.link,
+      }));
+  } else {
+    candidates = [payload];
+  }
+  for (const candidate of candidates) {
+    const photo = checked(candidate);
+    if (photo) return photo;
+  }
+  return NO_PHOTO;
+}
diff --git a/src/data/planespottersPhoto.test.mjs b/src/data/planespottersPhoto.test.mjs
new file mode 100644
index 000000000..e051367f2
--- /dev/null
+++ b/src/data/planespottersPhoto.test.mjs
@@ -0,0 +1,200 @@
+// src/data/planespottersPhoto.test.mjs — the Planespotters photo answer is read
+// into one credited thumbnail, and nothing outside Planespotters' own hosts is
+// ever shown or linked.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { parsePlanespottersPhoto } from './planespottersPhoto.js';
+
+const UPSTREAM = Object.freeze({
+  photos: [
+    {
+      id: '1745410',
+      thumbnail: {
+        src: 'https://t.plnspttrs.net/33043/1745410_822dfe330c_t.jpg',
+        size: { width: 200, height: 133 },
+      },
+      thumbnail_large: {
+        src: 'https://t.plnspttrs.net/33043/1745410_822dfe330c_280.jpg',
+        size: { width: 420, height: 280 },
+      },
+      link: 'https://www.planespotters.net/photo/1745410/n160an-american-airlines-airbus-a321-231-wl?utm_source=api',
+      photographer: 'Jan Seler',
+    },
+  ],
+});
+
+const PHOTO = Object.freeze({
+  found: true,
+  src: 'https://t.plnspttrs.net/33043/1745410_822dfe330c_280.jpg',
+  width: 420,
+  height: 280,
+  photographer: 'Jan Seler',
+  link: 'https://www.planespotters.net/photo/1745410/n160an-american-airlines-airbus-a321-231-wl?utm_source=api',
+});
+
+const photo = (overrides) => ({
+  photos: [{ ...UPSTREAM.photos[0], ...overrides }],
+});
+
+test('the upstream answer maps to the large thumbnail, its size, credit and link', () => {
+  assert.deepEqual(parsePlanespottersPhoto(UPSTREAM), PHOTO);
+});
+
+test('the small thumbnail stands in when the large one is missing', () => {
+  assert.deepEqual(parsePlanespottersPhoto(photo({ thumbnail_large: null })), {
+    ...PHOTO,
+    src: 'https://t.plnspttrs.net/33043/1745410_822dfe330c_t.jpg',
+    width: 200,
+    height: 133,
+  });
+});
+
+test('a server’s cached shape reads the same way', () => {
+  assert.deepEqual(
+    parsePlanespottersPhoto({
+      found: true,
+      thumbnail: { src: PHOTO.src, width: 420, height: 280 },
+      photographer: 'Jan Seler',
+      link: PHOTO.link,
+    }),
+    PHOTO,
+  );
+  assert.deepEqual(parsePlanespottersPhoto({ found: false }), {
+    found: false,
+  });
+});
+
+test('a server’s cached shape prefers its large thumbnail', () => {
+  assert.deepEqual(
+    parsePlanespottersPhoto({
+      found: true,
+      thumbnail: {
+        src: 'https://t.plnspttrs.net/33043/1745410_822dfe330c_t.jpg',
+        width: 200,
+        height: 133,
+      },
+      thumbnail_large: { src: PHOTO.src, width: 420, height: 280 },
+      photographer: 'Jan Seler',
+      link: PHOTO.link,
+    }),
+    PHOTO,
+  );
+});
+
+test('a server’s cached shape falls back to its small thumbnail when the large one fails the checks', () => {
+  const small = {
+    src: 'https://t.plnspttrs.net/33043/1745410_822dfe330c_t.jpg',
+    width: 200,
+    height: 133,
+  };
+  for (const thumbnail_large of [
+    { src: 'https://evil.example/a.jpg', width: 420, height: 280 },
+    null,
+  ]) {
+    assert.deepEqual(
+      parsePlanespottersPhoto({
+        found: true,
+        thumbnail: small,
+        thumbnail_large,
+        photographer: 'Jan Seler',
+        link: PHOTO.link,
+      }),
+      { ...PHOTO, ...small },
+      JSON.stringify(thumbnail_large),
+    );
+  }
+});
+
+test('no photo, junk, and missing fields are "no photo"', () => {
+  for (const payload of [
+    { photos: [] },
+    {},
+    null,
+    undefined,
+    'nope',
+    { photos: 'nope' },
+    { photos: [null] },
+    photo({ photographer: '' }),
+    photo({ photographer: '   ' }),
+    photo({ photographer: 42 }),
+    photo({ link: '' }),
+    photo({ thumbnail: null, thumbnail_large: null }),
+  ]) {
+    assert.deepEqual(
+      parsePlanespottersPhoto(payload),
+      { found: false },
+      JSON.stringify(payload),
+    );
+  }
+});
+
+test('a src outside https *.plnspttrs.net is dropped', () => {
+  for (const src of [
+    'http://t.plnspttrs.net/a.jpg',
+    'https://plnspttrs.net.evil.example/a.jpg',
+    'https://evil.example/t.plnspttrs.net/a.jpg',
+    'https://t.plnspttrs.net.evil.example/a.jpg',
+    'https://user@t.plnspttrs.net/a.jpg',
+    'https://t.plnspttrs.net:8443/a.jpg',
+    'javascript:alert(1)',
+    '//t.plnspttrs.net/a.jpg',
+    'not a url',
+  ]) {
+    assert.deepEqual(
+      parsePlanespottersPhoto(
+        photo({
+          thumbnail_large: { src, size: { width: 420, height: 280 } },
+          thumbnail: { src, size: { width: 200, height: 133 } },
+        }),
+      ),
+      { found: false },
+      src,
+    );
+  }
+});
+
+test('a link anywhere but https://www.planespotters.net is dropped', () => {
+  for (const link of [
+    'http://www.planespotters.net/photo/1',
+    'https://planespotters.net/photo/1',
+    'https://www.planespotters.net.evil.example/photo/1',
+    'https://evil.example/?u=https://www.planespotters.net/',
+    'https://user:pw@www.planespotters.net/photo/1',
+    'https://www.planespotters.net:444/photo/1',
+    'javascript:alert(1)',
+  ]) {
+    assert.deepEqual(
+      parsePlanespottersPhoto(photo({ link })),
+      { found: false },
+      link,
+    );
+  }
+});
+
+test('the first photo that passes the checks is the one shown', () => {
+  const second = {
+    ...UPSTREAM.photos[0],
+    photographer: 'Second Spotter',
+  };
+  assert.deepEqual(
+    parsePlanespottersPhoto({
+      photos: [
+        { ...UPSTREAM.photos[0], link: 'https://evil.example/' },
+        second,
+      ],
+    }),
+    { ...PHOTO, photographer: 'Second Spotter' },
+  );
+});
+
+test('a missing size is null and the credit is trimmed', () => {
+  assert.deepEqual(
+    parsePlanespottersPhoto(
+      photo({
+        photographer: '  Jan Seler ',
+        thumbnail_large: { src: PHOTO.src },
+      }),
+    ),
+    { ...PHOTO, width: null, height: null },
+  );
+});
diff --git a/src/i18n/locales/ar.json b/src/i18n/locales/ar.json
index 83e163cde..59a18415f 100644
--- a/src/i18n/locales/ar.json
+++ b/src/i18n/locales/ar.json
@@ -3619,5 +3619,6 @@
   "1 wk/s": "أسبوع/ث",
   "Play speed": "سرعة التشغيل",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "مرّر أو اقرص للتكبير، واسحب للتنقل · انقر نقرًا مزدوجًا لرؤية الكل",
-  "1 min/s": "دقيقة/ث"
+  "1 min/s": "دقيقة/ث",
+  "Photo © {photographer}": "صورة © {photographer}"
 }
diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json
index c21a9f936..02d6fdb73 100644
--- a/src/i18n/locales/de.json
+++ b/src/i18n/locales/de.json
@@ -3311,5 +3311,6 @@
   "1 wk/s": "1 Wo./s",
   "Play speed": "Wiedergabegeschwindigkeit",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "Scrollen oder mit zwei Fingern zoomen, ziehen zum Verschieben · Doppelklick zeigt alles",
-  "1 min/s": "1 Min./s"
+  "1 min/s": "1 Min./s",
+  "Photo © {photographer}": "Foto © {photographer}"
 }
diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json
index c060630e2..a007bec4e 100644
--- a/src/i18n/locales/es.json
+++ b/src/i18n/locales/es.json
@@ -3388,5 +3388,6 @@
   "1 wk/s": "1 sem/s",
   "Play speed": "Velocidad de reproducción",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "Desplaza o pellizca para ampliar, arrastra para moverte · doble clic para verlo todo",
-  "1 min/s": "1 min/s"
+  "1 min/s": "1 min/s",
+  "Photo © {photographer}": "Foto © {photographer}"
 }
diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json
index e0731d11a..f394eaf98 100644
--- a/src/i18n/locales/fr.json
+++ b/src/i18n/locales/fr.json
@@ -3388,5 +3388,6 @@
   "1 wk/s": "1 sem/s",
   "Play speed": "Vitesse de lecture",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "Faites défiler ou pincez pour zoomer, glissez pour vous déplacer · double-clic pour tout voir",
-  "1 min/s": "1 min/s"
+  "1 min/s": "1 min/s",
+  "Photo © {photographer}": "Photo © {photographer}"
 }
diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json
index 3ff2a8313..8122e2c47 100644
--- a/src/i18n/locales/it.json
+++ b/src/i18n/locales/it.json
@@ -3388,5 +3388,6 @@
   "1 wk/s": "1 sett/s",
   "Play speed": "Velocità di riproduzione",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "Scorri o pizzica per lo zoom, trascina per spostarti · doppio clic per vedere tutto",
-  "1 min/s": "1 min/s"
+  "1 min/s": "1 min/s",
+  "Photo © {photographer}": "Foto © {photographer}"
 }
diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json
index a4bd4522b..9c716ec48 100644
--- a/src/i18n/locales/ja.json
+++ b/src/i18n/locales/ja.json
@@ -3234,5 +3234,6 @@
   "1 wk/s": "1週間/秒",
   "Play speed": "再生速度",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "スクロールまたはピンチでズーム、ドラッグで移動 · ダブルクリックで全体表示",
-  "1 min/s": "1分/秒"
+  "1 min/s": "1分/秒",
+  "Photo © {photographer}": "写真 © {photographer}"
 }
diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json
index e1578d66d..1afd6d382 100644
--- a/src/i18n/locales/pt.json
+++ b/src/i18n/locales/pt.json
@@ -3388,5 +3388,6 @@
   "1 wk/s": "1 sem/s",
   "Play speed": "Velocidade de reprodução",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "Role ou faça pinça para ampliar, arraste para se mover · clique duplo para ver tudo",
-  "1 min/s": "1 min/s"
+  "1 min/s": "1 min/s",
+  "Photo © {photographer}": "Foto © {photographer}"
 }
diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json
index 43639b06f..d6af529c0 100644
--- a/src/i18n/locales/ru.json
+++ b/src/i18n/locales/ru.json
@@ -3465,5 +3465,6 @@
   "1 wk/s": "1 нед/с",
   "Play speed": "Скорость воспроизведения",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "Прокрутите или сведите пальцы для масштаба, перетащите для перемещения · двойной щелчок — показать всё",
-  "1 min/s": "1 мин/с"
+  "1 min/s": "1 мин/с",
+  "Photo © {photographer}": "Фото © {photographer}"
 }
diff --git a/src/i18n/locales/uk.json b/src/i18n/locales/uk.json
index a99148853..6826eb2fa 100644
--- a/src/i18n/locales/uk.json
+++ b/src/i18n/locales/uk.json
@@ -3465,5 +3465,6 @@
   "1 wk/s": "1 тиж/с",
   "Play speed": "Швидкість відтворення",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "Прокрутіть або зведіть пальці для масштабу, перетягніть для переміщення · подвійне клацання — показати все",
-  "1 min/s": "1 хв/с"
+  "1 min/s": "1 хв/с",
+  "Photo © {photographer}": "Фото © {photographer}"
 }
diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json
index e7d9ca384..d0af7ee5e 100644
--- a/src/i18n/locales/zh-CN.json
+++ b/src/i18n/locales/zh-CN.json
@@ -3234,5 +3234,6 @@
   "1 wk/s": "1 周/秒",
   "Play speed": "播放速度",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "滚动或双指缩放，拖动以移动 · 双击查看全部",
-  "1 min/s": "1 分钟/秒"
+  "1 min/s": "1 分钟/秒",
+  "Photo © {photographer}": "照片 © {photographer}"
 }
diff --git a/src/i18n/locales/zh-Hant.json b/src/i18n/locales/zh-Hant.json
index 1042a0d35..c0e22141b 100644
--- a/src/i18n/locales/zh-Hant.json
+++ b/src/i18n/locales/zh-Hant.json
@@ -3234,5 +3234,6 @@
   "1 wk/s": "1 週/秒",
   "Play speed": "播放速度",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "捲動或雙指縮放，拖曳以移動 · 按兩下查看全部",
-  "1 min/s": "1 分鐘/秒"
+  "1 min/s": "1 分鐘/秒",
+  "Photo © {photographer}": "照片 © {photographer}"
 }
diff --git a/src/i18n/same-as-english.json b/src/i18n/same-as-english.json
index 8c2a2bd75..458354169 100644
--- a/src/i18n/same-as-english.json
+++ b/src/i18n/same-as-english.json
@@ -586,7 +586,8 @@
     "Ⅱ PAUSE",
     "≥ {value} MW",
     "▲ {frp} MW",
-    "SATELLITE"
+    "SATELLITE",
+    "Photo © {photographer}"
   ],
   "it": [
     "1 min/s",
diff --git a/src/layers/awareness/panel.js b/src/layers/awareness/panel.js
index 5396a0390..fbc9725c9 100644
--- a/src/layers/awareness/panel.js
+++ b/src/layers/awareness/panel.js
@@ -182,6 +182,28 @@ export function createPanel({ state: layerState, parts }) {
       : null;
   }
 
+  /** 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;
+    if (
+      !held ||
+      held.layerId !== subject.layerId ||
+      String(held.id) !== String(subject.id)
+    )
+      return null;
+    const { photo } = held;
+    return {
+      src: photo.src,
+      width: photo.width ?? null,
+      height: photo.height ?? null,
+      link: photo.link,
+      credit: t('Photo © {photographer}', {
+        photographer: photo.photographer,
+      }),
+    };
+  }
+
   function renderResults() {
     if (!layerState.enabled || !layerState.results) return hidePanel();
     ensurePanel();
@@ -191,6 +213,7 @@ export function createPanel({ state: layerState, parts }) {
       kind: 'results',
       subject: `${subject.label} · ${t('{distance} FLIGHT / VESSEL WINDOW', { distance: presentAwarenessDistance(AWARENESS_RADIUS_M) })}`,
       subjectNames: presentNames(subject.memberNames),
+      photo: presentPhoto(subject),
       navigation: presentNavigation(),
       rows: cohorts.map(presentRow),
       note: t(
diff --git a/src/layers/awareness/panel.test.mjs b/src/layers/awareness/panel.test.mjs
index eaaac70e9..4fa2c448c 100644
--- a/src/layers/awareness/panel.test.mjs
+++ b/src/layers/awareness/panel.test.mjs
@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { createPanel } from './panel.js';
+import { createSubject } from './subject.js';
 
 test('a Contacts row names its provider as the Layers panel does, with its feed state', () => {
   const cohort = (id, source, sourceStatus) => ({
@@ -36,3 +37,119 @@ test('a Contacts row names its provider as the Layers panel does, with its feed
   );
   state.offPanelLocale?.();
 });
+
+const PHOTO = Object.freeze({
+  src: 'https://t.plnspttrs.net/1/abc123_280.jpg',
+  width: 280,
+  height: 186,
+  photographer: 'Jane Doe',
+  link: 'https://www.planespotters.net/photo/1/n123ab',
+});
+
+/** The published Contacts view for one subject and the refresh's photo. */
+function photoView(subject, subjectPhoto) {
+  const state = {
+    enabled: true,
+    results: { subject, cohorts: [] },
+    subjectPhoto,
+    cohortPages: new Map(),
+    panelListeners: new Set(),
+    panelSignature: '',
+    navigationIndex: 0,
+  };
+  const parts = {
+    navigation: { canNavigateNext: () => false },
+    rendering: { hideDirectionOverlay() {} },
+  };
+  createPanel({ state, parts }).renderResults();
+  state.offPanelLocale?.();
+  return state.panelView;
+}
+
+const FLIGHT = Object.freeze({
+  layerId: 'flights',
+  id: 'abc123',
+  label: 'N123AB',
+});
+
+test('the Contacts view carries the tracked flight’s photo with its credit', () => {
+  const view = photoView(FLIGHT, {
+    layerId: 'flights',
+    id: 'abc123',
+    photo: PHOTO,
+  });
+  assert.deepEqual(view.photo, {
+    src: PHOTO.src,
+    width: 280,
+    height: 186,
+    link: PHOTO.link,
+    credit: 'Photo © Jane Doe',
+  });
+});
+
+test('the Contacts view has no photo without one, or with another subject’s', () => {
+  assert.equal(photoView(FLIGHT, null).photo, null);
+  assert.equal(
+    photoView(FLIGHT, { layerId: 'flights', id: 'def456', photo: PHOTO }).photo,
+    null,
+  );
+  assert.equal(
+    photoView(
+      { layerId: 'ais-live-vessels', id: 'abc123', label: 'VESSEL' },
+      { layerId: 'flights', id: 'abc123', photo: PHOTO },
+    ).photo,
+    null,
+  );
+});
+
+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',
+    label: 'N123AB',
+    photo: PHOTO,
+  };
+  let current = tracked;
+  let lookups = 0;
+  const flights = {
+    getTrackedSubject: () => {
+      lookups += 1;
+      return current;
+    },
+  };
+  const military = {
+    getTrackedSubject: () => ({ ...tracked, layerId: 'military' }),
+  };
+  const { resolveSubjectPhoto } = createSubject({
+    state: {},
+    services: { flights, military, vessels: {}, installations: {} },
+    parts: {
+      navigation: {
+        isFlightLayer: (id) => id === 'flights' || id === 'military',
+      },
+    },
+  });
+  assert.deepEqual(
+    resolveSubjectPhoto({ layerId: 'flights', id: 'abc123' }),
+    PHOTO,
+  );
+  assert.equal(lookups, 1);
+  assert.equal(resolveSubjectPhoto({ layerId: 'flights', id: 'def456' }), null);
+  assert.equal(
+    resolveSubjectPhoto({ layerId: 'ais-live-vessels', id: 'abc123' }),
+    null,
+  );
+  assert.equal(
+    resolveSubjectPhoto({ layerId: 'military-installations', id: 'abc123' }),
+    null,
+  );
+  assert.equal(
+    resolveSubjectPhoto({ layerId: 'military', id: 'abc123' }),
+    null,
+  );
+  assert.equal(resolveSubjectPhoto(null), null);
+  current = null;
+  assert.equal(resolveSubjectPhoto({ layerId: 'flights', id: 'abc123' }), null);
+  current = { ...tracked, photo: null };
+  assert.equal(resolveSubjectPhoto({ layerId: 'flights', id: 'abc123' }), null);
+});
diff --git a/src/layers/awareness/state.js b/src/layers/awareness/state.js
index adc896943..d950e7a84 100644
--- a/src/layers/awareness/state.js
+++ b/src/layers/awareness/state.js
@@ -29,6 +29,8 @@ export function createState({ services }) {
     /** Stops following the manager's adoptions (see watchAdoptions). */
     unwatchAdoptions: null,
     subject: null,
+    /** The tracked flight's photo with the subject it belongs to, or null. */
+    subjectPhoto: null,
     results: null,
     visual: null,
     /** Whether layer views replace the panel's initial markup yet. */
diff --git a/src/layers/awareness/subject.js b/src/layers/awareness/subject.js
index 60f622e29..050d144c2 100644
--- a/src/layers/awareness/subject.js
+++ b/src/layers/awareness/subject.js
@@ -378,19 +378,48 @@ export function createSubject({ state: layerState, services, parts, source }) {
    *
    * Identity (`subject.id`) is NEVER re-derived — only the rendered string.
    * @param {{layerId: string, id: string, label: string}} subject Current subject.
+   * @param {?object} [tracked] The subject's tracked descriptor, when the
+   *   caller already has it (see trackedSubjectOf).
    * @returns {string} The current label, or the cached one when the owning layer
    *   has no tracked subject (e.g. a cross-layer handoff is in flight).
    */
 
-  function resolveSubjectLabel(subject) {
-    if (!parts.navigation.isFlightLayer(subject?.layerId))
-      return subject?.label;
+  function resolveSubjectLabel(subject, tracked = trackedSubjectOf(subject)) {
+    return tracked?.label || subject?.label;
+  }
+
+  /**
+   * The owning flight layer's tracked-subject descriptor when it describes
+   * this subject, else null. Built once per refresh and shared by the label
+   * and the photo.
+   * @param {{layerId: string, id: string}|null} subject Current subject.
+   * @returns {?{id: string, label: string, photo?: ?object}}
+   */
+  function trackedSubjectOf(subject) {
+    if (!parts.navigation.isFlightLayer(subject?.layerId)) return null;
     const layer =
       subject.layerId === 'flights' ? flightsLayer : militaryFlightsLayer;
     const tracked = layer.getTrackedSubject?.();
-    if (tracked?.label && String(tracked.id) === String(subject.id))
-      return tracked.label;
-    return subject.label;
+    return tracked && String(tracked.id) === String(subject.id)
+      ? tracked
+      : null;
+  }
+
+  /**
+   * The tracked airliner's Planespotters photo, for the Contacts panel.
+   *
+   * 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}}
+   */
+  function resolveSubjectPhoto(subject, tracked = trackedSubjectOf(subject)) {
+    return subject?.layerId === 'flights' && tracked?.photo
+      ? tracked.photo
+      : null;
   }
 
   /** Refresh proximity counts/distances against the subject's current live position. */
@@ -417,8 +446,21 @@ export function createSubject({ state: layerState, services, parts, source }) {
     if (presence === SUBJECT_PRESENCE.LIVE) layerState.subjectMissing = false;
     else if (presence === SUBJECT_PRESENCE.MISSING)
       layerState.subjectMissing = true;
-    const nextLabel = resolveSubjectLabel(layerState.subject);
+    const tracked = trackedSubjectOf(layerState.subject);
+    const nextLabel = resolveSubjectLabel(layerState.subject, tracked);
     const labelChanged = nextLabel !== layerState.subject.label;
+    // The panel reads the photo from here, with the subject it belongs to.
+    const photo = resolveSubjectPhoto(layerState.subject, tracked);
+    layerState.subjectPhoto = photo
+      ? {
+          layerId: layerState.subject.layerId,
+          id: layerState.subject.id,
+          photo,
+        }
+      : null;
+    // A photo arriving after selection is render-worthy on its own, as a label.
+    const photoChanged =
+      (photo?.src ?? null) !== (layerState.panelView?.photo?.src ?? null);
     layerState.subject = { ...layerState.subject, position, label: nextLabel };
     const movementM = layerState.lastEvaluatedPosition
       ? Cesium.Cartesian3.distance(layerState.lastEvaluatedPosition, position)
@@ -439,7 +481,7 @@ export function createSubject({ state: layerState, services, parts, source }) {
       // kept the ICAO hex until unrelated movement, a source-revision bump, or
       // page rotation happened to repaint it. Gated on an ACTUAL change so the
       // common no-op refresh (every 750 ms) still costs no repaint.
-      if (labelChanged) parts.panel.renderResults();
+      if (labelChanged || photoChanged) parts.panel.renderResults();
       parts.rendering.scheduleDirectionOverlayUpdate(force);
       return;
     }
@@ -502,6 +544,7 @@ export function createSubject({ state: layerState, services, parts, source }) {
     militaryInstallationsLayer.setContextAnchor?.(null);
     layerState.autoFocusRetryPending = false;
     layerState.subject = null;
+    layerState.subjectPhoto = null;
     layerState.subjectMissing = false;
     layerState.results = null;
     layerState.navigationHistory = [];
@@ -528,6 +571,7 @@ export function createSubject({ state: layerState, services, parts, source }) {
     resolveSubjectPosition,
     collectionSubjectPosition,
     resolveSubjectLabel,
+    resolveSubjectPhoto,
     refreshSelectedSubject,
     subjectFromContext,
     markSubjectEvicted,
diff --git a/src/layers/flights/enrichment.js b/src/layers/flights/enrichment.js
index aaf8ceb38..1132c36c8 100644
--- a/src/layers/flights/enrichment.js
+++ b/src/layers/flights/enrichment.js
@@ -1,5 +1,6 @@
 import { classifyAircraft } from '../../data/aircraftClass.js';
 import { horizonOccluder } from '../../data/iconOrientation.js';
+import { parsePlanespottersPhoto } from '../../data/planespottersPhoto.js';
 import * as Cesium from 'cesium';
 import {
   ENRICH_MAX_INFLIGHT,
@@ -8,6 +9,7 @@ import {
   ENRICH_AMBIENT_REFILL_TOKENS,
   ENRICH_AMBIENT_REFILL_WINDOW_MS,
   ENRICH_AMBIENT_PER_SWEEP,
+  ENRICH_RETRY_COOLDOWN_MS,
 } from './policy.js';
 
 export function createEnrichment({
@@ -17,11 +19,62 @@ export function createEnrichment({
   layer,
   resolveAsset,
 }) {
-  function _enqueueEnrich(key, query, onData, priority = false) {
+  const { isMilitaryIcao } = services.militaryRegistry;
+  const { isTr3b } = services.aircraftPresentation;
+  /**
+   * Whether `key` is answered, queued, or cooling down after a failure. A
+   * key past its cool-down is released here so it can be asked again.
+   * @param {string} key Lookup key.
+   * @returns {boolean}
+   */
+  function _enrichHeld(key) {
+    if (flightState._enrichSeen.has(key)) return true;
+    const retryAfter = flightState._enrichRetryAfter.get(key);
+    if (retryAfter === undefined) return false;
+    if (Date.now() < retryAfter) return true;
+    flightState._enrichRetryAfter.delete(key);
+    return false;
+  }
+
+  /**
+   * Whether a source failure is permanent: an unsupported lookup, or an HTTP
+   * 4xx other than 401/403 (an authorization refusal that may clear), 408
+   * (timeout) and 429 (rate limited). Anything else, including an error without a
+   * status, is temporary.
+   * @param {*} error The rejection, as `LiveSourceError` / `httpError` carry it.
+   * @returns {boolean}
+   */
+  function _enrichFailureIsFinal(error) {
+    if (error?.code === 'unsupported') return true;
+    const status = Number(error?.status);
+    return (
+      Number.isInteger(status) &&
+      status >= 400 &&
+      status < 500 &&
+      status !== 401 &&
+      status !== 403 &&
+      status !== 408 &&
+      status !== 429
+    );
+  }
+
+  /**
+   * Ask each key at most once per session, except that a lookup whose source
+   * failed temporarily (rejected or threw) may be asked again after
+   * ENRICH_RETRY_COOLDOWN_MS; an answer, found or not, and a permanent
+   * refusal (see _enrichFailureIsFinal) are final.
+   * @param {string} key Session-unique lookup key.
+   * @param {object} query The source's enrichment query.
+   * @param {function(object):void} onData Receives a `found` answer.
+   * @param {boolean} [priority] Front of the queue.
+   * @param {function(*):?object} [read] Reads the source's answer first, for
+   *   a lookup whose answer may arrive in more than one shape.
+   */
+  function _enqueueEnrich(key, query, onData, priority = false, read = null) {
     if (flightState.lifetime.signal.aborted) return;
-    if (flightState._enrichSeen.has(key)) return;
+    if (_enrichHeld(key)) return;
     flightState._enrichSeen.add(key);
-    const job = { query, onData };
+    const job = { key, query, onData, read };
     // Priority (tracked / model-eligible) goes to the FRONT so a deep ambient
     // backlog can never delay the plane the user just clicked or zoomed into.
     if (priority) flightState._enrichQueue.unshift(job);
@@ -61,9 +114,24 @@ export function createEnrichment({
             signal: lifetime.signal,
           });
         })
-        .then((data) => {
-          if (!lifetime.signal.aborted && data && data.found) job.onData(data);
-        })
+        .then(
+          (answer) => {
+            const data = job.read ? job.read(answer) : answer;
+            if (!lifetime.signal.aborted && data && data.found)
+              job.onData(data);
+          },
+          (error) => {
+            // The source failed: release the key after a cool-down. A layer
+            // teardown is not a failure and schedules nothing, and a
+            // permanent refusal is as final as an answer.
+            if (lifetime.signal.aborted || _enrichFailureIsFinal(error)) return;
+            flightState._enrichSeen.delete(job.key);
+            flightState._enrichRetryAfter.set(
+              job.key,
+              Date.now() + ENRICH_RETRY_COOLDOWN_MS,
+            );
+          },
+        )
         .catch(() => {
           /* enrichment never surfaces errors */
         })
@@ -119,6 +187,14 @@ export function createEnrichment({
       (data) => {
         const meta = flightState.records.data.get(icao24);
         if (!meta) return;
+        // A late answer for a callsign the plane no longer flies is dropped.
+        if (
+          String(meta.callsign || '')
+            .trim()
+            .toUpperCase() !== cs
+        )
+          return;
+        meta.routeCallsign = cs;
         meta.airline = data.airline || meta.airline;
         if (data.origin && data.destination)
           meta.route = { origin: data.origin, destination: data.destination };
@@ -129,6 +205,31 @@ export function createEnrichment({
     ); // route lookups only fire for the TRACKED plane — front of the queue
   }
 
+  /** The tracked plane's photo from Planespotters, asked once per hex at the
+   *  front of the queue like its route. A miss is final; a temporary failure
+   *  is asked again after the cool-down. A military aircraft or a converted
+   *  TR-3B is never looked up. The answer is read with
+   *  `parsePlanespottersPhoto` whatever shape the source returns (the upstream
+   *  answer, a server's cached shape, or an already-read photo), so only a
+   *  checked photo is ever stored. */
+  function _requestPhotoEnrichment(icao24) {
+    if (!/^[0-9a-f]{6}$/i.test(icao24)) return;
+    const id = icao24.toLowerCase();
+    if (isMilitaryIcao(id) || isTr3b(id)) return;
+    _enqueueEnrich(
+      `p:${id}`,
+      { kind: 'photo', id },
+      (data) => {
+        const meta = flightState.records.data.get(id);
+        if (!meta) return; // evicted while the lookup was in flight
+        const { src, width, height, photographer, link } = data;
+        meta.photo = { src, width, height, photographer, link };
+      },
+      true,
+      parsePlanespottersPhoto,
+    );
+  }
+
   /** QA seam: headless harnesses (scripts/qa-enrich-ambient.mjs) shrink the
    *  bucket knobs via window.__GEV_ENRICH_AMBIENT_QA = {ceil, refillTokens,
    *  windowMs} — they cannot wait out a real 5-minute window. Read lazily each
@@ -196,7 +297,9 @@ export function createEnrichment({
       );
       const cand = [];
       for (const [icao24, bb] of flightState._billboards) {
-        if (flightState._enrichSeen.has(`t:${icao24}`)) continue; // answered / queued / negative this session
+        // Answered, queued, negative this session, or cooling down after a
+        // failure: never spend a token on it.
+        if (_enrichHeld(`t:${icao24}`)) continue;
         if (!/^[0-9a-f]{6}$/i.test(icao24)) continue; // adsbdb keys are 6-char hex only
         if (flightState.records.data.get(icao24)?.onGround) continue; // ground traffic never spends ambient budget (click-to-enrich still works)
         if (!bb.position || !occluder.isPointVisible(bb.position)) continue; // beyond the limb
@@ -233,6 +336,7 @@ export function createEnrichment({
     _drainEnrich,
     _requestTypeEnrichment,
     _requestRouteEnrichment,
+    _requestPhotoEnrichment,
     _ambientBudgetKnobs,
     _refillAmbientBudget,
     _sweepAmbientEnrichment,
diff --git a/src/layers/flights/lifecycle.js b/src/layers/flights/lifecycle.js
index 0ca944647..87e3e356a 100644
--- a/src/layers/flights/lifecycle.js
+++ b/src/layers/flights/lifecycle.js
@@ -312,6 +312,7 @@ export function createLifecycle({
       flightState._displayFloorState.clear();
       flightState._enrichQueue.length = 0;
       flightState._enrichSeen.clear();
+      flightState._enrichRetryAfter.clear();
       if (flightState._enrichDripTimer) {
         clearTimeout(flightState._enrichDripTimer);
         flightState._enrichDripTimer = null;
diff --git a/src/layers/flights/ownership.test.mjs b/src/layers/flights/ownership.test.mjs
index 16c1a9cc6..9b0c1a606 100644
--- a/src/layers/flights/ownership.test.mjs
+++ b/src/layers/flights/ownership.test.mjs
@@ -4,6 +4,7 @@ import { createCivilFlightLayer } from './index.js';
 import { createFlightState } from './state.js';
 import { createEnrichment } from './enrichment.js';
 import { createTracking } from './tracking.js';
+import { LiveSourceError } from '../../sources/live/contract.js';
 
 function services() {
   const names = [
@@ -29,6 +30,14 @@ function services() {
   };
 }
 
+/** The services enrichment reads: which hexes are military or a TR-3B. */
+function enrichServices({ military = [], tr3b = [] } = {}) {
+  return {
+    militaryRegistry: { isMilitaryIcao: (id) => military.includes(id) },
+    aircraftPresentation: { isTr3b: (id) => tr3b.includes(id) },
+  };
+}
+
 test('constructing independent flight layers performs no source request and isolates selection', () => {
   let requests = 0;
   const source = {
@@ -90,7 +99,11 @@ test('aborted enrichment cannot write into a later lifecycle or decrement its ac
     },
   };
   const flightState = createFlightState({ source, services: services() });
-  const enrichment = createEnrichment({ flightState, services: {}, parts: {} });
+  const enrichment = createEnrichment({
+    flightState,
+    services: enrichServices(),
+    parts: {},
+  });
   let writes = 0;
   enrichment._enqueueEnrich(
     'test',
@@ -118,7 +131,11 @@ test('a synchronous enrichment failure stays bounded and releases its slot', asy
       },
     },
   });
-  const enrichment = createEnrichment({ flightState, services: {}, parts: {} });
+  const enrichment = createEnrichment({
+    flightState,
+    services: enrichServices(),
+    parts: {},
+  });
   assert.doesNotThrow(() =>
     enrichment._enqueueEnrich('test', {}, () => assert.fail()),
   );
@@ -146,3 +163,336 @@ test('voice context reads a track that rounds to north as 0°, not 360°', () =>
     '0°',
   );
 });
+
+test('the tracked plane’s photo is asked once per hex and lands on its record', async () => {
+  const queries = [];
+  let answer = {
+    found: true,
+    src: 'https://t.plnspttrs.net/33043/1745410_822dfe330c_280.jpg',
+    width: 420,
+    height: 280,
+    photographer: 'Jan Seler',
+    link: 'https://www.planespotters.net/photo/1745410/x?utm_source=api',
+  };
+  const flightState = createFlightState({
+    services: services(),
+    source: {
+      async getEnrichment(query) {
+        queries.push(query);
+        if (answer instanceof Error) throw answer;
+        return answer;
+      },
+    },
+  });
+  const enrichment = createEnrichment({
+    flightState,
+    services: enrichServices(),
+    parts: {},
+  });
+  flightState.records.data.set('a0f1bb', { callsign: 'AAL1' });
+  flightState._trackedIcao = 'a0f1bb';
+  flightState._trackedEntity = {};
+  enrichment._requestPhotoEnrichment('A0F1BB');
+  enrichment._requestPhotoEnrichment('a0f1bb');
+  await new Promise((done) => setImmediate(done));
+  assert.deepEqual(queries, [{ kind: 'photo', id: 'a0f1bb' }]);
+  assert.deepEqual(flightState.records.data.get('a0f1bb').photo, {
+    src: answer.src,
+    width: 420,
+    height: 280,
+    photographer: 'Jan Seler',
+    link: answer.link,
+  });
+
+  // A failure is not asked again within its cool-down.
+  answer = new Error('outage');
+  flightState.records.data.set('abc123', {});
+  enrichment._requestPhotoEnrichment('abc123');
+  await new Promise((done) => setTimeout(done, 300));
+  enrichment._requestPhotoEnrichment('abc123');
+  await new Promise((done) => setImmediate(done));
+  assert.equal(queries.length, 2);
+  assert.equal(flightState.records.data.get('abc123').photo, undefined);
+  enrichment._requestPhotoEnrichment('not-hex');
+  assert.equal(queries.length, 2);
+  flightState.lifetime.abort();
+});
+
+test('a military aircraft or a converted TR-3B is never looked up for a photo', async () => {
+  const queries = [];
+  const flightState = createFlightState({
+    services: services(),
+    source: {
+      async getEnrichment(query) {
+        queries.push(query);
+        return { found: false };
+      },
+    },
+  });
+  const enrichment = createEnrichment({
+    flightState,
+    services: enrichServices({ military: ['ae1234'], tr3b: ['a0f1bb'] }),
+    parts: {},
+  });
+  for (const id of ['ae1234', 'a0f1bb']) {
+    flightState.records.data.set(id, {});
+    enrichment._requestPhotoEnrichment(id);
+  }
+  enrichment._requestPhotoEnrichment('AE1234');
+  await new Promise((done) => setImmediate(done));
+  assert.deepEqual(queries, []);
+  assert.equal(flightState._enrichSeen.size, 0);
+  flightState.lifetime.abort();
+});
+
+test('a photo answer in the upstream shape or a server’s cached shape lands checked', async () => {
+  const SRC = 'https://t.plnspttrs.net/33043/1745410_822dfe330c_280.jpg';
+  const LINK = 'https://www.planespotters.net/photo/1745410/x?utm_source=api';
+  const answers = {
+    a0f1bb: {
+      photos: [
+        {
+          thumbnail_large: { src: SRC, size: { width: 420, height: 280 } },
+          link: LINK,
+          photographer: 'Jan Seler',
+        },
+      ],
+    },
+    abc123: {
+      found: true,
+      thumbnail: { src: SRC, width: 420, height: 280 },
+      photographer: 'Jan Seler',
+      link: LINK,
+    },
+    def456: {
+      found: true,
+      thumbnail: { src: 'https://evil.example/a.jpg', width: 1, height: 1 },
+      photographer: 'Jan Seler',
+      link: LINK,
+    },
+    fed789: { photos: [] },
+  };
+  const flightState = createFlightState({
+    services: services(),
+    source: { getEnrichment: async ({ id }) => answers[id] },
+  });
+  const enrichment = createEnrichment({
+    flightState,
+    services: enrichServices(),
+    parts: {},
+  });
+  const ids = Object.keys(answers);
+  for (const id of ids) flightState.records.data.set(id, {});
+  for (const id of ids) {
+    enrichment._requestPhotoEnrichment(id);
+    // One dispatch per drip gap.
+    await new Promise((done) => setTimeout(done, 250));
+  }
+  const photo = {
+    src: SRC,
+    width: 420,
+    height: 280,
+    photographer: 'Jan Seler',
+    link: LINK,
+  };
+  assert.deepEqual(flightState.records.data.get('a0f1bb').photo, photo);
+  assert.deepEqual(flightState.records.data.get('abc123').photo, photo);
+  assert.equal(flightState.records.data.get('def456').photo, undefined);
+  assert.equal(flightState.records.data.get('fed789').photo, undefined);
+  flightState.lifetime.abort();
+});
+
+/** An enrichment queue over `answer(query)` with a hand-driven clock. */
+function enrichmentClock(t, answer) {
+  let now = 1_000_000;
+  t.mock.method(Date, 'now', () => now);
+  const queries = [];
+  const flightState = createFlightState({
+    services: services(),
+    source: {
+      getEnrichment(query) {
+        queries.push(query.id);
+        return answer(query);
+      },
+    },
+  });
+  const enrichment = createEnrichment({
+    flightState,
+    services: enrichServices(),
+    parts: { tracking: { _updateTrackedLabelModel() {} } },
+  });
+  const settle = () => new Promise((done) => setImmediate(done));
+  const advance = (ms) => {
+    now += ms;
+  };
+  return { flightState, enrichment, queries, settle, advance };
+}
+
+test('a failed lookup is asked again only after its cool-down', async (t) => {
+  let fail = true;
+  const { flightState, enrichment, queries, settle, advance } = enrichmentClock(
+    t,
+    async () => {
+      if (fail) throw new Error('503');
+      return { found: true, typeCode: 'A321' };
+    },
+  );
+  flightState.records.data.set('a0f1bb', {});
+  enrichment._requestTypeEnrichment('a0f1bb');
+  await settle();
+  assert.deepEqual(queries, ['a0f1bb']);
+  advance(59_000);
+  enrichment._requestTypeEnrichment('a0f1bb');
+  await settle();
+  assert.deepEqual(queries, ['a0f1bb'], 'not within the cool-down');
+  fail = false;
+  advance(1_000);
+  enrichment._requestTypeEnrichment('a0f1bb');
+  await settle();
+  assert.deepEqual(queries, ['a0f1bb', 'a0f1bb'], 'asked again after it');
+  assert.equal(flightState.records.data.get('a0f1bb').typeCode, 'A321');
+  advance(120_000);
+  enrichment._requestTypeEnrichment('a0f1bb');
+  await settle();
+  assert.equal(queries.length, 2, 'an answer is final');
+  assert.equal(flightState._enrichActive, 0);
+  flightState.lifetime.abort();
+});
+
+test('a synchronous source failure cools down like a rejected one', async (t) => {
+  const { flightState, enrichment, queries, settle, advance } = enrichmentClock(
+    t,
+    () => {
+      throw new Error('boom');
+    },
+  );
+  enrichment._requestPhotoEnrichment('a0f1bb');
+  await settle();
+  advance(60_000);
+  enrichment._requestPhotoEnrichment('a0f1bb');
+  await settle();
+  assert.deepEqual(queries, ['a0f1bb', 'a0f1bb']);
+  flightState.lifetime.abort();
+});
+
+test('a "not found" answer is never asked again', async (t) => {
+  const { flightState, enrichment, queries, settle, advance } = enrichmentClock(
+    t,
+    async ({ kind }) => (kind === 'photo' ? { photos: [] } : { found: false }),
+  );
+  enrichment._requestTypeEnrichment('a0f1bb');
+  await settle();
+  advance(1_000); // past the dispatch drip
+  enrichment._requestPhotoEnrichment('a0f1bb');
+  await settle();
+  assert.equal(queries.length, 2);
+  advance(3_600_000);
+  enrichment._requestTypeEnrichment('a0f1bb');
+  enrichment._requestPhotoEnrichment('a0f1bb');
+  await settle();
+  assert.equal(queries.length, 2);
+  assert.equal(flightState._enrichRetryAfter.size, 0);
+  flightState.lifetime.abort();
+});
+
+test('a lookup cut off by the layer’s teardown schedules no retry', async (t) => {
+  let release;
+  const { flightState, enrichment, settle } = enrichmentClock(
+    t,
+    (query) =>
+      new Promise((_resolve, reject) => {
+        release = () => reject(new DOMException('aborted', 'AbortError'));
+      }),
+  );
+  enrichment._requestTypeEnrichment('a0f1bb');
+  await settle();
+  flightState.lifetime.abort();
+  release();
+  await settle();
+  assert.equal(flightState._enrichRetryAfter.size, 0);
+  assert.equal(flightState._enrichSeen.has('t:a0f1bb'), true);
+});
+
+test('a permanent refusal is final; a timeout, rate limit, outage or authorization refusal cools down', async (t) => {
+  const errors = {
+    aaaaa1: new LiveSourceError('denied', 'adsbdb HTTP 404', { status: 404 }),
+    aaaaa2: new LiveSourceError('unsupported', 'Enrichment unavailable'),
+    aaaaa3: new LiveSourceError('limited', 'adsbdb rate limited', {
+      status: 429,
+    }),
+    aaaaa4: new LiveSourceError('unavailable', 'adsbdb HTTP 503', {
+      status: 503,
+    }),
+    aaaaa5: new LiveSourceError('unavailable', 'adsbdb HTTP 408', {
+      status: 408,
+    }),
+    aaaaa6: new Error('network'),
+    aaaaa7: new LiveSourceError('denied', 'Unauthorized', { status: 401 }),
+    aaaaa8: new LiveSourceError('denied', 'Forbidden', { status: 403 }),
+  };
+  const { flightState, enrichment, queries, settle, advance } = enrichmentClock(
+    t,
+    async ({ id }) => {
+      throw errors[id];
+    },
+  );
+  const ids = Object.keys(errors);
+  for (const id of ids) {
+    enrichment._requestTypeEnrichment(id);
+    await settle();
+    advance(1_000); // past the dispatch drip
+  }
+  assert.deepEqual(queries, ids);
+  advance(60_000);
+  for (const id of ids) {
+    enrichment._requestTypeEnrichment(id);
+    await settle();
+    advance(1_000);
+  }
+  assert.deepEqual(
+    queries.slice(ids.length),
+    ['aaaaa3', 'aaaaa4', 'aaaaa5', 'aaaaa6', 'aaaaa7', 'aaaaa8'],
+    'a 404 and an unsupported lookup are never asked again',
+  );
+  assert.equal(flightState._enrichSeen.has('t:aaaaa1'), true);
+  assert.equal(flightState._enrichRetryAfter.has('t:aaaaa1'), false);
+  flightState.lifetime.abort();
+});
+
+test('a route answer for a callsign the plane no longer flies is dropped', async (t) => {
+  const pending = [];
+  const { flightState, enrichment, settle, advance } = enrichmentClock(
+    t,
+    (query) => new Promise((resolve) => pending.push({ query, resolve })),
+  );
+  const meta = { callsign: 'UAL9' };
+  flightState.records.data.set('a0f1bb', meta);
+  enrichment._requestRouteEnrichment('a0f1bb');
+  await settle();
+  meta.callsign = 'UAL10'; // the next poll's callsign
+  advance(1_000);
+  enrichment._requestRouteEnrichment('a0f1bb');
+  await settle();
+  assert.deepEqual(
+    pending.map(({ query }) => query.id),
+    ['UAL9', 'UAL10'],
+  );
+  const route = (code) => ({
+    found: true,
+    airline: `${code} Air`,
+    origin: { code: `${code}O` },
+    destination: { code: `${code}D` },
+  });
+  pending[0].resolve(route('OLD'));
+  await settle();
+  assert.equal(meta.route, undefined, 'the late UAL9 answer is ignored');
+  assert.equal(meta.airline, undefined);
+  pending[1].resolve(route('NEW'));
+  await settle();
+  assert.deepEqual(meta.route, {
+    origin: { code: 'NEWO' },
+    destination: { code: 'NEWD' },
+  });
+  assert.equal(meta.routeCallsign, 'UAL10');
+  flightState.lifetime.abort();
+});
diff --git a/src/layers/flights/policy.js b/src/layers/flights/policy.js
index 9f0e810bd..de44b806a 100644
--- a/src/layers/flights/policy.js
+++ b/src/layers/flights/policy.js
@@ -254,6 +254,11 @@ export const ENRICH_MAX_INFLIGHT = 4;
 
 export const ENRICH_DISPATCH_GAP_MS = 200;
 
+/** A lookup whose source failed (an outage, a timeout, a restarting server) may
+ *  be asked again after this long; a real "not found" answer never is. */
+
+export const ENRICH_RETRY_COOLDOWN_MS = 60_000;
+
 // ---------------------------------------------------------------------------
 // Ambient fleet type enrichment (2026-07-02 field data: OpenSky's live
 // category field is 0/"no info" for ~94% of planes, so ambient classification
diff --git a/src/layers/flights/queries.js b/src/layers/flights/queries.js
index 89b91f125..a696238dc 100644
--- a/src/layers/flights/queries.js
+++ b/src/layers/flights/queries.js
@@ -24,7 +24,8 @@ export function createQueries({
   layer,
   resolveAsset,
 }) {
-  const { tr3bTypeLabel, tr3bAircraftClass } = services.aircraftPresentation;
+  const { isTr3b, tr3bTypeLabel, tr3bAircraftClass } =
+    services.aircraftPresentation;
   const { formatFlightLevel } = services.labels;
   const { isMilitaryIcao } = services.militaryRegistry;
   const { applyTrackedCameraFrame } = services.camera;
@@ -208,6 +209,12 @@ export function createQueries({
               destination: { ...info.route.destination },
             }
           : null,
+      // The airframe's Planespotters photo for the Context panel; a military
+      // aircraft or a converted TR-3B (it would name the real one) shows none.
+      photo:
+        info?.photo && !isTr3b(icao24) && !isMilitaryIcao(icao24)
+          ? { ...info.photo }
+          : null,
     };
   }
 
@@ -875,8 +882,9 @@ export function createQueries({
 
     /**
      * Describe the currently tracked aircraft at its dead-reckoned position.
-     * @returns {{icao24: string, callsign: string|null, latitude: number, longitude: number, altitudeM: number, velocityMps: number|null, track: number|null, verticalRateMps: number|null}|null}
-     *   Tracked aircraft info, or null when nothing is tracked.
+     * @returns {{icao24: string, callsign: string|null, latitude: number, longitude: number, altitudeM: number, velocityMps: number|null, track: number|null, verticalRateMps: number|null, photo: {src: string, width: number|null, height: number|null, photographer: string, link: string}|null}|null}
+     *   Tracked aircraft info, or null when nothing is tracked. `photo` is the
+     *   airframe's credited Planespotters photo, or null.
      */
     getTrackedInfo() {
       if (!flightState._trackedIcao) return null;
@@ -906,6 +914,8 @@ export function createQueries({
           _toCleanText(described.registration) ||
           described.icao24,
         position: Cesium.Cartesian3.clone(described.position),
+        // The airframe's photo for the Context panel, or null.
+        photo: described.photo,
       };
     },
 
diff --git a/src/layers/flights/records.js b/src/layers/flights/records.js
index 709cd69ed..fdd2d67c8 100644
--- a/src/layers/flights/records.js
+++ b/src/layers/flights/records.js
@@ -198,10 +198,16 @@ export class FlightRecords {
       !!prevMeta && (prevMeta.onGround === true) !== onGround;
     // Store flight metadata for click-to-track labels
     const cat = stickyNumber(category, prevMeta?.category, null);
+    const nextCallsign = stickyText(callsign, prevMeta?.callsign);
+    // A route (and its airline) belongs to the callsign it was looked up for;
+    // a new callsign drops it, so an old flight's route never shows under it.
+    const routeHeld =
+      Boolean(prevMeta?.routeCallsign) &&
+      prevMeta.routeCallsign === nextCallsign.toUpperCase();
     const meta = {
       sourceReference: observation.reference,
       observedReceiptMs: Date.now(),
-      callsign: stickyText(callsign, prevMeta?.callsign),
+      callsign: nextCallsign,
       altitude: alt,
       // geoAltitudeM/renderAltitudeM are ADDITIVE fields alongside the
       // untouched aviation `altitude` — never rename/replace it (labels,
@@ -256,8 +262,11 @@ export class FlightRecords {
       typeCode: prevMeta?.typeCode ?? null,
       typeName: prevMeta?.typeName ?? null,
       registration: prevMeta?.registration ?? null,
-      airline: prevMeta?.airline ?? null,
-      route: prevMeta?.route ?? null,
+      airline: routeHeld ? (prevMeta.airline ?? null) : null,
+      route: routeHeld ? (prevMeta.route ?? null) : null,
+      routeCallsign: routeHeld ? prevMeta.routeCallsign : null,
+      // Planespotters photo of the tracked airframe (Core asks it directly).
+      photo: prevMeta?.photo ?? null,
       // The RAW poll fix lat/lon (this tick's OpenSky state-vector
       // coords, pre-dead-reckon) — kept distinct from the continuously
       // dead-reckoned billboard position for any consumer that needs the
diff --git a/src/layers/flights/records.test.mjs b/src/layers/flights/records.test.mjs
index 638c6f843..f74574e96 100644
--- a/src/layers/flights/records.test.mjs
+++ b/src/layers/flights/records.test.mjs
@@ -39,6 +39,7 @@ test('civil records keep aviation units separate from render height and survive
   assert.equal(first.meta.renderAltitudeM, 1040);
   assert.equal(first.fixEpochMs, 1700000000000);
   first.meta.typeCode = 'B738';
+  first.meta.photo = { src: 'https://t.plnspttrs.net/1/2_280.jpg' };
   const second = store.receive(
     observation({
       callsign: '',
@@ -55,6 +56,7 @@ test('civil records keep aviation units separate from render height and survive
   assert.equal(second.meta.velocity, 120);
   assert.equal(second.meta.true_track, 90);
   assert.equal(second.meta.typeCode, 'B738');
+  assert.equal(second.meta.photo, first.meta.photo, 'the photo survives polls');
   assert.equal(Object.hasOwn(second.meta, 'cullPosition'), false);
   assert.deepEqual(JSON.parse(JSON.stringify(second.meta)), second.meta);
 });
@@ -140,3 +142,25 @@ test('civil emergency status follows the latest poll instead of sticking', () =>
   assert.equal(next.meta.squawk, '2000');
   assert.equal(next.meta.emergency, null);
 });
+
+test('a route belongs to its callsign: a new callsign drops it, a blank one keeps it', () => {
+  const store = records();
+  store.geoidReady = true;
+  const first = store.receive(observation({ callsign: 'UAL9' }), view());
+  first.meta.route = { origin: { code: 'AUS' }, destination: { code: 'DEN' } };
+  first.meta.airline = 'United';
+  first.meta.routeCallsign = 'UAL9';
+  const same = store.receive(observation({ callsign: 'UAL9 ' }), view());
+  assert.equal(same.meta.route, first.meta.route);
+  const blank = store.receive(observation({ callsign: '' }), view());
+  assert.equal(
+    blank.meta.route,
+    first.meta.route,
+    'a dropped callsign is sticky',
+  );
+  assert.equal(blank.meta.airline, 'United');
+  const next = store.receive(observation({ callsign: 'UAL10' }), view());
+  assert.equal(next.meta.route, null, 'the old route never shows under UAL10');
+  assert.equal(next.meta.airline, null);
+  assert.equal(next.meta.routeCallsign, null);
+});
diff --git a/src/layers/flights/snapshotRenderer.js b/src/layers/flights/snapshotRenderer.js
index d48d12774..414e6a0f6 100644
--- a/src/layers/flights/snapshotRenderer.js
+++ b/src/layers/flights/snapshotRenderer.js
@@ -230,6 +230,13 @@ export function createFlightSnapshotRenderer({
       // (position updates automatically via dead-reckoning CallbackProperty)
       if (isTracked && flightState._trackedEntity) {
         tracking._updateTrackedLabelModel(icao24);
+        // Re-ask the tracked plane's lookups each poll. Answered and queued
+        // keys return at once; a lookup whose source failed runs again once
+        // its cool-down has passed, and the route uses the callsign this
+        // snapshot just recorded.
+        enrichment._requestTypeEnrichment(icao24, true);
+        enrichment._requestRouteEnrichment(icao24);
+        enrichment._requestPhotoEnrichment(icao24);
       }
     }
 
diff --git a/src/layers/flights/state.js b/src/layers/flights/state.js
index c259c44f1..81b849f4b 100644
--- a/src/layers/flights/state.js
+++ b/src/layers/flights/state.js
@@ -342,6 +342,10 @@ export function createFlightState({ source, services }) {
 
   flightState._enrichSeen = new Set();
 
+  /** Lookup key -> epoch ms before which a failed lookup is not asked again. */
+
+  flightState._enrichRetryAfter = new Map();
+
   flightState._enrichAmbientBudget = ENRICH_AMBIENT_BUDGET_CEIL;
 
   /** Epoch ms the bucket last accounted a refill window from (0 = unset). */
diff --git a/src/layers/flights/testing.js b/src/layers/flights/testing.js
index ccb109ae1..60c5de10c 100644
--- a/src/layers/flights/testing.js
+++ b/src/layers/flights/testing.js
@@ -190,8 +190,20 @@ export function createTesting({
     );
   }
 
-  /** Exercise the exact asynchronous fleet loader and return its admitted model. */
+  /** Forget every enrichment lookup and the dispatch clock, so a test that
+   *  moved `Date.now` leaves no future-dated drip or cool-down behind. */
+  function _resetEnrichmentForTest() {
+    flightState._enrichQueue.length = 0;
+    flightState._enrichSeen.clear();
+    flightState._enrichRetryAfter.clear();
+    flightState._enrichLastDispatchMs = 0;
+    if (flightState._enrichDripTimer) {
+      clearTimeout(flightState._enrichDripTimer);
+      flightState._enrichDripTimer = null;
+    }
+  }
 
+  /** Exercise the exact asynchronous fleet loader and return its admitted model. */
   async function _ensureFleetModelForTest(icao24) {
     await parts.rendering._ensureModel(icao24);
     return flightState._models.get(icao24) || null;
@@ -212,5 +224,6 @@ export function createTesting({
     _trackedBillboardColorForTest,
     _driveFleetModelHandoffForTest,
     _ensureFleetModelForTest,
+    _resetEnrichmentForTest,
   };
 }
diff --git a/src/layers/flights/tracking.js b/src/layers/flights/tracking.js
index f81249e88..9fbde6a3f 100644
--- a/src/layers/flights/tracking.js
+++ b/src/layers/flights/tracking.js
@@ -1060,6 +1060,7 @@ export function createTracking({
     // starts one.
     parts.enrichment._requestTypeEnrichment(icao24, true); // tracked plane — front of the enrichment queue
     parts.enrichment._requestRouteEnrichment(icao24);
+    parts.enrichment._requestPhotoEnrichment(icao24);
     // Round 2 (owner): grounded contacts get trails too — a landed-but-taxiing
     // aircraft's history is retrievable on select. Grounded flights positions
     // are already surface-clamped (the surfaceM chain), so seeds/appends drape.
diff --git a/src/sources/live/contract.test.mjs b/src/sources/live/contract.test.mjs
index f42a00ec3..416b42a37 100644
--- a/src/sources/live/contract.test.mjs
+++ b/src/sources/live/contract.test.mjs
@@ -412,3 +412,77 @@ test('squawks are validated and omitted OpenSky status differs from an explicit
   assert.equal(quiet.squawk, null);
   assert.equal(quiet.emergency, null);
 });
+
+test('a photo enrichment asks Planespotters directly and returns the checked photo', async () => {
+  const requests = [];
+  const source = createFlightSource({
+    fetchImpl: async (url, init) => {
+      requests.push({ url, init });
+      return response({
+        photos: [
+          {
+            thumbnail_large: {
+              src: 'https://t.plnspttrs.net/33043/1745410_822dfe330c_280.jpg',
+              size: { width: 420, height: 280 },
+            },
+            link: 'https://www.planespotters.net/photo/1745410/x?utm_source=api',
+            photographer: 'Jan Seler',
+          },
+        ],
+      });
+    },
+  });
+  const signal = new AbortController().signal;
+  const photo = await source.getEnrichment(
+    { kind: 'photo', id: 'a0f1bb' },
+    { signal },
+  );
+  assert.equal(
+    requests[0].url,
+    'https://api.planespotters.net/pub/photos/hex/a0f1bb',
+  );
+  assert.ok(requests[0].init.signal, 'the request is cancellable');
+  assert.equal(requests[0].init.credentials, 'omit');
+  assert.deepEqual(photo, {
+    found: true,
+    src: 'https://t.plnspttrs.net/33043/1745410_822dfe330c_280.jpg',
+    width: 420,
+    height: 280,
+    photographer: 'Jan Seler',
+    link: 'https://www.planespotters.net/photo/1745410/x?utm_source=api',
+  });
+});
+
+test('a photo enrichment reads an empty answer as no photo and refuses a bad hex', async () => {
+  let calls = 0;
+  const source = createFlightSource({
+    fetchImpl: async (_url, _init) => {
+      calls++;
+      return response({ photos: [] });
+    },
+  });
+  assert.deepEqual(
+    await source.getEnrichment({ kind: 'photo', id: 'a0f1bb' }),
+    { found: false },
+  );
+  await assert.rejects(source.getEnrichment({ kind: 'photo', id: '../x' }), {
+    code: 'unsupported',
+  });
+  assert.equal(calls, 1);
+});
+
+test('a photo enrichment outage rejects without echoing the body', async () => {
+  for (const status of [403, 429, 502]) {
+    const source = createFlightSource({
+      fetchImpl: async () => response({ error: 'sensitive' }, {}, status),
+    });
+    await assert.rejects(
+      source.getEnrichment({ kind: 'photo', id: 'a0f1bb' }),
+      (error) => {
+        assert.equal(error.status, status);
+        assert.equal(error.message.includes('sensitive'), false);
+        return true;
+      },
+    );
+  }
+});
diff --git a/src/sources/live/standalone.js b/src/sources/live/standalone.js
index d76ecf3fa..b244266b0 100644
--- a/src/sources/live/standalone.js
+++ b/src/sources/live/standalone.js
@@ -11,10 +11,37 @@ import {
   readsbIdentities,
 } from './aircraft.js';
 import { normalizeVesselTrack, vesselSnapshot } from './vessels.js';
+import { parsePlanespottersPhoto } from '../../data/planespottersPhoto.js';
 
 const defaultFetch = (...args) => globalThis.fetch(...args);
 const header = (response, name) => response.headers?.get?.(name);
 
+/** Planespotters' public photo lookup, called straight from the browser (it
+ *  answers with `access-control-allow-origin: *`). */
+const PLANESPOTTERS_PHOTOS = 'https://api.planespotters.net/pub/photos/hex/';
+/** A photo is decoration: a slow answer gives up rather than hold an
+ *  enrichment slot. */
+const PHOTO_TIMEOUT_MS = 8000;
+
+/** The tracked plane's Planespotters photo, read and host-checked. */
+async function planespottersPhoto(fetchImpl, hex, signal) {
+  const id = String(hex || '').toLowerCase();
+  if (!/^[0-9a-f]{6}$/.test(id))
+    throw new LiveSourceError('unsupported', 'Enrichment unavailable');
+  const timeout = AbortSignal.timeout(PHOTO_TIMEOUT_MS);
+  const { response, payload } = await readResponse(
+    fetchImpl,
+    PLANESPOTTERS_PHOTOS + id,
+    {
+      signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+      credentials: 'omit',
+    },
+    'Planespotters',
+  );
+  if (!response.ok) throw httpError(response, 'Planespotters');
+  return parsePlanespottersPhoto(payload);
+}
+
 function openSkyError(response) {
   const error = httpError(response, 'Flights');
   const mode = String(
@@ -106,6 +133,8 @@ export function createFlightSource({
       };
     },
     async getEnrichment(query, { signal } = {}) {
+      if (query.kind === 'photo')
+        return planespottersPhoto(fetchImpl, query.id, signal);
       if (!['type', 'route'].includes(query.kind))
         throw new LiveSourceError('unsupported', 'Enrichment unavailable');
       const { response, payload } = await readResponse(
diff --git a/src/ui/awarenessPanel.test.mjs b/src/ui/awarenessPanel.test.mjs
index 101711c66..53cf0ad94 100644
--- a/src/ui/awarenessPanel.test.mjs
+++ b/src/ui/awarenessPanel.test.mjs
@@ -245,3 +245,73 @@ test('a repaint that leaves focus outside the panel does not pull it back', asyn
     'an empty cohort renders no list',
   );
 });
+
+const photo = (extra = {}) => ({
+  src: 'https://t.plnspttrs.net/1/abc123_280.jpg',
+  width: 280,
+  height: 186,
+  link: 'https://www.planespotters.net/photo/1/n123ab',
+  credit: 'Photo © Jane Doe',
+  ...extra,
+});
+
+test('a tracked flight’s photo shows under its name, credited and linked to its page', async (t) => {
+  const { panel, publish } = fixture(t);
+  await publish({ ...results(), photo: photo() });
+  const root = panel();
+  const link = root.querySelector('a.military-awareness-photo');
+  assert.ok(link, 'the photo renders');
+  assert.equal(
+    root.querySelector('.military-awareness-subject').nextElementSibling,
+    link,
+    'directly under the subject line',
+  );
+  assert.equal(link.getAttribute('href'), photo().link);
+  assert.equal(link.getAttribute('target'), '_blank');
+  assert.equal(link.getAttribute('rel'), 'noopener');
+  const img = link.querySelector('img');
+  assert.equal(img.getAttribute('src'), photo().src);
+  assert.equal(img.getAttribute('alt'), '');
+  assert.equal(img.getAttribute('width'), '280');
+  assert.equal(img.getAttribute('height'), '186');
+  assert.equal(link.querySelector('small').textContent, 'Photo © Jane Doe');
+});
+
+test('no photo renders without one', async (t) => {
+  const { panel, publish } = fixture(t);
+  await publish({ ...results(), photo: null });
+  assert.equal(panel().querySelector('.military-awareness-photo'), null);
+});
+
+test('a photo whose image fails to load is hidden until another arrives', async (t) => {
+  const { panel, publish } = fixture(t);
+  await publish({ ...results(), photo: photo() });
+  panel()
+    .querySelector('.military-awareness-photo img')
+    .dispatchEvent(new Event('error'));
+  await nextTick();
+  assert.equal(panel().querySelector('.military-awareness-photo'), null);
+  // A repaint with the same photo keeps it hidden.
+  await publish({ ...results({ previousDisabled: false }), photo: photo() });
+  assert.equal(panel().querySelector('.military-awareness-photo'), null);
+  // Another plane's photo shows.
+  const next = photo({ src: 'https://t.plnspttrs.net/2/def456_280.jpg' });
+  await publish({ ...results(), photo: next });
+  assert.equal(
+    panel().querySelector('.military-awareness-photo img').getAttribute('src'),
+    next.src,
+  );
+});
+
+test('a late error from a previous photo’s image does not hide the current one', async (t) => {
+  const { panel, publish } = fixture(t);
+  const previous = photo();
+  const current = photo({ src: 'https://t.plnspttrs.net/2/def456_280.jpg' });
+  await publish({ ...results(), photo: current });
+  // The error belongs to the image that failed: here, one still on the old src.
+  const img = panel().querySelector('.military-awareness-photo img');
+  img.setAttribute('src', previous.src);
+  img.dispatchEvent(new Event('error'));
+  await nextTick();
+  assert.ok(panel().querySelector('.military-awareness-photo'));
+});
diff --git a/src/ui/styles/radio.css b/src/ui/styles/radio.css
index 91611bf4a..e9af111f1 100644
--- a/src/ui/styles/radio.css
+++ b/src/ui/styles/radio.css
@@ -360,6 +360,31 @@ html:not([lang='en']) .radio-transport button {
   margin: 0 0 7px;
   color: #fff;
 }
+.military-awareness-photo {
+  display: block;
+  margin: 0 0 8px;
+  color: #a9b7c7;
+  text-decoration: none;
+}
+.military-awareness-photo img {
+  display: block;
+  width: 100%;
+  height: auto;
+  border: 1px solid rgba(98, 181, 255, 0.34);
+  border-radius: 4px;
+}
+.military-awareness-photo small {
+  display: block;
+  margin-top: 3px;
+}
+.military-awareness-photo:hover small,
+.military-awareness-photo:focus-visible small {
+  color: #fff;
+}
+.military-awareness-photo:focus-visible {
+  outline: 1px solid rgba(127, 200, 255, 0.85);
+  outline-offset: 2px;
+}
 .military-awareness-controls {
   display: grid;
   grid-template-columns: 1fr 1fr 1fr;
diff --git a/src/ui/views/panels/AwarenessPanel.vue b/src/ui/views/panels/AwarenessPanel.vue
index cb4fa7f62..7179cb251 100644
--- a/src/ui/views/panels/AwarenessPanel.vue
+++ b/src/ui/views/panels/AwarenessPanel.vue
@@ -11,6 +11,13 @@ import AwarenessNames from './AwarenessNames.vue';
 const { awareness: view, awarenessLayer: layer } = storeToRefs(useContextStore());
 const user = { origin: 'user' };
 const root = ref(null);
+// A photo whose image failed to load stays hidden until another one arrives.
+// The failing image's own src is recorded, so a late error from a previous
+// photo never hides the current one.
+const failedPhoto = ref('');
+const fail = (event) => {
+  failedPhoto.value = event.target.getAttribute('src');
+};
 
 // A live repaint keeps focus on the same control by identity: browsers drop
 // focus from a node Vue moves, removes or disables, so the control is found
@@ -52,6 +59,10 @@ onUpdated(() => {
     </div>
     <template v-else-if="view.kind === 'results'">
       <div class="military-awareness-subject">{{ view.subject }}</div>
+      <a v-if="view.photo && view.photo.src !== failedPhoto" class="military-awareness-photo" :href="view.photo.link" target="_blank" rel="noopener">
+        <img :src="view.photo.src" :width="view.photo.width ?? undefined" :height="view.photo.height ?? undefined" alt="" @error="fail" />
+        <small>{{ view.photo.credit }}</small>
+      </a>
       <AwarenessNames v-if="view.subjectNames" :names="view.subjectNames" />
       <div class="military-awareness-controls" role="group" :aria-label="view.navigation.label">
         <button type="button" data-awareness-action="previous" :title="view.navigation.previous.title" :disabled="view.navigation.previous.disabled" @click="layer?.navigatePrevious(user)">{{ view.navigation.previous.text }}</button>

From a904562f0fe75991821ec063d0f49225487299b6 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 9 Nov 2026 20:36:34 -0800
Subject: [PATCH 56/71] Changelog fragment for #1647

---
 changelog.d/1647-planespotters-photo.md | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 changelog.d/1647-planespotters-photo.md

diff --git a/changelog.d/1647-planespotters-photo.md b/changelog.d/1647-planespotters-photo.md
new file mode 100644
index 000000000..2ba4543fd
--- /dev/null
+++ b/changelog.d/1647-planespotters-photo.md
@@ -0,0 +1,6 @@
+- Show a photo of the tracked aircraft. Tracking a civil flight asks
+  Planespotters for that aircraft's photo, and the CONTEXT panel's CONTACTS view
+  shows it with the photographer's credit and a link to the photo's page. A
+  flight lookup (type, route or photo) that failed temporarily is now asked
+  again after a minute instead of staying empty for the session, and a callsign
+  change drops the previous callsign's route (Sameh Khamis, @samehkhamis, #1647).

From 0af33707da5788a27c5ce77ba3dac6aa1911834a Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Tue, 10 Nov 2026 13:58:48 +0400
Subject: [PATCH 57/71] fix(voice): restore the globe-rotation import a main
 merge dropped

The earlier main merge replaced `import { interruptGlobeRotation } from
'../cameraVerbs.js'` with the displayText import while keeping the
`interruptGlobeRotation('voice-zoom-intent')` call, so voice zoom actions
threw ReferenceError. The same merge replaced main's Overpass reservation
paragraph in docs/CURRENT-STATE.md; restore it next to the new text.
---
 docs/CURRENT-STATE.md   | 8 ++++++++
 src/voice/gevActions.js | 1 +
 2 files changed, 9 insertions(+)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 28f1daa01..cf9ed5fb6 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -129,6 +129,14 @@ search keeps a successful geocode, with no search or view-based region recovery.
 
 Manager-owned periodic network updates pause while the document is hidden. Returning to a visible tab runs one overdue update per enabled layer without overlapping an active refresh and restarts that layer's polling schedule from the return, so the next poll follows one interval later whether or not the catch-up update succeeds; explicit refresh requests remain available. Transit also defers camera-driven feed admission while hidden and rechecks coverage on return. Visibility listeners are released with their polling intervals.
 
+Overpass reserves each normalized query before its disk-cache lookup. The
+initial disk lookup, upstream quota admission, fetching and memory publication
+are coalesced under that reservation. A caller that joined a reservation
+rejected by another client's quota retries admission with its own quota.
+Stale fallback runs per response after the reservation is released, and disk
+writes finish asynchronously. Settled and rejected reservations are removed
+only while they still own their map entry.
+
 External ALPR tags, surveillance-tool display fields, voice context text and
 compact analyst strings collapse controls and whitespace before a final
 180-character cap (scene labels retain their 120-character cap). Empty ALPR
diff --git a/src/voice/gevActions.js b/src/voice/gevActions.js
index af350eb1d..0ad5d8def 100644
--- a/src/voice/gevActions.js
+++ b/src/voice/gevActions.js
@@ -1,3 +1,4 @@
+import { interruptGlobeRotation } from '../cameraVerbs.js';
 import { normalizeDisplayText } from '../data/displayText.js';
 import {
   layerSnapshot,

From 20d58cf8885dd77cb93b55f674d1f047226c3e21 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Tue, 10 Nov 2026 13:50:27 +0400
Subject: [PATCH 58/71] Report zero queued alpha for an entry the yield pass
 hid

getQueuedOverlayEntryAlpha now returns 0 for a yielding entry that
declutterYieldingEntries marked collisionHidden this frame. That pass runs
before custom lanes, so they no longer read full opacity for an entry that
will not paint.
---
 src/overlays/worldOverlay.js       |  8 ++++---
 src/overlays/worldOverlay.test.mjs | 37 ++++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/src/overlays/worldOverlay.js b/src/overlays/worldOverlay.js
index 71f4b849f..e0ca77038 100644
--- a/src/overlays/worldOverlay.js
+++ b/src/overlays/worldOverlay.js
@@ -1047,9 +1047,9 @@ export function getOverlayPaintRect(sourceId, entryId) {
 }
 
 /**
- * Opacity an entry paints with this frame, or 0 when it is not queued. Custom
- * lanes may call it before later lanes publish paint rects. Leaves out the
- * Cyber sonar fade and yield-collision hiding.
+ * Opacity an entry paints with this frame, or 0 when it is not queued or the
+ * yield-collision pass hid it. Custom lanes may call it before later lanes
+ * publish paint rects. Leaves out the Cyber sonar fade.
  * @param {string} sourceId
  * @param {string} entryId
  * @returns {number}
@@ -1059,6 +1059,8 @@ export function getQueuedOverlayEntryAlpha(sourceId, entryId) {
   const item = _queuedItemBySource.get(sourceId)?.get(entryId);
   // Pooled items are reassigned every frame: check the frame and the entry.
   if (!item || item.stamp !== _frameStamp) return 0;
+  // Declutter has already run when custom lanes call this.
+  if (item.collisionHidden) return 0;
   const record = item.record;
   if (record.entry.id !== entryId || record.entry.source !== sourceId) return 0;
   return (
diff --git a/src/overlays/worldOverlay.test.mjs b/src/overlays/worldOverlay.test.mjs
index 1b8223bbc..30dd021c2 100644
--- a/src/overlays/worldOverlay.test.mjs
+++ b/src/overlays/worldOverlay.test.mjs
@@ -1259,6 +1259,43 @@ test('a detection lane sees which cards this frame will paint before they publis
   env.cleanup();
 });
 
+test('a detection lane reads zero for a yielding entry the declutter pass hid this frame', () => {
+  // Declutter runs before custom lanes, so a yielding entry it hid must not
+  // report its full queued alpha to them.
+  const env = installMockEnvironment({ width: 400, height: 300, dpr: 1 });
+  initWorldOverlay(env.viewer);
+  const seen = [];
+  registerWorldOverlayPaintLane('detection', () => {
+    seen.push({
+      winner: getQueuedOverlayEntryAlpha('cards', 'ABOVE'),
+      yielder: getQueuedOverlayEntryAlpha('labels', 'YIELDER'),
+    });
+  }, { id: 'detection', active: true, target: 'detection' });
+  // Two cards take both vertical slots, so a vertical-only yielder has none.
+  const at = positionAtScreen(200, 150);
+  const card = (id, placement) => selectedEntry(id, {
+    position: at,
+    placement,
+    verticalOnly: true,
+    collisionGroup: 'shared-card',
+  });
+  setOverlayEntries('cards', [card('ABOVE', 'above'), card('BELOW', 'below')]);
+  setOverlayEntries('labels', [selectedEntry('YIELDER', {
+    position: at,
+    verticalOnly: true,
+    collisionGroup: 'yielding-label',
+    yieldToCollisionGroup: 'shared-card',
+  })]);
+
+  env.postRender.raise();
+  assert.ok(getOverlayPaintRect('cards', 'ABOVE'), 'the winner painted');
+  assert.equal(getOverlayPaintRect('labels', 'YIELDER'), null, 'the yielder was hidden');
+  assert.ok(seen[0].winner > 0, 'the winner reads its queued alpha');
+  assert.equal(seen[0].yielder, 0, 'the yielder hidden this frame reads zero');
+  destroyWorldOverlay();
+  env.cleanup();
+});
+
 test('custom-lane painter state is bracketed by host save/restore', () => {
   // A painter that leaks a clip or alpha must not corrupt later frames: the
   // host wraps every custom-lane painter in save/try/finally-restore. Pin the

From 1b010fe328e868c01d9f1f3d167bab319617b0ff Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Tue, 10 Nov 2026 14:31:28 +0400
Subject: [PATCH 59/71] fix(voice): keep transit route IDs out of display-text
 normalization

A follow-up analyst_query filters on the routeId it was handed back, so a
route ID with repeated spaces or over 180 characters must stay byte-for-byte
raw like the other canonical fields.
---
 src/voice/gevActions.js       |  1 +
 src/voice/gevActions.test.mjs | 26 ++++++++++++++++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/src/voice/gevActions.js b/src/voice/gevActions.js
index 0ad5d8def..617f51e02 100644
--- a/src/voice/gevActions.js
+++ b/src/voice/gevActions.js
@@ -5365,6 +5365,7 @@ const ANALYST_CANONICAL_FIELDS = new Set([
   'noradId',
   'registration',
   'callsign',
+  'routeId',
 ]);
 
 /**
diff --git a/src/voice/gevActions.test.mjs b/src/voice/gevActions.test.mjs
index e879dab60..802f20126 100644
--- a/src/voice/gevActions.test.mjs
+++ b/src/voice/gevActions.test.mjs
@@ -6600,6 +6600,32 @@ test('analyst_query keeps canonical IDs raw so numbered references still fly to
   }
 });
 
+test('analyst_query keeps transit route IDs raw so a follow-up filter still matches', async () => {
+  globalThis.window = globalThis.window || { clearTimeout, setTimeout, requestIdleCallback: null };
+  for (const routeId of ['Route  17', 'R'.repeat(181)]) {
+    const { viewer, styleManager } = createVoiceNavigationHarness();
+    const vehicles = [{ id: 'bus-1', routeId, lat: 30, lon: -97 }];
+    const transit = { getStats: () => ({ count: 1, lastUpdate: Date.now() }), getAnalystRecords: () => vehicles };
+    const runner = createActionRunner({
+      viewer, styleManager,
+      dataManager: {
+        layers: new Map([['transit', { module: transit }]]),
+        isEnabled: () => true,
+        getAll: () => [{ id: 'transit', name: 'transit', enabled: true, stats: transit.getStats() }],
+      },
+    });
+    const listed = await runner('analyst_query', { layers: ['transit'], scope: { kind: 'anywhere' }, limit: 1 });
+    assert.equal(listed.ok, true);
+    assert.equal(listed.items[0].routeId, routeId);
+    const followUp = await runner('analyst_query', {
+      followUp: true,
+      filters: [{ field: 'routeId', op: 'eq', value: listed.items[0].routeId }],
+    });
+    assert.equal(followUp.ok, true);
+    assert.equal(followUp.count, 1, 'the returned route ID matches the same vehicle');
+  }
+});
+
 test('set_panel_open accepts the Authoring name for the scene panel', async () => {
   const calls = [];
   const runner = createGevActionRunner({

From 12a56309919d07cf3ecb685a13358362980feda6 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Tue, 10 Nov 2026 15:34:32 +0400
Subject: [PATCH 60/71] docs: tighten the display-text notes

Name routeId among the canonical analyst IDs in CURRENT-STATE, say what the
changelog entry changes for users, and drop the comment that repeated the
canonical-field doc.
---
 changelog.d/1280-text-issue-fix.md |  4 +++-
 docs/CURRENT-STATE.md              | 17 +++++++----------
 src/data/displayText.js            |  2 +-
 src/voice/gevActions.js            | 10 ++++------
 4 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/changelog.d/1280-text-issue-fix.md b/changelog.d/1280-text-issue-fix.md
index d13f3f9cc..5e5474967 100644
--- a/changelog.d/1280-text-issue-fix.md
+++ b/changelog.d/1280-text-issue-fix.md
@@ -1 +1,3 @@
-- Bound untrusted display text at output boundaries (asturksever, #1280).
+- Keep outside text in voice and MCP tool results to one line of 180
+  characters: ALPR tags, station names and other display fields (asturksever,
+  #1280).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 809048675..7e2470098 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -137,16 +137,13 @@ Stale fallback runs per response after the reservation is released, and disk
 writes finish asynchronously. Settled and rejected reservations are removed
 only while they still own their map entry.
 
-External ALPR tags, surveillance-tool display fields, voice context text and
-compact analyst strings collapse controls and whitespace before a final
-180-character cap (scene labels retain their 120-character cap). Empty ALPR
-values remain null and Unicode text is preserved without splitting a surrogate
-pair. Only display fields are normalized: canonical analyst identifiers
-(`id`, `layerKey`, `icao24`, `mmsi`, `noradId`, `registration`, `callsign`)
-pass through unchanged, because bikeshare uses the raw station name as its ID
-and numbered voice references resolve by that key. These fields remain
-untrusted source data in structured tool output; text normalization does not
-establish trust or eliminate prompt injection.
+External ALPR tags, surveillance-tool fields, voice context text and compact
+analyst strings become one line of at most 180 characters (scene labels: 120).
+Empty ALPR values stay null, and the cap never splits a surrogate pair.
+Canonical analyst identifiers such as `id` and `routeId` stay unchanged, because
+voice follow-ups match on them and bikeshare uses the raw station name as its
+ID. The text is still untrusted: normalization does not prevent prompt
+injection.
 
 Terrain height requests accept at most 64 points, matching the browser service's
 existing batch size and one bounded upstream chunk. Larger requests return HTTP
diff --git a/src/data/displayText.js b/src/data/displayText.js
index 1138c4cc0..fd0fe4eba 100644
--- a/src/data/displayText.js
+++ b/src/data/displayText.js
@@ -1,4 +1,4 @@
-/** Bounded, single-line external display text; it remains untrusted source data. */
+/** One-line text capped at `maxLength` without splitting a surrogate pair. Still untrusted. */
 export function normalizeDisplayText(value, maxLength = 180) {
   if (value == null || typeof value === 'object' || typeof value === 'function')
     return '';
diff --git a/src/voice/gevActions.js b/src/voice/gevActions.js
index 617f51e02..2d9334bc8 100644
--- a/src/voice/gevActions.js
+++ b/src/voice/gevActions.js
@@ -5353,9 +5353,9 @@ const ANALYST_IDENTITY_FIELDS = Object.freeze([
 ]);
 
 /**
- * Analyst item keys that identify a record rather than describe it: the
- * referent registry, track_entity and locateLayerEntity match on them, so
- * display-text normalization must leave them byte-for-byte unchanged.
+ * Keys that identify an analyst record. The referent registry, track_entity,
+ * locateLayerEntity and follow-up filters match on them, so they skip
+ * display-text normalization.
  */
 const ANALYST_CANONICAL_FIELDS = new Set([
   'layerKey',
@@ -5405,9 +5405,7 @@ function compactAnalystItem(r) {
     } else compact[key] = r[key];
   }
   if (present(r.ageHours)) compact.ageHours = r.ageHours;
-  // Display text only: canonical keys are lookup identities (bikeshare uses
-  // the raw station name as its id), so the referent registry and
-  // locateLayerEntity must see them exactly as the layer reports them.
+  // Canonical keys stay raw: bikeshare's id is the raw station name.
   for (const key of Object.keys(compact)) {
     if (typeof compact[key] === 'string' && !ANALYST_CANONICAL_FIELDS.has(key))
       compact[key] = normalizeDisplayText(compact[key]);

From 353eebf224e13e216a2ed4c78e9d30214ad0a442 Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Tue, 10 Nov 2026 15:37:16 +0400
Subject: [PATCH 61/71] refactor(tools): normalize ALPR text once, in the
 records

Every camera find_alpr_cameras returns comes from the tile source, which builds
it through normalizeAlprNode, so the tags are already one line and capped.
Drop the second pass in the tool, its duplicate test and the boundary entry,
and the function check normalizeDisplayText never sees.
---
 scripts/package-boundaries.json         |  1 -
 src/data/displayText.js                 |  3 +--
 src/tools/queries/surveillance.js       | 11 ++++-----
 src/tools/queries/surveillance.test.mjs | 31 -------------------------
 4 files changed, 6 insertions(+), 40 deletions(-)

diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index 2aee3df36..9b9f880e5 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -5140,7 +5140,6 @@
       "src/i18n/marker.js",
       "src/tools/queries/imagery.js",
       "src/tools/queries/cables.js",
-      "src/data/displayText.js",
       "src/tools/queries/surveillance.js",
       "src/tools/queries/infrastructure.js",
       "src/tools/queries/events.js",
diff --git a/src/data/displayText.js b/src/data/displayText.js
index fd0fe4eba..d151d8af7 100644
--- a/src/data/displayText.js
+++ b/src/data/displayText.js
@@ -1,7 +1,6 @@
 /** One-line text capped at `maxLength` without splitting a surrogate pair. Still untrusted. */
 export function normalizeDisplayText(value, maxLength = 180) {
-  if (value == null || typeof value === 'object' || typeof value === 'function')
-    return '';
+  if (value == null || typeof value === 'object') return '';
   return String(value)
     .replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ')
     .replace(/\s+/g, ' ')
diff --git a/src/tools/queries/surveillance.js b/src/tools/queries/surveillance.js
index 4ddafabc2..06723007a 100644
--- a/src/tools/queries/surveillance.js
+++ b/src/tools/queries/surveillance.js
@@ -1,6 +1,5 @@
 /** Automated license plate reader cameras mapped in OpenStreetMap. */
 
-import { normalizeDisplayText } from '../../data/displayText.js';
 import { suggestView } from '../views.js';
 import { defineTool, ToolError } from '../catalog.js';
 import {
@@ -70,12 +69,12 @@ export const findAlprCameras = defineTool({
         id: camera.id,
         lat: round(point.lat, 6),
         lon: round(point.lon, 6),
-        operator: normalizeDisplayText(camera.operator) || null,
-        manufacturer: normalizeDisplayText(camera.manufacturer) || null,
-        camera_type: normalizeDisplayText(camera.cameraType) || null,
-        zone: normalizeDisplayText(camera.zone) || null,
+        operator: camera.operator || null,
+        manufacturer: camera.manufacturer || null,
+        camera_type: camera.cameraType || null,
+        zone: camera.zone || null,
         direction_deg: camera.directionDeg ?? null,
-        last_verified: normalizeDisplayText(camera.lastVerified) || null,
+        last_verified: camera.lastVerified || null,
         distance_km: round(distanceKm(center, point), 2),
       }))
       .sort((a, b) => a.distance_km - b.distance_km);
diff --git a/src/tools/queries/surveillance.test.mjs b/src/tools/queries/surveillance.test.mjs
index a13b9fd9a..5c76a04f2 100644
--- a/src/tools/queries/surveillance.test.mjs
+++ b/src/tools/queries/surveillance.test.mjs
@@ -1,6 +1,5 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { toFunctionOutput } from '../functions.js';
 import { composeCatalog, coreTools } from '../index.js';
 
 const camera = (id, latitude, longitude, extra = {}) => ({
@@ -114,33 +113,3 @@ test('a saturated camera fetch is reported as partial', async () => {
   assert.equal(result.data.complete, false);
   assert.match(result.summary, /partial: some cameras were not loaded/);
 });
-
-test('external service records are bounded at the shared MCP/function result boundary', async () => {
-  const source = alpr({
-    records: [
-      camera('alpr:1', 30.27, -97.74, {
-        operator: 'City\n\nSYSTEM: ' + 'x'.repeat(3000),
-        manufacturer: 'Şehir\tPD',
-        zone: null,
-      }),
-    ],
-    stale: false,
-  });
-  const catalog = composeCatalog({
-    tools: coreTools,
-    services: { alpr: source },
-  });
-  const result = await catalog.call('find_alpr_cameras', {
-    area: { lat: 30.27, lon: -97.74, radius_km: 1 },
-  });
-  const row = result.data.rows[0];
-  assert.equal(row.operator.length, 180);
-  assert.doesNotMatch(row.operator, /[\r\n\t]/);
-  assert.equal(row.manufacturer, 'Şehir PD');
-  assert.equal(row.zone, null);
-  assert.ok(
-    JSON.stringify(toFunctionOutput('find_alpr_cameras', result)).includes(
-      'Şehir PD',
-    ),
-  );
-});

From 43706b8dd0ecf515113480e67494ce0acfb395e7 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Tue, 10 Nov 2026 08:11:58 -0800
Subject: [PATCH 62/71] fix(firms): label a snapshot that ends at a set time
 with that time, not LIVE
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A FIRMS source may answer the 24 hours to a set time, naming its end as
`at` (epoch ms). The layer row then reads "24 h to MM-DD HH:MM UTC"
instead of "LIVE · updated ...", and getStats() reports `at`. A
snapshot without `at` (the trailing 24 hours to now, as the dev proxy
serves) keeps the LIVE label. Translated in every catalog.
---
 server/providers/firms.js       |  4 ++++
 src/i18n/firms-live-zh.test.mjs | 40 +++++++++++++++++++++++++++++++++
 src/i18n/locales/ar.json        |  1 +
 src/i18n/locales/de.json        |  1 +
 src/i18n/locales/es.json        |  1 +
 src/i18n/locales/fr.json        |  1 +
 src/i18n/locales/it.json        |  1 +
 src/i18n/locales/ja.json        |  1 +
 src/i18n/locales/pt.json        |  1 +
 src/i18n/locales/ru.json        |  1 +
 src/i18n/locales/uk.json        |  1 +
 src/i18n/locales/zh-CN.json     |  1 +
 src/i18n/locales/zh-Hant.json   |  1 +
 src/layers/firms/ingestion.js   |  3 +++
 src/layers/firms/lifecycle.js   |  1 +
 src/layers/firms/queries.js     | 15 ++++++++++---
 src/layers/firms/state.js       |  2 ++
 17 files changed, 73 insertions(+), 3 deletions(-)

diff --git a/server/providers/firms.js b/server/providers/firms.js
index d21dc296e..0fe7f1cb5 100644
--- a/server/providers/firms.js
+++ b/server/providers/firms.js
@@ -145,6 +145,10 @@ export async function fetchFirms(
  *
  * Routes:
  *   GET /api/firms        → {fetchedAt, stale, ttlMs, sources, count, fires}
+ *
+ * The trailing 24 hours to now. A source may instead answer the 24 hours to
+ * a set time, naming its end as `at` (epoch ms); the layer's row then shows
+ * that time rather than LIVE. This proxy never sets `at`.
  *   GET /api/firms/status → {hasKey, lastFetch, count, stale, ttlMs, transactions}
  *
  * Keyless (no FIRMS_MAP_KEY): /api/firms → 503 {error:'no_key'}; status →
diff --git a/src/i18n/firms-live-zh.test.mjs b/src/i18n/firms-live-zh.test.mjs
index 03b3af6c8..04d22ec0d 100644
--- a/src/i18n/firms-live-zh.test.mjs
+++ b/src/i18n/firms-live-zh.test.mjs
@@ -43,3 +43,43 @@ for (const [age, zh, en, hant] of cases) {
     }
   });
 }
+
+test('a FIRMS snapshot that ends at a set time names it instead of LIVE', (context) => {
+  const now = 1800000000000;
+  context.mock.method(Date, 'now', () => now);
+  const previousLocale = getLocale();
+  const at = Date.UTC(2026, 9, 21, 15);
+  const layerState = {
+    _loading: false,
+    _stale: false,
+    _keyRequired: false,
+    _error: null,
+    _lastUpdate: now - 120000,
+    _at: at,
+    _count: 1,
+    _cellCount: 0,
+    _fires: [],
+  };
+  const model = createModel({ services: { anchors: {} } });
+  const { methods } = createQueries({
+    layerState,
+    components: { model },
+    config: {},
+  });
+  try {
+    setLocale('en');
+    assert.equal(methods.getStats().loadingLabel, '24 h to 10-21 15:00 UTC');
+    assert.equal(methods.getStats().at, at);
+    setLocale('de');
+    assert.equal(
+      methods.getStats().loadingLabel,
+      '24 Std. bis 21.10. 15:00 UTC',
+    );
+    layerState._at = null;
+    setLocale('en');
+    assert.equal(methods.getStats().loadingLabel, 'LIVE · updated 2m ago');
+    assert.equal(methods.getStats().at, null);
+  } finally {
+    setLocale(previousLocale);
+  }
+});
diff --git a/src/i18n/locales/ar.json b/src/i18n/locales/ar.json
index 59a18415f..20315a871 100644
--- a/src/i18n/locales/ar.json
+++ b/src/i18n/locales/ar.json
@@ -879,6 +879,7 @@
   "KEY REQUIRED": "المفتاح مطلوب",
   "STALE · cached {age}": "متقادم · مخزّن {age}",
   "LIVE · updated {age}": "مباشر · حُدّث {age}",
+  "24 h to {day} {time} UTC": "24 ساعة حتى {day} {time} UTC",
   "<1m ago": "قبل أقل من دقيقة",
   "FIRE · {frp} MW": "حريق · {frp} MW",
   "▲ {frp} MW": "▲ {frp} MW",
diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json
index 02d6fdb73..d4fbdf244 100644
--- a/src/i18n/locales/de.json
+++ b/src/i18n/locales/de.json
@@ -164,6 +164,7 @@
   "loading...": "lädt...",
   "KEY REQUIRED": "SCHLÜSSEL ERFORDERLICH",
   "LIVE · updated {age}": "LIVE · aktualisiert {age}",
+  "24 h to {day} {time} UTC": "24 Std. bis {day} {time} UTC",
   "loading mapped installation context": "Kontext der kartierten Anlage wird geladen",
   "MAPPED INSTALLATION": "KARTIERTE ANLAGE",
   "LAUNCH SITE · {site}": "STARTPLATZ · {site}",
diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json
index a007bec4e..e5d4d0689 100644
--- a/src/i18n/locales/es.json
+++ b/src/i18n/locales/es.json
@@ -737,6 +737,7 @@
   "KEY REQUIRED": "CLAVE REQUERIDA",
   "STALE · cached {age}": "DESACTUALIZADO · en caché hace {age}",
   "LIVE · updated {age}": "EN VIVO · actualizado {age}",
+  "24 h to {day} {time} UTC": "24 h hasta {day} {time} UTC",
   "<1m ago": "hace <1 min",
   "FIRE · {frp} MW": "INCENDIO · {frp} MW",
   "▲ {frp} MW": "▲ {frp} MW",
diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json
index f394eaf98..452d8bf04 100644
--- a/src/i18n/locales/fr.json
+++ b/src/i18n/locales/fr.json
@@ -734,6 +734,7 @@
   "loading...": "chargement…",
   "KEY REQUIRED": "CLÉ REQUISE",
   "LIVE · updated {age}": "DIRECT · mis à jour {age}",
+  "24 h to {day} {time} UTC": "24 h jusqu’au {day} {time} UTC",
   "Source snapshot time unavailable": "Heure de l'instantané source indisponible",
   "Live data unavailable": "Données en direct indisponibles",
   "Intel Picture": "Situation renseignement",
diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json
index 8122e2c47..227296b93 100644
--- a/src/i18n/locales/it.json
+++ b/src/i18n/locales/it.json
@@ -734,6 +734,7 @@
   "loading...": "caricamento...",
   "KEY REQUIRED": "CHIAVE RICHIESTA",
   "LIVE · updated {age}": "LIVE · aggiornato {age}",
+  "24 h to {day} {time} UTC": "24 h fino al {day} {time} UTC",
   "Source snapshot time unavailable": "Ora dello snapshot della fonte non disponibile",
   "Live data unavailable": "Dati live non disponibili",
   "Intel Picture": "Quadro intelligence",
diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json
index 9c716ec48..650869d13 100644
--- a/src/i18n/locales/ja.json
+++ b/src/i18n/locales/ja.json
@@ -716,6 +716,7 @@
   "loading...": "読込中…",
   "KEY REQUIRED": "キーが必要",
   "LIVE · updated {age}": "ライブ · 更新 {age}",
+  "24 h to {day} {time} UTC": "{day} {time} UTC までの24時間",
   "Source snapshot time unavailable": "ソースのスナップショット時刻を取得できません",
   "Live data unavailable": "ライブデータを利用できません",
   "Intel Picture": "情勢図",
diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json
index 1afd6d382..8545f38e8 100644
--- a/src/i18n/locales/pt.json
+++ b/src/i18n/locales/pt.json
@@ -732,6 +732,7 @@
   "loading...": "carregando...",
   "KEY REQUIRED": "CHAVE NECESSÁRIA",
   "LIVE · updated {age}": "AO VIVO · atualizado {age}",
+  "24 h to {day} {time} UTC": "24 h até {day} {time} UTC",
   "Source snapshot time unavailable": "Horário do snapshot da fonte indisponível",
   "Live data unavailable": "Dados ao vivo indisponíveis",
   "Intel Picture": "Panorama de inteligência",
diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json
index d6af529c0..4b3d2c9f5 100644
--- a/src/i18n/locales/ru.json
+++ b/src/i18n/locales/ru.json
@@ -147,6 +147,7 @@
   "loading...": "загрузка...",
   "KEY REQUIRED": "ТРЕБУЕТСЯ КЛЮЧ",
   "LIVE · updated {age}": "ОНЛАЙН · обновлено {age}",
+  "24 h to {day} {time} UTC": "24 ч до {day} {time} UTC",
   "Retrying mapped sites…": "Повторный запрос объектов…",
   "Fetching mapped sites…": "Загрузка объектов…",
   "Zoom in to search mapped installations": "Приблизьте, чтобы искать картографированные объекты",
diff --git a/src/i18n/locales/uk.json b/src/i18n/locales/uk.json
index 6826eb2fa..e5a26fd14 100644
--- a/src/i18n/locales/uk.json
+++ b/src/i18n/locales/uk.json
@@ -742,6 +742,7 @@
   "loading...": "завантаження...",
   "KEY REQUIRED": "ПОТРІБЕН КЛЮЧ",
   "LIVE · updated {age}": "ОНЛАЙН · оновлено {age}",
+  "24 h to {day} {time} UTC": "24 год до {day} {time} UTC",
   "Source snapshot time unavailable": "Час знімка джерела невідомий",
   "Live data unavailable": "Дані в реальному часі недоступні",
   "Intel Picture": "Розвідувальна обстановка",
diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json
index d0af7ee5e..707891bc2 100644
--- a/src/i18n/locales/zh-CN.json
+++ b/src/i18n/locales/zh-CN.json
@@ -716,6 +716,7 @@
   "loading...": "加载中…",
   "KEY REQUIRED": "需要密钥",
   "LIVE · updated {age}": "实时 · 更新于 {age}",
+  "24 h to {day} {time} UTC": "截至 {day} {time} UTC 的 24 小时",
   "Source snapshot time unavailable": "来源快照时间不可用",
   "Live data unavailable": "实时数据不可用",
   "Low-accuracy score < 2%": "低精度评分 < 2%",
diff --git a/src/i18n/locales/zh-Hant.json b/src/i18n/locales/zh-Hant.json
index c0e22141b..5deb177ed 100644
--- a/src/i18n/locales/zh-Hant.json
+++ b/src/i18n/locales/zh-Hant.json
@@ -711,6 +711,7 @@
   "loading...": "加載中…",
   "KEY REQUIRED": "需要密鑰",
   "LIVE · updated {age}": "實時 · 更新於 {age}",
+  "24 h to {day} {time} UTC": "截至 {day} {time} UTC 的 24 小時",
   "Source snapshot time unavailable": "來源快照時間不可用",
   "Live data unavailable": "實時數據不可用",
   "Low-accuracy score < 2%": "低精度評分 < 2%",
diff --git a/src/layers/firms/ingestion.js b/src/layers/firms/ingestion.js
index cb9dbd72f..dc3f64d9a 100644
--- a/src/layers/firms/ingestion.js
+++ b/src/layers/firms/ingestion.js
@@ -39,6 +39,9 @@ export function createIngestion({
       layerState._keyRequired = false;
       layerState._error = null;
       layerState._stale = Boolean(payload?.stale);
+      // A snapshot of the 24 hours to a set time names it; one of the
+      // trailing 24 hours to now does not.
+      layerState._at = Number.isFinite(payload?.at) ? payload.at : null;
       const previousSelection = layerState._selectedFire;
       layerState._selectedFire = null;
       layerState._allFires = adaptFirmsRecords(payload?.fires);
diff --git a/src/layers/firms/lifecycle.js b/src/layers/firms/lifecycle.js
index 90d9cc217..d106ed5ad 100644
--- a/src/layers/firms/lifecycle.js
+++ b/src/layers/firms/lifecycle.js
@@ -127,6 +127,7 @@ export function createLifecycle({
       layerState._rowControlsListener = null;
       layerState._cellCount = 0;
       layerState._lastUpdate = null;
+      layerState._at = null;
       layerState._keyRequired = false;
       layerState._stale = false;
       layerState._error = null;
diff --git a/src/layers/firms/queries.js b/src/layers/firms/queries.js
index 34040ea43..f2e5674e5 100644
--- a/src/layers/firms/queries.js
+++ b/src/layers/firms/queries.js
@@ -8,7 +8,7 @@ import {
   rampTrackGradient,
   sliderPositionForFrp,
 } from '../../data/firmsIntensity.js';
-import { formatNumber, t } from '../../i18n/index.js';
+import { formatNumber, formatUtcDayMonth, t } from '../../i18n/index.js';
 import { LOD_LEVELS, REFRESH_INTERVAL_MS } from './policy.js';
 
 /** Slider resolution: whole-percent positions along the log axis. */
@@ -190,8 +190,9 @@ export function createQueries({
      * Layer stats for the data panel. Degraded feed states surface through
      * `error` (established qa-failstate pattern: a dead feed must never look
      * like a healthy empty layer) with a matching human `loadingLabel`:
-     * 'LIVE · updated Xm ago' fresh, 'STALE · cached Xh' when the proxy
-     * served past-TTL cache, 'KEY REQUIRED' keyless.
+     * 'LIVE · updated Xm ago' fresh, '24 h to MM-DD HH:MM UTC' for a
+     * snapshot that ends at a set time (`at`), 'STALE · cached Xh' when the
+     * proxy served past-TTL cache, 'KEY REQUIRED' keyless.
      */
     getStats() {
       const now = Date.now();
@@ -213,6 +214,11 @@ export function createQueries({
         loadingLabel = staleText;
       } else if (layerState._error) {
         loadingLabel = layerState._error;
+      } else if (Number.isFinite(layerState._at)) {
+        loadingLabel = t('24 h to {day} {time} UTC', {
+          day: formatUtcDayMonth(layerState._at),
+          time: new Date(layerState._at).toISOString().slice(11, 16),
+        });
       } else if (layerState._lastUpdate) {
         loadingLabel = t('LIVE · updated {age}', {
           age: components.model.formatAgoMinutes(now - layerState._lastUpdate),
@@ -226,6 +232,9 @@ export function createQueries({
         lastUpdate: layerState._lastUpdate,
         loading: layerState._loading,
         stale: layerState._stale,
+        // The end of the 24 hours shown when the snapshot ends at a set time;
+        // null for the trailing 24 hours to now.
+        at: Number.isFinite(layerState._at) ? layerState._at : null,
         // The machine-readable half of the keyless state, ahead of the human
         // strings below: without it "no key configured" is indistinguishable
         // from a broken feed, and the row reads as a fault instead of a step
diff --git a/src/layers/firms/state.js b/src/layers/firms/state.js
index 0b96c53ea..8c34528ad 100644
--- a/src/layers/firms/state.js
+++ b/src/layers/firms/state.js
@@ -77,6 +77,8 @@ export function createFirmsState({ services, config }) {
 
   layerState._lastUpdate = null;
 
+  layerState._at = null;
+
   layerState._currentLodId = null;
 
   layerState._currentLodIndex = -1;

From 4ef0869a87f118605683bcbfdf37b817fb727a23 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Tue, 10 Nov 2026 08:19:40 -0800
Subject: [PATCH 63/71] fix(firms): drop LIVE from the row's source and the
 voice answer for a snapshot that ends at a set time
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The catalog source 'NASA FIRMS · LIVE' still led the row; getStats() now
names the source 'NASA FIRMS' for such a snapshot. get_active_fires says
"in the 24 hours to" its end and reports window_end. The end is checked
to be a printable time, cleared under KEY REQUIRED, the test moves next
to the layer, and the changelog and CURRENT-STATE describe it.
---
 changelog.d/1650-firms-window-label.md |  4 ++
 docs/CURRENT-STATE.md                  |  9 ++-
 server/providers/firms.js              |  9 +--
 src/i18n/firms-live-zh.test.mjs        | 40 -----------
 src/i18n/locales/fr.json               |  2 +-
 src/layers/firms/ingestion.js          |  7 +-
 src/layers/firms/queries.js            |  4 +-
 src/layers/firms/windowLabel.test.mjs  | 47 +++++++++++++
 src/tools/queries/hazards.js           |  9 ++-
 src/tools/queries/hazards.test.mjs     | 93 +++++++++++++++++++++++---
 10 files changed, 163 insertions(+), 61 deletions(-)
 create mode 100644 changelog.d/1650-firms-window-label.md
 create mode 100644 src/layers/firms/windowLabel.test.mjs

diff --git a/changelog.d/1650-firms-window-label.md b/changelog.d/1650-firms-window-label.md
new file mode 100644
index 000000000..47b1f8bdf
--- /dev/null
+++ b/changelog.d/1650-firms-window-label.md
@@ -0,0 +1,4 @@
+- A FIRMS snapshot that ends at a set time (`at`, epoch ms, from a source that
+  serves one) is no longer labelled live: the Active Fires row reads
+  `NASA FIRMS · 24 h to 10-21 15:00 UTC`, and `get_active_fires` says "in the
+  24 hours to" that time and reports it as `window_end` (samehkhamis, #1650).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 7e2470098..9c274434a 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -767,7 +767,7 @@ Consult the linked official advisory for safety decisions.
 
 Voice and HUD snapshots reuse the existing feedState classifier. Analyst follow-ups retain their original data provenance; current-view results append provenance without replacing legacy fields. HUD context and deterministic telemetry include non-nominal feed state.
 
-Analyst records come on demand from each layer's `getAnalystRecords`: flights, military, local ADS-B, vessels, satellites, launches, earthquakes, FIRMS (VIIRS and MODIS, with a `sensor` field), fire perimeters, cyclones, transit, bikeshare, ALPR cameras, mapped installations, datacenters and dams. `analyst_query` counts the whole loaded set (up to 250,000 records per layer; past that `coverage.records` reports `returned`, `total` and `truncated: true` and the result carries `complete: false`). Ranking keeps a top-k and scans in 20,000-row slices that yield to the page and stop when superseded. It refuses unknown fields, operators, units that do not convert (`altitudeM(ft)` converts), wrong-typed values, invalid centres, unknown scope kinds and sort fields with `code` and `allowed`, refuses a follow-up with no previous answer (`NO_RESULT_CONTEXT`) or naming other layers than that answer (`FOLLOW_UP_MISMATCH`), and tells `LAYER_OFF`, `NOT_READY` and `FEED_UNAVAILABLE` apart from a real zero; when only some layers can answer the result is `partial` with `unanswered` ids. The Contacts-window path applies the same filters, ranking and item shape to one immutable panel snapshot. Each aircraft layer retains at most 20,000 rows; reaching that bound sets `complete: false` and the spoken/card count becomes “At least”, never an exact claim. A superseded query never replaces follow-up memory, while sibling analyst calls from one assistant response do not cancel one another. Items carry `lat`/`lon`; the feed window (earthquakes and FIRMS: last 24 h), the precise scope and any caveat sit in `display`, which is on-screen detail rather than something the model recites. "In view" is still a radius around the view centre, not the visible footprint. Satellite distance is ground distance.
+Analyst records come on demand from each layer's `getAnalystRecords`: flights, military, local ADS-B, vessels, satellites, launches, earthquakes, FIRMS (VIIRS and MODIS, with a `sensor` field), fire perimeters, cyclones, transit, bikeshare, ALPR cameras, mapped installations, datacenters and dams. `analyst_query` counts the whole loaded set (up to 250,000 records per layer; past that `coverage.records` reports `returned`, `total` and `truncated: true` and the result carries `complete: false`). Ranking keeps a top-k and scans in 20,000-row slices that yield to the page and stop when superseded. It refuses unknown fields, operators, units that do not convert (`altitudeM(ft)` converts), wrong-typed values, invalid centres, unknown scope kinds and sort fields with `code` and `allowed`, refuses a follow-up with no previous answer (`NO_RESULT_CONTEXT`) or naming other layers than that answer (`FOLLOW_UP_MISMATCH`), and tells `LAYER_OFF`, `NOT_READY` and `FEED_UNAVAILABLE` apart from a real zero; when only some layers can answer the result is `partial` with `unanswered` ids. The Contacts-window path applies the same filters, ranking and item shape to one immutable panel snapshot. Each aircraft layer retains at most 20,000 rows; reaching that bound sets `complete: false` and the spoken/card count becomes “At least”, never an exact claim. A superseded query never replaces follow-up memory, while sibling analyst calls from one assistant response do not cancel one another. Items carry `lat`/`lon`; the feed window (earthquakes and FIRMS: last 24 h, or for FIRMS the 24 hours to a snapshot's `at`), the precise scope and any caveat sit in `display`, which is on-screen detail rather than something the model recites. "In view" is still a radius around the view centre, not the visible footprint. Satellite distance is ground distance.
 
 Keyless terrain tiles retry when Re:Earth throttles them. The browser fetches
 `terrain.reearth.land/cesium-mesh/ellipsoid/{z}/{x}/{y}.terrain` directly; no
@@ -2913,6 +2913,13 @@ reporting are unchanged.
 The FIRMS proxy requests VIIRS NOAA-20, VIIRS NOAA-21 and MODIS NRT (Terra and
 Aqua). It skips VIIRS Suomi NPP, which NASA stopped delivering on 2026-11-02.
 
+`/api/firms` answers the trailing 24 hours to now, and the Active Fires row
+reads `NASA FIRMS · LIVE · updated …`. A source may instead answer the 24 hours
+to a set time, naming its end as `at` (epoch ms): the row then reads
+`NASA FIRMS · 24 h to MM-DD HH:MM UTC`, `getStats()` reports `at`, and
+`get_active_fires` says "in the 24 hours to" that time and reports it as
+`window_end`. The dev proxy never sets `at`.
+
 The FIRMS CSV parser rejects impossible acquisition calendar dates before the proxy filters records to the trailing 24 hours, while retaining valid UTC acquisition times.
 The `get_active_fires` tool reports acquisition times as UTC ISO timestamps,
 including zero-padded hours and minutes; missing or invalid dates and times
diff --git a/server/providers/firms.js b/server/providers/firms.js
index 0fe7f1cb5..2b0e00944 100644
--- a/server/providers/firms.js
+++ b/server/providers/firms.js
@@ -145,15 +145,16 @@ export async function fetchFirms(
  *
  * Routes:
  *   GET /api/firms        → {fetchedAt, stale, ttlMs, sources, count, fires}
- *
- * The trailing 24 hours to now. A source may instead answer the 24 hours to
- * a set time, naming its end as `at` (epoch ms); the layer's row then shows
- * that time rather than LIVE. This proxy never sets `at`.
  *   GET /api/firms/status → {hasKey, lastFetch, count, stale, ttlMs, transactions}
  *
  * Keyless (no FIRMS_MAP_KEY): /api/firms → 503 {error:'no_key'}; status →
  * {hasKey:false}. Upstream is never touched without a key.
  *
+ * /api/firms answers the trailing 24 hours to now. A source may instead
+ * answer the 24 hours to a set time, naming its end as `at` (epoch ms); the
+ * layer's row then shows that time rather than LIVE. This proxy never sets
+ * `at`.
+ *
  * @returns {import('vite').Plugin}
  */
 export function firmsProxy() {
diff --git a/src/i18n/firms-live-zh.test.mjs b/src/i18n/firms-live-zh.test.mjs
index 04d22ec0d..03b3af6c8 100644
--- a/src/i18n/firms-live-zh.test.mjs
+++ b/src/i18n/firms-live-zh.test.mjs
@@ -43,43 +43,3 @@ for (const [age, zh, en, hant] of cases) {
     }
   });
 }
-
-test('a FIRMS snapshot that ends at a set time names it instead of LIVE', (context) => {
-  const now = 1800000000000;
-  context.mock.method(Date, 'now', () => now);
-  const previousLocale = getLocale();
-  const at = Date.UTC(2026, 9, 21, 15);
-  const layerState = {
-    _loading: false,
-    _stale: false,
-    _keyRequired: false,
-    _error: null,
-    _lastUpdate: now - 120000,
-    _at: at,
-    _count: 1,
-    _cellCount: 0,
-    _fires: [],
-  };
-  const model = createModel({ services: { anchors: {} } });
-  const { methods } = createQueries({
-    layerState,
-    components: { model },
-    config: {},
-  });
-  try {
-    setLocale('en');
-    assert.equal(methods.getStats().loadingLabel, '24 h to 10-21 15:00 UTC');
-    assert.equal(methods.getStats().at, at);
-    setLocale('de');
-    assert.equal(
-      methods.getStats().loadingLabel,
-      '24 Std. bis 21.10. 15:00 UTC',
-    );
-    layerState._at = null;
-    setLocale('en');
-    assert.equal(methods.getStats().loadingLabel, 'LIVE · updated 2m ago');
-    assert.equal(methods.getStats().at, null);
-  } finally {
-    setLocale(previousLocale);
-  }
-});
diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json
index 452d8bf04..b3857c8a6 100644
--- a/src/i18n/locales/fr.json
+++ b/src/i18n/locales/fr.json
@@ -734,7 +734,7 @@
   "loading...": "chargement…",
   "KEY REQUIRED": "CLÉ REQUISE",
   "LIVE · updated {age}": "DIRECT · mis à jour {age}",
-  "24 h to {day} {time} UTC": "24 h jusqu’au {day} {time} UTC",
+  "24 h to {day} {time} UTC": "24 h jusqu'au {day} {time} UTC",
   "Source snapshot time unavailable": "Heure de l'instantané source indisponible",
   "Live data unavailable": "Données en direct indisponibles",
   "Intel Picture": "Situation renseignement",
diff --git a/src/layers/firms/ingestion.js b/src/layers/firms/ingestion.js
index dc3f64d9a..d70d52d46 100644
--- a/src/layers/firms/ingestion.js
+++ b/src/layers/firms/ingestion.js
@@ -3,6 +3,10 @@ import { fireDetectionKey } from '../../data/firmsLabels.js';
 import { filterFires } from '../../data/firmsIntensity.js';
 import { msg } from '../../i18n/index.js';
 
+/** A time a Date can print: epoch ms within JavaScript's date range. */
+const isSnapshotEnd = (value) =>
+  Number.isFinite(value) && Math.abs(value) <= 8_640_000_000_000_000;
+
 export function createIngestion({
   layerState,
   services,
@@ -32,6 +36,7 @@ export function createIngestion({
         return;
       if (payload.keyRequired) {
         layerState._keyRequired = true;
+        layerState._at = null;
         layerState._error = null;
         layerState._stale = false;
         return;
@@ -41,7 +46,7 @@ export function createIngestion({
       layerState._stale = Boolean(payload?.stale);
       // A snapshot of the 24 hours to a set time names it; one of the
       // trailing 24 hours to now does not.
-      layerState._at = Number.isFinite(payload?.at) ? payload.at : null;
+      layerState._at = isSnapshotEnd(payload?.at) ? payload.at : null;
       const previousSelection = layerState._selectedFire;
       layerState._selectedFire = null;
       layerState._allFires = adaptFirmsRecords(payload?.fires);
diff --git a/src/layers/firms/queries.js b/src/layers/firms/queries.js
index f2e5674e5..c6cf70d4e 100644
--- a/src/layers/firms/queries.js
+++ b/src/layers/firms/queries.js
@@ -233,8 +233,10 @@ export function createQueries({
         loading: layerState._loading,
         stale: layerState._stale,
         // The end of the 24 hours shown when the snapshot ends at a set time;
-        // null for the trailing 24 hours to now.
+        // null for the trailing 24 hours to now. Such a snapshot is not live,
+        // so the row names the provider without the catalog's "LIVE".
         at: Number.isFinite(layerState._at) ? layerState._at : null,
+        ...(Number.isFinite(layerState._at) ? { source: 'NASA FIRMS' } : {}),
         // The machine-readable half of the keyless state, ahead of the human
         // strings below: without it "no key configured" is indistinguishable
         // from a broken feed, and the row reads as a fault instead of a step
diff --git a/src/layers/firms/windowLabel.test.mjs b/src/layers/firms/windowLabel.test.mjs
new file mode 100644
index 000000000..8113db14d
--- /dev/null
+++ b/src/layers/firms/windowLabel.test.mjs
@@ -0,0 +1,47 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { getLocale, setLocale } from '../../i18n/index.js';
+import { createModel } from './model.js';
+import { createQueries } from './queries.js';
+
+test('a FIRMS snapshot that ends at a set time names it instead of LIVE', (context) => {
+  const now = 1800000000000;
+  context.mock.method(Date, 'now', () => now);
+  const previousLocale = getLocale();
+  const at = Date.UTC(2026, 9, 21, 15);
+  const layerState = {
+    _loading: false,
+    _stale: false,
+    _keyRequired: false,
+    _error: null,
+    _lastUpdate: now - 120000,
+    _at: at,
+    _count: 1,
+    _cellCount: 0,
+    _fires: [],
+  };
+  const model = createModel({ services: { anchors: {} } });
+  const { methods } = createQueries({
+    layerState,
+    components: { model },
+    config: {},
+  });
+  try {
+    setLocale('en');
+    assert.equal(methods.getStats().loadingLabel, '24 h to 10-21 15:00 UTC');
+    assert.equal(methods.getStats().at, at);
+    assert.equal(methods.getStats().source, 'NASA FIRMS', 'the row drops LIVE');
+    setLocale('de');
+    assert.equal(
+      methods.getStats().loadingLabel,
+      '24 Std. bis 21.10. 15:00 UTC',
+    );
+    layerState._at = null;
+    setLocale('en');
+    assert.equal(methods.getStats().loadingLabel, 'LIVE · updated 2m ago');
+    assert.equal(methods.getStats().at, null);
+    assert.equal(methods.getStats().source, undefined);
+  } finally {
+    setLocale(previousLocale);
+  }
+});
diff --git a/src/tools/queries/hazards.js b/src/tools/queries/hazards.js
index e671db426..817b01ff5 100644
--- a/src/tools/queries/hazards.js
+++ b/src/tools/queries/hazards.js
@@ -94,7 +94,8 @@ export const getActiveFires = defineTool({
   name: 'get_active_fires',
   title: 'Active fires',
   description:
-    'Satellite fire detections from NASA FIRMS in the last 24 hours within an ' +
+    'Satellite fire detections from NASA FIRMS in the last 24 hours (or the 24 ' +
+    'hours to window_end, when the source names one) within an ' +
     'area, most intense (fire radiative power) first. Optionally limited to a ' +
     'minimum fire radiative power in megawatts and a confidence level — the ' +
     "same filter as the Active Fires layer's intensity controls.",
@@ -171,7 +172,10 @@ export const getActiveFires = defineTool({
       summary:
         `${countNoun(fires.length, 'fire detection')}` +
         (filterNotes.length ? ` (${filterNotes.join(', ')})` : '') +
-        ` in ${area.label} in the last 24 hours` +
+        ` in ${area.label} ` +
+        (Number.isFinite(snapshot.at)
+          ? `in the 24 hours to ${isoTime(snapshot.at)}`
+          : 'in the last 24 hours') +
         (notes.length ? ` (${notes.join('; ')}).` : '.'),
       data: {
         view: suggestView(services, { area, layers: ['local-firms'] }),
@@ -182,6 +186,7 @@ export const getActiveFires = defineTool({
         stale,
         missing_sources: missing,
         fetched_at: isoTime(snapshot.fetchedAt),
+        window_end: Number.isFinite(snapshot.at) ? isoTime(snapshot.at) : null,
         ...result,
         rows: result.rows.map((fire) => ({
           lat: fire.lat,
diff --git a/src/tools/queries/hazards.test.mjs b/src/tools/queries/hazards.test.mjs
index c1d3eb43a..1c1529bc3 100644
--- a/src/tools/queries/hazards.test.mjs
+++ b/src/tools/queries/hazards.test.mjs
@@ -46,29 +46,80 @@ test('fire acquisition timestamps preserve valid leap days and UTC times', async
 });
 
 const WEEK = [
-  { lat: 24.1, lon: 121.1, frp: 864, confidence: 'l', acqDate: '2026-10-01', acqTime: '0100' },
-  { lat: 24.2, lon: 121.2, frp: 120, confidence: 'h', acqDate: '2026-10-01', acqTime: '0100' },
-  { lat: 24.3, lon: 121.3, frp: 20, confidence: 'n', acqDate: '2026-10-01', acqTime: '0100' },
-  { lat: 24.4, lon: 121.4, frp: 2, confidence: 'h', acqDate: '2026-10-01', acqTime: '0100' },
-  { lat: 30, lon: 100, frp: 500, confidence: 'h', acqDate: '2026-10-01', acqTime: '0100' },
+  {
+    lat: 24.1,
+    lon: 121.1,
+    frp: 864,
+    confidence: 'l',
+    acqDate: '2026-10-01',
+    acqTime: '0100',
+  },
+  {
+    lat: 24.2,
+    lon: 121.2,
+    frp: 120,
+    confidence: 'h',
+    acqDate: '2026-10-01',
+    acqTime: '0100',
+  },
+  {
+    lat: 24.3,
+    lon: 121.3,
+    frp: 20,
+    confidence: 'n',
+    acqDate: '2026-10-01',
+    acqTime: '0100',
+  },
+  {
+    lat: 24.4,
+    lon: 121.4,
+    frp: 2,
+    confidence: 'h',
+    acqDate: '2026-10-01',
+    acqTime: '0100',
+  },
+  {
+    lat: 30,
+    lon: 100,
+    frp: 500,
+    confidence: 'h',
+    acqDate: '2026-10-01',
+    acqTime: '0100',
+  },
 ];
 const TAIWAN = { area: { bbox: [120, 23, 122, 25] } };
 
 test('get_active_fires shows every detection by default and reports the filter it used', async () => {
   const result = await catalogWith(WEEK).call('get_active_fires', TAIWAN);
-  assert.deepEqual(result.data.rows.map((row) => row.frp_mw), [864, 120, 20, 2]);
+  assert.deepEqual(
+    result.data.rows.map((row) => row.frp_mw),
+    [864, 120, 20, 2],
+  );
   assert.deepEqual(result.data.filter, { min_frp_mw: 0, confidence: 'all' });
   assert.match(result.summary, /^4 fire detections in /);
 });
 
 test('get_active_fires applies the same minimum-FRP and confidence filter as the layer', async () => {
   const catalog = catalogWith(WEEK);
-  const strong = await catalog.call('get_active_fires', { ...TAIWAN, min_frp_mw: 20 });
-  assert.deepEqual(strong.data.rows.map((row) => row.frp_mw), [864, 120, 20]);
+  const strong = await catalog.call('get_active_fires', {
+    ...TAIWAN,
+    min_frp_mw: 20,
+  });
+  assert.deepEqual(
+    strong.data.rows.map((row) => row.frp_mw),
+    [864, 120, 20],
+  );
   assert.match(strong.summary, /^3 fire detections \(≥ 20 MW\) in /);
 
-  const nominal = await catalog.call('get_active_fires', { ...TAIWAN, confidence: 'nominal' });
-  assert.deepEqual(nominal.data.rows.map((row) => row.frp_mw), [120, 20, 2], 'the 864 MW low-confidence fire drops');
+  const nominal = await catalog.call('get_active_fires', {
+    ...TAIWAN,
+    confidence: 'nominal',
+  });
+  assert.deepEqual(
+    nominal.data.rows.map((row) => row.frp_mw),
+    [120, 20, 2],
+    'the 864 MW low-confidence fire drops',
+  );
   assert.match(nominal.summary, /\(nominal or high confidence\)/);
 
   const both = await catalog.call('get_active_fires', {
@@ -76,7 +127,27 @@ test('get_active_fires applies the same minimum-FRP and confidence filter as the
     min_frp_mw: 19.6,
     confidence: 'high',
   });
-  assert.deepEqual(both.data.rows.map((row) => row.frp_mw), [120]);
+  assert.deepEqual(
+    both.data.rows.map((row) => row.frp_mw),
+    [120],
+  );
   assert.deepEqual(both.data.filter, { min_frp_mw: 20, confidence: 'high' });
   assert.match(both.summary, /\(≥ 20 MW, high confidence\)/);
 });
+
+test('get_active_fires names the end of a snapshot that ends at a set time', async () => {
+  const at = Date.UTC(2026, 9, 1, 3);
+  const catalog = composeCatalog({
+    tools: [getActiveFires],
+    services: { fires: { getSnapshot: async () => ({ fires: WEEK, at }) } },
+  });
+  const result = await catalog.call('get_active_fires', TAIWAN);
+  assert.match(
+    result.summary,
+    /in the 24 hours to 2026-10-01T03:00:00\.000Z\.$/,
+  );
+  assert.equal(result.data.window_end, '2026-10-01T03:00:00.000Z');
+  const now = await catalogWith(WEEK).call('get_active_fires', TAIWAN);
+  assert.match(now.summary, /in the last 24 hours\.$/);
+  assert.equal(now.data.window_end, null);
+});

From c9559955f024eabf2d1bf5adae933397ae34616d Mon Sep 17 00:00:00 2001
From: Mazeyar Moeini Feizabadi <mazy.moeini@gmail.com>
Date: Tue, 10 Nov 2026 17:57:37 +0100
Subject: [PATCH 64/71] ci: announce merged PRs in Discord

---
 .github/workflows/discord-merged-pr.yml | 40 +++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 .github/workflows/discord-merged-pr.yml

diff --git a/.github/workflows/discord-merged-pr.yml b/.github/workflows/discord-merged-pr.yml
new file mode 100644
index 000000000..5f927d893
--- /dev/null
+++ b/.github/workflows/discord-merged-pr.yml
@@ -0,0 +1,40 @@
+name: Announce merged PRs in Discord
+
+on:
+  pull_request_target:
+    types: [closed]
+
+permissions: {}
+
+jobs:
+  announce:
+    if: github.repository == 'bilawalsidhu/gods-eye-view' && github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+      # This uses the trusted base workflow and never checks out or runs PR code.
+      - name: Post to Discord contributions
+        shell: bash
+        env:
+          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_CONTRIBUTIONS_WEBHOOK_URL }}
+        run: |
+          if [[ ! "$DISCORD_WEBHOOK_URL" =~ ^https://discord\.com/api/webhooks/[0-9]+/[A-Za-z0-9_-]+$ ]]; then
+            echo '::error::Set DISCORD_CONTRIBUTIONS_WEBHOOK_URL to the Discord channel webhook URL.'
+            exit 1
+          fi
+
+          payload=$(jq -ce '
+            .pull_request | {
+              allowed_mentions: {parse: []},
+              embeds: [{
+                title: ("Merged #" + (.number | tostring) + ": " + (.title | .[0:115])),
+                url: .html_url,
+                footer: {text: ("By " + .user.login + " · into " + (.base.ref | .[0:100]))}
+              }]
+            }
+          ' "$GITHUB_EVENT_PATH")
+
+          curl --silent --show-error --fail --output /dev/null \
+            --connect-timeout 10 --max-time 20 --retry 3 --retry-max-time 50 \
+            --header 'Content-Type: application/json' --data-binary "$payload" \
+            --url "$DISCORD_WEBHOOK_URL?wait=true"

From 7571e42556d6c092800874bb5d4acd69318de03a Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Tue, 10 Nov 2026 21:23:28 +0400
Subject: [PATCH 65/71] i18n(he): apply the second translation review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- RECORD is «רשומה», a record rather than a recording.
- Time abbreviations end in the geresh again (דק׳, שנ׳, שע׳, ימ׳), and the
  counted forms agree with 1.
- Numbers after a Latin name, ordinals and units keep their order in RTL.
- Meaning, agreement and domain terms fixed across the catalog: cyclone
  advisories and storm centre, sensor swath, track-up, cinematic, tropical
  depression, pilot and sailing vessels, chips, metered billing, radio static,
  airspace, NOT AN ALL-CLEAR, and the remaining review items.
- LOOK and OFF-NADIR are translated; {value} KM stays Latin as an instrument
  readout, like KM/S.
- rtl.css shares the Arabic and Hebrew letter-spacing reset and drops the
  duplicated Arabic rules; he.md and its glossary follow the catalog.
---
 docs/translations/he.md       |   9 +-
 src/i18n/locales/he.json      | 626 +++++++++++++++++-----------------
 src/i18n/same-as-english.json |   4 +-
 src/ui/styles/rtl.css         |  35 +-
 4 files changed, 323 insertions(+), 351 deletions(-)

diff --git a/docs/translations/he.md b/docs/translations/he.md
index 44bb6f0c6..f6a7d1b14 100644
--- a/docs/translations/he.md
+++ b/docs/translations/he.md
@@ -6,8 +6,7 @@ Catalog: `src/i18n/locales/he.json`. General rules: [TRANSLATORS.md](../TRANSLAT
 
 - Address the user with a masculine imperative, Google style: הסתר, הצג, נסה שוב, התקרב. Menu items and tooltips take the noun form: הסרת {name}, הרחבת {name}, שינוי הצבע של {name}.
 - Sentence case: Hebrew has no case forms, so UPPERCASE English is normal sentence style here; short HUD labels stay short, favor an abbreviation over a wrapped line.
-- Keep the `·`, `—`, `→`, `↗`, `…` separators. Latin codes read inside RTL text because the app isolates interpolated values; leave them alone.
-- Units follow the catalog: ק"מ, מ׳, קמ"ש, שנ', דק', שע'. Instrument readouts and formatted shared-unit labels keep the Latin units (km, NM, FT, KTS, MW, KM/S); catalog prose outside those readouts keeps ק"מ/מ׳. Codes like HDG, FOV, CAL, SRC, REC stay exactly as in English — see `same-as-english.json`.
+- Units follow the catalog: ק"מ, מ׳, קמ"ש, שנ׳, דק׳, שע׳; an abbreviation always ends in the geresh (׳). Instrument readouts and formatted shared-unit labels keep the Latin units (km, NM, FT, KTS, MW, KM/S); catalog prose outside those readouts keeps ק"מ/מ׳. Codes like HDG, FOV, CAL, SRC, REC stay exactly as in English — see `same-as-english.json`.
 
 ## Digits and direction
 
@@ -46,20 +45,20 @@ With {count} shown as a digit, `two` and `other` share the plural noun (2 מצל
 | contact / tracking                             | מגע / עקיבה                                           |
 | installation / site                            | מתקן / אתר                                            |
 | camera / CCTV camera / ALPR camera             | מצלמה / מצלמת CCTV / מצלמת ALPR                       |
-| earthquake / active fire / cyclone             | רעידת אדמה / שרפה פעילה / ציקלון                      |
+| earthquake / active fire / cyclone             | רעידת אדמה / שריפה פעילה / ציקלון                     |
 | scene / shot                                   | סצנה / שוט                                            |
 | briefing / panel / dock                        | תדריך / פאנל / עגינה                                  |
 | visual preset / style                          | ערכת ראייה / סגנון                                   |
 | Scope (circular viewport mask) / keyhole       | סקופ / חור המנעול                                    |
 | heading (compass °) / course                   | כיוון / מהלך                                         |
 | HDG / BRG / CRS / FOV / DEST / SPD / RANGE     | בלי שינוי — קודי מכשיר                               |
-| advisory (NHC/CPHC cyclone)                    | ייעוץ; Advisory center — מרכז הייעוץ                  |
+| advisory (NHC/CPHC cyclone)                    | עדכון; Advisory center — מרכז הסערה לפי העדכון        |
 | Street View (Google)                           | Street View, בלי תרגום                                |
 | Street Level / Street Level layer              | Street Level, בלי תרגום (שם שכבה)                    |
 | WHOT/BHOT, Ironbow, CRT, NVG, FLIR             | בלי שינוי — קודים ושמות מצבים                        |
 | PREV / NEXT                                    | הקודם / הבא                                           |
 | anchor / data pack / asset bundle (scene)      | עוגן / חבילת נתונים / חבילת נכסים                   |
 | forecast (weather)                             | תחזית                                                 |
-| witness / geolocated source                    | עד ראייה / מקור נתון גיאוגרפית                        |
+| witness / geolocated source                    | עד ראייה / מקור מאוכן                                 |
 | contained (wildland fire) / FRP                | הכלה / FRP, בלי שינוי                                 |
 
diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json
index d614063b4..ff46a207e 100644
--- a/src/i18n/locales/he.json
+++ b/src/i18n/locales/he.json
@@ -12,7 +12,7 @@
   "Colour of {name}": "הצבע של {name}",
   "Hide {name}": "הסתרת {name}",
   "Show {name}": "הצגת {name}",
-  "Fly to {name}": "טוס אל {name}",
+  "Fly to {name}": "טיסה אל {name}",
   "Remove {name}": "הסרת {name}",
   "Pick a shape, then click the map.": "בחר צורה ואז לחץ על המפה.",
   "Enter to place the pin, Esc to cancel.": "Enter להצבת הסיכה, Esc לביטול.",
@@ -40,7 +40,7 @@
   "Loading the keyless globe...": "טוען גלובוס ללא מפתח...",
   "Google 3D Tiles unavailable ({detail}). Loading the keyless globe...": "Google 3D Tiles אינם זמינים ({detail}). טוען גלובוס ללא מפתח...",
   "Initializing systems...": "מאתחל מערכות...",
-  "Space Missions isolates replay data. Exit the mode to enable {layer}.": "משימות החלל מנתקות את נתוני ההשמעה החוזרת. צא מהמצב כדי להפעיל את {layer}.",
+  "Space Missions isolates replay data. Exit the mode to enable {layer}.": "מצב משימות החלל מבודד את נתוני ההצגה החוזרת. צא מהמצב כדי להפעיל את {layer}.",
   "Data attribution": "ייחוס נתונים",
   "Data provided by:": "הנתונים מסופקים על ידי:",
   "Close data attribution": "סגירת ייחוס הנתונים",
@@ -68,7 +68,7 @@
   "SOURCE CREDITED · LOCATION UNRESOLVED": "מקור מיוחס · מיקום לא הוכרע",
   "REFERENCE ONLY · CLAIMS UNVERIFIED": "לעיון בלבד · טענות לא אומתו",
   "SOURCE GEOCONFIRMED": "מקור אומת גיאוגרפית",
-  "2021 historical reference versus 2026 post-event imagery; changes are cumulative and include the July 2025 Rasuwagadhi flood. Schematic downstream progression, not modeled arrival time; not an official hazard model.": "מקור היסטורי של 2021 מול צילומי 2026 שאחרי האירוע; השינויים מצטברים וכוללים את השיטפון ב-Rasuwagadhi יולי 2025. ההתקדמות במורד הזרם סכמטית, אינה זמן הגעה ממודל; אינו מודל סיכונים רשמי.",
+  "2021 historical reference versus 2026 post-event imagery; changes are cumulative and include the July 2025 Rasuwagadhi flood. Schematic downstream progression, not modeled arrival time; not an official hazard model.": "תמונת ייחוס היסטורית מ-2021 מול צילומי 2026 שאחרי האירוע; השינויים מצטברים וכוללים את השיטפון ב-Rasuwagadhi ביולי 2025. ההתקדמות במורד הזרם סכמטית ואינה זמן הגעה ממודל; זה אינו מודל סיכונים רשמי.",
   "Immediate collapse viewpoint": "נקודת תצפית — הקריסה המיידית",
   "Collapse viewpoint": "נקודת תצפית — הקריסה",
   "Debris-dammed lake": "אגם סכור במפולת",
@@ -121,12 +121,12 @@
   "CONSEQUENCE": "תוצאה",
   "DOWNSTREAM CONSEQUENCE": "תוצאה במורד הזרם",
   "EVIDENCE": "ראיות",
-  "{year} HISTORICAL REFERENCE": "{year} מקור היסטורי",
+  "{year} HISTORICAL REFERENCE": "{year} ייחוס היסטורי",
   "{year} POST-EVENT": "{year} אחרי האירוע",
   "{count} GEOLOCATED SOURCE-MAP PLACEMENTS": {
-    "one": "{count} מיקום מקור נתון גיאוגרפית על המפה",
-    "two": "{count} מיקומי מקור נתונים גיאוגרפית על המפה",
-    "other": "{count} מיקומי מקור נתונים גיאוגרפית על המפה"
+    "one": "{count} מיקום מאוכן במפת המקורות",
+    "two": "{count} מיקומים מאוכנים במפת המקורות",
+    "other": "{count} מיקומים מאוכנים במפת המקורות"
   },
   "NO PREVIEW": "אין תצוגה מקדימה",
   "YouTube source": "מקור YouTube",
@@ -135,7 +135,7 @@
   "{publisher} / OPEN": "{publisher} / פתח",
   "▶ PLAY": "▶ נגן",
   "▶ PLAY SCENE": "▶ נגן סצנה",
-  "◉ CINEMATIC": "◉ קינמטי",
+  "◉ CINEMATIC": "◉ קולנועי",
   "↺ FULL STORY": "↺ הסיפור המלא",
   "Previous story beat": "קטע הסיפור הקודם",
   "Next story beat": "קטע הסיפור הבא",
@@ -145,15 +145,15 @@
   "CAPTURE TIME UNVERIFIED": "זמן הצילום לא אומת",
   "Rasuwagadhi witness": "עד Rasuwagadhi",
   "Open original source for {source}; capture time unverified": "פתיחת המקור המקורי של {source}; זמן הצילום לא אומת",
-  "Historical reference and post-event image divider": "מפריד בין תמונת המקור ההיסטורי לתמונה שאחרי האירוע",
-  "A historical reference {before} percent, B post-event {after} percent": "A מקור היסטורי {before} אחוזים, B אחרי האירוע {after} אחוזים",
+  "Historical reference and post-event image divider": "מפריד בין תמונת הייחוס ההיסטורית לתמונה שאחרי האירוע",
+  "A historical reference {before} percent, B post-event {after} percent": "A ייחוס היסטורי {before} אחוזים, B אחרי האירוע {after} אחוזים",
   "■ RELEASE CAMERA": "■ שחרר מצלמה",
   "Seek Nepal scene clock": "גרירה בשעון סצנת נפאל",
   "NEPAL SCENE CLOCK": "שעון סצנת נפאל",
   "… PLAYING SHOT": "… שוט בנגינה",
   "▶ PLAY SHOT": "▶ נגן שוט",
   "Ⅱ PAUSE": "Ⅱ השהה",
-  "↺ REPLAY CINEMATIC": "↺ נגן קינמטי שוב",
+  "↺ REPLAY CINEMATIC": "↺ נגן שוב במצב קולנועי",
   "↺ REPLAY": "↺ נגן שוב",
   "… PLAYING SCENE": "… סצנה בנגינה",
   "Continue {scene} from next shot": "המשך את {scene} מהשוט הבא",
@@ -166,7 +166,7 @@
     "two": "{count} מקורות",
     "other": "{count} מקורות"
   },
-  "OUTSIDE IMAGERY SWIPE": "החלקת צילומי חוץ",
+  "OUTSIDE IMAGERY SWIPE": "מחוץ להשוואת הצילומים",
   "{scene} / AUTHORED SHOT": "{scene} / שוט ידני",
   "NEPAL FLOOD INCIDENT": "אירוע השיטפון בנפאל",
   "Play {shot}": "נגן את {shot}",
@@ -190,12 +190,12 @@
   "CITIES": "ערים",
   "Keep the regional incident context and introduce nearby city labels": "שמירת ההקשר האזורי של האירוע והצגת תוויות ערים סמוכות",
   "PLACES": "מקומות",
-  "Introduce the reconstruction scene key places from trigger to downstream": "הצגת המקומות המרכזיים בסצנת השחזור, מהגורם ועד במורד הזרם",
+  "Introduce the reconstruction scene key places from trigger to downstream": "הצגת המקומות המרכזיים בסצנת השחזור, מהגורם ועד מורד הזרם",
   "PATH": "מסלול",
   "Animate the sourced cyan river-centerline route to Trishuli Bazaar": "הנפשת מסלול קו האמצע של הנהר בטורקיז עד Trishuli Bazaar, לפי המקורות",
   "OVERVIEW": "סקירה",
-  "Keep the completed flood path and location labels visible": "השארת מסלול השיטפון המושלם ותוויות המיקומים גלויים",
-  "RECORD": "הקלטה",
+  "Keep the completed flood path and location labels visible": "השארת מסלול השיטפון המלא ותוויות המיקומים גלויים",
+  "RECORD": "רשומה",
   "Reveal the trigger record while making a slow camera approach": "חשיפת רשומת הטריגר תוך התקרבות אטית של המצלמה",
   "{speed} kn": "{speed} kn",
   "That file is not valid JSON.": "הקובץ אינו JSON תקין.",
@@ -223,7 +223,7 @@
   "That file has an unreadable image or exceeds the 16-megapixel image limit.": "הקובץ מכיל תמונה שלא ניתן לקרוא או חורג ממגבלת 16 מגה-פיקסל.",
   "That KML could not be read.": "את ה-KML לא ניתן לקרוא.",
   "That file has invalid point coordinates.": "הקובץ מכיל קואורדינטות נקודה בלתי תקינות.",
-  "Ground heights are not available for that file. Try again when the map has loaded.": "גבהי הקרקע אינם זמינים עבור הקובץ הזה. נסה שוב אחרי שהמפה נטענת.",
+  "Ground heights are not available for that file. Try again when the map has loaded.": "גבהי הקרקע אינם זמינים עבור הקובץ הזה. נסה שוב אחרי שהמפה תיטען.",
   "That file took too long to read.": "קריאת הקובץ ארכה יותר מדי זמן.",
   "Nothing to import.": "אין מה לייבא.",
   "That file is larger than {size} MiB.": "הקובץ גדול מ-{size} MiB.",
@@ -240,9 +240,9 @@
   "Map tiles temporarily unavailable": "אריחי המפה אינם זמינים זמנית",
   "Mapped names temporarily unavailable": "שמות ממופים אינם זמינים זמנית",
   "Overpass temporarily unavailable": "Overpass אינו זמין זמנית",
-  "Retrying mapped sites…": "מנסה שוב אתרים ממופים…",
+  "Retrying mapped sites…": "מנסה שוב לטעון אתרים ממופים…",
   "Fetching mapped sites…": "שולף אתרים ממופים…",
-  "{reason} — retrying in {seconds}s": "{reason} — מנסה שוב בעוד {seconds} שנ",
+  "{reason} — retrying in {seconds}s": "{reason} — מנסה שוב בעוד {seconds} שנ׳",
   "{reason} — retry pending": "{reason} — ניסיון חוזר בתור",
   "Zoom in to search mapped installations": "התקרב כדי לחפש מתקנים ממופים",
   "Showing cached mapped sites": "מציג אתרים ממופים מהמטמון",
@@ -273,15 +273,15 @@
   "VISUAL": "ויזואלי",
   "Brightest naked-eye objects — CelesTrak visual group": "העצמים הבהירים ביותר לעין בלתי מזוינת — קבוצת הויזואל של CelesTrak",
   "COMMS": "תקשורת",
-  "Broadband constellation shell — shown only in DENSE mode": "מעטפת קונסטלציית פס רחב — מוצגת במצב DENSE בלבד",
+  "Broadband constellation shell — shown only in DENSE mode": "מעטפת קונסטלציית פס רחב — מוצגת במצב \"דחוס\" בלבד",
   "FISHING": "דיג",
   "TOWING": "גרירה",
   "DREDGER": "מחפר",
   "DIVE OPS": "פעולות צלילה",
   "MILITARY": "צבאי",
-  "SAILING": "שייט",
+  "SAILING": "מפרשית",
   "PLEASURE": "פנאי",
-  "PILOT": "נחייה",
+  "PILOT": "סירת נתב",
   "SAR": "SAR",
   "TUG": "גוררת",
   "PORT TENDER": "אוניית שירות נמל",
@@ -304,7 +304,7 @@
   "Starting live contacts…": "מתחיל מגעים חיים…",
   "Opening space missions…": "פותח משימות חלל…",
   "Scanning active events…": "סורק אירועים פעילים…",
-  "Live earthquakes and active fires, from USGS and NASA": "רעידות אדמה חיות ושרפות פעילות, מ-USGS ו-NASA",
+  "Live earthquakes and active fires, from USGS and NASA": "רעידות אדמה חיות ושריפות פעילות, מ-USGS ו-NASA",
   "It feels like a forbidden cockpit—then you realize the sources are public and the data is real.": "מרגיש כמו תא טייס אסור — ואז מבינים שהמקורות פומביים והנתונים אמיתיים.",
   "Working…": "מבצע…",
   "Could not open that mission{detail}. Retry or explore manually.": "לא ניתן לפתוח את המשימה הזאת{detail}. נסה שוב או חקור ידנית.",
@@ -332,7 +332,7 @@
   "FALLBACK": "חלופה",
   "view band|STREET": "רחוב",
   "view band|CITY": "עיר",
-  "view band|METRO": "מטרו",
+  "view band|METRO": "מטרופולין",
   "view band|REGIONAL": "אזורי",
   "view band|GLOBAL": "גלובלי",
   "AIS: --": "AIS: --",
@@ -374,13 +374,13 @@
   "{name} may only contain printable characters with no spaces": "{name} יכול להכיל רק תווים שניתנים להדפסה ללא רווחים",
   "{name} contains a character that is not valid in a key (#, quotes, $, \\, or backtick)": "{name} מכיל תו שאינו תקין במפתח (#, מירכאות, $, \\, או בק-טיק)",
   "{name} is configured outside Provider Settings and can only be changed where it was set": "{name} מוגדר מחוץ להגדרות הספקים וניתן לשינוי רק במקום שבו הוגדר",
-  "The key was not saved: could not restrict the credential file to your account; nothing was saved": "המפתח לא נשמר: לא הצליח להגביל את קובץ הפרטים לחשבון שלך; לא נשמר דבר",
+  "The key was not saved: could not restrict the credential file to your account; nothing was saved": "המפתח לא נשמר: לא ניתן היה להגביל את קובץ הפרטים לחשבון שלך; לא נשמר דבר",
   "The key was not saved: the existing configuration could not be read, so nothing was changed": "המפתח לא נשמר: לא ניתן לקרוא את התצורה הקיימת, ולכן לא נעשה שינוי",
-  "Could not write the {store} store": "לא ניתן לכתוב את מחסן {store}",
+  "Could not write the {store} store": "לא ניתן לכתוב אל {store}",
   "Save failed ({status}).": "השמירה נכשלה ({status}).",
   "OAuth check failed: {detail}": "בדיקת OAuth נכשלה: {detail}",
   "Could not check ChatGPT sign-in. Try again.": "לא ניתן לבדוק את ההתחברות ל-ChatGPT. נסה שוב.",
-  "Metered — a billing-enabled account": "מדוד — חשבון מופעל חיוב",
+  "Metered — a billing-enabled account": "בתשלום לפי שימוש — חשבון עם חיוב פעיל",
   "Optional paid token — public access works without one": "אסימון בתשלום אופציונלי — הגישה הציבורית עובדת בלעדיו",
   "Free key — register, paste, done": "מפתח חינמי — להירשם, להדביק, סיימת",
   "Project keys: {status}": "מפתחות פרויקט: {status}",
@@ -389,9 +389,9 @@
   "Saving…": "שומר…",
   "Save failed: {detail}": "השמירה נכשלה: {detail}",
   "Paste at least one key first.": "הדבק קודם מפתח אחד לפחות.",
-  "Saved to {store}. Restarting — this page reloads itself.": "נשמר ב-{store}. מאתחל — העמוד הזה יטען את עצמו.",
+  "Saved to {store}. Restarting — this page reloads itself.": "נשמר ב-{store}. מאתחל — העמוד הזה ייטען מחדש מעצמו.",
   "Remove this key from your saved configuration?": "להסיר את המפתח הזה מהתצורה השמורה שלך?",
-  "Removed from {store}. Restarting — this page reloads itself.": "הוסר מ-{store}. מאתחל — העמוד הזה יטען את עצמו.",
+  "Removed from {store}. Restarting — this page reloads itself.": "הוסר מ-{store}. מאתחל — העמוד הזה ייטען מחדש מעצמו.",
   "Cloud voice will use OPENAI_API_KEY on the next session.": "הקול בענן ישתמש ב-OPENAI_API_KEY בהפעלה הבאה.",
   "Checking local ChatGPT OAuth sign-in…": "בודק התחברות OAuth מקומית ל-ChatGPT…",
   "Could not check ChatGPT sign-in.": "לא ניתן לבדוק את ההתחברות ל-ChatGPT.",
@@ -407,12 +407,12 @@
   "Places context + Street View fallback; optional separate key": "הקשר מקומות + גיבוי Street View; מפתח נפרד אופציונלי",
   "Voice control — API key or ChatGPT OAuth": "שליטה קולית — מפתח API או OAuth של ChatGPT",
   "Gemini Live voice control": "שליטה קולית של Gemini Live",
-  "Live ships, worldwide": "אוניות חיים, בכל העולם",
-  "Live active-fire detections": "זיהויי שרפות חיים",
+  "Live ships, worldwide": "אוניות בזמן אמת, בכל העולם",
+  "Live active-fire detections": "זיהויי שריפות חיים",
   "Real live traffic (keyless runs a simulation)": "תנועה חיה אמיתית (ללא מפתח רצה סימולציה)",
-  "Bing imagery map stacks + world terrain": "ערמות מפות צילומים של Bing + טופוגרפיה עולמית",
-  "More flight-polling credits (anonymous works without)": "אשראי דגימת טיסות נוסף (אנונימי עובד בלעדיו)",
-  "Street-level imagery and coverage in the Street Level layer. Free: register an app in the Mapillary developer dashboard and paste its Client Token": "צילומי רחוב וכיסוי בשכבת Street Level. חינם: רשמו אפליקציה במרכז השליטה המפתחים של Mapillary והדביקו את ה-Client Token שלה",
+  "Bing imagery map stacks + world terrain": "ערכות מפות צילומים של Bing + טופוגרפיה עולמית",
+  "More flight-polling credits (anonymous works without)": "מכסת דגימת טיסות גדולה יותר (אנונימי עובד גם בלעדיה)",
+  "Street-level imagery and coverage in the Street Level layer. Free: register an app in the Mapillary developer dashboard and paste its Client Token": "צילומי רחוב וכיסוי בשכבת Street Level. חינם: רשום אפליקציה בלוח הבקרה למפתחים של Mapillary והדבק את ה-Client Token שלה",
   "Public space-missions access needs no key. Leave blank for standard use; paid tokens only raise request limits.": "הגישה הציבורית למשימות החלל אינה דורשת מפתח. השאר ריק לשימוש הרגיל; אסימונים בתשלום מעלים רק את מגבלות הבקשות.",
   "Air quality request failed": "בקשת איכות האוויר נכשלה",
   "No readings available": "אין מדידות זמינות",
@@ -439,7 +439,7 @@
   "Malformed AQHI observation response": "תשובת תצפיות AQHI פגומה",
   "Camera source temporarily unavailable": "מקור המצלמות אינו זמין זמנית",
   "Mapped camera locations": "מיקומי מצלמות ממופים",
-  "SHOW NEAREST": "הצג את הקרוב",
+  "SHOW NEAREST": "הצג את הקרובה",
   "Stop following the current object before navigating to a camera": "הפסק עקיבה אחר העצם הנוכחי לפני ניווט אל מצלמה",
   "Move to the nearest loaded camera and show its details": "מעבר אל המצלמה הקרובה שנטענה והצגת פרטיה",
   "Camera badges": "תגי מצלמות",
@@ -454,7 +454,7 @@
     "two": "{count} בקרבה",
     "other": "{count} בקרבה"
   },
-  "retrying mapped ALPR cameras": "מנסה שוב מצלמות ALPR ממופות",
+  "retrying mapped ALPR cameras": "מנסה שוב לטעון מצלמות ALPR ממופות",
   "loading mapped ALPR cameras": "טוען מצלמות ALPR ממופות",
   "No ALPR data for this area — US and Canada only": "אין נתוני ALPR לאזור הזה — ארה\"ב וקנדה בלבד",
   "Zoom in to load mapped cameras": "התקרב כדי לטעון מצלמות ממופות",
@@ -481,7 +481,7 @@
   "Next — nearest unvisited contact in the 250 km window": "הבא — המגע הקרוב ביותר שלא ביקרת בו בחלון של 250 ק\"מ",
   "Named areas ({n})": "אזורים בעלי שם ({n})",
   "{distance} FLIGHT / VESSEL WINDOW": "חלון טיסות / אוניות של {distance}",
-  "Open-source mapped/observed context. Missing broadcasts, unloaded map areas, or unmapped sites are not evidence of absence.": "הקשר ממופה/נצפה ממקורות פתוחים. שידורים חסרים, אזורי מפה שלא נטענו או אתרים שלא ממופו אינם הוכחה להיעדר.",
+  "Open-source mapped/observed context. Missing broadcasts, unloaded map areas, or unmapped sites are not evidence of absence.": "הקשר ממופה/נצפה ממקורות פתוחים. שידורים חסרים, אזורי מפה שלא נטענו או אתרים שלא מופו אינם הוכחה להיעדר.",
   "mapped matches within {km} km of the subject": "התאמות ממופות בטווח {km} ק\"מ מהעצם",
   "none mapped within {km} km; not a complete 250 km survey": "אין התאמות ממופות בטווח {km} ק\"מ; אינו מיפוי מלא של 250 ק\"מ",
   "mapped matches from the loaded viewport": "התאמות ממופות מתוך התצוגה שנטענה",
@@ -501,13 +501,13 @@
   "GBFS fetch error": "שגיאת אחזור GBFS",
   "Station {id}": "תחנה {id}",
   "Station": "תחנה",
-  "🚲 {bikes} avail · {docks} docks · {capacity} cap": "🚲 {bikes} זמינות · {docks} עמדות · {capacity} קיבולת",
+  "🚲 {bikes} avail · {docks} docks · {capacity} cap": "🚲 {bikes} זמינים · {docks} עמדות · {capacity} קיבולת",
   "⚠️ Not installed": "⚠️ לא מותקנת",
   "⚠️ Not renting": "⚠️ לא משכירה",
   "⚠️ Not returning": "⚠️ לא מקבלת החזרות",
   "HDG {value}° (ESTIMATED)": "HDG {value}° (מוערך)",
   "CALIBRATED": "מכויל",
-  "CURATED": "קוראטד",
+  "CURATED": "נבחר ידנית",
   "RAW PRIOR": "הערכה ראשונית",
   "SNAPSHOT": "תמונת מצב",
   "LIVE": "חי",
@@ -534,20 +534,20 @@
   "{value} CONTEXT": "הקשר {value}",
   "{spec} · SPECS: CCTV-DATABASE.COM": "{spec} · מפרט: CCTV-DATABASE.COM",
   "Atlantic and eastern/central North Pacific; not worldwide cyclone coverage.": "האטלנטי והפסיפיק הצפוני המזרחי/מרכזי; אין כיסוי ציקלונים עולמי.",
-  "Cyclone advisories unavailable": "ייעוצי ציקלונים אינם זמינים",
+  "Cyclone advisories unavailable": "עדכוני ציקלונים אינם זמינים",
   "Cyclone data unavailable": "נתוני ציקלונים אינם זמינים",
   "Potential tropical cyclone": "ציקלון טרופי פוטנציאלי",
   "Post-tropical cyclone": "ציקלון פוסט-טרופי",
   "Hurricane": "הוריקן",
   "Tropical storm": "סערה טרופית",
-  "Tropical depression": "דיפרסיה טרופית",
+  "Tropical depression": "שקע טרופי",
   "Subtropical storm": "סערה סובטרופית",
-  "Subtropical depression": "דיפרסיה סובטרופית",
-  "Track and cone match this advisory": "המסלול והחרוט תואמים לייעוץ הזה",
-  "Track/cone awaiting advisory {number}": "מסלול/חרוט ממתין לייעוץ {number}",
+  "Subtropical depression": "שקע סובטרופי",
+  "Track and cone match this advisory": "המסלול והחרוט תואמים לעדכון הזה",
+  "Track/cone awaiting advisory {number}": "מסלול/חרוט ממתין לעדכון {number}",
   "Track/cone unavailable": "מסלול/חרוט אינם זמינים",
-  "Cached advisory · stale source": "ייעוץ מהמטמון · מקור מיושן",
-  "Loading advisories…": "טוען ייעוצים…",
+  "Cached advisory · stale source": "עדכון מהמטמון · מקור מיושן",
+  "Loading advisories…": "טוען עדכונים…",
   "{count} active storms": {
     "one": "{count} סערה פעילה",
     "two": "{count} סערות פעילות",
@@ -555,18 +555,18 @@
   },
   "Position as of {time}": "מיקום נכון ל-{time}",
   "Maximum sustained wind: {wind} · Pressure: {pressure}": "רוח מתמשכת מרבית: {wind} · לחץ: {pressure}",
-  "{name} · {classification} · Advisory {number} · issued {time}": "{name} · {classification} · ייעוץ {number} · פורסם {time}",
+  "{name} · {classification} · Advisory {number} · issued {time}": "{name} · {classification} · עדכון {number} · פורסם {time}",
   "No active NHC/CPHC systems": "אין מערכות NHC/CPHC פעילות",
-  "Advisories unavailable": "ייעוצים אינם זמינים",
+  "Advisories unavailable": "עדכונים אינם זמינים",
   "Cyclones · NHC / CPHC": "ציקלונים · NHC / CPHC",
-  "Atlantic · E/C Pacific": "האטלנטי · הפסיפיק מ/צ",
+  "Atlantic · E/C Pacific": "האטלנטי · מזרח ומרכז הפסיפיק",
   "{storms} · {name} selected": "{storms} · {name} נבחר",
-  "Official advisory ↗": "ייעוץ רשמי ↗",
-  "Active NHC and CPHC cyclone advisories": "ייעוצי ציקלונים פעילים של NHC ו-CPHC",
+  "Official advisory ↗": "עדכון רשמי ↗",
+  "Active NHC and CPHC cyclone advisories": "עדכוני ציקלונים פעילים של NHC ו-CPHC",
   "Wind unavailable": "רוח אינה זמינה",
-  "Advisory center / forecast track": "מרכז הייעוץ / מסלול התחזית",
-  "Center-track uncertainty cone": "חרוט אי-הוודאות של מהלך המרכז",
-  "Select a storm on the map, or choose a storm in the list to select it and move the camera. Click empty map space to clear the selection. NOAA NHC/CPHC advisory context. The cone describes forecast center-track uncertainty, not storm size or the full hazard area. Forecast point labels are source lead hours, not times computed from advisory issuance. Geometry follows the surface; height is not weather altitude. Consult the official advisory.": "בחר סערה במפה, או בחר סערה ברשימה כדי לבחור אותה ולהזיז את המצלמה. לחץ בשטח ריק במפה כדי לבטל את הבחירה. הקשר ייעוצים של NOAA NHC/CPHC. החרוט מתאר אי-ודאות של מסלול המרכז בתחזית, לא את גודל הסערה ולא את מלוא אזור הסכנה. תוויות נקודות התחזית הן שעות חיזוי של המקור, לא זמנים שחושבו מפרסום הייעוץ. הגאומטריה נצמדת לפני הקרקע; הגובה אינו גובה מטאורולוגי. היוועץ בייעוץ הרשמי.",
+  "Advisory center / forecast track": "מרכז הסערה לפי העדכון / מסלול התחזית",
+  "Center-track uncertainty cone": "חרוט אי-הוודאות של מסלול המרכז",
+  "Select a storm on the map, or choose a storm in the list to select it and move the camera. Click empty map space to clear the selection. NOAA NHC/CPHC advisory context. The cone describes forecast center-track uncertainty, not storm size or the full hazard area. Forecast point labels are source lead hours, not times computed from advisory issuance. Geometry follows the surface; height is not weather altitude. Consult the official advisory.": "בחר סערה במפה, או בחר סערה ברשימה כדי לבחור אותה ולהזיז את המצלמה. לחץ בשטח ריק במפה כדי לבטל את הבחירה. הקשר עדכונים של NOAA NHC/CPHC. החרוט מתאר אי-ודאות של מסלול המרכז בתחזית, לא את גודל הסערה ולא את מלוא אזור הסכנה. תוויות נקודות התחזית הן שעות חיזוי של המקור, לא זמנים שחושבו מפרסום העדכון. הגאומטריה נצמדת לפני הקרקע; הגובה אינו גובה מטאורולוגי. עיין בעדכון הרשמי.",
   "Malformed cyclone snapshot": "תמונת מצב של ציקלון פגומה",
   "Cyclone request timed out": "בקשת הציקלון חרגה מהזמן הקצוב",
   "DRIVE": "נסיעה",
@@ -599,10 +599,10 @@
   "lane direction|sharply left": "השמאלי החד",
   "lane direction|sharply right": "הימני החד",
   "lane direction|straight": "הישר",
-  "ordinal|{number}st": "{number}.",
-  "ordinal|{number}nd": "{number}.",
-  "ordinal|{number}rd": "{number}.",
-  "ordinal|{number}th": "{number}.",
+  "ordinal|{number}st": "ה-{number}",
+  "ordinal|{number}nd": "ה-{number}",
+  "ordinal|{number}rd": "ה-{number}",
+  "ordinal|{number}th": "ה-{number}",
   "Head out on {road}": "צא אל {road}",
   "Head out": "צא לדרך",
   "Arrive at your destination, on the left": "הגעה ליעד, בצד שמאל",
@@ -622,8 +622,8 @@
   "At the end of the road, turn {direction}": "בקצה הכביש, פנה {direction}",
   "At the end of the road, continue onto {road}": "בקצה הכביש, המשך אל {road}",
   "At the end of the road, continue": "בקצה הכביש, המשך",
-  "Keep {direction} at the fork onto {road}": "הישאר {direction} בפיצול אל {road}",
-  "Keep {direction} at the fork": "הישאר {direction} בפיצול",
+  "Keep {direction} at the fork onto {road}": "בפיצול, המשך {direction} אל {road}",
+  "Keep {direction} at the fork": "בפיצול, המשך {direction}",
   "Continue at the fork onto {road}": "המשך בפיצול אל {road}",
   "Continue at the fork": "המשך בפיצול",
   "Merge {direction} onto {road}": "השתלב {direction} אל {road}",
@@ -636,14 +636,14 @@
   "Take the ramp {direction}": "היכנס לכביש הגישה {direction}",
   "Take the ramp onto {road}": "היכנס לכביש הגישה אל {road}",
   "Take the ramp": "היכנס לכביש הגישה",
-  "Take the exit on the {direction} onto {road}": "קח את היציאה {direction} אל {road}",
-  "Take the exit on the {direction}": "קח את היציאה {direction}",
-  "Take the exit {direction} onto {road}": "קח את היציאה {direction} אל {road}",
-  "Take the exit {direction}": "קח את היציאה {direction}",
-  "Take the exit onto {road}": "קח את היציאה אל {road}",
-  "Take the exit": "קח את היציאה",
-  "At the roundabout, take the {exit} exit onto {road}": "במעגל התנועה, היכנס ליציאה {exit} אל {road}",
-  "At the roundabout, take the {exit} exit": "במעגל התנועה, היכנס ליציאה {exit}",
+  "Take the exit on the {direction} onto {road}": "צא ביציאה {direction} אל {road}",
+  "Take the exit on the {direction}": "צא ביציאה {direction}",
+  "Take the exit {direction} onto {road}": "צא ביציאה {direction} אל {road}",
+  "Take the exit {direction}": "צא ביציאה {direction}",
+  "Take the exit onto {road}": "צא ביציאה אל {road}",
+  "Take the exit": "צא ביציאה",
+  "At the roundabout, take the {exit} exit onto {road}": "במעגל התנועה, צא ביציאה {exit} אל {road}",
+  "At the roundabout, take the {exit} exit": "במעגל התנועה, צא ביציאה {exit}",
   "Enter the roundabout onto {road}": "היכנס למעגל התנועה אל {road}",
   "Enter the roundabout": "היכנס למעגל התנועה",
   "At the roundabout, turn {direction} onto {road}": "במעגל התנועה, פנה {direction} אל {road}",
@@ -665,7 +665,7 @@
   "Click a spot on the globe to place B (click again to cancel)": "לחץ על נקודה בגלובוס כדי לקבוע את B (לחיצה נוספת מבטלת)",
   "Then click the globe to place the destination": "ואז לחץ על הגלובוס להצבת היעד",
   "Swap A and B": "החלפה בין A ל-B",
-  "FLY ···": "עף ···",
+  "FLY ···": "טוס ···",
   "FLYING": "בטיסה",
   "FLY": "טוס",
   "Fly the camera along the route": "טוס עם המצלמה לאורך המסלול",
@@ -675,7 +675,7 @@
   "press Escape twice to leave Draw": "הקש Escape פעמיים כדי לצאת משרטוט",
   "{name} is active — turn {name} off, then set {endpoint}": "{name} פעיל — כבה את {name} ואז קבע את {endpoint}",
   "{name} is active — {leave}, then set {endpoint}": "{name} פעיל — {leave} ואז קבע את {endpoint}",
-  "Only the first {count} turns of this route are shown": "מוצגים רק {count} הפניות הראשונות של המסלול הזה",
+  "Only the first {count} turns of this route are shown": "מוצגות רק {count} הפניות הראשונות של המסלול הזה",
   "Turn-by-turn directions": "הכוונה צעד אחר צעד",
   "Another map tool is using clicks — close it, then SET A again": "כלי מפה אחר משתמש בלחיצות — סגור אותו ואז קבע A שוב",
   "Routing…": "מחשב מסלול…",
@@ -696,10 +696,10 @@
   "From {lower}": "מ-{lower}",
   "Informational only · not for flight planning": "למידע בלבד · לא לתכנון טיסה",
   "Unnamed zone": "אזור ללא שם",
-  "Restricted airspace source unavailable": "מקור השמיים המוגבלים אינו זמין",
+  "Restricted airspace source unavailable": "מקור המרחב האווירי המוגבל אינו זמין",
   "Prohibited (P)": "אסור (P)",
   "Restricted (R)": "מוגבל (R)",
-  "FAA prohibited and restricted special-use airspace only, not the UAS Facility Map or UAS flight restrictions. Informational only — not a substitute for official UAS flight-planning tools (B4UFLY / LAANC).": "השמיים האסורים (P) והמוגבלים (R) לשימוש מיוחד של ה-FAA בלבד, לא מפת ה-UAS Facility ולא מגבלות הטיסה של UAS. למידע בלבד — אינו תחליף לכלי תכנון הטיסה הרשמיים של UAS (B4UFLY / LAANC).",
+  "FAA prohibited and restricted special-use airspace only, not the UAS Facility Map or UAS flight restrictions. Informational only — not a substitute for official UAS flight-planning tools (B4UFLY / LAANC).": "המרחב האווירי האסור (P) והמוגבל (R) לשימוש מיוחד של ה-FAA בלבד, לא מפת ה-UAS Facility ולא מגבלות הטיסה של UAS. למידע בלבד — אינו תחליף לכלי תכנון הטיסה הרשמיים של UAS (B4UFLY / LAANC).",
   "Prohibited": "אסור",
   "Restricted": "מוגבל",
   "Earthquake source unavailable": "מקור רעידות האדמה אינו זמין",
@@ -711,7 +711,7 @@
   "FIRE · {frp} MW": "שריפה · {frp} MW",
   "NIGHT": "לילה",
   "▲ {frp} MW": "▲ {frp} MW",
-  "max {value} MW": "מקס {value} MW",
+  "max {value} MW": "מקס׳ {value} MW",
   "new {value}": "חדש לפני {value}",
   "{n} fires": {
     "one": "{n} שריפה",
@@ -724,18 +724,18 @@
   "{value}°W": "{value}°W",
   "just now": "כרגע",
   "<1m ago": "לפני פחות מדקה",
-  "{count}m ago": "לפני {count} דק'",
-  "{count}h ago": "לפני {count} שע'",
+  "{count}m ago": "לפני {count} דק׳",
+  "{count}h ago": "לפני {count} שע׳",
   "fire confidence|high": "גבוהה",
   "fire confidence|nominal": "רגילה",
   "fire confidence|low": "נמוכה",
   "age|<1h": "פחות משעה",
-  "age|{count}h": "{count} שע",
-  "age|{count}d": "{count} ימים",
+  "age|{count}h": "{count} שע׳",
+  "age|{count}d": "{count} ימ׳",
   "fire confidence filter|All": "הכול",
   "fire confidence filter|Nominal+": "רגילה+",
   "fire confidence filter|High": "גבוהה",
-  "Every detection — many of the strongest fires are rated low confidence": "כל זיהוי — חלק מהשריפות החזקות ביותר מדורגות בוודאות נמוכה",
+  "Every detection — many of the strongest fires are rated low confidence": "כל זיהוי — רבות מהשריפות החזקות ביותר מדורגות בוודאות נמוכה",
   "Nominal and high confidence detections": "זיהויים בוודאות רגילה וגבוהה",
   "High confidence detections only": "זיהויים בוודאות גבוהה בלבד",
   "Fire intensity (FRP)": "עוצמת השריפה (FRP)",
@@ -770,11 +770,11 @@
   "Report": "דוח",
   "Open the source for {title}": "פתיחת המקור של {title}",
   "GhostMaps catalog unavailable": "קטלוג GhostMaps אינו זמין",
-  "LIVE · GitHub {commit} · {message} · checked every {seconds}s": "חי · GitHub {commit} · {message} · בדיקה כל {seconds} שנ",
+  "LIVE · GitHub {commit} · {message} · checked every {seconds}s": "חי · GitHub {commit} · {message} · בדיקה כל {seconds} שנ׳",
   "GitHub {commit} · {message} · reconnecting for live updates": "GitHub {commit} · {message} · מתחבר מחדש לעדכונים חיים",
   "Connecting to the S2 GhostMaps repository…": "מתחבר למאגר S2 GhostMaps…",
   "{count} placemarks": {
-    "one": "{count} סימון מקום",
+    "one": "{count} סימן מקום",
     "two": "{count} סימני מקום",
     "other": "{count} סימני מקום"
   },
@@ -784,10 +784,10 @@
   "Low-accuracy score 2–10%": "ציון דיוק נמוך 2–10%",
   "Low-accuracy score > 10%": "ציון דיוק נמוך מעל 10%",
   "GNSS integrity source unavailable": "מקור שלמות ה-GNSS אינו זמין",
-  "Regional sample · 250 nm radius · cells from visited views over {minutes} min": "דגימה אזורית · רדיוס 250 מייל ימי · תאים מתצפיות שביקרת על פני {minutes} דק",
+  "Regional sample · 250 nm radius · cells from visited views over {minutes} min": "דגימה אזורית · רדיוס 250 מייל ימי · תאים מתצפיות שביקרת על פני {minutes} דק׳",
   "Retrying automatically at {time} UTC": "מנסה שוב אוטומטית ב-{time} UTC",
-  "Retrying automatically after provider cooldown": "מנסה שוב אוטומטית אחרי קירור הספק",
-  "Updates automatically after pan or zoom and once a minute. The public feed covers a 250-nautical-mile circle around the view centre; zooming out does not make it a worldwide snapshot. Blank cells are outside sampled coverage or have insufficient observations.": "מתעדכן אוטומטית אחרי הזזה או זום ופעם בדקה. הפיד הציבורי מכסה מעגל של 250 מייל ימי סביב מרכז התצוגה; זום החוצה לא הופך אותו לתמונת-מצב עולמית. תאים ריקים נמצאים מחוץ לדגימה או חסרי תצפיות דיין.",
+  "Retrying automatically after provider cooldown": "מנסה שוב אוטומטית אחרי תקופת ההמתנה של הספק",
+  "Updates automatically after pan or zoom and once a minute. The public feed covers a 250-nautical-mile circle around the view centre; zooming out does not make it a worldwide snapshot. Blank cells are outside sampled coverage or have insufficient observations.": "מתעדכן אוטומטית אחרי הזזה או זום ופעם בדקה. הפיד הציבורי מכסה מעגל של 250 מייל ימי סביב מרכז התצוגה; זום החוצה לא הופך אותו לתמונת-מצב עולמית. תאים ריקים נמצאים מחוץ לדגימה או שאין בהם די תצפיות.",
   "Low-accuracy score = 100 × max(0, bad − 1) / total: one aircraft is discounted, so this is not the raw share. Cells need {aircraft} aircraft over {minutes} minutes. Navigation-integrity anomalies are not a detection of jamming or spoofing.": "ציון דיוק נמוך = 100 × מקס(0, פגומים − 1) / סה\"כ: מטוס אחד מנוכה, ולכן זה אינו השבר הגולמי. לתאים דרושים {aircraft} מטוסים על פני {minutes} דקות. אנומליות שלמות ניווט אינן זיהוי של שיבוש או הטעיה.",
   "GNSS snapshot needs a view anchor": "תמונת מצב GNSS דורשת עוגן תצוגה",
   "GNSS feed rate limited (HTTP 429)": "פיד GNSS מוגבל בקצב (HTTP 429)",
@@ -800,7 +800,7 @@
   "installation class|BASE": "בסיס",
   "installation class|BARRACKS": "מחנה",
   "installation class|TRAINING AREA": "שטח אימונים",
-  "installation class|PLACES CANDIDATE": "מועמד למקומות",
+  "installation class|PLACES CANDIDATE": "מועמד מ-Places",
   "installation class|INSTALLATION": "מתקן",
   "No mapped sites within {km} km of the contact": "אין אתרים ממופים בטווח {km} ק\"מ מהמגע",
   "{count} mapped sites within {km} km of the contact": {
@@ -823,36 +823,36 @@
   "LAUNCH SITE": "אתר שיגור",
   "T−{time} · {mission}": "T−{time} · {mission}",
   "LAUNCH STANDBY": "המתנה לשיגור",
-  "LIFTOFF · {mission}": "ניתוק מהקרקע · {mission}",
+  "LIFTOFF · {mission}": "המראה · {mission}",
   "ASCENT REPLAY · {mission}": "שחזור עלייה · {mission}",
   "ASCENT ESTIMATE · {mission}": "הערכת עלייה · {mission}",
   "STAGE RE-ENTRY / RECOVERY · {mission}": "כניסה חוזרת / השבת שלב · {mission}",
   "ORBIT REPLAY · {mission}": "שחזור מסלול · {mission}",
   "PAUSED · {title}": "מושהה · {title}",
   "CONFIRMED": "מאושר",
-  "PAD / RTLS": "פלטפורמה / RTLS",
+  "PAD / RTLS": "כן שיגור / RTLS",
   "UNSPECIFIED": "לא צוין",
-  "{value} KM DOWNRANGE": "{value} ק\"מ במורד הטווח",
+  "{value} KM DOWNRANGE": "{value} ק\"מ לאורך המסלול",
   "POSITION UNAVAILABLE": "מיקום אינו זמין",
   "FLIGHT {count}": "טיסה {count}",
-  "REUSED": "משומש",
+  "REUSED": "בשימוש חוזר",
   "+{count} additional payload records": "+{count} רשומות מטען נוספות",
   "Select {mission}": "בחר את {mission}",
   "UNSPECIFIED OPERATOR": "מפעיל לא צוין",
   "DATE UNAVAILABLE": "תאריך אינו זמין",
-  "{count} / 30D": "{count} / 30D",
+  "{count} / 30D": "{count} / 30 יום",
   "NO MISSIONS AVAILABLE IN THE CURRENT 30-DAY WINDOW": "אין משימות זמינות בחלון 30 הימים הנוכחי",
-  "{value} KM": "{value} ק\"מ",
+  "{value} KM": "{value} KM",
   "{value} KM/S": "{value} KM/S",
-  "EST. DOWNRANGE": "הערכה במורד הטווח",
+  "EST. DOWNRANGE": "הערכה לאורך המסלול",
   "PLANNED · ": "מתוכנן · ",
   "SUPPLIED TRAJECTORY POINTS": "נקודות מסלול שסופקו",
   "RECONSTRUCTED ESTIMATE": "הערכת שחזור",
-  "Resume replay": "המשך השמעה חוזרת",
-  "Pause replay": "השהה השמעה חוזרת",
-  "T minus {seconds}": "נותרו {seconds} שנ לשיגור",
+  "Resume replay": "המשך את ההצגה החוזרת",
+  "Pause replay": "השהה את ההצגה החוזרת",
+  "T minus {seconds}": "נותרו {seconds} שנ׳ לשיגור",
   "Preparing launch site": "מכין את אתר השיגור",
-  "Liftoff": "ניתוק",
+  "Liftoff": "המראה",
   "Ascent replay": "שחזור עלייה",
   "Orbit replay": "שחזור מסלול",
   ", paused": ", מושהה",
@@ -869,8 +869,8 @@
   "ALT {altitude} FT · GS {speed} KT · TRK {track}": "ALT {altitude} FT · GS {speed} KT · TRK {track}",
   "V/S {rate}": "V/S {rate}",
   "V/S {rate} FPM": "V/S {rate} FPM",
-  "POSITION {age}": "מיקום לפני {age}",
-  "POSITION {seconds} S AGO": "מקום לפני {seconds} שנ",
+  "POSITION {age}": "מיקום {age}",
+  "POSITION {seconds} S AGO": "מיקום לפני {seconds} שנ׳",
   "{count} MSGS": {
     "one": "{count} הודעה",
     "two": "{count} הודעות",
@@ -902,7 +902,7 @@
   "fire behavior|Active": "פעיל",
   "fire behavior|Extreme": "קיצוני",
   "Type {level} Incident": "אירוע מדרגה {level}",
-  "age|{count}m": "{count} דקות",
+  "age|{count}m": "{count} דק׳",
   "{acres} ac": {
     "one": "{acres} אקר",
     "two": "{acres} אקר",
@@ -912,9 +912,9 @@
   "containment unknown": "הכלה לא ידועה",
   "{cause} cause": "סיבה {cause}",
   "{personnel} personnel": {
-    "one": "{personnel} כוח אדם",
-    "two": "{personnel} כוח אדם",
-    "other": "{personnel} כוח אדם"
+    "one": "{personnel} אנשי צוות",
+    "two": "{personnel} אנשי צוות",
+    "other": "{personnel} אנשי צוות"
   },
   "{county} County": "מחוז {county}",
   "{cost} to date": "{cost} עד כה",
@@ -926,7 +926,7 @@
   "Unnamed incident": "אירוע ללא שם",
   "Open {title} on InciWeb": "פתיחת {title} ב-InciWeb",
   "Perimeter source unavailable": "מקור ההיקף אינו זמין",
-  "Not contained or unknown": "לא הוכל או לא ידוע",
+  "Not contained or unknown": "ללא הכלה או לא ידוע",
   "Under 50% contained": "הכלה מתחת ל-50%",
   "50–99% contained": "הכלה 50–99%",
   "Fully contained": "הכלה מלאה",
@@ -936,7 +936,7 @@
   "News": "חדשות",
   "Talk": "שיחות",
   "Weather / Emergency": "מזג אוויר / חירום",
-  "Public Safety": "ביטחון הפנים",
+  "Public Safety": "ביטחון הציבור",
   "Aviation / Marine": "תעופה / ימי",
   "Traffic / Transit": "תנועה / תחבורה",
   "Music": "מוזיקה",
@@ -971,7 +971,7 @@
   "Jazz": "ג׳אז",
   "Latin": "לטיני",
   "Metal": "מטאל",
-  "Oldies": "קלאסיקות",
+  "Oldies": "להיטי עבר",
   "Pop": "פופ",
   "Punk": "פאנק רוק",
   "R&B": "R&B",
@@ -996,9 +996,9 @@
   "Search cancelled": "החיפוש בוטל",
   "Box and images cleared": "התיבה והתמונות נוקו",
   "MORE DETAIL · 30 m": "יותר פירוט · 30 מ׳",
-  "Sentinel-2 and Landsat via HLS, 30 m, every 2–6 days": "Sentinel-2 ו-Landsat דרך HLS, 30 מ׳, כל 2–6 ימים",
+  "Sentinel-2 and Landsat via HLS, 30 m, every 2–6 days": "Sentinel-2 ו-Landsat דרך HLS, ברזולוציית 30 מ׳, כל 2–6 ימים",
   "DAILY OVERVIEW · 250 m": "סקירה יומית · 250 מ׳",
-  "VIIRS daily mosaic, 250 m, follows broad changes; little detail under 25 km": "פסיפס יומי של VIIRS, 250 מ׳, עוקב אחר שינויים רחבים; פירוט מעט מתחת ל-25 ק\"מ",
+  "VIIRS daily mosaic, 250 m, follows broad changes; little detail under 25 km": "פסיפס יומי של VIIRS, ברזולוציית 250 מ׳, עוקב אחר שינויים רחבים; מעט פירוט מתחת ל-25 ק\"מ",
   "Sentinel-2": "Sentinel-2",
   "Sentinel-2 via HLS": "Sentinel-2 דרך HLS",
   "Landsat 8/9": "Landsat 8/9",
@@ -1026,7 +1026,7 @@
   "Point the camera at the ground for street-level coverage": "כוון את המצלמה אל הקרקע כדי לראות כיסוי רחוב",
   "Coverage tile failed": "אריח הכיסוי נכשל",
   "The photo could not be loaded": "את התמונה לא ניתן לטעון",
-  "{name} photo. ← and → step along the sequence. On a 360° photo, drag or use Shift+← →, ↑ ↓ to look around, and + − to zoom": "תמונה של {name}. ← ו-→ דורכים ברצף. בתמונת 360°, גרור או השתמש ב-Shift+← →, ↑ ↓ להבט מסביב, ו-+ − לזום",
+  "{name} photo. ← and → step along the sequence. On a 360° photo, drag or use Shift+← →, ↑ ↓ to look around, and + − to zoom": "תמונה של {name}. ← ו-→ עוברים בין תמונות הרצף. בתמונת 360°, גרור או השתמש ב-Shift+← →, ↑ ↓ כדי להביט מסביב, ו-+ − לזום",
   "{name} street-level photo": "תמונת רחוב של {name}",
   "Previous photo in this sequence (←)": "התמונה הקודמת ברצף הזה (←)",
   "Next photo in this sequence (→)": "התמונה הבאה ברצף הזה (→)",
@@ -1107,21 +1107,21 @@
   "LIVE · Roads: OpenStreetMap · Flow: TomTom · {percent}% cov": "חי · כבישים: OpenStreetMap · זרימה: TomTom · {percent}% כיסוי",
   "SIMULATED · Roads: OpenStreetMap · Flow: TomTom (no matches)": "מדומה · כבישים: OpenStreetMap · זרימה: TomTom (אין התאמות)",
   "SIMULATED — traffic service unreachable": "מדומה — שירות התנועה אינו נגיש",
-  "SIMULATED — add TomTom key for live": "מדומה — הוסף מפתח TomTom לחי",
+  "SIMULATED — add TomTom key for live": "מדומה — הוסף מפתח TomTom לנתונים חיים",
   "OpenFreeMap tiles rate-limited": "אריחי OpenFreeMap מוגבלים בקצב",
   "OpenFreeMap tiles timed out": "אריחי OpenFreeMap חרגו מהזמן הקצוב",
   "OpenFreeMap tiles unavailable": "אריחי OpenFreeMap אינם זמינים",
-  "occupancy|empty": "פנויה",
+  "occupancy|empty": "ללא נוסעים",
   "occupancy|many seats available": "מקומות פנויים רבים",
   "occupancy|few seats available": "מעט מקומות פנויים",
   "occupancy|standing room only": "עמידה בלבד",
   "occupancy|crushed standing room only": "עמידה צפופה בלבד",
-  "occupancy|full": "מלאה",
-  "occupancy|not accepting passengers": "אינה מקבלת נוסעים",
+  "occupancy|full": "תפוסה מלאה",
+  "occupancy|not accepting passengers": "אין העלאת נוסעים",
   "occupancy|not boardable": "אין אפשרות עלייה",
   "Route {route}": "קו {route}",
   "Vehicle {vehicle}": "רכב {vehicle}",
-  "vehicle motion|Stopped": "עצור",
+  "vehicle motion|Stopped": "בעצירה",
   "No recent fix": "אין קביעת מיקום אחרונה",
   "Waiting for update": "ממתין לעדכון",
   "Moving": "נע",
@@ -1131,12 +1131,12 @@
   "Last report: arriving at stop {stop}": "דיווח אחרון: מגיע לתחנה {stop}",
   "Last report: next stop {stop}": "דיווח אחרון: התחנה הבאה {stop}",
   "Shown at street level · depth not in the feed": "מוצג בגובה הרחוב · המפלס אינו כלול בפיד",
-  "Reported {seconds} s ago": "דווח לפני {seconds} שניות",
-  "Reported {minutes} min ago": "דווח לפני {minutes} דק",
-  "shown {seconds} s behind": "מוצג {seconds} שניות מאחור",
+  "Reported {seconds} s ago": "דווח לפני {seconds} שנ׳",
+  "Reported {minutes} min ago": "דווח לפני {minutes} דק׳",
+  "shown {seconds} s behind": "מוצג באיחור של {seconds} שנ׳",
   "{reported} (feed time)": "{reported} (זמן הפיד)",
-  "Available trail: {minutes} min (limited)": "שובל זמין: {minutes} דק (מוגבל)",
-  "Available trail: {minutes} min": "שובל זמין: {minutes} דק",
+  "Available trail: {minutes} min (limited)": "שובל זמין: {minutes} דק׳ (מוגבל)",
+  "Available trail: {minutes} min": "שובל זמין: {minutes} דק׳",
   "Bus": "אוטובוס",
   "Tram": "חשמלית",
   "Subway": "רכבת תחתית",
@@ -1161,7 +1161,7 @@
   "feed down": "הפיד מושבת",
   "feed idle": "פיד בחוסר פעילות",
   "API key rejected — check AISSTREAM_API_KEY": "מפתח ה-API נדחה — בדוק את AISSTREAM_API_KEY",
-  "feed silent {seconds}s — no AIS data": "פיד שקט {seconds} שנ — אין נתוני AIS",
+  "feed silent {seconds}s — no AIS data": "פיד שקט {seconds} שנ׳ — אין נתוני AIS",
   "feed silent — no AIS data": "פיד שקט — אין נתוני AIS",
   "feed down — retrying slowly (attempt {attempt})": "הפיד מושבת — מנסה שוב לאט (ניסיון {attempt})",
   "reconnecting to feed… (attempt {attempt})": "מתחבר מחדש לפיד… (ניסיון {attempt})",
@@ -1175,10 +1175,10 @@
   "Weather imagery unavailable": "תצוגת מזג האוויר אינה זמינה",
   "Weather source unavailable; previous observation retained": "מקור מזג האוויר אינו זמין; התצפית הקודמת נשמרה",
   "Weather unavailable": "מזג האוויר אינו זמין",
-  "No frame within {gap} min of {time}": "אין שקופית בטווח {gap} דק מ-{time}",
-  "No frame within {gap} h of {time}": "אין שקופית בטווח {gap} שע מ-{time}",
-  "{hours}h {minutes}m ago": "לפני {hours} שע {minutes} דק",
-  "{minutes}m ago": "לפני {minutes} דק",
+  "No frame within {gap} min of {time}": "אין שקופית בטווח {gap} דק׳ מ-{time}",
+  "No frame within {gap} h of {time}": "אין שקופית בטווח {gap} שע׳ מ-{time}",
+  "{hours}h {minutes}m ago": "לפני {hours} שע׳ {minutes} דק׳",
+  "{minutes}m ago": "לפני {minutes} דק׳",
   "{state} · {time} · {lag}": "{state} · {time} · {lag}",
   "Observed": "נצפה",
   "History": "היסטוריה",
@@ -1188,9 +1188,9 @@
   "{detail} · nearest": "{detail} · הקרוב",
   "RADAR · {units}": "רדאר · {units}",
   "RADAR REFLECTIVITY · dBZ": "רפלקטיביות רדאר · dBZ",
-  "LIGHTNING DENSITY · 15 min accumulation": "צפיפות ברקים · צבירה של 15 דק",
+  "LIGHTNING DENSITY · 15 min accumulation": "צפיפות ברקים · צבירה של 15 דק׳",
   "GLOBAL INFRARED · hourly": "אינפרא-אדום גלובלי · לכל שעה",
-  "GOES INFRARED · ~5 min": "אינפרא-אדום GOES · ~5 דק",
+  "GOES INFRARED · ~5 min": "אינפרא-אדום GOES · כל ~5 דק׳",
   "{state}: {time}": "{state}: {time}",
   "Latest observation": "התצפית האחרונה",
   "frame {index}/{total}": "שקופית {index} מתוך {total}",
@@ -1198,14 +1198,14 @@
   "Observation: unavailable": "תצפית: לא זמינה",
   "Contiguous US · gaps ≠ no rain": "ארה\"ב הרציפה · פערים ≠ אין גשם",
   "Americas + Pacific · not individual strikes": "האמריקות + הפסיפיק · לא פגיעות בודדות",
-  "60°S–60°N · typically 2–3 h delayed": "60°S–60°N · בדרך כלל בפער 2–3 שע",
+  "60°S–60°N · typically 2–3 h delayed": "60°S–60°N · בדרך כלל בפער 2–3 שע׳",
   "North America · infrared imagery": "אמריקה הצפונית · צילומי אינפרא-אדום",
-  "Color: strikes/km²/min ×10³": "צבע: פגיעות ברק/קמ\"ר/דק ×10³",
+  "Color: strikes/km²/min ×10³": "צבע: פגיעות ברק/קמ\"ר/דק׳ ×10³",
   "Color: {units}": "צבע: {units}",
   "Reduced motion · history playback unavailable": "תנועה מופחתת · הצגת ההיסטוריה אינה זמינה",
   "Reduced motion · manual history available": "תנועה מופחתת · היסטוריה ידנית זמינה",
   "Rain radar · US": "רדאר גשם · ארה\"ב",
-  "Lightning density · 15 min": "צפיפות ברקים · 15 דק",
+  "Lightning density · 15 min": "צפיפות ברקים · 15 דק׳",
   "Satellite clouds": "עננים מלוויין",
   "Americas + Pacific": "האמריקות + הפסיפיק",
   "Global · 60°S–60°N": "גלובלית · 60°S–60°N",
@@ -1214,28 +1214,28 @@
   "Stale source": "מקור מיושן",
   "Loading next frame…": "טוען את השקופית הבאה…",
   "Map center outside coverage": "מרכז המפה מחוץ לכיסוי",
-  "strikes/km²/min ×10³": "פגיעות ברק/קמ\"ר/דק ×10³",
+  "strikes/km²/min ×10³": "פגיעות ברק/קמ\"ר/דק׳ ×10³",
   "N. America": "צפ. אמריקה",
   "Global": "גלובלי",
   "Hourly global mosaic; usually 2–3 hours delayed": "פסיפס גלובלי של שעה; בדרך כלל בפער 2–3 שעות",
-  "GOES regional clouds; approximately 5-minute updates": "עננים אזוריים של GOES; עדכונים בערך כל 5 דק",
+  "GOES regional clouds; approximately 5-minute updates": "עננים אזוריים של GOES; עדכונים בערך כל 5 דק׳",
   "Clouds only": "עננים בלבד",
   "Apply the full cloud brightness key; 100% filter strength": "החל את מפתח בהירות העננים המלא; עוצמת סינון 100%",
   "Full": "מלא",
   "Show the complete infrared image; 0% filter strength": "הצג את תמונת האינפרא-אדום המלאה; עוצמת סינון 0%",
   "Soft": "רך",
-  "Vivid": "חי",
+  "Vivid": "עז",
   "Image opacity; does not alter the observed values": "אטימות התמונה; אינה משנה את הערכים הנצפים",
   "View coverage": "הצג כיסוי",
   "View US radar": "הצג רדאר ארה\"ב",
   "View Americas & Pacific": "הצג האמריקות והפסיפיק",
-  "{value} strikes/km²/min ×10³ (15-minute density)": "{value} פגיעות ברק/קמ\"ר/דק ×10³ (צפיפות 15 דק)",
+  "{value} strikes/km²/min ×10³ (15-minute density)": "{value} פגיעות ברק/קמ\"ר/דק׳ ×10³ (צפיפות 15 דק׳)",
   "{value} dBZ radar reflectivity": "{value} dBZ רפלקטיביות רדאר",
   "STALE · cached source metadata": "מיושן · מידע המקור מהמטמון",
   "Map center is outside source coverage": "מרכז המפה מחוץ לכיסוי המקור",
-  "NOAA/NWS 15-minute lightning density derived from Vaisala NLDN/GLD360. Coverage 110°E across the Pacific/Americas to 0°, 25°S–80°N. Not a live strike count, global coverage or a safety warning.": "צפיפות ברקים של 15 דק מ-NOAA/NWS, נגזרת מ-Vaisala NLDN/GLD360. כיסוי מ-110°E דרך הפסיפיק/האמריקות עד 0°, בין 25°S–80°N. אינו מנייה חיה של פגיעות, כיסוי גלובלי, ולא אזהרת בטיחות.",
-  "NOAA MRMS radar echoes indicate precipitation patterns, not rain rate, a storm warning or a future forecast. Native source approximately 1 km; display is limited to level 6. Frames use exact advertised observation times.": "הדי הרדאר של NOAA MRMS מציינים דפוסי משקעים, לא קצב גשם, אזהרת סערה או חזוי עתידי. המקור הילידי בערך 1 ק\"מ; התצוגה מוגבלת לרמה 6. השקופיות משתמשות בזמני התצפית שהוכרזו, במדויק.",
-  "GOES-19/18 longwave infrared Band 14 regional; NESDIS global longwave mosaic. Clouds only dims everything but bright, cold cloud tops; a brightness filter, not a cloud mask. Coverage and freshness differ by region.": "האינפרא-אדום בגלים ארוכים של GOES-19/18, ערוץ 14, אזורי; פסיפס עולמי של גלים ארוכים מ-NESDIS. „עננים בלבד\" מעמעם הכול מלבד ראשי העננים הקרים והבהירים; זהו מסנן בהירות, לא מסך עננים. הכיסוי והרעננות משתנים לפי האזור.",
+  "NOAA/NWS 15-minute lightning density derived from Vaisala NLDN/GLD360. Coverage 110°E across the Pacific/Americas to 0°, 25°S–80°N. Not a live strike count, global coverage or a safety warning.": "צפיפות ברקים של 15 דק׳ מ-NOAA/NWS, נגזרת מ-Vaisala NLDN/GLD360. כיסוי מ-110°E דרך הפסיפיק/האמריקות עד 0°, בין 25°S–80°N. אין מדובר בספירת פגיעות בזמן אמת, בכיסוי גלובלי או באזהרת בטיחות.",
+  "NOAA MRMS radar echoes indicate precipitation patterns, not rain rate, a storm warning or a future forecast. Native source approximately 1 km; display is limited to level 6. Frames use exact advertised observation times.": "הדי הרדאר של NOAA MRMS מציינים דפוסי משקעים, לא קצב גשם, אזהרת סערה או תחזית לעתיד. רזולוציית המקור כ-1 ק\"מ; התצוגה מוגבלת לרמה 6. השקופיות משתמשות בזמני התצפית המדויקים שפורסמו.",
+  "GOES-19/18 longwave infrared Band 14 regional; NESDIS global longwave mosaic. Clouds only dims everything but bright, cold cloud tops; a brightness filter, not a cloud mask. Coverage and freshness differ by region.": "האינפרא-אדום בגלים ארוכים של GOES-19/18, ערוץ 14, אזורי; פסיפס עולמי של גלים ארוכים מ-NESDIS. \"עננים בלבד\" מעמעם הכול מלבד ראשי העננים הקרים והבהירים; זהו מסנן בהירות, לא מסכת עננים. הכיסוי והרעננות משתנים לפי האזור.",
   "REGION": "אזור",
   "FILTER": "מסנן",
   "Cloud filter strength": "עוצמת סינון עננים",
@@ -1252,7 +1252,7 @@
   "Mammals": "יונקים",
   "Reptiles": "זוחלים",
   "Amphibians": "דו-חיים",
-  "Ray-finned fishes": "דגי סנפיר",
+  "Ray-finned fishes": "מקריני סנפיר",
   "Insects": "חרקים",
   "Arachnids": "עכבישנים",
   "Plants": "צמחים",
@@ -1286,7 +1286,7 @@
   "Wildlife Sightings": "תצפיות חיות בר",
   "Temperature field unavailable": "שדה הטמפרטורה אינו זמין",
   "Mean sea level pressure field unavailable": "שדה לחץ בגובה פני הים אינו זמין",
-  "Wind upstream unavailable": "מקור הרוח במעלה הזרם אינו זמין",
+  "Wind upstream unavailable": "שרת המקור של נתוני הרוח אינו זמין",
   "{source} HTTP {status}": "{source} HTTP {status}",
   "Wind": "רוח",
   "Wind source unavailable": "מקור הרוח אינו זמין",
@@ -1312,7 +1312,7 @@
   "Pressure": "לחץ",
   "Temperature": "טמפרטורה",
   "Wind trails with no field shading": "שובלי רוח ללא הצללת שדה",
-  "How hard the surface wind is blowing": "עד כמה חזקה נושבת הרוח בגובה הקרקע",
+  "How hard the surface wind is blowing": "באיזו עוצמה נושבת הרוח בגובה הקרקע",
   "Sea-level air pressure: broad highs and lows": "לחץ אוויר בגובה פני הים: אזורי לחץ גבוהים ונמוכים רחבים",
   "Air temperature two meters above the surface": "טמפרטורת אוויר שני מטרים מעל הקרקע",
   "Wind speed units": "יחידות מהירות רוח",
@@ -1324,7 +1324,7 @@
   "Issued: {time}": "פורסם: {time}",
   "Selected field unavailable · wind remains visible": "השדה הנבחר אינו זמין · הרוח נשארת גלויה",
   "{error} · wind remains visible": "{error} · הרוח נשארת גלויה",
-  "Surface wind at 10 m. Approximately 1° global grid. Curves follow the 10 m wind field, lifted 12 km for visibility; display height is not weather altitude. View lighting is for readability. Animation shows flow through one fixed forecast; it does not advance time. Color fields drape the globe basemap or the active photorealistic 3D Tiles.": "רוח פני הקרקע בגובה 10 מ׳, על סריג של כ-1°. העקומות עוקבות את שדה הרוח בגובה 10 מ׳, מוגבהות 12 ק\"מ לקריאות; גובה התצוגה אינו גובה מטאורולוגי. תאורת התצוגה נועדה לקריאות. ההנפשה מציגה זרימה בתחזית אחת קבועה; היא אינה מקדמת את הזמן. שדות הצבע נפרשים מעל מפת הבסיס של הגלובוס או מעל ה-3D Tiles הפוטוריאליסטיים הפעילים.",
+  "Surface wind at 10 m. Approximately 1° global grid. Curves follow the 10 m wind field, lifted 12 km for visibility; display height is not weather altitude. View lighting is for readability. Animation shows flow through one fixed forecast; it does not advance time. Color fields drape the globe basemap or the active photorealistic 3D Tiles.": "רוח פני הקרקע בגובה 10 מ׳, על סריג של כ-1°. העקומות עוקבות אחר שדה הרוח בגובה 10 מ׳, מוגבהות 12 ק\"מ לקריאות; גובה התצוגה אינו גובה מטאורולוגי. תאורת התצוגה נועדה לקריאות. ההנפשה מציגה זרימה בתחזית אחת קבועה; היא אינה מקדמת את הזמן. שדות הצבע נפרשים מעל מפת הבסיס של הגלובוס או מעל ה-3D Tiles הפוטוריאליסטיים הפעילים.",
   "MODEL": "מודל",
   "FIELD": "שדה",
   "UNITS": "יחידות",
@@ -1346,9 +1346,9 @@
   "WNW": "WNW",
   "NW": "NW",
   "NNW": "NNW",
-  "No surface reading": "אין קריאת שטח",
+  "No surface reading": "אין קריאה בגובה הקרקע",
   "Aim the map center at Earth": "כוון את מרכז המפה אל העולם",
-  "A location reading needs a loaded forecast and the Earth at the center of the view.": "קריאת מקום דורשת תחזית טעונה ואת כדור הארץ במרכז התצוגה.",
+  "A location reading needs a loaded forecast and the Earth at the center of the view.": "קריאת מיקום דורשת תחזית שנטענה ואת כדור הארץ במרכז התצוגה.",
   "Interpolated model forecast on an approximately 1° grid. Broad weather patterns, not a street-level measurement.": "תחזית מודל באינטרפולציה על סריג של כ-1°. דפוסי מזג אוויר רחבים, לא מדידה ברמת הרחוב.",
   " · calm": " · שקטה",
   " from {direction}": " מ-{direction}",
@@ -1365,33 +1365,33 @@
   "Error: {message}": "שגיאה: {message}",
   "Needs {envVars} — add it in Provider Settings": "דורש {envVars} — הוסף בהגדרות הספקים",
   "{label} is unavailable": "{label} אינו זמין",
-  "This map stack": "ערמת מפה זו",
-  "Google 3D tiles unavailable — check the key's API restrictions, quota, or network": "ה-Google 3D tiles אינם זמינים — בדוק את מגבלות ה-API של המפתח, את מכסה או את הרשת",
+  "This map stack": "ערכת מפות זו",
+  "Google 3D tiles unavailable — check the key's API restrictions, quota, or network": "ה-Google 3D tiles אינם זמינים — בדוק את מגבלות ה-API של המפתח, את המכסה או את הרשת",
   "Needs {envVars} — add it in Provider Settings — or a Cesium ion token for the ion-hosted route": "דורש {envVars} — הוסף בהגדרות הספקים — או אסימון Cesium ion לנתיב המתארח ב-ion",
-  "Exit cockpit to fly to a camera": "צא מתא הטייס כדי לעוף אל מצלמה",
-  "Exit cockpit to fly to a location": "צא מתא הטייס כדי לעוף אל מקום",
-  "Exit cockpit to fly to a photo": "צא מתא הטייס כדי לעוף אל תמונה",
-  "Exit cockpit to fly to a shared view": "צא מתא הטייס כדי לעוף אל תצוגה משותפת",
-  "Exit cockpit to fly to a target": "צא מתא הטייס כדי לעוף אל מטרה",
-  "Exit cockpit to fly to a vessel": "צא מתא הטייס כדי לעוף אל אונייה",
-  "Exit cockpit to fly to a fire": "צא מתא הטייס כדי לעוף אל שריפה",
-  "Exit cockpit to fly to a sighting": "צא מתא הטייס כדי לעוף אל תצפית",
-  "Exit cockpit to fly to a sighting area": "צא מתא הטייס כדי לעוף אל אזור תצפית",
-  "Exit cockpit to fly to a route": "צא מתא הטייס כדי לעוף אל מסלול",
-  "Exit cockpit to fly to a file": "צא מתא הטייס כדי לעוף אל קובץ",
-  "Exit cockpit to fly to a drawing": "צא מתא הטייס כדי לעוף אל שרטוט",
-  "Exit cockpit to fly to a scene": "צא מתא הטייס כדי לעוף אל סצנה",
+  "Exit cockpit to fly to a camera": "צא מתא הטייס כדי לטוס אל מצלמה",
+  "Exit cockpit to fly to a location": "צא מתא הטייס כדי לטוס אל מקום",
+  "Exit cockpit to fly to a photo": "צא מתא הטייס כדי לטוס אל תמונה",
+  "Exit cockpit to fly to a shared view": "צא מתא הטייס כדי לטוס אל תצוגה משותפת",
+  "Exit cockpit to fly to a target": "צא מתא הטייס כדי לטוס אל מטרה",
+  "Exit cockpit to fly to a vessel": "צא מתא הטייס כדי לטוס אל אונייה",
+  "Exit cockpit to fly to a fire": "צא מתא הטייס כדי לטוס אל שריפה",
+  "Exit cockpit to fly to a sighting": "צא מתא הטייס כדי לטוס אל תצפית",
+  "Exit cockpit to fly to a sighting area": "צא מתא הטייס כדי לטוס אל אזור תצפית",
+  "Exit cockpit to fly to a route": "צא מתא הטייס כדי לטוס אל מסלול",
+  "Exit cockpit to fly to a file": "צא מתא הטייס כדי לטוס אל קובץ",
+  "Exit cockpit to fly to a drawing": "צא מתא הטייס כדי לטוס אל שרטוט",
+  "Exit cockpit to fly to a scene": "צא מתא הטייס כדי לטוס אל סצנה",
   "Exit cockpit to view weather coverage": "צא מתא הטייס כדי לצפות בכיסוי מזג האוויר",
-  "Exit cockpit to fly to a cyclone": "צא מתא הטייס כדי לעוף אל ציקלון",
-  "Exit cockpit to fly to an aircraft": "צא מתא הטייס כדי לעוף אל מטוס",
-  "Exit cockpit to fly to a satellite": "צא מתא הטייס כדי לעוף אל לוויין",
-  "Exit cockpit to frame contacts": "צא מתא הטייס כדי לסגור מגעים בתצוגה",
+  "Exit cockpit to fly to a cyclone": "צא מתא הטייס כדי לטוס אל ציקלון",
+  "Exit cockpit to fly to an aircraft": "צא מתא הטייס כדי לטוס אל מטוס",
+  "Exit cockpit to fly to a satellite": "צא מתא הטייס כדי לטוס אל לוויין",
+  "Exit cockpit to frame contacts": "צא מתא הטייס כדי למסגר את המגעים",
   "Focusing {label}": "מתמקד ב-{label}",
   "Camera ownership changed": "בעלות המצלמה השתנתה",
   "Saved project could not be read; storage preserved. Import a valid file to resume saving.": "לא ניתן לקרוא את הפרויקט השמור; האחסון נשמר. ייבא קובץ תקין כדי לחדש שמירה.",
   "Ready": "מוכן",
   "Scene layer turned off": "שכבת הסצנה כבויה",
-  "Stopped": "עצר",
+  "Stopped": "נעצר",
   "Scene not saved — existing saved project could not be read. Export edits or import a valid file.": "הסצנה לא נשמרה — לא ניתן לקרוא את הפרויקט השמור הקיים. ייצא עריכות או ייבא קובץ תקין.",
   "Scene not saved — {reason}": "הסצנה לא נשמרה — {reason}",
   "Scene not saved — browser storage unavailable": "הסצנה לא נשמרה — אחסון הדפדפן אינו זמין",
@@ -1425,8 +1425,8 @@
   "Imported {file}": "יובא {file}",
   "Import failed: {error}": "הייבוא נכשל: {error}",
   "Import failed (could not read JSON file)": "הייבוא נכשל (לא ניתן לקרוא קובץ JSON)",
-  "Layers refused: {layers}": "שכבות שסירבו: {layers}",
-  "Could not exit {mode} — scene layers may be refused": "לא ניתן לצאת מ-{mode} — שכבות הסצנה עשויות להיסרב",
+  "Layers refused: {layers}": "שכבות שנדחו: {layers}",
+  "Could not exit {mode} — scene layers may be refused": "לא ניתן לצאת מ-{mode} — ייתכן ששכבות הסצנה יידחו",
   "Camera move interrupted": "תנועת המצלמה הופסקה",
   "Scene media timed out": "מדיית הסצנה חרגה מהזמן הקצוב",
   "Action complete": "הפעולה הושלמה",
@@ -1438,7 +1438,7 @@
   "Bhote Koshi Evidence Sequence": "רצף הראיות של Bhote Koshi",
   "Nepal Flood Incident": "אירוע השיטפון בנפאל",
   "Global Flights Radar": "מכ\"ם טיסות עולמי",
-  "Orbital Watch": "צפי מסלולי",
+  "Orbital Watch": "תצפית מסלולית",
   "Thermal Threat Board": "לוח איומים תרמיים",
   "City Overload": "עומס עירוני",
   "Omniscience Pullback": "נסיגת ראייה כוללת",
@@ -1482,8 +1482,8 @@
   },
   "{scene} / {pack}: {status}. File: {path}. {attribution} · {license}": "{scene} / {pack}: {status}. קובץ: {path}. {attribution} · {license}",
   "Unavailable layers: {layers}": "שכבות בלתי זמינות: {layers}",
-  "Uses registered content or linked media. Those external files are not included in a scene bundle. Their original notices still apply.": "משתמש בתוכן רשום או במדיה מקושרת. הקבצים החיצוניים האלה אינם נכללים בחבילת סצנה. הודעות המקור שלהם חלות בעינם.",
-  "{bytes} bundled bytes verified. Files stay in memory for this session. Reimport the bundle after reloading the app.": "{bytes} בתי החבילה מאומתים. הקבצים נשארים בזיכרון להפעלה הזאת. ייבא מחדש את החבילה אחרי טעינת האפליקציה.",
+  "Uses registered content or linked media. Those external files are not included in a scene bundle. Their original notices still apply.": "משתמש בתוכן רשום או במדיה מקושרת. הקבצים החיצוניים האלה אינם נכללים בחבילת סצנה. הודעות המקור שלהם חלות בעינן.",
+  "{bytes} bundled bytes verified. Files stay in memory for this session. Reimport the bundle after reloading the app.": "אומתו {bytes} בייטים בחבילה. הקבצים נשארים בזיכרון להפעלה הזאת. ייבא מחדש את החבילה אחרי טעינה מחדש של האפליקציה.",
   "Review scene import": "סקירת ייבוא סצנה",
   "Nothing is loaded or changed until you apply this file.": "עד שתאשר את הקובץ לא נטען ולא משתנה דבר.",
   "Ready to import": "מוכן לייבוא",
@@ -1510,7 +1510,7 @@
   "Choose data-pack files": "בחירת קבצי חבילת נתונים",
   "Or choose a data-pack folder": "או בחירת תיקיית חבילת נתונים",
   "Download asset bundle": "הורדת חבילת הנכסים",
-  "Asset bundle downloaded": "חבילת הנכסים ירדה",
+  "Asset bundle downloaded": "חבילת הנכסים הורדה",
   "No RTL-SDR device selected": "לא נבחר מקלט RTL-SDR",
   "WebUSB requires desktop Chrome or Edge on localhost/HTTPS": "WebUSB דורש Chrome או Edge שולחני ב-localhost/HTTPS",
   "RTL-SDR access failed; close other SDR apps and check USB permissions": "הגישה ל-RTL-SDR נכשלה; סגור אפליקציות SDR אחרות ובדוק הרשאות USB",
@@ -1568,7 +1568,7 @@
   "Link shared": "הקישור שותף",
   "Link copied!": "הקישור הועתק!",
   "Copy failed": "ההעתקה נכשלה",
-  "Tilted view": "תצוגה משופעת",
+  "Tilted view": "תצוגה מוטה",
   "Straight-down view": "תצוגה ישרה מלמעלה",
   "North up": "צפון מעלה",
   "CCTV calibration saved": "כיול CCTV נשמר",
@@ -1630,7 +1630,7 @@
     "two": "{count} מצלמות נטענו · הפעל CCTV להפעלה",
     "other": "{count} מצלמות נטענו · הפעל CCTV להפעלה"
   },
-  "Enable CCTV to load camera intersections": "הפעל CCTV לטעינת חיתוכי מצלמות",
+  "Enable CCTV to load camera intersections": "הפעל CCTV לטעינת מצלמות הצמתים",
   "Enable CCTV to start camera-linked intelligence summaries.": "הפעל CCTV להתחלת סיכומי מודיעין הקשורים למצלמות.",
   "No summary available.": "אין סיכום זמין.",
   "loading frames": "טוען שקופיות",
@@ -1645,8 +1645,8 @@
   "{source} · LOCATION QUERY · RECENT": "{source} · שאילתת מיקום · אחרונים",
   "LOCAL INFO": "מידע מקומי",
   "PLACE / CONDITIONS / POSITION": "מקום / מצב / עמדה",
-  "Stop automatic page cycling. Previous, Next, and the SIG/NEWS/LOCAL tabs stay available.": "הפסק את מחזור העמודים האוטומטי. קודם, הבא, והלשוניות אותות/חדשות/מקומי נשארות זמינות.",
-  "Cycle briefing pages automatically every 9 seconds (Signals → News → Local). Pauses while you hover or focus the panel. Live signal data refreshes continuously either way.": "מחזר את עמודי הדיווח אוטומטית כל 9 שניות (אותות → חדשות → מקומי). מושהה בזמן ריחוף או מיקוד הפאנל. נתוני האותות החיים מתרעננים כל הזמן בכל מקרה.",
+  "Stop automatic page cycling. Previous, Next, and the SIG/NEWS/LOCAL tabs stay available.": "הפסק את מחזור העמודים האוטומטי. הקודם, הבא והלשוניות אותות/חדשות/מקומי נשארים זמינים.",
+  "Cycle briefing pages automatically every 9 seconds (Signals → News → Local). Pauses while you hover or focus the panel. Live signal data refreshes continuously either way.": "מעבר אוטומטי בין עמודי התדריך כל 9 שניות (אותות → חדשות → מקומי). מושהה בזמן ריחוף או מיקוד הפאנל. נתוני האותות החיים מתרעננים כל הזמן בכל מקרה.",
   "CYCLE OFF": "מחזור כבוי",
   "ACQUIRING REGIONAL NEWS": "אוסף חדשות אזוריות",
   "RESOLVING REGION": "מזהה אזור",
@@ -1675,10 +1675,10 @@
   "{scope} · INSTALLATIONS {coverage}": "{scope} · מתקנים {coverage}",
   "MILITARY FEED OFF · PARTIAL PICTURE": "פיד צבאי כבוי · תמונה חלקית",
   "FLIGHTS FEED OFF · PARTIAL PICTURE": "פיד טיסות כבוי · תמונה חלקית",
-  "NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR": "מטוסים סמוכים חלקיים · ללא אישור מלא",
+  "NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR": "נתוני המטוסים הסמוכים חלקיים · לא אות הרגעה",
   "CONTEXT STANDBY": "ההקשר בהמתנה",
   "ENABLE GLOBAL CONTEXT FOR PROXIMITY PINGS": "הפעל הקשר גלובלי לפינגים של קרבה",
-  "CONTACT LOST · LAST KNOWN READOUT · NOT AN ALL-CLEAR": "המגע אבד · הקריאה האחרונה הידועה · ללא אישור מלא",
+  "CONTACT LOST · LAST KNOWN READOUT · NOT AN ALL-CLEAR": "המגע אבד · הקריאה האחרונה הידועה · לא אות הרגעה",
   "CONTACT LOST · {subject}": "המגע אבד · {subject}",
   "SUBJECT LEFT ITS FEED · READOUT HOLDING LAST KNOWN": "העצם יצא מהפיד · הקריאה מחזיקה את האחרון הידוע",
   "{cohort} · {contact}": "{cohort} · {contact}",
@@ -1686,16 +1686,16 @@
   "{cohort}, Unavailable": "{cohort}, לא זמין",
   "AHEAD": "לפנים",
   "{side} {angle}": "{side} {angle}",
-  "L": "L",
-  "R": "R",
+  "L": "שמאל",
+  "R": "ימין",
   "{count} INPUTS UNKNOWN · NOT AN ALL-CLEAR": {
     "one": "{count} קלט לא ידוע · לא אות הרגעה",
     "two": "{count} קלטים לא ידועים · לא אות הרגעה",
     "other": "{count} קלטים לא ידועים · לא אות הרגעה"
   },
-  "AVAILABLE INPUTS CURRENT · NOT AN ALL-CLEAR": "הקלטים הזמינים עדכניים · ללא אישור מלא",
+  "AVAILABLE INPUTS CURRENT · NOT AN ALL-CLEAR": "הקלטים הזמינים עדכניים · לא אות הרגעה",
   "CONTACTS · 250 KM": "מגעים · 250 ק\"מ",
-  "AVAILABLE INPUTS ONLY · NOT AN ALL-CLEAR": "קלטים זמינים בלבד · ללא אישור מלא",
+  "AVAILABLE INPUTS ONLY · NOT AN ALL-CLEAR": "קלטים זמינים בלבד · לא אות הרגעה",
   "Normal": "רגיל",
   "Night vision": "ראיית לילה",
   "Thermal": "תרמי",
@@ -1708,7 +1708,7 @@
   "SQUAWK {code} · {status}": "SQUAWK {code} · {status}",
   "ADS-B PRIORITY · {status}": "עדיפות ADS-B · {status}",
   "ADS-B EMERGENCY · {status}": "חירום ADS-B · {status}",
-  "ACQUIRING SURFACE": "אוסף משטח",
+  "ACQUIRING SURFACE": "מאתר משטח",
   "SURFACE FALLBACK": "משטח חלופי",
   "STALE FEED": "פיד מיושן",
   "LIVE TRACK": "מעקב חי",
@@ -1718,9 +1718,9 @@
   "ARROW · ESTIMATED DIRECTION": "חץ · כיוון מוערך",
   "DEST {bearing}": "DEST {bearing}",
   "TIME UNKNOWN": "זמן לא ידוע",
-  "{count}M AGO": "לפני {count} דק",
-  "{count}H AGO": "לפני {count} שע",
-  "{count}D AGO": "לפני {count} ימ",
+  "{count}M AGO": "לפני {count} דק׳",
+  "{count}H AGO": "לפני {count} שע׳",
+  "{count}D AGO": "לפני {count} ימ׳",
   "DIR UNKNOWN": "כיוון לא ידוע",
   "COCKPIT": "תא טייס",
   "Select flight {title}": "בחירת הטיסה {title}",
@@ -1730,12 +1730,12 @@
   "{aircraftClass} · {distance}": "{aircraftClass} · {distance}",
   "DISTANCE UNKNOWN": "מרחק לא ידוע",
   "{count} INPUTS UNKNOWN": {
-    "one": "{count} קלטים לא ידועים",
+    "one": "{count} קלט לא ידוע",
     "two": "{count} קלטים לא ידועים",
     "other": "{count} קלטים לא ידועים"
   },
   "SOURCE STATUS UNAVAILABLE": "מצב המקור אינו זמין",
-  "TRACK ACQUIRED": "המעקב נתפס",
+  "TRACK ACQUIRED": "המעקב ננעל",
   "{label} · COURSE {heading}°": "{label} · מהלך {heading}°",
   "Context could not restore every layer; try again": "ההקשר לא שיחזר את כל השכבות; נסה שוב",
   "No selected data layers": "אין שכבות נתונים נבחרות",
@@ -1755,13 +1755,13 @@
   "Nearby installations could not be refreshed; try again": "לא ניתן לרענן את המתקנים הסמוכים; נסה שוב",
   "Space Missions cancellation could not restore the previous layer state": "ביטול משימות החלל לא שיחזר את מצב השכבה הקודם",
   "That layer is unavailable in the current Context mode": "השכבה הזאת אינה זמינה במצב ההקשר הנוכחי",
-  "{layerId} could not {action} cleanly": "{layerId} — הפעולה {action} לא הסתיימה בנקיון",
+  "{layerId} could not {action} cleanly": "{layerId} — הפעולה {action} לא הסתיימה כראוי",
   "start": "התחלה",
   "stop": "עצירה",
-  "{mode} could not start because another layer did not stop cleanly": "{mode} לא החל כי שכבה אחרת לא נעצרה בנקיון",
+  "{mode} could not start because another layer did not stop cleanly": "{mode} לא החל כי שכבה אחרת לא נעצרה כראוי",
   "Space Missions": "משימות חלל",
   "Context": "ההקשר",
-  "Ground heights could not be refreshed. Try the file again when the map has loaded.": "את גבהי הקרקע לא ניתן לרענן. נסה שוב את הקובץ כשהמפה נטענת.",
+  "Ground heights could not be refreshed. Try the file again when the map has loaded.": "את גבהי הקרקע לא ניתן לרענן. נסה שוב את הקובץ אחרי שהמפה תיטען.",
   "{count} map objects": {
     "one": "{count} אובייקט מפה",
     "two": "{count} אובייקטי מפה",
@@ -1793,7 +1793,7 @@
   "panel": "פאנל",
   "Live Flights": "טיסות חיות",
   "Military Flights": "טיסות צבאיות",
-  "Earthquakes (24h)": "רעידות אדמה (24 שע)",
+  "Earthquakes (24h)": "רעידות אדמה (24 שע׳)",
   "Satellites": "לוויינים",
   "Space Missions (30d)": "משימות חלל (30 יום)",
   "Street Traffic": "תנועה ברחובות",
@@ -1811,13 +1811,13 @@
   "OSM Places": "מקומות OSM",
   "Transit": "תחבורה ציבורית",
   "Recent Imagery": "צילומים אחרונים",
-  "Fire Perimeters": "היקפי שרפות",
+  "Fire Perimeters": "היקפי שריפות",
   "GNSS Integrity": "שלמות GNSS",
   "Prohibited & Restricted Airspace": "מרחב אווירי אסור ומוגבל",
   "S2 GhostMaps": "S2 GhostMaps",
   "Rain radar": "רדאר גשם",
   "Lightning density": "צפיפות ברקים",
-  "Cyclone advisories": "ייעוצי ציקלונים",
+  "Cyclone advisories": "עדכוני ציקלונים",
   "ALPR Cameras": "מצלמות ALPR",
   "Sea Marks": "סימני ים",
   "Ski Pistes": "מסלולי סקי",
@@ -1828,7 +1828,7 @@
   "Mapped ALPR Cameras": "מצלמות ALPR ממופות",
   "Data Centers": "מרכזי נתונים",
   "Active Fires": "שריפות פעילות",
-  "Military aircraft": "מטוס צבאי",
+  "Military aircraft": "מטוסים צבאיים",
   "Vessels": "אוניות",
   "CCTV + Street View fallback": "CCTV + גיבוי Street View",
   "OpenStreetMap + optional Google Maps Places": "OpenStreetMap + Google Maps Places אופציונלי",
@@ -1854,17 +1854,17 @@
   "Other layers": "שכבות אחרות",
   "{state} · {source}": "{state} · {source}",
   "UNCERTAIN · {source} · lifecycle state requires reconciliation": "לא ודאי · {source} · מצב מחזור החיים מצריך התאמה",
-  "{state} · {source} · {detail} · retry {seconds}s": "{state} · {source} · {detail} · ניסיון חוזר בעוד {seconds} שנ",
+  "{state} · {source} · {detail} · retry {seconds}s": "{state} · {source} · {detail} · ניסיון חוזר בעוד {seconds} שנ׳",
   "{state} · {source} · {detail}": "{state} · {source} · {detail}",
   "never": "לעולם לא",
   "{source} · {loadingLabel}": "{source} · {loadingLabel}",
   "{accepted} of {raw} records accepted": "התקבלו {accepted} מתוך {raw} רשומות",
   "incomplete snapshot": "תמונת מצב שאינה שלמה",
   "{state} · {source} · {detail} · {ago}": "{state} · {source} · {detail} · {ago}",
-  "{state} · {source} · {ago} · retrying in {seconds}s": "{state} · {source} · {ago} · מנסה שוב בעוד {seconds} שנ",
+  "{state} · {source} · {ago} · retrying in {seconds}s": "{state} · {source} · {ago} · מנסה שוב בעוד {seconds} שנ׳",
   "{state} · {source} · {ago}": "{state} · {source} · {ago}",
   "{source} · {ago}": "{source} · {ago}",
-  "{count}s ago": "לפני {count} שנ'",
+  "{count}s ago": "לפני {count} שנ׳",
   "Local FM stopped: internet radio started": "FM מקומי נעצר: רדיו אינטרנט החל",
   "IDLE": "אין פעילות",
   "CONNECTING": "מתחבר",
@@ -1904,17 +1904,17 @@
   "LOCATING…": "מאתר…",
   "LOCATED": "אותר",
   "LOCATE": "אתר",
-  " · read while Local ADS-B is on": " · נקרא בזמן ש-Local ADS-B פעיל",
+  " · read while Local ADS-B is on": " · נקרא בזמן ש-ADS-B מקומי פעיל",
   "Decoder feeds: {feeds}": "פידי דקודר: {feeds}",
   "📍 Location: --": "📍 מיקום: --",
   "Landmark: --": "ציון דרך: --",
-  "Searched location": "המקום שנחפש",
+  "Searched location": "המיקום שחיפשת",
   "Location not found": "המקום לא נמצא",
   "Check the spelling and press Enter to search again.": "בדוק את האיות והקש Enter כדי לחפש שוב.",
   "Search failed": "החיפוש נכשל",
   "Press Enter to try again.": "הקש Enter לניסיון חוזר.",
   "Detailed outline unavailable": "קו המתאר המפורט אינו זמין",
-  "Fly to a POI first": "עוף קודם אל נקודת עניין",
+  "Fly to a POI first": "טוס קודם אל נקודת עניין",
   "{label} unavailable: {hint}": "{label} אינו זמין: {hint}",
   "MAP": "מפה",
   "Layers": "שכבות",
@@ -1947,7 +1947,7 @@
   "OFF AIR": "מחוץ לשידור",
   "STATION UNAVAILABLE": "התחנה אינה זמינה",
   "Station unavailable after directory refresh": "התחנה אינה זמינה אחרי רענון המדריך",
-  "Radio could not {action} cleanly": "הרדיו לא השלים את {action} בנקיון",
+  "Radio could not {action} cleanly": "הרדיו — הפעולה {action} לא הסתיימה כראוי",
   "SYNC": "סנכרון",
   "RECONCILE": "התאמה",
   "DISABLE": "כיבוי",
@@ -1964,9 +1964,9 @@
   "Play": "נגן",
   "PAUSE": "השהה",
   "RESUME": "המשך",
-  "PLAY": "נגינה",
-  "selected": "נבחר",
-  "nearest": "הקרוב",
+  "PLAY": "נגן",
+  "selected": "הנבחרת",
+  "nearest": "הקרובה",
   "{action} {target} radio station": "{action} את תחנת הרדיו {target}",
   "station": "תחנה",
   " · stale/degraded directory": " · מדריך מיושן/מופחת",
@@ -1982,8 +1982,8 @@
   "Broadcaster stream unavailable": "זרימת המשדר אינה זמינה",
   " · muted during voice interaction": " · מושתק בזמן אינטראקציה קולית",
   " · restoring volume after voice": " · מחזיר עוצמה אחרי הקול",
-  " · static indicates no broadcaster audio": " · רקע רק מעיד שאין שמע מהמשדר",
-  " · tuning static until broadcaster starts": " · רקע עד לתחילת השידור של המשדר",
+  " · static indicates no broadcaster audio": " · רעש סטטי מעיד שאין שמע מהמשדר",
+  " · tuning static until broadcaster starts": " · רעש כוונון עד שהמשדר יתחיל לשדר",
   "Station unavailable after directory refresh — choose another channel": "התחנה אינה זמינה אחרי רענון המדריך — בחר ערוץ אחר",
   "Radio is enabling…": "הרדיו במהלך הפעלה…",
   "Radio is disabling…": "הרדיו במהלך כיבוי…",
@@ -2008,8 +2008,8 @@
   "View is {size} wide · limit {limit}": "רוחב התצוגה {size} · מגבלה {limit}",
   "VS BASEMAP": "מול מפת הבסיס",
   "A / B": "A / B",
-  "Newest low-cloud day for this box · scene cloud, not box cloud": "היום החדש ביותר בעל עננות נמוכה לתיבה הזאת · עננות הסצנה, לא עננות התיבה",
-  "Newest day covering this box · cloudier than 20%": "היום החדש ביותר המכסה את התיבה הזאת · מעונן מ-20%",
+  "Newest low-cloud day for this box · scene cloud, not box cloud": "היום החדש ביותר עם מעט עננים לתיבה הזאת · עננות הסצנה, לא עננות התיבה",
+  "Newest day covering this box · cloudier than 20%": "היום החדש ביותר המכסה את התיבה הזאת · עננות מעל 20%",
   "Newest day with imagery for this box · partial coverage": "היום החדש ביותר עם צילומים לתיבה הזאת · כיסוי חלקי",
   "Newest daily overview for this box": "הסקירה היומית החדשה ביותר לתיבה הזאת",
   "newest clear day": "היום הבהיר החדש ביותר",
@@ -2070,7 +2070,7 @@
   "Download {slot} as a PNG": "הורדת {slot} כקובץ PNG",
   "Download the image as a PNG": "הורדת התמונה כקובץ PNG",
   "Box {width} × {height} km": "תיבה {width} × {height} ק\"מ",
-  "Acquired {time}": "נאסף {time}",
+  "Acquired {time}": "צולם {time}",
   "Coverage {coverage}": "כיסוי {coverage}",
   "START HERE · {reason}": "התחלה כאן · {reason}",
   "Daily overview shows little detail in a box this small": "הסקירה היומית מציגה מעט פירוט בתיבה קטנה כל כך",
@@ -2089,7 +2089,7 @@
   "{before} {left} percent, {after} {right} percent": "{before} {left} אחוזים, {after} {right} אחוזים",
   "Export failed · {error}": "הייצוא נכשל · {error}",
   "START HERE": "התחלה כאן",
-  "Fly in until the view fits the 1,000 km limit": "עוף פנימה עד שהתצוגה נכנסת למגבלה של 1,000 ק\"מ",
+  "Fly in until the view fits the 1,000 km limit": "טוס פנימה עד שהתצוגה תיכנס למגבלה של 1,000 ק\"מ",
   "ZOOM IN": "התקרבות",
   "Imagery days, newest first · arrows move, S or A and B pin": "ימי צילומים, חדש בראש · החצים מזיזים, S או A ו-B מקבעים",
   "On the map": "על המפה",
@@ -2105,7 +2105,7 @@
   "Stopped (Esc)": "נעצר (Esc)",
   "SPARSE": "דליל",
   "BALANCED": "מאוזן",
-  "{duration}s + {hold}s": "{duration} שנ + {hold} שנ",
+  "{duration}s + {hold}s": "{duration} שנ׳ + {hold} שנ׳",
   "Cancel": "ביטול",
   "Shared flight follow expired": "עקיבת הטיסה המשותפת פגה",
   "Shared military flight follow expired": "עקיבת הטיסה הצבאית המשותפת פגה",
@@ -2124,8 +2124,8 @@
   "{id} isn't reporting now — showing where it was at {time}": "{id} לא מדווח עכשיו — מציג היכן היה ב-{time}",
   "This share link can't be opened": "לא ניתן לפתוח את קישור השיתוף הזה",
   "Shared vessel is unavailable": "האונייה המשותפת אינה זמינה",
-  "ACQUIRING": "אוסף",
-  "SHARED {subject}": "{subject} משותף",
+  "ACQUIRING": "מאתר",
+  "SHARED {subject}": "שיתוף: {subject}",
   "subject": "עצם",
   "LOADING LIVE DATA": "טוען נתונים חיים",
   "LOAD COMPLETE": "הטעינה הושלמה",
@@ -2133,9 +2133,9 @@
   "LOAD FAILED": "הטעינה נכשלה",
   "LIVE DATA OFF": "נתונים חיים כבויים",
   "MAPPED SITES LOADED": "אתרים ממופים נטענו",
-  "RETRYING MAPPED SITES": "מנסה שוב אתרים ממופים",
+  "RETRYING MAPPED SITES": "מנסה שוב לטעון אתרים ממופים",
   "FETCHING MAPPED SITES": "שולף אתרים ממופים",
-  "RETRYING ALPR CAMERAS": "מנסה שוב מצלמות ALPR",
+  "RETRYING ALPR CAMERAS": "מנסה שוב לטעון מצלמות ALPR",
   "FETCHING ALPR CAMERAS": "שולף מצלמות ALPR",
   "OVERPASS TEMPORARILY UNAVAILABLE": "OVERPASS אינו זמין זמנית",
   "OVERPASS RATE-LIMITED": "OVERPASS מוגבל בקצב",
@@ -2147,7 +2147,7 @@
   "REFRESHING LIVE DATA": "מרענן נתונים חיים",
   "syncing road network": "מסנכרן את רשת הכבישים",
   "retry pending": "ניסיון חוזר בתור",
-  "retrying in {seconds}s": "מנסה שוב בעוד {seconds} שנ",
+  "retrying in {seconds}s": "מנסה שוב בעוד {seconds} שנ׳",
   "ALPR cameras": "מצלמות ALPR",
   "OpenSky OAuth client missing/invalid": "לקוח ה-OAuth של OpenSky חסר או בלתי תקין",
   "OpenSky OAuth rejected credentials": "אישורי ה-OAuth של OpenSky נדחו",
@@ -2167,7 +2167,7 @@
     "other": "{count} קבוצות CelesTrak אינן זמינות"
   },
   "{feed} feed unavailable": "הפיד {feed} אינו זמין",
-  "Source snapshot {minutes} min old": "תמונת המצב של המקור בת {minutes} דק",
+  "Source snapshot {minutes} min old": "תמונת המצב של המקור בת {minutes} דק׳",
   "{source} rate limited (anonymous)": "{source} מוגבל בקצב (אנונימי)",
   "{source} rate limited": "{source} מוגבל בקצב",
   "{source} network error": "שגיאת רשת ב-{source}",
@@ -2204,15 +2204,15 @@
     "two": "{count} נשמעו",
     "other": "{count} נשמעו"
   },
-  "USB {rate} msg/s": "USB {rate} הודעות/שנ",
-  "{rate} msg/s": "{rate} הודעות/שנ",
+  "USB {rate} msg/s": "USB {rate} הודעות/שנ׳",
+  "{rate} msg/s": "{rate} הודעות/שנ׳",
   "{count} feeds live": {
     "one": "{count} פיד חי",
     "two": "{count} פידים חיים",
     "other": "{count} פידים חיים"
   },
-  "{feed} {count} ({seconds}s old)": "{feed} {count} (בן {seconds} שנ)",
-  "Street Level toggle failed": "החלפת Street Level נכשלה",
+  "{feed} {count} ({seconds}s old)": "{feed} {count} (בן {seconds} שנ׳)",
+  "Street Level toggle failed": "שינוי המצב של Street Level נכשל",
   "Street Level could not start": "Street Level לא הצליח להתחיל",
   "ANY DATE": "תאריך כלשהו",
   "LAST 10 YEARS": "10 השנים האחרונות",
@@ -2239,7 +2239,7 @@
   "Open {names} at the centre of the view": "פתח את {names} במרכז התצוגה",
   "Zoom in to a street to open {names} here": "התקרב לרחוב כדי לפתוח את {names} כאן",
   "Switch Street Level on to draw its coverage.": "הפעל Street Level כדי לצייר את כיסויו.",
-  "Every provider is switched off: light a chip to draw its coverage.": "כל הספקים כבויים: הדלק שבב כדי לצייר את כיסויו.",
+  "Every provider is switched off: light a chip to draw its coverage.": "כל הספקים כבויים: הפעל ספק כדי לצייר את הכיסוי שלו.",
   "Loading this sequence…": "טוען את הרצף הזה…",
   "{n} images in this sequence · Esc clears": {
     "one": "{n} תמונה ברצף הזה · Esc מנקה",
@@ -2315,8 +2315,8 @@
   "Emulate a green phosphor CRT with scanlines and screen curvature.": "הדמיית CRT פוספור ירוק עם קווי סריקה ועקמומיות מסך.",
   "Simulate night-vision goggles with green intensification and a tube vignette.": "הדמיית משקפי ראיית לילה עם הבהרה ירוקה ווינייטת צינור.",
   "Simulate FLIR-style thermal contrast. Turn up Ironbow for color.": "הדמיית ניגודיות תרמית דמוית FLIR. הגדל את Ironbow לצבע.",
-  "Apply bright cel-shaded color and illustrated outlines.": "החלת צבע מובלט בסגנון אנימציה וקווי מתאר מומחשים.",
-  "Apply high-contrast monochrome film-noir grading.": "החלת גיוון חד-צבעי ניגודי בסגנון פילם-נואר.",
+  "Apply bright cel-shaded color and illustrated outlines.": "החלת צבעים עזים בסגנון אנימציה וקווי מתאר מאוירים.",
+  "Apply high-contrast monochrome film-noir grading.": "החלת עיבוד צבע חד-צבעי בניגודיות גבוהה, בסגנון פילם נואר.",
   "MAP SOURCE": "מקור מפה",
   "Map source": "מקור מפה",
   "Style": "סגנון",
@@ -2332,7 +2332,7 @@
   "Imagery days in the box": "ימי הצילומים בתיבה",
   "Context mode": "מצב ההקשר",
   "CONTACTS": "מגעים",
-  "Cycles the nearest contacts of whatever type you select — planes, vessels, installations. Satellites track independently.": "מחזר את המגעים הקרובים מהסוג שתבחר — מטוסים, אוניות, מתקנים. לוויינים נעקבים בנפרד.",
+  "Cycles the nearest contacts of whatever type you select — planes, vessels, installations. Satellites track independently.": "עובר בין המגעים הקרובים מהסוג שתבחר — מטוסים, אוניות, מתקנים. לוויינים נעקבים בנפרד.",
   "SPACE MISSIONS": "משימות חלל",
   "SELECT CONTEXT": "בחירת ההקשר",
   "CONTACTS — nearest planes · vessels · sites": "מגעים — המטוסים הקרובים · אוניות · אתרים",
@@ -2363,7 +2363,7 @@
   "STOP": "עצירה",
   "Play the shot after the selected one, moving on to the next scene when needed": "ניגון השוט שאחרי הנבחר, עם מעבר לסצנה הבאה כשצריך",
   "SAVE & SHARE": "שמירה ושיתוף",
-  "Download every scene as a JSON file you can import later": "הורדת כל סצנה כקובץ JSON לייבוא בהמשך",
+  "Download every scene as a JSON file you can import later": "הורדת כל הסצנות בקובץ JSON אחד לייבוא בהמשך",
   "Load scenes from an exported JSON file": "טעינת סצנות מקובץ JSON שיוצא",
   "IMPORT": "ייבוא",
   "Download the timing log of the last play": "הורדת יומן התזמון של הנגינה האחרונה",
@@ -2378,7 +2378,7 @@
   "GROUND STATION · PROVIDER SETTINGS": "תחנת קרקע · הגדרות ספקים",
   "Close key setup": "סגירת הגדרת המפתח",
   "Power up the globe": "שדרוג הגלובוס",
-  "The globe already flies keyless. Every key below switches on another real feed — paste one and it's saved into this app's local configuration, then the server restarts itself. Server-side keys stay on this machine; Google Maps and Cesium ion run in the browser and must be provider-restricted. Keys you configured elsewhere are shown but never touched.": "הגלובוס כבר עף בלי מפתחות. לכל מפתח להלן הזנה אמיתית נוספת — הדבק אחד והוא נשמר לתצורה המקומית של האפליקציה, ואז השרת מאתחל את עצמו. מפתחות של שרת נשארים במכונה הזאת; Google Maps ו-Cesium ion רצים בדפדפן וחייבים הגבלה אצל הספק. מפתחות שהגדרת במקום אחר מוצגים, אך האפליקציה לעולם אינה משנה אותם.",
+  "The globe already flies keyless. Every key below switches on another real feed — paste one and it's saved into this app's local configuration, then the server restarts itself. Server-side keys stay on this machine; Google Maps and Cesium ion run in the browser and must be provider-restricted. Keys you configured elsewhere are shown but never touched.": "הגלובוס כבר פועל בלי מפתחות. כל מפתח להלן מפעיל פיד אמיתי נוסף — הדבק אחד והוא נשמר לתצורה המקומית של האפליקציה, ואז השרת מאתחל את עצמו. מפתחות של שרת נשארים במכונה הזאת; Google Maps ו-Cesium ion רצים בדפדפן וחייבים הגבלה אצל הספק. מפתחות שהגדרת במקום אחר מוצגים, אך האפליקציה לעולם אינה משנה אותם.",
   "This key runs in the browser by design — restrict it at the provider (see SECURITY.md)": "מפתח זה רץ בדפדפן מתוך תכנון — הגבל אותו אצל הספק (ראה SECURITY.md)",
   "browser-side": "בצד הדפדפן",
   "Supplied by your environment, Keychain, or launcher — change it where it was set": "מסופק על ידי הסביבה, ה-Keychain או מריץ ההפעלה — שנה אותו במקום שבו הוגדר",
@@ -2397,7 +2397,7 @@
   "ESC to close": "Esc לסגירה",
   "Visible map targets": "היעדים הגלויים במפה",
   "NO PLACE LEFT BEHIND": "בלי מקום שנשאר מאחור",
-  "Rendered globe frames per second · toggle with `": "פריימי גלובוס לשנייה · החלפה עם `",
+  "Rendered globe frames per second · toggle with `": "פריימי גלובוס לשנייה · הצגה/הסתרה עם `",
   "ACTIVE STYLE": "הסגנון הפעיל",
   "ORBIT": "הקפה",
   "No shots yet. Use CAPTURE SHOT to save current look.": "אין עדיין שוטים. השתמש בלכידת שוט כדי לשמור את המראה הנוכחי.",
@@ -2423,8 +2423,8 @@
   "Close event layer": "סגירת שכבת האירוע",
   "OBSERVED IMAGERY": "צילומים נצפים",
   "SCHEMATIC CORRIDOR": "מסדרון סכמטי",
-  "2021 HISTORICAL REFERENCE / 2026 POST-EVENT": "מקור היסטורי 2021 / אחרי האירוע 2026",
-  "Historical reference and post-event image split": "הפיצול בין תמונת המקור ההיסטורי לתמונה שאחרי האירוע",
+  "2021 HISTORICAL REFERENCE / 2026 POST-EVENT": "ייחוס היסטורי 2021 / אחרי האירוע 2026",
+  "Historical reference and post-event image split": "הפיצול בין תמונת הייחוס ההיסטורית לתמונה שאחרי האירוע",
   "Story beat navigation": "ניווט קטעי הסיפור",
   "Play the next shot and continue through this scene": "נגינת השוט הבא והמשך לאורך הסצנה הזאת",
   "↗ OPEN ORIGINAL": "↗ פתח את המקור",
@@ -2433,16 +2433,16 @@
   "GEOLOCATIONS · {credit}": "מיקומים גיאוגרפיים · {credit}",
   "↗ OPEN PUBLIC MAP": "↗ פתח מפה ציבורית",
   " Clouds are preserved from the source imagery.": " העננים נשמרו מצילומי המקור.",
-  "ACQUIRING FRAME": "אוסף שקופית",
+  "ACQUIRING FRAME": "טוען שקופית",
   "CCTV ON": "CCTV פעיל",
   "CCTV OFF": "CCTV כבוי",
-  "NEAREST": "הקרוב",
+  "NEAREST": "הקרובה",
   "CCTV camera": "מצלמת CCTV",
   "CALIBRATION": "כיול",
   "Drag the camera in the world: rings rotate, arrows move, handles set range/FOV": "גרור את המצלמה בעולם: טבעות מסובבות, חצים מזיזים, נקודות אחיזה קובעות טווח/FOV",
   "Camera pose — click a value to type": "מצב המצלמה — לחץ על ערך להקלדה",
   "Heading (compass °) — click to type": "כיוון (מעלות מצפן) — לחץ להקלדה",
-  "Pitch (° up/down) — click to type": "הטיה (° למעלה/למטה) — לחץ להקלדה",
+  "Pitch (° up/down) — click to type": "הטייה (° למעלה/למטה) — לחץ להקלדה",
   "Horizontal FOV (°) — click to type": "FOV אופקי (°) — לחץ להקלדה",
   "Range / monitor-plane distance (m) — click to type": "טווח / מרחק למישור המוניטור (מ׳) — לחץ להקלדה",
   "Mount height above ground (m) — click to type": "גובה ההרכבה מעל הקרקע (מ׳) — לחץ להקלדה",
@@ -2451,7 +2451,7 @@
   "SAVE CAL": "שמירת כיול",
   "RESET CAL": "איפוס כיול",
   "SCENE SUMMARY": "סיכום הסצנה",
-  "Fly to Tokyo": "עיפה אל טוקיו",
+  "Fly to Tokyo": "טוס אל טוקיו",
   "Show live flights": "הצגת טיסות חיות",
   "AI chat": "צ׳אט AI",
   "GEV CHAT": "צ׳אט GEV",
@@ -2489,7 +2489,7 @@
   "Live signals": "אותות חיים",
   "Latest regional news": "חדשות אזוריות אחרונות",
   "Location-based information": "מידע לפי מקום",
-  "TEMP": "טמפ",
+  "TEMP": "טמפ׳",
   "WIND": "רוח",
   "SKY": "שמיים",
   "PRECIP": "משקעים",
@@ -2497,7 +2497,7 @@
   "Weather data by Open-Meteo.com": "נתוני מזג אוויר מאת Open-Meteo.com",
   "Cockpit briefing pages": "עמודי התדריך של תא הטייס",
   "Show Live Signals": "הצגת אותות חיים",
-  "SIG": "אות",
+  "SIG": "אותות",
   "Show Regional News": "הצגת חדשות אזוריות",
   "NEWS": "חדשות",
   "Show Local Info": "הצגת מידע מקומי",
@@ -2518,10 +2518,10 @@
   "SITE": "אתר",
   "NEAREST OBSERVED / MAPPED": "הנצפים / הממופים הקרובים",
   "WX": "WX",
-  "Estimated flight plan": "תכנון הטיסה המשוער",
+  "Estimated flight plan": "תוכנית הטיסה המשוערת",
   "ESTIMATED FLIGHT PLAN": "תוכנית טיסה משוערת",
-  "FROM": "מ-",
-  "TO": "אל",
+  "FROM": "מוצא",
+  "TO": "יעד",
   "Collapse Cockpit display options": "קיפול אפשרויות התצוגה של תא הטייס",
   "Expand Cockpit display options": "הרחבת אפשרויות התצוגה של תא הטייס",
   "Collapse Cockpit Radio controls": "קיפול פקדי הרדיו של תא הטייס",
@@ -2571,13 +2571,13 @@
   "Fade": "התפוגגות",
   "Detection fade distance": "מרחק התפוגגות הזיהוי",
   "World-overlay fade distance outside the keyhole as a percentage of its radius": "מרחק התפוגגות שכבות העולם מחוץ לחור המנעול, כאחוז מרדיוסו",
-  "Outside": "מחוץ",
+  "Outside": "בחוץ",
   "Detection opacity outside the keyhole": "אטימות הזיהוי מחוץ לחור המנעול",
   "World-overlay label and card opacity beyond the fade distance": "אטימות התוויות והכרטיסים של שכבות העולם מעבר למרחק ההתפוגגות",
   "PARAMETERS": "פרמטרים",
-  "3D aircraft — flat icons zoomed out, 3D models up close": "מטוסים תלת-הממדיים — סמלים שטוחים בזום החוצה, דגמים תלת-הממדיים מקרוב",
+  "3D aircraft — flat icons zoomed out, 3D models up close": "מטוסים תלת-ממדיים — סמלים שטוחים בזום החוצה, דגמים תלת-ממדיים מקרוב",
   "Models": "דגמים",
-  "3D model coverage": "כיסוי דגמים תלת-הממדיים",
+  "3D model coverage": "כיסוי דגמים תלת-ממדיים",
   "Scope — the circular viewport mask": "סקופ — מסכת התצוגה העגולה",
   "Scope": "סקופ",
   "Feather": "ריכוך",
@@ -2597,7 +2597,7 @@
   "Remove every mark from the board": "הסרת כל סימן מהלוח",
   "Clear": "ניקוי",
   "Drawn shapes": "צורות ששורטטו",
-  "Show your own GeoJSON, KML, KMZ or GPX files on the globe (or drop them onto it). File bytes stay on this device; overlays can appear in map screenshots shared with voice.": "הצגת קבצי GeoJSON, KML, KMZ או GPX משלך על הגלובוס (או גרירתם אליו). בתי הקבצים נשארים במכשיר הזה; שכבות-על עשויות להופיע בצילומי מסך המשותפים עם הקול.",
+  "Show your own GeoJSON, KML, KMZ or GPX files on the globe (or drop them onto it). File bytes stay on this device; overlays can appear in map screenshots shared with voice.": "הצגת קבצי GeoJSON, KML, KMZ או GPX משלך על הגלובוס (או גרירתם אליו). תוכן הקבצים נשאר במכשיר הזה; שכבות-על עשויות להופיע בצילומי מסך המשותפים עם הקול.",
   "Import": "ייבוא",
   "Choose GeoJSON, KML, KMZ or GPX files": "בחירת קבצי GeoJSON, KML, KMZ או GPX",
   "Imported files": "קבצים שיובאו",
@@ -2651,7 +2651,7 @@
   "Available Space Missions": "משימות החלל הזמינות",
   "AVAILABLE MISSIONS": "המשימות הזמינות",
   "SELECT A MISSION TO INSPECT": "בחר משימה לבחינה",
-  "LOADING 30-DAY MISSION INDEX": "טוען את מפתח המשימות ל-30 יום",
+  "LOADING 30-DAY MISSION INDEX": "טוען את רשימת המשימות ל-30 יום",
   "TAB PREVIEWS · ENTER / SPACE SELECTS": "Tab לתצוגה מקדימה · Enter / מקש הרווח בוחר",
   "Panel position": "מקום הפאנל",
   "Move above the dock": "מעבר מעל העגינה",
@@ -2664,7 +2664,7 @@
   "Expand Radio": "הרחבת הרדיו",
   "Collapse Radio": "קיפול הרדיו",
   "Internet radio and local SDR": "רדיו אינטרנט ו-SDR מקומי",
-  "STATION TAG": "תגי תחנה",
+  "STATION TAG": "תגית תחנה",
   "Filter stations by station tag": "סינון תחנות לפי תגית התחנה",
   "Enable Radio, then choose a globe marker or use next.": "הפעל את הרדיו, ואז בחר סמן על הגלובוס או השתמש בהבא.",
   "Radio playback": "נגינת הרדיו",
@@ -2676,7 +2676,7 @@
   "STATION SITE": "אתר התחנה",
   "DIRECTORY: RADIO BROWSER": "מדריך: RADIO BROWSER",
   "Audio connects directly to the broadcaster when you press play, choose a station on the globe or ask voice to play. Your IP is visible to that broadcaster.": "השמע מתחבר ישירות למשדר כשלוחצים על נגן, בוחרים תחנה בגלובוס או מבקשים בקול לנגן. ה-IP שלך גלוי למשדר הזה.",
-  "DRAG TO TUNE": "גרירה לכיוון",
+  "DRAG TO TUNE": "גרור לכוונון",
   "Tune available internet radio stations": "כוונון תחנות הרדיו הזמינות באינטרנט",
   "ALL · DRAG THE NEEDLE": "הכול · גרור את המחט",
   "SNAPS TO AVAILABLE STATIONS": "נצמד לתחנות הזמינות",
@@ -2690,17 +2690,17 @@
   "Scene actions": "פעולות סצנה",
   "Local RTL-SDR receiver": "מקלט RTL-SDR מקומי",
   "LOCAL RTL-SDR": "RTL-SDR מקומי",
-  "Chrome/Edge · WebUSB · one local tuner shared by FM and the Local ADS-B layer.": "Chrome/Edge · WebUSB · מכוון מקומי אחד המשותף ל-FM ולשכבת Local ADS-B.",
+  "Chrome/Edge · WebUSB · one local tuner shared by FM and the Local ADS-B layer.": "Chrome/Edge · WebUSB · מכוון מקומי אחד המשותף ל-FM ולשכבת ADS-B מקומי.",
   "Use your location for faster ADS-B position decoding": "שימוש במיקומך לפענוח מהיר יותר של מיקומי ADS-B",
   "Choose a different RTL-SDR or receiver channel": "בחירת RTL-SDR או ערוץ מקלט אחר",
   "CHANGE DEVICE": "החלפת מכשיר",
   "RTL-SDR receiver mode": "מצב המקלט RTL-SDR",
-  "GAIN": "הגברה",
-  "RTL-SDR tuner gain for the current mode": "הגברת מכוון ה-RTL-SDR למצב הנוכחי",
+  "GAIN": "הגבר",
+  "RTL-SDR tuner gain for the current mode": "הגבר מכוון ה-RTL-SDR למצב הנוכחי",
   "AUTO": "אוטומטי",
   "MSG/S": "MSG/S",
   "HEARD": "נשמעו",
-  "POSITIONED": "הוגדר מקום",
+  "POSITIONED": "עם מיקום",
   "FM MHZ": "FM MHZ",
   "TUNE": "כוונון",
   "Seek broadcast FM stations": "חיפוש תחנות FM שידוריות",
@@ -2748,7 +2748,7 @@
   "Close voice panel": "סגירת פאנל הקול",
   "Latest voice exchange": "חילופי הקול האחרונים",
   "Try saying": "נסה לומר",
-  "What am I looking at?": "מה עיני רואות?",
+  "What am I looking at?": "על מה אני מסתכל?",
   "AI Provider": "ספק AI",
   "The selected AI provider is shared by voice and chat.": "ספק ה-AI הנבחר משותף לקול ולצ׳אט.",
   "Show quick commands": "הצגת פקודות מהירות",
@@ -2782,13 +2782,13 @@
   "Detection overlay: {mode}": "שכבת הזיהוי: {mode}",
   "Detection overlay: off": "שכבת הזיהוי: כבויה",
   "Active weather": "מזג אוויר פעיל",
-  "{time} · {minutes} min ago": "{time} · לפני {minutes} דק",
+  "{time} · {minutes} min ago": "{time} · לפני {minutes} דק׳",
   "LATEST · newest per product": "האחרון · החדש ביותר לכל מוצר",
   "Forecast · valid {valid} · issued {issued}": "תחזית · תקפה {valid} · פורסמה {issued}",
   "{detail} · Does not follow history": "{detail} · אינו נע עם ההיסטוריה",
   "Forecast · valid {valid}": "תחזית · תקפה {valid}",
   "You can attach up to four items.": "ניתן לצרף עד ארבעה פריטים.",
-  "Attachments are too large together. Use smaller files.": "הקבצים המצורפים גדולים יחד. השתמש בקבצים קטנים יותר.",
+  "Attachments are too large together. Use smaller files.": "הקבצים המצורפים גדולים מדי יחד. השתמש בקבצים קטנים יותר.",
   "Choose a TXT, Markdown, CSV, JSON or GeoJSON file.": "בחר קובץ TXT, Markdown, CSV, JSON או GeoJSON.",
   "Each file must be 10 KB or smaller.": "כל קובץ חייב להיות בן 10 ק\"ב לכל היותר.",
   "Choose a non-empty UTF-8 text file.": "בחר קובץ טקסט UTF-8 לא ריק.",
@@ -2804,7 +2804,7 @@
   "Connection timed out. Try again.": "החיבור חרג מהזמן הקצוב. נסה שוב.",
   "Chat closed.": "הצ׳אט נסגר.",
   "Connection stopped.": "החיבור הופסק.",
-  "Message and attachments are too large. Remove an attachment or shorten your message.": "ההודעה והקבצים המצורפים גדולים יחד. הסר קובץ מצורף או קצר את ההודעה.",
+  "Message and attachments are too large. Remove an attachment or shorten your message.": "ההודעה והקבצים המצורפים גדולים מדי. הסר קובץ מצורף או קצר את ההודעה.",
   "Message was not sent. Try again.": "ההודעה לא נשלחה. נסה שוב.",
   "Reply stopped.": "התשובה נעצרה.",
   "Reset to globe view": "איפוס לתצוגת הגלובוס",
@@ -2818,7 +2818,7 @@
   "THIS": "זה",
   "Changing provider reconnects voice if it is on.": "החלפת הספק מחברת מחדש את הקול אם הוא פעיל.",
   "STD": "רגיל",
-  "Voice control — activate to toggle voice; hold Space to speak": "שליטה קולית — הפעל להחלפת קול; החזק Space כדי לדבר",
+  "Voice control — activate to toggle voice; hold Space to speak": "שליטה קולית — הפעל כדי להדליק או לכבות את הקול; החזק Space כדי לדבר",
   "ON/OFF": "פעיל/כבוי",
   "VOICE STANDBY": "הקול בהמתנה",
   "Hold Space to speak · tap Space to activate focused controls": "החזק Space לדיבור · הקש Space להפעלת הפקדים במוקד",
@@ -2893,7 +2893,7 @@
   "mini": "מיני",
   "COST UNKNOWN": "העלות לא ידועה",
   "ChatGPT OAuth session: {responses} response(s), {input} input and {output} output tokens, {captions} caption transcription(s) reported.": "הפעלת OAuth של ChatGPT: {responses} תשובות, {input} אסימוני קלט ו-{output} אסימוני פלט, {captions} תמלולי כתוביות שדווחו.",
-  "USD cost and the API spend cap are unavailable for this auth mode.": "העלות ב-USD ותקרת ההוצאה של ה-API אינם זמינים לאימות הזה.",
+  "USD cost and the API spend cap are unavailable for this auth mode.": "העלות ב-USD ותקרת ההוצאה של ה-API אינן זמינות במצב האימות הזה.",
   "Usage is incomplete because a response was still in flight when the session ended.": "השימוש חסר כי תשובה עוד הייתה בעיצומה כשההפעלה הסתיימה.",
   "Estimated session cost on {modelId} — {responses} response(s). Warns at {warn}, ends the session at {cap}.": "עלות ההפעלה המוערכת על {modelId} — {responses} תשובות. מזהיר ב-{warn}, מסיים את ההפעלה ב-{cap}.",
   "Estimate is incomplete — a response was still in flight when the session ended, so its usage was never reported.": "ההערכה חסרה — תשובה עוד הייתה בעיצומה כשההפעלה הסתיימה, ולכן השימוש שלה לא דווח מעולם.",
@@ -2999,7 +2999,7 @@
   "{items} {scope}": "{items} {scope}",
   "last 24 h": "24 השעות האחרונות",
   "past 30 d and upcoming": "30 הימים האחרונים והקרובים",
-  "the flights layer loads by viewport": "שכבת הטיסות נטענת לרוחב התצוגה",
+  "the flights layer loads by viewport": "שכבת הטיסות נטענת לפי אזור התצוגה",
   "distance is ground distance, not overhead": "המרחק הוא מרחק קרקע, לא ישירות מלמעלה",
   "the count is a lower bound because at least one layer reached its retained limit.": "המניין הוא גבול תחתון כי לפחות שכבה אחת הגיעה למגבלת השמירה שלה.",
   "buffer sized to the place": "חיץ בגודל המקום",
@@ -3019,26 +3019,26 @@
   },
   "{drawn} of {total} parts drawn": {
     "one": "שורטט {drawn} מתוך {total} חלק",
-    "two": "שורטטו {drawn} מתוך {total} חלקים",
-    "other": "שורטטו {drawn} מתוך {total} חלקים"
+    "two": "חלקים ששורטטו: {drawn} מתוך {total}",
+    "other": "חלקים ששורטטו: {drawn} מתוך {total}"
   },
   "{count} duplicate mappings merged": {
     "one": "מוזג {count} מיפוי כפול",
     "two": "מוזגו {count} מיפויים כפולים",
     "other": "מוזגו {count} מיפויים כפולים"
   },
-  "listed the first {limit}": "הוצגו הראשונים {limit}",
+  "listed the first {limit}": "הוצגו {limit} הראשונים",
   "counted over the bounding box of {area}, not its outline": "נספר לפי תיבת ההקפה של {area}, לא לפי קו המתאר שלה",
   "counted the first {returned} loaded records": "נספרו {returned} הרשומות הראשונות הטעונות",
   "counted {returned} of {total} loaded records": "נספרו {returned} מתוך {total} רשומות טעונות",
   "{layers} just turned on — still loading, counts will rise": "{layers} הופעלו זה עתה — עדיין בטעינה, המניינים יגדלו",
-  "Contacts panel snapshot at {time} — the same retained cohort supplies the card, speech, and follow-up memory": "תמונת מצב של פאנל המגעים ב-{time} — אותה קבוצה נשמרת מספקת את הכרטיס, הדיבור והזיכרון להמשך",
-  "Contacts panel snapshot — the same retained cohort supplies the card, speech, and follow-up memory": "תמונת מצב של פאנל המגעים — אותה קבוצה נשמרת מספקת את הכרטיס, הדיבור והזיכרון להמשך",
-  "Fly below {km} km to a covered region": "עוף מטה מתחת ל-{km} ק\"מ אל אזור הזנה",
+  "Contacts panel snapshot at {time} — the same retained cohort supplies the card, speech, and follow-up memory": "תמונת מצב של פאנל המגעים ב-{time} — אותה קבוצה שמורה מספקת את הכרטיס, הדיבור והזיכרון להמשך",
+  "Contacts panel snapshot — the same retained cohort supplies the card, speech, and follow-up memory": "תמונת מצב של פאנל המגעים — אותה קבוצה שמורה מספקת את הכרטיס, הדיבור והזיכרון להמשך",
+  "Fly below {km} km to a covered region": "טוס מתחת ל-{km} ק\"מ אל אזור עם כיסוי",
   "No feed here yet · {n} regions available": {
-    "one": "אין עדיין הזנה כאן · {n} אזור זמין",
-    "two": "אין עדיין הזנה כאן · {n} אזורים זמינים",
-    "other": "אין עדיין הזנה כאן · {n} אזורים זמינים"
+    "one": "אין עדיין פיד כאן · {n} אזור זמין",
+    "two": "אין עדיין פיד כאן · {n} אזורים זמינים",
+    "other": "אין עדיין פיד כאן · {n} אזורים זמינים"
   },
   "degraded": "מופחת",
   "stale": "מיושן",
@@ -3057,9 +3057,9 @@
     "other": "{count} מתוך {total} אחזורים תואמים"
   },
   "{n} acquisitions searched": {
-    "one": "נחפשו {n} אחזורים",
-    "two": "נחפשו {n} אחזורים",
-    "other": "נחפשו {n} אחזורים"
+    "one": "נסרקו {n} אחזורים",
+    "two": "נסרקו {n} אחזורים",
+    "other": "נסרקו {n} אחזורים"
   },
   "No matching imagery": "אין צילומים תואמים",
   "Unknown number of {kind}": "מספר לא ידוע של {kind}",
@@ -3067,8 +3067,8 @@
   "At least {count} {kind}": "לפחות {count} {kind}",
   "{count} {kind}": "{count} {kind}",
   "In {area}": "ב-{area}",
-  "Toggle voice control": "החלפת שליטה קולית",
-  "Activate to toggle voice": "הפעל להחלפת הקול",
+  "Toggle voice control": "הפעלה או כיבוי של השליטה הקולית",
+  "Activate to toggle voice": "הפעל כדי להדליק או לכבות את הקול",
   "Voice active": "הקול פעיל",
   "Voice could not be started.": "לא ניתן היה להתחיל את הקול.",
   "{value} feet": "{value} רגל",
@@ -3090,11 +3090,11 @@
   "No military within {radius} of the current view": "אין טיסות צבאיות בטווח {radius} מהתצוגה הנוכחית",
   "No satellites within {radius} of the current view": "אין לוויינים בטווח {radius} מהתצוגה הנוכחית",
   "No vessels within {radius} of the current view": "אין אוניות בטווח {radius} מהתצוגה הנוכחית",
-  "{layer} is enabled on the {source} feed, but no airborne aircraft is loaded in the {place} view yet": "{layer} מופעל בהזנת {source}, אך אין עדיין מטוסים באוויר טעונים בתצוגת {place}",
-  "{layer} is enabled, but no airborne aircraft is loaded in the {place} view yet": "{layer} מופעל, אך אין עדיין מטוסים באוויר טעונים בתצוגת {place}",
-  "{layer} is enabled, but its aircraft feed is unavailable": "{layer} מופעל, אך הזנת המטוסים שלו אינה זמינה",
-  "{layer} is enabled, but its destination refresh did not complete": "{layer} מופעל, אך רענון היעד שלו לא הושלם",
-  "{layer} is enabled, but {source} is unavailable": "{layer} מופעל, אך {source} אינו זמין",
+  "{layer} is enabled on the {source} feed, but no airborne aircraft is loaded in the {place} view yet": "השכבה {layer} מופעלת בפיד {source}, אך עדיין לא נטענו מטוסים באוויר בתצוגת {place}",
+  "{layer} is enabled, but no airborne aircraft is loaded in the {place} view yet": "השכבה {layer} מופעלת, אך עדיין לא נטענו מטוסים באוויר בתצוגת {place}",
+  "{layer} is enabled, but its aircraft feed is unavailable": "השכבה {layer} מופעלת, אך פיד המטוסים שלה אינו זמין",
+  "{layer} is enabled, but its destination refresh did not complete": "השכבה {layer} מופעלת, אך רענון היעד שלה לא הושלם",
+  "{layer} is enabled, but {source} is unavailable": "השכבה {layer} מופעלת, אך המקור {source} אינו זמין",
   "Could not arrive at {place}": "לא ניתן להגיע אל {place}",
   "{name} is no longer loaded": "{name} אינו טעון עוד",
   "Unknown target layer: {target}": "שכבת יעד בלתי מוכרת: {target}",
@@ -3166,11 +3166,11 @@
   "Change context mode": "שינוי מצב ההקשר",
   "Control cockpit": "שליטה בתא הטייס",
   "Change visual style": "שינוי סגנון הראייה",
-  "Adjust HUD": "כיוון ה-HUD",
-  "Adjust cyber sonar": "כיוון הסונאר הסייברי",
-  "Adjust detection overlay": "כיוון שכבת הזיהוי",
-  "Change map stack": "שינוי ערמת המפות",
-  "Adjust post-processing": "כיוון עיבוד שלאחר",
+  "Adjust HUD": "כוונון ה-HUD",
+  "Adjust cyber sonar": "כוונון הסונאר הסייברי",
+  "Adjust detection overlay": "כוונון שכבת הזיהוי",
+  "Change map stack": "שינוי ערכת המפות",
+  "Adjust post-processing": "כוונון העיבוד שלאחר הרינדור",
   "Control scene": "שליטה בסצנה",
   "Control CCTV": "שליטה ב-CCTV",
   "Control radio": "שליטה ברדיו",
@@ -3188,7 +3188,7 @@
   "Fly to {place}": "טיסה אל {place}",
   "Fly to Location": "טיסה אל המיקום",
   "Nearest aircraft to {place}": "המטוס הקרוב ביותר אל {place}",
-  "Nearest aircraft to Here": "המטוס הקרוב ביותר אל כאן",
+  "Nearest aircraft to Here": "המטוס הקרוב ביותר לכאן",
   "Layer on": "השכבה פעילה",
   "Layer off": "השכבה כבויה",
   "Zoom out": "התרחקות",
@@ -3208,7 +3208,7 @@
   "Finding places": "מחפש מקומות",
   "Tracing outline": "משרטט קו מתאר",
   "Looking up place": "מאתר מקום",
-  "Flying": "עף",
+  "Flying": "טס",
   "Turning on layer": "מפעיל את השכבה",
   "Loading aircraft": "טוען מטוסים",
   "Picking nearest": "בוחר את הקרוב",
@@ -3220,8 +3220,8 @@
   "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "צ׳אט בהקלדה אינו זמין בזמן ש-GEV_PREFER_CODEX_OAUTH דורש OAuth של ChatGPT.",
   "The provider rejected the API key. Check it in Provider Settings.": "הספק דחה את מפתח ה-API. בדוק אותו בהגדרות הספקים.",
   "The provider refused access for this key. Check the key's project, region or permissions.": "הספק סירב לאשר גישה למפתח הזה. בדוק את הפרויקט, האזור או ההרשאות של המפתח.",
-  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "לחשבון הספק נגמר האשראי. בדוק את החיוב שלו, או בחר ספק AI אחר בהגדרות.",
-  "Too many chat requests. Try again in {seconds} s.": "יותר מדי בקשות צ׳אט. נסה שוב בעוד {seconds} שנ.",
+  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "לחשבון הספק נגמרה היתרה. בדוק את החיוב שלו, או בחר ספק AI אחר בהגדרות.",
+  "Too many chat requests. Try again in {seconds} s.": "יותר מדי בקשות צ׳אט. נסה שוב בעוד {seconds} שנ׳.",
   "That request needed too many steps. Changes already made to the map stay in place.": "הבקשה הזאת דרשה יותר מדי צעדים. השינויים שכבר בוצעו במפה נשארים במקומם.",
   "That request needed too many steps. Try a simpler request.": "הבקשה הזאת דרשה יותר מדי צעדים. נסה בקשה פשוטה יותר.",
   "in progress": "בעבודה",
@@ -3238,12 +3238,12 @@
   "Initializing photorealistic world...": "מאתחל את העולם הפוטוריאליסטי...",
   "Event age": "גיל האירוע",
   "event age filter|All": "הכול",
-  "{days}d": "{days} יום",
+  "{days}d": "{days} ימ׳",
   "Show markers of every age": "הצגת סמנים בכל גיל",
-  "Maximum event age: {days}d; undated markers are kept": "גיל אירוע מרבי: {days} יום; סמנים ללא תאריך נשמרים",
+  "Maximum event age: {days}d; undated markers are kept": "גיל אירוע מרבי: {days} ימ׳; סמנים ללא תאריך נשמרים",
   "All markers": "כל הסמנים",
-  "Event age: {days}d · undated kept": "גיל האירוע: {days} יום · ללא תאריך נשמרים",
-  "30-DAY MISSION INDEX UNAVAILABLE": "מפתח המשימות ל-30 יום אינו זמין",
+  "Event age: {days}d · undated kept": "גיל האירוע: {days} ימ׳ · ללא תאריך נשמרים",
+  "30-DAY MISSION INDEX UNAVAILABLE": "רשימת המשימות ל-30 יום אינה זמינה",
   "STATIONS": "תחנות",
   "Crewed stations and the craft that visit them": "תחנות מאוישות והחלליות המבקרות בהן",
   "IMAGING": "צילום",
@@ -3256,9 +3256,9 @@
   "Space science, technology demonstration and other payloads": "מדע בחלל, הדגמות טכנולוגיה ומטענים אחרים",
   "DEBRIS": "פסולת חלל",
   "Rocket bodies, fragments and dead satellites": "גופי משגרים, שברים ולוויינים מתים",
-  "Classes may lag: SATCAT is a cached copy": "הקבוצות עשויות להשתהות: SATCAT הוא תמונת מצב במטמון",
-  "Classes may lag: SATCAT unavailable": "הקבוצות עשויות להשתהות: SATCAT אינו זמין",
-  "CelesTrak SATCAT gives each object's type and status. Without a current copy the classes rest on the UCS database, names and CelesTrak groups, so a satellite that has died since may still show as working.": "CelesTrak SATCAT נותן לכל עצם סוג ומצב. בלי תמונת מצב עדכנית הקבוצות נשענות על מאגר UCS, השמות וקבוצות CelesTrak, ולכן לוויין שמת מאז עשוי עדיין להיראות פעיל.",
+  "Classes may lag: SATCAT is a cached copy": "הסיווגים עשויים לפגר: SATCAT הוא עותק מהמטמון",
+  "Classes may lag: SATCAT unavailable": "הסיווגים עשויים לפגר: SATCAT אינו זמין",
+  "CelesTrak SATCAT gives each object's type and status. Without a current copy the classes rest on the UCS database, names and CelesTrak groups, so a satellite that has died since may still show as working.": "CelesTrak SATCAT נותן לכל עצם סוג ומצב. בלי עותק עדכני הסיווגים נשענים על מאגר UCS, השמות וקבוצות CelesTrak, ולכן לוויין שמת מאז עשוי עדיין להיראות פעיל.",
   "Lines": "קווים",
   "Road lines colored by live flow: green to red": "קווי כבישים בצבע לפי זרימה חיה: מירוק לאדום",
   "Dots": "נקודות",
@@ -3267,14 +3267,14 @@
   "Monthly traffic allowance used": "הקצבה החודשית לתנועה נוצלה",
   "Traffic rate limit reached": "הגעת למגבלת הקצב של שירות התנועה",
   "Traffic service unavailable": "שירות התנועה אינו זמין",
-  "LOOK STBD {bearing}°": "מבט ימין {bearing}°",
-  "LOOK PORT {bearing}°": "מבט שמאל {bearing}°",
+  "LOOK STBD {bearing}°": "מבט ימינה {bearing}°",
+  "LOOK PORT {bearing}°": "מבט שמאלה {bearing}°",
   "LOOK ASTERN": "מבט אחורה",
   "UP {angle}°": "מעלה {angle}°",
   "DOWN {angle}°": "מטה {angle}°",
   "{direction} · {elevation}": "{direction} · {elevation}",
-  "LOOK {elevation}": "LOOK {elevation}",
-  "{vesselType} · {feedState} · EYE {height}": "{vesselType} · {feedState} · עין {height}",
+  "LOOK {elevation}": "מבט {elevation}",
+  "{vesselType} · {feedState} · EYE {height}": "{vesselType} · {feedState} · גובה עין {height}",
   "LIVE AIS": "AIS חי",
   "CONTACT NAVIGATION OFF": "ניווט המגעים כבוי",
   "THE BRIDGE STAYS WITH THE SELECTED VESSEL": "הגשר נשאר עם האונייה הנבחרת",
@@ -3285,12 +3285,12 @@
   "RIGHT": "ימין",
   "LEFT": "שמאל",
   "{direction} {angle}°": "{direction} {angle}°",
-  "OFF-NADIR {angle}° · {offset}": "OFF-NADIR {angle}° · {offset}",
+  "OFF-NADIR {angle}° · {offset}": "סטייה מהנדיר {angle}° · {offset}",
   "BRIDGE": "גשר",
   "{label} · NADIR VIEW": "{label} · תצוגת נדיר",
   "{label} · HEADING {heading}°": "{label} · כיוון {heading}°",
   "{label} · NO HEADING": "{label} · ללא כיוון",
-  "Space Missions unavailable: the mission index could not load. Try again later.": "משימות החלל אינן זמינות: טעינת מפתח המשימות נכשלה. נסה שוב מאוחר יותר.",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "משימות החלל אינן זמינות: טעינת רשימת המשימות נכשלה. נסה שוב מאוחר יותר.",
   "Close camera preview": "סגירת תצוגת המצלמה",
   "Refresh map still": "רענון תמונת המפה",
   "The map still uses a separate request and may show a different moment.": "תמונת המפה נשלפת בבקשה נפרדת ועשויה להראות רגע שונה.",
@@ -3319,35 +3319,35 @@
   "ARROWS TILT": "חצים להטיה",
   "HOME NADIR": "Home אל הנדיר",
   "ZOOM {zoom}×": "זום {zoom}×",
-  "SENSOR SWATH ≈ {value} KM": "רוחב חיישן ≈ {value} ק\"מ",
-  "SENSOR SWATH {value} KM": "רוחב חיישן {value} ק\"מ",
-  "SWATH ≈ {value} KM": "רוחב ≈ {value} ק\"מ",
-  "SWATH {value} KM": "רוחב {value} ק\"מ",
+  "SENSOR SWATH ≈ {value} KM": "רוחב רצועת החיישן ≈ {value} ק\"מ",
+  "SENSOR SWATH {value} KM": "רוחב רצועת החיישן {value} ק\"מ",
+  "SWATH ≈ {value} KM": "רוחב רצועה ≈ {value} ק\"מ",
+  "SWATH {value} KM": "רוחב רצועה {value} ק\"מ",
   "{division}, {country}": "{division}, {country}",
   "{region} · near {place}": "{region} · קרוב אל {place}",
   "NORAD {id}": "NORAD {id}",
   "EPOCH {time}": "EPOCH {time}",
-  "<1 H OLD": "פחות משעה",
-  "{value} H OLD": "{value} שע",
-  "{value} D OLD": "{value} ימ",
+  "<1 H OLD": "לפני פחות משעה",
+  "{value} H OLD": "לפני {value} שע׳",
+  "{value} D OLD": "לפני {value} ימ׳",
   "Orbital view": "תצוגה מסלולית",
   "CURRENTLY OVER": "כעת מעל",
-  "ORBITAL VIEW · OFF-NADIR": "תצוגה מסלולית · OFF-NADIR",
+  "ORBITAL VIEW · OFF-NADIR": "תצוגה מסלולית · סטייה מהנדיר",
   "ORBITAL VIEW · NADIR": "תצוגה מסלולית · נדיר",
-  "Hide the two-line element set": "הסתרת ערכת האלמנטים הדו-הקווית",
-  "Show the two-line element set": "הצגת ערכת האלמנטים הדו-הקווית",
+  "Hide the two-line element set": "הסתרת ערכת האלמנטים הדו-שורתית",
+  "Show the two-line element set": "הצגת ערכת האלמנטים הדו-שורתית",
   "TLE": "TLE",
-  "Two-line element set": "ערכת אלמנטים דו-הקווית",
+  "Two-line element set": "ערכת אלמנטים דו-שורתית",
   "ORBITAL VELOCITY": "מהירות מסלולית",
   "SUB-SATELLITE POINT": "נקודת תת-הלוויין",
-  "TRACK UP": "המעקב מעלה",
+  "TRACK UP": "מסלול מעלה",
   "NORTH UP": "צפון מעלה",
   "Return the view to nadir": "החזרת התצוגה אל הנדיר",
   "Return to nadir (Home or 0)": "חזרה אל הנדיר (Home או 0)",
   "NADIR": "נדיר",
   "Zoom out (−)": "התרחקות (−)",
   "Zoom in (+)": "התקרבות (+)",
-  "Zoom to the imaging sensor swath": "זום אל רוחב חיישן הצילום",
+  "Zoom to the imaging sensor swath": "זום אל רצועת הסריקה של חיישן הצילום",
   "SENSOR": "חיישן",
   "RINGS {spacing} NM": "טבעות {spacing} NM",
   "{count} CONTACTS": {
@@ -3359,21 +3359,21 @@
   "Bridge radar": "רדאר הגשר",
   "Reported voyage": "הפלגה שדווחה",
   "REPORTED VOYAGE": "הפלגה שדווחה",
-  "1 min/s": "דקה/שנ",
-  "1 h/s": "שעה/שנ",
-  "1 d/s": "יום/שנ",
-  "1 wk/s": "שבוע/שנ",
+  "1 min/s": "דקה/שנ׳",
+  "1 h/s": "שעה/שנ׳",
+  "1 d/s": "יום/שנ׳",
+  "1 wk/s": "שבוע/שנ׳",
   "World time": "הזמן העולמי",
   "Play speed": "מהירות הנגינה",
   "Scroll or pinch to zoom, drag to move along · double-click to see it all": "גלילה או צביטה לזום, גרירה להזזה לאורך · לחיצה כפולה לתצוגה המלאה",
   "Live": "חי",
-  "Back to live": "חזרה לחי",
+  "Back to live": "חזרה לזמן אמת",
   "STARLINK ···": "STARLINK ···",
   "STARLINK ✕": "STARLINK ✕",
   "SITES STANDBY": "האתרים בהמתנה",
-  "ENABLE MAPPED INSTALLATIONS FOR SITE PINGS": "הפעל את המתקנים הממופים כדי לקבל צפצופי אתרים",
+  "ENABLE MAPPED INSTALLATIONS FOR SITE PINGS": "הפעל את המתקנים הממופים כדי לקבל פינגים של אתרים",
   "Unnamed site": "אתר ללא שם",
-  "OFF-NADIR {angle}°": "OFF-NADIR {angle}°",
+  "OFF-NADIR {angle}°": "סטייה מהנדיר {angle}°",
   "Release the camera from {name}": "שחרור המצלמה מ-{name}",
   "Keep the camera on {name}": "השארת המצלמה על {name}",
   "RETURN · {name}": "חזרה · {name}",
@@ -3383,7 +3383,7 @@
   "Ride {name}": "רכיבה על {name}",
   "FOCUS · {name}": "מוקד · {name}",
   "Place names": "שמות מקומות",
-  "Fly below {km} km to a covered city": "טוס מטה מתחת ל-{km} ק\"מ אל עיר עם הזנה",
+  "Fly below {km} km to a covered city": "טוס מתחת ל-{km} ק\"מ אל עיר עם כיסוי",
   "No bike share here yet · {n} systems available": {
     "one": "אין עדיין שיתוף אופניים כאן · {n} מערכת זמינה",
     "two": "אין עדיין שיתוף אופניים כאן · {n} מערכות זמינות",
diff --git a/src/i18n/same-as-english.json b/src/i18n/same-as-english.json
index 34ca8c016..292b6ffaa 100644
--- a/src/i18n/same-as-english.json
+++ b/src/i18n/same-as-english.json
@@ -1279,13 +1279,11 @@
     "STARLINK",
     "STARLINK ···",
     "STARLINK ✕",
-    "LOOK {elevation}",
     "{range} NM",
-    "OFF-NADIR {angle}° · {offset}",
     "NORAD {id}",
     "EPOCH {time}",
     "TLE",
-    "OFF-NADIR {angle}°",
+    "{value} KM",
     "{value} KM/S",
     "Ironbow"
   ]
diff --git a/src/ui/styles/rtl.css b/src/ui/styles/rtl.css
index 2106b1bca..fa0179b70 100644
--- a/src/ui/styles/rtl.css
+++ b/src/ui/styles/rtl.css
@@ -4,11 +4,12 @@
    express. */
 
 /* Arabic letters join: letter-spacing tears every word into separate glyphs.
+   Hebrew letters do not join, but tracking only spaces their words out.
    Latin marked translate="no" and the intel HUD's Latin telemetry keep their
    tracking; the HUD's translated lines are released below. Unlike cjk.css, a
    container that merely holds a translate="no" span is not spared: its own
-   Arabic text would come apart. */
-html:lang(ar)
+   text would come apart. */
+html:is(:lang(ar), :lang(he))
   body
   :not(#intel-hud, #intel-hud *, [translate='no'], [translate='no'] *) {
   letter-spacing: 0 !important;
@@ -31,8 +32,7 @@ html[dir='rtl'] #intel-hud :is(.hud-mode, .hud-summary-label, .hud-summary) {
    letter apart. Noto Sans Arabic (loaded with the other Google fonts; its
    files download only when the page shows Arabic) leads the mono stack, so
    the spaces between Arabic words come from it too and not from the
-   fixed-pitch Latin face. The intel and cockpit HUDs keep JetBrains Mono for
-   their Latin telemetry and column-aligned digits. */
+   fixed-pitch Latin face. */
 html:lang(ar) {
   --font-mono:
     'Noto Sans Arabic', 'JetBrains Mono', 'SF Mono', 'Fira Code', 'Geeza Pro',
@@ -41,32 +41,11 @@ html:lang(ar) {
     'Inter', 'Noto Sans Arabic', -apple-system, BlinkMacSystemFont, 'Geeza Pro',
     Tahoma, sans-serif;
 }
-/* The Global Context lines and their buttons set ui-monospace through the
-   `font` shorthand; route them through the Arabic-aware stack too. */
-html:lang(ar)
-  :is(
-    #military-awareness-panel,
-    .military-awareness-controls button,
-    .military-awareness-standby button,
-    .military-awareness-compass-label,
-    .military-awareness-compass-heading,
-    .military-awareness-direction-label,
-    .tr3b-toggle
-  ) {
-  font-family: var(--font-mono);
-}
-html:lang(ar) :is(#intel-hud, #cockpit-hud) {
-  --font-mono:
-    'JetBrains Mono', 'SF Mono', 'Fira Code', 'Noto Sans Arabic', 'Geeza Pro',
-    Tahoma, monospace;
-}
 
 /* Hebrew: JetBrains Mono and Inter also lack Hebrew glyphs. Noto Sans Hebrew
    (loaded with the other Google fonts; its files download only when the page
    shows Hebrew) leads the stack so the body text keeps one proportional
-   Hebrew face across platforms. Hebrew letters do not join, so tracking on
-   them only spaces a word out; the body is released the same way, and the
-   HUDs keep their instrument tracking inside. */
+   Hebrew face across platforms. */
 html:lang(he) {
   --font-mono:
     'Noto Sans Hebrew', 'JetBrains Mono', 'SF Mono', 'Fira Code', Tahoma,
@@ -102,10 +81,6 @@ html:lang(he) :is(#intel-hud, #cockpit-hud) {
     'JetBrains Mono', 'SF Mono', 'Fira Code', 'Noto Sans Hebrew', Tahoma,
     monospace;
 }
-html:lang(he) body
-  :not(#intel-hud, #intel-hud *, [translate='no'], [translate='no'] *) {
-  letter-spacing: 0 !important;
-}
 
 /* The Display/Context rail moves to the left edge. It keeps a physical
    `right` in layers.css because the attribution-clearance model

From b6c2ba379b7521913ad5b6dcd01e52d0147f2c1e Mon Sep 17 00:00:00 2001
From: German Khokhlov <ouchlock@gmail.com>
Date: Tue, 10 Nov 2026 21:26:15 +0400
Subject: [PATCH 66/71] i18n(he): translate the photo credit added on main

---
 src/i18n/locales/he.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json
index ff46a207e..514b9b41a 100644
--- a/src/i18n/locales/he.json
+++ b/src/i18n/locales/he.json
@@ -3360,6 +3360,7 @@
   "Reported voyage": "הפלגה שדווחה",
   "REPORTED VOYAGE": "הפלגה שדווחה",
   "1 min/s": "דקה/שנ׳",
+  "Photo © {photographer}": "צילום © {photographer}",
   "1 h/s": "שעה/שנ׳",
   "1 d/s": "יום/שנ׳",
   "1 wk/s": "שבוע/שנ׳",

From 6eb07298323e2607b93f04a4c604dec5254c3bb8 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Tue, 10 Nov 2026 10:35:16 -0800
Subject: [PATCH 67/71] fix(firms): translate the snapshot-end label for Hebrew

---
 src/i18n/locales/he.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json
index 514b9b41a..2960c4912 100644
--- a/src/i18n/locales/he.json
+++ b/src/i18n/locales/he.json
@@ -750,6 +750,7 @@
   "loading...": "טוען...",
   "KEY REQUIRED": "נדרש מפתח",
   "LIVE · updated {age}": "חי · עודכן {age}",
+  "24 h to {day} {time} UTC": "24 שעות עד {day} {time} UTC",
   "FIRE": "שריפה",
   "Source snapshot time unavailable": "זמן תמונת המצב של המקור אינו זמין",
   "Live data unavailable": "נתונים חיים אינם זמינים",

From 8fec5a76bfd9779a5ac3a24c920d05e3cb31896b Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Tue, 10 Nov 2026 11:15:18 -0800
Subject: [PATCH 68/71] feat(flights): a tracked flight's trail splits at gaps,
 follows the drawn aircraft, and a lost aircraft coasts then reads SIGNAL LOST

The trail no longer joins a day of history into one line. It lifts the pen
across a gap of more than 48 minutes, an implied speed over 1,500 kt, or a
report without altitude (a parked aircraft within 0.1 nm for under 3 h stays
joined), and every history point is kept as its own segment. History never
gets an invented altitude. The live end is the path the aircraft was drawn
along, thinned to its shape, so it no longer cuts corners through turns; a
late report trims what was drawn after it. Old segments are frozen in chunks,
so a 2,000-point trail costs about 0.1 ms a frame.

A tracked aircraft that misses an update shows STALE and is dimmed. It keeps
flying on its last speed and heading for five minutes (at most 1,500 kt),
then stops, dimmed, labelled SIGNAL LOST with the time since its last report,
and is kept for ten minutes after that report so the camera keeps its target.
Aircraft on or near known ground hold at their last report instead of
coasting. Military flights follow the same rules.
---
 docs/CURRENT-STATE.md                      | 107 ++-
 scripts/package-boundaries.json            |   5 +
 scripts/qa-trail-freeze.mjs                | 241 ++++++
 scripts/track-regression.mjs               | 174 ++++-
 src/data/motionModel.js                    | 189 ++++-
 src/data/routeSegment.test.mjs             |   5 +-
 src/data/trailContinuity.js                | 607 +++++++++++++++
 src/data/trailRenderer.js                  | 327 ++++++--
 src/data/trailRenderer.test.mjs            | 252 +++++-
 src/data/trailReports.test.mjs             | 165 ++++
 src/data/trailThinning.test.mjs            | 180 +++++
 src/i18n/locales/ar.json                   |   1 +
 src/i18n/locales/de.json                   |   1 +
 src/i18n/locales/es.json                   |   1 +
 src/i18n/locales/fr.json                   |   1 +
 src/i18n/locales/he.json                   |   1 +
 src/i18n/locales/it.json                   |   1 +
 src/i18n/locales/ja.json                   |   1 +
 src/i18n/locales/pt.json                   |   1 +
 src/i18n/locales/ru.json                   |   1 +
 src/i18n/locales/uk.json                   |   1 +
 src/i18n/locales/zh-CN.json                |   1 +
 src/i18n/locales/zh-Hant.json              |   1 +
 src/layers/flights/motion.js               | 100 ++-
 src/layers/flights/policy.js               |   5 +-
 src/layers/flights/recordPolicy.js         |   4 +
 src/layers/flights/records.js              |  73 +-
 src/layers/flights/records.test.mjs        |  96 +++
 src/layers/flights/rendering.js            |  26 +-
 src/layers/flights/snapshotRenderer.js     |  26 +-
 src/layers/flights/snapshotStale.test.mjs  | 153 ++++
 src/layers/flights/staleHold.test.mjs      | 421 ++++++++++
 src/layers/flights/state.js                |  27 +-
 src/layers/flights/tracking.js             | 358 ++++++---
 src/layers/flights/trail.test.mjs          | 414 ++++++++++
 src/layers/flights/trailRecord.test.mjs    | 846 +++++++++++++++++++++
 src/layers/military/motion.js              |  95 ++-
 src/layers/military/policy.js              |   5 +-
 src/layers/military/recordPolicy.js        |   4 +
 src/layers/military/records.js             |  64 +-
 src/layers/military/records.test.mjs       |  95 +++
 src/layers/military/rendering.js           |  26 +-
 src/layers/military/snapshotRenderer.js    |  22 +-
 src/layers/military/snapshotStale.test.mjs | 152 ++++
 src/layers/military/staleHold.test.mjs     | 199 +++++
 src/layers/military/state.js               |  27 +-
 src/layers/military/tracking.js            | 390 +++++++---
 src/layers/military/trail.test.mjs         | 260 +++++++
 src/layers/military/trailRecord.test.mjs   | 697 +++++++++++++++++
 49 files changed, 6486 insertions(+), 363 deletions(-)
 create mode 100644 scripts/qa-trail-freeze.mjs
 create mode 100644 src/data/trailContinuity.js
 create mode 100644 src/data/trailReports.test.mjs
 create mode 100644 src/data/trailThinning.test.mjs
 create mode 100644 src/layers/flights/snapshotStale.test.mjs
 create mode 100644 src/layers/flights/staleHold.test.mjs
 create mode 100644 src/layers/flights/trail.test.mjs
 create mode 100644 src/layers/flights/trailRecord.test.mjs
 create mode 100644 src/layers/military/snapshotStale.test.mjs
 create mode 100644 src/layers/military/staleHold.test.mjs
 create mode 100644 src/layers/military/trail.test.mjs
 create mode 100644 src/layers/military/trailRecord.test.mjs

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 5c2e52c58..82f6f65b3 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -1444,6 +1444,52 @@ use the supplied asset resolver, including the preload path. Enrichment receives
 an abort signal and cannot update a later lifecycle after destruction. Existing
 camera, terrain floor, trail, selection and measured model-size policies remain.
 
+A tracked civil or military aircraft's trail (`src/data/trailContinuity.js`) lifts
+the pen, drawing nothing, between two points more than 48 minutes or over 1,500 kt
+apart (a parked aircraft within 0.1 nm keeps one line for up to three hours) and at a
+waypoint with no altitude; a ground waypoint is drawn on the ground. The head joins the
+aircraft only within 150 km. Each trail keeps up to 2,000 points, a full day of history
+at one fix per minute plus the live session; past that the oldest recorded points go
+first, and the oldest reports only once none are left. The renderer
+(`src/data/trailRenderer.js`) freezes every chunk of 128 points except the newest into
+static geometry, so a long trail costs about as much per frame as a short one;
+`scripts/qa-trail-freeze.mjs` checks that a freeze never shows a blank frame.
+While an aircraft is tracked, its trail between reports is the path its icon was
+drawn along: the displayed position is recorded about once a second or every 150 m
+(`recordTrailPoint`). Recorded points are thinned by shape: one stays only where
+dropping it would move the line more than 30 m across the track or in height from any
+position it stood for, or leave a straight piece longer than 10 km, so straight flight
+adds a vertex every 10 km at most and a turn keeps its curve. A recorded point that
+would turn the line back sharper than 120° over a short step is dropped. Reports stay
+in the trail as anchors, in time order. Recorded points never join two reports that are
+not one flight under the 48-minute and 1,500 kt rules; the points between them go and
+nothing is recorded across such a pair. A report for a time the display has already
+passed replaces what was drawn after it, and nothing is recorded until the icon has
+eased onto it, so the line reads arc, report, corrected path. History from before tracking started, and the backfill, run report to report.
+The trail never runs past the icon or through its 3D model, and the head runs from the
+newest kept point outside the model to the icon (to the model's tail when the model is
+the visual). A contact with no new report coasts along its reported track for 5 minutes
+past its last real report, at no more than 1,500 kt and never below known ground, then stops;
+one that
+went quiet on the ground, or within 150 m of a known ground floor, holds at its last
+report, records nothing and draws no head (with the ground unknown, a low barometric
+altitude alone does not hold it). The hold-or-coast choice is made once per report (`staleHoldsForFix`
+in `src/data/motionModel.js`), and the forward fix built when a repeated position carries
+new speed or course follows the same rules and is never a trail report. A live report
+with no altitude breaks the line and leaves no point at an invented height, and so does
+such a report seeded from position history when tracking starts.
+
+A contact that misses an update is stale from the first miss: it is drawn with the
+45%-alpha stale fade (`STALE_ALPHA`), the tracked billboard and 3D model included, and the
+tracked label reads STALE. For the tracked aircraft a poll that re-sends a fix no newer
+than the last one is a miss too. Once its coast has ended, or it holds at its last report
+after a miss, it stands still, dimmed, and the label reads SIGNAL LOST · <time since its
+last report>, in seconds under a minute and minutes after (`_trackedStaleCue` in each
+flight layer's `tracking.js`). The tracked aircraft is kept, so the follow camera keeps its
+target, until 10 minutes after its newest fix (`TRACKED_RETENTION_MS`): 5 minutes coasting,
+then 5 stopped as SIGNAL LOST. Untracked aircraft keep their missed-poll limits. A report
+that arrives later eases the aircraft onto it.
+
 The tracked-aircraft descriptor both flight layers hand to the cockpit carries
 `verticalRateMps` beside `velocityMps` and `track`. Civil records store the rate as
 `verticalRate` and military records as `verticalRateMps`; the query seam maps both to
@@ -1762,7 +1808,7 @@ time. TRACK ACQUIRED stays first. Then:
   left out (the satellites layer's bounded `getNearestPositions`, measured
   from the satellite itself), with their bearing from the top of the frame
   and distance. A row (`Ride …`) rides that satellite. While there is a
-  satellite ridden before this one, a RETURN · *name* row goes back to it; if
+  satellite ridden before this one, a RETURN · _name_ row goes back to it; if
   that satellite has left the catalogue it is dropped and RETURN offers the
   one before. Riding stays in orbit: the satellites layer tracks the new
   satellite (`trackById`), the Cockpit takes the camera back at once and
@@ -1974,6 +2020,7 @@ video; camera poses use the existing low-confidence heading prior.
 
 The CCTV catalog includes Taiwan national freeway cameras from the Freeway Bureau, MOTC. The app first reads the daily MOTC 2.0 CCTV.xml table with a keyless HTTPS request, a 15-second deadline, a 6 MiB response cap, and the shared 15-minute cache. If that catalog is unreachable and no last-good source list exists, the loader uses the Highway Bureau’s public provincial-road CCTV XML feed at https://cctv-maintain.thb.gov.tw/opendataCCTVs.xml. The fallback is capped by the same Taiwan source limit and hourly retry backoff; its MJPEG feeds are restricted to the eight cctv-ss01 through cctv-ss08.thb.gov.tw HTTPS servers. The frame proxy returns one bounded JPEG from each stream, not an unbounded video response. The Highway Bureau open-data page states XML downloads are free and asks users to attribute the source; the app credits Highway Bureau, MOTC. These are provincial-road cameras, not a replacement for the national freeway cameras. CCTV_TAIWAN_ENABLED=0 disables both feeds; CCTV_TAIWAN_MAX_SOURCES sets the shared cap (default 600, bounded to 1–2000), and CCTV_TAIWAN_URL overrides the Freeway Bureau table URL.
 Gate: src/data/cctvTaiwan.test.mjs and src/data/cctvProxy.test.mjs.
+
 ## DriveBC CCTV source pack
 
 The CCTV catalog adds DriveBC highway cameras for British Columbia alongside the
@@ -4726,35 +4773,35 @@ nearby place—always use station selection. Unqualified “turn on/start the ra
 requests use Play; a qualified Play-shaped tool call is normalized to Select so
 its criteria cannot be silently ignored.
 
-| Layer                                | Source                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | File                                                                      | Proxy                                                                                                   | Update Interval                                                                                                             |
-| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
-| Live Flights ✈️                      | OpenSky Network; bounded adsb.lol regional fallback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `src/data/flights.js`                                                     | `/api/flights` (OAuth + fallback)                                                                       | 30s                                                                                                                         |
-| Military Flights 🎖️                  | adsb.lol /v2/mil                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `src/data/militaryFlights.js`                                             | `/api/military`                                                                                         | 15s                                                                                                                         |
-| Live AIS Vessels 🚢                  | AISStream websocket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `src/data/aisLiveVessels.js`                                              | `/api/vessels`                                                                                          | 60s (+800ms visibility pass)                                                                                                |
-| Mapped Installations ⌖               | OpenFreeMap military areas; optional configured Overpass names and Google Places search                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `src/data/militaryInstallations.js`                                       | OpenFreeMap tiles, `/api/military-installations`, `/api/google/text-search`                             | viewport-driven; transient errors back off, missing capability switches to tiles                                            |
-| Earthquakes                          | USGS                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `src/data/earthquakes.js`                                                 | —                                                                                                       | 60s                                                                                                                         |
-| Air quality                          | ECCC MSC GeoMet OGC API (AQHI, Canada only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `src/layers/airQuality/`                                                  | —                                                                                                       | 20 min readings, 12 h station catalog                                                                                       |
-| Satellites                           | CelesTrak TLE + SATCAT; bundled UCS pack (purpose)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `src/data/satellites.js`                                                  | `/api/celestrak` + `/api/celestrak-satcat`                                                              | 120s                                                                                                                        |
-| Space Missions (30d)                 | Launch Library 2 + CelesTrak                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `src/data/rocketLaunches.js`                                              | `/api/launches` + `/api/celestrak/active`                                                               | 5 min                                                                                                                       |
-| Traffic                              | Selectable TomTom / OpenStreetMap / Hybrid roads; optional TomTom flow (BYOK)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `src/data/traffic.js`                                                     | browser-direct OpenFreeMap tiles; `/api/tomtom` for flow                                                | viewport-driven; capped tile cache                                                                                          |
+| Layer                                | Source                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | File                                                                      | Proxy                                                                                                   | Update Interval                                                                                                             |
+| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| Live Flights ✈️                      | OpenSky Network; bounded adsb.lol regional fallback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `src/data/flights.js`                                                     | `/api/flights` (OAuth + fallback)                                                                       | 30s                                                                                                                         |
+| Military Flights 🎖️                  | adsb.lol /v2/mil                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `src/data/militaryFlights.js`                                             | `/api/military`                                                                                         | 15s                                                                                                                         |
+| Live AIS Vessels 🚢                  | AISStream websocket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `src/data/aisLiveVessels.js`                                              | `/api/vessels`                                                                                          | 60s (+800ms visibility pass)                                                                                                |
+| Mapped Installations ⌖               | OpenFreeMap military areas; optional configured Overpass names and Google Places search                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `src/data/militaryInstallations.js`                                       | OpenFreeMap tiles, `/api/military-installations`, `/api/google/text-search`                             | viewport-driven; transient errors back off, missing capability switches to tiles                                            |
+| Earthquakes                          | USGS                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `src/data/earthquakes.js`                                                 | —                                                                                                       | 60s                                                                                                                         |
+| Air quality                          | ECCC MSC GeoMet OGC API (AQHI, Canada only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `src/layers/airQuality/`                                                  | —                                                                                                       | 20 min readings, 12 h station catalog                                                                                       |
+| Satellites                           | CelesTrak TLE + SATCAT; bundled UCS pack (purpose)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `src/data/satellites.js`                                                  | `/api/celestrak` + `/api/celestrak-satcat`                                                              | 120s                                                                                                                        |
+| Space Missions (30d)                 | Launch Library 2 + CelesTrak                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `src/data/rocketLaunches.js`                                              | `/api/launches` + `/api/celestrak/active`                                                               | 5 min                                                                                                                       |
+| Traffic                              | Selectable TomTom / OpenStreetMap / Hybrid roads; optional TomTom flow (BYOK)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `src/data/traffic.js`                                                     | browser-direct OpenFreeMap tiles; `/api/tomtom` for flow                                                | viewport-driven; capped tile cache                                                                                          |
 | CCTV                                 | Austin + Caltrans (CA) + TfL London + Ontario 511 + Fintraffic (FI) + DriveBC (BC) + TxDOT (TX) + Estonia (Tallinn, Tarktee) + Live Traffic NSW + Open Calgary Open Data + Statens vegvesen (NO, stills + live HLS, Kartverket ground heights) + King County (WA) Open Data + WSDOT (WA) Open Data + NYC DOT TMC (opt-in) + City of Toronto RESCU + Catalonia (Servei Català de Trànsit) + Iceland (Vegagerðin / IRCA) + Hong Kong Transport Department + FL511 (FL, opt-in) + Freeway Bureau, MOTC (Taiwan) + Houston TranStar (opt-in) + Autostrada del Brennero (IT, A22 stills) + Street View fallback | `src/data/cctv.js`                                                        | `/api/cctv`                                                                                             | 10s (active)                                                                                                                |
-| Radio                                | Radio Browser (public-domain station directory)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `src/data/radio.js`                                                       | `/api/radio/stations`, `/api/radio/click/:uuid`                                                         | 45 min directory refresh                                                                                                    |
-| Transit 🚌                           | Operator GTFS-Realtime VehiclePositions (7 keyless regions, `src/data/transitFeeds.js`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `src/layers/transit/` via `src/app/layers/transit.js`                     | `/api/transit`                                                                                          | 15s (poll + delayed playback)                                                                                               |
-| Bikeshare 🚲                         | GBFS (Lyft + BCycle + Social Bicycles + PBSC incl. Bike Share Toronto, Bike Itaú (Brazil), Bicing (Barcelona) and seven other Spanish cities + Urban Sharing, Entur, JCDecaux (Lillestrøm, Valencia, Seville) + nextbike (AMBici))                                                                                                                                                                                                                                                                                                                                           | `src/data/bikeshare.js`                                                   | `/api/gbfs`                                                                                             | 60s                                                                                                                         |
-| Directions 🧭                        | OSRM on FOSSGIS servers (OpenStreetMap)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `src/data/directions.js`                                                  | `/api/route` (`steps=1`)                                                                                | on placement / mode change                                                                                                  |
-| Datacenters ▣                        | OSM extract (bundled)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `src/data/infrastructure.js`                                              | —                                                                                                       | static                                                                                                                      |
-| Dams ▰                               | OpenInfraMap/OSM extract (bundled)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `src/data/infrastructure.js`                                              | —                                                                                                       | static                                                                                                                      |
-| Submarine Cables ◠                   | TeleGeography public map (bundled)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `src/data/telegeographySubmarineCables.js`                                | —                                                                                                       | static                                                                                                                      |
-| FIRMS Active Fires ▲                 | NASA FIRMS live (VIIRS ×2 NRT + MODIS NRT, trailing 24h)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `src/data/firmsHeatmap.js`                                                | `/api/firms` (`FIRMS_MAP_KEY`)                                                                          | 10 min (proxy TTL 30 min)                                                                                                   |
-| Street Level 📷                      | Mapillary street-level imagery (vector tiles, Graph API, MapillaryJS)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `src/layers/streetLevel/` via `src/app/layers/streetLevel.js`             | `/api/mapillary/status`, `/api/mapillary/tiles/coverage/{z}/{x}/{y}` (`MAPILLARY_CLIENT_TOKEN`)         | camera-driven (320 ms debounce, ≤9 tiles, server memory cache 24 h)                                                         |
-| Wind 🌬                               | NOAA GFS 10 m wind (keyless, 0.25°→1° grid; animated particles)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `src/data/wind.js`                                                        | `/api/wind`                                                                                             | 1 h (forecast cycle)                                                                                                        |
-| GNSS Integrity 📡 (`gnss-integrity`) | adsb.lol point snapshot, low navigation accuracy binned per 0.5° cell (GEV NIC/NACp threshold + gpsjam.org formula and bands, keyless, ODbL)                                                                                                                                                                                                                                                                                                                                                                                                                                 | `src/layers/gnss/` via `src/app/layers/gnss.js`                           | `/api/gnss-integrity`                                                                                   | camera-driven (600 ms debounce, minimum 2.5 s between reads) + 60s poll (server cache 60 s; 30 min rolling window)          |
-| S2 GhostMaps 👻 (`s2-ghostmaps`)     | S2 Underground's public GhostMaps repository on GitHub (KMZ intel products, keyless, CC BY-NC-SA 4.0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `src/layers/ghostMaps/` via `src/app/layers/ghostMaps.js`                 | `/api/ghostmaps/catalog`, `/api/ghostmaps/events` (server-sent events), `/api/ghostmaps/file/{product}` | branch head checked every 15 s; new commits pushed to the page; 5 min catalog backstop                                      |
-| Sea Marks ⚓ (`sea-marks`)           | OpenSeaMap seamark raster tiles (keyless; CC BY-SA 2.0 tiles, OSM data ODbL)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `src/data/osmOverlays.js`                                                 | — (browser-direct tiles)                                                                                | on view (Cesium tile requests; no polling)                                                                                  |
-| Ski Pistes ⛷ (`ski-pistes`)          | OpenSnowMap piste raster tiles (keyless; CC BY-SA tiles, OSM data ODbL; no bulk download)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `src/data/osmOverlays.js`                                                 | — (browser-direct tiles)                                                                                | on view (Cesium tile requests; no polling)                                                                                  |
-| Fire Perimeters 🔥                   | NIFC WFIGS current interagency perimeters (keyless, paged past the 2000-record cap); InciWeb catalog + incident page origin and update time checks for verified incident-page links                                                                                                                                                                                                                                                                                                                                                                                          | `src/layers/perimeters/` via `src/app/layers/perimeters.js`               | `/api/fire-perimeters` + `/api/fire-perimeters/inciweb/*`                                               | 5 min (server caches: catalog 1 h; publication 30 min)                                                                      |
-| Prohibited & Restricted Airspace 🚫  | FAA Special Use Airspace prohibited (P) and restricted (R) zones (keyless FeatureServer, simplified geometry)                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `src/layers/droneAirspace/` via `src/app/layers/droneAirspace.js`         | `/api/drone-airspace`                                                                                   | 1 h (server cache 1 h; stale-on-error)                                                                                      |
-| Wildlife Sightings 🦉                | iNaturalist wildlife observed within 48 h (whales 7 d), per view; Acartia Salish Sea marine mammal coverage (keyless)                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `src/layers/wildlifeSightings/` via `src/app/layers/wildlifeSightings.js` | `/api/inaturalist/observations`, `/api/inaturalist/grid`, `/api/acartia/sightings`                      | camera moveEnd (600 ms debounce; enable settles 300 ms) + 5 min (observations 5 / 10 min; tiles 15 min; stale ≤ 1 h / 24 h) |
+| Radio                                | Radio Browser (public-domain station directory)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `src/data/radio.js`                                                       | `/api/radio/stations`, `/api/radio/click/:uuid`                                                         | 45 min directory refresh                                                                                                    |
+| Transit 🚌                           | Operator GTFS-Realtime VehiclePositions (7 keyless regions, `src/data/transitFeeds.js`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `src/layers/transit/` via `src/app/layers/transit.js`                     | `/api/transit`                                                                                          | 15s (poll + delayed playback)                                                                                               |
+| Bikeshare 🚲                         | GBFS (Lyft + BCycle + Social Bicycles + PBSC incl. Bike Share Toronto, Bike Itaú (Brazil), Bicing (Barcelona) and seven other Spanish cities + Urban Sharing, Entur, JCDecaux (Lillestrøm, Valencia, Seville) + nextbike (AMBici))                                                                                                                                                                                                                                                                                                                                                                         | `src/data/bikeshare.js`                                                   | `/api/gbfs`                                                                                             | 60s                                                                                                                         |
+| Directions 🧭                        | OSRM on FOSSGIS servers (OpenStreetMap)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `src/data/directions.js`                                                  | `/api/route` (`steps=1`)                                                                                | on placement / mode change                                                                                                  |
+| Datacenters ▣                        | OSM extract (bundled)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `src/data/infrastructure.js`                                              | —                                                                                                       | static                                                                                                                      |
+| Dams ▰                               | OpenInfraMap/OSM extract (bundled)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `src/data/infrastructure.js`                                              | —                                                                                                       | static                                                                                                                      |
+| Submarine Cables ◠                   | TeleGeography public map (bundled)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `src/data/telegeographySubmarineCables.js`                                | —                                                                                                       | static                                                                                                                      |
+| FIRMS Active Fires ▲                 | NASA FIRMS live (VIIRS ×2 NRT + MODIS NRT, trailing 24h)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `src/data/firmsHeatmap.js`                                                | `/api/firms` (`FIRMS_MAP_KEY`)                                                                          | 10 min (proxy TTL 30 min)                                                                                                   |
+| Street Level 📷                      | Mapillary street-level imagery (vector tiles, Graph API, MapillaryJS)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `src/layers/streetLevel/` via `src/app/layers/streetLevel.js`             | `/api/mapillary/status`, `/api/mapillary/tiles/coverage/{z}/{x}/{y}` (`MAPILLARY_CLIENT_TOKEN`)         | camera-driven (320 ms debounce, ≤9 tiles, server memory cache 24 h)                                                         |
+| Wind 🌬                               | NOAA GFS 10 m wind (keyless, 0.25°→1° grid; animated particles)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `src/data/wind.js`                                                        | `/api/wind`                                                                                             | 1 h (forecast cycle)                                                                                                        |
+| GNSS Integrity 📡 (`gnss-integrity`) | adsb.lol point snapshot, low navigation accuracy binned per 0.5° cell (GEV NIC/NACp threshold + gpsjam.org formula and bands, keyless, ODbL)                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `src/layers/gnss/` via `src/app/layers/gnss.js`                           | `/api/gnss-integrity`                                                                                   | camera-driven (600 ms debounce, minimum 2.5 s between reads) + 60s poll (server cache 60 s; 30 min rolling window)          |
+| S2 GhostMaps 👻 (`s2-ghostmaps`)     | S2 Underground's public GhostMaps repository on GitHub (KMZ intel products, keyless, CC BY-NC-SA 4.0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `src/layers/ghostMaps/` via `src/app/layers/ghostMaps.js`                 | `/api/ghostmaps/catalog`, `/api/ghostmaps/events` (server-sent events), `/api/ghostmaps/file/{product}` | branch head checked every 15 s; new commits pushed to the page; 5 min catalog backstop                                      |
+| Sea Marks ⚓ (`sea-marks`)           | OpenSeaMap seamark raster tiles (keyless; CC BY-SA 2.0 tiles, OSM data ODbL)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `src/data/osmOverlays.js`                                                 | — (browser-direct tiles)                                                                                | on view (Cesium tile requests; no polling)                                                                                  |
+| Ski Pistes ⛷ (`ski-pistes`)          | OpenSnowMap piste raster tiles (keyless; CC BY-SA tiles, OSM data ODbL; no bulk download)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `src/data/osmOverlays.js`                                                 | — (browser-direct tiles)                                                                                | on view (Cesium tile requests; no polling)                                                                                  |
+| Fire Perimeters 🔥                   | NIFC WFIGS current interagency perimeters (keyless, paged past the 2000-record cap); InciWeb catalog + incident page origin and update time checks for verified incident-page links                                                                                                                                                                                                                                                                                                                                                                                                                        | `src/layers/perimeters/` via `src/app/layers/perimeters.js`               | `/api/fire-perimeters` + `/api/fire-perimeters/inciweb/*`                                               | 5 min (server caches: catalog 1 h; publication 30 min)                                                                      |
+| Prohibited & Restricted Airspace 🚫  | FAA Special Use Airspace prohibited (P) and restricted (R) zones (keyless FeatureServer, simplified geometry)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `src/layers/droneAirspace/` via `src/app/layers/droneAirspace.js`         | `/api/drone-airspace`                                                                                   | 1 h (server cache 1 h; stale-on-error)                                                                                      |
+| Wildlife Sightings 🦉                | iNaturalist wildlife observed within 48 h (whales 7 d), per view; Acartia Salish Sea marine mammal coverage (keyless)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `src/layers/wildlifeSightings/` via `src/app/layers/wildlifeSightings.js` | `/api/inaturalist/observations`, `/api/inaturalist/grid`, `/api/acartia/sightings`                      | camera moveEnd (600 ms debounce; enable settles 300 ms) + 5 min (observations 5 / 10 min; tiles 15 min; stale ≤ 1 h / 24 h) |
 
 GNSS Integrity samples a 250 nm circle around the Earth point under the screen
 centre. Camera reads debounce for 600 ms with a monotonic 2.5 s minimum gap;
@@ -5740,7 +5787,7 @@ silently demoting every later lookup for the session.
 
 ### Motion & Symbology Correctness (June 10, 2026)
 
-- **Flights (commercial + military)** render one poll interval behind real time (30s/15s) and interpolate between two known feed-stamped fixes (OpenSky `time_position`; adsb.lol `receipt − seen_pos`). The display latency is an intentional product decision — do not "fix" it away. The fleet dead-reckons at ~12Hz (1m² write gating); a contact already hidden behind the horizon whose last position still is re-reckons on a staggered one-in-13-ticks rotation (about once a second) instead, so the worldwide feed's ~13k contacts no longer cost a full pass when well under 1% are on screen. Anything that position puts in view, and any contact with a fleet model, takes the full pass immediately, and hidden-inclusive proximity queries read positions at most about a second old; aircraft get a 3-poll grace period (faded icon) before removal. When a position epoch pauses, both layers coast for at least 60 seconds of contact grace with an absolute five-minute ceiling. Source backoff marks each contact and the cockpit `STALE`; the cockpit then holds the exact layer position instead of continuing inertial flight. Repeated-position kinematic changes create a forward-only synthetic fix rather than mutating history, and grounded history is lifted only when no owned 3D model already controls its datum. A nominally successful worldwide OpenSky response whose own snapshot epoch is more than two minutes old prefers the existing 250-nm viewport-scoped adsb.lol fallback and labels the source/coverage accordingly when that upstream is available. If the fallback is also unavailable, the layer's freshness/error fields use the source epoch—never the cache receipt time—so the UI reports an old snapshot rather than “just now.”
+- **Flights (commercial + military)** render one poll interval behind real time (30s/15s) and interpolate between two known feed-stamped fixes (OpenSky `time_position`; adsb.lol `receipt − seen_pos`). The display latency is an intentional product decision — do not "fix" it away. The fleet dead-reckons at ~12Hz (1m² write gating); a contact already hidden behind the horizon whose last position still is re-reckons on a staggered one-in-13-ticks rotation (about once a second) instead, so the worldwide feed's ~13k contacts no longer cost a full pass when well under 1% are on screen. Anything that position puts in view, and any contact with a fleet model, takes the full pass immediately, and hidden-inclusive proximity queries read positions at most about a second old; aircraft get a 3-poll grace period (faded icon) before removal, except the tracked aircraft, which is kept until 10 minutes after its newest fix. When a position epoch pauses, both layers coast for five minutes on the last speed and heading (at most 1,500 kt), then stop dimmed as SIGNAL LOST; contacts on or near known ground hold instead. Source backoff marks each contact and the cockpit `STALE`; the cockpit then holds the exact layer position instead of continuing inertial flight. Repeated-position kinematic changes create a forward-only synthetic fix rather than mutating history, and grounded history is lifted only when no owned 3D model already controls its datum. A nominally successful worldwide OpenSky response whose own snapshot epoch is more than two minutes old prefers the existing 250-nm viewport-scoped adsb.lol fallback and labels the source/coverage accordingly when that upstream is available. If the fallback is also unavailable, the layer's freshness/error fields use the source epoch—never the cache receipt time—so the UI reports an old snapshot rather than “just now.”
 - **World-space headings at every angle** (`src/data/iconOrientation.js`): aircraft/vessel icon rotation uses the camera right/up basis per tick (alignedAxis always ZERO), which is exact at screen center and for orthographic/nadir views and remains stable through >180° tracked orbits. Perspective rays vary across the viewport, so off-center contacts at oblique pitch can diverge from an exact finite-difference window projection; a regression test pins that known regime, and field evidence decides whether to adopt exact projection with the basis method as fallback. Fleet rotations refresh on camera-pose change; tracked entities per frame. Billboards are horizon-culled via a shared EllipsoidalOccluder.
 - **Military/OpenSky reconciliation** (`src/data/militaryRegistry.js`): known-military ICAOs render amber in the flights layer (60s self-poll of the cached mil endpoint when the military layer is off) and are suppressed there while the military layer renders them.
 - **Satellites**: core catalog from CelesTrak's stations, visual, GPS, GLONASS, Galileo, GEO, resource, weather, planet, SAR and science groups, tracking lands ~726km out via `viewFrom` (tracked entity owns a point graphic so the tracking camera engages), rings realign via primitive modelMatrix (no per-second rebuild flicker), optional `setParams({catalog:'dense'})` Starlink mode.
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index ade3bba6c..79be4fbe6 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -1459,6 +1459,7 @@
       "src/layers/flights/state.js",
       "src/layers/flights/testing.js",
       "src/layers/flights/tracking.js",
+      "src/data/trailContinuity.js",
       "src/layers/flights/records.js",
       "src/layers/flights/recordPolicy.js",
       "src/layers/flights/snapshotRenderer.js",
@@ -1523,6 +1524,7 @@
       "src/layers/military/state.js",
       "src/layers/military/testing.js",
       "src/layers/military/tracking.js",
+      "src/data/trailContinuity.js",
       "src/layers/military/records.js",
       "src/layers/military/recordPolicy.js",
       "src/layers/military/snapshotRenderer.js",
@@ -1542,6 +1544,7 @@
       "src/i18n/locales/uk.json",
       "src/i18n/locales/zh-CN.json",
       "src/i18n/locales/zh-Hant.json",
+      "src/ui/unitLabels.js",
       "src/time/worldClock.js",
       "src/time/julian.js"
     ],
@@ -2632,6 +2635,7 @@
       "src/data/trafficPresetStyle.js",
       "src/data/trafficQueue.js",
       "src/data/trailRenderer.js",
+      "src/data/trailContinuity.js",
       "src/data/vesselLabels.js",
       "src/data/vesselTypes.js",
       "src/firstRunExperience.js",
@@ -3631,6 +3635,7 @@
       "src/data/trafficPresetStyle.js",
       "src/data/trafficQueue.js",
       "src/data/trailRenderer.js",
+      "src/data/trailContinuity.js",
       "src/data/vesselLabels.js",
       "src/data/vesselTypes.js",
       "src/keylessGeocoder.js",
diff --git a/scripts/qa-trail-freeze.mjs b/scripts/qa-trail-freeze.mjs
new file mode 100644
index 000000000..77d7cbf6c
--- /dev/null
+++ b/scripts/qa-trail-freeze.mjs
@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+/**
+ * Trail freeze gate: freezing a trail chunk never shows a blank frame.
+ *
+ * A tracked aircraft's trail is cut into chunks; every chunk but the newest
+ * is frozen into static geometry, which Cesium builds asynchronously. Until
+ * that geometry is in the scene, the chunk keeps being drawn dynamically.
+ *
+ * This gate drives the real app and a real Cesium scene: it draws a trail of
+ * CHUNK_POINTS points (all dynamic), then adds one point so the first chunk
+ * freezes, and on every rendered frame after that it checks two things:
+ *  1. every frozen chunk is either still drawn by a dynamic polyline or its
+ *     static geometry is in the scene (DataSourceDisplay reports DONE);
+ *  2. the number of trail-coloured pixels never drops below 90% of the
+ *     count measured just before the freeze.
+ * It also checks that clearing the trail releases every chunk entity.
+ *
+ * The camera is held still while the gate runs.
+ *
+ * Needs a running dev server:
+ *   node scripts/qa-trail-freeze.mjs [--url http://localhost:4173]
+ */
+import puppeteer from 'puppeteer';
+import { chromeExecutablePath } from './qa-chrome.mjs';
+
+const urlFlag = process.argv.indexOf('--url');
+const APP_URL =
+  urlFlag > 0 ? process.argv[urlFlag + 1] : 'http://localhost:4173';
+
+const browser = await puppeteer.launch({
+  headless: 'new',
+  protocolTimeout: 300_000,
+  executablePath: chromeExecutablePath(),
+  args: [
+    '--no-sandbox',
+    '--disable-setuid-sandbox',
+    '--use-gl=angle',
+    '--use-angle=swiftshader',
+    '--disable-dev-shm-usage',
+    '--disable-background-timer-throttling',
+    '--disable-renderer-backgrounding',
+    '--window-size=960,640',
+  ],
+});
+
+let failed = false;
+const report = (name, ok, detail) => {
+  if (!ok) failed = true;
+  console.log(
+    `  [${ok ? 'PASS' : 'FAIL'}] ${name}${detail ? `  — ${detail}` : ''}`,
+  );
+};
+
+try {
+  const page = await browser.newPage();
+  await page.setViewport({ width: 960, height: 640 });
+  await page.goto(APP_URL, { waitUntil: 'domcontentloaded', timeout: 120_000 });
+  await page.waitForFunction(
+    () =>
+      window.__godsEyeView?.viewer &&
+      document.getElementById('loading-screen')?.classList.contains('hidden'),
+    { timeout: 180_000 },
+  );
+
+  const result = await page.evaluate(async () => {
+    // The exact Cesium module the renderer uses, so classes are shared.
+    const source = await (await fetch('/src/data/trailRenderer.js')).text();
+    const cesiumUrl = source.match(/from\s+["']([^"']*cesium[^"']*)["']/)[1];
+    const Cesium = await import(cesiumUrl);
+    const { createTrail, CHUNK_POINTS } =
+      await import('/src/data/trailRenderer.js');
+    const viewer = window.__godsEyeView.viewer;
+    const scene = viewer.scene;
+    const nextFrame = () =>
+      new Promise((resolve) => {
+        const remove = scene.postRender.addEventListener(() => {
+          remove();
+          resolve();
+        });
+        scene.requestRender();
+      });
+
+    // A line across the middle of the current view, in mid-air in front of
+    // the camera, so terrain and buildings never hide it.
+    viewer.camera.cancelFlight?.();
+    const camera = viewer.camera;
+    const ahead = Cesium.Cartesian3.add(
+      camera.positionWC,
+      Cesium.Cartesian3.multiplyByScalar(
+        camera.directionWC,
+        3_000,
+        new Cesium.Cartesian3(),
+      ),
+      new Cesium.Cartesian3(),
+    );
+    const points = Array.from({ length: CHUNK_POINTS + 1 }, (_, i) =>
+      Cesium.Cartesian3.add(
+        ahead,
+        Cesium.Cartesian3.multiplyByScalar(
+          camera.rightWC,
+          -1_200 + (2_400 * i) / CHUNK_POINTS,
+          new Cesium.Cartesian3(),
+        ),
+        new Cesium.Cartesian3(),
+      ),
+    );
+    const added = [];
+    const removed = [];
+    const add = viewer.entities.add.bind(viewer.entities);
+    const remove = viewer.entities.remove.bind(viewer.entities);
+    viewer.entities.add = (definition) => {
+      const entity = add(definition);
+      if (String(entity.id).startsWith('gev-trail:')) added.push(entity);
+      return entity;
+    };
+    viewer.entities.remove = (entity) => {
+      if (String(entity?.id).startsWith('gev-trail:')) removed.push(entity);
+      return remove(entity);
+    };
+
+    const gl = scene.context._gl;
+    const width = gl.drawingBufferWidth;
+    const height = gl.drawingBufferHeight;
+    const pixels = new Uint8Array(width * height * 4);
+    // Magenta trail: count pixels that are clearly magenta.
+    const countTrailPixels = () => {
+      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+      gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+      let count = 0;
+      for (let p = 0; p < pixels.length; p += 4) {
+        const r = pixels[p];
+        const g = pixels[p + 1];
+        const b = pixels[p + 2];
+        if (r > 150 && b > 150 && g < 110) count++;
+      }
+      return count;
+    };
+
+    const trail = createTrail(viewer, { color: '#ff00ff', width: 8 });
+    trail.setPositions(points.slice(0, CHUNK_POINTS));
+    for (let i = 0; i < 20; i++) await nextFrame();
+    const before = trail._chunksForTest();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+    let lit = 0;
+    for (let p = 0; p < pixels.length; p += 4)
+      if (pixels[p] || pixels[p + 1] || pixels[p + 2]) lit++;
+    const cam = viewer.camera.positionCartographic;
+    const diagnostics = {
+      lit,
+      size: [width, height],
+      camera: [
+        Cesium.Math.toDegrees(cam.longitude),
+        Cesium.Math.toDegrees(cam.latitude),
+        cam.height,
+      ],
+      preserveDrawingBuffer: gl.getContextAttributes().preserveDrawingBuffer,
+    };
+    let baseline = 0;
+    for (let i = 0; i < 5; i++) {
+      await nextFrame();
+      baseline = Math.max(baseline, countTrailPixels());
+    }
+
+    trail.setPositions(points);
+    const frames = [];
+    const sphere = new Cesium.BoundingSphere();
+    let resolvedAt = null;
+    for (let i = 0; i < 400; i++) {
+      await nextFrame();
+      const state = trail._chunksForTest();
+      const covered = state.frozen.every(
+        (chunk) =>
+          chunk.standIn ||
+          viewer.dataSourceDisplay.getBoundingSphere(
+            chunk.entity,
+            false,
+            sphere,
+          ) === Cesium.BoundingSphereState.DONE,
+      );
+      frames.push({ covered, pixels: countTrailPixels() });
+      if (resolvedAt == null && state.frozen.every((c) => !c.standIn))
+        resolvedAt = i;
+      if (resolvedAt != null && i > resolvedAt + 30) break;
+    }
+
+    trail.clear();
+    for (let i = 0; i < 3; i++) await nextFrame();
+    const frozenAfterClear = trail._chunksForTest().frozen.length;
+    trail.destroy();
+    const leaked = added.filter((entity) => !removed.includes(entity)).length;
+    viewer.entities.add = add;
+    viewer.entities.remove = remove;
+    return {
+      chunkPoints: CHUNK_POINTS,
+      diagnostics,
+      frozenBefore: before.frozen.length,
+      baseline,
+      frames,
+      resolvedAt,
+      frozenAfterClear,
+      entities: added.length,
+      leaked,
+    };
+  });
+
+  if (process.env.GEV_TEST_VERBOSE)
+    console.log(JSON.stringify(result.diagnostics));
+  const minPixels = Math.min(...result.frames.map((frame) => frame.pixels));
+  report(
+    'the trail draws before the freeze',
+    result.baseline > 200 && result.frozenBefore === 0,
+    `baseline=${result.baseline} trail pixels, frozen chunks=${result.frozenBefore}`,
+  );
+  report(
+    'the frozen chunk reaches the scene as static geometry',
+    result.resolvedAt != null,
+    `stand-in dropped after ${result.resolvedAt} frames`,
+  );
+  report(
+    'every frame after the freeze draws the frozen chunk (dynamic copy or static geometry)',
+    result.frames.every((frame) => frame.covered),
+    `${result.frames.length} frames checked`,
+  );
+  report(
+    'no blank frame: trail pixels never drop below 90% of the pre-freeze count',
+    minPixels >= 0.9 * result.baseline,
+    `min=${minPixels} baseline=${result.baseline}`,
+  );
+  report(
+    'clearing and destroying release every trail entity',
+    result.frozenAfterClear === 0 && result.leaked === 0,
+    `entities created=${result.entities} leaked=${result.leaked}`,
+  );
+} catch (error) {
+  report('gate ran', false, error.message);
+} finally {
+  await browser.close();
+}
+console.log(failed ? 'RESULT: FAIL' : 'RESULT: PASS');
+process.exit(failed ? 1 : 0);
diff --git a/scripts/track-regression.mjs b/scripts/track-regression.mjs
index d2e04609b..f87250430 100644
--- a/scripts/track-regression.mjs
+++ b/scripts/track-regression.mjs
@@ -42,8 +42,9 @@
  *                           and a real mouse click on the tracked plane is a
  *                           NO-OP (no deselect, no camera spike).
  *   M3. AGE-OUT RELEASE   — when the tracked plane's fixes stop arriving
- *                           (3 missed polls via the shim), tracking clears and
- *                           the camera is RELEASED IN PLACE: viewer.trackedEntity
+ *                           it stays tracked (STALE, then SIGNAL LOST) until
+ *                           10 min after its newest fix; then tracking clears
+ *                           and the camera is RELEASED IN PLACE: viewer.trackedEntity
  *                           undefined, NO jump (owner decision 2026-07-02 —
  *                           the old ~80 km overview flyTo is gone).
  *
@@ -362,7 +363,12 @@ async function main() {
             'Synthetica',      // 2 origin_country
             Math.floor(Date.now() / 1000), // 3 time_position
             Math.floor(Date.now() / 1000), // 4 last_contact
-            f.lon,             // 5 longitude
+            // A plane given `moveFromMs` flies east at its reported speed
+            // (the trail-head check needs a moving icon); others hold still.
+            Number.isFinite(f.moveFromMs)
+              ? f.lon + (f.vel * (Date.now() - f.moveFromMs)) / 1000
+                / (111320 * Math.cos((f.lat * Math.PI) / 180))
+              : f.lon,         // 5 longitude
             f.lat,             // 6 latitude
             f.alt,             // 7 baro_altitude (m)
             f.onGround === true, // 8 on_ground (ground-traffic phase flips this live)
@@ -1498,6 +1504,110 @@ async function main() {
         `max=${maxDelta.toFixed(3)} m over ${samples.length} frames (tol ${JITTER_TOL_M} m, mode=${modelUp ? 'model-matrix' : 'display-contract'})`);
     }
 
+    // ============================================================
+    // TRAIL HEAD ENDS AT THE DRAWN ICON, every rendered frame.
+    //   The head's last vertex is where the tracked plane is drawn (the
+    //   display position, or the model's tail anchor while the model is the
+    //   visual). getTrackedInfo reports the dead-reckoned position without
+    //   the brief post-report easing; its gap is logged, not asserted.
+    // ============================================================
+    console.log('\nTrail head — ends at the drawn icon on every frame');
+    // The fixture planes repeat one position, so the icon holds and draws no
+    // head. Fly the tracked one east for this check; the display runs 30 s
+    // behind, so give it time to reach the moving reports.
+    await evalPage((icao) => {
+      const f = window.__SYNTH.flights.find((p) => p.icao === icao);
+      f.moveFromMs = Date.now();
+    }, trackedIcao);
+    await sleep(55_000);
+    const headSamples = await sampleFrames(page, 40, (icao) => {
+      const viewer = window.__godsEyeView.viewer;
+      const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
+      const ent = viewer.trackedEntity;
+      const time = viewer.clock.currentTime;
+      const head = viewer.entities.values.find((e) => String(e.id).startsWith('gev-trail:fl-head-'));
+      const line = head?.polyline?.positions?.getValue(time);
+      const drawn = ent?.position?.getValue(time);
+      if (!line?.length || !drawn) return null;
+      const end = line[line.length - 1];
+      const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y, a.z - b.z);
+      const ti = fl.getTrackedInfo();
+      let infoGap = null;
+      if (ti && ti.icao24 === icao) {
+        // WGS84 lat/lon → ECEF on the ellipsoid; the angle at the centre to
+        // the drawn position, times the mean radius, is the ground gap.
+        const a = 6378137, e2 = 6.69437999014e-3;
+        const lat = (ti.latitude * Math.PI) / 180, lon = (ti.longitude * Math.PI) / 180;
+        const n = a / Math.sqrt(1 - e2 * Math.sin(lat) ** 2);
+        const p = {
+          x: n * Math.cos(lat) * Math.cos(lon),
+          y: n * Math.cos(lat) * Math.sin(lon),
+          z: n * (1 - e2) * Math.sin(lat),
+        };
+        const dot = p.x * drawn.x + p.y * drawn.y + p.z * drawn.z;
+        const cos = dot / (Math.hypot(p.x, p.y, p.z) * Math.hypot(drawn.x, drawn.y, drawn.z));
+        infoGap = 6371008.8 * Math.acos(Math.min(1, cos));
+      }
+      // While the 3D model is the visual the head ends at the model's tail
+      // anchor, which sits on the drawn (pixel-size-enlarged) model.
+      const model = window.__findTrackedModel ? window.__findTrackedModel() : null;
+      const sphere = model && model.ready && model.show ? model.boundingSphere : null;
+      // boundingSphere leaves out the minimum-pixel-size enlargement that
+      // computedScale carries; the drawn model is that much larger.
+      const enlarge = sphere && Number.isFinite(model.computedScale) && model.scale > 0
+        ? Math.max(1, model.computedScale / model.scale)
+        : 1;
+      const radius = sphere ? sphere.radius * enlarge : null;
+      return {
+        end: dist(end, drawn),
+        onModel: sphere ? dist(end, sphere.center) <= radius + 50 : false,
+        modelRadius: radius,
+        infoGap,
+        vertices: line.length,
+      };
+    }, trackedIcao);
+    // The same reading between frames, the way a page script polls it: the
+    // head holds the last rendered frame while getTrackedInfo dead-reckons
+    // the current instant. Logged only, to tell the two apart.
+    const betweenFrames = [];
+    for (let i = 0; i < 8; i++) {
+      await sleep(600);
+      betweenFrames.push(await evalPage((icao) => {
+        const viewer = window.__godsEyeView.viewer;
+        const head = viewer.entities.values.find((e) => String(e.id).startsWith('gev-trail:fl-head-'));
+        const line = head?.polyline?.positions?.getValue(viewer.clock.currentTime);
+        const drawn = viewer.trackedEntity?.position?.getValue(viewer.clock.currentTime);
+        if (!line?.length || !drawn) return null;
+        const end = line[line.length - 1];
+        return Math.hypot(end.x - drawn.x, end.y - drawn.y, end.z - drawn.z);
+      }, trackedIcao));
+    }
+    console.log(`  (between frames: head end vs entity position, m: ${
+      betweenFrames.map((v) => (v == null ? '-' : v.toFixed(1))).join(' ')})`);
+    // Freeze the plane where it got to, so later checks see a still contact.
+    await evalPage((icao) => {
+      const f = window.__SYNTH.flights.find((p) => p.icao === icao);
+      f.lon += (f.vel * (Date.now() - f.moveFromMs)) / 1000
+        / (111320 * Math.cos((f.lat * Math.PI) / 180));
+      delete f.moveFromMs;
+    }, trackedIcao);
+    const headUsable = headSamples.values.filter((v) => v != null);
+    if (headUsable.length < 10) {
+      skip('trail head: ends at the drawn icon on every frame',
+        `only ${headUsable.length} frames with a drawn head (timedOut=${headSamples.timedOut})`);
+    } else {
+      const worst = Math.max(...headUsable.map((v) => v.end));
+      const off = headUsable.filter((v) => !(v.end <= 50 || v.onModel));
+      const onModel = headUsable.filter((v) => v.end > 50 && v.onModel).length;
+      const radii = headUsable.map((v) => v.modelRadius).filter((v) => v != null);
+      const gaps = headUsable.map((v) => v.infoGap).filter((v) => v != null);
+      record('trail head: last vertex on the drawn icon (within 50 m, or on the drawn 3D model) on every frame',
+        off.length === 0,
+        `${off.length} of ${headUsable.length} frames off; max end-to-centre=${worst.toFixed(1)} m, ${onModel} frames ending on the model's tail (model radius ${
+          radii.length ? Math.max(...radii).toFixed(0) : 'n/a'} m); getTrackedInfo vs drawn icon max=${
+          gaps.length ? Math.max(...gaps).toFixed(1) : 'n/a'} m (logged only)`);
+    }
+
     // ============================================================
     // INVARIANT 2: NO PULL-OUT on a track switch
     //   tracking B while tracking A must not fly to ~80 km overview.
@@ -1744,7 +1854,8 @@ async function main() {
 
     // ============================================================
     // REGRESSION M3 (rewritten 2026-07-02 — deliberate behavior change):
-    // when the TRACKED plane ages out (3 missed polls), tracking must clear
+    // when the TRACKED plane ages out (10 min after its newest fix, past the
+    // 3 missed polls that remove an untracked plane), tracking must clear
     // and the camera must be RELEASED IN PLACE — viewer.trackedEntity
     // undefined and NO jump (the old contract flew an ~80 km overview; the
     // owner field-ruled that wrong: "it randomly zooms way up and loses my
@@ -1765,27 +1876,48 @@ async function main() {
       const beforeTracking = !!fl.getTrackedInfo();
       // Simulate the age-out via the shim: the plane stops arriving.
       window.__SYNTH.flights = window.__SYNTH.flights.filter((f) => f.icao !== icao);
-      // MISSING_POLL_LIMIT = 3 consecutive absent polls → removal + clear.
-      // Capture the camera pose right BEFORE the removing poll — the follow
-      // camera drifts with the coasting plane until the instant of release,
-      // so this is the "where the user was looking" reference.
+      // The tracked plane outlives MISSING_POLL_LIMIT (3 absent polls): it is
+      // kept until 10 min after its newest fix, so the camera keeps its target.
       await fl.update(v);
       await fl.update(v);
-      const c0 = v.camera.positionCartographic;
-      const atAgeOut = {
-        lonDeg: (c0.longitude * 180) / Math.PI,
-        latDeg: (c0.latitude * 180) / Math.PI,
-        height: c0.height,
-      };
-      await fl.update(v); // third miss → removal + clear + in-place release
-      return {
-        beforeTracking,
-        atAgeOut,
-        stillTrackedAfter: !!fl.getTrackedInfo(),
-        viewerStillTracking: !!v.trackedEntity,
-      };
+      await fl.update(v);
+      const trackedThroughMisses = !!fl.getTrackedInfo();
+      // Jump the page clock past the 10 min retention instead of waiting.
+      const realNow = Date.now;
+      Date.now = () => realNow() + 11 * 60 * 1000;
+      try {
+        // Let the follow camera settle on the stopped plane, then capture the
+        // pose right BEFORE the removing poll: the "where the user was
+        // looking" reference.
+        await new Promise((res) => {
+          const stop = v.scene.postRender.addEventListener(() => {
+            stop();
+            res();
+          });
+          v.scene.requestRender();
+        });
+        const c0 = v.camera.positionCartographic;
+        const atAgeOut = {
+          lonDeg: (c0.longitude * 180) / Math.PI,
+          latDeg: (c0.latitude * 180) / Math.PI,
+          height: c0.height,
+        };
+        await fl.update(v); // past retention → removal + clear + in-place release
+        return {
+          beforeTracking,
+          trackedThroughMisses,
+          atAgeOut,
+          stillTrackedAfter: !!fl.getTrackedInfo(),
+          viewerStillTracking: !!v.trackedEntity,
+        };
+      } finally {
+        Date.now = realNow;
+      }
     }, m3Icao);
 
+    record('M3: the tracked plane stays tracked through 3 missed polls (kept 10 min after its newest fix)',
+      m3.trackedThroughMisses,
+      `trackedThroughMisses=${m3.trackedThroughMisses}`);
     record('M3: tracking cleared after the tracked plane ages out (getTrackedInfo null)',
       m3.beforeTracking && !m3.stillTrackedAfter,
       `before=${m3.beforeTracking} trackedAfter=${m3.stillTrackedAfter}`);
diff --git a/src/data/motionModel.js b/src/data/motionModel.js
index eb6020850..7e4474c34 100644
--- a/src/data/motionModel.js
+++ b/src/data/motionModel.js
@@ -198,6 +198,157 @@ export function staleCoastLimitSeconds({
   return Math.min(ceiling, Math.max(floor, contactLeadSec + grace));
 }
 
+/** @constant {number} Dead reckoning never moves a contact faster than this
+ *  (1,500 kt, the trail's continuity limit), so a corrupt reported speed
+ *  cannot fly a coasting plane hundreds of kilometres. */
+export const COAST_MAX_SPEED_MPS = (1_500 * 1852) / 3600;
+
+/** @constant {number} A contact with no fresh report coasts at most this long past it, whatever its source limit; there is no distance cap. */
+export const STALE_COAST_MAX_SEC = 300;
+
+/** @constant {number} A report this close to a known ground height holds
+ *  instead of coasting. */
+export const STALE_HOLD_MAX_HEIGHT_M = 150;
+
+/**
+ * Whether a contact whose reports have stopped holds at its last reported
+ * position instead of coasting: it reported on the ground, or a known ground
+ * floor puts it within STALE_HOLD_MAX_HEIGHT_M of the ground (landing or
+ * taking off). A plane that low has no evidence of being anywhere but where
+ * it was last heard. Where the ground is unknown, barometric altitude is not
+ * read as height above it; the contact coasts under the stale cap.
+ * @param {object} report
+ * @param {boolean} [report.onGround]
+ * @param {number} [report.heightM] - Render height (ellipsoidal metres).
+ * @param {number} [report.groundM] - Ellipsoidal ground under the report, if known.
+ * @returns {boolean}
+ */
+export function staleHoldsAtLastReport({ onGround, heightM, groundM } = {}) {
+  if (onGround === true) return true;
+  return (
+    Number.isFinite(heightM) &&
+    Number.isFinite(groundM) &&
+    heightM - groundM < STALE_HOLD_MAX_HEIGHT_M
+  );
+}
+
+/**
+ * The hold-or-coast decision for a report, made once and kept on the report,
+ * so a ground floor that resolves while the contact coasts cannot flip it and
+ * snap the icon back. Height and position come from the report itself.
+ * @param {{position: Cesium.Cartesian3, staleHolds?: boolean}} fix - History
+ *   fix; `staleHolds` is stored on it.
+ * @param {object} args
+ * @param {boolean} [args.onGround] - The contact's ground flag.
+ * @param {(latDeg: number, lonDeg: number) => number|null} [args.cachedGroundFloor]
+ * @returns {boolean}
+ */
+export function staleHoldsForFix(fix, { onGround, cachedGroundFloor } = {}) {
+  if (typeof fix.staleHolds === 'boolean') return fix.staleHolds;
+  const carto = Cesium.Cartographic.fromCartesian(
+    fix.position,
+    Cesium.Ellipsoid.WGS84,
+    _holdCarto,
+  );
+  const groundM =
+    carto && typeof cachedGroundFloor === 'function'
+      ? cachedGroundFloor(
+          Cesium.Math.toDegrees(carto.latitude),
+          Cesium.Math.toDegrees(carto.longitude),
+        )
+      : null;
+  fix.staleHolds = staleHoldsAtLastReport({
+    onGround,
+    heightM: carto?.height,
+    groundM,
+  });
+  return fix.staleHolds;
+}
+
+const _holdCarto = new Cesium.Cartographic();
+
+/**
+ * Seconds a contact coasts past `newest` at a display time `elapsedSec`
+ * after it, counting any coast a synthetic fix already took since the real
+ * report it was built from (`reportEpochMs`), so a chain of synthetic fixes
+ * never coasts further than one report would.
+ * @param {object} args
+ * @param {{epochMs: number, reportEpochMs?: number, velocity?: number}} args.newest
+ * @param {number} args.elapsedSec - Display time past `newest`.
+ * @param {number} args.coastLimitSec - Source limit past `newest`.
+ * @param {boolean} args.holds
+ * @returns {number}
+ */
+export function staleCoastSecondsFrom({
+  newest,
+  elapsedSec,
+  coastLimitSec,
+  holds,
+}) {
+  const alreadySec = Number.isFinite(newest?.reportEpochMs)
+    ? Math.max(0, (newest.epochMs - newest.reportEpochMs) / 1000)
+    : 0;
+  return Math.max(
+    0,
+    staleCoastSeconds({
+      elapsedSec: elapsedSec + alreadySec,
+      coastLimitSec: coastLimitSec + alreadySec,
+      holds,
+    }) - alreadySec,
+  );
+}
+
+/** @constant {number} A coasted position sits at least this far (m) above the ground. */
+export const COAST_FLOOR_LIFT_M = 1.5;
+
+/**
+ * Lift a coasted position to COAST_FLOOR_LIFT_M above the ground where the
+ * ground is known; a coast runs level from the report and terrain may rise
+ * under it.
+ * @param {Cesium.Cartesian3} position - Mutated in place.
+ * @param {(latDeg: number, lonDeg: number) => number|null} [cachedGroundFloor]
+ * @returns {Cesium.Cartesian3}
+ */
+export function floorCoastedPosition(position, cachedGroundFloor) {
+  if (typeof cachedGroundFloor !== 'function') return position;
+  const carto = Cesium.Cartographic.fromCartesian(
+    position,
+    Cesium.Ellipsoid.WGS84,
+    _coastCarto,
+  );
+  if (!carto) return position;
+  const ground = cachedGroundFloor(
+    Cesium.Math.toDegrees(carto.latitude),
+    Cesium.Math.toDegrees(carto.longitude),
+  );
+  if (!Number.isFinite(ground) || carto.height >= ground + COAST_FLOOR_LIFT_M)
+    return position;
+  return Cesium.Cartesian3.fromRadians(
+    carto.longitude,
+    carto.latitude,
+    ground + COAST_FLOOR_LIFT_M,
+    Cesium.Ellipsoid.WGS84,
+    position,
+  );
+}
+
+const _coastCarto = new Cesium.Cartographic();
+
+/**
+ * Seconds to coast past the last report: the elapsed time, bounded by the
+ * source's coast limit and STALE_COAST_MAX_SEC; none for a contact that
+ * holds.
+ * @param {object} args
+ * @param {number} args.elapsedSec - Display time past the last report.
+ * @param {number} args.coastLimitSec - From `staleCoastLimitSeconds`.
+ * @param {boolean} args.holds - From `staleHoldsAtLastReport`.
+ * @returns {number}
+ */
+export function staleCoastSeconds({ elapsedSec, coastLimitSec, holds }) {
+  if (holds || !(elapsedSec > 0)) return 0;
+  return Math.max(0, Math.min(elapsedSec, coastLimitSec, STALE_COAST_MAX_SEC));
+}
+
 /**
  * Shortest-arc rate limiter: step `prevDeg` toward `targetDeg` by at most
  * `maxDegPerSec * dtSec`. Seeds directly on the target when prev is null.
@@ -446,12 +597,21 @@ const _forwardFixOffset = new Cesium.Cartesian3();
  * kinematics. This prevents a late course change from reprojecting the entire
  * stale interval and snapping the rendered contact by kilometres.
  *
+ * The same stale rules as the display apply: no fix for a contact that holds
+ * at its report (`staleHoldsForFix`, decided before calling), a coast of at
+ * most STALE_COAST_MAX_SEC counted from the real report
+ * (`reportEpochMs` carries it along a chain), and never below known ground.
+ * The result is a motion fix only, never a report for the trail.
+ *
  * @param {{time: Cesium.JulianDate, epochMs?: number, position: Cesium.Cartesian3,
- *   velocity?: number, track?: number}} newest Existing immutable history fix.
- * @param {{epochMs: number, velocity: number, track: number, turnRateDps?: number}} next
+ *   velocity?: number, track?: number, staleHolds?: boolean, reportEpochMs?: number}} newest
+ *   Existing immutable history fix.
+ * @param {{epochMs: number, velocity: number, track: number, turnRateDps?: number,
+ *   cachedGroundFloor?: Function}} next
  *   New kinematics and the wall/source epoch at which they become authoritative.
  * @returns {{time: Cesium.JulianDate, epochMs: number, position: Cesium.Cartesian3,
- *   velocity: number, track: number}|null} Forward synthetic fix, or null.
+ *   velocity: number, track: number, staleHolds?: boolean, reportEpochMs: number}|null}
+ *   Forward synthetic fix, or null.
  */
 export function synthesizeForwardKinematicsFix(newest, next = {}) {
   if (!newest?.position || !newest?.time || !Number.isFinite(next.epochMs))
@@ -461,12 +621,18 @@ export function synthesizeForwardKinematicsFix(newest, next = {}) {
     : Cesium.JulianDate.toDate(newest.time).getTime();
   if (!Number.isFinite(startEpochMs) || next.epochMs <= startEpochMs)
     return null;
+  if (newest.staleHolds === true) return null;
 
   const previousVelocity = Number.isFinite(newest.velocity)
     ? Math.max(0, newest.velocity)
     : 0;
   const previousTrack = Number.isFinite(newest.track) ? newest.track : 0;
-  const dtSec = (next.epochMs - startEpochMs) / 1000;
+  const dtSec = staleCoastSecondsFrom({
+    newest: { epochMs: startEpochMs, reportEpochMs: newest.reportEpochMs },
+    elapsedSec: (next.epochMs - startEpochMs) / 1000,
+    coastLimitSec: Infinity,
+    holds: false,
+  });
   arcOffsetEnu(
     previousVelocity,
     previousTrack,
@@ -485,14 +651,21 @@ export function synthesizeForwardKinematicsFix(newest, next = {}) {
     Cesium.Ellipsoid.WGS84,
     _forwardFixEnu,
   );
-  const position = Cesium.Matrix4.multiplyByPoint(
-    enu,
-    _forwardFixOffset,
-    new Cesium.Cartesian3(),
+  const position = floorCoastedPosition(
+    Cesium.Matrix4.multiplyByPoint(
+      enu,
+      _forwardFixOffset,
+      new Cesium.Cartesian3(),
+    ),
+    next.cachedGroundFloor,
   );
   return {
     time: Cesium.JulianDate.fromDate(new Date(next.epochMs)),
     epochMs: next.epochMs,
+    reportEpochMs: Number.isFinite(newest.reportEpochMs)
+      ? newest.reportEpochMs
+      : startEpochMs,
+    staleHolds: newest.staleHolds,
     position,
     velocity: Number.isFinite(next.velocity)
       ? Math.max(0, next.velocity)
diff --git a/src/data/routeSegment.test.mjs b/src/data/routeSegment.test.mjs
index caa02c4ea..0760c4825 100644
--- a/src/data/routeSegment.test.mjs
+++ b/src/data/routeSegment.test.mjs
@@ -140,7 +140,10 @@ test('the actual native tracked label hides the wrong leg and keeps a healthy ro
     ].map((name) => [name, {}]),
   );
   services.aircraftPresentation = { isTr3b: () => false };
-  const parts = { queries: { _contactLabel: (_, info) => info.callsign } };
+  const parts = {
+    queries: { _contactLabel: (_, info) => info.callsign },
+    motion: { _signalLost: () => null },
+  };
   const tracking = createTracking({ flightState, services, parts });
   for (const [position, expected] of [
     [beyond, false],
diff --git a/src/data/trailContinuity.js b/src/data/trailContinuity.js
new file mode 100644
index 000000000..629b8bca1
--- /dev/null
+++ b/src/data/trailContinuity.js
@@ -0,0 +1,607 @@
+/**
+ * @module trailContinuity
+ * @description Where a tracked aircraft's trail lifts the pen.
+ *
+ * A trail is a chronological list of fixes `{position, timeMs, nullAltitude,
+ * breakBefore, drawn}`: reports, and (`drawn`) points where the tracked icon
+ * was drawn between them. Between two consecutive fixes that are not one path, a new
+ * segment starts and nothing is drawn between them: no dashes, no arcs.
+ * Nothing is dropped except the oldest fixes past the layer's point limit.
+ *
+ * Two points are not one path when time does not advance, when the gap is
+ * longer than 48 minutes (a coverage hole or a separate flight), when the
+ * implied great-circle speed is over 1,500 kt, or when either point has no
+ * reported altitude. A parked aircraft is the exception: a pair under three
+ * hours apart within 0.1 nm stays one path.
+ *
+ * Civil and military flight tracking share these rules.
+ */
+import * as Cesium from 'cesium';
+
+/** @constant {number} A gap longer than this is a coverage hole or a separate flight. */
+export const TRAIL_CONTINUITY_MAX_GAP_MS = 48 * 60_000;
+
+/** @constant {number} A pair implying more than this great-circle speed is not one path. */
+export const TRAIL_CONTINUITY_MAX_SPEED_KT = 1_500;
+
+/** @constant {number} A parked aircraft may stop reporting this long and stay one path. */
+export const TRAIL_STATIONARY_HOLD_MAX_GAP_MS = 3 * 60 * 60_000;
+
+/** @constant {number} How close (nautical miles) two points must be to count as parked. */
+export const TRAIL_STATIONARY_HOLD_MAX_DISTANCE_NM = 0.1;
+
+/** @constant {number} The head never joins a body point farther than this from the aircraft. */
+export const TRAIL_HEAD_JOIN_MAX_M = 150_000;
+
+const METRES_PER_NM = 1852;
+
+/** @constant {number} Mean Earth radius (m) for great-circle trail distances. */
+const EARTH_MEAN_RADIUS_M = 6_371_008.8;
+
+/**
+ * Whether two consecutive trail points belong to different paths. Time that
+ * does not advance, a gap over TRAIL_CONTINUITY_MAX_GAP_MS or an implied
+ * speed over TRAIL_CONTINUITY_MAX_SPEED_KT breaks the line, except for a
+ * parked aircraft: a pair under three hours apart within 0.1 nm.
+ * @param {number} deltaMs - Later point's time minus the earlier one's.
+ * @param {number} distanceM - Great-circle distance between the points.
+ * @returns {boolean}
+ */
+export function trailPairBreaks(deltaMs, distanceM) {
+  if (!(deltaMs > 0) || !Number.isFinite(distanceM)) return true;
+  const distanceNm = distanceM / METRES_PER_NM;
+  if (
+    deltaMs <= TRAIL_STATIONARY_HOLD_MAX_GAP_MS &&
+    distanceNm <= TRAIL_STATIONARY_HOLD_MAX_DISTANCE_NM
+  )
+    return false;
+  return (
+    deltaMs > TRAIL_CONTINUITY_MAX_GAP_MS ||
+    distanceNm / (deltaMs / 3_600_000) > TRAIL_CONTINUITY_MAX_SPEED_KT
+  );
+}
+
+/**
+ * Whether the head segment may join the last body point to the aircraft:
+ * within TRAIL_HEAD_JOIN_MAX_M and not broken under `trailPairBreaks`.
+ * @param {number} deltaMs - Current time minus the body point's time.
+ * @param {number} distanceM - Distance from the body point to the aircraft.
+ * @returns {boolean}
+ */
+export function trailHeadJoins(deltaMs, distanceM) {
+  return (
+    distanceM <= TRAIL_HEAD_JOIN_MAX_M && !trailPairBreaks(deltaMs, distanceM)
+  );
+}
+
+/**
+ * Great-circle distance between two trail positions, in metres.
+ * @param {Cesium.Cartesian3} a
+ * @param {Cesium.Cartesian3} b
+ * @returns {number}
+ */
+export function trailDistanceM(a, b) {
+  return Cesium.Cartesian3.angleBetween(a, b) * EARTH_MEAN_RADIUS_M;
+}
+
+/**
+ * Whether the pen lifts between two consecutive fixes.
+ * @param {object|undefined} prev - Earlier fix, if any.
+ * @param {object} next - Later fix.
+ * @returns {boolean}
+ */
+export function trailFixBreaks(prev, next) {
+  if (!prev || prev.nullAltitude || next.nullAltitude) return true;
+  // A recorded point is where the icon was drawn; the speed between it and a
+  // report it was eased onto is not a flight speed, so only the gap counts.
+  if (prev.drawn || next.drawn)
+    return Math.abs(next.timeMs - prev.timeMs) > TRAIL_CONTINUITY_MAX_GAP_MS;
+  return trailPairBreaks(
+    next.timeMs - prev.timeMs,
+    trailDistanceM(prev.position, next.position),
+  );
+}
+
+/**
+ * Build backfill fixes from chronological waypoints. Every waypoint with a
+ * position is kept. A waypoint without one (no altitude and no known ground)
+ * is skipped, and the line still breaks there.
+ * @param {{position: Cesium.Cartesian3|null, timeMs: number, nullAltitude: boolean}[]} waypoints
+ * @returns {{fixes: object[], breakAfter: boolean}} The fixes, and whether the
+ *   line breaks after the last one because trailing waypoints were skipped.
+ */
+export function trailBackfillFixes(waypoints) {
+  const fixes = [];
+  let skipped = false;
+  for (const { position, timeMs, nullAltitude } of waypoints) {
+    if (!position) {
+      skipped = true;
+      continue;
+    }
+    const fix = { position, timeMs, nullAltitude: !!nullAltitude };
+    fix.breakBefore = skipped || trailFixBreaks(fixes[fixes.length - 1], fix);
+    skipped = false;
+    fixes.push(fix);
+  }
+  return { fixes, breakAfter: skipped };
+}
+
+/**
+ * Put backfill fixes ahead of the live trail. The join follows the same
+ * rule, so a distant history tail never connects to the first live fix.
+ * Past `maxPoints` the oldest recorded points go first, then the oldest
+ * reports.
+ * @param {{fixes: object[], breakAfter: boolean}} backfill
+ * @param {object[]} live - Live fixes; the first one's break is recomputed.
+ * @param {number} maxPoints - Point limit across all segments.
+ * @returns {object[]} The joined trail.
+ */
+export function joinTrailBackfill({ fixes, breakAfter }, live, maxPoints) {
+  if (!fixes.length) return live;
+  if (live.length)
+    live[0].breakBefore =
+      breakAfter || trailFixBreaks(fixes[fixes.length - 1], live[0]);
+  return keepTrailLimit(fixes.concat(live), maxPoints);
+}
+
+/**
+ * How many fixes the drawn body holds: every fix at or before the display
+ * time, where the aircraft is drawn. Fixes ahead of it (reports newer than
+ * the delayed display) are reached by the head segment instead, so the trail
+ * never runs past the aircraft, and once the display passes the newest
+ * report the body ends there.
+ * @param {object[]} fixes
+ * @param {number} displayMs - Time the aircraft is drawn at.
+ * @returns {number}
+ */
+export function trailBodyCount(fixes, displayMs) {
+  let count = fixes.length;
+  while (count > 0 && fixes[count - 1].timeMs > displayMs) count -= 1;
+  return count;
+}
+
+/**
+ * Leave out the newest recorded points that lie inside the aircraft's 3D
+ * model, so the body never runs through the fuselage; the head then runs
+ * from the newest point outside the model to the plane. Reports are kept.
+ * @param {object[]} fixes
+ * @param {number} count - From `trailBodyCount`.
+ * @param {Cesium.Cartesian3|null} modelCenter - The model's centre, or null
+ *   when no model is the visual.
+ * @param {number|null} envelopeM - The model's radius (m).
+ * @returns {number}
+ */
+export function trailBodyCountOutsideModel(
+  fixes,
+  count,
+  modelCenter,
+  envelopeM,
+) {
+  if (!modelCenter || !(envelopeM > 0)) return count;
+  while (
+    count > 0 &&
+    fixes[count - 1].drawn &&
+    Cesium.Cartesian3.distance(fixes[count - 1].position, modelCenter) <
+      envelopeM
+  )
+    count -= 1;
+  return count;
+}
+
+/**
+ * The drawn trail body, split at breaks: the first `count` fixes.
+ * @param {object[]} fixes
+ * @param {number} count - From `trailBodyCount`.
+ * @returns {Cesium.Cartesian3[][]}
+ */
+export function trailBodySegments(fixes, count) {
+  const segments = [];
+  for (let i = 0; i < count; i++) {
+    const fix = fixes[i];
+    // A live report with no altitude keeps no position; it only breaks the line.
+    if (!fix.position) continue;
+    if (fix.breakBefore || !segments.length) segments.push([]);
+    segments[segments.length - 1].push(fix.position);
+  }
+  return segments;
+}
+
+/**
+ * Draw body segments. A trail without breaks support draws only the newest
+ * segment, never a line across a break.
+ * @param {{setSegments?: Function, setPositions: Function}} trail
+ * @param {Cesium.Cartesian3[][]} segments
+ */
+export function drawTrailSegments(trail, segments) {
+  if (typeof trail.setSegments === 'function') trail.setSegments(segments);
+  else trail.setPositions(segments[segments.length - 1] ?? []);
+}
+
+/** @constant {number} A head shorter than this (m) is not drawn: the aircraft is holding at its last report. */
+const TRAIL_HEAD_MIN_M = 0.5;
+
+/**
+ * The body fix the head segment starts from, or null when the head is not
+ * drawn: no body yet, the aircraft holding at that fix, a body point more
+ * than 150 km from the aircraft, or one too long ago or too far away to be
+ * one path.
+ * @param {object[]} fixes
+ * @param {Cesium.Cartesian3} head - Displayed aircraft position.
+ * @param {number} nowMs - Current time.
+ * @param {number} count - Body fixes, from `trailBodyCount`.
+ * @returns {object|null}
+ */
+export function trailHeadStartFix(fixes, head, nowMs, count) {
+  if (count < 1 || !head) return null;
+  const last = fixes[count - 1];
+  if (!last.position) return null;
+  if (Cesium.Cartesian3.distance(last.position, head) < TRAIL_HEAD_MIN_M)
+    return null;
+  return trailHeadJoins(
+    nowMs - last.timeMs,
+    trailDistanceM(last.position, head),
+  )
+    ? last
+    : null;
+}
+
+/**
+ * Epoch ms of a position-history fix (`{epochMs?, time}`).
+ * @param {object|undefined} fix
+ * @returns {number} NaN when unknown.
+ */
+export function historyFixEpochMs(fix) {
+  if (Number.isFinite(fix?.epochMs)) return fix.epochMs;
+  return fix?.time ? Cesium.JulianDate.toDate(fix.time).getTime() : NaN;
+}
+
+/** @constant {number} The tracked icon's drawn position is recorded at least this often (ms of display time)... */
+export const TRAIL_RECORD_STEP_MS = 1_000;
+
+/** @constant {number} ...or whenever it has moved this far (m), whichever comes first. */
+export const TRAIL_RECORD_STEP_M = 150;
+
+/** @constant {number} A recorded point is kept only where dropping it would move the line by more than this (m) across the track or in height. */
+export const TRAIL_THIN_TOLERANCE_M = 30;
+
+/** @constant {number} A recorded point is kept where dropping it would leave a straight piece longer than this (m), so a long leg still has vertices. */
+export const TRAIL_THIN_MAX_SPAN_M = 10_000;
+
+/** @constant {number} A kept point stands in for at most this many dropped positions; past it the point is kept. */
+const TRAIL_THIN_MAX_ABSORBED = 512;
+
+/** @constant {number} A recorded point is dropped where the line turns back sharper than this (degrees)... */
+export const TRAIL_SPUR_TURN_DEG = 120;
+
+/** @constant {number} ...over a step shorter than this (m). */
+export const TRAIL_SPUR_MAX_STEP_M = 500;
+
+/** @constant {number} A recorded point closer than this (m) to the previous one is not kept: the aircraft is holding. */
+const TRAIL_RECORD_MIN_STEP_M = 1;
+
+const _u = new Cesium.Cartesian3();
+const _v = new Cesium.Cartesian3();
+
+/** Cosine of the turn at `b` on the way a → b → c, or NaN for a zero step. */
+function turnCos(a, b, c) {
+  Cesium.Cartesian3.subtract(b, a, _u);
+  Cesium.Cartesian3.subtract(c, b, _v);
+  const lu = Cesium.Cartesian3.magnitude(_u);
+  const lv = Cesium.Cartesian3.magnitude(_v);
+  if (!(lu > 0 && lv > 0)) return NaN;
+  return Cesium.Cartesian3.dot(_u, _v) / (lu * lv);
+}
+
+const SPUR_COS = Math.cos(Cesium.Math.toRadians(TRAIL_SPUR_TURN_DEG));
+
+/** Whether entry `i` and its neighbours are one drawn piece of line. */
+function joinedAt(fixes, i) {
+  const a = fixes[i - 1];
+  const b = fixes[i];
+  const c = fixes[i + 1];
+  return (
+    a?.position &&
+    b?.position &&
+    c?.position &&
+    !b.breakBefore &&
+    !c.breakBefore
+  );
+}
+
+/** Whether the line turns back on itself at entry `i` over a short step. */
+function spurAt(fixes, i) {
+  if (!joinedAt(fixes, i)) return false;
+  const a = fixes[i - 1].position;
+  const b = fixes[i].position;
+  const c = fixes[i + 1].position;
+  if (
+    Math.min(
+      Cesium.Cartesian3.distance(a, b),
+      Cesium.Cartesian3.distance(b, c),
+    ) > TRAIL_SPUR_MAX_STEP_M
+  )
+    return false;
+  return turnCos(a, b, c) < SPUR_COS;
+}
+
+/** Remove entry `i` and re-judge the break before the entry that takes its place. */
+function removeAt(fixes, i) {
+  fixes.splice(i, 1);
+  if (i < fixes.length)
+    fixes[i].breakBefore = trailFixBreaks(fixes[i - 1], fixes[i]);
+}
+
+/**
+ * Keep the point limit: drop the oldest recorded point first, and the oldest
+ * report only when no recorded point is left.
+ * @param {object[]} fixes - The trail, mutated.
+ * @param {number} maxPoints
+ * @returns {object[]} `fixes`.
+ */
+function keepTrailLimit(fixes, maxPoints) {
+  let excess = fixes.length - maxPoints;
+  if (excess <= 0) return fixes;
+  for (let i = 0; i < fixes.length && excess > 0;) {
+    if (fixes[i].drawn) {
+      removeAt(fixes, i);
+      excess -= 1;
+    } else i += 1;
+  }
+  if (excess > 0) fixes.splice(0, excess);
+  return fixes;
+}
+
+const _ab = new Cesium.Cartesian3();
+const _ap = new Cesium.Cartesian3();
+const _off = new Cesium.Cartesian3();
+const _up = new Cesium.Cartesian3();
+
+/** Whether `p` lies within the thinning tolerance of segment a → b, across the track and in height. */
+function nearSegment(p, a, b) {
+  Cesium.Cartesian3.subtract(b, a, _ab);
+  Cesium.Cartesian3.subtract(p, a, _ap);
+  const len2 = Cesium.Cartesian3.magnitudeSquared(_ab);
+  const t =
+    len2 > 0
+      ? Math.max(0, Math.min(1, Cesium.Cartesian3.dot(_ap, _ab) / len2))
+      : 0;
+  Cesium.Cartesian3.multiplyByScalar(_ab, t, _off);
+  Cesium.Cartesian3.subtract(_ap, _off, _off);
+  Cesium.Cartesian3.normalize(p, _up);
+  const vertical = Cesium.Cartesian3.dot(_off, _up);
+  const across = Math.sqrt(
+    Math.max(0, Cesium.Cartesian3.magnitudeSquared(_off) - vertical * vertical),
+  );
+  return (
+    Math.abs(vertical) <= TRAIL_THIN_TOLERANCE_M &&
+    across <= TRAIL_THIN_TOLERANCE_M
+  );
+}
+
+/**
+ * Drop recorded point `i` when the line without it stays within the
+ * tolerance of every position it stood for, and the straight piece left is
+ * no longer than TRAIL_THIN_MAX_SPAN_M. The positions it stood for go on to
+ * the next entry. Reports are never dropped.
+ * @returns {boolean} Whether it was dropped.
+ */
+function thinAt(fixes, i) {
+  const entry = fixes[i];
+  if (!entry?.drawn || entry.sealed || !joinedAt(fixes, i)) return false;
+  const a = fixes[i - 1].position;
+  const next = fixes[i + 1];
+  if (next.sealed) return false;
+  const b = next.position;
+  if (Cesium.Cartesian3.distance(a, b) > TRAIL_THIN_MAX_SPAN_M) return false;
+  const stood = entry.absorbed ?? [];
+  const nextStood = next.absorbed ?? [];
+  if (stood.length + nextStood.length + 1 > TRAIL_THIN_MAX_ABSORBED)
+    return false;
+  if (!nearSegment(entry.position, a, b)) return false;
+  for (const p of stood) if (!nearSegment(p.position, a, b)) return false;
+  for (const p of nextStood) if (!nearSegment(p.position, a, b)) return false;
+  next.absorbed = stood.concat(
+    [{ position: entry.position, timeMs: entry.timeMs }],
+    nextStood,
+  );
+  removeAt(fixes, i);
+  return true;
+}
+
+/**
+ * Thin the recorded points either side of entry `i`, reaching past a
+ * neighbouring report: the point recorded just before a report is only
+ * judged once the line goes on beyond it.
+ */
+function thinAround(fixes, i) {
+  if (!thinAt(fixes, i + 1) && fixes[i + 1] && !fixes[i + 1].drawn)
+    thinAt(fixes, i + 2);
+  if (thinAt(fixes, i - 1)) i -= 1;
+  else if (fixes[i - 1] && !fixes[i - 1].drawn) thinAt(fixes, i - 2);
+}
+
+/**
+ * Drop recorded points that make a spur next to entry `i`. Reports are never
+ * dropped; at a report the recorded neighbour is dropped instead.
+ * @returns {number} The index entry `i` ends up at.
+ */
+function removeSpursAround(fixes, i) {
+  for (let guard = 0; guard < 64; guard++) {
+    let changed = false;
+    for (const j of [i - 1, i, i + 1]) {
+      if (!spurAt(fixes, j)) continue;
+      let drop = -1;
+      if (fixes[j].drawn) drop = j;
+      else if (fixes[j + 1]?.drawn) drop = j + 1;
+      else if (fixes[j - 1]?.drawn) drop = j - 1;
+      if (drop < 0) continue;
+      removeAt(fixes, drop);
+      if (drop < i) i -= 1;
+      changed = true;
+      break;
+    }
+    if (!changed) break;
+  }
+  return i;
+}
+
+/** Index a fix at `timeMs` goes in at: after every entry at or before it. */
+function insertionIndex(fixes, timeMs) {
+  let i = fixes.length;
+  while (i > 0 && fixes[i - 1].timeMs > timeMs) i -= 1;
+  return i;
+}
+
+/**
+ * Insert an entry at `i`, judge both breaks, remove spurs, thin the recorded
+ * points either side and keep the limit.
+ */
+function insertAt(fixes, i, entry, maxPoints) {
+  fixes.splice(i, 0, entry);
+  entry.breakBefore = trailFixBreaks(fixes[i - 1], entry);
+  const after = fixes[i + 1];
+  if (after) {
+    after.breakBefore = trailFixBreaks(entry, after);
+    // Positions the next entry stood for that come before this one are now
+    // on this entry's side.
+    if (after.absorbed?.length) {
+      const mine = after.absorbed.filter((p) => p.timeMs < entry.timeMs);
+      if (mine.length) {
+        entry.absorbed = mine;
+        after.absorbed = after.absorbed.filter((p) => p.timeMs >= entry.timeMs);
+      }
+    }
+  }
+  i = removeSpursAround(fixes, i);
+  thinAround(fixes, i);
+  keepTrailLimit(fixes, maxPoints);
+}
+
+/** Index of the newest report before entry `i`, or -1. */
+function reportBefore(fixes, i) {
+  let j = i - 1;
+  while (j >= 0 && fixes[j].drawn) j -= 1;
+  return j;
+}
+
+/** Index of the oldest report at or after `i`, or `fixes.length`. */
+function reportFrom(fixes, i) {
+  let j = i;
+  while (j < fixes.length && fixes[j].drawn) j += 1;
+  return j;
+}
+
+/**
+ * Put a report into the trail in time order. Reports are the record: they
+ * are kept as anchors among the recorded points.
+ *
+ * - A report the display has already passed replaces the guess drawn after
+ *   it: the recorded points timed after it go, and nothing is recorded until
+ *   the icon has eased onto the correction (`displayMs` + `settleMs`), so the
+ *   line reads arc, report, corrected path.
+ * - Recorded points never join two reports that break under
+ *   `trailPairBreaks` (too long or too fast apart to be one flight): the
+ *   points between them go and the line breaks.
+ * - A live report with no altitude keeps no position and only breaks the
+ *   line.
+ * @param {object[]} fixes - The trail, mutated.
+ * @param {Cesium.Cartesian3} position - Owned position.
+ * @param {number} timeMs - The report's epoch ms.
+ * @param {number} maxPoints - Point limit across all segments.
+ * @param {{nullAltitude?: boolean, displayMs?: number, settleMs?: number}} [options]
+ *   `displayMs`: the time the aircraft is drawn at as the report arrives;
+ *   `settleMs`: how long the icon takes to ease onto a correction.
+ * @returns {object[]} `fixes`.
+ */
+export function insertTrailFix(
+  fixes,
+  position,
+  timeMs,
+  maxPoints,
+  { nullAltitude = false, displayMs = NaN, settleMs = 0 } = {},
+) {
+  const entry = {
+    position: nullAltitude ? null : position,
+    timeMs,
+    nullAltitude,
+    drawn: false,
+    breakBefore: false,
+  };
+  let i = insertionIndex(fixes, timeMs);
+  // The guess drawn after a report the display already passed.
+  fixes.splice(i, reportFrom(fixes, i) - i);
+  if (displayMs > timeMs) entry.settleUntilMs = displayMs + settleMs;
+  // Recorded points across a pair of reports that are not one flight.
+  const before = reportBefore(fixes, i);
+  if (before >= 0 && trailFixBreaks(fixes[before], entry)) {
+    fixes.splice(before + 1, i - before - 1);
+    i = before + 1;
+  }
+  insertAt(fixes, i, entry, maxPoints);
+  return fixes;
+}
+
+/**
+ * Record where the tracked aircraft was drawn at a display time. Between
+ * reports this recorded path is the trail, so the line follows every turn
+ * the icon made instead of a straight chord between two reports. Points are
+ * thinned by shape: one stays only where dropping it would move the line by
+ * more than TRAIL_THIN_TOLERANCE_M across the track or in height, or leave a
+ * straight piece longer than TRAIL_THIN_MAX_SPAN_M. Nothing is recorded
+ * while the aircraft holds.
+ * @param {object[]} fixes - The trail, mutated.
+ * @param {Cesium.Cartesian3} position - Owned drawn position.
+ * @param {number} timeMs - Display time it was drawn for.
+ * @param {number} maxPoints - Point limit across all segments.
+ * @returns {boolean} Whether the trail changed.
+ */
+export function recordTrailPoint(fixes, position, timeMs, maxPoints) {
+  const i = insertionIndex(fixes, timeMs);
+  const prev = fixes[i - 1];
+  if (
+    prev?.position &&
+    Cesium.Cartesian3.distance(prev.position, position) <
+      TRAIL_RECORD_MIN_STEP_M
+  )
+    return false;
+  const entry = {
+    position,
+    timeMs,
+    nullAltitude: false,
+    drawn: true,
+    breakBefore: false,
+  };
+  insertAt(fixes, i, entry, maxPoints);
+  // Entries before the second report behind this point can never be thinned
+  // again, so they let go of the positions they stood for.
+  const passed = reportBefore(fixes, fixes.lastIndexOf(entry));
+  if (passed >= 0) sealThrough(fixes, reportBefore(fixes, passed));
+  return true;
+}
+
+/** Release the absorbed positions of entry `i` and everything before it. */
+function sealThrough(fixes, i) {
+  for (let j = i; j >= 0 && !fixes[j].sealed; j--) {
+    fixes[j].sealed = true;
+    delete fixes[j].absorbed;
+  }
+}
+
+/**
+ * Whether the icon's drawn position must not be recorded at a display time:
+ * a report on either side of it has no altitude (the icon is drawn at an
+ * invented height), the reports on either side are not one flight
+ * (`trailPairBreaks`), or the icon is still easing onto a report that
+ * arrived after the display had passed it.
+ * @param {object[]} fixes
+ * @param {number} displayMs
+ * @returns {boolean}
+ */
+export function trailRecordingBlocked(fixes, displayMs) {
+  const i = insertionIndex(fixes, displayMs);
+  const before = fixes[reportBefore(fixes, i)];
+  const after = fixes[reportFrom(fixes, i)];
+  if (before?.nullAltitude || after?.nullAltitude) return true;
+  if (before?.settleUntilMs > displayMs) return true;
+  return !!(before && after && trailFixBreaks(before, after));
+}
diff --git a/src/data/trailRenderer.js b/src/data/trailRenderer.js
index 8c69ca31c..97c7d3497 100644
--- a/src/data/trailRenderer.js
+++ b/src/data/trailRenderer.js
@@ -14,6 +14,18 @@
  *    the whole history renders at one readable alpha (dimmer where it passes
  *    behind/below geometry).
  *
+ * A trail with breaks draws each segment separately and nothing between
+ * them. Every segment is cut into chunks of up to CHUNK_POINTS points;
+ * adjacent chunks share their boundary point, so the line has no seam. A
+ * chunk that can no longer change (every chunk except the newest one of the
+ * newest segment) is FROZEN: an entity with constant positions, built once as
+ * static geometry, so it costs nothing per frame. Only the newest chunk stays
+ * dynamic. A freshly frozen chunk is also drawn dynamically until its static
+ * geometry is in the scene, so freezing never shows a blank frame. A chunk is
+ * identified by its position objects, so a chunk survives every update that
+ * keeps those points: appends, a backfill prepended ahead of it, or the
+ * oldest points dropping off the front (which rebuilds only the first chunk).
+ *
  * Trails update at poll cadence (~15-60 s) plus once on history backfill, so
  * assigning a fresh positions array per update is cheap. `allowPicking` has
  * no entity equivalent; the polyline entity is excluded from clicks by never
@@ -42,6 +54,13 @@ const TRAIL_ALPHA = 0.85;
 const TRAIL_OCCLUDED_ALPHA = 0.4;
 /** @constant {number} Squared distance (m^2) below which consecutive points are merged. */
 const MIN_SEGMENT_DISTANCE_SQ = 0.01;
+/** @constant {Cesium.Cartesian3[]} What a spare dynamic polyline draws. */
+const NO_POSITIONS = Object.freeze([]);
+/** @constant {number} Points per chunk; adjacent chunks share one point. */
+export const CHUNK_POINTS = 128;
+/** @constant {number} Visible frames a frozen chunk's stand-in waits for its
+ *  static geometry before it is dropped anyway. */
+const STAND_IN_MAX_FRAMES = 600;
 
 /**
  * Create an always-visible polyline trail bound to a viewer.
@@ -49,93 +68,285 @@ const MIN_SEGMENT_DISTANCE_SQ = 0.01;
  * @param {object} options - Trail options.
  * @param {string} options.color - CSS color string for the trail hue.
  * @param {number} [options.width=2.5] - Polyline width in pixels.
- * @returns {{setPositions: function(Cesium.Cartesian3[]): void, setVisible: function(boolean): void, clear: function(): void, destroy: function(): void}}
- *   Trail handle: setPositions replaces the geometry, setVisible temporarily
- *   hides it without discarding history, clear empties it, and destroy removes
- *   the entity permanently.
+ * @returns {{setPositions: function(Cesium.Cartesian3[]): void, setSegments: function(Cesium.Cartesian3[][]): void, setVisible: function(boolean): void, clear: function(): void, destroy: function(): void}}
+ *   Trail handle: setPositions replaces the geometry with one line,
+ *   setSegments with one line per segment, setVisible temporarily hides it
+ *   without discarding history, clear empties it, and destroy removes the
+ *   entities permanently.
  */
 export function createTrail(viewer, { color, width = 2.5 }) {
   const baseColor = Cesium.Color.fromCssColorString(color);
-  /** @type {Cesium.Cartesian3[]} Current deduped positions (owned copy). */
-  let current = [];
+  const material = baseColor.withAlpha(TRAIL_ALPHA);
+  const depthFailMaterial = baseColor.withAlpha(TRAIL_OCCLUDED_ALPHA);
   let destroyed = false;
   let visible = true;
-  /** @type {Cesium.Entity|null} */
-  let entity = null;
+  /** @type {{positions: Cesium.Cartesian3[], entity: Cesium.Entity, standIn: boolean, frames: number}[]} */
+  let frozen = [];
+  /** Newest chunk of the newest segment: the only part that changes. */
+  let tail = NO_POSITIONS;
+  /** What the dynamic polylines draw: the tail, then frozen chunks whose
+   *  static geometry is not in the scene yet. */
+  let dynamicRuns = [];
+  /** @type {Cesium.Entity[]} Pooled dynamic polylines; spares draw nothing. */
+  const dynamicEntities = [];
+  let removeReadyListener = null;
+  const scratchSphere = new Cesium.BoundingSphere();
 
-  function ensureEntity() {
-    if (entity || destroyed || !viewer || viewer.isDestroyed()) return;
-    entity = viewer.entities.add({
+  const usable = () => !destroyed && viewer && !viewer.isDestroyed();
+
+  function polyline(positions) {
+    return {
+      positions,
+      width,
+      material,
+      // The owner-locked rule (round 6): a segment below the photoreal
+      // mesh renders dimmed — it must never disappear into the ground.
+      depthFailMaterial,
+      // Round 8 (owner: UAL1104's Pacific trail "cutting through the
+      // globe"): NONE draws straight 3D chords between waypoints — over a
+      // sparse trans-oceanic trace a single segment spans hundreds of km
+      // and tunnels through the planet. GEODESIC subdivides each segment
+      // along the curved surface (heights interpolated), so long legs hug
+      // the globe instead of chording through it.
+      arcType: Cesium.ArcType.GEODESIC,
+    };
+  }
+
+  function addEntity(positions) {
+    return viewer.entities.add({
       id: `gev-trail:${++_trailSeq}`,
       show: visible,
-      polyline: {
-        // CallbackProperty so a positions swap never rebuilds the entity —
-        // Cesium re-reads on change; `false` marks it non-constant.
-        positions: new Cesium.CallbackProperty(() => current, false),
-        width,
-        material: baseColor.withAlpha(TRAIL_ALPHA),
-        // The owner-locked rule (round 6): a segment below the photoreal
-        // mesh renders dimmed — it must never disappear into the ground.
-        depthFailMaterial: baseColor.withAlpha(TRAIL_OCCLUDED_ALPHA),
-        // Round 8 (owner: UAL1104's Pacific trail "cutting through the
-        // globe"): NONE draws straight 3D chords between waypoints — over a
-        // sparse trans-oceanic trace a single segment spans hundreds of km
-        // and tunnels through the planet. GEODESIC subdivides each segment
-        // along the curved surface (heights interpolated), so long legs hug
-        // the globe instead of chording through it.
-        arcType: Cesium.ArcType.GEODESIC,
-      },
+      polyline: polyline(positions),
     });
   }
 
+  function removeEntity(entity) {
+    try {
+      viewer.entities.remove(entity);
+    } catch {
+      /* torn down */
+    }
+  }
+
+  function syncDynamic() {
+    dynamicRuns = [];
+    if (tail.length >= 2) dynamicRuns.push(tail);
+    for (const chunk of frozen)
+      if (chunk.standIn) dynamicRuns.push(chunk.positions);
+    while (dynamicEntities.length < Math.max(1, dynamicRuns.length)) {
+      const index = dynamicEntities.length;
+      dynamicEntities.push(
+        addEntity(
+          // CallbackProperty so a positions swap never rebuilds the entity —
+          // Cesium re-reads on change; `false` marks it non-constant.
+          new Cesium.CallbackProperty(
+            () => dynamicRuns[index] ?? NO_POSITIONS,
+            false,
+          ),
+        ),
+      );
+    }
+  }
+
+  /** Whether a frozen chunk's static geometry is drawn in the scene. */
+  function staticReady(chunk) {
+    const display = viewer.dataSourceDisplay;
+    if (typeof display?.getBoundingSphere !== 'function') return true;
+    if (!visible) return false;
+    chunk.frames += 1;
+    if (chunk.frames > STAND_IN_MAX_FRAMES) return true;
+    try {
+      return (
+        display.getBoundingSphere(chunk.entity, false, scratchSphere) ===
+        Cesium.BoundingSphereState.DONE
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  /** Drop stand-ins whose static geometry is in; stop listening when none are left. */
+  function resolveStandIns() {
+    if (!usable()) return;
+    let changed = false;
+    for (const chunk of frozen) {
+      if (chunk.standIn && staticReady(chunk)) {
+        chunk.standIn = false;
+        changed = true;
+      }
+    }
+    if (changed) syncDynamic();
+    if (!frozen.some((chunk) => chunk.standIn)) stopListening();
+  }
+
+  function stopListening() {
+    if (removeReadyListener) removeReadyListener();
+    removeReadyListener = null;
+  }
+
+  function listenForStandIns() {
+    if (removeReadyListener) return;
+    const event = viewer.scene?.postRender;
+    if (typeof event?.addEventListener !== 'function') {
+      resolveStandIns();
+      return;
+    }
+    removeReadyListener = event.addEventListener(resolveStandIns);
+  }
+
+  /** Drop consecutive near-duplicates: zero-length segments add nothing. */
+  function dedupe(cartesians) {
+    const positions = [];
+    for (const position of Array.isArray(cartesians) ? cartesians : []) {
+      if (!position) continue;
+      const last = positions[positions.length - 1];
+      if (
+        last &&
+        Cesium.Cartesian3.distanceSquared(last, position) <
+          MIN_SEGMENT_DISTANCE_SQ
+      )
+        continue;
+      positions.push(position);
+    }
+    return positions;
+  }
+
+  /** Whether `chunk` holds exactly the same position objects as `seg` from `start`. */
+  function sameRun(chunk, seg, start) {
+    const positions = chunk.positions;
+    if (start + positions.length > seg.length) return false;
+    for (let k = 0; k < positions.length; k++)
+      if (positions[k] !== seg[start + k]) return false;
+    return true;
+  }
+
+  /**
+   * Cut segments into chunks, reusing every frozen chunk whose points are
+   * still drawn in the same order. New chunks end where a reusable one begins,
+   * so dropping the oldest point rebuilds only the first chunk.
+   */
+  function reconcile(segments) {
+    const byStart = new Map();
+    for (const chunk of frozen) byStart.set(chunk.positions[0], chunk);
+    const kept = new Set();
+    const reusable = (seg, j) => {
+      const chunk = byStart.get(seg[j]);
+      return chunk && !kept.has(chunk) && sameRun(chunk, seg, j) ? chunk : null;
+    };
+    const next = [];
+    let nextTail = NO_POSITIONS;
+    segments.forEach((seg, s) => {
+      const newest = s === segments.length - 1;
+      let i = 0;
+      while (i < seg.length - 1) {
+        const existing = reusable(seg, i);
+        if (existing) {
+          kept.add(existing);
+          next.push(existing);
+          i += existing.positions.length - 1;
+          continue;
+        }
+        if (newest && seg.length - i <= CHUNK_POINTS) {
+          nextTail = seg.slice(i);
+          break;
+        }
+        let end = Math.min(seg.length - 1, i + CHUNK_POINTS - 1);
+        for (let j = i + 1; j < end; j++) {
+          if (reusable(seg, j)) {
+            end = j;
+            break;
+          }
+        }
+        const positions = seg.slice(i, end + 1);
+        next.push({
+          positions,
+          entity: addEntity(positions),
+          standIn: true,
+          frames: 0,
+        });
+        i = end;
+      }
+    });
+    for (const chunk of frozen)
+      if (!kept.has(chunk)) removeEntity(chunk.entity);
+    frozen = next;
+    tail = nextTail;
+    syncDynamic();
+    if (frozen.some((chunk) => chunk.standIn)) listenForStandIns();
+    else stopListening();
+  }
+
+  function release() {
+    stopListening();
+    for (const chunk of frozen) removeEntity(chunk.entity);
+    frozen = [];
+    tail = NO_POSITIONS;
+    dynamicRuns = [];
+  }
+
   return {
     /**
-     * Replace the trail geometry with a chronological position list
+     * Replace the trail geometry with one chronological position list
      * (oldest first). Fewer than 2 distinct positions clears the trail.
      * @param {Cesium.Cartesian3[]} cartesians - Positions, oldest -> newest.
      */
     setPositions(cartesians) {
-      if (destroyed || !viewer || viewer.isDestroyed()) return;
-      // Drop consecutive near-duplicates: zero-length segments add nothing.
-      const positions = [];
-      for (const position of Array.isArray(cartesians) ? cartesians : []) {
-        if (!position) continue;
-        const last = positions[positions.length - 1];
-        if (
-          last &&
-          Cesium.Cartesian3.distanceSquared(last, position) <
-            MIN_SEGMENT_DISTANCE_SQ
-        )
-          continue;
-        positions.push(position);
-      }
-      current = positions.length >= 2 ? positions : [];
-      ensureEntity();
+      this.setSegments([cartesians]);
+    },
+
+    /**
+     * Replace the trail geometry with chronological segments (oldest first).
+     * Nothing is drawn between segments. A segment with fewer than 2 distinct
+     * positions draws nothing. Pass the same position objects on every
+     * update: a chunk whose points are unchanged is never rebuilt.
+     * @param {Cesium.Cartesian3[][]} list - Segments, each oldest -> newest.
+     */
+    setSegments(list) {
+      if (!usable()) return;
+      reconcile(
+        (Array.isArray(list) ? list : [])
+          .map(dedupe)
+          .filter((positions) => positions.length >= 2),
+      );
     },
 
     /** Temporarily hide/show the trail without discarding accumulated history. */
     setVisible(nextVisible) {
       visible = nextVisible !== false;
-      if (entity) entity.show = visible;
+      for (const entity of dynamicEntities) entity.show = visible;
+      for (const chunk of frozen) chunk.entity.show = visible;
     },
 
-    /** Empty the trail without removing the entity (cheap re-arm). */
+    /** Empty the trail and release its frozen geometry; dynamic polylines stay for re-arm. */
     clear() {
-      current = [];
+      if (!usable()) return;
+      release();
     },
 
-    /** Remove the trail entity permanently (layer disable/teardown). */
+    /** Remove every trail entity permanently (layer disable/teardown). */
     destroy() {
-      destroyed = true;
-      current = [];
-      if (entity && viewer && !viewer.isDestroyed()) {
-        try {
-          viewer.entities.remove(entity);
-        } catch {
-          /* torn down */
-        }
+      if (usable()) {
+        release();
+        for (const entity of dynamicEntities) removeEntity(entity);
       }
-      entity = null;
+      destroyed = true;
+      frozen = [];
+      tail = NO_POSITIONS;
+      dynamicRuns = [];
+      dynamicEntities.length = 0;
+      stopListening();
+    },
+
+    /** Test seam: frozen chunks (positions, stand-in state) and the dynamic runs. */
+    _chunksForTest() {
+      return {
+        frozen: frozen.map((chunk) => ({
+          positions: chunk.positions,
+          standIn: chunk.standIn,
+          entity: chunk.entity,
+        })),
+        dynamic: dynamicRuns.slice(),
+      };
     },
   };
 }
diff --git a/src/data/trailRenderer.test.mjs b/src/data/trailRenderer.test.mjs
index 83ac45cd0..bcf256db4 100644
--- a/src/data/trailRenderer.test.mjs
+++ b/src/data/trailRenderer.test.mjs
@@ -1,7 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import * as Cesium from 'cesium';
-import { createTrail } from './trailRenderer.js';
+import { CHUNK_POINTS, createTrail } from './trailRenderer.js';
 
 test('trail visibility can change without discarding its accumulated geometry', () => {
   const added = [];
@@ -37,3 +37,253 @@ test('trail visibility can change without discarding its accumulated geometry',
   trail.destroy();
   assert.deepEqual(removed, [added[0]]);
 });
+
+/**
+ * A fake viewer. `ready` holds the frozen-chunk entities whose static
+ * geometry is in the scene; `frame()` runs one post-render pass.
+ */
+function fakeViewer({ scene = true } = {}) {
+  const added = [];
+  const removed = [];
+  const ready = new Set();
+  let listeners = [];
+  const viewer = {
+    added,
+    removed,
+    ready,
+    isDestroyed: () => false,
+    entities: {
+      add(definition) {
+        added.push(definition);
+        return definition;
+      },
+      remove(entity) {
+        removed.push(entity);
+      },
+    },
+    listenerCount: () => listeners.length,
+    frame() {
+      for (const listener of listeners.slice()) listener();
+    },
+  };
+  if (scene) {
+    viewer.scene = {
+      postRender: {
+        addEventListener(listener) {
+          listeners.push(listener);
+          return () => {
+            listeners = listeners.filter((l) => l !== listener);
+          };
+        },
+      },
+    };
+    viewer.dataSourceDisplay = {
+      getBoundingSphere: (entity) =>
+        ready.has(entity)
+          ? Cesium.BoundingSphereState.DONE
+          : Cesium.BoundingSphereState.PENDING,
+    };
+  }
+  return viewer;
+}
+
+const valueOf = (positions) =>
+  typeof positions?.getValue === 'function' ? positions.getValue() : positions;
+
+/** Every line the scene can draw now: live entities with two or more points. */
+function drawnRuns(viewer) {
+  return viewer.added
+    .filter((entity) => !viewer.removed.includes(entity))
+    .map((entity) => valueOf(entity.polyline.positions))
+    .filter((positions) => positions.length >= 2);
+}
+
+/** Distinct position objects across all drawn lines. */
+function drawnPoints(viewer) {
+  return new Set(drawnRuns(viewer).flat());
+}
+
+function line(count, offset = 0) {
+  return Array.from(
+    { length: count },
+    (_, i) => new Cesium.Cartesian3(6_378_137 + offset, i * 1000, 0),
+  );
+}
+
+test('a trail with breaks draws each segment and nothing between them', () => {
+  const viewer = fakeViewer({ scene: false });
+  const trail = createTrail(viewer, { color: '#ffffff' });
+  const first = line(2, 0);
+  const lone = line(1, 50_000);
+  const second = line(3, 100_000);
+
+  trail.setSegments([first, lone, second]);
+  assert.deepEqual(
+    drawnRuns(viewer).sort((a, b) => a[0].x - b[0].x),
+    [first, second],
+  );
+  for (const entity of viewer.added) {
+    assert.match(String(entity.id), /^gev-trail:/);
+    assert.equal(entity.polyline.width, 2.5);
+  }
+
+  // The first segment is gone later: its geometry is released.
+  trail.setSegments([second]);
+  assert.deepEqual(drawnRuns(viewer), [second]);
+
+  trail.setVisible(false);
+  assert.ok(
+    viewer.added
+      .filter((entity) => !viewer.removed.includes(entity))
+      .every((entity) => entity.show === false),
+  );
+  trail.destroy();
+  assert.equal(new Set(viewer.removed).size, viewer.added.length);
+});
+
+test('chunks share their boundary points and only the newest chunk is dynamic', () => {
+  const viewer = fakeViewer({ scene: false });
+  const trail = createTrail(viewer, { color: '#ffffff' });
+  const points = line(300);
+  trail.setPositions(points);
+  const { frozen, dynamic } = trail._chunksForTest();
+  assert.deepEqual(
+    frozen.map((chunk) => chunk.positions.length),
+    [CHUNK_POINTS, CHUNK_POINTS],
+  );
+  assert.equal(frozen[0].positions.at(-1), frozen[1].positions[0]);
+  assert.equal(dynamic.length, 1);
+  assert.equal(frozen[1].positions.at(-1), dynamic[0][0]);
+  assert.equal(dynamic[0].at(-1), points.at(-1));
+  assert.equal(drawnPoints(viewer).size, points.length);
+  // A frozen chunk is constant geometry, not a per-frame callback.
+  for (const chunk of frozen)
+    assert.ok(Array.isArray(chunk.entity.polyline.positions));
+});
+
+test('freezing a chunk keeps every point drawn, and the dynamic copy goes only once the static geometry is in', () => {
+  const viewer = fakeViewer();
+  const trail = createTrail(viewer, { color: '#ffffff' });
+  const points = line(CHUNK_POINTS + 20);
+  for (let n = 2; n <= points.length; n++) {
+    trail.setPositions(points.slice(0, n));
+    assert.equal(drawnPoints(viewer).size, n, `points drawn at ${n}`);
+  }
+  const { frozen } = trail._chunksForTest();
+  assert.equal(frozen.length, 1);
+  // Not in the scene yet: the chunk is still drawn by a dynamic polyline.
+  viewer.frame();
+  assert.equal(trail._chunksForTest().frozen[0].standIn, true);
+  assert.ok(
+    trail._chunksForTest().dynamic.includes(frozen[0].positions),
+    'the dynamic copy stays until the static geometry is ready',
+  );
+  viewer.ready.add(frozen[0].entity);
+  viewer.frame();
+  const after = trail._chunksForTest();
+  assert.equal(after.frozen[0].standIn, false);
+  assert.ok(!after.dynamic.includes(frozen[0].positions));
+  assert.equal(after.dynamic.length, 1);
+  assert.equal(viewer.listenerCount(), 0, 'no listener once nothing waits');
+  // The frozen entity is the same object: freezing built it once.
+  assert.equal(after.frozen[0].entity, frozen[0].entity);
+});
+
+test('a hidden trail keeps its dynamic copy until it is shown and the static geometry is in', () => {
+  const viewer = fakeViewer();
+  const trail = createTrail(viewer, { color: '#ffffff' });
+  trail.setVisible(false);
+  trail.setPositions(line(CHUNK_POINTS + 5));
+  const [chunk] = trail._chunksForTest().frozen;
+  viewer.ready.add(chunk.entity);
+  viewer.frame();
+  assert.equal(trail._chunksForTest().frozen[0].standIn, true);
+  trail.setVisible(true);
+  viewer.frame();
+  assert.equal(trail._chunksForTest().frozen[0].standIn, false);
+});
+
+test('dropping the oldest point rebuilds only the first chunk', () => {
+  const viewer = fakeViewer({ scene: false });
+  const trail = createTrail(viewer, { color: '#ffffff' });
+  const points = line(400);
+  trail.setPositions(points);
+  const before = trail._chunksForTest().frozen;
+  trail.setPositions(points.slice(1));
+  const after = trail._chunksForTest().frozen;
+  assert.equal(after.length, before.length);
+  assert.notEqual(after[0].entity, before[0].entity);
+  assert.ok(viewer.removed.includes(before[0].entity));
+  for (let k = 1; k < before.length; k++)
+    assert.equal(after[k].entity, before[k].entity);
+  assert.equal(after[0].positions.at(-1), after[1].positions[0]);
+  assert.equal(drawnPoints(viewer).size, 399);
+});
+
+test('a backfill prepended ahead of frozen chunks keeps them and joins at a shared point', () => {
+  const viewer = fakeViewer({ scene: false });
+  const trail = createTrail(viewer, { color: '#ffffff' });
+  const live = line(300, 0);
+  trail.setPositions(live);
+  const before = trail._chunksForTest().frozen;
+  // History older than every live point, joined as one path.
+  const history = Array.from(
+    { length: 200 },
+    (_, i) => new Cesium.Cartesian3(6_378_137, -(200 - i) * 1000, 0),
+  );
+  trail.setPositions(history.concat(live));
+  const after = trail._chunksForTest().frozen;
+  for (const chunk of before)
+    assert.ok(after.some((c) => c.entity === chunk.entity));
+  for (let k = 0; k + 1 < after.length; k++)
+    assert.equal(after[k].positions.at(-1), after[k + 1].positions[0]);
+  assert.equal(drawnPoints(viewer).size, 500);
+
+  // A backfill that breaks from the live trail is its own segment.
+  trail.setSegments([history, live]);
+  assert.equal(drawnPoints(viewer).size, 500);
+  const runs = drawnRuns(viewer);
+  assert.ok(
+    !runs.some((run) => run.includes(history.at(-1)) && run.includes(live[0])),
+    'no line across the break',
+  );
+});
+
+test('clearing and re-tracking release every frozen chunk', () => {
+  const viewer = fakeViewer();
+  const trail = createTrail(viewer, { color: '#ffffff' });
+  trail.setPositions(line(600));
+  const frozen = trail._chunksForTest().frozen.map((chunk) => chunk.entity);
+  assert.ok(frozen.length >= 4);
+  assert.equal(viewer.listenerCount(), 1);
+  trail.clear();
+  for (const entity of frozen) assert.ok(viewer.removed.includes(entity));
+  assert.equal(viewer.listenerCount(), 0);
+  assert.equal(drawnRuns(viewer).length, 0);
+
+  // Another aircraft: nothing of the first one survives.
+  const other = line(200, 900_000);
+  trail.setPositions(other);
+  assert.equal(drawnPoints(viewer).size, 200);
+  trail.destroy();
+  assert.equal(new Set(viewer.removed).size, viewer.added.length);
+  assert.equal(viewer.listenerCount(), 0);
+});
+
+test('replacing the newest point and removing points inside the trail draws exactly the new trail', () => {
+  const viewer = fakeViewer({ scene: false });
+  const trail = createTrail(viewer, { color: '#ffffff' });
+  const points = line(400);
+  trail.setPositions(points.slice());
+  // A recorded point replaces the newest one; a spur point inside a frozen
+  // chunk and one at a chunk boundary go.
+  points[points.length - 1] = new Cesium.Cartesian3(6_378_137, 399_500, 10);
+  points.splice(200, 1);
+  points.splice(CHUNK_POINTS - 1, 1);
+  trail.setPositions(points.slice());
+  assert.deepEqual(drawnPoints(viewer), new Set(points));
+  // Every drawn line runs through consecutive trail points only.
+  const next = new Map(points.slice(0, -1).map((p, i) => [p, points[i + 1]]));
+  for (const run of drawnRuns(viewer))
+    for (let i = 1; i < run.length; i++) assert.equal(next.get(run[i - 1]), run[i]);
+});
diff --git a/src/data/trailReports.test.mjs b/src/data/trailReports.test.mjs
new file mode 100644
index 000000000..106c6f25a
--- /dev/null
+++ b/src/data/trailReports.test.mjs
@@ -0,0 +1,165 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import {
+  insertTrailFix,
+  recordTrailPoint,
+  trailBodySegments,
+  trailPairBreaks,
+  trailDistanceM,
+  trailRecordingBlocked,
+} from './trailContinuity.js';
+
+// Reports decide where the line may run: recorded points never join two
+// reports too far apart to be one flight, a report the display has already
+// passed replaces the guess drawn after it, and old entries let go of the
+// positions they stood for.
+
+const SEC = 1000;
+const LIMIT = 2_000;
+const enu = Cesium.Transforms.eastNorthUpToFixedFrame(
+  Cesium.Cartesian3.fromDegrees(-100, 40, 0),
+);
+const at = (e, n, u = 10) =>
+  Cesium.Matrix4.multiplyByPoint(
+    enu,
+    new Cesium.Cartesian3(e, n, u),
+    new Cesium.Cartesian3(),
+  );
+
+/** No two neighbours in one drawn segment are too far apart to be one flight. */
+function assertNoBrokenJoin(fixes) {
+  const reports = fixes.filter((fix) => !fix.drawn && fix.position);
+  for (const segment of trailBodySegments(fixes, fixes.length)) {
+    const inSegment = reports.filter((r) =>
+      segment.some((p) => Cesium.Cartesian3.distance(p, r.position) < 0.01),
+    );
+    for (let i = 1; i < inSegment.length; i++)
+      assert.equal(
+        trailPairBreaks(
+          inSegment[i].timeMs - inSegment[i - 1].timeMs,
+          trailDistanceM(inSegment[i - 1].position, inSegment[i].position),
+        ),
+        false,
+        `one segment joins reports at ${inSegment[i - 1].timeMs / SEC} s and ${
+          inSegment[i].timeMs / SEC
+        } s`,
+      );
+  }
+}
+
+test('two reports 60 s and 51 km apart are not joined, even by recorded points', () => {
+  const A = Cesium.Cartesian3.fromDegrees(-100, 40, 9_000);
+  const B = Cesium.Cartesian3.fromDegrees(-99.4, 40, 9_000);
+  const fixes = [];
+  insertTrailFix(fixes, A, 0, LIMIT);
+  insertTrailFix(fixes, B, 60 * SEC, LIMIT); // ahead of the display
+  for (let t = 1; t < 60; t++) {
+    // Nothing is recorded across the pair.
+    assert.equal(trailRecordingBlocked(fixes, t * SEC), true);
+  }
+  assert.equal(trailBodySegments(fixes, fixes.length).length, 2);
+  // Points recorded before the far report was known are dropped.
+  const late = [];
+  insertTrailFix(late, A, 0, LIMIT);
+  for (let t = 1; t < 60; t++)
+    recordTrailPoint(
+      late,
+      Cesium.Cartesian3.lerp(A, B, t / 60, new Cesium.Cartesian3()),
+      t * SEC,
+      LIMIT,
+    );
+  insertTrailFix(late, B, 60 * SEC, LIMIT);
+  assert.equal(late.filter((fix) => fix.drawn).length, 0);
+  assert.equal(trailBodySegments(late, late.length).length, 2);
+  assertNoBrokenJoin(late);
+});
+
+test('a coast, a hold and then a far report: nothing is drawn across', () => {
+  const A = at(0, 0, 9_000);
+  const fixes = [];
+  insertTrailFix(fixes, A, 0, LIMIT);
+  // The icon coasts east for 90 s at 230 m/s, then holds.
+  for (let t = 1; t <= 200; t++)
+    recordTrailPoint(
+      fixes,
+      at(230 * Math.min(t, 90), 0, 9_000),
+      t * SEC,
+      LIMIT,
+    );
+  assert.ok(fixes.filter((fix) => fix.drawn).length > 0);
+  // The next report is 150 km away two minutes later: over 1,500 kt.
+  const B = at(0, 150_000, 9_000);
+  insertTrailFix(fixes, B, 120 * SEC, LIMIT);
+  assertNoBrokenJoin(fixes);
+  const segments = trailBodySegments(fixes, fixes.length);
+  const segmentOf = (p) =>
+    segments.findIndex((s) =>
+      s.some((q) => Cesium.Cartesian3.distance(p, q) < 0.01),
+    );
+  assert.notEqual(segmentOf(A), segmentOf(B));
+  // No recorded point between the two reports remains.
+  assert.equal(
+    fixes.filter((fix) => fix.drawn && fix.timeMs < 120 * SEC).length,
+    0,
+  );
+});
+
+for (const off of [200, 400, 600, 1_000]) {
+  test(`a report the display already passed, ${off} m off a 2 km turn, leaves no spike`, () => {
+    const R = 2_000;
+    const w = 100 / R;
+    const pos = (t, r = R) =>
+      at(r * Math.sin(w * t), R - r * Math.cos(w * t), 3_000);
+    const fixes = [];
+    insertTrailFix(fixes, pos(0), 0, LIMIT);
+    for (let t = 1; t <= 60; t++)
+      recordTrailPoint(fixes, pos(t), t * SEC, LIMIT);
+    const report = pos(50, R - off);
+    // It arrives with the display at 60 s; the ease takes 900 ms.
+    insertTrailFix(fixes, report, 50 * SEC, LIMIT, {
+      displayMs: 60 * SEC,
+      settleMs: 900,
+    });
+    // The guess drawn after the report is gone...
+    assert.deepEqual(
+      fixes.filter((fix) => fix.drawn && fix.timeMs > 50 * SEC),
+      [],
+    );
+    // ...nothing is recorded while the icon eases onto the correction...
+    assert.equal(trailRecordingBlocked(fixes, 60.5 * SEC), true);
+    assert.equal(trailRecordingBlocked(fixes, 61 * SEC), false);
+    // ...and the line reads arc, report, corrected path.
+    for (let t = 61; t <= 70; t++)
+      recordTrailPoint(fixes, pos(t, R - off), t * SEC, LIMIT);
+    const line = trailBodySegments(fixes, fixes.length).flat();
+    const r = line.findIndex(
+      (p) => Cesium.Cartesian3.distance(p, report) < 0.01,
+    );
+    assert.ok(r > 0);
+    for (const p of line.slice(0, r))
+      assert.ok(
+        Math.abs(Cesium.Cartesian3.distance(p, at(0, R, 3_000)) - R) < 31,
+        'a point before the report is off the arc',
+      );
+    for (const p of line.slice(r + 1))
+      assert.ok(
+        Math.abs(Cesium.Cartesian3.distance(p, at(0, R, 3_000)) - (R - off)) <
+          31,
+        'a point after the report is off the corrected path',
+      );
+  });
+}
+
+test('entries behind the report before the display let go of the positions they stood for', () => {
+  const fixes = [];
+  for (let s = 0; s <= 2 * 3_600; s++) {
+    const p = at(230 * s, 0, 10_000);
+    if (s % 15 === 0) insertTrailFix(fixes, p, s * SEC, LIMIT);
+    else recordTrailPoint(fixes, p, s * SEC, LIMIT);
+  }
+  let held = 0;
+  for (const fix of fixes) held += fix.absorbed?.length ?? 0;
+  // Only the newest stretch, up to two reports back, keeps what it stood for.
+  assert.ok(held <= 30, `${held} positions still held`);
+});
diff --git a/src/data/trailThinning.test.mjs b/src/data/trailThinning.test.mjs
new file mode 100644
index 000000000..df0785559
--- /dev/null
+++ b/src/data/trailThinning.test.mjs
@@ -0,0 +1,180 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import {
+  insertTrailFix,
+  joinTrailBackfill,
+  recordTrailPoint,
+  TRAIL_THIN_MAX_SPAN_M,
+  TRAIL_THIN_TOLERANCE_M,
+} from './trailContinuity.js';
+
+// Recorded points are thinned by shape: a point stays only where the line
+// would move without it. Reports always stay.
+
+const SEC = 1000;
+const LIMIT = 2_000;
+const LAT0 = 40;
+const LON0 = -100;
+const M_PER_DEG_LAT = 111_320;
+const mPerDegLon = (lat) => M_PER_DEG_LAT * Math.cos((lat * Math.PI) / 180);
+
+/** Straight and level east at `speed` m/s, `tSec` after the start. */
+const eastbound = (speed, tSec, heightM = 10_000) =>
+  Cesium.Cartesian3.fromDegrees(
+    LON0 + (speed * tSec) / mPerDegLon(LAT0),
+    LAT0,
+    heightM,
+  );
+
+/** A standard-rate (3°/s) left turn from north, radius v / ω, `tSec` in. */
+function turning(speed, tSec, heightM = 10_000) {
+  const omega = (3 * Math.PI) / 180;
+  const radius = speed / omega;
+  // Centre west of the start; heading north, turning left (towards west).
+  const angle = omega * tSec;
+  const east = -radius + radius * Math.cos(angle);
+  const north = radius * Math.sin(angle);
+  return Cesium.Cartesian3.fromDegrees(
+    LON0 + east / mPerDegLon(LAT0),
+    LAT0 + north / M_PER_DEG_LAT,
+    heightM,
+  );
+}
+
+/** Distance from p to the nearest point of a polyline. */
+function distanceToPath(p, path) {
+  let best = Infinity;
+  const ab = new Cesium.Cartesian3();
+  const ap = new Cesium.Cartesian3();
+  const closest = new Cesium.Cartesian3();
+  for (let i = 1; i < path.length; i++) {
+    Cesium.Cartesian3.subtract(path[i], path[i - 1], ab);
+    Cesium.Cartesian3.subtract(p, path[i - 1], ap);
+    const len2 = Cesium.Cartesian3.magnitudeSquared(ab);
+    const t =
+      len2 > 0
+        ? Math.max(0, Math.min(1, Cesium.Cartesian3.dot(ap, ab) / len2))
+        : 0;
+    Cesium.Cartesian3.add(
+      path[i - 1],
+      Cesium.Cartesian3.multiplyByScalar(ab, t, closest),
+      closest,
+    );
+    best = Math.min(best, Cesium.Cartesian3.distance(p, closest));
+  }
+  return best;
+}
+
+const drawnCount = (fixes) => fixes.filter((fix) => fix.drawn).length;
+
+test('one hour straight and level with a report every 15 s adds under 60 recorded points', () => {
+  const speed = 230;
+  const fixes = [];
+  for (const t of [0, 15, 30])
+    insertTrailFix(fixes, eastbound(speed, t), t * SEC, LIMIT);
+  // Live order: a report arrives 30 s before the display reaches it, and the
+  // drawn icon is recorded once a second.
+  for (let t = 1; t <= 3_600; t++) {
+    const reportAt = t + 30;
+    if (reportAt % 15 === 0 && reportAt <= 3_600)
+      insertTrailFix(fixes, eastbound(speed, reportAt), reportAt * SEC, LIMIT);
+    recordTrailPoint(fixes, eastbound(speed, t), t * SEC, LIMIT);
+  }
+  assert.ok(
+    drawnCount(fixes) < 60,
+    `${drawnCount(fixes)} recorded points kept`,
+  );
+  assert.equal(fixes.filter((fix) => !fix.drawn).length, 241);
+});
+
+test('with no report at all, a straight leg keeps one point per 10 km and no more', () => {
+  const speed = 230;
+  const fixes = [];
+  insertTrailFix(fixes, eastbound(speed, 0), 0, LIMIT);
+  for (let t = 1; t <= 3_600; t++)
+    recordTrailPoint(fixes, eastbound(speed, t), t * SEC, LIMIT);
+  const legKm = (speed * 3_600) / 1_000;
+  assert.equal(TRAIL_THIN_MAX_SPAN_M, 10_000);
+  assert.ok(
+    drawnCount(fixes) <= Math.ceil(legKm / 10) + 1,
+    `${drawnCount(fixes)} points over ${legKm} km`,
+  );
+  for (let i = 1; i < fixes.length; i++)
+    assert.ok(
+      Cesium.Cartesian3.distance(fixes[i - 1].position, fixes[i].position) <=
+        TRAIL_THIN_MAX_SPAN_M + speed,
+    );
+});
+
+test('a standard-rate 180° turn keeps its curve: every recorded position stays within 30 m of the kept line', () => {
+  const speed = 230;
+  const fixes = [];
+  const recorded = [];
+  insertTrailFix(fixes, turning(speed, 0), 0, LIMIT);
+  for (let t = 1; t <= 60; t++) {
+    const position = turning(speed, t);
+    recorded.push(position);
+    recordTrailPoint(fixes, position, t * SEC, LIMIT);
+  }
+  const line = fixes.map((fix) => fix.position);
+  assert.equal(TRAIL_THIN_TOLERANCE_M, 30);
+  for (const position of recorded) {
+    const off = distanceToPath(position, line);
+    assert.ok(off <= TRAIL_THIN_TOLERANCE_M + 1, `${off.toFixed(1)} m off`);
+  }
+  assert.ok(drawnCount(fixes) < recorded.length, 'nothing was thinned');
+  assert.ok(drawnCount(fixes) >= 6, 'the curve was flattened');
+});
+
+test('a climb off the straight line keeps its vertices', () => {
+  const fixes = [];
+  insertTrailFix(fixes, eastbound(200, 0, 1_000), 0, LIMIT);
+  // 30 s level, then a 60 s climb of 20 m/s, then level again.
+  const height = (t) => 1_000 + 20 * Math.min(60, Math.max(0, t - 30));
+  const recorded = [];
+  for (let t = 1; t <= 150; t++) {
+    const position = eastbound(200, t, height(t));
+    recorded.push(position);
+    recordTrailPoint(fixes, position, t * SEC, LIMIT);
+  }
+  const line = fixes.map((fix) => fix.position);
+  for (const position of recorded)
+    assert.ok(distanceToPath(position, line) <= TRAIL_THIN_TOLERANCE_M + 1);
+});
+
+test('at the limit, old recorded points go before any report from the backfill', () => {
+  const max = 300;
+  const backfill = [];
+  for (let i = 0; i < 100; i++)
+    backfill.push({
+      position: eastbound(200, i * 60 - 20_000),
+      timeMs: (i * 60 - 20_000) * SEC,
+      nullAltitude: false,
+    });
+  let fixes = [];
+  insertTrailFix(fixes, turning(150, 0), 0, max);
+  // A long series of turns keeps many recorded points.
+  for (let t = 1; t <= 2_000; t++)
+    recordTrailPoint(fixes, turning(150, t), t * SEC, max);
+  assert.ok(drawnCount(fixes) > 150);
+  fixes = joinTrailBackfill(
+    {
+      fixes: backfill.map((b) => ({ ...b, breakBefore: false })),
+      breakAfter: false,
+    },
+    fixes,
+    max,
+  );
+  assert.ok(fixes.length <= max);
+  const reports = fixes.filter((fix) => !fix.drawn);
+  assert.equal(reports.length, 101, 'a report was dropped');
+  // More recording at the limit drops recorded points, never reports.
+  for (let t = 2_001; t <= 2_400; t++)
+    recordTrailPoint(fixes, turning(150, t), t * SEC, max);
+  assert.ok(fixes.length <= max);
+  assert.equal(fixes.filter((fix) => !fix.drawn).length, 101);
+  // The recorded points that remain are the newest.
+  const drawnTimes = fixes.filter((fix) => fix.drawn).map((fix) => fix.timeMs);
+  assert.ok(Math.min(...drawnTimes) > 1_000 * SEC);
+});
diff --git a/src/i18n/locales/ar.json b/src/i18n/locales/ar.json
index 20315a871..4445dd12b 100644
--- a/src/i18n/locales/ar.json
+++ b/src/i18n/locales/ar.json
@@ -615,6 +615,7 @@
   "LOADING": "جارٍ التحميل",
   "DEGRADED": "متدهور",
   "STALE": "متقادم",
+  "SIGNAL LOST · {time}": "انقطعت الإشارة · {time}",
   "FALLBACK": "بديل",
   "PARTIAL": "جزئي",
   "UNCERTAIN": "غير مؤكد",
diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json
index d4fbdf244..f85338ce9 100644
--- a/src/i18n/locales/de.json
+++ b/src/i18n/locales/de.json
@@ -72,6 +72,7 @@
   "LOADING": "LÄDT",
   "DEGRADED": "EINGESCHRÄNKT",
   "STALE": "VERALTET",
+  "SIGNAL LOST · {time}": "SIGNAL VERLOREN · {time}",
   "PARTIAL": "TEILWEISE",
   "FALLBACK": "FALLBACK",
   "SUMMARY": "ÜBERSICHT",
diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json
index e5d4d0689..cae5cb9f2 100644
--- a/src/i18n/locales/es.json
+++ b/src/i18n/locales/es.json
@@ -500,6 +500,7 @@
   "LOADING": "CARGANDO",
   "DEGRADED": "DEGRADADO",
   "STALE": "DESACTUALIZADO",
+  "SIGNAL LOST · {time}": "SEÑAL PERDIDA · {time}",
   "FALLBACK": "RESPALDO",
   "PARTIAL": "PARCIAL",
   "UNCERTAIN": "INCIERTO",
diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json
index b3857c8a6..468abca63 100644
--- a/src/i18n/locales/fr.json
+++ b/src/i18n/locales/fr.json
@@ -329,6 +329,7 @@
   "LOADING": "CHARGEMENT",
   "DEGRADED": "DÉGRADÉ",
   "STALE": "OBSOLÈTE",
+  "SIGNAL LOST · {time}": "SIGNAL PERDU · {time}",
   "PARTIAL": "PARTIEL",
   "FALLBACK": "SECOURS",
   "view band|STREET": "RUE",
diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json
index 2960c4912..a4e0408dd 100644
--- a/src/i18n/locales/he.json
+++ b/src/i18n/locales/he.json
@@ -328,6 +328,7 @@
   "LOADING": "טוען",
   "DEGRADED": "מופחת",
   "STALE": "מיושן",
+  "SIGNAL LOST · {time}": "האות אבד · {time}",
   "PARTIAL": "חלקי",
   "FALLBACK": "חלופה",
   "view band|STREET": "רחוב",
diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json
index 227296b93..72cd1d3d7 100644
--- a/src/i18n/locales/it.json
+++ b/src/i18n/locales/it.json
@@ -329,6 +329,7 @@
   "LOADING": "CARICAMENTO",
   "DEGRADED": "DEGRADATO",
   "STALE": "OBSOLETO",
+  "SIGNAL LOST · {time}": "SEGNALE PERSO · {time}",
   "PARTIAL": "PARZIALE",
   "FALLBACK": "RISERVA",
   "view band|STREET": "STRADA",
diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json
index 650869d13..6b1adab73 100644
--- a/src/i18n/locales/ja.json
+++ b/src/i18n/locales/ja.json
@@ -323,6 +323,7 @@
   "LOADING": "読込中",
   "DEGRADED": "性能低下",
   "STALE": "更新遅延",
+  "SIGNAL LOST · {time}": "信号途絶 · {time}",
   "PARTIAL": "部分的",
   "FALLBACK": "フォールバック",
   "view band|STREET": "街路",
diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json
index 8545f38e8..1c44dcaef 100644
--- a/src/i18n/locales/pt.json
+++ b/src/i18n/locales/pt.json
@@ -329,6 +329,7 @@
   "LOADING": "CARREGANDO",
   "DEGRADED": "DEGRADADO",
   "STALE": "DESATUALIZADO",
+  "SIGNAL LOST · {time}": "SINAL PERDIDO · {time}",
   "PARTIAL": "PARCIAL",
   "FALLBACK": "ALTERNATIVO",
   "view band|STREET": "RUA",
diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json
index 4b3d2c9f5..1bbef50be 100644
--- a/src/i18n/locales/ru.json
+++ b/src/i18n/locales/ru.json
@@ -143,6 +143,7 @@
   "{count}h ago": "{count} ч назад",
   "STALE · cached {age}": "УСТАРЕЛ · кэш {age}",
   "STALE": "УСТАРЕЛ",
+  "SIGNAL LOST · {time}": "СИГНАЛ ПОТЕРЯН · {time}",
   "refreshing...": "обновление...",
   "loading...": "загрузка...",
   "KEY REQUIRED": "ТРЕБУЕТСЯ КЛЮЧ",
diff --git a/src/i18n/locales/uk.json b/src/i18n/locales/uk.json
index e5a26fd14..6cc56bcf5 100644
--- a/src/i18n/locales/uk.json
+++ b/src/i18n/locales/uk.json
@@ -332,6 +332,7 @@
   "LOADING": "ЗАВАНТАЖЕННЯ",
   "DEGRADED": "ПЕРЕБОЇ",
   "STALE": "ЗАСТАРІЛО",
+  "SIGNAL LOST · {time}": "СИГНАЛ ВТРАЧЕНО · {time}",
   "PARTIAL": "ЧАСТКОВО",
   "FALLBACK": "РЕЗЕРВ",
   "view band|STREET": "ВУЛИЦЯ",
diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json
index 707891bc2..247c9e782 100644
--- a/src/i18n/locales/zh-CN.json
+++ b/src/i18n/locales/zh-CN.json
@@ -323,6 +323,7 @@
   "LOADING": "加载中",
   "DEGRADED": "降级",
   "STALE": "过期",
+  "SIGNAL LOST · {time}": "信号丢失 · {time}",
   "PARTIAL": "部分",
   "FALLBACK": "备用",
   "view band|STREET": "街道",
diff --git a/src/i18n/locales/zh-Hant.json b/src/i18n/locales/zh-Hant.json
index 5deb177ed..a98f994b8 100644
--- a/src/i18n/locales/zh-Hant.json
+++ b/src/i18n/locales/zh-Hant.json
@@ -323,6 +323,7 @@
   "LOADING": "加載中",
   "DEGRADED": "降級",
   "STALE": "過期",
+  "SIGNAL LOST · {time}": "訊號遺失 · {time}",
   "PARTIAL": "部分",
   "FALLBACK": "備用",
   "view band|STREET": "街道",
diff --git a/src/layers/flights/motion.js b/src/layers/flights/motion.js
index c09522153..ecfb26d7f 100644
--- a/src/layers/flights/motion.js
+++ b/src/layers/flights/motion.js
@@ -5,11 +5,15 @@ import {
   lerpAngleDeg,
   speedRamp,
   courseBetweenCartesians,
+  floorCoastedPosition,
   staleCoastLimitSeconds,
+  staleCoastSecondsFrom,
+  staleHoldsForFix,
   arcOffsetEnu,
   courseSlewCapDps,
   limitCourseStep,
   corridorPathLatLon,
+  COAST_MAX_SPEED_MPS,
 } from '../../data/motionModel.js';
 import { CLASS_SCALE_2D } from '../../data/aircraftClass.js';
 import {
@@ -248,30 +252,88 @@ export function createMotion({
       );
     }
 
-    // Newest POSITION is older than renderTime. OpenSky can still be receiving
-    // fresh contact/kinematic messages for that aircraft; freezing at a hard
-    // 60 s-after-position boundary produced the visible stop → catch-up → stop
-    // cadence. Coast through the latest real contact plus a bounded grace
-    // window, with an absolute cap so a stale cached feed cannot drift forever.
+    // Newest POSITION is older than renderTime. Coast on the last speed and
+    // heading for five minutes past it, then stop, dimmed as SIGNAL LOST.
+    // A contact last heard on or near the ground holds there instead, and a
+    // coast never goes below the ground.
+    const { coastSec } = _coastPlan(newest, info, elapsedSec);
+    _extrapolateFix(
+      newest,
+      info,
+      coastSec,
+      out,
+      (info && info.turnRateDps) || 0,
+    );
+    return coastSec > 0 ? floorCoastedPosition(out, cachedGroundFloor) : out;
+  }
+
+  /**
+   * How far a contact coasts past its newest fix at a display time
+   * `elapsedSec` after it: up to five minutes, or not at all for a contact
+   * that holds at a report on or near the ground. The hold decision is made once
+   * per report and kept on it.
+   * @param {{epochMs?: number, time: Cesium.JulianDate}} newest
+   * @param {object|undefined} info - The contact's record.
+   * @param {number} elapsedSec
+   * @returns {{coastSec: number, holds: boolean}}
+   */
+  function _coastPlan(newest, info, elapsedSec) {
     const coastLimitSec = staleCoastLimitSeconds({
       // `epochMs` is captured once when the poll is normalized. Avoid allocating
-      // a Date per aircraft on every 12 Hz fleet tick.
+      // a Date per aircraft on every fleet tick.
       fixEpochMs: Number.isFinite(newest.epochMs)
         ? newest.epochMs
         : Cesium.JulianDate.toDate(newest.time).getTime(),
       lastContactEpochMs: info?.lastContactEpochMs,
-      // Permit one minute of contact grace but cap any cached-feed drift at
-      // five minutes. Source backoff is exposed separately as a STALE cue.
-      minimumSec: 60,
+      // A plane that stops reporting keeps flying for five minutes, whatever
+      // its contact time, then stops dimmed as SIGNAL LOST. A missed update
+      // shows STALE throughout.
+      minimumSec: 300,
       maximumSec: 300,
     });
-    return _extrapolateFix(
+    const holds = staleHoldsForFix(newest, {
+      onGround: info?.onGround,
+      cachedGroundFloor,
+    });
+    return {
+      coastSec: staleCoastSecondsFrom({
+        newest,
+        elapsedSec,
+        coastLimitSec,
+        holds,
+      }),
+      holds,
+    };
+  }
+
+  /**
+   * Whether a contact has stopped where its coast ended (or held at its last
+   * report) with no newer report, and since when it has had none.
+   * @param {string} icao24
+   * @returns {{reportEpochMs: number, holds: boolean}|null} Null while a
+   *   report is ahead of the display time or the contact is still coasting.
+   */
+  function _signalLost(icao24) {
+    const newest = flightState._positionHistory.get(icao24)?.at(-1);
+    if (!newest) return null;
+    const newestMs = Number.isFinite(newest.epochMs)
+      ? newest.epochMs
+      : Cesium.JulianDate.toDate(newest.time).getTime();
+    const elapsedSec =
+      (flightState.now() - RENDER_DELAY_SEC * 1000 - newestMs) / 1000;
+    if (!(elapsedSec > 0)) return null;
+    const { coastSec, holds } = _coastPlan(
       newest,
-      info,
-      Math.min(elapsedSec, coastLimitSec),
-      out,
-      (info && info.turnRateDps) || 0,
+      flightState.records.data.get(icao24),
+      elapsedSec,
     );
+    if (!(elapsedSec > coastSec)) return null;
+    return {
+      reportEpochMs: Number.isFinite(newest.reportEpochMs)
+        ? newest.reportEpochMs
+        : newestMs,
+      holds,
+    };
   }
 
   /**
@@ -286,9 +348,12 @@ export function createMotion({
    */
 
   function _extrapolateFix(fix, info, dt, out, turnRateDps = 0) {
-    const speed = Number.isFinite(fix.velocity)
-      ? fix.velocity
-      : (info && info.velocity) || 0;
+    const speed = Math.min(
+      Number.isFinite(fix.velocity)
+        ? fix.velocity
+        : (info && info.velocity) || 0,
+      COAST_MAX_SPEED_MPS,
+    );
     const heading = Number.isFinite(fix.track)
       ? fix.track
       : (info && info.true_track) || 0;
@@ -1131,6 +1196,7 @@ export function createMotion({
   return {
     _refloorStaleGroundedContacts,
     _deadReckon,
+    _signalLost,
     _extrapolateFix,
     _isTrackWarmingUp,
     _trackedFocusSizePx,
diff --git a/src/layers/flights/policy.js b/src/layers/flights/policy.js
index de44b806a..2e450d6d5 100644
--- a/src/layers/flights/policy.js
+++ b/src/layers/flights/policy.js
@@ -132,7 +132,7 @@ export const TRAIL_COLOR = '#00d4ff';
 
 /** @constant {number} Combined cap on trail vertices (backfill + live accumulation). */
 
-export const TRAIL_MAX_POINTS = 400;
+export const TRAIL_MAX_POINTS = 2000;
 
 // ---------------------------------------------------------------------------
 // Render-behind smoothing (PRD WS-C C2 — approved product decision):
@@ -471,3 +471,6 @@ export const FLOOR_SEED_GRACE_MS = 90_000;
  *  reloads synchronously. */
 
 export const IR_RELOAD_BATCH = 40;
+
+/** Alpha of a contact that has missed an update or lost its signal: the stale fade, for the fleet and the tracked aircraft alike. */
+export const STALE_ALPHA = 0.45;
diff --git a/src/layers/flights/recordPolicy.js b/src/layers/flights/recordPolicy.js
index e269639d0..7ce36d302 100644
--- a/src/layers/flights/recordPolicy.js
+++ b/src/layers/flights/recordPolicy.js
@@ -9,6 +9,10 @@ export const LANDED_MISSING_POLL_LIMIT = 1;
 
 export const MISSING_POLL_LIMIT = 3;
 
+/** The tracked contact is kept this long after its newest fix: five minutes
+ *  coasting, then five stopped as SIGNAL LOST. */
+export const TRACKED_RETENTION_MS = 10 * 60_000;
+
 /** Cooldown in milliseconds after a transient source error. */
 export const ERROR_BACKOFF_INTERVAL = 20000;
 
diff --git a/src/layers/flights/records.js b/src/layers/flights/records.js
index fdd2d67c8..2636ed47a 100644
--- a/src/layers/flights/records.js
+++ b/src/layers/flights/records.js
@@ -11,6 +11,7 @@ import {
   GROUND_FLOOR_WARM_MAX_ALT_M,
   LANDED_MISSING_POLL_LIMIT,
   MISSING_POLL_LIMIT,
+  TRACKED_RETENTION_MS,
 } from './recordPolicy.js';
 
 /** Source-independent aircraft metadata and bounded missing-poll retention. */
@@ -23,10 +24,45 @@ export class FlightRecords {
     };
     this.data = new Map();
     this.missingPolls = new Map();
+    // Contacts whose last poll re-sent a fix no newer than the one before.
+    this.fixRepeated = new Set();
+    this.lastSnapshotMs = null;
+    this.snapshotAdvanced = true;
     this.geoidNCache = new Map();
     this.geoidReady = false;
   }
 
+  /**
+   * Start reading a snapshot taken at `observedAtMs`. A fix re-sent in a
+   * newer snapshot marks its contact as not updated; the same snapshot read
+   * again does not.
+   * @param {number} observedAtMs
+   */
+  beginSnapshot(observedAtMs) {
+    this.snapshotAdvanced =
+      !Number.isFinite(observedAtMs) ||
+      !Number.isFinite(this.lastSnapshotMs) ||
+      observedAtMs > this.lastSnapshotMs;
+    if (Number.isFinite(observedAtMs))
+      this.lastSnapshotMs = Math.max(
+        this.lastSnapshotMs ?? -Infinity,
+        observedAtMs,
+      );
+  }
+
+  /** Note a received fix: the newest fix time, and whether it advanced. */
+  _noteFix(id, prevMeta, fixEpochMs) {
+    const prevFixMs = prevMeta?.newestFixMs;
+    // A fix counts as new only when it moves on by a second: feeds that
+    // derive fix time from receipt (readsb `now − seen_pos`, 0.1 s) jitter.
+    if (!Number.isFinite(prevFixMs) || fixEpochMs >= prevFixMs + 1000) {
+      this.fixRepeated.delete(id);
+      return fixEpochMs;
+    }
+    if (this.snapshotAdvanced) this.fixRepeated.add(id);
+    return prevFixMs;
+  }
+
   receive(
     observation,
     { viewerLatDeg, viewerLonDeg, trackedId, floorWarmPoints },
@@ -158,6 +194,12 @@ export class FlightRecords {
     //   (2) otherwise the SAME default policy `alt` already uses, so the two
     //       never disagree on the genuine "no data yet" case (a never-reported
     //       aircraft has no prior render height, so it lands here unchanged).
+    // Neither altitude this poll nor a held render height: the height below
+    // is the airborne default, invented. The tracked trail keeps no point there.
+    const renderAltitudeInvented =
+      pickedAltM == null &&
+      !onGround &&
+      !Number.isFinite(prevMeta?.renderAltitudeM);
     let renderAltitudeM;
     if (pickedAltM != null) {
       renderAltitudeM = pickedAltM;
@@ -204,9 +246,15 @@ export class FlightRecords {
     const routeHeld =
       Boolean(prevMeta?.routeCallsign) &&
       prevMeta.routeCallsign === nextCallsign.toUpperCase();
+    const fixEpochMs =
+      Number.isFinite(observation.positionTimeMs) &&
+      observation.positionTimeMs > 0
+        ? observation.positionTimeMs
+        : Date.now();
     const meta = {
       sourceReference: observation.reference,
       observedReceiptMs: Date.now(),
+      newestFixMs: this._noteFix(icao24, prevMeta, fixEpochMs),
       callsign: nextCallsign,
       altitude: alt,
       // geoAltitudeM/renderAltitudeM are ADDITIVE fields alongside the
@@ -215,6 +263,7 @@ export class FlightRecords {
       // still read `altitude`/baro).
       geoAltitudeM,
       renderAltitudeM,
+      renderAltitudeInvented,
       onGround,
       // Round 7: sticky airborne history — the landed fast-cull only
       // applies to contacts that actually flew this session.
@@ -276,15 +325,25 @@ export class FlightRecords {
     };
     this.data.set(icao24, meta);
 
-    const fixEpochMs =
-      Number.isFinite(observation.positionTimeMs) &&
-      observation.positionTimeMs > 0
-        ? observation.positionTimeMs
-        : Date.now();
     return { icao24, prevMeta, meta, groundFlipped, fixEpochMs };
   }
 
-  absence(id, { complete, retainIds, likelyLanded }) {
+  absence(id, { complete, retainIds, likelyLanded, tracked = false }) {
+    const misses = (this.missingPolls.get(id) || 0) + 1;
+    // The tracked contact has missed an update: it is stale from the first
+    // one, and kept (so the camera keeps its target) until ten minutes after
+    // its newest fix, whatever the snapshot says. With no fix time known it
+    // takes the ordinary limits below.
+    const meta = this.data.get(id);
+    const fixMs = meta?.newestFixMs ?? meta?.observedReceiptMs;
+    if (tracked && Number.isFinite(fixMs)) {
+      if (Date.now() - fixMs < TRACKED_RETENTION_MS) {
+        this.missingPolls.set(id, misses);
+        return 'stale';
+      }
+      this.missingPolls.delete(id);
+      return 'remove';
+    }
     // Partial admissions and position-less rows do not prove absence, but
     // retention remains bounded; a likely-landed position-less contact
     // still takes the landed limit.
@@ -293,7 +352,6 @@ export class FlightRecords {
       Date.now() - (this.data.get(id)?.observedReceiptMs ?? 0) < 300000
     )
       return 'retain';
-    const misses = (this.missingPolls.get(id) || 0) + 1;
     const limit = likelyLanded ? LANDED_MISSING_POLL_LIMIT : MISSING_POLL_LIMIT;
     if (misses < limit) {
       this.missingPolls.set(id, misses);
@@ -306,6 +364,7 @@ export class FlightRecords {
   forget(id) {
     this.data.delete(id);
     this.missingPolls.delete(id);
+    this.fixRepeated.delete(id);
     this.geoidNCache.delete(id);
   }
 }
diff --git a/src/layers/flights/records.test.mjs b/src/layers/flights/records.test.mjs
index f74574e96..9fab9e129 100644
--- a/src/layers/flights/records.test.mjs
+++ b/src/layers/flights/records.test.mjs
@@ -164,3 +164,99 @@ test('a route belongs to its callsign: a new callsign drops it, a blank one keep
   assert.equal(next.meta.airline, null);
   assert.equal(next.meta.routeCallsign, null);
 });
+
+test('a contact with no altitude yet is marked as drawn at an invented height; a held one is not', () => {
+  const store = records();
+  const none = store.receive(
+    observation({ baroAltitudeM: null, ellipsoidAltitudeM: null }),
+    view(),
+  );
+  assert.equal(none.meta.renderAltitudeInvented, true);
+  const known = store.receive(
+    observation({ positionTimeMs: 1700000005000 }),
+    view(),
+  );
+  assert.equal(known.meta.renderAltitudeInvented, false);
+  const held = store.receive(
+    observation({
+      baroAltitudeM: null,
+      ellipsoidAltitudeM: null,
+      positionTimeMs: 1700000010000,
+    }),
+    view(),
+  );
+  assert.equal(held.meta.renderAltitudeInvented, false);
+  const parked = records().receive(
+    observation({ id: 'abc124', baroAltitudeM: null, onGround: true }),
+    view(),
+  );
+  assert.equal(parked.meta.renderAltitudeInvented, false);
+});
+
+test('the tracked contact is stale from its first missed update and kept until ten minutes after its newest fix', () => {
+  const realNow = Date.now;
+  const fixMs = Date.UTC(2026, 10, 9, 20, 0);
+  let clock = fixMs + 5_000;
+  Date.now = () => clock;
+  try {
+    for (const snapshot of [
+      { complete: true },
+      { complete: true, retainIds: new Set(['abc123']) },
+      { complete: false },
+    ]) {
+      const store = records();
+      store.receive(observation({ positionTimeMs: fixMs }), view());
+      const absent = (tracked) =>
+        store.absence('abc123', { ...snapshot, likelyLanded: false, tracked });
+      clock = fixMs + 15_000;
+      assert.equal(absent(true), 'stale');
+      assert.equal(store.missingPolls.get('abc123'), 1);
+      // Kept long after the untracked limits, measured from the fix time.
+      clock = fixMs + 9 * 60_000;
+      assert.equal(absent(true), 'stale');
+      clock = fixMs + 10 * 60_000 - 1;
+      assert.equal(absent(true), 'stale');
+      clock = fixMs + 10 * 60_000;
+      assert.equal(absent(true), 'remove');
+      assert.equal(store.missingPolls.has('abc123'), false);
+    }
+    // Untracked contacts keep their own limits.
+    const store = records();
+    store.receive(observation({ positionTimeMs: fixMs }), view());
+    clock = fixMs + 15_000;
+    const untracked = (snapshot) =>
+      store.absence('abc123', { ...snapshot, likelyLanded: false });
+    assert.equal(untracked({ complete: false }), 'retain');
+    assert.deepEqual(
+      [1, 2, 3].map(() => untracked({ complete: true })),
+      ['stale', 'stale', 'remove'],
+    );
+  } finally {
+    Date.now = realNow;
+  }
+});
+
+test('a repeated fix time marks the contact as not updated; removal is unchanged', () => {
+  const store = records();
+  const fixMs = Date.UTC(2026, 10, 9, 20, 0);
+  store.beginSnapshot(fixMs + 2_000);
+  store.receive(observation({ positionTimeMs: fixMs }), view());
+  assert.equal(store.fixRepeated.has('abc123'), false);
+  // The next poll re-sends the same position.
+  store.beginSnapshot(fixMs + 12_000);
+  store.receive(observation({ positionTimeMs: fixMs }), view());
+  assert.equal(store.fixRepeated.has('abc123'), true);
+  assert.equal(store.missingPolls.has('abc123'), false);
+  // The same snapshot read again is not a missed update.
+  store.beginSnapshot(fixMs + 12_000);
+  store.receive(observation({ positionTimeMs: fixMs }), view());
+  assert.equal(store.fixRepeated.has('abc123'), true);
+  // A newer fix clears it.
+  store.beginSnapshot(fixMs + 22_000);
+  store.receive(observation({ positionTimeMs: fixMs + 10_000 }), view());
+  assert.equal(store.fixRepeated.has('abc123'), false);
+  store.beginSnapshot(fixMs + 32_000);
+  store.receive(observation({ positionTimeMs: fixMs + 10_000 }), view());
+  store.forget('abc123');
+  assert.equal(store.fixRepeated.has('abc123'), false);
+});
diff --git a/src/layers/flights/rendering.js b/src/layers/flights/rendering.js
index 333935bc1..dfc46a553 100644
--- a/src/layers/flights/rendering.js
+++ b/src/layers/flights/rendering.js
@@ -39,6 +39,7 @@ import {
   COURSE_MAX_DPS,
   HIDDEN_CONTACT_DR_TICKS,
   hiddenContactDrPhase,
+  STALE_ALPHA,
 } from './policy.js';
 import { AIRCRAFT_ENVIRONMENT_MAP_OPTIONS } from '../../data/aircraftModelLighting.js';
 
@@ -680,6 +681,19 @@ export function createRendering({
    *  follow-camera's bounding sphere is ALWAYS ready — toggling 3D, or tracking while already zoomed
    *  in, can never stall or freeze the centering (the old model-graphic-on-entity failure mode). */
 
+  /** Fade the tracked 3D model like the billboard while the plane is stale. */
+
+  function _applyTrackedModelFade(model) {
+    const alpha = parts.tracking._trackedStaleCue?.(flightState._trackedIcao)
+      ?.dimmed
+      ? STALE_ALPHA
+      : 1;
+    if (model.color?.alpha === alpha) return;
+    model.color = (
+      flightState._irBoost ? Cesium.Color.WHITE : Cesium.Color.CYAN
+    ).withAlpha(alpha);
+  }
+
   function _updateTrackedModel() {
     const active =
       flightState._trackedIcao &&
@@ -823,6 +837,7 @@ export function createRendering({
         parts.motion._trackedDisplayCourse(),
         flightState._trackedModel.modelMatrix,
       );
+      _applyTrackedModelFade(flightState._trackedModel);
       if (!flightState._trackedModel.ready) return;
       const spec = _modelSpec(
         flightState.records.data.get(flightState._trackedIcao)?.klass,
@@ -849,6 +864,13 @@ export function createRendering({
   }
 
   function _fleetTick() {
+    // Every frame, shown or not: the tracked trail records where its icon is
+    // drawn and moves its body on (the head callback only reads the result),
+    // and the tracked label's stale cue follows the clock.
+    if (flightState._viewer) {
+      parts.tracking._trailTick?.();
+      parts.tracking._staleCueTick?.();
+    }
     if (
       !flightState._viewer ||
       !flightState._billboardCollection ||
@@ -1081,7 +1103,9 @@ export function createRendering({
           flightState._cockpitContactMode && !isCockpitNear
             ? 1
             : _fleetBillboardScale(icao24, info?.klass),
-        baseAlpha: flightState.records.missingPolls.get(icao24) ? 0.45 : 1,
+        baseAlpha: flightState.records.missingPolls.get(icao24)
+          ? STALE_ALPHA
+          : 1,
         baseColor,
         focusFactor: focus.factor,
         cameraDistanceM,
diff --git a/src/layers/flights/snapshotRenderer.js b/src/layers/flights/snapshotRenderer.js
index 414e6a0f6..1ef928562 100644
--- a/src/layers/flights/snapshotRenderer.js
+++ b/src/layers/flights/snapshotRenderer.js
@@ -3,6 +3,7 @@ import { cyberSonarBaseAlpha } from '../../cyberSonar.js';
 import {
   turnRateFromFixHistory,
   liftRepeatedGroundFix,
+  staleHoldsForFix,
   synthesizeForwardKinematicsFix,
 } from '../../data/motionModel.js';
 import { aircraftIcon } from '../../data/aircraftIcons.js';
@@ -22,7 +23,7 @@ export function createFlightSnapshotRenderer({
   queries,
 }) {
   const { refreshMilitaryRegistryIfStale, isMilitaryIcao } = militaryRegistry;
-  const { warmGroundFloor } = groundFloor;
+  const { warmGroundFloor, cachedGroundFloor } = groundFloor;
   const { sampleMeshFloorCells } = meshFloor;
   return function applySnapshot(snapshot, viewer) {
     const currentIcaos = new Set();
@@ -39,6 +40,7 @@ export function createFlightSnapshotRenderer({
       ? Cesium.Math.toDegrees(viewerCarto.longitude)
       : null;
     const floorWarmPoints = [];
+    records.beginSnapshot(snapshot.observedAtMs);
 
     // Classification and display policy consume source-independent observations.
     refreshMilitaryRegistryIfStale();
@@ -112,6 +114,9 @@ export function createFlightSnapshotRenderer({
           position: position.clone(),
           velocity: meta.velocity,
           track: meta.true_track,
+          // Drawn at an invented height: a trail seeded from history keeps no
+          // position for it.
+          inventedHeight: meta.renderAltitudeInvented === true,
         });
         if (history.length > POSITION_HISTORY_LIMIT) {
           history.shift();
@@ -125,7 +130,10 @@ export function createFlightSnapshotRenderer({
         // Round 2 (owner): ground traffic appends too — taxi history stays
         // live after touchdown (grounded flights positions are already
         // surface-clamped via the surfaceM chain, so the ground leg drapes).
-        if (isTracked) tracking._appendTrailFix(position.clone());
+        if (isTracked)
+          tracking._appendTrailFix(position.clone(), fixEpochMs, {
+            nullAltitude: meta.renderAltitudeInvented === true,
+          });
       } else {
         const modelOwnsGroundVisual = rendering._modelOwnsVisual(icao24);
         if (!modelOwnsGroundVisual) {
@@ -133,21 +141,28 @@ export function createFlightSnapshotRenderer({
         }
         // Apply fresh kinematics only from a forward synthetic fix. Mutating
         // the historical fix reprojects the entire stale interval and snaps
-        // the rendered aircraft when course or speed changes late.
+        // the rendered aircraft when course or speed changes late. The stale
+        // rules apply: none for a contact that holds at its report, a coast
+        // capped from the real report, never below the ground. It is a motion
+        // aid, not a report, so it never joins the trail.
         const kinematicsChanged =
           newest.velocity !== meta.velocity || newest.track !== meta.true_track;
-        if (kinematicsChanged) {
+        const holds = staleHoldsForFix(newest, {
+          onGround: meta.onGround,
+          cachedGroundFloor,
+        });
+        if (kinematicsChanged && !holds) {
           const synthetic = synthesizeForwardKinematicsFix(newest, {
             epochMs: Date.now(),
             velocity: meta.velocity,
             track: meta.true_track,
             turnRateDps: meta.turnRateDps,
+            cachedGroundFloor,
           });
           if (synthetic) {
             history.push(synthetic);
             if (history.length > POSITION_HISTORY_LIMIT) history.shift();
             meta.turnRateDps = turnRateFromFixHistory(history);
-            if (isTracked) tracking._appendTrailFix(synthetic.position.clone());
           }
         }
       }
@@ -252,6 +267,7 @@ export function createFlightSnapshotRenderer({
         complete: snapshot.complete,
         retainIds: snapshot.retainIds,
         likelyLanded: queries._likelyLanded(icao24),
+        tracked: icao24 === flightState._trackedIcao,
       });
       if (absence === 'retain') continue;
       if (absence === 'stale') {
diff --git a/src/layers/flights/snapshotStale.test.mjs b/src/layers/flights/snapshotStale.test.mjs
new file mode 100644
index 000000000..c1f4a7278
--- /dev/null
+++ b/src/layers/flights/snapshotStale.test.mjs
@@ -0,0 +1,153 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createFlightSnapshotRenderer } from './snapshotRenderer.js';
+
+// A poll that repeats a contact's last position with new speed or course
+// must not move it past where the stale rules allow, and never adds a
+// report to the tracked trail.
+
+const ICAO = '00a002';
+const SEC = 1000;
+
+/** Any property is a no-op function unless given. */
+function stub(overrides = {}) {
+  return new Proxy(overrides, {
+    get: (target, key) => (key in target ? target[key] : () => undefined),
+  });
+}
+
+function harness({ ground = () => null }) {
+  const appended = [];
+  const history = [];
+  const flightState = {
+    _trackedIcao: ICAO,
+    _trackedEntity: null,
+    _positionHistory: new Map([[ICAO, history]]),
+    _billboards: new Map([[ICAO, { position: new Cesium.Cartesian3() }]]),
+    _billboardCollection: stub(),
+    _cullPositions: new Map(),
+    _displayCourse: new Map(),
+    _groundSnap: stub(),
+    _displayFloorState: new Map(),
+    _models: new Map(),
+    _viewer: null,
+    _cockpitContactMode: false,
+    records: { data: new Map() },
+  };
+  let meta = null;
+  let fixEpochMs = 0;
+  const records = stub({
+    receive: () => {
+      flightState.records.data.set(ICAO, meta);
+      return { prevMeta: meta, meta, groundFlipped: false, fixEpochMs };
+    },
+    absence: () => 'retain',
+  });
+  const apply = createFlightSnapshotRenderer({
+    flightState,
+    records,
+    militaryRegistry: stub({ isMilitaryIcao: () => false }),
+    groundFloor: stub({ cachedGroundFloor: ground }),
+    meshFloor: stub(),
+    rendering: stub({
+      _modelOwnsVisual: () => false,
+      _fleetBillboardColor: () => Cesium.Color.WHITE,
+    }),
+    tracking: stub({
+      _militaryLayerSuppresses: () => false,
+      _appendTrailFix: (position, epochMs) =>
+        appended.push({ position, epochMs }),
+    }),
+    motion: stub(),
+    enrichment: stub(),
+    queries: stub({ _likelyLanded: () => false }),
+  });
+  return {
+    history,
+    appended,
+    poll(nextMeta, epochMs) {
+      meta = nextMeta;
+      fixEpochMs = epochMs;
+      apply({ records: [{ id: ICAO }], complete: true }, null);
+    },
+  };
+}
+
+const lightAircraft = (velocity, track) => ({
+  rawLat: 38.1436,
+  rawLon: -122.5561,
+  renderAltitudeM: 10,
+  altitude: 40,
+  velocity,
+  true_track: track,
+  onGround: false,
+  wasAirborne: true,
+  klass: 'light',
+});
+
+test('a low contact whose position repeats while its speed changes is not moved and adds nothing to the trail', (t) => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  t.mock.timers.enable({ apis: ['Date'], now: t0 });
+  const h = harness({ ground: () => -30 });
+  h.poll(lightAircraft(36.4, 63), t0);
+  const first = h.history[0].position;
+  for (const [i, velocity] of [30, 22, 14, 9].entries()) {
+    t.mock.timers.tick(10 * SEC);
+    h.poll(lightAircraft(velocity, 63 + i * 20), t0);
+  }
+  assert.equal(h.history.length, 1, 'a synthetic fix moved a holding contact');
+  assert.equal(h.history[0].position, first);
+  assert.equal(h.appended.length, 1, 'only the real report joins the trail');
+});
+
+test('a cruising contact whose position repeats coasts no further than the stale cap, and the synthetic fix is not a report', (t) => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  t.mock.timers.enable({ apis: ['Date'], now: t0 });
+  const h = harness({});
+  const cruise = (velocity, track) => ({
+    rawLat: 36,
+    rawLon: -115,
+    renderAltitudeM: 9_000,
+    altitude: 9_000,
+    velocity,
+    true_track: track,
+    onGround: false,
+    wasAirborne: true,
+    klass: 'jet',
+  });
+  h.poll(cruise(220, 90), t0);
+  const report = h.history[0].position;
+  t.mock.timers.tick(300 * SEC);
+  h.poll(cruise(200, 100), t0);
+  assert.equal(h.history.length, 2);
+  const moved = Cesium.Cartesian3.distance(report, h.history[1].position);
+  assert.ok(
+    moved <= 220 * 300 + 1,
+    `the synthetic fix coasted ${moved.toFixed(0)} m`,
+  );
+  assert.equal(h.appended.length, 1, 'the synthetic fix joined the trail');
+});
+
+test('a report drawn at an invented height says so on its history fix', (t) => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  t.mock.timers.enable({ apis: ['Date'], now: t0 });
+  const h = harness({});
+  h.poll({ ...lightAircraft(60, 90), renderAltitudeInvented: true }, t0);
+  h.poll({ ...lightAircraft(60, 90), rawLon: -122.55 }, t0 + 10 * SEC);
+  assert.equal(h.history[0].inventedHeight, true);
+  assert.equal(h.history[1].inventedHeight, false);
+});
+
+test('with the ground unknown, a low barometric altitude alone does not hold a contact', (t) => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  t.mock.timers.enable({ apis: ['Date'], now: t0 });
+  const h = harness({});
+  h.poll(lightAircraft(36.4, 63), t0);
+  t.mock.timers.tick(10 * SEC);
+  h.poll(lightAircraft(30, 80), t0);
+  // It coasts under the stale cap instead.
+  assert.equal(h.history.length, 2);
+  assert.equal(h.history[0].staleHolds, false);
+  assert.equal(h.appended.length, 1);
+});
diff --git a/src/layers/flights/staleHold.test.mjs b/src/layers/flights/staleHold.test.mjs
new file mode 100644
index 000000000..15c41342b
--- /dev/null
+++ b/src/layers/flights/staleHold.test.mjs
@@ -0,0 +1,421 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createMotion } from './motion.js';
+import { createFlightState } from './state.js';
+import { createTracking } from './tracking.js';
+import {
+  staleCoastSeconds,
+  staleHoldsAtLastReport,
+} from '../../data/motionModel.js';
+import { TRAIL_CONTINUITY_MAX_SPEED_KT } from '../../data/trailContinuity.js';
+import { RENDER_DELAY_SEC } from './policy.js';
+
+const SEC = 1000;
+// Ellipsoidal ground at a sea-level airfield (geoid about -32 m).
+const FIELD_GROUND_M = -30;
+
+/** A motion module over one contact's history, with a fixed clock. */
+function motionFixture({ info, fixes, nowMs, ground = () => null }) {
+  const flightState = {
+    records: { data: new Map([['00a001', info]]) },
+    _positionHistory: new Map([['00a001', fixes]]),
+    _focusEvidenceIds: new Set(),
+    _scratchArc: {},
+    _scratchOffset: new Cesium.Cartesian3(),
+    _scratchRenderTime: new Cesium.JulianDate(),
+    _scratchCoastCarto: new Cesium.Cartographic(),
+    now: () => nowMs,
+  };
+  const motion = createMotion({
+    flightState,
+    services: {
+      groundFloor: {
+        cachedGroundFloor: ground,
+        floorAltitudeM: (alt, g) =>
+          Number.isFinite(g) ? Math.max(alt, g + 1.5) : alt,
+      },
+      camera: {},
+      focus: {},
+    },
+    parts: {},
+  });
+  return { flightState, motion };
+}
+
+function fix(timeMs, lat, lon, heightM, velocity, track) {
+  return {
+    time: Cesium.JulianDate.fromDate(new Date(timeMs)),
+    epochMs: timeMs,
+    position: Cesium.Cartesian3.fromDegrees(lon, lat, heightM),
+    velocity,
+    track,
+  };
+}
+
+const height = (position) => Cesium.Cartographic.fromCartesian(position).height;
+
+test('a stale contact holds at its last report when it reported on the ground or low', () => {
+  assert.equal(staleHoldsAtLastReport({ onGround: true }), true);
+  // A light aircraft on final: -30 m barometric, its render height 1.5 m above the known ground.
+  assert.equal(
+    staleHoldsAtLastReport({
+      onGround: false,
+      heightM: FIELD_GROUND_M + 1.5,
+      groundM: FIELD_GROUND_M,
+    }),
+    true,
+  );
+  // Ground unknown: a low barometric altitude alone does not hold it; it
+  // coasts under the cap.
+  assert.equal(
+    staleHoldsAtLastReport({ onGround: false, heightM: 120 }),
+    false,
+  );
+  // A high airfield: 1,600 m barometric but 60 m above its ground.
+  assert.equal(
+    staleHoldsAtLastReport({
+      onGround: false,
+      heightM: 1_660,
+      groundM: 1_600,
+    }),
+    true,
+  );
+  assert.equal(
+    staleHoldsAtLastReport({
+      onGround: false,
+      heightM: 10_000,
+      groundM: 20,
+    }),
+    false,
+  );
+});
+
+test('a stale contact coasts up to its source limit at any speed, and a holding one not at all', () => {
+  const coast = (over) =>
+    staleCoastSeconds({
+      elapsedSec: 400,
+      coastLimitSec: 300,
+      speedMps: 230,
+      holds: false,
+      ...over,
+    });
+  assert.equal(coast(), 300);
+  assert.equal(coast({ elapsedSec: 200 }), 200);
+  assert.equal(coast({ coastLimitSec: 60 }), 60);
+  assert.equal(coast({ speedMps: 1_000 }), 300);
+  assert.equal(coast({ holds: true }), 0);
+  assert.equal(coast({ elapsedSec: -5 }), 0);
+});
+
+test('a light aircraft on short final goes stale after a low, slow, descending report, the icon holds at that report, not below the ground', () => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  const fixes = [
+    fix(t0, 38.1279, -122.5425, 122, 40, 340),
+    fix(t0 + 30 * SEC, 38.133, -122.5494, 38, 37, 10),
+    fix(t0 + 60 * SEC, 38.1436, -122.5561, FIELD_GROUND_M + 1.5, 36.4, 63),
+  ];
+  const info = {
+    altitude: -30,
+    renderAltitudeM: FIELD_GROUND_M + 1.5,
+    rawLat: 38.1436,
+    rawLon: -122.5561,
+    velocity: 36.4,
+    true_track: 63,
+    onGround: false,
+    wasAirborne: true,
+    lastContactEpochMs: t0 + 60 * SEC,
+  };
+  for (const afterSec of [5, 45, 90, 240]) {
+    const nowMs = t0 + 60 * SEC + RENDER_DELAY_SEC * SEC + afterSec * SEC;
+    const { motion } = motionFixture({
+      info,
+      fixes,
+      nowMs,
+      ground: () => FIELD_GROUND_M,
+    });
+    const drawn = motion._deadReckon('00a001', new Cesium.Cartesian3());
+    assert.ok(
+      Cesium.Cartesian3.distance(drawn, fixes[2].position) < 0.01,
+      `${afterSec} s after the report the icon is at the report`,
+    );
+    assert.ok(height(drawn) >= FIELD_GROUND_M);
+  }
+});
+
+function cruiser(lastContactAfterSec) {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  const fixes = [
+    fix(t0, 40, -100, 10_000, 230, 90),
+    fix(t0 + 15 * SEC, 40, -99.96, 10_000, 230, 90),
+  ];
+  const info = {
+    altitude: 10_000,
+    renderAltitudeM: 10_000,
+    rawLat: 40,
+    rawLon: -99.96,
+    velocity: 230,
+    true_track: 90,
+    onGround: false,
+    wasAirborne: true,
+    lastContactEpochMs: t0 + 15 * SEC + lastContactAfterSec * SEC,
+  };
+  const at = (afterSec) => {
+    const nowMs = t0 + 15 * SEC + RENDER_DELAY_SEC * SEC + afterSec * SEC;
+    const { motion } = motionFixture({ info, fixes, nowMs });
+    return motion._deadReckon('00a001', new Cesium.Cartesian3());
+  };
+  const d = (p) => Cesium.Cartesian3.distance(p, fixes[1].position);
+  return { at, d };
+}
+
+test('a cruising contact still heard after its last position coasts past 90 s, for up to 5 minutes, then stops', () => {
+  // Contact kept arriving for four minutes after the last position.
+  const { at, d } = cruiser(240);
+  const near = (got, want) => Math.abs(got - want) < want * 0.005 + 50;
+  assert.ok(near(d(at(90)), 230 * 90));
+  assert.ok(near(d(at(200)), 230 * 200), 'still moving at 200 s');
+  assert.ok(near(d(at(300)), 230 * 300));
+  assert.ok(near(d(at(400)), 230 * 300), 'stopped at 300 s');
+  assert.ok(Cesium.Cartesian3.distance(at(400), at(600)) < 0.01);
+});
+
+test('a cruising contact that stops reporting coasts five minutes, then stops', () => {
+  const { at, d } = cruiser(0);
+  assert.ok(Math.abs(d(at(60)) - 230 * 60) < 120);
+  assert.ok(Math.abs(d(at(300)) - 230 * 300) < 600);
+  assert.ok(Cesium.Cartesian3.distance(at(301), at(420)) < 0.01);
+});
+
+test('a bad reported speed coasts no faster than the 1,500 kt continuity limit', () => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  // 2,000 m/s (about 3,900 kt): a corrupt velocity, not a real aircraft.
+  const fixes = [
+    fix(t0, 40, -100, 10_000, 2_000, 90),
+    fix(t0 + 15 * SEC, 40, -99.96, 10_000, 2_000, 90),
+  ];
+  const info = {
+    altitude: 10_000,
+    renderAltitudeM: 10_000,
+    rawLat: 40,
+    rawLon: -99.96,
+    velocity: 2_000,
+    true_track: 90,
+    onGround: false,
+    wasAirborne: true,
+  };
+  const nowMs = t0 + 15 * SEC + RENDER_DELAY_SEC * SEC + 300 * SEC;
+  const { motion } = motionFixture({ info, fixes, nowMs });
+  const drawn = motion._deadReckon('00a001', new Cesium.Cartesian3());
+  const limitMps = (TRAIL_CONTINUITY_MAX_SPEED_KT * 1852) / 3600;
+  const d = Cesium.Cartesian3.distance(drawn, fixes[1].position);
+  assert.ok(Math.abs(d - limitMps * 300) < 1_500, `${d.toFixed(0)} m`);
+});
+
+test('coasting never takes a contact below the ground', () => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  const fixes = [
+    fix(t0, 39.7, -105.5, 3_400, 80, 270),
+    fix(t0 + 15 * SEC, 39.7, -105.514, 3_400, 80, 270),
+  ];
+  const info = {
+    altitude: 3_400,
+    renderAltitudeM: 3_400,
+    rawLat: 39.7,
+    rawLon: -105.514,
+    velocity: 80,
+    true_track: 270,
+    onGround: false,
+    wasAirborne: true,
+  };
+  // 3,000 m under the report, rising to 3,600 m along the coast west.
+  const nowMs = t0 + 15 * SEC + RENDER_DELAY_SEC * SEC + 60 * SEC;
+  const { motion } = motionFixture({
+    info,
+    fixes,
+    nowMs,
+    ground: (lat, lon) => (lon < -105.52 ? 3_600 : 3_000),
+  });
+  const drawn = motion._deadReckon('00a001', new Cesium.Cartesian3());
+  assert.ok(height(drawn) >= 3_600, `height ${height(drawn)}`);
+});
+
+// ---------------------------------------------------------------------------
+// The trail and head across a stale gap.
+
+function services(trail) {
+  const names = [
+    'picking',
+    'sprites',
+    'aircraftPresentation',
+    'camera',
+    'militaryRegistry',
+    'labels',
+    'meshFloor',
+    'focus',
+    'readout',
+    'context',
+    'render',
+    'recession',
+  ];
+  return {
+    ...Object.fromEntries(names.map((name) => [name, {}])),
+    groundSnap: { createGroundSnap: () => ({ clear() {} }) },
+    trails: trail,
+    geoid: { ensureGeoidReady: async () => {}, geoidHeight: () => 0 },
+    groundFloor: {
+      resolveGroundFloorCellsBounded: async () => {},
+      cachedGroundFloor: () => null,
+      floorAltitudeM: (alt) => alt,
+    },
+  };
+}
+
+function trailHarness({ fixes, nowMs, head }) {
+  const calls = [];
+  const trail = {
+    createTrail: () => ({
+      setSegments(segments) {
+        calls.push(segments.map((segment) => segment.slice()));
+      },
+      setPositions(positions) {
+        calls.push([positions.slice()]);
+      },
+      setVisible() {},
+      clear() {},
+      destroy() {},
+    }),
+  };
+  const svc = services(trail);
+  const flightState = createFlightState({
+    services: svc,
+    source: { label: 'Fixture aircraft' },
+  });
+  const added = [];
+  flightState._viewer = {
+    isDestroyed: () => false,
+    entities: {
+      add(definition) {
+        added.push(definition);
+        return definition;
+      },
+      remove() {},
+    },
+  };
+  flightState._trackedIcao = '00a001';
+  let clock = nowMs;
+  flightState.now = () => clock;
+  flightState._positionHistory.set('00a001', fixes);
+  let headPosition = head;
+  const tracking = createTracking({
+    flightState,
+    services: svc,
+    parts: {
+      motion: {
+        _isTrackWarmingUp: () => false,
+        _trackedTrailCached: () => headPosition,
+        _trackedDisplayPosition: () => headPosition,
+        _trackedModelCenterWorld: () => null,
+        _trackedModelEnvelopeM: () => null,
+      },
+    },
+    layer: {},
+  });
+  const headEntity = () =>
+    added.find((definition) =>
+      String(definition.id).startsWith('gev-trail:fl-head-'),
+    );
+  return {
+    tracking,
+    flightState,
+    drawn: () => (calls.at(-1) ?? []).flat(),
+    head: () => headEntity().polyline.positions.getValue(),
+    setClock: (ms) => {
+      clock = ms;
+    },
+    setHead: (position) => {
+      headPosition = position;
+    },
+  };
+}
+
+test('a holding contact draws no head, and the trail ends at the last report, never past the icon', () => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  const fixes = [
+    fix(t0, 38.1678, -122.527, 303, 45, 200),
+    fix(t0 + 30 * SEC, 38.1279, -122.5425, 122, 40, 340),
+    fix(t0 + 60 * SEC, 38.133, -122.5494, 38, 37, 10),
+    fix(t0 + 90 * SEC, 38.1436, -122.5561, 0, 36.4, 63),
+  ];
+  const last = fixes.at(-1).position;
+  // The display time is long past the last report; the icon holds there.
+  const h = trailHarness({
+    fixes,
+    nowMs: t0 + 90 * SEC + RENDER_DELAY_SEC * SEC + 120 * SEC,
+    head: Cesium.Cartesian3.clone(last),
+  });
+  h.tracking._startTrail('00a001');
+  // Every report, including the last, is in the trail: the head no longer
+  // cuts from the one before it to the icon.
+  assert.equal(h.drawn().length, 4);
+  assert.equal(h.drawn().at(-1), h.flightState._trailFixes.at(-1).position);
+  assert.deepEqual(h.head(), []);
+});
+
+test('while the display is between reports, the trail stops at the report behind the icon', () => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  // Reports every 10 s; the icon is drawn 30 s behind, between the 2nd and 3rd.
+  const fixes = [0, 1, 2, 3, 4, 5].map((i) =>
+    fix(t0 + i * 10 * SEC, 40, -100 + i * 0.03, 10_000, 230, 90),
+  );
+  const nowMs = t0 + 25 * SEC + RENDER_DELAY_SEC * SEC;
+  const icon = Cesium.Cartesian3.fromDegrees(-100 + 0.075, 40, 10_000);
+  const h = trailHarness({ fixes, nowMs, head: icon });
+  h.tracking._startTrail('00a001');
+  // Reports at 0, 10 and 20 s are behind the icon (display time 25 s).
+  assert.equal(h.drawn().length, 3);
+  const head = h.head();
+  assert.equal(head.length, 2);
+  assert.ok(Cesium.Cartesian3.distance(head[0], fixes[2].position) < 0.01);
+});
+
+test('the hold-or-coast decision is made once per report: a floor that resolves mid-coast does not snap the icon back', () => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  const fixes = [
+    fix(t0, 39.7, -104.6, 1_900, 70, 270),
+    fix(t0 + 15 * SEC, 39.7, -104.6123, 1_900, 70, 270),
+  ];
+  const info = {
+    altitude: 1_950,
+    renderAltitudeM: 1_900,
+    rawLat: 39.7,
+    rawLon: -104.6123,
+    velocity: 70,
+    true_track: 270,
+    onGround: false,
+    wasAirborne: true,
+    lastContactEpochMs: t0 + 15 * SEC + 120 * SEC,
+  };
+  // No floor known when the contact goes stale: baro says well clear of the
+  // ground, so it coasts. Mid-coast the floor resolves 100 m under the report.
+  let ground = () => null;
+  const at = (afterSec) => {
+    const nowMs = t0 + 15 * SEC + RENDER_DELAY_SEC * SEC + afterSec * SEC;
+    const { motion } = motionFixture({
+      info,
+      fixes,
+      nowMs,
+      ground: (lat, lon) => ground(lat, lon),
+    });
+    return motion._deadReckon('00a001', new Cesium.Cartesian3());
+  };
+  const d = (p) => Cesium.Cartesian3.distance(p, fixes[1].position);
+  const before = d(at(30));
+  assert.ok(Math.abs(before - 70 * 30) < 50, `coasted ${before.toFixed(0)} m`);
+  ground = () => 1_800;
+  const after = d(at(31));
+  assert.ok(
+    after > before,
+    `the icon went from ${before.toFixed(0)} m to ${after.toFixed(0)} m`,
+  );
+});
diff --git a/src/layers/flights/state.js b/src/layers/flights/state.js
index 81b849f4b..4b58f54fb 100644
--- a/src/layers/flights/state.js
+++ b/src/layers/flights/state.js
@@ -195,9 +195,32 @@ export function createFlightState({ source, services }) {
 
   flightState._trailHeadSeq = 0;
 
-  /** @type {Cesium.Cartesian3[]} Chronological tracked-aircraft fixes (oldest first) */
+  /** @type {{position: Cesium.Cartesian3|null, timeMs: number, nullAltitude: boolean, breakBefore: boolean, drawn?: boolean}[]}
+   *  Chronological tracked-aircraft trail (oldest first): reports, and
+   *  (`drawn`) where the icon was drawn between them; `breakBefore` starts a
+   *  new segment. */
 
-  flightState._trailPositions = [];
+  flightState._trailFixes = [];
+
+  /** @type {number} Body fixes drawn: those at or before the display time. */
+
+  flightState._trailBodyCount = 0;
+
+  /** @type {Cesium.Cartesian3|null} Where the tracked icon was last recorded into the trail. */
+
+  flightState._trailRecordPosition = null;
+
+  /** @type {number} Display time (epoch ms) of that recording. */
+
+  flightState._trailRecordMs = -Infinity;
+
+  /** @type {string|undefined} The stale cue last written into the tracked label (see `_staleCueTick`). */
+
+  flightState._trackedStaleCueText = undefined;
+
+  /** @type {{key: string, cue: {text: string, dimmed: boolean}}|null} This frame's tracked stale cue (see `_trackedStaleCue`). */
+
+  flightState._trackedStaleCueCache = null;
 
   /** @type {number} Monotonic token — invalidates in-flight backfill responses */
 
diff --git a/src/layers/flights/tracking.js b/src/layers/flights/tracking.js
index 9fbde6a3f..cbc1b66ad 100644
--- a/src/layers/flights/tracking.js
+++ b/src/layers/flights/tracking.js
@@ -1,5 +1,4 @@
 import * as Cesium from 'cesium';
-import { julianAt } from '../../time/julian.js';
 import { formatNumber, t } from '../../i18n/index.js';
 import { unitLabel } from '../../ui/unitLabels.js';
 import { nextCockpitNearContacts } from '../../data/cockpitAirLod.js';
@@ -21,12 +20,31 @@ import {
   TRACKED_MODEL_MAX_LOAD_FAILS,
   TRACKED_MODEL_RETRY_BACKOFF_MS,
   TRAIL_MAX_POINTS,
+  DR_CORRECTION_MS,
   RENDER_DELAY_SEC,
   TRAIL_COLOR,
   CYAN_TRANSPARENT,
+  STALE_ALPHA,
 } from './policy.js';
+import {
+  drawTrailSegments,
+  historyFixEpochMs,
+  insertTrailFix,
+  joinTrailBackfill,
+  recordTrailPoint,
+  trailBackfillFixes,
+  trailBodyCount,
+  trailBodyCountOutsideModel,
+  trailBodySegments,
+  trailHeadStartFix,
+  trailRecordingBlocked,
+  TRAIL_RECORD_STEP_M,
+  TRAIL_RECORD_STEP_MS,
+} from '../../data/trailContinuity.js';
 import { roundHeadingDegrees } from '../../data/headingDegrees.js';
 
+const STALE_CYAN = Cesium.Color.CYAN.withAlpha(STALE_ALPHA);
+
 export function createTracking({
   flightState,
   services,
@@ -333,18 +351,81 @@ export function createTracking({
   }
 
   /**
-   * Append one fix to the tracked aircraft's trail accumulation and refresh
-   * the rendered trail. Caller passes an owned (cloned) Cartesian3.
-   * @param {Cesium.Cartesian3} position - New fix position, appended at the head.
+   * Put one report into the tracked aircraft's trail, in time order, and
+   * refresh the rendered trail. Caller passes an owned (cloned) Cartesian3. A
+   * report that breaks from its neighbour starts a new segment (see
+   * trailContinuity).
+   * @param {Cesium.Cartesian3} position - The report's position.
+   * @param {number} [epochMs] - The report's time; defaults to the tracked
+   *   aircraft's newest position-history fix, which every caller has just pushed.
+   * @param {{nullAltitude?: boolean}} [options] - `nullAltitude`: the report
+   *   had no altitude, so its position is not kept and the line breaks there.
+   *   A report for a time the display has already passed replaces what was
+   *   drawn after it (see `insertTrailFix`).
    */
 
-  function _appendTrailFix(position) {
-    flightState._trailPositions.push(position);
-    if (flightState._trailPositions.length > TRAIL_MAX_POINTS)
-      flightState._trailPositions.shift();
+  function _appendTrailFix(position, epochMs, { nullAltitude = false } = {}) {
+    const history = flightState._positionHistory.get(flightState._trackedIcao);
+    const timeMs = Number.isFinite(epochMs)
+      ? epochMs
+      : historyFixEpochMs(history?.[history.length - 1]);
+    insertTrailFix(
+      flightState._trailFixes,
+      position,
+      timeMs,
+      TRAIL_MAX_POINTS,
+      {
+        nullAltitude,
+        displayMs: flightState.now() - RENDER_DELAY_SEC * 1000,
+        settleMs: DR_CORRECTION_MS,
+      },
+    );
     _refreshTrailDisplay();
   }
 
+  /**
+   * Per-frame trail work, run from the layer's preRender pass whether or not
+   * the head is visible: record where the tracked icon is drawn (at most once
+   * a second or every 150 m) and move the body on as the display time passes
+   * reports. The head callback only reads the result.
+   */
+
+  function _trailTick() {
+    if (!flightState._trackedIcao || !flightState._trail) return;
+    const displayMs = flightState.now() - RENDER_DELAY_SEC * 1000;
+    let changed = false;
+    if (
+      flightState._trailFixes.length &&
+      !parts.motion._isTrackWarmingUp() &&
+      !trailRecordingBlocked(flightState._trailFixes, displayMs)
+    ) {
+      const drawn = parts.motion._trackedDisplayPosition(
+        flightState._trackedIcao,
+      );
+      const last = flightState._trailRecordPosition;
+      if (
+        drawn &&
+        (!last ||
+          displayMs - flightState._trailRecordMs >= TRAIL_RECORD_STEP_MS ||
+          Cesium.Cartesian3.distance(last, drawn) >= TRAIL_RECORD_STEP_M)
+      ) {
+        flightState._trailRecordMs = displayMs;
+        flightState._trailRecordPosition = Cesium.Cartesian3.clone(
+          drawn,
+          flightState._trailRecordPosition ?? undefined,
+        );
+        changed = recordTrailPoint(
+          flightState._trailFixes,
+          Cesium.Cartesian3.clone(drawn),
+          displayMs,
+          TRAIL_MAX_POINTS,
+        );
+      }
+    }
+    if (changed || _trailBodyCountNow() !== flightState._trailBodyCount)
+      _refreshTrailDisplay();
+  }
+
   /**
    * Renders the trail with its head clamped to the render-behind display
    * position. Raw newest fixes run up to RENDER_DELAY_SEC ahead of the
@@ -354,17 +435,33 @@ export function createTracking({
    */
 
   function _refreshTrailDisplay() {
-    // The trail BODY is the accumulated fixes EXCLUDING the newest raw one — that newest
-    // fix is at ~now, ~one poll interval AHEAD of the delayed icon (rendered at
-    // now − RENDER_DELAY_SEC), so drawing it would push the trail in front of the plane.
-    // The cheap per-frame _trailHeadEntity segment bridges the last body point to the
-    // delayed dead-reckoned head, so the body primitive only rebuilds on a real fix
-    // (poll cadence), never at motion cadence.
+    // The trail BODY is the accumulated fixes at or before the delayed display time
+    // (now − RENDER_DELAY_SEC); newer fixes are AHEAD of the icon, so drawing them
+    // would push the trail in front of the plane. The cheap per-frame
+    // _trailHeadEntity segment bridges the last body point to the delayed
+    // dead-reckoned head, so the body rebuilds only on a real fix or when the
+    // display time passes one, never at motion cadence.
+    // A break lifts the pen: each segment is its own line, nothing between them.
     if (!flightState._trail) return;
-    flightState._trail.setPositions(
-      flightState._trailPositions.length > 1
-        ? flightState._trailPositions.slice(0, -1)
-        : flightState._trailPositions,
+    flightState._trailBodyCount = _trailBodyCountNow();
+    drawTrailSegments(
+      flightState._trail,
+      trailBodySegments(flightState._trailFixes, flightState._trailBodyCount),
+    );
+  }
+
+  /** Fixes at or before the time the aircraft is drawn (now − RENDER_DELAY_SEC),
+   *  less the newest recorded points inside its 3D model. */
+
+  function _trailBodyCountNow() {
+    return trailBodyCountOutsideModel(
+      flightState._trailFixes,
+      trailBodyCount(
+        flightState._trailFixes,
+        flightState.now() - RENDER_DELAY_SEC * 1000,
+      ),
+      parts.motion._trackedModelCenterWorld(),
+      parts.motion._trackedModelEnvelopeM(),
     );
   }
 
@@ -377,21 +474,24 @@ export function createTracking({
 
   function _startTrail(icao24) {
     flightState._trailBackfillToken += 1;
-    flightState._trailPositions = [];
+    flightState._trailFixes = [];
+    flightState._trailRecordPosition = null;
+    flightState._trailRecordMs = -Infinity;
     const history = flightState._positionHistory.get(icao24) || [];
-    // Seed only fixes at/behind the DELAYED display time (now − RENDER_DELAY_SEC). The
-    // newest ~RENDER_DELAY_SEC of fixes are AHEAD of the displayed icon; including them
-    // would draw the trail in front of the plane. They join the trail via _appendTrailFix
-    // as they age past the delay.
-    const seedRenderTime = Cesium.JulianDate.addSeconds(
-      julianAt(flightState.now()),
-      -RENDER_DELAY_SEC,
-      flightState._scratchWarmupTime,
-    );
+    // Seed every report. The body only draws those at or before the delayed
+    // display time (now − RENDER_DELAY_SEC); newer ones join it as the display
+    // passes them. A synthetic forward fix (it carries `reportEpochMs`) is a
+    // motion aid, never a report. A report drawn at an invented height keeps
+    // no position and breaks the line.
     for (const fix of history) {
-      if (Cesium.JulianDate.lessThanOrEquals(fix.time, seedRenderTime)) {
-        flightState._trailPositions.push(Cesium.Cartesian3.clone(fix.position));
-      }
+      if (Number.isFinite(fix.reportEpochMs)) continue;
+      insertTrailFix(
+        flightState._trailFixes,
+        Cesium.Cartesian3.clone(fix.position),
+        historyFixEpochMs(fix),
+        TRAIL_MAX_POINTS,
+        { nullAltitude: fix.inventedHeight === true },
+      );
     }
     if (!flightState._trail && flightState._viewer) {
       flightState._trail = createTrail(flightState._viewer, {
@@ -412,14 +512,13 @@ export function createTracking({
         show: !flightState._cockpitContactMode,
         polyline: {
           positions: new Cesium.CallbackProperty(() => {
-            // Need ≥2 accumulated points: the body draws all-but-newest, so the head must
-            // start at the last DISPLAYED body point (index n−2). With a single fix that
-            // point would be the sole raw fix — which is ~now, AHEAD of the delayed icon —
-            // so the segment would draw IN FRONT of the plane. Likewise during warm-up the
-            // icon predates all real history, so there is no valid body point behind it.
+            // The head starts at the last DISPLAYED body point, the newest fix at or
+            // before the delayed display time; a fix ahead of the icon would draw the
+            // segment IN FRONT of the plane. During warm-up the icon predates all real
+            // history, so there is no valid body point behind it.
             if (
               !flightState._trackedIcao ||
-              flightState._trailPositions.length < 2 ||
+              !flightState._trailFixes.length ||
               parts.motion._isTrackWarmingUp()
             )
               return [];
@@ -427,12 +526,19 @@ export function createTracking({
               parts.motion._trackedTrailCached() ||
               parts.motion._trackedDisplayPosition(flightState._trackedIcao);
             if (!head) return [];
-            // body[n−2] (last displayed body point) → delayed head: runs FORWARD, never a
-            // backward/reversing segment.
-            const start =
-              flightState._trailPositions[
-                flightState._trailPositions.length - 2
-              ];
+            // The last body point (a report, or where the icon was drawn a
+            // moment ago) → the icon. The body is moved on by _trailTick, never
+            // here: a callback must not add or remove entities.
+            // No head across a break: a body point more than 150 km away, or
+            // too long ago or too far to be one path, stays detached; none while
+            // the aircraft holds at its last point.
+            const last = trailHeadStartFix(
+              flightState._trailFixes,
+              head,
+              flightState.now(),
+              flightState._trailBodyCount,
+            );
+            if (!last) return [];
             // On a contact that has not moved this segment runs from inside the
             // model out to its own anchor — a line through the fuselage. The END
             // never gives, so a moving trail still terminates on the tail; the
@@ -441,7 +547,7 @@ export function createTracking({
             // See trailHeadStart. Read `head` in place and clone only on the draw
             // path — a suppressed parked contact runs this every frame.
             const from = trailHeadStart(
-              start,
+              last.position,
               head,
               parts.motion._trackedModelCenterWorld(),
               parts.motion._trackedModelEnvelopeM(),
@@ -520,7 +626,13 @@ export function createTracking({
       const time = observedAtMs / 1000;
       if (!Number.isFinite(lat) || !Number.isFinite(lon)) continue;
       if (!Number.isFinite(time) || time >= oldestFixEpochSec) continue;
-      parsed.push({ lat, lon, baroAlt });
+      parsed.push({
+        lat,
+        lon,
+        baroAlt,
+        onGround: waypoint.onGround === true,
+        timeMs: observedAtMs,
+      });
     }
     if (!parsed.length) return;
 
@@ -543,27 +655,30 @@ export function createTracking({
     )
       return;
 
-    const older = [];
-    let lastAltM = null; // carry-forward for no-baro points whose cell isn't warm yet
-    for (const { lat, lon, baroAlt } of parsed) {
-      const baroM = Number.isFinite(baroAlt)
-        ? baroAlt + geoidHeight(lat, lon)
-        : null;
-      let altM = floorAltitudeM(baroM, cachedGroundFloor(lat, lon));
-      // No baro + unresolved floor: hold the previous waypoint's altitude
-      // (continuity — never a dive/spike to a made-up height). Leading points
-      // with nothing to carry keep the old 10 km airborne default.
-      if (altM == null) altM = lastAltM != null ? lastAltM : 10000;
-      lastAltM = altM;
-      older.push(Cesium.Cartesian3.fromDegrees(lon, lat, altM));
-    }
-
-    flightState._trailPositions = older.concat(flightState._trailPositions);
-    if (flightState._trailPositions.length > TRAIL_MAX_POINTS) {
-      flightState._trailPositions = flightState._trailPositions.slice(
-        flightState._trailPositions.length - TRAIL_MAX_POINTS,
-      );
-    }
+    // Every waypoint is kept, each leg its own segment. A ground waypoint is
+    // at altitude 0, floored at the ground. A waypoint with no altitude is a
+    // break on both sides: it sits on the ground where the floor is known and
+    // is skipped otherwise; a skipped point still breaks the line.
+    const backfill = trailBackfillFixes(
+      parsed.map(({ lat, lon, baroAlt, onGround, timeMs }) => {
+        const known = Number.isFinite(baroAlt) ? baroAlt : onGround ? 0 : null;
+        const altM = floorAltitudeM(
+          known == null ? null : known + geoidHeight(lat, lon),
+          cachedGroundFloor(lat, lon),
+        );
+        return {
+          position:
+            altM == null ? null : Cesium.Cartesian3.fromDegrees(lon, lat, altM),
+          timeMs,
+          nullAltitude: known == null,
+        };
+      }),
+    );
+    flightState._trailFixes = joinTrailBackfill(
+      backfill,
+      flightState._trailFixes,
+      TRAIL_MAX_POINTS,
+    );
     _refreshTrailDisplay();
   }
 
@@ -573,7 +688,9 @@ export function createTracking({
 
   function _clearTrail() {
     flightState._trailBackfillToken += 1;
-    flightState._trailPositions = [];
+    flightState._trailFixes = [];
+    flightState._trailRecordPosition = null;
+    flightState._trailRecordMs = -Infinity;
     if (flightState._trail) flightState._trail.clear();
     if (
       flightState._trailHeadEntity &&
@@ -737,14 +854,90 @@ export function createTracking({
     flightState._pendingTrackingRestore = null;
   }
 
+  /**
+   * The tracked plane's stale cue and whether it is drawn with the stale fade.
+   * - SIGNAL LOST · <time since its last report>, dimmed: its coast has ended
+   *   (or it holds at its last report after a missed update) and no newer
+   *   report has come.
+   * - STALE, dimmed: it has missed an update and still coasts.
+   * - STALE, not dimmed: the whole feed is backing off.
+   * @param {string} icao24
+   * @returns {{text: string, dimmed: boolean}}
+   */
+
+  function _trackedStaleCue(icao24) {
+    const records = flightState.records;
+    const misses = records.missingPolls.get(icao24) || 0;
+    const repeated = records.fixRepeated?.has(icao24) === true;
+    const backoff = flightState.feed._backoff === true;
+    // Computed once per frame for the label, the icon colour and the model
+    // fade; a poll between frames changes the key.
+    const frame = flightState._viewer?.scene?.frameState?.frameNumber;
+    const key = Number.isFinite(frame)
+      ? `${frame}|${icao24}|${misses}|${repeated}|${backoff}`
+      : null;
+    const cached = flightState._trackedStaleCueCache;
+    if (key !== null && cached?.key === key) return cached.cue;
+    const cue = _computeTrackedStaleCue(
+      icao24,
+      misses > 0 || repeated,
+      backoff,
+    );
+    flightState._trackedStaleCueCache = key === null ? null : { key, cue };
+    return cue;
+  }
+
+  /** `_trackedStaleCue` without the per-frame cache. A repeated fix counts as missed. */
+
+  function _computeTrackedStaleCue(icao24, missed, backoff) {
+    const lost = parts.motion._signalLost(icao24);
+    if (lost && (missed || !lost.holds)) {
+      const sec = Math.max(
+        0,
+        Math.floor((flightState.now() - lost.reportEpochMs) / 1000),
+      );
+      const time =
+        sec < 60
+          ? `${formatNumber(sec, { useGrouping: false })} ${unitLabel('s')}`
+          : `${formatNumber(Math.floor(sec / 60), { useGrouping: false })} ${unitLabel('min')}`;
+      return { text: t('SIGNAL LOST · {time}', { time }), dimmed: true };
+    }
+    if (missed) return { text: t('STALE'), dimmed: true };
+    if (backoff) return { text: t('STALE'), dimmed: false };
+    return { text: '', dimmed: false };
+  }
+
+  /** The tracked billboard's colour: cyan, faded while stale, clear while the 3D model is the visual. */
+
+  function _trackedIconColor() {
+    if (parts.rendering._modelOwnsVisual(flightState._trackedIcao))
+      return CYAN_TRANSPARENT;
+    return _trackedStaleCue(flightState._trackedIcao).dimmed
+      ? STALE_CYAN
+      : Cesium.Color.CYAN;
+  }
+
+  /**
+   * Re-word the tracked label when its stale cue changes (STALE, SIGNAL LOST,
+   * each new second or minute of it). Run from the layer's per-frame pass.
+   */
+
+  function _staleCueTick() {
+    const icao24 = flightState._trackedIcao;
+    if (!icao24 || !flightState._trackedEntity) return;
+    const text = _trackedStaleCue(icao24).text;
+    if (text === flightState._trackedStaleCueText) return;
+    flightState._trackedStaleCueText = text;
+    _updateTrackedLabelModel(icao24);
+  }
+
   /** Multi-line tracked presentation text: "CS · FL · kts" + "Airline · Type" +
    *  "ORIG → DEST". The route line is gated by
    *  routePlausible so a wrong-leg adsbdb route is hidden, not displayed.
-   *  While the plane is in its missed-poll grace (coasting on dead reckoning
-   *  with sticky metadata), the first line carries a "· STALE" cue — the fleet's
-   *  45%-alpha billboard fade doesn't apply to the tracked plane (its entity
-   *  owns the visual), so without this the readout would present last-known
-   *  velocity/altitude as live. */
+   *  The first line carries the stale cue (`_trackedStaleCue`): STALE while
+   *  the plane coasts on dead reckoning after a missed update, SIGNAL LOST
+   *  once the coast has ended, so last-known velocity/altitude are never
+   *  presented as live. */
 
   function _trackedLabelText(icao24) {
     const info = flightState.records.data.get(icao24);
@@ -765,10 +958,7 @@ export function createTracking({
     const spd = info.velocity
       ? quantity(Math.round(info.velocity * 1.944), 'kts')
       : '';
-    const stale =
-      flightState.records.missingPolls.get(icao24) || flightState.feed._backoff
-        ? t('STALE')
-        : '';
+    const stale = _trackedStaleCue(icao24).text;
     const lines = [[cs, fl, spd, stale].filter(Boolean).join(' · ')];
     // Converted contacts report their class as TR-3B and nothing else — the
     // operator/type identity is exactly what the Easter egg is replacing.
@@ -967,15 +1157,9 @@ export function createTracking({
           CLASS_SCALE_2D[
             flightState.records.data.get(flightState._trackedIcao)?.klass
           ] || 1,
-        // Solid cyan when the billboard is the visual (zoomed out, 3D off, or model still loading);
-        // transparent once the STANDALONE tracked model is actually up (ready + shown).
-        color: new Cesium.CallbackProperty(
-          () =>
-            parts.rendering._modelOwnsVisual(flightState._trackedIcao)
-              ? CYAN_TRANSPARENT
-              : Cesium.Color.CYAN,
-          false,
-        ),
+        // Solid cyan (faded while stale) when the billboard is the visual (zoomed out, 3D off,
+        // or model still loading); transparent once the STANDALONE tracked model is actually up.
+        color: new Cesium.CallbackProperty(_trackedIconColor, false),
         sizeInMeters: false,
         scaleByDistance: new Cesium.NearFarScalar(1000, 3.0, 8000000, 0.5),
         alignedAxis: Cesium.Cartesian3.ZERO,
@@ -1257,6 +1441,7 @@ export function createTracking({
     _trackedModelRegimeActive,
     _syncTracked2dRotation,
     _appendTrailFix,
+    _trailTick,
     _refreshTrailDisplay,
     _startTrail,
     _backfillTrail,
@@ -1267,6 +1452,9 @@ export function createTracking({
     _applyPendingTrackingRestore,
     _cancelPendingTrackingRestore,
     _trackedLabelText,
+    _trackedStaleCue,
+    _trackedIconColor,
+    _staleCueTick,
     _updateTrackedLabelModel,
     _syncTrackedBillboardImage,
     _refreshTr3bContact,
diff --git a/src/layers/flights/trail.test.mjs b/src/layers/flights/trail.test.mjs
new file mode 100644
index 000000000..200f97db0
--- /dev/null
+++ b/src/layers/flights/trail.test.mjs
@@ -0,0 +1,414 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createFlightState } from './state.js';
+import { createTracking } from './tracking.js';
+import { TRAIL_MAX_POINTS } from './policy.js';
+import { trailHeadJoins, trailPairBreaks } from '../../data/trailContinuity.js';
+
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+const NM = 1852;
+
+function services({ trails, floor = () => null } = {}) {
+  const names = [
+    'picking',
+    'sprites',
+    'aircraftPresentation',
+    'camera',
+    'militaryRegistry',
+    'labels',
+    'meshFloor',
+    'focus',
+    'readout',
+    'context',
+    'render',
+    'recession',
+  ];
+  return {
+    ...Object.fromEntries(names.map((name) => [name, {}])),
+    groundSnap: { createGroundSnap: () => ({ clear() {} }) },
+    trails,
+    geoid: { ensureGeoidReady: async () => {}, geoidHeight: () => 0 },
+    groundFloor: {
+      resolveGroundFloorCellsBounded: async () => {},
+      cachedGroundFloor: floor,
+      floorAltitudeM: (alt, ground) =>
+        Number.isFinite(alt)
+          ? alt
+          : Number.isFinite(ground)
+            ? ground + 1
+            : null,
+    },
+  };
+}
+
+/** A fake trail that records every segment list it is given. */
+function recordingTrail() {
+  const calls = [];
+  return {
+    calls,
+    // What draws: a lone point is a segment with no line.
+    last: () =>
+      (calls[calls.length - 1] ?? []).filter((segment) => segment.length >= 2),
+    createTrail: () => ({
+      setSegments(segments) {
+        calls.push(segments.map((segment) => segment.slice()));
+      },
+      setPositions(positions) {
+        calls.push([positions.slice()]);
+      },
+      setVisible() {},
+      clear() {
+        calls.push([]);
+      },
+      destroy() {},
+    }),
+  };
+}
+
+function viewer() {
+  const added = [];
+  return {
+    added,
+    isDestroyed: () => false,
+    entities: {
+      add(definition) {
+        added.push(definition);
+        return definition;
+      },
+      remove() {},
+    },
+  };
+}
+
+/**
+ * A tracked aircraft whose live history holds `liveFixes` ({timeMs, lat, lon}),
+ * with a track endpoint answering `waypoints`.
+ */
+function trackedHarness({
+  liveFixes = [],
+  waypoints = null,
+  nowMs,
+  floor,
+  head = null,
+} = {}) {
+  const trail = recordingTrail();
+  const svc = services({ trails: trail, floor });
+  const flightState = createFlightState({
+    services: svc,
+    source: {
+      label: 'Fixture aircraft',
+      async getTrack() {
+        if (!waypoints) throw new Error('404');
+        return { records: waypoints };
+      },
+    },
+  });
+  const v = viewer();
+  flightState._viewer = v;
+  flightState._trackedIcao = 'abc123';
+  flightState.now = () => nowMs;
+  flightState._positionHistory.set(
+    'abc123',
+    liveFixes.map((fix) => ({
+      time: Cesium.JulianDate.fromDate(new Date(fix.timeMs)),
+      epochMs: fix.timeMs,
+      position: Cesium.Cartesian3.fromDegrees(fix.lon, fix.lat, 10_000),
+    })),
+  );
+  const tracking = createTracking({
+    flightState,
+    services: svc,
+    parts: {
+      motion: {
+        _isTrackWarmingUp: () => false,
+        _trackedTrailCached: () => head,
+        _trackedDisplayPosition: () => head,
+        _trackedModelCenterWorld: () => null,
+        _trackedModelEnvelopeM: () => null,
+      },
+    },
+    layer: {},
+  });
+  return { trail, tracking, flightState, viewer: v };
+}
+
+const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+function waypoint(timeMs, lat, lon, baroAltitudeM = 10_000) {
+  return { observedAtMs: timeMs, latitude: lat, longitude: lon, baroAltitudeM };
+}
+
+/** `count` waypoints one minute apart flying east at ~420 kt from (lat, lon). */
+function leg(startMs, lat, lon, count) {
+  return Array.from({ length: count }, (_, i) =>
+    waypoint(startMs + i * MINUTE, lat, lon + i * 0.12),
+  );
+}
+
+function headPositions(v) {
+  const entity = v.added.find((definition) =>
+    String(definition.id).startsWith('gev-trail:fl-head-'),
+  );
+  return entity.polyline.positions.getValue();
+}
+
+test('a pair 40 minutes and 300 km apart stays joined', () => {
+  assert.equal(trailPairBreaks(40 * MINUTE, 300_000), false);
+});
+
+test('a pair 1 minute and 200 km apart breaks: faster than 1,500 kt', () => {
+  assert.equal(trailPairBreaks(MINUTE, 200_000), true);
+});
+
+test('a gap longer than 48 minutes breaks, and time that does not advance breaks', () => {
+  assert.equal(trailPairBreaks(49 * MINUTE, 10_000), true);
+  assert.equal(trailPairBreaks(48 * MINUTE, 10_000), false);
+  assert.equal(trailPairBreaks(0, 0), true);
+  assert.equal(trailPairBreaks(-MINUTE, 100), true);
+});
+
+test('a parked aircraft two hours apart within 0.1 nm stays joined', () => {
+  assert.equal(trailPairBreaks(2 * HOUR, 0.09 * NM), false);
+  assert.equal(trailPairBreaks(3 * HOUR + MINUTE, 0.09 * NM), true);
+  assert.equal(trailPairBreaks(2 * HOUR, 0.2 * NM), true);
+});
+
+test('the head joins within 150 km under the time and speed test', () => {
+  assert.equal(trailHeadJoins(30_000, 5_000), true);
+  assert.equal(trailHeadJoins(30 * MINUTE, 151_000), false);
+  assert.equal(trailHeadJoins(HOUR, 5_000), false);
+});
+
+test('a backfill with gaps of 10 h, 2 h, 1.2 h and 6.5 h draws five segments and no line across a gap', async () => {
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  const legs = [];
+  let start = t0;
+  const gaps = [10 * HOUR, 2 * HOUR, 1.2 * HOUR, 6.5 * HOUR];
+  const anchors = [
+    [30, 31],
+    [12, 0],
+    [14, -15],
+    [20, -40],
+    [35, -75],
+  ];
+  for (let i = 0; i < anchors.length; i++) {
+    const points = leg(start, anchors[i][0], anchors[i][1], 6);
+    legs.push(points);
+    start = points[points.length - 1].observedAtMs + (gaps[i] ?? 0);
+  }
+  const waypoints = legs.flat();
+  const lastLeg = legs[legs.length - 1];
+  const liveStart = lastLeg[lastLeg.length - 1].observedAtMs + MINUTE;
+  const liveFixes = [0, 1, 2].map((i) => ({
+    timeMs: liveStart + i * MINUTE,
+    lat: 35,
+    lon: -75 + 0.72 + i * 0.12,
+  }));
+  const nowMs = liveStart + 3 * MINUTE;
+  const { trail, tracking, flightState } = trackedHarness({
+    liveFixes,
+    waypoints,
+    nowMs,
+  });
+  tracking._startTrail('abc123');
+  await settle();
+
+  assert.equal(flightState._trailFixes.length, waypoints.length + 3);
+  const segments = trail.last();
+  assert.equal(segments.length, 5);
+  const bodyCount = segments.reduce((sum, segment) => sum + segment.length, 0);
+  // The body draws every fix at or before the display time: all of them here.
+  assert.equal(bodyCount, waypoints.length + 3);
+  for (const [index, segment] of segments.entries()) {
+    const expected = legs[index].map((point) =>
+      Cesium.Cartesian3.fromDegrees(point.longitude, point.latitude, 10_000),
+    );
+    for (const position of segment.slice(0, expected.length)) {
+      assert.ok(
+        expected.some((e) => Cesium.Cartesian3.distance(e, position) < 1),
+        `segment ${index} holds a point from another leg`,
+      );
+    }
+  }
+});
+
+test('a null-altitude waypoint breaks the line, and nothing is drawn at 10 km', async () => {
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  const waypoints = leg(t0, 40, 10, 6);
+  waypoints[3] = waypoint(waypoints[3].observedAtMs, 40, 10.36, null);
+  const nowMs = t0 + 8 * MINUTE;
+  const liveFixes = [
+    { timeMs: t0 + 6 * MINUTE, lat: 40, lon: 10.72 },
+    { timeMs: t0 + 7 * MINUTE, lat: 40, lon: 10.84 },
+  ];
+
+  // Unknown floor: the null point is skipped, and the line still breaks there.
+  const skipped = trackedHarness({ liveFixes, waypoints, nowMs });
+  skipped.tracking._startTrail('abc123');
+  await settle();
+  assert.equal(
+    skipped.flightState._trailFixes.length,
+    waypoints.length - 1 + 2,
+  );
+  const segments = skipped.trail.last();
+  assert.deepEqual(
+    segments.map((segment) => segment.length),
+    [3, 4],
+  );
+  for (const segment of segments) {
+    for (const position of segment) {
+      const height = Cesium.Cartographic.fromCartesian(position).height;
+      assert.ok(Math.abs(height - 10_000) < 1, 'only real altitudes drawn');
+    }
+  }
+
+  // Known floor: the point is kept on the ground, alone, joined to nothing.
+  const grounded = trackedHarness({
+    liveFixes,
+    waypoints,
+    nowMs,
+    floor: () => 120,
+  });
+  grounded.tracking._startTrail('abc123');
+  await settle();
+  assert.equal(grounded.flightState._trailFixes.length, waypoints.length + 2);
+  assert.deepEqual(
+    grounded.trail.last().map((segment) => segment.length),
+    [3, 4],
+  );
+  const kept = grounded.flightState._trailFixes[3];
+  assert.ok(
+    Math.abs(Cesium.Cartographic.fromCartesian(kept.position).height - 121) < 1,
+  );
+});
+
+test('a history tail far from the first live fix does not connect to it', async () => {
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  // History ends 20 minutes before the first live fix, 1,400 km away.
+  const waypoints = leg(t0, 50, 0, 5);
+  const liveStart = t0 + 24 * MINUTE;
+  const liveFixes = [0, 1, 2].map((i) => ({
+    timeMs: liveStart + i * MINUTE,
+    lat: 50,
+    lon: 20 + i * 0.12,
+  }));
+  const { trail, tracking } = trackedHarness({
+    liveFixes,
+    waypoints,
+    nowMs: liveStart + 3 * MINUTE,
+  });
+  tracking._startTrail('abc123');
+  await settle();
+  assert.deepEqual(
+    trail.last().map((segment) => segment.length),
+    [5, 3],
+  );
+});
+
+test('the head is drawn to a nearby aircraft and not to one more than 150 km away', () => {
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  const liveFixes = [0, 1, 2].map((i) => ({
+    timeMs: t0 + i * MINUTE,
+    lat: 50,
+    lon: 1 + i * 0.12,
+  }));
+  const near = Cesium.Cartesian3.fromDegrees(1.3, 50, 10_000);
+  const joined = trackedHarness({
+    liveFixes,
+    nowMs: t0 + 3 * MINUTE,
+    head: near,
+  });
+  joined.tracking._startTrail('abc123');
+  const drawn = headPositions(joined.viewer);
+  assert.equal(drawn.length, 2);
+  assert.ok(Cesium.Cartesian3.distance(drawn[1], near) < 1e-6);
+
+  const far = Cesium.Cartesian3.fromDegrees(4, 50, 10_000);
+  const detached = trackedHarness({
+    liveFixes,
+    nowMs: t0 + 3 * MINUTE,
+    head: far,
+  });
+  detached.tracking._startTrail('abc123');
+  assert.deepEqual(headPositions(detached.viewer), []);
+
+  // An hour without a fix: the head no longer joins the last body point.
+  const stale = trackedHarness({ liveFixes, nowMs: t0 + HOUR, head: near });
+  stale.tracking._startTrail('abc123');
+  assert.deepEqual(headPositions(stale.viewer), []);
+});
+
+test('a live fix after a one-hour feed gap starts a new segment', () => {
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  const liveFixes = [0, 1, 2].map((i) => ({
+    timeMs: t0 + i * MINUTE,
+    lat: 50,
+    lon: 1 + i * 0.12,
+  }));
+  const { trail, tracking, flightState } = trackedHarness({
+    liveFixes,
+    nowMs: t0 + 3 * MINUTE,
+  });
+  tracking._startTrail('abc123');
+  assert.deepEqual(
+    trail.last().map((segment) => segment.length),
+    [3],
+  );
+  const later = t0 + 2 * MINUTE + HOUR;
+  // The display time moves past the new fixes.
+  flightState.now = () => later + 3 * MINUTE;
+  for (const [i, lon] of [3, 3.12, 3.24].entries()) {
+    tracking._appendTrailFix(
+      Cesium.Cartesian3.fromDegrees(lon, 50, 10_000),
+      later + i * MINUTE,
+    );
+  }
+  assert.equal(flightState._trailFixes.length, 6);
+  assert.deepEqual(
+    trail.last().map((segment) => segment.length),
+    [3, 3],
+  );
+});
+
+test('every waypoint of a 24 h history survives, and the trail stays within TRAIL_MAX_POINTS', async () => {
+  // A full day at one fix per minute.
+  const day = 24 * 60;
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  const full = leg(t0, 10, -100, day);
+  const liveStart = t0 + day * MINUTE;
+  const liveFixes = [{ timeMs: liveStart, lat: 10, lon: -100 + day * 0.12 }];
+  const kept = trackedHarness({
+    liveFixes,
+    waypoints: full,
+    nowMs: liveStart + MINUTE,
+  });
+  kept.tracking._startTrail('abc123');
+  await settle();
+  assert.ok(TRAIL_MAX_POINTS >= day + 500);
+  assert.equal(kept.flightState._trailFixes.length, full.length + 1);
+  assert.deepEqual(
+    kept.trail.last().map((segment) => segment.length),
+    [day + 1],
+  );
+
+  const count = TRAIL_MAX_POINTS + 120;
+  const large = leg(
+    liveStart - count * MINUTE,
+    10,
+    -100 + (day - count) * 0.12,
+    count,
+  );
+  const capped = trackedHarness({
+    liveFixes,
+    waypoints: large,
+    nowMs: liveStart + MINUTE,
+  });
+  capped.tracking._startTrail('abc123');
+  await settle();
+  const fixes = capped.flightState._trailFixes;
+  assert.equal(fixes.length, TRAIL_MAX_POINTS);
+  // The oldest go first: the newest live fix is still the last point.
+  assert.equal(fixes[fixes.length - 1].timeMs, liveStart);
+});
diff --git a/src/layers/flights/trailRecord.test.mjs b/src/layers/flights/trailRecord.test.mjs
new file mode 100644
index 000000000..3dd5a6bdd
--- /dev/null
+++ b/src/layers/flights/trailRecord.test.mjs
@@ -0,0 +1,846 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createMotion } from './motion.js';
+import { createFlightState } from './state.js';
+import { createTracking } from './tracking.js';
+import { RENDER_DELAY_SEC, STALE_ALPHA } from './policy.js';
+
+// Between reports, a tracked trail is the path the icon was actually drawn
+// along: the real display position, recorded as the frames go by. These tests
+// drive the real motion and display path frame by frame.
+
+const SEC = 1000;
+const ICAO = '00a001';
+const T0 = Date.UTC(2026, 10, 9, 21, 0);
+
+function fix(timeMs, lat, lon, heightM, velocity, track) {
+  return {
+    time: Cesium.JulianDate.fromDate(new Date(timeMs)),
+    epochMs: timeMs,
+    position: Cesium.Cartesian3.fromDegrees(lon, lat, heightM),
+    velocity,
+    track,
+  };
+}
+
+function services(trail, ground) {
+  const names = [
+    'picking',
+    'sprites',
+    'aircraftPresentation',
+    'camera',
+    'militaryRegistry',
+    'labels',
+    'meshFloor',
+    'focus',
+    'readout',
+    'context',
+    'render',
+    'recession',
+  ];
+  return {
+    ...Object.fromEntries(names.map((name) => [name, {}])),
+    aircraftPresentation: {
+      isTr3b: () => false,
+      tr3bTypeLabel: (id, label) => label,
+    },
+    focus: {
+      nearFarScalarValueAtDistance: () => 1,
+      clearFocusTarget() {},
+      publishFocusTargetFromCachedPosition() {},
+    },
+    groundSnap: { createGroundSnap: () => ({ clear() {} }) },
+    trails: trail,
+    geoid: { ensureGeoidReady: async () => {}, geoidHeight: () => 0 },
+    groundFloor: {
+      resolveGroundFloorCellsBounded: async () => {},
+      cachedGroundFloor: ground,
+      stickyFloorCell: (lat, lon) => ({ lat, lon }),
+      neighborFloorM: () => null,
+      floorAltitudeM: (alt, g) =>
+        Number.isFinite(g) && Number.isFinite(alt)
+          ? Math.max(alt, g + 1.5)
+          : alt,
+    },
+  };
+}
+
+/**
+ * Real motion, real display position and real tracking over one contact.
+ * `frame()` runs one rendered frame: the layer's preRender work, then the
+ * head callback, as Cesium does.
+ */
+function harness({
+  fixes,
+  info,
+  nowMs,
+  ground = () => null,
+  envelopeM = null,
+}) {
+  const segmentsCalls = [];
+  let inHead = false;
+  const trail = {
+    createTrail: () => ({
+      setSegments(segments) {
+        assert.ok(
+          !inHead,
+          'the trail body was rebuilt inside the head callback',
+        );
+        segmentsCalls.push(segments.map((segment) => segment.slice()));
+      },
+      setPositions(positions) {
+        assert.ok(
+          !inHead,
+          'the trail body was rebuilt inside the head callback',
+        );
+        segmentsCalls.push([positions.slice()]);
+      },
+      setVisible() {},
+      clear() {},
+      destroy() {},
+    }),
+  };
+  const svc = services(trail, ground);
+  const flightState = createFlightState({
+    services: svc,
+    source: { label: 'Fixture aircraft' },
+  });
+  flightState.records.data.set(ICAO, info);
+  let frameNumber = 0;
+  const added = [];
+  let entityChanges = 0;
+  flightState._viewer = {
+    isDestroyed: () => false,
+    scene: {
+      frameState: {
+        get frameNumber() {
+          return frameNumber;
+        },
+      },
+    },
+    entities: {
+      add(definition) {
+        entityChanges += 1;
+        added.push(definition);
+        return definition;
+      },
+      remove() {
+        entityChanges += 1;
+      },
+    },
+  };
+  flightState._trackedIcao = ICAO;
+  let clock = nowMs;
+  flightState.now = () => clock;
+  flightState._positionHistory.set(ICAO, fixes);
+  const parts = {
+    rendering: { _modelOwnsVisual: () => false, _modelSpec: () => ({}) },
+    queries: { _contactLabel: (id, info) => info?.callsign || id },
+  };
+  parts.motion = createMotion({ flightState, services: svc, parts });
+  if (envelopeM != null) {
+    // A 3D model is the visual: its centre is the drawn position.
+    parts.motion._trackedModelCenterWorld = () =>
+      parts.motion._trackedDisplayCached();
+    parts.motion._trackedModelEnvelopeM = () => envelopeM;
+  }
+  const tracking = createTracking({
+    flightState,
+    services: svc,
+    parts,
+    layer: {},
+  });
+  parts.tracking = tracking;
+  const realDateNow = Date.now;
+  Date.now = () => clock;
+  const headEntity = () =>
+    added.find((definition) =>
+      String(definition.id).startsWith('gev-trail:fl-head-'),
+    );
+  const head = () => {
+    const before = entityChanges;
+    inHead = true;
+    try {
+      return headEntity().polyline.positions.getValue();
+    } finally {
+      inHead = false;
+      assert.equal(
+        entityChanges,
+        before,
+        'the head callback added or removed an entity',
+      );
+    }
+  };
+  /** Drawn icon positions, one per frame. */
+  const drawn = [];
+  const frame = ({ readHead = true } = {}) => {
+    frameNumber += 1;
+    tracking._trailTick();
+    const icon = parts.motion._trackedDisplayPosition(ICAO);
+    if (icon) drawn.push(Cesium.Cartesian3.clone(icon));
+    if (readHead) head();
+  };
+  const run = (toMs, { frameMs = 100, readHead = true } = {}) => {
+    while (clock < toMs) {
+      clock = Math.min(toMs, clock + frameMs);
+      frame({ readHead });
+    }
+  };
+  return {
+    flightState,
+    tracking,
+    motion: parts.motion,
+    head,
+    drawn,
+    run,
+    body: () => segmentsCalls.at(-1) ?? [],
+    bodyPoints: () => (segmentsCalls.at(-1) ?? []).flat(),
+    restore: () => {
+      Date.now = realDateNow;
+    },
+  };
+}
+
+/** Distance from p to the nearest point of a polyline. */
+function distanceToPath(p, path) {
+  let best = Infinity;
+  const ab = new Cesium.Cartesian3();
+  const ap = new Cesium.Cartesian3();
+  const closest = new Cesium.Cartesian3();
+  if (path.length === 1) return Cesium.Cartesian3.distance(p, path[0]);
+  for (let i = 1; i < path.length; i++) {
+    Cesium.Cartesian3.subtract(path[i], path[i - 1], ab);
+    Cesium.Cartesian3.subtract(p, path[i - 1], ap);
+    const len2 = Cesium.Cartesian3.magnitudeSquared(ab);
+    const t =
+      len2 > 0
+        ? Math.max(0, Math.min(1, Cesium.Cartesian3.dot(ap, ab) / len2))
+        : 0;
+    Cesium.Cartesian3.add(
+      path[i - 1],
+      Cesium.Cartesian3.multiplyByScalar(ab, t, closest),
+      closest,
+    );
+    best = Math.min(best, Cesium.Cartesian3.distance(p, closest));
+  }
+  return best;
+}
+
+/** No vertex turns the line back sharper than 120° over a short step. */
+function assertNoSpur(line, label) {
+  const u = new Cesium.Cartesian3();
+  const v = new Cesium.Cartesian3();
+  for (let i = 1; i < line.length - 1; i++) {
+    Cesium.Cartesian3.subtract(line[i], line[i - 1], u);
+    Cesium.Cartesian3.subtract(line[i + 1], line[i], v);
+    const lu = Cesium.Cartesian3.magnitude(u);
+    const lv = Cesium.Cartesian3.magnitude(v);
+    if (!(lu > 0 && lv > 0) || Math.min(lu, lv) > 500) continue;
+    const cos = Cesium.Cartesian3.dot(u, v) / (lu * lv);
+    assert.ok(
+      cos >= -0.5,
+      `${label}: spur at vertex ${i} of ${line.length} (turn ${(
+        (Math.acos(cos) * 180) /
+        Math.PI
+      ).toFixed(0)}°)`,
+    );
+  }
+}
+
+const indexOfPoint = (line, p) =>
+  line.findIndex((q) => Cesium.Cartesian3.distance(p, q) < 0.01);
+
+// A departing jet: four northbound climb reports, then a left turn through
+// west to south with no report while the icon flies it.
+function departure() {
+  const fixes = [
+    fix(T0, 37.6329, -122.3661, 213, 85, 8),
+    fix(T0 + 30 * SEC, 37.6542, -122.3616, 495, 95, 0),
+    fix(T0 + 60 * SEC, 37.6813, -122.3615, 808, 104, 350),
+    fix(T0 + 90 * SEC, 37.7066, -122.3755, 1257, 112, 340),
+  ];
+  const info = {
+    altitude: 1257,
+    renderAltitudeM: 1257,
+    rawLat: 37.7066,
+    rawLon: -122.3755,
+    velocity: 112,
+    true_track: 340,
+    turnRateDps: -2,
+    onGround: false,
+    wasAirborne: true,
+    lastContactEpochMs: T0 + 200 * SEC,
+  };
+  return { fixes, info };
+}
+
+test('a report newer than the display time arrives mid-turn: the trail between the two reports stays on the drawn arc', () => {
+  const { fixes, info } = departure();
+  const start = T0 + 90 * SEC + RENDER_DELAY_SEC * SEC;
+  const h = harness({ fixes, info, nowMs: start });
+  try {
+    h.tracking._startTrail(ICAO);
+    // 40 s of turn with no new report: the icon flies the arc.
+    h.run(start + 40 * SEC);
+    const arc = h.drawn.slice();
+    // The next report is where the plane really was 60 s after the last one,
+    // still ahead of the display time (normal 30 s delay, slow feed). The icon
+    // now interpolates the straight line between the two reports and is eased
+    // onto it.
+    const at60 = h.motion._deadReckon(
+      ICAO,
+      new Cesium.Cartesian3(),
+      Cesium.JulianDate.fromDate(new Date(T0 + 150 * SEC)),
+    );
+    const c = Cesium.Cartographic.fromCartesian(at60);
+    const report = fix(
+      T0 + 150 * SEC,
+      Cesium.Math.toDegrees(c.latitude),
+      Cesium.Math.toDegrees(c.longitude),
+      c.height,
+      112,
+      220,
+    );
+    fixes.push(report);
+    info.true_track = 220;
+    h.tracking._appendTrailFix(
+      Cesium.Cartesian3.clone(report.position),
+      report.epochMs,
+    );
+    // The display passes the new report.
+    h.run(start + 75 * SEC);
+    const line = h.bodyPoints();
+    const from = indexOfPoint(line, fixes[3].position);
+    const to = indexOfPoint(line, report.position);
+    assert.ok(from >= 0 && to > from, 'both reports are on the trail');
+    const between = line.slice(from, to + 1);
+    // Every vertex between the reports is where the icon was drawn...
+    const drawnPath = [fixes[3].position, ...h.drawn, report.position];
+    for (const vertex of between) {
+      const off = distanceToPath(vertex, drawnPath);
+      assert.ok(
+        off < 50,
+        `trail vertex ${off.toFixed(0)} m off the drawn path`,
+      );
+    }
+    // ...and the arc the icon flew is still there: no straight chord. (The
+    // arc strays far from the chord, so a chord would fail this.)
+    const chord = [fixes[3].position, report.position];
+    assert.ok(Math.max(...arc.map((p) => distanceToPath(p, chord))) > 300);
+    // The last 10 s of the arc are exempt: the correction pulled the icon back
+    // over them, and keeping them would fold the line back on itself.
+    for (const point of arc.slice(0, -100)) {
+      const off = distanceToPath(point, between);
+      assert.ok(off < 50, `drawn arc point ${off.toFixed(0)} m from the trail`);
+    }
+    assertNoSpur(line, 'trail');
+    assertNoSpur(h.head(), 'head');
+  } finally {
+    h.restore();
+  }
+});
+
+test('a fresh report after a hold resumes with no backward spur', () => {
+  const fixes = [0, 1, 2, 3].map((i) =>
+    fix(T0 + i * 15 * SEC, 40, -100 + i * 0.04, 10_000, 230, 90),
+  );
+  const info = {
+    altitude: 10_000,
+    renderAltitudeM: 10_000,
+    rawLat: 40,
+    rawLon: -100 + 0.12,
+    velocity: 230,
+    true_track: 90,
+    turnRateDps: 0,
+    onGround: false,
+    wasAirborne: true,
+    lastContactEpochMs: T0 + 45 * SEC,
+  };
+  const start = T0 + 45 * SEC + RENDER_DELAY_SEC * SEC;
+  const h = harness({ fixes, info, nowMs: start });
+  try {
+    h.tracking._startTrail(ICAO);
+    // The contact coasts five minutes, then holds; recording stops while it
+    // holds.
+    h.run(start + 320 * SEC);
+    const held = h.bodyPoints().length;
+    h.run(start + 360 * SEC);
+    assert.equal(h.bodyPoints().length, held, 'the trail grew during a hold');
+    // A fresh report, a little north of the track, ahead of the display.
+    const display = start + 360 * SEC - RENDER_DELAY_SEC * SEC;
+    // Just past where it held: five minutes and ten seconds at 230 m/s.
+    const aheadDeg = (230 * 310) / (111_320 * Math.cos((40 * Math.PI) / 180));
+    const fresh = fix(
+      display + 10 * SEC,
+      40.01,
+      -100 + 0.12 + aheadDeg,
+      10_000,
+      230,
+      80,
+    );
+    fixes.push(fresh);
+    info.lastContactEpochMs = fresh.epochMs;
+    h.tracking._appendTrailFix(
+      Cesium.Cartesian3.clone(fresh.position),
+      fresh.epochMs,
+    );
+    h.run(start + 390 * SEC);
+    assertNoSpur(h.bodyPoints(), 'trail');
+    assertNoSpur(h.head(), 'head');
+    assert.ok(indexOfPoint(h.bodyPoints(), fresh.position) >= 0);
+  } finally {
+    h.restore();
+  }
+});
+
+test('with the head hidden the body keeps advancing, and untracking clears the recording', () => {
+  const { fixes, info } = departure();
+  const start = T0 + 90 * SEC + RENDER_DELAY_SEC * SEC;
+  const h = harness({ fixes, info, nowMs: start });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(start + 5 * SEC);
+    const before = h.bodyPoints().at(-1);
+    // Cockpit view: the head is hidden and its callback never runs.
+    h.run(start + 30 * SEC, { readHead: false });
+    // The body's end keeps following the icon; straight stretches are thinned.
+    const end = h.bodyPoints().at(-1);
+    assert.ok(
+      Cesium.Cartesian3.distance(end, before) > 1_000,
+      'the body stopped advancing',
+    );
+    assert.ok(Cesium.Cartesian3.distance(end, h.drawn.at(-1)) < 300);
+    h.tracking._clearTrail();
+    assert.equal(h.flightState._trailFixes.length, 0);
+    // A new track of the same plane starts from reports only.
+    h.tracking._startTrail(ICAO);
+    assert.equal(
+      h.flightState._trailFixes.filter((entry) => entry.drawn).length,
+      0,
+    );
+  } finally {
+    h.restore();
+  }
+});
+
+test('a live fix with no altitude breaks the line and puts no point at an invented height', () => {
+  const { fixes, info } = departure();
+  const start = T0 + 90 * SEC + RENDER_DELAY_SEC * SEC;
+  const h = harness({ fixes, info, nowMs: start });
+  try {
+    h.tracking._startTrail(ICAO);
+    const invented = Cesium.Cartesian3.fromDegrees(-122.38, 37.71, 10_000);
+    h.tracking._appendTrailFix(invented, T0 + 95 * SEC, { nullAltitude: true });
+    const later = Cesium.Cartesian3.fromDegrees(-122.39, 37.715, 1400);
+    h.tracking._appendTrailFix(later, T0 + 100 * SEC);
+    h.run(T0 + 100 * SEC + RENDER_DELAY_SEC * SEC + SEC, { frameMs: 500 });
+    for (const point of h.bodyPoints())
+      assert.ok(Cesium.Cartographic.fromCartesian(point).height < 5_000);
+    // The reports on either side of it are not joined.
+    const segments = h.body();
+    const holding = (p) =>
+      segments.findIndex((segment) =>
+        segment.some((q) => Cesium.Cartesian3.distance(p, q) < 0.01),
+      );
+    assert.notEqual(holding(fixes[3].position), holding(later));
+  } finally {
+    h.restore();
+  }
+});
+
+test('with a 3D model as the visual, the trail stops outside the model and the head runs from there to the plane', () => {
+  const { fixes, info } = departure();
+  info.turnRateDps = 0;
+  const start = T0 + 90 * SEC + RENDER_DELAY_SEC * SEC;
+  const envelopeM = 300;
+  const h = harness({ fixes, info, nowMs: start, envelopeM });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(start + 30 * SEC);
+    const icon = h.drawn.at(-1);
+    const body = h.bodyPoints();
+    const head = h.head();
+    assert.ok(head.length >= 2, 'no head is drawn');
+    assert.ok(Cesium.Cartesian3.distance(head.at(-1), icon) < 0.01);
+    // No trail point inside the model, and the head starts where the body ends.
+    for (const point of body)
+      assert.ok(Cesium.Cartesian3.distance(point, icon) >= envelopeM - 1);
+    assert.ok(Cesium.Cartesian3.distance(head[0], body.at(-1)) < 0.01);
+    // Body and head together follow where the icon was drawn.
+    const line = body.concat(head);
+    for (const point of h.drawn) {
+      const off = distanceToPath(point, line);
+      assert.ok(off < 35, `drawn icon ${off.toFixed(0)} m off the trail`);
+    }
+  } finally {
+    h.restore();
+  }
+});
+
+test('a report the display already passed replaces the guess drawn after it, with no spike', () => {
+  const { fixes, info } = departure();
+  const start = T0 + 90 * SEC + RENDER_DELAY_SEC * SEC;
+  const h = harness({ fixes, info, nowMs: start });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(start + 40 * SEC);
+    const displayMs = T0 + 130 * SEC;
+    // A report for 10 s before the display time, 400 m inside the drawn arc.
+    const guess = h.motion._deadReckon(
+      ICAO,
+      new Cesium.Cartesian3(),
+      Cesium.JulianDate.fromDate(new Date(T0 + 120 * SEC)),
+    );
+    const c = Cesium.Cartographic.fromCartesian(guess);
+    const report = fix(
+      T0 + 120 * SEC,
+      Cesium.Math.toDegrees(c.latitude) - 400 / 111_320,
+      Cesium.Math.toDegrees(c.longitude),
+      c.height,
+      112,
+      250,
+    );
+    fixes.push(report);
+    info.true_track = 250;
+    h.tracking._appendTrailFix(
+      Cesium.Cartesian3.clone(report.position),
+      report.epochMs,
+    );
+    h.run(start + 55 * SEC);
+    const recorded = h.flightState._trailFixes.filter((entry) => entry.drawn);
+    // Nothing recorded between the report and the end of the ease.
+    assert.deepEqual(
+      recorded
+        .filter(
+          (entry) =>
+            entry.timeMs > report.epochMs && entry.timeMs < displayMs + 900,
+        )
+        .map((entry) => entry.timeMs - T0),
+      [],
+    );
+    const line = h.bodyPoints();
+    assert.ok(indexOfPoint(line, report.position) >= 0);
+    assertNoSpur(line, 'trail');
+  } finally {
+    h.restore();
+  }
+});
+
+test('a history report at an invented height is seeded with no position, and nothing is recorded next to it', () => {
+  const { fixes, info } = departure();
+  fixes[3].inventedHeight = true;
+  const start = T0 + 90 * SEC + RENDER_DELAY_SEC * SEC;
+  const h = harness({ fixes, info, nowMs: start });
+  try {
+    h.tracking._startTrail(ICAO);
+    const seeded = h.flightState._trailFixes.find(
+      (entry) => entry.timeMs === fixes[3].epochMs,
+    );
+    assert.equal(seeded.position, null);
+    assert.equal(seeded.nullAltitude, true);
+    h.run(start + 10 * SEC);
+    assert.equal(
+      h.flightState._trailFixes.filter((entry) => entry.drawn).length,
+      0,
+    );
+  } finally {
+    h.restore();
+  }
+});
+
+// A turboprop at FL210 flying east out of receiver coverage: its last
+// position is at T0 + 30 s, and contact goes on for four more minutes.
+function outOfCoverage() {
+  const fixes = [
+    fix(T0, 43, -108.1, 6_400, 140, 90),
+    fix(T0 + 30 * SEC, 43, -108.05, 6_400, 140, 90),
+  ];
+  const info = {
+    altitude: 6_400,
+    renderAltitudeM: 6_400,
+    rawLat: 43,
+    rawLon: -108.05,
+    velocity: 140,
+    true_track: 90,
+    callsign: 'TEST7',
+    turnRateDps: 0,
+    onGround: false,
+    wasAirborne: true,
+    lastContactEpochMs: T0 + 30 * SEC + 240 * SEC,
+  };
+  return { fixes, info };
+}
+
+/** Display time (ms) `afterSec` past the last report. */
+const pastReport = (afterSec) =>
+  T0 + 30 * SEC + RENDER_DELAY_SEC * SEC + afterSec * SEC;
+
+test('a plane that stops reporting keeps moving dimmed as STALE from its first missed update, then stops as SIGNAL LOST', () => {
+  const { fixes, info } = outOfCoverage();
+  const h = harness({ fixes, info, nowMs: pastReport(-5) });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(pastReport(30));
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: '',
+      dimmed: false,
+    });
+    assert.equal(h.tracking._trackedIconColor().alpha, 1);
+    // The first missed update.
+    h.flightState.records.missingPolls.set(ICAO, 1);
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: 'STALE',
+      dimmed: true,
+    });
+    assert.match(h.tracking._trackedLabelText(ICAO), /STALE/);
+    // Drawn with the fleet's stale fade.
+    assert.equal(h.tracking._trackedIconColor().alpha, STALE_ALPHA);
+    // Still moving well past 90 s.
+    h.run(pastReport(200));
+    assert.ok(
+      Cesium.Cartesian3.distance(h.drawn.at(-1), h.drawn.at(-11)) > 100,
+    );
+    // The coast ends 300 s past the report; the plane stops there.
+    h.run(pastReport(310));
+    const recorded = h.flightState._trailFixes.filter((e) => e.drawn).length;
+    h.run(pastReport(330));
+    assert.ok(
+      Cesium.Cartesian3.distance(h.drawn.at(-1), h.drawn.at(-50)) < 0.01,
+    );
+    assert.equal(
+      h.flightState._trailFixes.filter((e) => e.drawn).length,
+      recorded,
+      'the trail kept recording a stopped plane',
+    );
+    // 330 s of display past the report is 330 s + the display delay of wall time.
+    const minutes = Math.floor((330 + RENDER_DELAY_SEC) / 60);
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: `SIGNAL LOST · ${minutes} min`,
+      dimmed: true,
+    });
+    assert.match(
+      h.tracking._trackedLabelText(ICAO),
+      new RegExp(`SIGNAL LOST · ${minutes} min`),
+    );
+  } finally {
+    h.restore();
+  }
+});
+
+test('a plane held at its last report shows SIGNAL LOST in seconds under a minute', () => {
+  // Its last report is 100 m above a known ground height: it holds there.
+  const { fixes, info } = outOfCoverage();
+  const h = harness({
+    fixes,
+    info,
+    nowMs: pastReport(-5),
+    ground: () => 6_300,
+  });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.flightState.records.missingPolls.set(ICAO, 1);
+    h.run(pastReport(10));
+    assert.ok(10 + RENDER_DELAY_SEC < 60);
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: `SIGNAL LOST · ${10 + RENDER_DELAY_SEC} s`,
+      dimmed: true,
+    });
+  } finally {
+    h.restore();
+  }
+});
+
+test('a report arriving 200 s into a coast: the plane eases onto it and the trail drops what was drawn after it', () => {
+  const { fixes, info } = outOfCoverage();
+  const h = harness({ fixes, info, nowMs: pastReport(-5) });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(pastReport(200));
+    // Heard again: the report is for 10 s before the display time, 2 km north
+    // of where the coast put it.
+    const at = T0 + 30 * SEC + 190 * SEC;
+    const guess = h.motion._deadReckon(
+      ICAO,
+      new Cesium.Cartesian3(),
+      Cesium.JulianDate.fromDate(new Date(at)),
+    );
+    const c = Cesium.Cartographic.fromCartesian(guess);
+    const report = fix(
+      at,
+      Cesium.Math.toDegrees(c.latitude) + 2_000 / 111_320,
+      Cesium.Math.toDegrees(c.longitude),
+      c.height,
+      140,
+      90,
+    );
+    fixes.push(report);
+    h.tracking._appendTrailFix(
+      Cesium.Cartesian3.clone(report.position),
+      report.epochMs,
+    );
+    assert.deepEqual(
+      h.flightState._trailFixes.filter(
+        (e) => e.drawn && e.timeMs > report.epochMs,
+      ),
+      [],
+    );
+    const from = h.drawn.length;
+    h.run(pastReport(203));
+    const after = h.drawn.slice(from - 1);
+    for (let i = 1; i < after.length; i++)
+      assert.ok(
+        Cesium.Cartesian3.distance(after[i], after[i - 1]) < 400,
+        'the plane jumped instead of easing',
+      );
+    // Eased onto the path from the report: 13 s on from it at 140 m/s.
+    const off = Cesium.Cartesian3.distance(after.at(-1), report.position);
+    assert.ok(
+      Math.abs(off - 140 * 13) < 150,
+      `${off.toFixed(0)} m from the report`,
+    );
+  } finally {
+    h.restore();
+  }
+});
+
+test('a tracked plane that stops reporting: STALE from the first missed poll, SIGNAL LOST after the five-minute coast, kept at 9 min, removed at 10 min', () => {
+  const { fixes, info } = outOfCoverage();
+  const fixMs = fixes.at(-1).epochMs;
+  // Contact stops with the position: the plane left coverage.
+  info.lastContactEpochMs = fixMs;
+  info.newestFixMs = fixMs;
+  const h = harness({ fixes, info, nowMs: fixMs + 5 * SEC });
+  try {
+    h.tracking._startTrail(ICAO);
+    const records = h.flightState.records;
+    const polls = new Map();
+    let removedAtSec = null;
+    // A poll every 10 s that lists the plane without a position.
+    for (let afterSec = 10; afterSec <= 660; afterSec += 10) {
+      h.run(fixMs + afterSec * SEC, { frameMs: 500, readHead: false });
+      const result = records.absence(ICAO, {
+        complete: true,
+        retainIds: new Set([ICAO]),
+        likelyLanded: false,
+        tracked: true,
+      });
+      if (result === 'remove') {
+        removedAtSec = afterSec;
+        break;
+      }
+      polls.set(afterSec, {
+        cue: h.tracking._trackedStaleCue(ICAO),
+        drawn: Cesium.Cartesian3.clone(h.drawn.at(-1)),
+      });
+    }
+    // Wall time when the display reaches the end of the coast.
+    const coastEndSec = 300 + RENDER_DELAY_SEC;
+    for (const [afterSec, { cue }] of polls) {
+      if (afterSec <= coastEndSec) {
+        assert.deepEqual(cue, { text: 'STALE', dimmed: true }, `${afterSec} s`);
+      } else {
+        assert.deepEqual(
+          cue,
+          {
+            text: `SIGNAL LOST · ${Math.floor(afterSec / 60)} min`,
+            dimmed: true,
+          },
+          `${afterSec} s`,
+        );
+      }
+    }
+    const moved = (a, b) =>
+      Cesium.Cartesian3.distance(polls.get(a).drawn, polls.get(b).drawn);
+    // Moving through the coast, still at its last speed at four minutes.
+    assert.ok(Math.abs(moved(230, 240) - 140 * 10) < 20);
+    // Stopped once the coast has ended.
+    const after = Math.ceil(coastEndSec / 10) * 10;
+    assert.ok(moved(after, 540) < 0.01);
+    assert.equal(polls.get(300).cue.text, 'STALE');
+    assert.deepEqual(polls.get(540).cue, {
+      text: 'SIGNAL LOST · 9 min',
+      dimmed: true,
+    });
+    assert.equal(removedAtSec, 600);
+  } finally {
+    h.restore();
+  }
+});
+
+test('a repeated old fix counts as a missed update for the tracked plane', () => {
+  const { fixes, info } = outOfCoverage();
+  const h = harness({ fixes, info, nowMs: pastReport(-5) });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(pastReport(-2));
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: '',
+      dimmed: false,
+    });
+    // The feed re-sends the last position: its fix time did not advance.
+    h.flightState.records.fixRepeated.add(ICAO);
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: 'STALE',
+      dimmed: true,
+    });
+    assert.equal(h.tracking._trackedIconColor().alpha, STALE_ALPHA);
+    assert.equal(h.flightState.records.missingPolls.has(ICAO), false);
+  } finally {
+    h.restore();
+  }
+});
+
+test('a report arriving after the plane has stopped: it eases in with no spur, and the trail keeps everything up to the stop', () => {
+  const { fixes, info } = outOfCoverage();
+  info.lastContactEpochMs = fixes.at(-1).epochMs;
+  const h = harness({ fixes, info, nowMs: pastReport(-5) });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(pastReport(360));
+    const stop = Cesium.Cartesian3.clone(h.drawn.at(-1));
+    assert.ok(Cesium.Cartesian3.distance(stop, h.drawn.at(-100)) < 0.01);
+    const kept = h.flightState._trailFixes
+      .filter((e) => e.drawn)
+      .map((e) => Cesium.Cartesian3.clone(e.position));
+    // The thinned straight coast, recorded up to where the plane stopped.
+    assert.ok(kept.length >= 2);
+    assert.ok(Cesium.Cartesian3.distance(kept.at(-1), stop) < 300);
+    // Heard again, for 20 s before the display time: the plane flew on, a
+    // little north of its old heading.
+    const at = T0 + 30 * SEC + 340 * SEC;
+    const lonDeg =
+      -108.05 + (140 * 340) / (111_320 * Math.cos((43 * Math.PI) / 180));
+    const report = fix(at, 43 + 1_000 / 111_320, lonDeg, 6_400, 140, 90);
+    fixes.push(report);
+    h.tracking._appendTrailFix(
+      Cesium.Cartesian3.clone(report.position),
+      report.epochMs,
+    );
+    // Nothing was recorded after the stop, so nothing is dropped.
+    const after = h.flightState._trailFixes
+      .filter((e) => e.drawn)
+      .map((e) => e.position);
+    assert.equal(after.length, kept.length);
+    kept.forEach((p, i) =>
+      assert.ok(Cesium.Cartesian3.distance(p, after[i]) < 0.01),
+    );
+    const from = h.drawn.length;
+    h.run(pastReport(365));
+    const eased = h.drawn.slice(from - 1);
+    const jump = Cesium.Cartesian3.distance(eased[0], eased.at(-1));
+    for (let i = 1; i < eased.length; i++)
+      assert.ok(
+        Cesium.Cartesian3.distance(eased[i], eased[i - 1]) < jump / 2,
+        'the plane jumped instead of easing',
+      );
+    // On the path from the report: 25 s on from it at 140 m/s.
+    const off = Cesium.Cartesian3.distance(eased.at(-1), report.position);
+    assert.ok(Math.abs(off - 140 * 25) < 150, `${off.toFixed(0)} m`);
+    assertNoSpur(h.bodyPoints(), 'trail');
+    assertNoSpur(h.head(), 'head');
+    assert.ok(indexOfPoint(h.bodyPoints(), report.position) >= 0);
+  } finally {
+    h.restore();
+  }
+});
diff --git a/src/layers/military/motion.js b/src/layers/military/motion.js
index a13508e54..6a01e6c49 100644
--- a/src/layers/military/motion.js
+++ b/src/layers/military/motion.js
@@ -5,10 +5,14 @@ import {
   speedRamp,
   courseBetweenCartesians,
   COURSE_HOLD_SPEED_MPS,
+  floorCoastedPosition,
   staleCoastLimitSeconds,
+  staleCoastSecondsFrom,
+  staleHoldsForFix,
   arcOffsetEnu,
   courseSlewCapDps,
   limitCourseStep,
+  COAST_MAX_SPEED_MPS,
 } from '../../data/motionModel.js';
 import { CLASS_SCALE_2D } from '../../data/aircraftClass.js';
 import {
@@ -141,23 +145,86 @@ export function createMotion({
       );
     }
 
-    // Continue through fresh adsb.lol contacts even when the position epoch has
-    // not advanced, but keep an absolute stale-feed drift ceiling.
+    // Coast on the last speed and heading for five minutes past the newest
+    // fix, then stop, dimmed as SIGNAL LOST. A contact last heard on or near
+    // the ground holds there instead, and a coast never goes below the ground.
+    const { coastSec } = _coastPlan(newest, info, elapsedSec);
+    const cachedGroundFloor = services.groundFloor?.cachedGroundFloor;
+    _extrapolateFix(
+      newest,
+      info,
+      coastSec,
+      out,
+      (info && info.turnRateDps) || 0,
+    );
+    return coastSec > 0 ? floorCoastedPosition(out, cachedGroundFloor) : out;
+  }
+
+  /**
+   * How far a contact coasts past its newest fix at a display time
+   * `elapsedSec` after it: up to five minutes, or not at all for a contact
+   * that holds at a report on or near the ground. The hold decision is made once
+   * per report and kept on it.
+   * @param {{epochMs?: number, time: Cesium.JulianDate}} newest
+   * @param {object|undefined} info - The contact's record.
+   * @param {number} elapsedSec
+   * @returns {{coastSec: number, holds: boolean}}
+   */
+  function _coastPlan(newest, info, elapsedSec) {
     const coastLimitSec = staleCoastLimitSeconds({
-      // Captured at poll normalization so the fleet tick does not allocate a
-      // Date for every aircraft twelve times per second.
+      // `epochMs` is captured once when the poll is normalized. Avoid allocating
+      // a Date per aircraft on every fleet tick.
       fixEpochMs: Number.isFinite(newest.epochMs)
         ? newest.epochMs
         : Cesium.JulianDate.toDate(newest.time).getTime(),
       lastContactEpochMs: info?.lastContactEpochMs,
+      // Five minutes of flight after the last report, as flights.
+      minimumSec: 300,
+      maximumSec: 300,
     });
-    return _extrapolateFix(
+    const holds = staleHoldsForFix(newest, {
+      onGround: info?.onGround,
+      cachedGroundFloor: services.groundFloor?.cachedGroundFloor,
+    });
+    return {
+      coastSec: staleCoastSecondsFrom({
+        newest,
+        elapsedSec,
+        coastLimitSec,
+        holds,
+      }),
+      holds,
+    };
+  }
+
+  /**
+   * Whether a contact has stopped where its coast ended (or held at its last
+   * report) with no newer report, and since when it has had none.
+   * @param {string} icao24
+   * @returns {{reportEpochMs: number, holds: boolean}|null} Null while a
+   *   report is ahead of the display time or the contact is still coasting.
+   */
+  function _signalLost(icao24) {
+    const newest = flightState._positionHistory.get(icao24)?.at(-1);
+    if (!newest) return null;
+    const newestMs = Number.isFinite(newest.epochMs)
+      ? newest.epochMs
+      : Cesium.JulianDate.toDate(newest.time).getTime();
+    const elapsedSec =
+      (flightState.now() - RENDER_DELAY_SEC * 1000 - newestMs) / 1000;
+    if (!(elapsedSec > 0)) return null;
+    const { coastSec, holds } = _coastPlan(
       newest,
-      info,
-      Math.min(elapsedSec, coastLimitSec),
-      out,
-      (info && info.turnRateDps) || 0,
+      flightState.records.data.get(icao24),
+      elapsedSec,
     );
+    if (!(elapsedSec > coastSec)) return null;
+    return {
+      reportEpochMs: Number.isFinite(newest.reportEpochMs)
+        ? newest.reportEpochMs
+        : newestMs,
+      holds,
+    };
   }
 
   /**
@@ -172,9 +239,12 @@ export function createMotion({
    */
 
   function _extrapolateFix(fix, info, dt, out, turnRateDps = 0) {
-    const speed = Number.isFinite(fix.velocity)
-      ? fix.velocity
-      : (info && info.speedMps) || 0;
+    const speed = Math.min(
+      Number.isFinite(fix.velocity)
+        ? fix.velocity
+        : (info && info.speedMps) || 0,
+      COAST_MAX_SPEED_MPS,
+    );
     const heading = Number.isFinite(fix.track)
       ? fix.track
       : (info && info.track) || 0;
@@ -514,6 +584,7 @@ export function createMotion({
   }
   return {
     _deadReckon,
+    _signalLost,
     _extrapolateFix,
     _isTrackWarmingUp,
     _trackedFocusSizePx,
diff --git a/src/layers/military/policy.js b/src/layers/military/policy.js
index bb1d89127..da67bc9b6 100644
--- a/src/layers/military/policy.js
+++ b/src/layers/military/policy.js
@@ -172,7 +172,7 @@ export const TRAIL_COLOR = '#FFB800';
 
 /** @constant {number} Combined cap on trail vertices (backfill + live accumulation). */
 
-export const TRAIL_MAX_POINTS = 400;
+export const TRAIL_MAX_POINTS = 2000;
 
 // ---------------------------------------------------------------------------
 // Render-behind smoothing (mirrors flights.js): the fleet renders at
@@ -271,3 +271,6 @@ export const TRACKED_MODEL_RETRY_BACKOFF_MS = 1500;
  *  synchronously (single primitive). */
 
 export const IR_RELOAD_BATCH = 40;
+
+/** Alpha of a contact that has missed an update or lost its signal: the stale fade, for the fleet and the tracked aircraft alike. */
+export const STALE_ALPHA = 0.45;
diff --git a/src/layers/military/recordPolicy.js b/src/layers/military/recordPolicy.js
index 18f4a488d..3a72fa8ad 100644
--- a/src/layers/military/recordPolicy.js
+++ b/src/layers/military/recordPolicy.js
@@ -6,4 +6,8 @@ export const LANDED_MISSING_POLL_LIMIT = 1;
 
 export const MISSING_POLL_LIMIT = 3;
 
+/** The tracked contact is kept this long after its newest fix: five minutes
+ *  coasting, then five stopped as SIGNAL LOST. */
+export const TRACKED_RETENTION_MS = 10 * 60_000;
+
 export const ERROR_BACKOFF_INTERVAL = 20000;
diff --git a/src/layers/military/records.js b/src/layers/military/records.js
index 7198d62da..7b48e6f8b 100644
--- a/src/layers/military/records.js
+++ b/src/layers/military/records.js
@@ -6,6 +6,7 @@ import {
   GROUND_FLOOR_WARM_MAX_ALT_M,
   LANDED_MISSING_POLL_LIMIT,
   MISSING_POLL_LIMIT,
+  TRACKED_RETENTION_MS,
 } from './recordPolicy.js';
 
 /** Portable military aircraft metadata and bounded missing-poll retention. */
@@ -14,9 +15,44 @@ export class MilitaryFlightRecords {
     this.services = { geoidHeight, cachedGroundFloor, floorAltitudeM };
     this.data = new Map();
     this.missingPolls = new Map();
+    // Contacts whose last poll re-sent a fix no newer than the one before.
+    this.fixRepeated = new Set();
+    this.lastSnapshotMs = null;
+    this.snapshotAdvanced = true;
     this.geoidNCache = new Map();
     this.geoidReady = false;
   }
+  /**
+   * Start reading a snapshot taken at `observedAtMs`. A fix re-sent in a
+   * newer snapshot marks its contact as not updated; the same snapshot read
+   * again does not.
+   * @param {number} observedAtMs
+   */
+  beginSnapshot(observedAtMs) {
+    this.snapshotAdvanced =
+      !Number.isFinite(observedAtMs) ||
+      !Number.isFinite(this.lastSnapshotMs) ||
+      observedAtMs > this.lastSnapshotMs;
+    if (Number.isFinite(observedAtMs))
+      this.lastSnapshotMs = Math.max(
+        this.lastSnapshotMs ?? -Infinity,
+        observedAtMs,
+      );
+  }
+
+  /** Note a received fix: the newest fix time, and whether it advanced. */
+  _noteFix(id, prevMeta, fixEpochMs) {
+    const prevFixMs = prevMeta?.newestFixMs;
+    // A fix counts as new only when it moves on by a second: feeds that
+    // derive fix time from receipt (readsb `now − seen_pos`, 0.1 s) jitter.
+    if (!Number.isFinite(prevFixMs) || fixEpochMs >= prevFixMs + 1000) {
+      this.fixRepeated.delete(id);
+      return fixEpochMs;
+    }
+    if (this.snapshotAdvanced) this.fixRepeated.add(id);
+    return prevFixMs;
+  }
+
   receive(
     aircraft,
     { observedAtMs, floorWarmPoints: _floorWarmPoints, modelOwnsVisual },
@@ -88,6 +124,10 @@ export class MilitaryFlightRecords {
     // already uses (which also carries the on-ground 0 m / last-known-baro
     // case), so the two never disagree on the "no data yet" case.
     let renderAltitudeM = pickedAltM != null ? pickedAltM : altitudeM;
+    // No altitude for an airborne contact: the height is the airborne
+    // default, invented. The tracked trail keeps no point there.
+    const renderAltitudeInvented =
+      pickedAltM == null && !onGround && aircraft.baroAltitudeM == null;
     // Field-test fix (RS46 heli-in-hillside, 2026-07-06): a baro-only
     // AIRBORNE contact near steep terrain can compute a render height
     // BELOW the local surface (no alt_geom; baro+N carries QNH error
@@ -127,9 +167,11 @@ export class MilitaryFlightRecords {
     // Sticky merge — adsb.lol intermittently drops flight/t/r/ownOp; hold
     // last-known-good (bounded by the layer's eviction, which deletes the entry).
     const stickyType = stickyText(type, prevMeta?.type);
+    const fixEpochMs = aircraft.positionTimeMs ?? observedAtMs;
     const meta = {
       sourceReference: aircraft.reference,
       observedReceiptMs: Date.now(),
+      newestFixMs: this._noteFix(icao24, prevMeta, fixEpochMs),
       callsign: stickyText(callsign, prevMeta?.callsign),
       type: stickyType,
       // Type outranks category automatically inside classifyAircraft.
@@ -146,6 +188,7 @@ export class MilitaryFlightRecords {
       // altitudeFt/baro).
       geoAltitudeM,
       renderAltitudeM,
+      renderAltitudeInvented,
       // A poll that omits track/speed holds the last values, like the civil
       // records; 0 only until one is known. A grounded row without a speed
       // reads 0, so a parked plane never coasts at its landing speed.
@@ -184,10 +227,25 @@ export class MilitaryFlightRecords {
       prevMeta,
       meta,
       groundFlipped,
-      fixEpochMs: aircraft.positionTimeMs ?? observedAtMs,
+      fixEpochMs,
     };
   }
-  absence(id, { complete, retainIds, likelyLanded }) {
+  absence(id, { complete, retainIds, likelyLanded, tracked = false }) {
+    const misses = (this.missingPolls.get(id) || 0) + 1;
+    // The tracked contact has missed an update: it is stale from the first
+    // one, and kept (so the camera keeps its target) until ten minutes after
+    // its newest fix, whatever the snapshot says. With no fix time known it
+    // takes the ordinary limits below.
+    const meta = this.data.get(id);
+    const fixMs = meta?.newestFixMs ?? meta?.observedReceiptMs;
+    if (tracked && Number.isFinite(fixMs)) {
+      if (Date.now() - fixMs < TRACKED_RETENTION_MS) {
+        this.missingPolls.set(id, misses);
+        return 'stale';
+      }
+      this.missingPolls.delete(id);
+      return 'remove';
+    }
     // Partial admissions and position-less rows do not prove absence, but
     // retention remains bounded; a likely-landed position-less contact
     // still takes the landed limit.
@@ -196,7 +254,6 @@ export class MilitaryFlightRecords {
       Date.now() - (this.data.get(id)?.observedReceiptMs ?? 0) < 300000
     )
       return 'retain';
-    const misses = (this.missingPolls.get(id) || 0) + 1;
     const limit = likelyLanded ? LANDED_MISSING_POLL_LIMIT : MISSING_POLL_LIMIT;
     if (misses < limit) {
       this.missingPolls.set(id, misses);
@@ -208,6 +265,7 @@ export class MilitaryFlightRecords {
   forget(id) {
     this.data.delete(id);
     this.missingPolls.delete(id);
+    this.fixRepeated.delete(id);
     this.geoidNCache.delete(id);
   }
 }
diff --git a/src/layers/military/records.test.mjs b/src/layers/military/records.test.mjs
index 65a3b76c9..3d72aed21 100644
--- a/src/layers/military/records.test.mjs
+++ b/src/layers/military/records.test.mjs
@@ -174,3 +174,98 @@ test('military records hold the last track and speed when a poll omits them', ()
   assert.equal(parked.meta.speedMps, 0);
   assert.equal(parked.meta.track, 90);
 });
+
+test('an airborne military contact reported with no altitude is marked as drawn at an invented height', () => {
+  const records = store();
+  const none = records.receive(
+    observation({ baroAltitudeM: null, ellipsoidAltitudeM: null }),
+    context(),
+  );
+  assert.equal(none.meta.renderAltitudeInvented, true);
+  const known = records.receive(
+    observation({ positionTimeMs: 1700000005000 }),
+    context(),
+  );
+  assert.equal(known.meta.renderAltitudeInvented, false);
+  const parked = store().receive(
+    observation({ baroAltitudeM: null, onGround: true }),
+    context(),
+  );
+  assert.equal(parked.meta.renderAltitudeInvented, false);
+});
+
+test('the tracked military contact is stale from its first missed update and kept until ten minutes after its newest fix', () => {
+  const realNow = Date.now;
+  const fixMs = Date.UTC(2026, 10, 9, 20, 0);
+  let clock = fixMs + 5_000;
+  Date.now = () => clock;
+  try {
+    for (const snapshot of [
+      { complete: true },
+      { complete: true, retainIds: new Set(['aaa001']) },
+      { complete: false },
+    ]) {
+      const records = store();
+      records.receive(
+        observation({ positionTimeMs: fixMs }),
+        context({ observedAtMs: fixMs + 1_000 }),
+      );
+      const absent = (tracked) =>
+        records.absence('aaa001', {
+          ...snapshot,
+          likelyLanded: false,
+          tracked,
+        });
+      clock = fixMs + 15_000;
+      assert.equal(absent(true), 'stale');
+      assert.equal(records.missingPolls.get('aaa001'), 1);
+      clock = fixMs + 9 * 60_000;
+      assert.equal(absent(true), 'stale');
+      clock = fixMs + 10 * 60_000 - 1;
+      assert.equal(absent(true), 'stale');
+      clock = fixMs + 10 * 60_000;
+      assert.equal(absent(true), 'remove');
+      assert.equal(records.missingPolls.has('aaa001'), false);
+    }
+    const records = store();
+    records.receive(
+      observation({ positionTimeMs: fixMs }),
+      context({ observedAtMs: fixMs + 1_000 }),
+    );
+    clock = fixMs + 15_000;
+    const untracked = (snapshot) =>
+      records.absence('aaa001', { ...snapshot, likelyLanded: false });
+    assert.equal(untracked({ complete: false }), 'retain');
+    assert.deepEqual(
+      [1, 2, 3].map(() => untracked({ complete: true })),
+      ['stale', 'stale', 'remove'],
+    );
+  } finally {
+    Date.now = realNow;
+  }
+});
+
+test('a repeated military fix time marks the contact as not updated; removal is unchanged', () => {
+  const records = store();
+  const fixMs = Date.UTC(2026, 10, 9, 20, 0);
+  const poll = (snapshotMs, positionTimeMs) => {
+    records.beginSnapshot(snapshotMs);
+    records.receive(
+      observation({ positionTimeMs }),
+      context({ observedAtMs: snapshotMs }),
+    );
+  };
+  poll(fixMs + 2_000, fixMs);
+  assert.equal(records.fixRepeated.has('aaa001'), false);
+  // adsb.lol re-sends the last position for up to a minute.
+  poll(fixMs + 12_000, fixMs);
+  assert.equal(records.fixRepeated.has('aaa001'), true);
+  assert.equal(records.missingPolls.has('aaa001'), false);
+  poll(fixMs + 12_000, fixMs);
+  assert.equal(records.fixRepeated.has('aaa001'), true);
+  poll(fixMs + 22_000, fixMs + 10_000);
+  assert.equal(records.fixRepeated.has('aaa001'), false);
+  poll(fixMs + 32_000, fixMs + 10_000);
+  records.forget('aaa001');
+  assert.equal(records.fixRepeated.has('aaa001'), false);
+});
diff --git a/src/layers/military/rendering.js b/src/layers/military/rendering.js
index 504d79c80..d783bd4a4 100644
--- a/src/layers/military/rendering.js
+++ b/src/layers/military/rendering.js
@@ -52,6 +52,7 @@ import {
   COURSE_SLEW_DT_MAX_SEC,
   ROTATION_REFRESH_MS,
   COURSE_MAX_DPS,
+  STALE_ALPHA,
 } from './policy.js';
 import { AIRCRAFT_ENVIRONMENT_MAP_OPTIONS } from '../../data/aircraftModelLighting.js';
 
@@ -640,6 +641,19 @@ export function createRendering({
   /** Per-frame driver for the standalone tracked model (see flights.js for the rationale). The
    *  tracked entity stays a pure billboard, so the follow-camera never stalls/freezes on 3D-toggle. */
 
+  /** Fade the tracked 3D model like the billboard while the plane is stale. */
+
+  function _applyTrackedModelFade(model) {
+    const alpha = parts.tracking._trackedStaleCue?.(flightState._trackedIcao)
+      ?.dimmed
+      ? STALE_ALPHA
+      : 1;
+    if (model.color?.alpha === alpha) return;
+    model.color = (
+      flightState._irBoost ? Cesium.Color.WHITE : TRACKED_ICON_COLOR
+    ).withAlpha(alpha);
+  }
+
   function _updateTrackedModel() {
     const active =
       flightState._trackedIcao &&
@@ -787,6 +801,7 @@ export function createRendering({
         flightState._trackedModel.modelMatrix,
         spec.headingOffsetDeg,
       );
+      _applyTrackedModelFade(flightState._trackedModel);
       if (!flightState._trackedModel.ready) return;
       flightState._trackedModel.scale = trackedModelScaleForPixelCap({
         baseScale: spec.scale,
@@ -814,6 +829,13 @@ export function createRendering({
    */
 
   function _fleetTick() {
+    // Every frame, shown or not: the tracked trail records where its icon is
+    // drawn and moves its body on (the head callback only reads the result),
+    // and the tracked label's stale cue follows the clock.
+    if (flightState._viewer) {
+      parts.tracking._trailTick?.();
+      parts.tracking._staleCueTick?.();
+    }
     if (
       !flightState._viewer ||
       !flightState._billboardCollection ||
@@ -989,7 +1011,9 @@ export function createRendering({
           flightState._cockpitContactMode && !isCockpitNear
             ? 1
             : _militaryBillboardScale(icao24),
-        baseAlpha: flightState.records.missingPolls.get(icao24) ? 0.45 : 1,
+        baseAlpha: flightState.records.missingPolls.get(icao24)
+          ? STALE_ALPHA
+          : 1,
         baseColor,
         focusFactor: focus.factor,
         cameraDistanceM,
diff --git a/src/layers/military/snapshotRenderer.js b/src/layers/military/snapshotRenderer.js
index eb3a341f8..e674cc456 100644
--- a/src/layers/military/snapshotRenderer.js
+++ b/src/layers/military/snapshotRenderer.js
@@ -4,6 +4,7 @@ import { CLASS_SCALE_2D } from '../../data/aircraftClass.js';
 import {
   turnRateFromFixHistory,
   liftRepeatedGroundFix,
+  staleHoldsForFix,
   synthesizeForwardKinematicsFix,
 } from '../../data/motionModel.js';
 import { aircraftIcon } from '../../data/aircraftIcons.js';
@@ -29,6 +30,7 @@ export function createMilitarySnapshotRenderer({
   return function applySnapshot(snapshot, viewer) {
     const currentIcaos = new Set();
     const receiptNowMs = snapshot.observedAtMs;
+    records.beginSnapshot(snapshot.observedAtMs);
     // Field-test fix (RS46): coarse floor cells to warm for the below-ground
     // clamp — collected during the loop (low airborne contacts only),
     // batch-resolved once after it. Never a fetch inside the loop.
@@ -83,6 +85,9 @@ export function createMilitarySnapshotRenderer({
           position: position.clone(),
           velocity: meta.speedMps,
           track: meta.track,
+          // Drawn at an invented height: a trail seeded from history keeps no
+          // position for it.
+          inventedHeight: meta.renderAltitudeInvented === true,
         });
         if (history.length > POSITION_HISTORY_LIMIT) {
           history.shift();
@@ -95,26 +100,36 @@ export function createMilitarySnapshotRenderer({
         // (owner): ground traffic appends too — taxi history stays live
         // after touchdown; _appendTrailFix floors grounded positions at
         // the surface so the ground leg drapes instead of diving.
-        if (isTracked) tracking._appendTrailFix(position.clone());
+        if (isTracked)
+          tracking._appendTrailFix(position.clone(), fixEpochMs, {
+            nullAltitude: meta.renderAltitudeInvented === true,
+          });
       } else {
         const modelOwnsGroundVisual = rendering._modelOwnsVisual(icao24);
         if (!modelOwnsGroundVisual) {
           liftRepeatedGroundFix(newest, position, meta.onGround);
         }
+        // A forward synthetic fix follows the stale rules (none while the
+        // contact holds at its report, a coast capped from the real report,
+        // never below the ground) and is a motion aid, never a trail report.
         const kinematicsChanged =
           newest.velocity !== meta.speedMps || newest.track !== meta.track;
-        if (kinematicsChanged) {
+        const holds = staleHoldsForFix(newest, {
+          onGround: meta.onGround,
+          cachedGroundFloor,
+        });
+        if (kinematicsChanged && !holds) {
           const synthetic = synthesizeForwardKinematicsFix(newest, {
             epochMs: Date.now(),
             velocity: meta.speedMps,
             track: meta.track,
             turnRateDps: meta.turnRateDps,
+            cachedGroundFloor,
           });
           if (synthetic) {
             history.push(synthetic);
             if (history.length > POSITION_HISTORY_LIMIT) history.shift();
             meta.turnRateDps = turnRateFromFixHistory(history);
-            if (isTracked) tracking._appendTrailFix(synthetic.position.clone());
           }
         }
       }
@@ -261,6 +276,7 @@ export function createMilitarySnapshotRenderer({
         complete: snapshot.complete,
         retainIds: snapshot.retainIds,
         likelyLanded: queries._likelyLanded(icao24),
+        tracked: icao24 === flightState._trackedIcao,
       });
       if (absence === 'retain') continue;
       if (absence === 'stale') {
diff --git a/src/layers/military/snapshotStale.test.mjs b/src/layers/military/snapshotStale.test.mjs
new file mode 100644
index 000000000..13720b5d3
--- /dev/null
+++ b/src/layers/military/snapshotStale.test.mjs
@@ -0,0 +1,152 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createMilitarySnapshotRenderer } from './snapshotRenderer.js';
+
+// A poll that repeats a contact's last position with new speed or course
+// must not move it past where the stale rules allow, and never adds a
+// report to the tracked trail.
+
+const ICAO = '00a005';
+const SEC = 1000;
+
+/** Any property is a no-op function unless given. */
+function stub(overrides = {}) {
+  return new Proxy(overrides, {
+    get: (target, key) => (key in target ? target[key] : () => undefined),
+  });
+}
+
+function harness({ ground = () => null }) {
+  const appended = [];
+  const history = [];
+  const flightState = {
+    _trackedIcao: ICAO,
+    _trackedEntity: null,
+    _positionHistory: new Map([[ICAO, history]]),
+    _billboards: new Map([[ICAO, { position: new Cesium.Cartesian3() }]]),
+    _billboardCollection: stub(),
+    _cullPositions: new Map(),
+    _displayCourse: new Map(),
+    _groundSnap: stub(),
+    _displayFloorState: new Map(),
+    _models: new Map(),
+    _viewer: null,
+    _cockpitContactMode: false,
+    records: { data: new Map() },
+  };
+  let meta = null;
+  let fixEpochMs = 0;
+  const records = stub({
+    receive: () => {
+      flightState.records.data.set(ICAO, meta);
+      return { prevMeta: meta, meta, groundFlipped: false, fixEpochMs };
+    },
+    absence: () => 'retain',
+  });
+  const apply = createMilitarySnapshotRenderer({
+    flightState,
+    records,
+    militaryRegistry: stub(),
+    groundFloor: stub({ cachedGroundFloor: ground }),
+    meshFloor: stub(),
+    rendering: stub({
+      _modelOwnsVisual: () => false,
+      _fleetBillboardColor: () => Cesium.Color.WHITE,
+    }),
+    tracking: stub({
+      _militaryLayerSuppresses: () => false,
+      _appendTrailFix: (position, epochMs) =>
+        appended.push({ position, epochMs }),
+    }),
+    motion: stub(),
+    enrichment: stub(),
+    queries: stub({ _likelyLanded: () => false }),
+  });
+  return {
+    history,
+    appended,
+    poll(nextMeta, epochMs) {
+      meta = nextMeta;
+      fixEpochMs = epochMs;
+      apply({ records: [{ id: ICAO }], complete: true }, null);
+    },
+  };
+}
+
+const lightAircraft = (velocity, track) => ({
+  rawLat: 38.1436,
+  rawLon: -122.5561,
+  renderAltitudeM: 10,
+  altitudeFt: 130,
+  speedMps: velocity,
+  track,
+  onGround: false,
+  wasAirborne: true,
+  klass: 'light',
+});
+
+test('military: a low contact whose position repeats while its speed changes is not moved and adds nothing to the trail', (t) => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  t.mock.timers.enable({ apis: ['Date'], now: t0 });
+  const h = harness({ ground: () => -30 });
+  h.poll(lightAircraft(36.4, 63), t0);
+  const first = h.history[0].position;
+  for (const [i, velocity] of [30, 22, 14, 9].entries()) {
+    t.mock.timers.tick(10 * SEC);
+    h.poll(lightAircraft(velocity, 63 + i * 20), t0);
+  }
+  assert.equal(h.history.length, 1, 'a synthetic fix moved a holding contact');
+  assert.equal(h.history[0].position, first);
+  assert.equal(h.appended.length, 1, 'only the real report joins the trail');
+});
+
+test('military: a cruising contact whose position repeats coasts no further than the stale cap, and the synthetic fix is not a report', (t) => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  t.mock.timers.enable({ apis: ['Date'], now: t0 });
+  const h = harness({});
+  const cruise = (velocity, track) => ({
+    rawLat: 36,
+    rawLon: -115,
+    renderAltitudeM: 9_000,
+    altitudeFt: 29_500,
+    speedMps: velocity,
+    track,
+    onGround: false,
+    wasAirborne: true,
+    klass: 'jet',
+  });
+  h.poll(cruise(220, 90), t0);
+  const report = h.history[0].position;
+  t.mock.timers.tick(300 * SEC);
+  h.poll(cruise(200, 100), t0);
+  assert.equal(h.history.length, 2);
+  const moved = Cesium.Cartesian3.distance(report, h.history[1].position);
+  assert.ok(
+    moved <= 220 * 300 + 1,
+    `the synthetic fix coasted ${moved.toFixed(0)} m`,
+  );
+  assert.equal(h.appended.length, 1, 'the synthetic fix joined the trail');
+});
+
+test('military: a report drawn at an invented height says so on its history fix', (t) => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  t.mock.timers.enable({ apis: ['Date'], now: t0 });
+  const h = harness({});
+  h.poll({ ...lightAircraft(60, 90), renderAltitudeInvented: true }, t0);
+  h.poll({ ...lightAircraft(60, 90), rawLon: -122.55 }, t0 + 10 * SEC);
+  assert.equal(h.history[0].inventedHeight, true);
+  assert.equal(h.history[1].inventedHeight, false);
+});
+
+test('military: with the ground unknown, a low barometric altitude alone does not hold a contact', (t) => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  t.mock.timers.enable({ apis: ['Date'], now: t0 });
+  const h = harness({});
+  h.poll(lightAircraft(36.4, 63), t0);
+  t.mock.timers.tick(10 * SEC);
+  h.poll(lightAircraft(30, 80), t0);
+  assert.equal(h.history.length, 2);
+  assert.equal(h.history[0].staleHolds, false);
+  assert.equal(h.appended.length, 1);
+});
diff --git a/src/layers/military/staleHold.test.mjs b/src/layers/military/staleHold.test.mjs
new file mode 100644
index 000000000..9ca4295af
--- /dev/null
+++ b/src/layers/military/staleHold.test.mjs
@@ -0,0 +1,199 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createMotion } from './motion.js';
+import { createFlightState } from './state.js';
+import { createTracking } from './tracking.js';
+import { TRAIL_CONTINUITY_MAX_SPEED_KT } from '../../data/trailContinuity.js';
+import { RENDER_DELAY_SEC } from './policy.js';
+
+const SEC = 1000;
+
+function motionFixture({ info, fixes, nowMs, ground = () => null }) {
+  const flightState = {
+    records: { data: new Map([['00a003', info]]) },
+    _positionHistory: new Map([['00a003', fixes]]),
+    _scratchArc: {},
+    _scratchOffset: new Cesium.Cartesian3(),
+    _scratchEnu: new Cesium.Matrix4(),
+    _scratchRenderTime: new Cesium.JulianDate(),
+    now: () => nowMs,
+  };
+  const motion = createMotion({
+    flightState,
+    services: {
+      groundFloor: { cachedGroundFloor: ground },
+      camera: {},
+      focus: {},
+    },
+    parts: {},
+  });
+  return motion;
+}
+
+function fix(timeMs, lat, lon, heightM, velocity, track) {
+  return {
+    time: Cesium.JulianDate.fromDate(new Date(timeMs)),
+    epochMs: timeMs,
+    position: Cesium.Cartesian3.fromDegrees(lon, lat, heightM),
+    velocity,
+    track,
+  };
+}
+
+test('a military contact stale after a low approach holds at its last report', () => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  const ground = 1_590; // An airbase, ellipsoidal.
+  const fixes = [
+    fix(t0, 35.03, -106.58, ground + 300, 75, 260),
+    fix(t0 + 10 * SEC, 35.03, -106.588, ground + 40, 70, 260),
+  ];
+  const info = {
+    altitudeFt: 5_350,
+    renderAltitudeM: ground + 40,
+    rawLat: 35.03,
+    rawLon: -106.588,
+    speedMps: 70,
+    track: 260,
+    onGround: false,
+  };
+  for (const afterSec of [10, 60, 200]) {
+    const motion = motionFixture({
+      info,
+      fixes,
+      nowMs: t0 + 10 * SEC + RENDER_DELAY_SEC * SEC + afterSec * SEC,
+      ground: () => ground,
+    });
+    const drawn = motion._deadReckon('00a003', new Cesium.Cartesian3());
+    assert.ok(Cesium.Cartesian3.distance(drawn, fixes[1].position) < 0.01);
+  }
+});
+
+test('a cruising military contact still heard after its last position coasts past 90 s, for up to 5 minutes, then stops', () => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  const fixes = [
+    fix(t0, 36, -115, 9_000, 220, 90),
+    fix(t0 + 10 * SEC, 36, -114.975, 9_000, 220, 90),
+  ];
+  const info = {
+    altitudeFt: 29_500,
+    renderAltitudeM: 9_000,
+    rawLat: 36,
+    rawLon: -114.975,
+    speedMps: 220,
+    track: 90,
+    onGround: false,
+    lastContactEpochMs: t0 + 10 * SEC + 300 * SEC,
+  };
+  const at = (afterSec) =>
+    motionFixture({
+      info,
+      fixes,
+      nowMs: t0 + 10 * SEC + RENDER_DELAY_SEC * SEC + afterSec * SEC,
+    })._deadReckon('00a003', new Cesium.Cartesian3());
+  const d = (p) => Cesium.Cartesian3.distance(p, fixes[1].position);
+  const near = (got, want) => Math.abs(got - want) < want * 0.005 + 50;
+  assert.ok(near(d(at(45)), 220 * 45));
+  assert.ok(near(d(at(250)), 220 * 250), 'still moving at 250 s');
+  assert.ok(near(d(at(400)), 220 * 300), 'stopped at 300 s');
+});
+
+test('a bad military speed coasts no faster than the 1,500 kt continuity limit', () => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  const fixes = [
+    fix(t0, 36, -115, 9_000, 2_000, 90),
+    fix(t0 + 10 * SEC, 36, -114.975, 9_000, 2_000, 90),
+  ];
+  const info = {
+    altitudeFt: 29_500,
+    renderAltitudeM: 9_000,
+    rawLat: 36,
+    rawLon: -114.975,
+    speedMps: 2_000,
+    track: 90,
+    onGround: false,
+  };
+  const drawn = motionFixture({
+    info,
+    fixes,
+    nowMs: t0 + 10 * SEC + RENDER_DELAY_SEC * SEC + 300 * SEC,
+  })._deadReckon('00a003', new Cesium.Cartesian3());
+  const limitMps = (TRAIL_CONTINUITY_MAX_SPEED_KT * 1852) / 3600;
+  const d = Cesium.Cartesian3.distance(drawn, fixes[1].position);
+  assert.ok(Math.abs(d - limitMps * 300) < 1_500, `${d.toFixed(0)} m`);
+});
+
+test('a holding military contact draws no head and its trail ends at the last report', () => {
+  const t0 = Date.UTC(2026, 10, 9, 20, 0);
+  const fixes = [0, 1, 2].map((i) =>
+    fix(t0 + i * 10 * SEC, 35.03, -106.57 - i * 0.008, 1_700, 70, 260),
+  );
+  const svc = {
+    ...Object.fromEntries(
+      [
+        'picking',
+        'sprites',
+        'aircraftPresentation',
+        'camera',
+        'militaryRegistry',
+        'labels',
+        'meshFloor',
+        'focus',
+        'readout',
+        'context',
+        'render',
+        'recession',
+      ].map((name) => [name, {}]),
+    ),
+    groundSnap: { createGroundSnap: () => ({ clear() {} }) },
+    geoid: { ensureGeoidReady: async () => {}, geoidHeight: () => 0 },
+    groundFloor: {
+      resolveGroundFloorCellsBounded: async () => {},
+      cachedGroundFloor: () => null,
+      floorAltitudeM: (alt) => alt,
+    },
+  };
+  const calls = [];
+  svc.trails = {
+    createTrail: () => ({
+      setSegments: (segments) => calls.push(segments.flat()),
+      setPositions: (positions) => calls.push(positions.slice()),
+      setVisible() {},
+      clear() {},
+      destroy() {},
+    }),
+  };
+  const flightState = createFlightState({ services: svc, source: {} });
+  const added = [];
+  flightState._viewer = {
+    isDestroyed: () => false,
+    entities: {
+      add: (definition) => (added.push(definition), definition),
+      remove() {},
+    },
+  };
+  flightState._trackedIcao = '00a003';
+  flightState.now = () => t0 + 20 * SEC + RENDER_DELAY_SEC * SEC + 120 * SEC;
+  flightState._positionHistory.set('00a003', fixes);
+  const last = Cesium.Cartesian3.clone(fixes[2].position);
+  const tracking = createTracking({
+    flightState,
+    services: svc,
+    parts: {
+      motion: {
+        _isTrackWarmingUp: () => false,
+        _trackedTrailCached: () => last,
+        _trackedDisplayPosition: () => last,
+        _trackedModelCenterWorld: () => null,
+        _trackedModelEnvelopeM: () => null,
+      },
+    },
+    layer: {},
+  });
+  tracking._startTrail('00a003');
+  assert.equal(calls.at(-1).length, 3);
+  const head = added.find((d) =>
+    String(d.id).startsWith('gev-trail:mil-head-'),
+  );
+  assert.deepEqual(head.polyline.positions.getValue(), []);
+});
diff --git a/src/layers/military/state.js b/src/layers/military/state.js
index f27595d2b..23f8f053c 100644
--- a/src/layers/military/state.js
+++ b/src/layers/military/state.js
@@ -178,9 +178,32 @@ export function createFlightState({ source, services }) {
 
   flightState._trailHeadSeq = 0;
 
-  /** @type {Cesium.Cartesian3[]} Chronological tracked-aircraft fixes (oldest first) */
+  /** @type {{position: Cesium.Cartesian3|null, timeMs: number, nullAltitude: boolean, breakBefore: boolean, drawn?: boolean}[]}
+   *  Chronological tracked-aircraft trail (oldest first): reports, and
+   *  (`drawn`) where the icon was drawn between them; `breakBefore` starts a
+   *  new segment. */
 
-  flightState._trailPositions = [];
+  flightState._trailFixes = [];
+
+  /** @type {number} Body fixes drawn: those at or before the display time. */
+
+  flightState._trailBodyCount = 0;
+
+  /** @type {Cesium.Cartesian3|null} Where the tracked icon was last recorded into the trail. */
+
+  flightState._trailRecordPosition = null;
+
+  /** @type {number} Display time (epoch ms) of that recording. */
+
+  flightState._trailRecordMs = -Infinity;
+
+  /** @type {string|undefined} The stale cue last written into the tracked label (see `_staleCueTick`). */
+
+  flightState._trackedStaleCueText = undefined;
+
+  /** @type {{key: string, cue: {text: string, dimmed: boolean}}|null} This frame's tracked stale cue (see `_trackedStaleCue`). */
+
+  flightState._trackedStaleCueCache = null;
 
   /** @type {number} Monotonic token — invalidates in-flight backfill responses */
 
diff --git a/src/layers/military/tracking.js b/src/layers/military/tracking.js
index ed40ff4ac..d2d4843b6 100644
--- a/src/layers/military/tracking.js
+++ b/src/layers/military/tracking.js
@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { julianAt } from '../../time/julian.js';
-import { t } from '../../i18n/index.js';
+import { formatNumber, t } from '../../i18n/index.js';
+import { unitLabel } from '../../ui/unitLabels.js';
 import { nextCockpitNearContacts } from '../../data/cockpitAirLod.js';
 import { aircraftIcon, TRACKED_ICON_PX } from '../../data/aircraftIcons.js';
 import { trackedModelZoomActive } from '../../data/trackedModelRegime.js';
@@ -19,14 +19,33 @@ import {
   TRACKED_MODEL_MAX_LOAD_FAILS,
   TRACKED_MODEL_RETRY_BACKOFF_MS,
   TRAIL_MAX_POINTS,
+  DR_CORRECTION_MS,
   RENDER_DELAY_SEC,
   TRAIL_COLOR,
   BILLBOARD_SCALE,
   GROUND_SCALE,
   AMBER_TRANSPARENT,
   TRACKED_ICON_COLOR,
+  STALE_ALPHA,
 } from './policy.js';
 import { roundHeadingDegrees } from '../../data/headingDegrees.js';
+import {
+  drawTrailSegments,
+  historyFixEpochMs,
+  insertTrailFix,
+  joinTrailBackfill,
+  recordTrailPoint,
+  trailBackfillFixes,
+  trailBodyCount,
+  trailBodyCountOutsideModel,
+  trailBodySegments,
+  trailHeadStartFix,
+  trailRecordingBlocked,
+  TRAIL_RECORD_STEP_M,
+  TRAIL_RECORD_STEP_MS,
+} from '../../data/trailContinuity.js';
+
+const STALE_TRACKED_COLOR = TRACKED_ICON_COLOR.withAlpha(STALE_ALPHA);
 
 export function createTracking({
   flightState,
@@ -206,24 +225,98 @@ export function createTracking({
     _setCockpitContactMode(active);
   }
 
+  /**
+   * The tracked plane's stale cue and whether it is drawn with the stale fade.
+   * - SIGNAL LOST · <time since its last report>, dimmed: its coast has ended
+   *   (or it holds at its last report after a missed update) and no newer
+   *   report has come.
+   * - STALE, dimmed: it has missed an update and still coasts.
+   * - STALE, not dimmed: the whole feed is backing off.
+   * @param {string} icao24
+   * @returns {{text: string, dimmed: boolean}}
+   */
+
+  function _trackedStaleCue(icao24) {
+    const records = flightState.records;
+    const misses = records.missingPolls.get(icao24) || 0;
+    const repeated = records.fixRepeated?.has(icao24) === true;
+    const backoff = flightState.feed._backoff === true;
+    // Computed once per frame for the label, the icon colour and the model
+    // fade; a poll between frames changes the key.
+    const frame = flightState._viewer?.scene?.frameState?.frameNumber;
+    const key = Number.isFinite(frame)
+      ? `${frame}|${icao24}|${misses}|${repeated}|${backoff}`
+      : null;
+    const cached = flightState._trackedStaleCueCache;
+    if (key !== null && cached?.key === key) return cached.cue;
+    const cue = _computeTrackedStaleCue(
+      icao24,
+      misses > 0 || repeated,
+      backoff,
+    );
+    flightState._trackedStaleCueCache = key === null ? null : { key, cue };
+    return cue;
+  }
+
+  /** `_trackedStaleCue` without the per-frame cache. A repeated fix counts as missed. */
+
+  function _computeTrackedStaleCue(icao24, missed, backoff) {
+    const lost = parts.motion._signalLost(icao24);
+    if (lost && (missed || !lost.holds)) {
+      const sec = Math.max(
+        0,
+        Math.floor((flightState.now() - lost.reportEpochMs) / 1000),
+      );
+      const time =
+        sec < 60
+          ? `${formatNumber(sec, { useGrouping: false })} ${unitLabel('s')}`
+          : `${formatNumber(Math.floor(sec / 60), { useGrouping: false })} ${unitLabel('min')}`;
+      return { text: t('SIGNAL LOST · {time}', { time }), dimmed: true };
+    }
+    if (missed) return { text: t('STALE'), dimmed: true };
+    if (backoff) return { text: t('STALE'), dimmed: false };
+    return { text: '', dimmed: false };
+  }
+
+  /** The tracked billboard's colour: amber, faded while stale, clear while the 3D model is the visual. */
+
+  function _trackedIconColor() {
+    if (parts.rendering._modelOwnsVisual(flightState._trackedIcao))
+      return AMBER_TRANSPARENT;
+    return _trackedStaleCue(flightState._trackedIcao).dimmed
+      ? STALE_TRACKED_COLOR
+      : TRACKED_ICON_COLOR;
+  }
+
+  /**
+   * Re-word the tracked label when its stale cue changes (STALE, SIGNAL LOST,
+   * each new second or minute of it). Run from the layer's per-frame pass.
+   */
+
+  function _staleCueTick() {
+    const icao24 = flightState._trackedIcao;
+    if (!icao24 || !flightState._trackedEntity) return;
+    const text = _trackedStaleCue(icao24).text;
+    if (text === flightState._trackedStaleCueText) return;
+    flightState._trackedStaleCueText = text;
+    _updateTrackedLabelModel(icao24);
+  }
+
   /**
    * Build the multi-line presentation text for the protected tracked host card.
    * Lines: callsign, type/registration, operator/altitude.
-   * While the plane is in its missed-poll grace (coasting on dead reckoning
-   * with sticky metadata) the first line carries a "· STALE" cue — the fleet's
-   * 45%-alpha billboard fade doesn't apply to the tracked plane (its entity
-   * owns the visual), so without this the readout would present last-known
-   * altitude/speed as live.
+   * The first line carries the stale cue (`_trackedStaleCue`): STALE while
+   * the plane coasts on dead reckoning after a missed update, SIGNAL LOST
+   * once the coast has ended, so last-known altitude/speed are never
+   * presented as live.
    * @param {Object|null} info - Flight metadata from _flightData
    * @param {string} icao24 - ICAO hex identifier (fallback display name)
    * @returns {string} Newline-separated label text
    */
 
   function _buildTrackedLabel(info, icao24) {
-    const stale =
-      flightState.records.missingPolls.get(icao24) || flightState.feed._backoff
-        ? ` · ${t('STALE')}`
-        : '';
+    const cue = _trackedStaleCue(icao24).text;
+    const stale = cue ? ` · ${cue}` : '';
     const callsign =
       (parts.queries._toCleanText(info?.callsign) ||
         parts.queries._toCleanText(info?.registration) ||
@@ -456,33 +549,112 @@ export function createTracking({
   }
 
   /**
-   * Append one fix to the tracked aircraft's trail accumulation and refresh
-   * the rendered trail. Caller passes an owned (cloned) Cartesian3.
-   * @param {Cesium.Cartesian3} position - New fix position, appended at the head.
+   * Put one report into the tracked aircraft's trail, in time order, and
+   * refresh the rendered trail. Caller passes an owned (cloned) Cartesian3. A
+   * report that breaks from its neighbour starts a new segment (see
+   * trailContinuity).
+   * @param {Cesium.Cartesian3} position - The report's position.
+   * @param {number} [epochMs] - The report's time; defaults to the tracked
+   *   aircraft's newest position-history fix, which every caller has just pushed.
+   * @param {{nullAltitude?: boolean}} [options] - `nullAltitude`: the report
+   *   had no altitude, so its position is not kept and the line breaks there.
+   *   A report for a time the display has already passed replaces what was
+   *   drawn after it (see `insertTrailFix`).
    */
 
-  function _appendTrailFix(position) {
-    flightState._trailPositions.push(_trailFloorPosition(position));
-    if (flightState._trailPositions.length > TRAIL_MAX_POINTS)
-      flightState._trailPositions.shift();
+  function _appendTrailFix(position, epochMs, { nullAltitude = false } = {}) {
+    const history = flightState._positionHistory.get(flightState._trackedIcao);
+    const timeMs = Number.isFinite(epochMs)
+      ? epochMs
+      : historyFixEpochMs(history?.[history.length - 1]);
+    insertTrailFix(
+      flightState._trailFixes,
+      _trailFloorPosition(position),
+      timeMs,
+      TRAIL_MAX_POINTS,
+      {
+        nullAltitude,
+        displayMs: flightState.now() - RENDER_DELAY_SEC * 1000,
+        settleMs: DR_CORRECTION_MS,
+      },
+    );
     _refreshTrailDisplay();
   }
 
   /**
-   * Renders the trail BODY — the accumulated fixes EXCLUDING the newest raw one. That
-   * newest fix is at ~now, ~one poll interval AHEAD of the delayed icon (rendered at
-   * now − RENDER_DELAY_SEC), so drawing it would push the trail in FRONT of the plane.
-   * The cheap per-frame _trailHeadEntity segment bridges the last body point to the
-   * delayed dead-reckoned head, so this primitive only rebuilds on a real fix (poll
-   * cadence), never at motion cadence.
+   * Per-frame trail work, run from the layer's preRender pass whether or not
+   * the head is visible: record where the tracked icon is drawn (at most once
+   * a second or every 150 m, floored like the head) and move the body on as
+   * the display time passes reports. The head callback only reads the result.
+   */
+
+  function _trailTick() {
+    if (!flightState._trackedIcao || !flightState._trail) return;
+    const displayMs = flightState.now() - RENDER_DELAY_SEC * 1000;
+    let changed = false;
+    if (
+      flightState._trailFixes.length &&
+      !parts.motion._isTrackWarmingUp() &&
+      !trailRecordingBlocked(flightState._trailFixes, displayMs)
+    ) {
+      const drawn = parts.motion._trackedDisplayPosition(
+        flightState._trackedIcao,
+      );
+      const last = flightState._trailRecordPosition;
+      if (
+        drawn &&
+        (!last ||
+          displayMs - flightState._trailRecordMs >= TRAIL_RECORD_STEP_MS ||
+          Cesium.Cartesian3.distance(last, drawn) >= TRAIL_RECORD_STEP_M)
+      ) {
+        flightState._trailRecordMs = displayMs;
+        flightState._trailRecordPosition = Cesium.Cartesian3.clone(
+          drawn,
+          flightState._trailRecordPosition ?? undefined,
+        );
+        changed = recordTrailPoint(
+          flightState._trailFixes,
+          _trailFloorPosition(Cesium.Cartesian3.clone(drawn)),
+          displayMs,
+          TRAIL_MAX_POINTS,
+        );
+      }
+    }
+    if (changed || _trailBodyCountNow() !== flightState._trailBodyCount)
+      _refreshTrailDisplay();
+  }
+
+  /**
+   * Renders the trail BODY — the accumulated fixes at or before the delayed display
+   * time (now − RENDER_DELAY_SEC). Newer fixes are AHEAD of the icon, so drawing them
+   * would push the trail in FRONT of the plane. The cheap per-frame _trailHeadEntity
+   * segment bridges the last body point to the delayed dead-reckoned head, so the
+   * body rebuilds only on a real fix or when the display time passes one, never at
+   * motion cadence. A break lifts the pen: each segment is
+   * its own line, nothing between them.
    */
 
   function _refreshTrailDisplay() {
     if (!flightState._trail) return;
-    flightState._trail.setPositions(
-      flightState._trailPositions.length > 1
-        ? flightState._trailPositions.slice(0, -1)
-        : flightState._trailPositions,
+    flightState._trailBodyCount = _trailBodyCountNow();
+    drawTrailSegments(
+      flightState._trail,
+      trailBodySegments(flightState._trailFixes, flightState._trailBodyCount),
+    );
+  }
+
+  /** Fixes at or before the time the aircraft is drawn (now − RENDER_DELAY_SEC),
+   *  less the newest recorded points inside its 3D model. */
+
+  function _trailBodyCountNow() {
+    return trailBodyCountOutsideModel(
+      flightState._trailFixes,
+      trailBodyCount(
+        flightState._trailFixes,
+        flightState.now() - RENDER_DELAY_SEC * 1000,
+      ),
+      parts.motion._trackedModelCenterWorld(),
+      parts.motion._trackedModelEnvelopeM(),
     );
   }
 
@@ -495,25 +667,27 @@ export function createTracking({
 
   function _startTrail(icao24) {
     flightState._trailBackfillToken += 1;
-    flightState._trailPositions = [];
+    flightState._trailFixes = [];
+    flightState._trailRecordPosition = null;
+    flightState._trailRecordMs = -Infinity;
     const history = flightState._positionHistory.get(icao24) || [];
-    // Seed only fixes at/behind the DELAYED display time (now − RENDER_DELAY_SEC). The
-    // newest ~RENDER_DELAY_SEC of fixes are AHEAD of the displayed icon; including them
-    // would draw the trail in front of the plane. They join via _appendTrailFix as they age.
-    const seedRenderTime = Cesium.JulianDate.addSeconds(
-      julianAt(flightState.now()),
-      -RENDER_DELAY_SEC,
-      flightState._scratchWarmupTime,
-    );
+    // Seed every report. The body only draws those at or before the delayed
+    // display time (now − RENDER_DELAY_SEC); newer ones join it as the display
+    // passes them. A synthetic forward fix (it carries `reportEpochMs`) is a
+    // motion aid, never a report. A report drawn at an invented height keeps
+    // no position and breaks the line.
     for (const fix of history) {
-      if (Cesium.JulianDate.lessThanOrEquals(fix.time, seedRenderTime)) {
-        // Floor grounded-history seeds (round 2): a grounded contact's stored
-        // fixes carry the pre-datum default height — the trail copy sits on
-        // the surface instead (pure lift; airborne fixes pass through).
-        flightState._trailPositions.push(
-          _trailFloorPosition(Cesium.Cartesian3.clone(fix.position)),
-        );
-      }
+      if (Number.isFinite(fix.reportEpochMs)) continue;
+      // Floor grounded-history seeds (round 2): a grounded contact's stored
+      // fixes carry the pre-datum default height — the trail copy sits on
+      // the surface instead (pure lift; airborne fixes pass through).
+      insertTrailFix(
+        flightState._trailFixes,
+        _trailFloorPosition(Cesium.Cartesian3.clone(fix.position)),
+        historyFixEpochMs(fix),
+        TRAIL_MAX_POINTS,
+        { nullAltitude: fix.inventedHeight === true },
+      );
     }
     if (!flightState._trail && flightState._viewer) {
       flightState._trail = createTrail(flightState._viewer, {
@@ -534,14 +708,13 @@ export function createTracking({
         show: !flightState._cockpitContactMode,
         polyline: {
           positions: new Cesium.CallbackProperty(() => {
-            // Need ≥2 accumulated points: the body draws all-but-newest, so the head must
-            // start at the last DISPLAYED body point (index n−2). With a single fix that
-            // point would be the sole raw fix — ~now, AHEAD of the delayed icon — so the
-            // segment would draw IN FRONT of the plane. Likewise during warm-up the icon
-            // predates all real history, so there is no valid body point behind it.
+            // The head starts at the last DISPLAYED body point, the newest fix at or
+            // before the delayed display time; a fix ahead of the icon would draw the
+            // segment IN FRONT of the plane. During warm-up the icon predates all real
+            // history, so there is no valid body point behind it.
             if (
               !flightState._trackedIcao ||
-              flightState._trailPositions.length < 2 ||
+              !flightState._trailFixes.length ||
               parts.motion._isTrackWarmingUp()
             )
               return [];
@@ -549,12 +722,20 @@ export function createTracking({
               parts.motion._trackedTrailCached() ||
               parts.motion._trackedDisplayPosition(flightState._trackedIcao);
             if (!head) return [];
-            // body[n−2] (last displayed body point) → delayed head: runs FORWARD, never a
-            // backward/reversing segment.
-            const start =
-              flightState._trailPositions[
-                flightState._trailPositions.length - 2
-              ];
+            // The last body point (a report, or where the icon was drawn a
+            // moment ago) → the icon. The body is moved on by _trailTick, never
+            // here: a callback must not add or remove entities.
+            // No head across a break: a body point more than 150 km away, or
+            // too long ago or too far to be one path, stays detached; none while
+            // the aircraft holds at its last point.
+            const last = trailHeadStartFix(
+              flightState._trailFixes,
+              head,
+              flightState.now(),
+              flightState._trailBodyCount,
+            );
+            if (!last) return [];
+            const start = last.position;
             // Floor the head too (round 2): a grounded tracked contact's DR
             // display height is the pre-datum default — without this the last
             // segment dives underground while taxiing.
@@ -595,10 +776,10 @@ export function createTracking({
   }
 
   /**
-   * Fire-and-forget optional source history backfill (PRD F2). Trace points are
-   * stride-thinned to the remaining vertex budget, then spliced strictly older
-   * than the oldest seeded fix AHEAD of the locally accumulated fine segment,
-   * capped at TRAIL_MAX_POINTS (newest kept). Any failure (404/timeout/
+   * Fire-and-forget optional source history backfill (PRD F2). Every trace
+   * point strictly older than the oldest seeded fix is spliced AHEAD of the
+   * locally accumulated fine segment, each leg its own segment, capped at
+   * TRAIL_MAX_POINTS (newest kept). Any failure (404/timeout/
    * malformed) silently keeps the local-only trail.
    * @param {string} icao24 - ICAO hex identifier being tracked.
    * @param {number} token - Backfill token captured at request time.
@@ -644,7 +825,13 @@ export function createTracking({
         lon = point.longitude;
       if (!Number.isFinite(lat) || !Number.isFinite(lon)) continue;
       if (!Number.isFinite(t) || t >= oldestFixEpochSec) continue;
-      parsed.push({ lat, lon, baroAltitudeM: point.baroAltitudeM });
+      parsed.push({
+        lat,
+        lon,
+        baroAltitudeM: point.baroAltitudeM,
+        onGround: point.onGround === true,
+        timeMs: point.observedAtMs,
+      });
     }
     if (!parsed.length) return;
 
@@ -667,39 +854,34 @@ export function createTracking({
     )
       return;
 
-    let older = [];
-    let lastAltM = null; // carry-forward for ground points whose cell isn't warm yet
-    for (const { lat, lon, baroAltitudeM } of parsed) {
-      const baroM =
-        baroAltitudeM == null ? null : baroAltitudeM + geoidHeight(lat, lon);
-      let altM = floorAltitudeM(baroM, cachedGroundFloor(lat, lon));
-      // Ground/no-alt point with an unresolved floor: hold the previous
-      // waypoint's altitude (continuity — never a dive to a made-up depth).
-      // Leading points with nothing to carry keep the old low breadcrumb
-      // sentinel (an arbitrary placeholder, never a reported altitude).
-      if (altM == null) altM = lastAltM != null ? lastAltM : 50;
-      lastAltM = altM;
-      older.push(Cesium.Cartesian3.fromDegrees(lon, lat, altM));
-    }
-
-    // Stride-thin the backfill so it plus the live fine segment fit the cap.
-    const budget = Math.max(
-      1,
-      TRAIL_MAX_POINTS - flightState._trailPositions.length,
+    // Every trace point is kept, each leg its own segment. A 'ground' point
+    // is at altitude 0, floored at the ground. A point with no altitude is a
+    // break on both sides: it sits on the ground where the floor is known and
+    // is skipped otherwise; a skipped point still breaks the line.
+    const backfill = trailBackfillFixes(
+      parsed.map(({ lat, lon, baroAltitudeM, onGround, timeMs }) => {
+        const known = Number.isFinite(baroAltitudeM)
+          ? baroAltitudeM
+          : onGround
+            ? 0
+            : null;
+        const altM = floorAltitudeM(
+          known == null ? null : known + geoidHeight(lat, lon),
+          cachedGroundFloor(lat, lon),
+        );
+        return {
+          position:
+            altM == null ? null : Cesium.Cartesian3.fromDegrees(lon, lat, altM),
+          timeMs,
+          nullAltitude: known == null,
+        };
+      }),
+    );
+    flightState._trailFixes = joinTrailBackfill(
+      backfill,
+      flightState._trailFixes,
+      TRAIL_MAX_POINTS,
     );
-    if (older.length > budget) {
-      const stride = Math.ceil(older.length / budget);
-      const thinned = [];
-      for (let i = 0; i < older.length; i += stride) thinned.push(older[i]);
-      older = thinned;
-    }
-
-    flightState._trailPositions = older.concat(flightState._trailPositions);
-    if (flightState._trailPositions.length > TRAIL_MAX_POINTS) {
-      flightState._trailPositions = flightState._trailPositions.slice(
-        flightState._trailPositions.length - TRAIL_MAX_POINTS,
-      );
-    }
     _refreshTrailDisplay();
   }
 
@@ -709,7 +891,9 @@ export function createTracking({
 
   function _clearTrail() {
     flightState._trailBackfillToken += 1;
-    flightState._trailPositions = [];
+    flightState._trailFixes = [];
+    flightState._trailRecordPosition = null;
+    flightState._trailRecordMs = -Infinity;
     if (flightState._trail) flightState._trail.clear();
     if (
       flightState._trailHeadEntity &&
@@ -926,15 +1110,9 @@ export function createTracking({
           (CLASS_SCALE_2D[
             flightState.records.data.get(flightState._trackedIcao)?.klass
           ] || 1),
-        // Solid amber when the billboard is the visual (zoomed out, 3D off, or model still loading);
-        // transparent once the STANDALONE tracked model is actually up (ready + shown).
-        color: new Cesium.CallbackProperty(
-          () =>
-            parts.rendering._modelOwnsVisual(flightState._trackedIcao)
-              ? AMBER_TRANSPARENT
-              : TRACKED_ICON_COLOR,
-          false,
-        ),
+        // Solid amber (faded while stale) when the billboard is the visual (zoomed out, 3D off,
+        // or model still loading); transparent once the STANDALONE tracked model is actually up.
+        color: new Cesium.CallbackProperty(_trackedIconColor, false),
         sizeInMeters: false,
         scaleByDistance: new Cesium.NearFarScalar(1000, 3.0, 8000000, 0.5),
         alignedAxis: Cesium.Cartesian3.ZERO,
@@ -1157,6 +1335,9 @@ export function createTracking({
     _setCockpitContactMode,
     _applyCockpitState,
     _buildTrackedLabel,
+    _trackedStaleCue,
+    _trackedIconColor,
+    _staleCueTick,
     _updateTrackedLabelModel,
     _syncTrackedBillboardImage,
     _refreshTr3bContact,
@@ -1168,6 +1349,7 @@ export function createTracking({
     _syncTracked2dRotation,
     _trailFloorPosition,
     _appendTrailFix,
+    _trailTick,
     _refreshTrailDisplay,
     _startTrail,
     _backfillTrail,
diff --git a/src/layers/military/trail.test.mjs b/src/layers/military/trail.test.mjs
new file mode 100644
index 000000000..aa27a6956
--- /dev/null
+++ b/src/layers/military/trail.test.mjs
@@ -0,0 +1,260 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createFlightState } from './state.js';
+import { createTracking } from './tracking.js';
+import { TRAIL_MAX_POINTS } from './policy.js';
+
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+
+function services({ trails, floor = () => null } = {}) {
+  const names = [
+    'picking',
+    'sprites',
+    'aircraftPresentation',
+    'camera',
+    'militaryRegistry',
+    'labels',
+    'meshFloor',
+    'focus',
+    'readout',
+    'context',
+    'render',
+    'recession',
+  ];
+  return {
+    ...Object.fromEntries(names.map((name) => [name, {}])),
+    groundSnap: { createGroundSnap: () => ({ clear() {} }) },
+    trails,
+    geoid: { ensureGeoidReady: async () => {}, geoidHeight: () => 0 },
+    groundFloor: {
+      resolveGroundFloorCellsBounded: async () => {},
+      cachedGroundFloor: floor,
+      floorAltitudeM: (alt, ground) =>
+        Number.isFinite(alt) && Number.isFinite(ground)
+          ? Math.max(alt, ground + 1)
+          : Number.isFinite(alt)
+            ? alt
+            : Number.isFinite(ground)
+              ? ground + 1
+              : null,
+    },
+  };
+}
+
+/** A fake trail that records what draws: segments of two or more points. */
+function recordingTrail() {
+  const calls = [];
+  return {
+    last: () =>
+      (calls[calls.length - 1] ?? []).filter((segment) => segment.length >= 2),
+    createTrail: () => ({
+      setSegments(segments) {
+        calls.push(segments.map((segment) => segment.slice()));
+      },
+      setPositions(positions) {
+        calls.push([positions.slice()]);
+      },
+      setVisible() {},
+      clear() {
+        calls.push([]);
+      },
+      destroy() {},
+    }),
+  };
+}
+
+function trackedHarness({ liveFixes = [], trace = null, nowMs, floor, head }) {
+  const trail = recordingTrail();
+  const svc = services({ trails: trail, floor });
+  const flightState = createFlightState({
+    services: svc,
+    source: {
+      label: 'Fixture military aircraft',
+      async getTrack() {
+        if (!trace) throw new Error('404');
+        return { records: trace };
+      },
+    },
+  });
+  const added = [];
+  flightState._viewer = {
+    isDestroyed: () => false,
+    entities: {
+      add(definition) {
+        added.push(definition);
+        return definition;
+      },
+      remove() {},
+    },
+  };
+  flightState._trackedIcao = 'ae0001';
+  flightState.now = () => nowMs;
+  flightState._positionHistory.set(
+    'ae0001',
+    liveFixes.map((fix) => ({
+      time: Cesium.JulianDate.fromDate(new Date(fix.timeMs)),
+      epochMs: fix.timeMs,
+      position: Cesium.Cartesian3.fromDegrees(fix.lon, fix.lat, 9_000),
+    })),
+  );
+  const tracking = createTracking({
+    flightState,
+    services: svc,
+    parts: {
+      motion: {
+        _isTrackWarmingUp: () => false,
+        _trackedTrailCached: () => head ?? null,
+        _trackedDisplayPosition: () => head ?? null,
+        _trackedModelCenterWorld: () => null,
+        _trackedModelEnvelopeM: () => null,
+      },
+    },
+    layer: {},
+  });
+  const headPositions = () =>
+    added
+      .find((definition) =>
+        String(definition.id).startsWith('gev-trail:mil-head-'),
+      )
+      .polyline.positions.getValue();
+  return { trail, tracking, flightState, headPositions };
+}
+
+const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+/** readsb-shaped trace points as the military source parses them. */
+function point(timeMs, lat, lon, baroAltitudeM = 9_000, onGround = false) {
+  return {
+    observedAtMs: timeMs,
+    latitude: lat,
+    longitude: lon,
+    baroAltitudeM,
+    onGround,
+  };
+}
+
+function leg(startMs, lat, lon, count) {
+  return Array.from({ length: count }, (_, i) =>
+    point(startMs + i * MINUTE, lat, lon + i * 0.12),
+  );
+}
+
+test('a multi-leg military trace becomes separate segments with no line across a gap', async () => {
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  const first = leg(t0, 36, -115, 5);
+  const second = leg(t0 + 5 * MINUTE + 3 * HOUR, 35, -106, 5);
+  const third = leg(t0 + 10 * MINUTE + 5 * HOUR, 38, -77, 5);
+  const trace = [...first, ...second, ...third];
+  const liveStart = t0 + 15 * MINUTE + 5 * HOUR;
+  const liveFixes = [0, 1, 2].map((i) => ({
+    timeMs: liveStart + i * MINUTE,
+    lat: 38,
+    lon: -77 + 0.6 + i * 0.12,
+  }));
+  const { trail, flightState, tracking } = trackedHarness({
+    liveFixes,
+    trace,
+    nowMs: liveStart + 3 * MINUTE,
+  });
+  tracking._startTrail('ae0001');
+  await settle();
+  assert.equal(flightState._trailFixes.length, trace.length + 3);
+  assert.deepEqual(
+    trail.last().map((segment) => segment.length),
+    [5, 5, 8],
+  );
+});
+
+test('a military trace point with no altitude breaks the line and is never given a made-up height', async () => {
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  const trace = leg(t0, 35, -106, 7);
+  trace[3] = point(trace[3].observedAtMs, 35, -105.64, null);
+  const liveFixes = [{ timeMs: t0 + 7 * MINUTE, lat: 35, lon: -105.16 }];
+  const { trail, flightState, tracking } = trackedHarness({
+    liveFixes,
+    trace,
+    nowMs: t0 + 9 * MINUTE,
+  });
+  tracking._startTrail('ae0001');
+  await settle();
+  // Skipped (no floor known): 3 + 3 + the live fix drawn.
+  assert.equal(flightState._trailFixes.length, trace.length - 1 + 1);
+  assert.deepEqual(
+    trail.last().map((segment) => segment.length),
+    [3, 4],
+  );
+  for (const fix of flightState._trailFixes) {
+    const height = Cesium.Cartographic.fromCartesian(fix.position).height;
+    assert.ok(Math.abs(height - 9_000) < 1, `no invented height: ${height}`);
+  }
+});
+
+test('a military ground point is drawn on the ground and stays joined', async () => {
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  // Taxiing: 'ground' points a few hundred metres apart, one minute apart.
+  const trace = Array.from({ length: 4 }, (_, i) =>
+    point(t0 + i * MINUTE, 35, -106.6 + i * 0.004, null, true),
+  );
+  const liveFixes = [{ timeMs: t0 + 4 * MINUTE, lat: 35, lon: -106.584 }];
+  const { trail, flightState, tracking } = trackedHarness({
+    liveFixes,
+    trace,
+    nowMs: t0 + 6 * MINUTE,
+    floor: () => 1_590,
+  });
+  tracking._startTrail('ae0001');
+  await settle();
+  assert.deepEqual(
+    trail.last().map((segment) => segment.length),
+    [5],
+  );
+  const height = Cesium.Cartographic.fromCartesian(
+    flightState._trailFixes[0].position,
+  ).height;
+  assert.ok(Math.abs(height - 1_591) < 1);
+});
+
+test('the military head is drawn to a nearby aircraft and not to one more than 150 km away', () => {
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  const liveFixes = [0, 1, 2].map((i) => ({
+    timeMs: t0 + i * MINUTE,
+    lat: 35,
+    lon: -106 + i * 0.12,
+  }));
+  const near = Cesium.Cartesian3.fromDegrees(-105.7, 35, 9_000);
+  const joined = trackedHarness({
+    liveFixes,
+    nowMs: t0 + 3 * MINUTE,
+    head: near,
+  });
+  joined.tracking._startTrail('ae0001');
+  assert.equal(joined.headPositions().length, 2);
+
+  const far = Cesium.Cartesian3.fromDegrees(-103, 35, 9_000);
+  const detached = trackedHarness({
+    liveFixes,
+    nowMs: t0 + 3 * MINUTE,
+    head: far,
+  });
+  detached.tracking._startTrail('ae0001');
+  assert.deepEqual(detached.headPositions(), []);
+});
+
+test('a full 24 h military trace fits within TRAIL_MAX_POINTS without thinning', async () => {
+  const day = 24 * 60;
+  const t0 = Date.UTC(2026, 10, 8, 0, 0);
+  const trace = leg(t0, 20, -150, day);
+  const liveStart = t0 + day * MINUTE;
+  const liveFixes = [{ timeMs: liveStart, lat: 20, lon: -150 + day * 0.12 }];
+  const { flightState, tracking } = trackedHarness({
+    liveFixes,
+    trace,
+    nowMs: liveStart + MINUTE,
+  });
+  tracking._startTrail('ae0001');
+  await settle();
+  assert.ok(TRAIL_MAX_POINTS >= day + 500);
+  assert.equal(flightState._trailFixes.length, day + 1);
+});
diff --git a/src/layers/military/trailRecord.test.mjs b/src/layers/military/trailRecord.test.mjs
new file mode 100644
index 000000000..3bc999b18
--- /dev/null
+++ b/src/layers/military/trailRecord.test.mjs
@@ -0,0 +1,697 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createMotion } from './motion.js';
+import { createFlightState } from './state.js';
+import { createTracking } from './tracking.js';
+import { RENDER_DELAY_SEC, STALE_ALPHA } from './policy.js';
+
+// A tracked military contact's trail between reports is the path its icon
+// was drawn along, recorded from the real display path frame by frame.
+
+const SEC = 1000;
+const ICAO = '00a004';
+const T0 = Date.UTC(2026, 10, 9, 21, 0);
+
+function fix(timeMs, lat, lon, heightM, velocity, track) {
+  return {
+    time: Cesium.JulianDate.fromDate(new Date(timeMs)),
+    epochMs: timeMs,
+    position: Cesium.Cartesian3.fromDegrees(lon, lat, heightM),
+    velocity,
+    track,
+  };
+}
+
+function services(trail, ground) {
+  const names = [
+    'picking',
+    'sprites',
+    'aircraftPresentation',
+    'camera',
+    'militaryRegistry',
+    'labels',
+    'meshFloor',
+    'focus',
+    'readout',
+    'context',
+    'render',
+    'recession',
+  ];
+  return {
+    ...Object.fromEntries(names.map((name) => [name, {}])),
+    aircraftPresentation: {
+      isTr3b: () => false,
+      tr3bTypeLabel: (id, label) => label,
+    },
+    focus: {
+      nearFarScalarValueAtDistance: () => 1,
+      clearFocusTarget() {},
+      publishFocusTargetFromCachedPosition() {},
+    },
+    groundSnap: { createGroundSnap: () => ({ clear() {} }) },
+    trails: trail,
+    geoid: { ensureGeoidReady: async () => {}, geoidHeight: () => 0 },
+    groundFloor: {
+      resolveGroundFloorCellsBounded: async () => {},
+      cachedGroundFloor: ground,
+      floorAltitudeM: (alt, g) =>
+        Number.isFinite(g) && Number.isFinite(alt)
+          ? Math.max(alt, g + 1.5)
+          : alt,
+    },
+  };
+}
+
+/**
+ * Real motion, real display position and real tracking over one contact.
+ * `frame()` runs one rendered frame: the layer's preRender work, then the
+ * head callback, as Cesium does.
+ */
+function harness({ fixes, info, nowMs, ground = () => null }) {
+  const segmentsCalls = [];
+  let inHead = false;
+  const trail = {
+    createTrail: () => ({
+      setSegments(segments) {
+        assert.ok(
+          !inHead,
+          'the trail body was rebuilt inside the head callback',
+        );
+        segmentsCalls.push(segments.map((segment) => segment.slice()));
+      },
+      setPositions(positions) {
+        assert.ok(
+          !inHead,
+          'the trail body was rebuilt inside the head callback',
+        );
+        segmentsCalls.push([positions.slice()]);
+      },
+      setVisible() {},
+      clear() {},
+      destroy() {},
+    }),
+  };
+  const svc = services(trail, ground);
+  const flightState = createFlightState({ services: svc, source: {} });
+  flightState.records.data.set(ICAO, info);
+  let frameNumber = 0;
+  const added = [];
+  let entityChanges = 0;
+  flightState._viewer = {
+    isDestroyed: () => false,
+    scene: {
+      frameState: {
+        get frameNumber() {
+          return frameNumber;
+        },
+      },
+    },
+    entities: {
+      add(definition) {
+        entityChanges += 1;
+        added.push(definition);
+        return definition;
+      },
+      remove() {
+        entityChanges += 1;
+      },
+    },
+  };
+  flightState._trackedIcao = ICAO;
+  let clock = nowMs;
+  flightState.now = () => clock;
+  flightState._positionHistory.set(ICAO, fixes);
+  const parts = {
+    rendering: { _modelOwnsVisual: () => false, _modelSpec: () => ({}) },
+    queries: {
+      _toCleanText: (value) => (typeof value === 'string' ? value.trim() : ''),
+      _formatAltitude: (ft) => `${ft} ft`,
+    },
+  };
+  parts.motion = createMotion({ flightState, services: svc, parts });
+  const tracking = createTracking({
+    flightState,
+    services: svc,
+    parts,
+    layer: {},
+  });
+  parts.tracking = tracking;
+  const realDateNow = Date.now;
+  Date.now = () => clock;
+  const headEntity = () =>
+    added.find((definition) =>
+      String(definition.id).startsWith('gev-trail:mil-head-'),
+    );
+  const head = () => {
+    const before = entityChanges;
+    inHead = true;
+    try {
+      return headEntity().polyline.positions.getValue();
+    } finally {
+      inHead = false;
+      assert.equal(
+        entityChanges,
+        before,
+        'the head callback added or removed an entity',
+      );
+    }
+  };
+  /** Drawn icon positions, one per frame. */
+  const drawn = [];
+  const frame = ({ readHead = true } = {}) => {
+    frameNumber += 1;
+    tracking._trailTick();
+    const icon = parts.motion._trackedDisplayPosition(ICAO);
+    if (icon) drawn.push(Cesium.Cartesian3.clone(icon));
+    if (readHead) head();
+  };
+  const run = (toMs, { frameMs = 100, readHead = true } = {}) => {
+    while (clock < toMs) {
+      clock = Math.min(toMs, clock + frameMs);
+      frame({ readHead });
+    }
+  };
+  return {
+    flightState,
+    tracking,
+    motion: parts.motion,
+    head,
+    drawn,
+    run,
+    body: () => segmentsCalls.at(-1) ?? [],
+    bodyPoints: () => (segmentsCalls.at(-1) ?? []).flat(),
+    restore: () => {
+      Date.now = realDateNow;
+    },
+  };
+}
+
+/** Distance from p to the nearest point of a polyline. */
+function distanceToPath(p, path) {
+  let best = Infinity;
+  const ab = new Cesium.Cartesian3();
+  const ap = new Cesium.Cartesian3();
+  const closest = new Cesium.Cartesian3();
+  if (path.length === 1) return Cesium.Cartesian3.distance(p, path[0]);
+  for (let i = 1; i < path.length; i++) {
+    Cesium.Cartesian3.subtract(path[i], path[i - 1], ab);
+    Cesium.Cartesian3.subtract(p, path[i - 1], ap);
+    const len2 = Cesium.Cartesian3.magnitudeSquared(ab);
+    const t =
+      len2 > 0
+        ? Math.max(0, Math.min(1, Cesium.Cartesian3.dot(ap, ab) / len2))
+        : 0;
+    Cesium.Cartesian3.add(
+      path[i - 1],
+      Cesium.Cartesian3.multiplyByScalar(ab, t, closest),
+      closest,
+    );
+    best = Math.min(best, Cesium.Cartesian3.distance(p, closest));
+  }
+  return best;
+}
+
+/** No vertex turns the line back sharper than 120° over a short step. */
+function assertNoSpur(line, label) {
+  const u = new Cesium.Cartesian3();
+  const v = new Cesium.Cartesian3();
+  for (let i = 1; i < line.length - 1; i++) {
+    Cesium.Cartesian3.subtract(line[i], line[i - 1], u);
+    Cesium.Cartesian3.subtract(line[i + 1], line[i], v);
+    const lu = Cesium.Cartesian3.magnitude(u);
+    const lv = Cesium.Cartesian3.magnitude(v);
+    if (!(lu > 0 && lv > 0) || Math.min(lu, lv) > 500) continue;
+    const cos = Cesium.Cartesian3.dot(u, v) / (lu * lv);
+    assert.ok(
+      cos >= -0.5,
+      `${label}: spur at vertex ${i} of ${line.length} (turn ${(
+        (Math.acos(cos) * 180) /
+        Math.PI
+      ).toFixed(0)}°)`,
+    );
+  }
+}
+
+const indexOfPoint = (line, p) =>
+  line.findIndex((q) => Cesium.Cartesian3.distance(p, q) < 0.01);
+
+// A departing jet: four northbound climb reports, then a left turn through
+// west to south with no report while the icon flies it.
+function departure() {
+  const fixes = [
+    fix(T0, 37.6329, -122.3661, 213, 85, 8),
+    fix(T0 + 30 * SEC, 37.6542, -122.3616, 495, 95, 0),
+    fix(T0 + 60 * SEC, 37.6813, -122.3615, 808, 104, 350),
+    fix(T0 + 90 * SEC, 37.7066, -122.3755, 1257, 112, 340),
+  ];
+  const info = {
+    altitudeFt: 4_124,
+    renderAltitudeM: 1257,
+    rawLat: 37.7066,
+    rawLon: -122.3755,
+    speedMps: 112,
+    track: 340,
+    turnRateDps: -2,
+    onGround: false,
+    wasAirborne: true,
+    lastContactEpochMs: T0 + 200 * SEC,
+  };
+  return { fixes, info };
+}
+
+test('military: a report newer than the display time arrives mid-turn, and the trail between the reports stays on the drawn arc', () => {
+  const { fixes, info } = departure();
+  const start = T0 + 90 * SEC + RENDER_DELAY_SEC * SEC;
+  const h = harness({ fixes, info, nowMs: start });
+  try {
+    h.tracking._startTrail(ICAO);
+    // 40 s of turn with no new report: the icon flies the arc.
+    h.run(start + 40 * SEC);
+    const arc = h.drawn.slice();
+    // The next report is where the plane really was 60 s after the last one,
+    // still ahead of the display time (normal 30 s delay, slow feed). The icon
+    // now interpolates the straight line between the two reports and is eased
+    // onto it.
+    const at60 = h.motion._deadReckon(
+      ICAO,
+      new Cesium.Cartesian3(),
+      Cesium.JulianDate.fromDate(new Date(T0 + 150 * SEC)),
+    );
+    const c = Cesium.Cartographic.fromCartesian(at60);
+    const report = fix(
+      T0 + 150 * SEC,
+      Cesium.Math.toDegrees(c.latitude),
+      Cesium.Math.toDegrees(c.longitude),
+      c.height,
+      112,
+      220,
+    );
+    fixes.push(report);
+    info.track = 220;
+    h.tracking._appendTrailFix(
+      Cesium.Cartesian3.clone(report.position),
+      report.epochMs,
+    );
+    // The display passes the new report.
+    h.run(start + 75 * SEC);
+    const line = h.bodyPoints();
+    const from = indexOfPoint(line, fixes[3].position);
+    const to = indexOfPoint(line, report.position);
+    assert.ok(from >= 0 && to > from, 'both reports are on the trail');
+    const between = line.slice(from, to + 1);
+    // Every vertex between the reports is where the icon was drawn...
+    const drawnPath = [fixes[3].position, ...h.drawn, report.position];
+    for (const vertex of between) {
+      const off = distanceToPath(vertex, drawnPath);
+      assert.ok(
+        off < 50,
+        `trail vertex ${off.toFixed(0)} m off the drawn path`,
+      );
+    }
+    // ...and the arc the icon flew is still there: no straight chord. (The
+    // arc strays far from the chord, so a chord would fail this.)
+    const chord = [fixes[3].position, report.position];
+    assert.ok(Math.max(...arc.map((p) => distanceToPath(p, chord))) > 300);
+    // The last 10 s of the arc are exempt: the correction pulled the icon back
+    // over them, and keeping them would fold the line back on itself.
+    for (const point of arc.slice(0, -100)) {
+      const off = distanceToPath(point, between);
+      assert.ok(off < 50, `drawn arc point ${off.toFixed(0)} m from the trail`);
+    }
+    assertNoSpur(line, 'trail');
+    assertNoSpur(h.head(), 'head');
+  } finally {
+    h.restore();
+  }
+});
+
+test('military: a report the display already passed replaces the guess drawn after it, with no spike', () => {
+  const { fixes, info } = departure();
+  const start = T0 + 90 * SEC + RENDER_DELAY_SEC * SEC;
+  const h = harness({ fixes, info, nowMs: start });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(start + 40 * SEC);
+    const displayMs = T0 + 130 * SEC;
+    // A report for 10 s before the display time, 400 m inside the drawn arc.
+    const guess = h.motion._deadReckon(
+      ICAO,
+      new Cesium.Cartesian3(),
+      Cesium.JulianDate.fromDate(new Date(T0 + 120 * SEC)),
+    );
+    const c = Cesium.Cartographic.fromCartesian(guess);
+    const report = fix(
+      T0 + 120 * SEC,
+      Cesium.Math.toDegrees(c.latitude) - 400 / 111_320,
+      Cesium.Math.toDegrees(c.longitude),
+      c.height,
+      112,
+      250,
+    );
+    fixes.push(report);
+    info.track = 250;
+    h.tracking._appendTrailFix(
+      Cesium.Cartesian3.clone(report.position),
+      report.epochMs,
+    );
+    h.run(start + 55 * SEC);
+    const recorded = h.flightState._trailFixes.filter((entry) => entry.drawn);
+    // Nothing recorded between the report and the end of the ease.
+    assert.deepEqual(
+      recorded
+        .filter(
+          (entry) =>
+            entry.timeMs > report.epochMs && entry.timeMs < displayMs + 900,
+        )
+        .map((entry) => entry.timeMs - T0),
+      [],
+    );
+    const line = h.bodyPoints();
+    assert.ok(indexOfPoint(line, report.position) >= 0);
+    assertNoSpur(line, 'trail');
+  } finally {
+    h.restore();
+  }
+});
+
+test('military: a history report at an invented height is seeded with no position, and nothing is recorded next to it', () => {
+  const { fixes, info } = departure();
+  fixes[3].inventedHeight = true;
+  const start = T0 + 90 * SEC + RENDER_DELAY_SEC * SEC;
+  const h = harness({ fixes, info, nowMs: start });
+  try {
+    h.tracking._startTrail(ICAO);
+    const seeded = h.flightState._trailFixes.find(
+      (entry) => entry.timeMs === fixes[3].epochMs,
+    );
+    assert.equal(seeded.position, null);
+    assert.equal(seeded.nullAltitude, true);
+    h.run(start + 10 * SEC);
+    assert.equal(
+      h.flightState._trailFixes.filter((entry) => entry.drawn).length,
+      0,
+    );
+  } finally {
+    h.restore();
+  }
+});
+
+// A turboprop at FL210 flying east out of receiver coverage: its last
+// position is at T0 + 30 s, and contact goes on for four more minutes.
+function outOfCoverage() {
+  const fixes = [
+    fix(T0, 43, -108.1, 6_400, 140, 90),
+    fix(T0 + 30 * SEC, 43, -108.05, 6_400, 140, 90),
+  ];
+  const info = {
+    altitudeFt: 21_000,
+    renderAltitudeM: 6_400,
+    rawLat: 43,
+    rawLon: -108.05,
+    speedMps: 140,
+    track: 90,
+    callsign: 'TEST7',
+    turnRateDps: 0,
+    onGround: false,
+    wasAirborne: true,
+    lastContactEpochMs: T0 + 30 * SEC + 240 * SEC,
+  };
+  return { fixes, info };
+}
+
+/** Display time (ms) `afterSec` past the last report. */
+const pastReport = (afterSec) =>
+  T0 + 30 * SEC + RENDER_DELAY_SEC * SEC + afterSec * SEC;
+
+test('military: a plane that stops reporting keeps moving dimmed as STALE from its first missed update, then stops as SIGNAL LOST', () => {
+  const { fixes, info } = outOfCoverage();
+  const h = harness({ fixes, info, nowMs: pastReport(-5) });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(pastReport(30));
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: '',
+      dimmed: false,
+    });
+    assert.equal(h.tracking._trackedIconColor().alpha, 1);
+    // The first missed update.
+    h.flightState.records.missingPolls.set(ICAO, 1);
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: 'STALE',
+      dimmed: true,
+    });
+    assert.match(
+      h.tracking._buildTrackedLabel(h.flightState.records.data.get(ICAO), ICAO),
+      /STALE/,
+    );
+    // Drawn with the fleet's stale fade.
+    assert.equal(h.tracking._trackedIconColor().alpha, STALE_ALPHA);
+    // Still moving well past 90 s.
+    h.run(pastReport(200));
+    assert.ok(
+      Cesium.Cartesian3.distance(h.drawn.at(-1), h.drawn.at(-11)) > 100,
+    );
+    // The coast ends 300 s past the report; the plane stops there.
+    h.run(pastReport(310));
+    const recorded = h.flightState._trailFixes.filter((e) => e.drawn).length;
+    h.run(pastReport(330));
+    assert.ok(
+      Cesium.Cartesian3.distance(h.drawn.at(-1), h.drawn.at(-50)) < 0.01,
+    );
+    assert.equal(
+      h.flightState._trailFixes.filter((e) => e.drawn).length,
+      recorded,
+      'the trail kept recording a stopped plane',
+    );
+    // 330 s of display past the report is 330 s + the display delay of wall time.
+    const minutes = Math.floor((330 + RENDER_DELAY_SEC) / 60);
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: `SIGNAL LOST · ${minutes} min`,
+      dimmed: true,
+    });
+    assert.match(
+      h.tracking._buildTrackedLabel(h.flightState.records.data.get(ICAO), ICAO),
+      new RegExp(`SIGNAL LOST · ${minutes} min`),
+    );
+  } finally {
+    h.restore();
+  }
+});
+
+test('military: a plane held at its last report shows SIGNAL LOST in seconds under a minute', () => {
+  // Its last report is 100 m above a known ground height: it holds there.
+  const { fixes, info } = outOfCoverage();
+  const h = harness({
+    fixes,
+    info,
+    nowMs: pastReport(-5),
+    ground: () => 6_300,
+  });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.flightState.records.missingPolls.set(ICAO, 1);
+    h.run(pastReport(10));
+    assert.ok(10 + RENDER_DELAY_SEC < 60);
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: `SIGNAL LOST · ${10 + RENDER_DELAY_SEC} s`,
+      dimmed: true,
+    });
+  } finally {
+    h.restore();
+  }
+});
+
+test('military: a report arriving 200 s into a coast: the plane eases onto it and the trail drops what was drawn after it', () => {
+  const { fixes, info } = outOfCoverage();
+  const h = harness({ fixes, info, nowMs: pastReport(-5) });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(pastReport(200));
+    // Heard again: the report is for 10 s before the display time, 2 km north
+    // of where the coast put it.
+    const at = T0 + 30 * SEC + 190 * SEC;
+    const guess = h.motion._deadReckon(
+      ICAO,
+      new Cesium.Cartesian3(),
+      Cesium.JulianDate.fromDate(new Date(at)),
+    );
+    const c = Cesium.Cartographic.fromCartesian(guess);
+    const report = fix(
+      at,
+      Cesium.Math.toDegrees(c.latitude) + 2_000 / 111_320,
+      Cesium.Math.toDegrees(c.longitude),
+      c.height,
+      140,
+      90,
+    );
+    fixes.push(report);
+    h.tracking._appendTrailFix(
+      Cesium.Cartesian3.clone(report.position),
+      report.epochMs,
+    );
+    assert.deepEqual(
+      h.flightState._trailFixes.filter(
+        (e) => e.drawn && e.timeMs > report.epochMs,
+      ),
+      [],
+    );
+    const from = h.drawn.length;
+    h.run(pastReport(203));
+    const after = h.drawn.slice(from - 1);
+    for (let i = 1; i < after.length; i++)
+      assert.ok(
+        Cesium.Cartesian3.distance(after[i], after[i - 1]) < 400,
+        'the plane jumped instead of easing',
+      );
+    // Eased onto the path from the report: 13 s on from it at 140 m/s.
+    const off = Cesium.Cartesian3.distance(after.at(-1), report.position);
+    assert.ok(
+      Math.abs(off - 140 * 13) < 150,
+      `${off.toFixed(0)} m from the report`,
+    );
+  } finally {
+    h.restore();
+  }
+});
+
+test('military: a tracked plane that stops reporting: STALE from the first missed poll, SIGNAL LOST after the five-minute coast, kept at 9 min, removed at 10 min', () => {
+  const { fixes, info } = outOfCoverage();
+  const fixMs = fixes.at(-1).epochMs;
+  // Contact stops with the position: the plane left coverage.
+  info.lastContactEpochMs = fixMs;
+  info.newestFixMs = fixMs;
+  const h = harness({ fixes, info, nowMs: fixMs + 5 * SEC });
+  try {
+    h.tracking._startTrail(ICAO);
+    const records = h.flightState.records;
+    const polls = new Map();
+    let removedAtSec = null;
+    // A poll every 10 s that lists the plane without a position.
+    for (let afterSec = 10; afterSec <= 660; afterSec += 10) {
+      h.run(fixMs + afterSec * SEC, { frameMs: 500, readHead: false });
+      const result = records.absence(ICAO, {
+        complete: true,
+        retainIds: new Set([ICAO]),
+        likelyLanded: false,
+        tracked: true,
+      });
+      if (result === 'remove') {
+        removedAtSec = afterSec;
+        break;
+      }
+      polls.set(afterSec, {
+        cue: h.tracking._trackedStaleCue(ICAO),
+        drawn: Cesium.Cartesian3.clone(h.drawn.at(-1)),
+      });
+    }
+    // Wall time when the display reaches the end of the coast.
+    const coastEndSec = 300 + RENDER_DELAY_SEC;
+    for (const [afterSec, { cue }] of polls) {
+      if (afterSec <= coastEndSec) {
+        assert.deepEqual(cue, { text: 'STALE', dimmed: true }, `${afterSec} s`);
+      } else {
+        assert.deepEqual(
+          cue,
+          {
+            text: `SIGNAL LOST · ${Math.floor(afterSec / 60)} min`,
+            dimmed: true,
+          },
+          `${afterSec} s`,
+        );
+      }
+    }
+    const moved = (a, b) =>
+      Cesium.Cartesian3.distance(polls.get(a).drawn, polls.get(b).drawn);
+    // Moving through the coast, still at its last speed at four minutes.
+    assert.ok(Math.abs(moved(230, 240) - 140 * 10) < 20);
+    // Stopped once the coast has ended.
+    const after = Math.ceil(coastEndSec / 10) * 10;
+    assert.ok(moved(after, 540) < 0.01);
+    assert.equal(polls.get(300).cue.text, 'STALE');
+    assert.deepEqual(polls.get(540).cue, {
+      text: 'SIGNAL LOST · 9 min',
+      dimmed: true,
+    });
+    assert.equal(removedAtSec, 600);
+  } finally {
+    h.restore();
+  }
+});
+
+test('military: a repeated old fix counts as a missed update for the tracked plane', () => {
+  const { fixes, info } = outOfCoverage();
+  const h = harness({ fixes, info, nowMs: pastReport(-5) });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(pastReport(-2));
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: '',
+      dimmed: false,
+    });
+    // The feed re-sends the last position: its fix time did not advance.
+    h.flightState.records.fixRepeated.add(ICAO);
+    assert.deepEqual(h.tracking._trackedStaleCue(ICAO), {
+      text: 'STALE',
+      dimmed: true,
+    });
+    assert.equal(h.tracking._trackedIconColor().alpha, STALE_ALPHA);
+    assert.equal(h.flightState.records.missingPolls.has(ICAO), false);
+  } finally {
+    h.restore();
+  }
+});
+
+test('military: a report arriving after the plane has stopped: it eases in with no spur, and the trail keeps everything up to the stop', () => {
+  const { fixes, info } = outOfCoverage();
+  info.lastContactEpochMs = fixes.at(-1).epochMs;
+  const h = harness({ fixes, info, nowMs: pastReport(-5) });
+  try {
+    h.tracking._startTrail(ICAO);
+    h.run(pastReport(360));
+    const stop = Cesium.Cartesian3.clone(h.drawn.at(-1));
+    assert.ok(Cesium.Cartesian3.distance(stop, h.drawn.at(-100)) < 0.01);
+    const kept = h.flightState._trailFixes
+      .filter((e) => e.drawn)
+      .map((e) => Cesium.Cartesian3.clone(e.position));
+    // The thinned straight coast, recorded up to where the plane stopped.
+    assert.ok(kept.length >= 2);
+    assert.ok(Cesium.Cartesian3.distance(kept.at(-1), stop) < 300);
+    // Heard again, for 20 s before the display time: the plane flew on, a
+    // little north of its old heading.
+    const at = T0 + 30 * SEC + 340 * SEC;
+    const lonDeg =
+      -108.05 + (140 * 340) / (111_320 * Math.cos((43 * Math.PI) / 180));
+    const report = fix(at, 43 + 1_000 / 111_320, lonDeg, 6_400, 140, 90);
+    fixes.push(report);
+    h.tracking._appendTrailFix(
+      Cesium.Cartesian3.clone(report.position),
+      report.epochMs,
+    );
+    // Nothing was recorded after the stop, so nothing is dropped.
+    const after = h.flightState._trailFixes
+      .filter((e) => e.drawn)
+      .map((e) => e.position);
+    assert.equal(after.length, kept.length);
+    kept.forEach((p, i) =>
+      assert.ok(Cesium.Cartesian3.distance(p, after[i]) < 0.01),
+    );
+    const from = h.drawn.length;
+    h.run(pastReport(365));
+    const eased = h.drawn.slice(from - 1);
+    const jump = Cesium.Cartesian3.distance(eased[0], eased.at(-1));
+    for (let i = 1; i < eased.length; i++)
+      assert.ok(
+        Cesium.Cartesian3.distance(eased[i], eased[i - 1]) < jump / 2,
+        'the plane jumped instead of easing',
+      );
+    // On the path from the report: 25 s on from it at 140 m/s.
+    const off = Cesium.Cartesian3.distance(eased.at(-1), report.position);
+    assert.ok(Math.abs(off - 140 * 25) < 150, `${off.toFixed(0)} m`);
+    assertNoSpur(h.bodyPoints(), 'trail');
+    assertNoSpur(h.head(), 'head');
+    assert.ok(indexOfPoint(h.bodyPoints(), report.position) >= 0);
+  } finally {
+    h.restore();
+  }
+});

From 8e25105a6ce78f6ec787948caefc15dc89543cfa Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Tue, 10 Nov 2026 11:33:14 -0800
Subject: [PATCH 69/71] docs(changelog): flight trails and SIGNAL LOST (#1654)

---
 changelog.d/1654-flight-trails-signal-lost.md | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 changelog.d/1654-flight-trails-signal-lost.md

diff --git a/changelog.d/1654-flight-trails-signal-lost.md b/changelog.d/1654-flight-trails-signal-lost.md
new file mode 100644
index 000000000..933708459
--- /dev/null
+++ b/changelog.d/1654-flight-trails-signal-lost.md
@@ -0,0 +1,7 @@
+- A tracked flight's trail splits at feed gaps, impossible jumps and reports
+  without altitude instead of joining a day of history into one line, keeps
+  every history point, and follows the path the aircraft was drawn along so it
+  no longer cuts across turns. A tracked aircraft that stops reporting shows
+  STALE, keeps flying on its last heading for five minutes, then stops dimmed
+  as SIGNAL LOST and is kept ten minutes after its last report; aircraft on or
+  near the ground hold instead (Sameh Khamis, @samehkhamis, #1654).

From 486a78ad8e1769fc00751f3d5cecba8f323c00c6 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Tue, 10 Nov 2026 11:37:04 -0800
Subject: [PATCH 70/71] fix(flights): a long flight keeps its route when it is
 up to 15% of the route's length off the great circle
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The route check allowed 200 km off the great circle between the airports, so a
coast-to-coast flight routed a few hundred kilometres around weather lost its
origin and destination (JFK–SFO over Kansas, 384 km south). The tolerance is
now 200 km or 15% of the route's length, whichever is larger: 623 km for
JFK–SFO, and still 200 km for a short hop, so a wrong leg stays hidden.
---
 docs/CURRENT-STATE.md            |  7 +++++--
 src/data/routePlausible.js       | 11 ++++++++++-
 src/data/routePlausible.test.mjs | 18 ++++++++++++++++++
 3 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 5c2e52c58..4fa9edd5b 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4257,8 +4257,11 @@ down | auth-failed` (plus the unchanged `missing-key`/`unsupported`) with
 >   advances dead reckoning from the host frame.
 > - **Scheduled route plausibility:** Aircraft route labels and selected-route
 >   context reject the distant backwards, forwards and antipodal extensions of
->   an airport pair's great circle. The existing 130 km endpoint admission and
->   200 km cross-track tolerance remain; a projected fix outside the finite
+>   an airport pair's great circle. The existing 130 km endpoint admission
+>   remains; the cross-track tolerance is 200 km or 15% of the route's length,
+>   whichever is larger (JFK–SFO allows 623 km, as airways and winds take a
+>   coast-to-coast flight several hundred kilometres off the great circle); a
+>   projected fix outside the finite
 >   origin-to-destination minor arc also has a generous 200 km extension at
 >   either end. Missing coordinates and coincident or antipodal endpoint pairs
 >   retain their loose, unjudgeable behavior; vertical-trend checks are unchanged.
diff --git a/src/data/routePlausible.js b/src/data/routePlausible.js
index d52b44ef8..7b2cffc06 100644
--- a/src/data/routePlausible.js
+++ b/src/data/routePlausible.js
@@ -46,7 +46,13 @@ function alongTrackKm(position, origin, destination) {
 }
 
 const NEAR_ENDPOINT_KM = 130;
+/** Least allowed distance off the great circle, and how far past either
+ *  endpoint the plane may be along it. */
 const CROSS_TRACK_KM = 200;
+/** On a long route the allowed distance off the great circle grows to this
+ *  share of its length: airways and winds take a coast-to-coast flight several
+ *  hundred kilometres off it (JFK–SFO: 623 km). */
+const CROSS_TRACK_ROUTE_FRACTION = 0.15;
 const LOW_ALT_M = 3700; // ~12 000 ft
 const VERT_TREND_MPS = 2; // ~400 fpm
 const LOCAL_AIRPORT_KM = 150;
@@ -90,6 +96,9 @@ export function routePlausible({
     // existing loose check when the segment cannot be judged reliably.
     const segmentKnown =
       routeKm > 0.001 && routeKm < Math.PI * EARTH_RADIUS_KM - 0.001;
+    const corridorKm = segmentKnown
+      ? Math.max(CROSS_TRACK_KM, CROSS_TRACK_ROUTE_FRACTION * routeKm)
+      : CROSS_TRACK_KM;
     geomOk =
       Math.abs(
         crossTrackKm(
@@ -100,7 +109,7 @@ export function routePlausible({
           destination.lat,
           destination.lon,
         ),
-      ) < CROSS_TRACK_KM &&
+      ) < corridorKm &&
       (!segmentKnown ||
         (segmentAlongKm >= -CROSS_TRACK_KM &&
           segmentAlongKm <= routeKm + CROSS_TRACK_KM));
diff --git a/src/data/routePlausible.test.mjs b/src/data/routePlausible.test.mjs
index aa59a0c18..f4ca0c573 100644
--- a/src/data/routePlausible.test.mjs
+++ b/src/data/routePlausible.test.mjs
@@ -27,6 +27,24 @@ test('plane in London with an SFO→LAX route: implausible', () => {
   }), false);
 });
 
+test('a long route allows a wider corridor; a short one does not', () => {
+  // JFK→SFO over Kansas, 384 km south of the great circle.
+  assert.equal(routePlausible({
+    latDeg: 38.21, lonDeg: -99.69, altitudeM: 10370, verticalRateMps: 0,
+    origin: JFK, destination: SFO,
+  }), true);
+  // 516 km off the 543 km SFO→LAX route is still the wrong route.
+  assert.equal(routePlausible({
+    latDeg: 37.9, lonDeg: -115.0, altitudeM: 10000, verticalRateMps: 0,
+    origin: SFO, destination: LAX,
+  }), false);
+  // 960 km off, past 15 % of the 4,152 km JFK→SFO route, is still wrong.
+  assert.equal(routePlausible({
+    latDeg: 33.0, lonDeg: -99.69, altitudeM: 10000, verticalRateMps: 0,
+    origin: JFK, destination: SFO,
+  }), false);
+});
+
 test('vertical trend: low climbing plane near SFO — origin must be local', () => {
   const nearSfo = { latDeg: 37.7, lonDeg: -122.4, altitudeM: 2500 };
   // JFK→SFO passes geometry (near destination), but a CLIMBING plane here just

From b97b49cf1d3169181f35a0ebcba6c9cb9b138943 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Tue, 10 Nov 2026 11:37:14 -0800
Subject: [PATCH 71/71] docs(changelog): long-route corridor (#1655)

---
 changelog.d/1655-long-route-corridor.md | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 changelog.d/1655-long-route-corridor.md

diff --git a/changelog.d/1655-long-route-corridor.md b/changelog.d/1655-long-route-corridor.md
new file mode 100644
index 000000000..5bc1bd84b
--- /dev/null
+++ b/changelog.d/1655-long-route-corridor.md
@@ -0,0 +1,4 @@
+- A long flight keeps its origin and destination when weather or airways take
+  it far off the great circle: the route check now allows 200 km or 15% of the
+  route's length, whichever is larger (623 km for JFK–SFO), while a short hop
+  still allows 200 km (Sameh Khamis, @samehkhamis, #1655).