Merge remote-tracking branch 'upstream/main' into rb/opensky-scope

src/app/application.test.mjs

@@ -2,7 +2,20 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
 import { createApplication } from './application.js';
-import { installTrackpadPinchZoom } from './viewer.js';
+import { KEYHOLE_OUTER_RADIUS } from '../celestialRing.js';
+import * as Cesium from 'cesium';
+import {
+  installFreeLookHeightLimit,
+  installGlobeInViewRecovery,
+  installTrackpadPinchZoom,
+} from './viewer.js';
+import {
+  FREE_LOOK_MAX_HEIGHT_METERS,
+  globeFrameShare,
+  globeOutOfFrame,
+  lookAngleWithinFrame,
+  lookStepLosesGlobe,
+} from '../globeInView.js';
 
 const phases = ['Scene', 'Controls', 'Data', 'Tools'];
 function fixture(overrides = {}) {
@@ -343,3 +356,652 @@ test('trackpad pinch falls back to the original event when relay construction fa
   assert.equal(event.propagationStopped, false);
   assert.equal(f.relayed.length, 0);
 });
+
+function freeLookFixture({ enableLook = true, height = 0 } = {}) {
+  const listeners = new Set();
+  const controller = { enableLook, minimumTrackBallHeight: 7_500_000 };
+  const camera = { positionCartographic: { height } };
+  const viewer = {
+    camera,
+    scene: {
+      screenSpaceCameraController: controller,
+      preUpdate: {
+        addEventListener(listener) {
+          listeners.add(listener);
+          return () => listeners.delete(listener);
+        },
+      },
+    },
+  };
+  const frame = (nextHeight) => {
+    camera.positionCartographic = { height: nextHeight };
+    for (const listener of listeners) listener();
+  };
+  return { viewer, controller, listeners, frame };
+}
+
+test('free look follows camera height and is restored on dispose', () => {
+  const f = freeLookFixture({ height: 500 });
+  const dispose = installFreeLookHeightLimit(f.viewer);
+  assert.equal(f.controller.enableLook, true);
+
+  f.frame(FREE_LOOK_MAX_HEIGHT_METERS + 1);
+  assert.equal(f.controller.enableLook, false);
+  f.frame(FREE_LOOK_MAX_HEIGHT_METERS);
+  assert.equal(f.controller.enableLook, true);
+  f.frame(Number.NaN);
+  assert.equal(f.controller.enableLook, true);
+
+  f.frame(FREE_LOOK_MAX_HEIGHT_METERS * 20);
+  dispose();
+  dispose();
+  assert.equal(f.controller.enableLook, true);
+  assert.equal(f.listeners.size, 0);
+});
+
+test('drags that start on the stars orbit above the free-look height', () => {
+  // Below Cesium's trackball height such a drag turns the camera in place.
+  const f = freeLookFixture({ height: 500 });
+  const dispose = installFreeLookHeightLimit(f.viewer);
+  assert.equal(
+    f.controller.minimumTrackBallHeight,
+    FREE_LOOK_MAX_HEIGHT_METERS,
+  );
+  dispose();
+  assert.equal(f.controller.minimumTrackBallHeight, 7_500_000);
+
+  const lower = freeLookFixture({ height: 500 });
+  lower.controller.minimumTrackBallHeight = 500_000;
+  const disposeLower = installFreeLookHeightLimit(lower.viewer);
+  assert.equal(
+    lower.controller.minimumTrackBallHeight,
+    500_000,
+    'never raised',
+  );
+  disposeLower();
+  assert.equal(lower.controller.minimumTrackBallHeight, 500_000);
+
+  const later = freeLookFixture({ height: 500 });
+  const disposeLater = installFreeLookHeightLimit(later.viewer);
+  later.controller.minimumTrackBallHeight = 2_000_000;
+  disposeLater();
+  assert.equal(
+    later.controller.minimumTrackBallHeight,
+    2_000_000,
+    'dispose keeps a value set after install',
+  );
+});
+
+test('free look keeps a setting other code makes after it is installed', () => {
+  const f = freeLookFixture({ height: 500 });
+  const dispose = installFreeLookHeightLimit(f.viewer);
+  f.controller.enableLook = false;
+  f.frame(10);
+  assert.equal(f.controller.enableLook, false, 'turned off stays off');
+  f.frame(FREE_LOOK_MAX_HEIGHT_METERS * 20);
+  f.frame(10);
+  assert.equal(f.controller.enableLook, false, 'and stays off after orbit');
+  f.controller.enableLook = true;
+  f.frame(10);
+  assert.equal(f.controller.enableLook, true, 'turned back on');
+  f.frame(FREE_LOOK_MAX_HEIGHT_METERS * 20);
+  assert.equal(f.controller.enableLook, false, 'still limited from orbit');
+  f.frame(10);
+  f.controller.enableLook = false;
+  dispose();
+  assert.equal(f.controller.enableLook, false, 'dispose keeps a later setting');
+});
+
+test('free look stays off when the viewer had it disabled', () => {
+  const f = freeLookFixture({ enableLook: false, height: 500 });
+  installFreeLookHeightLimit(f.viewer);
+  f.frame(10);
+  assert.equal(f.controller.enableLook, false);
+});
+
+// A real Cesium camera on the smallest scene its constructor reads, so the
+// frustum test runs on Cesium's own view math rather than a stub.
+function realCamera({ width = 1600, height = 900, mode } = {}) {
+  const scene = {
+    canvas: { clientWidth: width, clientHeight: height },
+    drawingBufferWidth: width,
+    drawingBufferHeight: height,
+    mapProjection: new Cesium.GeographicProjection(),
+    mode: mode ?? Cesium.SceneMode.SCENE3D,
+    pixelRatio: 1,
+    ellipsoid: Cesium.Ellipsoid.WGS84,
+    mapMode2D: Cesium.MapMode2D.INFINITE_SCROLL,
+    tweens: new Cesium.TweenCollection(),
+    renders: 0,
+    requestRender() {
+      this.renders += 1;
+    },
+  };
+  const camera = new Cesium.Camera(scene);
+  camera.frustum.aspectRatio = width / height;
+  return { camera, scene, viewer: { camera, scene } };
+}
+
+function aim(
+  camera,
+  { lon = -94.69, lat = 18.87, alt, heading = 0, pitch, roll = 0 },
+) {
+  camera.setView({
+    destination: Cesium.Cartesian3.fromDegrees(lon, lat, alt),
+    orientation: {
+      heading: Cesium.Math.toRadians(heading),
+      pitch: Cesium.Math.toRadians(pitch),
+      roll: Cesium.Math.toRadians(roll),
+    },
+  });
+}
+
+const reportedStuckView = {
+  alt: 17_996_811,
+  heading: 180,
+  pitch: -42,
+  roll: 180,
+};
+// Oblique poses that still show part of the planet: Director recipe shots
+// (Global Flights Radar, Omniscience Pullback) and a voice tilt from orbit.
+const partialGlobeViews = [
+  { lon: -30, lat: 20, alt: 19_000_000, pitch: -65 },
+  { lon: 2, lat: 46, alt: 8_000_000, pitch: -52 },
+  { lon: 110, lat: 20, alt: 9_500_000, pitch: -66 },
+  { lon: 0, lat: 0, alt: 2_000_000, pitch: -30 },
+];
+
+// Stars and a few pixels of limb, no surface: where a frame limit measured
+// against a sphere of the planet's largest radius used to stop a voice tilt.
+const limbOnlyView = { alt: 18_000_000, pitch: -56.75 };
+
+/**
+ * An oracle independent of the code under test: the share of an 80×45 grid of
+ * Cesium pick rays across the canvas that hit the ellipsoid surface.
+ */
+function surfacePixelShare(camera, width, height, { keyhole = false } = {}) {
+  const radius = (KEYHOLE_OUTER_RADIUS * height) / 2;
+  let hits = 0;
+  let counted = 0;
+  for (let row = 0; row < 45; row += 1) {
+    for (let column = 0; column < 80; column += 1) {
+      const x = ((column + 0.5) * width) / 80;
+      const y = ((row + 0.5) * height) / 45;
+      if (keyhole && Math.hypot(x - width / 2, y - height / 2) > radius)
+        continue;
+      counted += 1;
+      const ray = camera.getPickRay(new Cesium.Cartesian2(x, y));
+      if (Cesium.IntersectionTests.rayEllipsoid(ray, Cesium.Ellipsoid.WGS84))
+        hits += 1;
+    }
+  }
+  return hits / counted;
+}
+
+test('the globe is out of frame only when no surface is on screen', () => {
+  const cases = [
+    [reportedStuckView, 1225, 923, true],
+    [limbOnlyView, 1600, 900, true],
+    [{ alt: 17_996_811, pitch: -90 }, 1225, 923, false],
+    ...partialGlobeViews.map((view) => [view, 1600, 900, false]),
+  ];
+  for (const [view, width, height, out] of cases) {
+    const { camera } = realCamera({ width, height });
+    aim(camera, view);
+    const label = JSON.stringify(view);
+    assert.equal(globeOutOfFrame(camera), out, label);
+    assert.equal(surfacePixelShare(camera, width, height) === 0, out, label);
+    assert.ok(
+      Math.abs(
+        globeFrameShare(camera) - surfacePixelShare(camera, width, height),
+      ) < 0.03,
+      `${label}: the frame share matches the pick-ray oracle`,
+    );
+  }
+});
+
+test('a move that ends with the globe out of frame turns back to nadir', () => {
+  const { camera, scene, viewer } = realCamera({ width: 1225, height: 923 });
+  const dispose = installGlobeInViewRecovery(viewer);
+  aim(camera, reportedStuckView);
+  const position = Cesium.Cartesian3.clone(camera.positionWC);
+  const heading = camera.heading;
+  camera.moveEnd.raiseEvent();
+  assert.ok(Cesium.Math.equalsEpsilon(camera.pitch, -Math.PI / 2, 1e-6));
+  assert.ok(Cesium.Math.equalsEpsilon(camera.heading, heading, 1e-6));
+  assert.ok(
+    Cesium.Cartesian3.equalsEpsilon(camera.positionWC, position, 0, 1e-3),
+  );
+  assert.equal(globeOutOfFrame(camera), false);
+  assert.equal(scene.renders, 1);
+
+  // Looking up near the ground, then zoomed out past the limit.
+  aim(camera, { alt: 3_834_000, pitch: 10 });
+  camera.moveEnd.raiseEvent();
+  assert.ok(Cesium.Math.equalsEpsilon(camera.pitch, -Math.PI / 2, 1e-6));
+
+  // Only the limb on a 16:9 screen still counts as lost.
+  const wide = realCamera({ width: 1600, height: 900 });
+  const disposeWide = installGlobeInViewRecovery(wide.viewer);
+  aim(wide.camera, limbOnlyView);
+  wide.camera.moveEnd.raiseEvent();
+  assert.ok(Cesium.Math.equalsEpsilon(wide.camera.pitch, -Math.PI / 2, 1e-6));
+  disposeWide();
+
+  dispose();
+  dispose();
+  aim(camera, reportedStuckView);
+  camera.moveEnd.raiseEvent();
+  assert.equal(globeOutOfFrame(camera), true, 'disposed recovery is inert');
+});
+
+// True when a moveEnd leaves the camera's view direction as it was.
+function moveEndKeepsView(camera) {
+  const direction = Cesium.Cartesian3.clone(camera.directionWC);
+  camera.moveEnd.raiseEvent();
+  return Cesium.Cartesian3.equalsEpsilon(camera.directionWC, direction, 1e-9);
+}
+
+test('globe recovery leaves partial, low, locked and 2D views alone', () => {
+  for (const view of partialGlobeViews) {
+    const { camera, viewer } = realCamera();
+    installGlobeInViewRecovery(viewer);
+    aim(camera, view);
+    assert.ok(moveEndKeepsView(camera), JSON.stringify(view));
+  }
+
+  const low = realCamera();
+  installGlobeInViewRecovery(low.viewer);
+  aim(low.camera, { alt: 900_000, pitch: 85 });
+  assert.equal(globeOutOfFrame(low.camera), true);
+  assert.ok(moveEndKeepsView(low.camera), 'below the limit');
+
+  // Locked on a point in space, between it and the planet, facing away.
+  const locked = realCamera();
+  installGlobeInViewRecovery(locked.viewer);
+  locked.camera.lookAtTransform(
+    Cesium.Matrix4.fromTranslation(new Cesium.Cartesian3(30_000_000, 0, 0)),
+    new Cesium.Cartesian3(-1_000_000, 0, 0),
+  );
+  assert.equal(globeOutOfFrame(locked.camera), true);
+  assert.ok(moveEndKeepsView(locked.camera), 'locked camera');
+
+  // Tracking an entity that has no position yet keeps an identity transform.
+  const tracked = realCamera();
+  tracked.viewer.trackedEntity = { id: 'pending-fix' };
+  installGlobeInViewRecovery(tracked.viewer);
+  aim(tracked.camera, reportedStuckView);
+  assert.ok(moveEndKeepsView(tracked.camera), 'tracked camera');
+
+  const flat = realCamera({ mode: Cesium.SceneMode.COLUMBUS_VIEW });
+  installGlobeInViewRecovery(flat.viewer);
+  flat.scene.mode = Cesium.SceneMode.SCENE3D;
+  aim(flat.camera, reportedStuckView);
+  flat.scene.mode = Cesium.SceneMode.COLUMBUS_VIEW;
+  assert.ok(moveEndKeepsView(flat.camera), 'Columbus view');
+});
+
+test('the look limit from orbit tolerates grid noise and never reaches zero', () => {
+  const radians = Cesium.Math.toRadians;
+  // About 2% of a 16:9 frame on the planet, below the 10% limit.
+  const sliver = { alt: 18_000_000, pitch: -60 };
+  const { camera } = realCamera();
+  aim(camera, sliver);
+  const start = surfacePixelShare(camera, 1600, 900);
+  assert.ok(start > 0 && start < 0.1, `starts below the limit: ${start}`);
+
+  // Sideways across the sliver: the share wobbles by a cell, the planet stays.
+  assert.equal(lookStepLosesGlobe(camera, 'lookLeft', radians(0.5)), false);
+  const startShare = globeFrameShare(camera);
+  for (let i = 0; i < 20; i += 1) {
+    const step = lookAngleWithinFrame(camera, 'lookLeft', radians(0.25), {
+      startShare,
+    });
+    assert.equal(step, radians(0.25), `sideways step ${i + 1}`);
+    camera.lookLeft(step);
+  }
+  assert.ok(surfacePixelShare(camera, 1600, 900) > 0);
+
+  // Toward the planet is always allowed.
+  aim(camera, sliver);
+  assert.equal(
+    lookAngleWithinFrame(camera, 'lookDown', radians(10)),
+    radians(10),
+  );
+
+  // Away from it stops short of losing it.
+  aim(camera, sliver);
+  const away = lookAngleWithinFrame(camera, 'lookUp', radians(30));
+  assert.ok(away < radians(30));
+  camera.lookUp(away);
+  assert.ok(globeFrameShare(camera) > 0);
+  assert.ok(surfacePixelShare(camera, 1600, 900) > 0);
+});
+
+test('the look limit leaves a view with no surface to the move-end recovery', () => {
+  const { camera } = realCamera({ width: 1225, height: 923 });
+  aim(camera, reportedStuckView);
+  assert.equal(
+    lookAngleWithinFrame(camera, 'lookUp', Cesium.Math.toRadians(5)),
+    Cesium.Math.toRadians(5),
+  );
+});
+
+// Surface only in the corners of a 16:9 frame, all of it outside the scope's
+// keyhole: the full frame shows some planet, the scope shows none.
+const cornerOnlyView = { alt: 18_000_000, pitch: -52, roll: 60 };
+
+test('with a scope keyhole, surface hidden in the masked corners counts as none', () => {
+  const { camera } = realCamera();
+  aim(camera, cornerOnlyView);
+  const keyhole = { keyholeRadius: KEYHOLE_OUTER_RADIUS };
+  assert.ok(surfacePixelShare(camera, 1600, 900) > 0);
+  assert.equal(surfacePixelShare(camera, 1600, 900, { keyhole: true }), 0);
+  assert.equal(globeOutOfFrame(camera), false);
+  assert.equal(globeOutOfFrame(camera, keyhole), true);
+  aim(camera, { alt: 18_000_000, pitch: -90 });
+  assert.ok(
+    Math.abs(
+      globeFrameShare(camera, keyhole) -
+        surfacePixelShare(camera, 1600, 900, { keyhole: true }),
+    ) < 0.03,
+    'the keyhole share matches the pick-ray oracle',
+  );
+});
+
+test('the recovery follows the scope: corner-only views are turned back only behind it', () => {
+  for (const [scopeOn, expectRecovery] of [
+    [true, true],
+    [false, false],
+  ]) {
+    const { camera, viewer } = realCamera();
+    installGlobeInViewRecovery(viewer, {
+      keyholeRadius: () => (scopeOn ? KEYHOLE_OUTER_RADIUS : 0),
+    });
+    aim(camera, cornerOnlyView);
+    camera.moveEnd.raiseEvent();
+    assert.equal(
+      Cesium.Math.equalsEpsilon(camera.pitch, -Math.PI / 2, 1e-6),
+      expectRecovery,
+      `scope ${scopeOn ? 'on' : 'off'}`,
+    );
+  }
+});
+
+test('the recovery leaves a camera flight and an authored scene alone', () => {
+  let playing = true;
+  const { camera, scene, viewer } = realCamera({ width: 1225, height: 923 });
+  scene.camera = camera;
+  scene.screenSpaceCameraController = { enableInputs: true };
+  installGlobeInViewRecovery(viewer, { paused: () => playing });
+  aim(camera, reportedStuckView);
+  camera.moveEnd.raiseEvent();
+  assert.equal(globeOutOfFrame(camera), true, 'a playing scene is left alone');
+  playing = false;
+
+  // A flight that pauses looking away is left alone until it ends.
+  camera.flyTo({
+    destination: Cesium.Cartesian3.fromDegrees(10, 20, 18_000_000),
+    duration: 5,
+  });
+  camera.moveEnd.raiseEvent();
+  assert.equal(globeOutOfFrame(camera), true, 'a flight is left alone');
+  camera.cancelFlight();
+  camera.moveEnd.raiseEvent();
+  assert.ok(Cesium.Math.equalsEpsilon(camera.pitch, -Math.PI / 2, 1e-6));
+});
+
+test('a check a scene or flight defers runs once it ends', () => {
+  for (const viaMoveEnd of [false, true]) {
+    let playing = true;
+    const timers = fakeTimers();
+    const { camera, viewer } = realCamera({ width: 1225, height: 923 });
+    installGlobeInViewRecovery(viewer, {
+      paused: () => playing,
+      ...timers,
+    });
+    aim(camera, reportedStuckView);
+    camera.moveStart.raiseEvent();
+    // A hold on a stars-only shot: quiet, with or without Cesium's moveEnd.
+    for (let i = 0; i < 4; i += 1) timers.tick();
+    if (viaMoveEnd) camera.moveEnd.raiseEvent();
+    // Longer than the settle check's five-minute bound.
+    for (let i = 0; i < 1500; i += 1) timers.tick();
+    assert.equal(globeOutOfFrame(camera), true, 'left alone while it plays');
+    assert.equal(timers.pending(), 1, 'still watching');
+    playing = false;
+    timers.tick();
+    assert.ok(
+      Cesium.Math.equalsEpsilon(camera.pitch, -Math.PI / 2, 1e-6),
+      `recovered once the scene ends (${viaMoveEnd ? 'after moveEnd' : 'no moveEnd'})`,
+    );
+  }
+});
+
+// Holding a drag still for half a second on a view that already showed no
+// surface looked like a settled camera, and the view was turned down under
+// the user's hand.
+test('the recovery waits while a pointer is held on the globe', () => {
+  const timers = fakeTimers();
+  const { camera, scene, viewer } = realCamera({ width: 1225, height: 923 });
+  const document = new EventTarget();
+  scene.canvas = Object.assign(new EventTarget(), {
+    clientWidth: 1225,
+    clientHeight: 923,
+    ownerDocument: document,
+  });
+  const dispose = installGlobeInViewRecovery(viewer, timers);
+  aim(camera, reportedStuckView);
+  scene.canvas.dispatchEvent(new Event('pointerdown'));
+  camera.moveStart.raiseEvent();
+  for (let i = 0; i < 8; i += 1) timers.tick();
+  camera.moveEnd.raiseEvent();
+  for (let i = 0; i < 8; i += 1) timers.tick();
+  assert.equal(globeOutOfFrame(camera), true, 'left alone while held');
+  document.dispatchEvent(new Event('pointerup'));
+  for (let i = 0; i < 3; i += 1) timers.tick();
+  assert.ok(
+    Cesium.Math.equalsEpsilon(camera.pitch, -Math.PI / 2, 1e-6),
+    'recovered once the pointer is released',
+  );
+  dispose();
+  aim(camera, reportedStuckView);
+  scene.canvas.dispatchEvent(new Event('pointerdown'));
+  document.dispatchEvent(new Event('pointerup'));
+  assert.equal(timers.pending(), 0, 'disposed recovery holds no listeners');
+});
+
+/** A held-pointer recovery over a canvas in a document in a window. */
+function heldPointerRecovery() {
+  const timers = fakeTimers();
+  const { camera, scene, viewer } = realCamera({ width: 1225, height: 923 });
+  const window = new EventTarget();
+  const document = Object.assign(new EventTarget(), {
+    defaultView: window,
+    visibilityState: 'visible',
+  });
+  scene.canvas = Object.assign(new EventTarget(), {
+    clientWidth: 1225,
+    clientHeight: 923,
+    ownerDocument: document,
+  });
+  const dispose = installGlobeInViewRecovery(viewer, timers);
+  const pointer = (target, type, pointerId, init = {}) =>
+    target.dispatchEvent(
+      Object.assign(new Event(type), { pointerId, ...init }),
+    );
+  /** Press, move and hold still: the check defers while a pointer is held. */
+  const holdStill = () => {
+    aim(camera, reportedStuckView);
+    camera.moveStart.raiseEvent();
+    for (let i = 0; i < 8; i += 1) timers.tick();
+    camera.moveEnd.raiseEvent();
+    for (let i = 0; i < 8; i += 1) timers.tick();
+  };
+  const settle = () => {
+    for (let i = 0; i < 3; i += 1) timers.tick();
+  };
+  const recovered = () =>
+    Cesium.Math.equalsEpsilon(camera.pitch, -Math.PI / 2, 1e-6);
+  return {
+    camera,
+    document,
+    window,
+    dispose,
+    pointer,
+    holdStill,
+    settle,
+    recovered,
+    canvas: scene.canvas,
+  };
+}
+
+// Releasing one of two fingers cleared the held flag, and the recovery
+// turned the view down under the finger still on the glass.
+test('the recovery waits until every held pointer is released', () => {
+  const h = heldPointerRecovery();
+  h.pointer(h.canvas, 'pointerdown', 1);
+  h.pointer(h.canvas, 'pointerdown', 2);
+  h.holdStill();
+  h.pointer(h.document, 'pointerup', 1);
+  h.settle();
+  assert.equal(h.recovered(), false, 'left alone under the second finger');
+  assert.equal(globeOutOfFrame(h.camera), true);
+  h.pointer(h.document, 'pointercancel', 2);
+  h.settle();
+  assert.equal(h.recovered(), true, 'recovered once both are released');
+  h.dispose();
+});
+
+// A release the page never sees (the pointer let go outside the window)
+// must not hold the recovery off for good.
+for (const [label, lose] of [
+  ['the window loses focus', (h) => h.window.dispatchEvent(new Event('blur'))],
+  [
+    'the page is hidden',
+    (h) => {
+      h.document.visibilityState = 'hidden';
+      h.document.dispatchEvent(new Event('visibilitychange'));
+    },
+  ],
+  [
+    'the canvas loses the pointer capture',
+    (h) => h.pointer(h.canvas, 'lostpointercapture', 1),
+  ],
+  [
+    'the pointer moves with no button down',
+    (h) => h.pointer(h.document, 'pointermove', 1, { buttons: 0 }),
+  ],
+]) {
+  test(`a held pointer whose release is lost stops deferring when ${label}`, () => {
+    const h = heldPointerRecovery();
+    h.pointer(h.canvas, 'pointerdown', 1);
+    h.holdStill();
+    h.pointer(h.document, 'pointermove', 1, { buttons: 1 });
+    h.settle();
+    assert.equal(h.recovered(), false, 'left alone while held');
+    lose(h);
+    h.settle();
+    assert.equal(h.recovered(), true, 'recovered once the hold is let go');
+    h.dispose();
+  });
+}
+
+function fakeTimers() {
+  let next = 1;
+  const pending = new Map();
+  return {
+    setTimeout: (callback) => {
+      const id = next++;
+      pending.set(id, callback);
+      return id;
+    },
+    clearTimeout: (id) => pending.delete(id),
+    pending: () => pending.size,
+    /** Run the earliest pending callback, as 250 ms passing would. */
+    tick() {
+      const [id, callback] = pending.entries().next().value ?? [];
+      if (id === undefined) return false;
+      pending.delete(id);
+      callback();
+      return true;
+    },
+  };
+}
+
+test('a stuck view is recovered once it has held still, without waiting for moveEnd', () => {
+  // At this pose the camera can drift by a rounding error every frame, so
+  // Cesium never sees it stop and never raises moveEnd for it.
+  const timers = fakeTimers();
+  const { camera, viewer } = realCamera({ width: 1225, height: 923 });
+  installGlobeInViewRecovery(viewer, timers);
+  aim(camera, reportedStuckView);
+  camera.moveStart.raiseEvent();
+  timers.tick();
+  assert.equal(globeOutOfFrame(camera), true, 'one quiet sample is not enough');
+  // A rounding-error drift between samples still counts as at rest.
+  camera.lookUp(1e-15);
+  timers.tick();
+  assert.ok(Cesium.Math.equalsEpsilon(camera.pitch, -Math.PI / 2, 1e-6));
+  // Under that drift Cesium raises no new moveStart, so a later move that
+  // ends looking away is caught by the same check.
+  aim(camera, reportedStuckView);
+  timers.tick();
+  timers.tick();
+  assert.equal(globeOutOfFrame(camera), true, 'not yet at rest');
+  timers.tick();
+  assert.ok(Cesium.Math.equalsEpsilon(camera.pitch, -Math.PI / 2, 1e-6));
+  camera.moveEnd.raiseEvent();
+  assert.equal(timers.pending(), 0, 'moveEnd ends the check');
+});
+
+test('the settle check follows a long move and gives up five minutes after the last one', () => {
+  // A drag of half a minute that stops at a stuck pose is still recovered.
+  const long = fakeTimers();
+  const dragged = realCamera({ width: 1225, height: 923 });
+  installGlobeInViewRecovery(dragged.viewer, long);
+  aim(dragged.camera, reportedStuckView);
+  dragged.camera.moveStart.raiseEvent();
+  for (let i = 0; i < 120; i += 1) {
+    dragged.camera.moveLeft(0.01);
+    long.tick();
+  }
+  assert.equal(globeOutOfFrame(dragged.camera), true, 'still moving');
+  while (long.tick());
+  assert.ok(
+    Cesium.Math.equalsEpsilon(dragged.camera.pitch, -Math.PI / 2, 1e-6),
+    'recovered once it stopped',
+  );
+
+  // A camera that keeps moving is followed, and left alone, for as long as it
+  // moves; once it rests the check gives up five minutes later.
+  const timers = fakeTimers();
+  const { camera, viewer } = realCamera({ width: 1225, height: 923 });
+  installGlobeInViewRecovery(viewer, timers);
+  aim(camera, reportedStuckView);
+  camera.moveStart.raiseEvent();
+  for (let i = 0; i < 2000; i += 1) {
+    camera.moveLeft(0.01);
+    timers.tick();
+  }
+  assert.equal(timers.pending(), 1, 'still following after eight minutes');
+  assert.equal(globeOutOfFrame(camera), true, 'a moving camera is left alone');
+  let idleSamples = 0;
+  while (timers.tick()) idleSamples += 1;
+  assert.ok(
+    Cesium.Math.equalsEpsilon(camera.pitch, -Math.PI / 2, 1e-6),
+    'recovered once it stopped',
+  );
+  assert.ok(
+    idleSamples >= 1200 && idleSamples <= 1205,
+    `gave up ${idleSamples} samples after it stopped`,
+  );
+
+  const disposed = fakeTimers();
+  const other = realCamera({ width: 1225, height: 923 });
+  const dispose = installGlobeInViewRecovery(other.viewer, disposed);
+  aim(other.camera, reportedStuckView);
+  other.camera.moveStart.raiseEvent();
+  dispose();
+  assert.equal(disposed.pending(), 0, 'dispose cancels the pending check');
+});

src/app/catalog.js

@@ -5,6 +5,7 @@ const CONTROL_LAYER_IDS = Object.freeze({
   satellitesLayer: 'satellites',
   cctvLayer: 'cctv',
   streetLevelLayer: 'street-level',
+  wildlifeSightingsLayer: 'wildlife-sightings',
   radioLayer: 'radio',
   bikeshareLayer: 'bikeshare',
   transitLayer: 'transit',

src/app/catalog.test.mjs

@@ -139,6 +139,7 @@ test('controls bind catalog instances rather than similarly named defaults', ()
     'rocket-launches',
     'street-level',
     'local-adsb',
+    'wildlife-sightings',
   ];
   const layers = ids.map((id) => ({ id }));
   const catalog = createLayerCatalog(layers, metadata(layers));
@@ -147,6 +148,7 @@ test('controls bind catalog instances rather than similarly named defaults', ()
   assert.equal(services.transitLayer, layers[7]);
   assert.equal(services.aisLiveVesselsLayer, layers[8]);
   assert.equal(services.localAdsbLayer, layers[13]);
+  assert.equal(services.wildlifeSightingsLayer, layers[14]);
   assert.equal(new Set(Object.values(services)).size, layers.length);
   assert.throws(
     () => catalogControlServices(createLayerCatalog([], [])),

src/app/constructCatalog.js

@@ -1,7 +1,7 @@
 import { resolveCatalogSources } from './sourceComposition.js';
 import { createWeatherClock } from '../layers/weather/clock.js';
 import { createWeatherLayer } from '../layers/weather/index.js';
-import { createCyclonesLayer } from '../layers/cyclones/index.js';
+import { createApplicationCyclones } from './layers/cyclones.js';
 import { createWindLayer } from '../layers/wind/index.js';
 import { createLayerCatalog } from './catalog.js';
 import { LAYER_STATE_REGISTRY } from '../data/layerState.js';
@@ -30,6 +30,7 @@ import { createApplicationFirePerimeters } from './layers/perimeters.js';
 import { createApplicationGnssIntegrity } from './layers/gnss.js';
 import { createApplicationGhostMaps } from './layers/ghostMaps.js';
 import { createApplicationDroneAirspace } from './layers/droneAirspace.js';
+import { createApplicationWildlifeSightings } from './layers/wildlifeSightings.js';
 import { createApplicationCables } from './layers/submarineCables.js';
 import { createOsmOverlayLayers } from '../data/osmOverlays.js';
 import { createApplicationStreetLevel } from './layers/streetLevel.js';
@@ -137,6 +138,10 @@ export function createApplicationCatalog({
         createApplicationDroneAirspace({
           source: sources['drone-airspace'],
         }),
+        createApplicationWildlifeSightings({
+          source: sources['wildlife-sightings'],
+          groundFloor: surface.groundFloor,
+        }),
         createApplicationAlpr({ surface, source: sources.alpr }),
         createApplicationStreetLevel({
           surface,
@@ -177,7 +182,7 @@ export function createApplicationCatalog({
           id: 'weather-lightning',
           clock: weatherClock,
         }),
-        createCyclonesLayer({ feed: sources.cyclones }),
+        createApplicationCyclones({ feed: sources.cyclones }),
         ...createOsmOverlayLayers(),
         ...createInfrastructureLayers(localGeoJsonServices),
         createApplicationCables({ source: sources.cables }),

src/app/constructCatalog.test.mjs

@@ -40,7 +40,7 @@ test('catalogs construct distinct layers and classification from their supplied
     signal: b.signal,
     surface: fixtureSurface(b.signal),
   });
-  assert.equal(first.layers.length, 37);
+  assert.equal(first.layers.length, 38);
   assert.ok(first.get('local-adsb'), 'Local ADS-B is registered');
   assert.deepEqual(
     first.metadata.find(({ id }) => id === 'osm-places'),
@@ -161,7 +161,7 @@ test('Mapillary can be omitted or replaced without changing catalog membership',
     surface: fixtureSurface(lifetime.signal),
   };
   const catalog = createApplicationCatalog(options);
-  assert.equal(catalog.layers.length, 37);
+  assert.equal(catalog.layers.length, 38);
   assert.deepEqual(catalog.get('street-level').providerIds, []);
   assert.equal(
     catalogControlServices(catalog).streetLevelLayer,

src/app/layers/cyclones.js

@@ -0,0 +1,10 @@
+import { createCyclonesLayer } from '../../layers/cyclones/index.js';
+import * as context from '../../data/contextStore.js';
+
+/** Wire cyclone selection to the application shared context. */
+export function createApplicationCyclones(options) {
+  return createCyclonesLayer({
+    context: typeof window !== 'undefined' ? context : null,
+    ...options,
+  });
+}

src/app/layers/wildlifeSightings.js

@@ -0,0 +1,30 @@
+import * as Cesium from 'cesium';
+import { createWildlifeSightingsLayer } from '../../layers/wildlifeSightings/index.js';
+import * as picking from '../../data/pickRegistry.js';
+import * as overlays from '../../overlays/worldOverlay.js';
+import * as sprites from '../../data/spriteOrder.js';
+import * as render from '../../renderGovernor.js';
+import * as context from '../../data/contextStore.js';
+import * as focus from '../../worldFocus.js';
+import { isPointerFree } from '../../data/inputOwnership.js';
+
+/** Bind the wildlife layer to the application's scene and selection owners. */
+export function createApplicationWildlifeSightings(options) {
+  return createWildlifeSightingsLayer({
+    overlayHost: {
+      setEntries: overlays.setOverlayEntries,
+      setVisible: overlays.setOverlaySourceVisible,
+      clearSource: overlays.clearOverlaySource,
+      hitTest: overlays.hitTestWorldOverlay,
+    },
+    screenSpaceEventHandlerFactory: (viewer) =>
+      new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas),
+    picking,
+    pointer: { isPointerFree },
+    sprites,
+    render,
+    context,
+    focus,
+    ...options,
+  });
+}

src/app/scene.js

@@ -2,6 +2,7 @@ import { createApplicationOperations } from './operations.js';
 import * as Cesium from 'cesium';
 import {
   createApplicationViewer,
+  installFreeLookHeightLimit,
   installTrackpadPinchZoom,
 } from '../app/viewer.js';
 import { registerDataCredits } from '../data/dataCredits.js';
@@ -58,6 +59,7 @@ export async function createApplicationScene({
     if (!viewer.isDestroyed()) viewer.destroy();
   });
   defer(installTrackpadPinchZoom(viewer));
+  defer(installFreeLookHeightLimit(viewer));
   registerDataCredits(viewer, credits);
   configureCreditKeyboardAccess(document);
   defer(onLocaleChange(() => configureCreditKeyboardAccess(document)));

src/app/sourceComposition.js

@@ -50,6 +50,7 @@ export const CATALOG_SOURCE_CONTRACTS = Object.freeze({
   'gnss-integrity': contract(['gnss-integrity'], ['getSnapshot']),
   's2-ghostmaps': contract(['s2-ghostmaps'], ['getCatalog', 'getFile']),
   'drone-airspace': contract(['drone-airspace'], ['getSnapshot']),
+  'wildlife-sightings': contract(['wildlife-sightings'], ['getSnapshot']),
   cables: contract(['telegeography-submarine-cables'], ['fetch']),
   transit: contract(['transit'], ['requestSnapshot', 'getHistory']),
 });

src/app/sourceComposition.test.mjs

@@ -37,7 +37,7 @@ test('every acquisition source can be omitted without losing catalog membership'
 
 test('all acquisition sources may be absent, and enable fails before initializing or fetching', async (t) => {
   const actual = catalog({}, t);
-  assert.equal(actual.layers.length, 37);
+  assert.equal(actual.layers.length, 38);
   const manager = new LayerLifecycle(
     {},
     { getSourceAvailability: actual.getSourceAvailability },

src/app/tools.js

@@ -8,7 +8,13 @@ import { initImageryBoxTool } from '../ui/imageryBoxTool.js';
 import { createRecentImageryPanel } from '../ui/recentImagery.js';
 import { initGevVoiceCommands } from '../voice/gevRealtime.js';
 import { installViews, isEmbeddedInline } from './embed.js';
-import { installScopeMask, destroyScopeMask } from '../scopeMask.js';
+import {
+  installScopeMask,
+  destroyScopeMask,
+  isScopeMaskEnabled,
+} from '../scopeMask.js';
+import { KEYHOLE_OUTER_RADIUS } from '../celestialRing.js';
+import { installGlobeInViewRecovery } from './viewer.js';
 import { installLayerReleaseTrim } from '../sceneCommandRelease.js';
 import {
   installRenderGovernor,
@@ -44,6 +50,14 @@ export function createApplicationTools({
     .get('bhote-koshi-2026')
     ?.module.attachSceneController(sceneDirector);
   defer(() => sceneDirector.destroy());
+  defer(
+    installGlobeInViewRecovery(viewer, {
+      // The scope mask hides everything outside its keyhole.
+      keyholeRadius: () => (isScopeMaskEnabled() ? KEYHOLE_OUTER_RADIUS : 0),
+      // An authored scene frames its own shots, holds included.
+      paused: () => sceneDirector.running,
+    }),
+  );
   onSceneDirector?.(sceneDirector);
   const annotations = initAnnotations({
     viewer,

src/app/viewer.js

@@ -1,6 +1,11 @@
 import * as Cesium from 'cesium';
 import { applyModelAtmosphereWorkaround } from './atmosphereCompat.js';
 import { StarrySky } from '../sky/starrySky.js';
+import {
+  FREE_LOOK_MAX_HEIGHT_METERS,
+  globeOutOfFrame,
+  isFreeGlobeCamera,
+} from '../globeInView.js';
 
 const PINCH_ZOOM_MULTIPLIER = 8;
 const MAX_PINCH_PIXEL_DELTA = 120;
@@ -103,6 +108,231 @@ export function installTrackpadPinchZoom(
   };
 }
 
+/**
+ * Allow Cesium's free look only below `maxHeight` and return its disposer.
+ * Orbit, tilt and zoom stay available at every height. A value other code
+ * sets later is kept as the one to allow below that height, and restored on
+ * dispose; a `false` written while the camera is above `maxHeight` cannot be
+ * told apart from this limit's own write, so dispose restores the earlier
+ * value then. `enableLook` gates the Shift+drag binding only: below its trackball
+ * height Cesium also turns the camera in place for a drag that starts on the
+ * stars. That height is lowered to `maxHeight` too, so above it such a drag
+ * orbits the globe, as it does above Cesium's own 7,500 km.
+ */
+export function installFreeLookHeightLimit(
+  viewer,
+  maxHeight = FREE_LOOK_MAX_HEIGHT_METERS,
+) {
+  const scene = viewer?.scene;
+  const controller = scene?.screenSpaceCameraController;
+  const camera = viewer?.camera;
+  if (!controller || !camera || !scene?.preUpdate)
+    throw new TypeError('A complete Cesium viewer is required');
+
+  const originalTrackBallHeight = controller.minimumTrackBallHeight;
+  const trackBallHeight = Math.min(originalTrackBallHeight, maxHeight);
+  controller.minimumTrackBallHeight = trackBallHeight;
+  let wanted = controller.enableLook;
+  let written;
+  const sync = () => {
+    if (written !== undefined && controller.enableLook !== written)
+      wanted = controller.enableLook;
+    const height = camera.positionCartographic?.height;
+    written = wanted && !(Number.isFinite(height) && height > maxHeight);
+    controller.enableLook = written;
+  };
+  sync();
+  const removeListener = scene.preUpdate.addEventListener(sync);
+
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    removeListener();
+    if (controller.enableLook === written) controller.enableLook = wanted;
+    if (controller.minimumTrackBallHeight === trackBallHeight)
+      controller.minimumTrackBallHeight = originalTrackBallHeight;
+  };
+}
+
+// How often a moving camera is sampled to see whether it has come to rest, how
+// far a pose may drift between samples and still count as at rest, and how
+// long after the camera last moved the check gives up if Cesium never raises
+// moveEnd.
+const SETTLE_SAMPLE_MS = 250;
+const SETTLE_POSITION_TOLERANCE_M = 1e-3;
+const SETTLE_DIRECTION_TOLERANCE = 1e-9;
+const SETTLE_GIVE_UP_MS = 5 * 60_000;
+
+/**
+ * Turn the camera back to the planet when a move ends above `minHeight` with
+ * no surface on screen (`globeOutOfFrame`: limb glow and slivers up to about
+ * one sample cell thick can count as none), and return the disposer. Views with
+ * more surface, such as an oblique orbital shot, are left as they are. This
+ * catches a saved or shared view that looked away, or any other move that ends
+ * looking away from the planet.
+ * Heading and position are kept. Tracked cameras, locked ones (non-identity
+ * transform), a camera flight in progress, a pointer held down on the canvas
+ * (a drag held still), the 2D and Columbus modes, and any time `paused`
+ * returns true (an authored scene playing) are left alone; a check they defer
+ * runs once they end, however long they last.
+ * `keyholeRadius`
+ * returns the radius of the visible circle when a scope mask hides the rest of
+ * the frame (see `globeFrameShare`), or 0; it is read at every check.
+ *
+ * Cesium's `moveEnd` alone is not enough: Cesium compares the camera with the
+ * last frame's to the last rounding error, and at some of these poses the
+ * camera drifts by a rounding error every frame, so Cesium never sees it stop.
+ * So each `moveStart` also starts a check of its own that samples the pose
+ * every 250 ms, with a tolerance for that drift, and once the pose has held
+ * for half a second after moving runs the same recovery. It keeps watching
+ * until Cesium raises `moveEnd`, since under that drift Cesium raises no new
+ * `moveStart` for a later move, and gives up five minutes after the camera
+ * last moved.
+ * `setTimeout` and `clearTimeout` can be injected for tests.
+ */
+export function installGlobeInViewRecovery(
+  viewer,
+  {
+    minHeight = FREE_LOOK_MAX_HEIGHT_METERS,
+    keyholeRadius = () => 0,
+    paused = () => false,
+    setTimeout: schedule = globalThis.setTimeout,
+    clearTimeout: unschedule = globalThis.clearTimeout,
+  } = {},
+) {
+  const scene = viewer?.scene;
+  const camera = viewer?.camera;
+  if (!scene || !camera?.moveEnd || !camera?.moveStart)
+    throw new TypeError('A complete Cesium viewer is required');
+
+  // A pointer held on the globe is a gesture in progress, even when it holds
+  // still for half a second: the check waits until every pointer pressed on
+  // it (each finger of a pinch) is released. A release the page never sees,
+  // outside the window, is taken as given when the window loses focus, the
+  // page is hidden, the canvas loses the pointer's capture, or the pointer
+  // moves with no button down.
+  const canvas = scene.canvas;
+  const releaseTarget = canvas?.ownerDocument ?? canvas;
+  const releaseWindow = canvas?.ownerDocument?.defaultView;
+  const heldPointers = new Set();
+  const onPointerDown = (event) => heldPointers.add(event?.pointerId);
+  const onPointerUp = (event) => heldPointers.delete(event?.pointerId);
+  const onPointerMove = (event) => {
+    if (event?.buttons === 0) heldPointers.delete(event.pointerId);
+  };
+  const releaseAll = () => heldPointers.clear();
+  const onVisibilityChange = () => {
+    if (canvas.ownerDocument.visibilityState === 'hidden') releaseAll();
+  };
+  const listeners = [
+    [canvas, 'pointerdown', onPointerDown],
+    [canvas, 'lostpointercapture', onPointerUp],
+    [releaseTarget, 'pointerup', onPointerUp],
+    [releaseTarget, 'pointercancel', onPointerUp],
+    [releaseTarget, 'pointermove', onPointerMove],
+    [canvas?.ownerDocument, 'visibilitychange', onVisibilityChange],
+    [releaseWindow, 'blur', releaseAll],
+  ];
+  for (const [target, type, listener] of listeners)
+    target?.addEventListener?.(type, listener);
+
+  // Returns false while a flight, a paused scene or a held pointer defers the
+  // check, so the caller can try again once it ends.
+  const recover = () => {
+    if (!isFreeGlobeCamera(viewer)) return true;
+    // Cesium has no public running-flight flag.
+    if (camera._currentFlight || paused() || heldPointers.size > 0)
+      return false;
+    const height = camera.positionCartographic?.height;
+    if (
+      !(height > minHeight) ||
+      !globeOutOfFrame(camera, { keyholeRadius: keyholeRadius() })
+    )
+      return true;
+    camera.setView({
+      orientation: {
+        heading: camera.heading,
+        pitch: -Cesium.Math.PI_OVER_TWO,
+        roll: 0,
+      },
+    });
+    scene.requestRender?.();
+    return true;
+  };
+
+  const lastPosition = new Cesium.Cartesian3();
+  const lastDirection = new Cesium.Cartesian3();
+  let settleTimer = null;
+  let settleElapsed = 0;
+  let restingSamples = 0;
+  let movedSinceCheck = false;
+  const stopSettling = () => {
+    if (settleTimer !== null) unschedule(settleTimer);
+    settleTimer = null;
+  };
+  const sample = () => {
+    settleTimer = null;
+    settleElapsed += SETTLE_SAMPLE_MS;
+    const atRest =
+      Cesium.Cartesian3.equalsEpsilon(
+        camera.positionWC,
+        lastPosition,
+        0,
+        SETTLE_POSITION_TOLERANCE_M,
+      ) &&
+      Cesium.Cartesian3.equalsEpsilon(
+        camera.directionWC,
+        lastDirection,
+        0,
+        SETTLE_DIRECTION_TOLERANCE,
+      );
+    restingSamples = atRest ? restingSamples + 1 : 0;
+    if (!atRest) {
+      movedSinceCheck = true;
+      settleElapsed = 0;
+    }
+    // Two quiet samples in a row after a move: at rest for half a second, as
+    // for moveEnd.
+    if (restingSamples >= 2 && movedSinceCheck) {
+      if (recover()) movedSinceCheck = false;
+      // A flight or a playing scene bounds its own deferral.
+      else settleElapsed = 0;
+    }
+    if (settleElapsed >= SETTLE_GIVE_UP_MS) return;
+    Cesium.Cartesian3.clone(camera.positionWC, lastPosition);
+    Cesium.Cartesian3.clone(camera.directionWC, lastDirection);
+    settleTimer = schedule(sample, SETTLE_SAMPLE_MS);
+  };
+  const startSettling = () => {
+    stopSettling();
+    settleElapsed = 0;
+    restingSamples = 0;
+    movedSinceCheck = true;
+    Cesium.Cartesian3.clone(camera.positionWC, lastPosition);
+    Cesium.Cartesian3.clone(camera.directionWC, lastDirection);
+    settleTimer = schedule(sample, SETTLE_SAMPLE_MS);
+  };
+  const removeMoveEnd = camera.moveEnd.addEventListener(() => {
+    if (recover()) stopSettling();
+    // Deferred: keep sampling so the check runs once the flight or scene ends.
+    else if (settleTimer === null) startSettling();
+  });
+  const removeMoveStart = camera.moveStart.addEventListener(startSettling);
+
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    stopSettling();
+    removeMoveEnd();
+    removeMoveStart();
+    for (const [target, type, listener] of listeners)
+      target?.removeEventListener?.(type, listener);
+    heldPointers.clear();
+  };
+}
+
 /** Cesium.Viewer options of the standard globe viewer. */
 export function applicationViewerOptions(creditContainer) {
   return {

src/cameraGlobeRotation.test.mjs

@@ -13,8 +13,16 @@ import {
   moveCamera,
 } from './cameraVerbs.js';
 import { getRenderGovernorDiagnostics } from './renderGovernor.js';
+import {
+  MIN_GLOBE_FRAME_SHARE,
+  globeFrameShare,
+  globeOutOfFrame,
+} from './globeInView.js';
+import { KEYHOLE_OUTER_RADIUS } from './celestialRing.js';
+import { setScopeMaskEnabled } from './scopeMask.js';
 
 const radians = Cesium.Math.toRadians;
+const degrees = Cesium.Math.toDegrees;
 const clone = (value) => Cesium.Cartesian3.clone(value);
 const longitude = (camera) =>
   Cesium.Cartographic.fromCartesian(camera.positionWC).longitude;
@@ -1347,3 +1355,664 @@ test('close-up ultrawide refusal does not offer an unfit reset or move the camer
   samePose(h.camera, before);
   assert.equal(hasRenderHold(), false);
 });
+
+/**
+ * An oracle independent of the code under test: the share of an 80×45 grid of
+ * Cesium pick rays across the canvas that hit the ellipsoid surface. With
+ * `keyhole`, only the pixels inside the scope's visible circle count.
+ */
+function surfacePixelShare(camera, width, height, { keyhole = false } = {}) {
+  const radius = (KEYHOLE_OUTER_RADIUS * height) / 2;
+  let hits = 0;
+  let counted = 0;
+  for (let row = 0; row < 45; row += 1) {
+    for (let column = 0; column < 80; column += 1) {
+      const x = ((column + 0.5) * width) / 80;
+      const y = ((row + 0.5) * height) / 45;
+      if (keyhole && Math.hypot(x - width / 2, y - height / 2) > radius)
+        continue;
+      counted += 1;
+      const ray = camera.getPickRay(new Cesium.Cartesian2(x, y));
+      if (Cesium.IntersectionTests.rayEllipsoid(ray, Cesium.Ellipsoid.WGS84))
+        hits += 1;
+    }
+  }
+  return hits / counted;
+}
+
+/** Run a test with the scope mask on or off, restoring the default after. */
+function withScope(t, enabled) {
+  setScopeMaskEnabled(enabled);
+  t.after(() => setScopeMaskEnabled(true));
+}
+
+// The frame limit is measured on a coarser grid than the oracle.
+const SHARE_SLACK = 0.02;
+// Far-out poses, height in metres and pitch in degrees, where a few tilts up
+// are accepted before the limit refuses the next one.
+const FAR_OUT_POSES = [
+  [35_884_000, -86.26],
+  [35_884_000, -89],
+  [30_000_000, -86],
+  [25_000_000, -80],
+  [40_000_000, -88],
+];
+
+test('voice tilt from orbit stops with the planet still on screen and then says so', (t) => {
+  withScope(t, false); // the whole frame is visible
+  // Slightly off nadir: from straight down a tilt is clamped before it moves.
+  const { camera, finishOnce } = harness(t, {
+    pitch: -80,
+    viewportWidth: 1600,
+    viewportHeight: 900,
+  });
+  const results = [];
+  for (let i = 0; i < 4; i += 1) {
+    const result = moveCamera({
+      motion: 'tilt',
+      direction: 'up',
+      mode: 'once',
+    });
+    results.push(result);
+    if (result.ok) finishOnce();
+    assert.ok(
+      surfacePixelShare(camera, 1600, 900) >=
+        MIN_GLOBE_FRAME_SHARE - SHARE_SLACK,
+      `after tilt ${i + 1}`,
+    );
+  }
+  // From 18,000 km a 16:9 frame keeps a tenth of its area on the planet down
+  // to about -67°: the first tilt stops there, and later ones are refused.
+  assert.deepEqual(
+    results.map((result) => result.ok),
+    [true, false, false, false],
+  );
+  assert.match(results[1].error, /globe out of view/);
+  assert.ok(camera.pitch > radians(-68.5) && camera.pitch < radians(-66));
+});
+
+// The frame limit judges a tilt by the way its pitch moves, not by the
+// direction word: a tilt down or to a steeper angle turns toward the planet.
+for (const args of [{ direction: 'down' }, { pitchDeg: -80 }]) {
+  test(`a tilt ${JSON.stringify(args)} from the frame limit is judged as the look down it is`, (t) => {
+    withScope(t, false);
+    const { camera, finishOnce } = harness(t, {
+      pitch: -80,
+      viewportWidth: 1600,
+      viewportHeight: 900,
+    });
+    assert.equal(moveCamera({ motion: 'tilt', direction: 'up' }).ok, true);
+    finishOnce();
+    const atLimit = camera.pitch;
+    const result = moveCamera({ motion: 'tilt', ...args });
+    assert.equal(result.ok, true, result.error);
+    finishOnce();
+    assert.ok(camera.pitch < atLimit - radians(5), 'the tilt turned down');
+  });
+}
+
+for (const args of [{ pitchDeg: -10 }, {}]) {
+  test(`a tilt ${JSON.stringify(args)} up from the frame limit is refused, not reported as done`, (t) => {
+    withScope(t, false);
+    const { camera, finishOnce } = harness(t, {
+      pitch: -80,
+      viewportWidth: 1600,
+      viewportHeight: 900,
+    });
+    assert.equal(moveCamera({ motion: 'tilt', direction: 'up' }).ok, true);
+    finishOnce();
+    const atLimit = camera.pitch;
+    // A bare tilt means -45°: up from the -67° limit.
+    const result = moveCamera({ motion: 'tilt', ...args });
+    assert.equal(result.ok, false);
+    assert.match(result.error, /globe out of view/);
+    assert.equal(camera.pitch, atLimit);
+  });
+}
+
+// A tilt to an angle, or a bare tilt (-45°), from orbit turns in place like
+// a nudge and must keep the planet in frame the whole way, or the globe
+// recovery would snap the view back down.
+for (const [label, args, options] of [
+  ['a bare tilt', { motion: 'tilt' }, { pitch: -90 }],
+  ['a tilt to -10°', { motion: 'tilt', pitchDeg: -10 }, { pitch: -90 }],
+  [
+    'a continuous tilt up',
+    { motion: 'tilt', direction: 'up', mode: 'continuous' },
+    { pitch: -90 },
+  ],
+  [
+    'a tilt to -5° from 2,000 km',
+    { motion: 'tilt', pitchDeg: -5 },
+    { pitch: -90, height: 2_000_000 },
+  ],
+]) {
+  test(`${label} from top-down never turns the planet out of frame`, (t) => {
+    withScope(t, false);
+    const { camera, tick } = harness(t, {
+      ...options,
+      viewportWidth: 1600,
+      viewportHeight: 900,
+    });
+    const startPitch = camera.pitch;
+    const result = moveCamera(args);
+    for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) {
+      tick();
+      assert.ok(
+        surfacePixelShare(camera, 1600, 900) >=
+          MIN_GLOBE_FRAME_SHARE - SHARE_SLACK,
+        `frame ${i}: the planet left the frame`,
+      );
+    }
+    assert.equal(getActiveCameraMotion(), null, 'the tilt must stop');
+    assert.equal(globeOutOfFrame(camera), false, 'no snap-back');
+    if (result.ok) assert.ok(camera.pitch > startPitch, 'the tilt moved');
+  });
+}
+
+// The frame limit stops a tilt to an angle short of it: the reply names the
+// angle the camera reaches, not the one asked for (a tilt to -10° from
+// top-down reported -10° and ended at -66.5°).
+for (const [label, args, options] of [
+  ['a bare tilt', { motion: 'tilt' }, { pitch: -90 }],
+  ['a tilt to -10°', { motion: 'tilt', pitchDeg: -10 }, { pitch: -90 }],
+  [
+    'a tilt to -10° from -80°',
+    { motion: 'tilt', pitchDeg: -10 },
+    { pitch: -80 },
+  ],
+  [
+    'a tilt to -5° from 2,000 km',
+    { motion: 'tilt', pitchDeg: -5 },
+    { pitch: -90, height: 2_000_000 },
+  ],
+  // A rolled camera's look turns its pitch by less than the look angle:
+  // reported -25°, ended at -27.3°.
+  [
+    'a tilt to -5° from 2,000 km rolled 30°',
+    { motion: 'tilt', pitchDeg: -5 },
+    { pitch: -70, roll: 30, height: 2_000_000 },
+  ],
+]) {
+  test(`${label} from orbit reports the angle it reaches`, (t) => {
+    withScope(t, false);
+    const { camera, tick } = harness(t, {
+      ...options,
+      viewportWidth: 1600,
+      viewportHeight: 900,
+    });
+    const result = moveCamera(args);
+    assert.equal(result.ok, true, result.error);
+    for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) tick();
+    assert.equal(getActiveCameraMotion(), null, 'the tilt must stop');
+    const reached = degrees(camera.pitch);
+    assert.ok(
+      Math.abs(reached - result.pitchDeg) < 1,
+      `reported ${result.pitchDeg}°, reached ${reached}°`,
+    );
+    const asked = args.pitchDeg ?? -45;
+    if (Math.abs(reached - asked) >= 1)
+      assert.match(result.note ?? '', /globe out of view/);
+    else assert.equal(result.note, undefined);
+  });
+}
+
+// A continuous tilt promises no angle: it runs until stopped or the frame
+// limit ends it.
+test('a continuous tilt up from orbit claims no angle it may not reach', (t) => {
+  withScope(t, false);
+  const { tick } = harness(t, {
+    pitch: -90,
+    viewportWidth: 1600,
+    viewportHeight: 900,
+  });
+  const result = moveCamera({
+    motion: 'tilt',
+    direction: 'up',
+    mode: 'continuous',
+  });
+  assert.equal(result.ok, true, result.error);
+  assert.equal('pitchDeg' in result, false);
+  assert.equal(result.mode, 'continuous');
+  for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) tick();
+  assert.equal(getActiveCameraMotion(), null, 'the frame limit ends it');
+});
+
+test('voice turn in place from orbit stops with the planet still on screen', (t) => {
+  withScope(t, false); // the whole frame is visible
+  const { camera, tick } = harness(t, { pitch: -75 });
+  assert.equal(
+    moveCamera({ motion: 'rotate', direction: 'left', mode: 'continuous' }).ok,
+    true,
+  );
+  const heading = camera.heading;
+  for (let i = 0; i < 400 && getActiveCameraMotion(); i += 1) {
+    tick();
+    assert.ok(
+      surfacePixelShare(camera, 1280, 800) >=
+        MIN_GLOBE_FRAME_SHARE - SHARE_SLACK,
+      `tick ${i + 1}`,
+    );
+  }
+  assert.equal(getActiveCameraMotion(), null, 'the turn stops at the limit');
+  assert.notEqual(camera.heading, heading, 'the turn moved before stopping');
+});
+
+test('a long voice turn below the limit keeps the share it started with', (t) => {
+  withScope(t, false); // the whole frame is visible
+  // About 2% of a 16:9 frame on the planet: the limit is that share, less two
+  // grid cells of sampling noise, for the whole motion rather than per step.
+  const { camera, tick } = harness(t, {
+    pitch: -60,
+    viewportWidth: 1600,
+    viewportHeight: 900,
+  });
+  const start = globeFrameShare(camera);
+  assert.ok(start > 0 && start < MIN_GLOBE_FRAME_SHARE);
+  assert.equal(
+    moveCamera({ motion: 'rotate', direction: 'left', mode: 'continuous' }).ok,
+    true,
+  );
+  for (let i = 0; i < 400 && getActiveCameraMotion(); i += 1) {
+    tick();
+    assert.ok(
+      globeFrameShare(camera) >= start - 2 / (32 * 18) - 1e-9,
+      `tick ${i + 1}`,
+    );
+  }
+  assert.equal(getActiveCameraMotion(), null, 'the turn stops at the limit');
+  assert.ok(surfacePixelShare(camera, 1600, 900) > 0);
+});
+
+test('repeated voice turns from one spot cannot each take a little more', (t) => {
+  withScope(t, false); // the whole frame is visible
+  // About 2% of a 16:9 frame on the planet. Every turn from this position is
+  // measured against the same baseline, so asking again stops being allowed.
+  const { camera, finishOnce, tick } = harness(t, {
+    pitch: -60,
+    viewportWidth: 1600,
+    viewportHeight: 900,
+  });
+  const start = globeFrameShare(camera);
+  const floor = start - 2 / (32 * 18) - 1e-9;
+  const results = [];
+  for (const mode of ['once', 'once', 'continuous', 'once', 'continuous']) {
+    for (let i = 0; i < 4; i += 1) {
+      const result = moveCamera({ motion: 'rotate', direction: 'left', mode });
+      results.push(result.ok);
+      if (!result.ok) continue;
+      if (mode === 'once') finishOnce();
+      else for (let j = 0; j < 400 && getActiveCameraMotion(); j += 1) tick();
+      assert.ok(globeFrameShare(camera) >= floor, `${mode} turn ${i + 1}`);
+    }
+  }
+  assert.ok(results.includes(false), 'a turn at the limit is refused');
+  assert.equal(results.at(-1), false);
+  assert.ok(surfacePixelShare(camera, 1600, 900) > 0);
+});
+
+test('a voice turn after something else turned the camera starts over', (t) => {
+  withScope(t, false); // the whole frame is visible
+  // The same spot, first framed straight down, then turned to about 2% of the
+  // frame by something other than voice: a turn left is measured from there.
+  const { camera, finishOnce } = harness(t, {
+    pitch: -90,
+    viewportWidth: 1600,
+    viewportHeight: 900,
+  });
+  assert.equal(
+    moveCamera({ motion: 'rotate', direction: 'left', mode: 'once' }).ok,
+    true,
+  );
+  finishOnce();
+  camera.setView({
+    orientation: { heading: 0, pitch: radians(-60), roll: 0 },
+  });
+  const start = globeFrameShare(camera);
+  assert.ok(start > 0 && start < MIN_GLOBE_FRAME_SHARE);
+  assert.equal(
+    moveCamera({ motion: 'rotate', direction: 'left', mode: 'once' }).ok,
+    true,
+  );
+  finishOnce();
+  assert.ok(globeFrameShare(camera) >= start - 2 / (32 * 18) - 1e-9);
+});
+
+test('nudging the camera between voice turns cannot take the planet below the 1% floor', (t) => {
+  withScope(t, false); // the whole frame is visible
+  // A wheel notch or an orbit drag between requests starts each turn afresh;
+  // the 1% floor still holds, and below it a turn may only keep what it has.
+  for (const [nudge, pitch] of [
+    [(camera) => camera.moveBackward(2), -60],
+    [(camera) => camera.rotateRight(radians(0.2)), -60],
+    [(camera) => camera.moveBackward(2), -58],
+  ]) {
+    const { camera, tick } = harness(t, {
+      pitch,
+      viewportWidth: 1600,
+      viewportHeight: 900,
+    });
+    const start = globeFrameShare(camera);
+    const floor = Math.min(0.01, start) - 1e-9;
+    for (let i = 0; i < 12; i += 1) {
+      nudge(camera);
+      if (
+        moveCamera({ motion: 'rotate', direction: 'left', mode: 'continuous' })
+          .ok
+      )
+        for (let j = 0; j < 400 && getActiveCameraMotion(); j += 1) tick();
+      assert.ok(
+        globeFrameShare(camera) >= floor,
+        `start ${start}, turn ${i + 1}`,
+      );
+    }
+    assert.ok(surfacePixelShare(camera, 1600, 900) > 0);
+  }
+});
+
+test('after the frame changes size, a voice turn toward the planet is allowed', (t) => {
+  withScope(t, false); // the whole frame is visible
+  // A tilt stops at its limit; then the window widens at the same pose, so the
+  // frame shows less than the carried limit. Toward the planet must still go.
+  const { camera, canvas, viewer, finishOnce } = harness(t, {
+    pitch: -80,
+    viewportWidth: 1600,
+    viewportHeight: 900,
+  });
+  assert.equal(
+    moveCamera({ motion: 'tilt', direction: 'up', mode: 'once' }).ok,
+    true,
+  );
+  finishOnce();
+  canvas.clientWidth = canvas.width = viewer.scene.drawingBufferWidth = 3200;
+  camera.frustum.aspectRatio = 3200 / 900;
+  const narrowed = globeFrameShare(camera);
+  assert.ok(narrowed < MIN_GLOBE_FRAME_SHARE, `frame now shows ${narrowed}`);
+
+  const down = moveCamera({ motion: 'tilt', direction: 'down', mode: 'once' });
+  assert.equal(down.ok, true, down.error);
+  finishOnce();
+  assert.ok(globeFrameShare(camera) > narrowed);
+  assert.equal(
+    moveCamera({ motion: 'tilt', direction: 'down', mode: 'once' }).ok,
+    true,
+  );
+  finishOnce();
+  const up = moveCamera({ motion: 'tilt', direction: 'up', mode: 'once' });
+  if (up.ok) finishOnce();
+  assert.ok(surfacePixelShare(camera, 3200, 900) > 0);
+});
+
+test('with the scope on, a voice tilt stops while the keyhole still shows the planet', (t) => {
+  withScope(t, true);
+  const { camera, finishOnce } = harness(t, {
+    pitch: -80,
+    viewportWidth: 1600,
+    viewportHeight: 900,
+  });
+  const results = [];
+  for (let i = 0; i < 4; i += 1) {
+    const result = moveCamera({
+      motion: 'tilt',
+      direction: 'up',
+      mode: 'once',
+    });
+    results.push(result.ok);
+    if (result.ok) finishOnce();
+    assert.ok(
+      surfacePixelShare(camera, 1600, 900, { keyhole: true }) >=
+        MIN_GLOBE_FRAME_SHARE - SHARE_SLACK,
+      `after tilt ${i + 1}`,
+    );
+  }
+  assert.equal(results[0], true);
+  assert.equal(results.at(-1), false, 'a tilt past the limit is refused');
+});
+
+test('with the scope on, a voice turn cannot leave the planet only in the masked corners', (t) => {
+  // An oblique orbit view: turning in place swings the planet toward a corner,
+  // where the full frame still shows it but the scope mask hides it.
+  for (const [height, pitch] of [
+    [5_000_000, -70],
+    [3_000_000, -75],
+    [18_000_000, -80],
+  ]) {
+    withScope(t, true);
+    const { camera, tick } = harness(t, {
+      height,
+      pitch,
+      viewportWidth: 1600,
+      viewportHeight: 900,
+    });
+    assert.equal(
+      moveCamera({ motion: 'rotate', direction: 'left', mode: 'continuous' })
+        .ok,
+      true,
+    );
+    for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) tick();
+    assert.equal(getActiveCameraMotion(), null, 'the turn stops at the limit');
+    assert.ok(
+      surfacePixelShare(camera, 1600, 900, { keyhole: true }) >=
+        MIN_GLOBE_FRAME_SHARE - SHARE_SLACK,
+      `${height / 1000} km at ${pitch}°`,
+    );
+  }
+});
+
+test('far out, a voice tilt is either refused or really moves, at display frame rates', (t) => {
+  // A small planet disc: its sampled share wobbles as it crosses the grid.
+  // Whatever the limit decides, "done" must mean the camera turned, and some
+  // of these tilts must be accepted for that to be checked at all.
+  let accepted = 0;
+  for (const [height, pitch] of FAR_OUT_POSES) {
+    withScope(t, true);
+    const { camera, tick } = harness(t, {
+      latitude: 45.37,
+      longitudeDeg: -33.33,
+      height,
+      heading: 89.9,
+      pitch,
+      viewportWidth: 1280,
+      viewportHeight: 1024,
+    });
+    for (let i = 0; i < 4; i += 1) {
+      const before = camera.pitch;
+      const result = moveCamera({
+        motion: 'tilt',
+        direction: 'up',
+        mode: 'once',
+      });
+      if (!result.ok) {
+        assert.match(result.error, /zoom in first/);
+        continue;
+      }
+      accepted += 1;
+      for (let j = 0; j < 600 && getActiveCameraMotion(); j += 1) tick(1 / 60);
+      assert.ok(
+        camera.pitch - before > radians(0.5) - 1e-9,
+        `${height / 1000} km at ${pitch}°: tilt ${i + 1} reported done but moved ${Cesium.Math.toDegrees(camera.pitch - before)}°`,
+      );
+    }
+    assert.ok(surfacePixelShare(camera, 1280, 1024, { keyhole: true }) > 0);
+  }
+  assert.ok(accepted > 0, 'no far-out tilt was accepted');
+});
+
+test('a voice turn reported as done turns at least the half degree its check proved', (t) => {
+  // A grazing sliver: the first frame's small step lands in a dip of the
+  // sampled share, which used to stop the turn before it moved at all.
+  for (const scope of [true, false]) {
+    withScope(t, scope);
+    const { camera, tick } = harness(t, {
+      latitude: 20,
+      longitudeDeg: 10,
+      height: 18_000_000,
+      pitch: -58,
+      heading: 37,
+      viewportWidth: 1600,
+      viewportHeight: 900,
+    });
+    const before = Cesium.Cartesian3.clone(camera.directionWC);
+    const result = moveCamera({
+      motion: 'rotate',
+      direction: 'left',
+      mode: 'once',
+    });
+    if (!result.ok) {
+      assert.match(result.error, /globe out of view/);
+      continue;
+    }
+    for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) tick(1 / 60);
+    const turned = Cesium.Cartesian3.angleBetween(before, camera.directionWC);
+    assert.ok(
+      turned >= radians(0.5) - 1e-9,
+      `scope ${scope ? 'on' : 'off'}: turned ${Cesium.Math.toDegrees(turned)}°`,
+    );
+    assert.ok(surfacePixelShare(camera, 1600, 900, { keyhole: scope }) > 0);
+  }
+});
+
+/** Track an entity below `camera`, locking it into that entity's frame. */
+function trackFrom(viewer, camera) {
+  viewer.trackedEntity = { id: 'high-satellite' };
+  const below = Cesium.Cartesian3.fromDegrees(10, 20, 400_000);
+  camera.lookAtTransform(Cesium.Transforms.eastNorthUpToFixedFrame(below));
+}
+
+test('a voice turn that releases a tracked camera is checked as released', (t) => {
+  // Voice releases the follow camera inside the navigation that runs the
+  // motion, so the request is judged by the pose the release will leave.
+  let accepted = 0;
+  for (const [scope, direction, motion] of [
+    [true, 'up', 'tilt'],
+    [false, 'up', 'tilt'],
+    [false, 'left', 'rotate'],
+  ]) {
+    withScope(t, scope);
+    const { camera, viewer, tick } = harness(t, {
+      latitude: 20,
+      longitudeDeg: 10,
+      height: 18_000_000,
+      pitch: -58,
+      heading: 37,
+      viewportWidth: 1600,
+      viewportHeight: 900,
+    });
+    trackFrom(viewer, camera);
+    const releaseThenRun = (start) => {
+      viewer.trackedEntity = undefined;
+      camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
+      return start();
+    };
+    const before = Cesium.Cartesian3.clone(camera.directionWC);
+    const result = moveCamera(
+      { motion, direction, mode: 'once' },
+      releaseThenRun,
+    );
+    const label = `${motion} ${direction}, scope ${scope ? 'on' : 'off'}`;
+    if (!result.ok) {
+      assert.match(result.error, /globe out of view/, label);
+      continue;
+    }
+    accepted += 1;
+    for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) tick(1 / 60);
+    const turned = Cesium.Cartesian3.angleBetween(before, camera.directionWC);
+    assert.ok(turned >= radians(0.5) - 1e-9, `${label}: turned ${turned}`);
+    assert.ok(
+      surfacePixelShare(camera, 1600, 900, { keyhole: scope }) > 0,
+      `${label}: the planet stays on screen`,
+    );
+  }
+  assert.ok(accepted > 0, 'no released turn was accepted');
+});
+
+test('a refused voice turn leaves a tracked camera tracking', (t) => {
+  for (const scope of [true, false]) {
+    withScope(t, scope);
+    const { camera, viewer, tick } = harness(t, {
+      pitch: -80,
+      viewportWidth: 1600,
+      viewportHeight: 900,
+    });
+    // Tilt up to the limit untracked, then track from there.
+    for (let i = 0; i < 40; i += 1) {
+      if (!moveCamera({ motion: 'tilt', direction: 'up', mode: 'once' }).ok)
+        break;
+      for (let j = 0; j < 600 && getActiveCameraMotion(); j += 1) tick(1 / 60);
+    }
+    trackFrom(viewer, camera);
+    const tracked = viewer.trackedEntity;
+    const transform = Cesium.Matrix4.clone(camera.transform);
+    let released = false;
+    const result = moveCamera(
+      { motion: 'tilt', direction: 'up', mode: 'once' },
+      (start) => {
+        released = true;
+        viewer.trackedEntity = undefined;
+        camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
+        return start();
+      },
+    );
+    const label = `scope ${scope ? 'on' : 'off'}`;
+    assert.equal(result.ok, false, label);
+    assert.match(result.error, /globe out of view/, label);
+    assert.equal(released, false, label);
+    assert.equal(viewer.trackedEntity, tracked, label);
+    assert.ok(Cesium.Matrix4.equals(camera.transform, transform), label);
+  }
+});
+
+test('a turn proven at one position is checked again after a release moves the camera', (t) => {
+  withScope(t, false);
+  const { camera, tick } = harness(t, {
+    pitch: -80,
+    viewportWidth: 1600,
+    viewportHeight: 900,
+  });
+  // Tilt up to the limit, then check from 4,000 km closer along the same view
+  // direction, where the next tilt fits; the release moves the camera back.
+  for (let i = 0; i < 40; i += 1) {
+    if (!moveCamera({ motion: 'tilt', direction: 'up', mode: 'once' }).ok)
+      break;
+    for (let j = 0; j < 600 && getActiveCameraMotion(); j += 1) tick(1 / 60);
+  }
+  camera.moveForward(4_000_000);
+  const result = moveCamera(
+    { motion: 'tilt', direction: 'up', mode: 'once' },
+    (start) => {
+      camera.moveBackward(4_000_000);
+      return start();
+    },
+  );
+  assert.equal(result.ok, false);
+  assert.match(result.error, /globe out of view/);
+});
+
+test('the voice frame limit leaves Columbus view alone', (t) => {
+  // At its limit in 3D a further tilt up is refused; the same tilt in Columbus
+  // view is not limited by the frame.
+  withScope(t, false);
+  const { viewer, finishOnce } = harness(t, {
+    pitch: -80,
+    viewportWidth: 1600,
+    viewportHeight: 900,
+  });
+  assert.equal(
+    moveCamera({ motion: 'tilt', direction: 'up', mode: 'once' }).ok,
+    true,
+  );
+  finishOnce();
+  const refused = moveCamera({ motion: 'tilt', direction: 'up', mode: 'once' });
+  assert.match(refused.error || '', /globe out of view/);
+  viewer.scene.mode = Cesium.SceneMode.COLUMBUS_VIEW;
+  const result = moveCamera({ motion: 'tilt', direction: 'up', mode: 'once' });
+  assert.doesNotMatch(result.error || '', /globe out of view/);
+});
+
+test('voice tilt below the free-look height is not limited by the frame', (t) => {
+  const { camera, finishOnce } = harness(t, { height: 500_000, pitch: -60 });
+  const result = moveCamera({ motion: 'tilt', direction: 'up', mode: 'once' });
+  assert.equal(result.ok, true);
+  finishOnce();
+  near(camera.pitch, radians(-45), 1e-6, 'full 15° tilt');
+});

src/cameraHandoff.test.mjs

@@ -223,11 +223,20 @@ test('validated voice camera destinations share the UI navigation authority faca
     'move camera',
   );
   ordered(move, [
-    "if (!['orbit', 'pan', 'tilt', 'rotate', 'rotate_globe'].includes(motion))",
+    'if (argsError) return argsError;',
     'const start = () => {',
     /const preserveCameraFlight =\s*motion === 'orbit'/,
     'runNavigation(start, { preserveCameraFlight })',
   ], 'move validation before handoff');
+  const moveArgs = body(
+    cameraVerbs,
+    /export function moveCameraArgsError\(args = \{\}\) \{([\s\S]*?)\n\}/,
+    'move camera argument checks',
+  );
+  assert.ok(
+    moveArgs.includes("if (!['orbit', 'pan', 'tilt', 'rotate', 'rotate_globe'].includes(motion))"),
+    'unknown motions are refused before handoff',
+  );
 
   const route = body(
     cameraVerbs,

src/cameraTilt.test.mjs

@@ -0,0 +1,773 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import * as Cesium from 'cesium';
+import {
+  adjustOrbitRange,
+  getActiveCameraMotion,
+  initCameraVerbs,
+  interruptCameraMotion,
+  moveCamera,
+} from './cameraVerbs.js';
+import { createGevActionRunner } from './voice/gevActions.js';
+
+const radians = Cesium.Math.toRadians;
+const degrees = Cesium.Math.toDegrees;
+
+/** Real Cesium camera over London with no renderer: the voice fly-to frame. */
+function harness(
+  t,
+  { height = 4000, heading = 0, pitch = -90, pivot = true } = {},
+) {
+  const realPerformance = globalThis.performance;
+  let nowMs = 0;
+  globalThis.performance = { now: () => nowMs };
+  const canvas = Object.assign(new EventTarget(), {
+    clientWidth: 1280,
+    clientHeight: 800,
+    width: 1280,
+    height: 800,
+  });
+  const ellipsoid = Cesium.Ellipsoid.WGS84;
+  const scene = {
+    canvas,
+    drawingBufferWidth: 1280,
+    drawingBufferHeight: 800,
+    frameState: { mode: Cesium.SceneMode.SCENE3D },
+    mapProjection: new Cesium.GeographicProjection(ellipsoid),
+    globe: { ellipsoid },
+    mapMode2D: Cesium.MapMode2D.INFINITE_SCROLL,
+    mode: Cesium.SceneMode.SCENE3D,
+    pixelRatio: 1,
+    tweens: [],
+    requestRender() {},
+  };
+  const camera = new Cesium.Camera(scene);
+  scene.camera = camera;
+  camera.setView({
+    destination: Cesium.Cartesian3.fromDegrees(-0.1276, 51.5072, height),
+    orientation: { heading: radians(heading), pitch: radians(pitch), roll: 0 },
+  });
+  const viewer = {
+    camera,
+    scene,
+    trackedEntity: undefined,
+    trackedEntityChanged: new Cesium.Event(),
+    clock: { onTick: new Cesium.Event() },
+  };
+  // The app's view target: the ground point under the screen centre.
+  const viewTarget = () => {
+    const ray = new Cesium.Ray(camera.positionWC, camera.directionWC);
+    const hit = Cesium.IntersectionTests.rayEllipsoid(ray, ellipsoid);
+    return hit ? Cesium.Ray.getPoint(ray, hit.start) : undefined;
+  };
+  const target = viewTarget();
+  initCameraVerbs(viewer, pivot ? viewTarget : () => undefined);
+  t.after(() => {
+    interruptCameraMotion('test-cleanup');
+    globalThis.performance = realPerformance;
+  });
+  const tick = (seconds = 1 / 30) => {
+    nowMs += seconds * 1000;
+    viewer.clock.onTick.raiseEvent(viewer.clock);
+  };
+  const finish = () => {
+    for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) tick();
+    assert.equal(getActiveCameraMotion(), null, 'tilt must finish');
+  };
+  return { viewer, camera, target, tick, finish, viewTarget };
+}
+
+const pitchDeg = (camera) => degrees(camera.pitch);
+/** Tick until done() holds; a regression fails here instead of hanging. */
+const tickUntil = (h, done, frames = 600) => {
+  for (let i = 0; i < frames && !done(); i += 1) h.tick();
+  assert.ok(done(), `not reached in ${frames} frames`);
+};
+const headingDeg = (camera) =>
+  degrees(Cesium.Math.negativePiToPi(camera.heading));
+
+/** Metres between the original centre and the ground now under the crosshair. */
+function centreDrift(h) {
+  return Cesium.Cartesian3.distance(h.viewTarget(), h.target);
+}
+
+test('tilt up leaves a top-down view and keeps the place centred', (t) => {
+  const h = harness(t);
+  const result = moveCamera({ motion: 'tilt', direction: 'up' });
+  assert.equal(result.ok, true);
+  h.finish();
+  assert.ok(
+    Math.abs(pitchDeg(h.camera) - -75) < 0.5,
+    `pitch ${pitchDeg(h.camera)}`,
+  );
+  assert.ok(centreDrift(h) < 5, `centre drifted ${centreDrift(h)} m`);
+  assert.ok(Cesium.Matrix4.equals(h.camera.transform, Cesium.Matrix4.IDENTITY));
+});
+
+test('continuous tilt up from top-down keeps moving', (t) => {
+  const h = harness(t);
+  assert.equal(
+    moveCamera({ motion: 'tilt', direction: 'up', mode: 'continuous' }).ok,
+    true,
+  );
+  for (let i = 0; i < 30; i += 1) h.tick();
+  assert.equal(getActiveCameraMotion()?.kind, 'tilt');
+  assert.ok(pitchDeg(h.camera) > -82, `pitch ${pitchDeg(h.camera)}`);
+});
+
+test('a requested angle tilts to that pitch', (t) => {
+  const h = harness(t);
+  const result = moveCamera({ motion: 'tilt', pitchDeg: -45 });
+  assert.equal(result.ok, true);
+  assert.equal(result.direction, 'up');
+  assert.equal(result.pitchDeg, -45);
+  h.finish();
+  assert.ok(
+    Math.abs(pitchDeg(h.camera) - -45) < 0.5,
+    `pitch ${pitchDeg(h.camera)}`,
+  );
+  assert.ok(centreDrift(h) < 5, `centre drifted ${centreDrift(h)} m`);
+});
+
+test('a bare tilt settles on the default oblique angle', (t) => {
+  const h = harness(t);
+  const result = moveCamera({ motion: 'tilt' });
+  assert.equal(result.ok, true);
+  assert.equal(result.pitchDeg, -45);
+  h.finish();
+  assert.ok(Math.abs(pitchDeg(h.camera) - -45) < 0.5);
+});
+
+test('a requested angle can tilt back down toward top-down', (t) => {
+  const h = harness(t, { pitch: -30 });
+  const result = moveCamera({ motion: 'tilt', pitchDeg: -80 });
+  assert.equal(result.direction, 'down');
+  h.finish();
+  assert.ok(Math.abs(pitchDeg(h.camera) - -80) < 0.5);
+});
+
+test('requested angles clamp to the tilt limits', (t) => {
+  const h = harness(t);
+  assert.equal(moveCamera({ motion: 'tilt', pitchDeg: -2 }).pitchDeg, -5);
+  h.finish();
+  assert.ok(Math.abs(pitchDeg(h.camera) - -5) < 0.5);
+});
+
+test('a positive angle is read as the same angle below the horizon', (t) => {
+  const h = harness(t);
+  assert.equal(moveCamera({ motion: 'tilt', pitchDeg: 45 }).pitchDeg, -45);
+  h.finish();
+  assert.ok(Math.abs(pitchDeg(h.camera) - -45) < 0.5);
+});
+
+for (const pitch of ['', null, false, ' ', 'steep'])
+  test(`a blank or non-numeric angle ${JSON.stringify(pitch)} is ignored`, (t) => {
+    harness(t);
+    const result = moveCamera({ motion: 'tilt', pitchDeg: pitch });
+    // No angle and no direction: the default oblique view, never the horizon.
+    assert.equal(result.pitchDeg, -45);
+  });
+
+test('a requested angle the camera already holds is a no-op', (t) => {
+  harness(t, { pitch: -45 });
+  const result = moveCamera({ motion: 'tilt', pitchDeg: -45 });
+  assert.equal(result.ok, true);
+  assert.equal(result.unchanged, true);
+  assert.equal(getActiveCameraMotion(), null);
+});
+
+for (const pitch of [-90, -89]) {
+  test(`a top-down view asked for ${pitch}° stays put`, (t) => {
+    // The tool description calls -89 top-down; the clamp must not tilt a
+    // -90° view up 1° and report it as a move up.
+    const h = harness(t);
+    const before = pitchDeg(h.camera);
+    const result = moveCamera({ motion: 'tilt', pitchDeg: pitch });
+    assert.equal(result.ok, true);
+    assert.equal(result.unchanged, true);
+    assert.equal(result.pitchDeg, Math.round(before));
+    assert.equal(getActiveCameraMotion(), null);
+    assert.equal(pitchDeg(h.camera), before);
+  });
+}
+
+test('tilt down from top-down still refuses honestly', (t) => {
+  harness(t);
+  const result = moveCamera({ motion: 'tilt', direction: 'down' });
+  assert.equal(result.ok, false);
+  assert.match(result.error, /straight down/);
+});
+
+test('a tilt up nudge stops at the horizon limit', (t) => {
+  const h = harness(t, { pitch: -12 });
+  assert.equal(moveCamera({ motion: 'tilt', direction: 'up' }).ok, true);
+  h.finish();
+  assert.ok(Math.abs(pitchDeg(h.camera) - -5) < 0.5);
+});
+
+test('without a ground pivot a tilt still leaves top-down in place', (t) => {
+  const h = harness(t, { pivot: false });
+  const before = Cesium.Cartesian3.clone(h.camera.positionWC);
+  assert.equal(moveCamera({ motion: 'tilt', direction: 'up' }).ok, true);
+  h.finish();
+  assert.ok(Math.abs(pitchDeg(h.camera) - -75) < 0.5);
+  assert.ok(Cesium.Cartesian3.distance(h.camera.positionWC, before) < 1e-6);
+});
+
+for (const heading of [0, 30, -120])
+  test(`tilt from top-down keeps the ${heading}° heading`, (t) => {
+    const h = harness(t, { heading, height: 67000 });
+    // Top-down float noise must not pick a new heading for the pivot.
+    assert.equal(moveCamera({ motion: 'tilt', pitchDeg: -45 }).ok, true);
+    h.finish();
+    assert.ok(
+      Math.abs(headingDeg(h.camera) - heading) < 1,
+      `heading ${headingDeg(h.camera)}`,
+    );
+    assert.ok(centreDrift(h) < 50, `centre drifted ${centreDrift(h)} m`);
+  });
+
+test('an oblique tilt keeps its heading toward the pivot', (t) => {
+  const h = harness(t, { heading: 75, pitch: -60 });
+  assert.equal(moveCamera({ motion: 'tilt', pitchDeg: -30 }).ok, true);
+  h.finish();
+  assert.ok(Math.abs(headingDeg(h.camera) - 75) < 0.5);
+  assert.ok(centreDrift(h) < 5, `centre drifted ${centreDrift(h)} m`);
+});
+
+test('a pivoting tilt yields when tracking takes the camera', (t) => {
+  const h = harness(t);
+  assert.equal(moveCamera({ motion: 'tilt', pitchDeg: -45 }).ok, true);
+  h.tick();
+  const entity = { id: 'tracked' };
+  h.viewer.trackedEntity = entity;
+  h.viewer.trackedEntityChanged.raiseEvent(entity);
+  assert.equal(getActiveCameraMotion(), null);
+});
+
+/** Metres between the camera and the point it pivots about. */
+const pivotRange = (h) =>
+  Cesium.Cartesian3.distance(h.camera.positionWC, h.target);
+const heightM = (camera) =>
+  Cesium.Cartographic.fromCartesian(camera.positionWC).height;
+
+test('a zoom during a pivoting tilt changes the range it holds', (t) => {
+  const h = harness(t);
+  assert.equal(
+    moveCamera({ motion: 'tilt', direction: 'up', mode: 'continuous' }).ok,
+    true,
+  );
+  h.tick();
+  const before = pivotRange(h);
+  assert.deepEqual(
+    adjustOrbitRange(0.5),
+    { kind: 'tilt', changed: true },
+    'the tilt must take the zoom',
+  );
+  for (let i = 0; i < 5; i += 1) h.tick();
+  // The next frame's lookAt must not put the old range back.
+  assert.ok(
+    Math.abs(pivotRange(h) - before / 2) < 1,
+    `range ${pivotRange(h)} m, wanted ${before / 2} m`,
+  );
+});
+
+test('a zoom with no pivot to hold is left to the camera', (t) => {
+  harness(t, { pivot: false });
+  moveCamera({ motion: 'tilt', direction: 'up', mode: 'continuous' });
+  assert.equal(adjustOrbitRange(0.5), null);
+});
+
+test('a pivot tilt toward the horizon keeps its clearance above the ground', (t) => {
+  // A close top-down view: swinging 250 m of range to -5° would end ~22 m up.
+  const h = harness(t, { height: 250 });
+  assert.equal(moveCamera({ motion: 'tilt', pitchDeg: -5 }).ok, true);
+  let lowest = Infinity;
+  for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) {
+    h.tick();
+    lowest = Math.min(lowest, heightM(h.camera));
+  }
+  assert.equal(getActiveCameraMotion(), null, 'tilt must finish');
+  assert.ok(lowest > 149, `camera dropped to ${lowest} m`);
+  assert.ok(
+    Math.abs(pitchDeg(h.camera) - -5) < 0.5,
+    `pitch ${pitchDeg(h.camera)}`,
+  );
+  assert.ok(Cesium.Matrix4.equals(h.camera.transform, Cesium.Matrix4.IDENTITY));
+});
+
+test('a continuous tilt up from close in keeps its clearance', (t) => {
+  const h = harness(t, { height: 250 });
+  moveCamera({ motion: 'tilt', direction: 'up', mode: 'continuous' });
+  for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) {
+    h.tick();
+    assert.ok(heightM(h.camera) > 149, `camera at ${heightM(h.camera)} m`);
+  }
+  assert.ok(Math.abs(pitchDeg(h.camera) - -5) < 0.5);
+});
+
+test('a city-scale pivot tilt keeps the place centred to the horizon limit', (t) => {
+  const h = harness(t);
+  moveCamera({ motion: 'tilt', pitchDeg: -5 });
+  h.finish();
+  // 4 km of range clears the floor at every pitch: all pivot, no drift.
+  assert.ok(centreDrift(h) < 5, `centre drifted ${centreDrift(h)} m`);
+});
+
+test('pitchDeg against a contradicting direction is refused', (t) => {
+  harness(t, { pitch: -45 });
+  // "tilt down 10 degrees": -10° is an absolute angle, which is up from -45°.
+  const result = moveCamera({
+    motion: 'tilt',
+    direction: 'down',
+    pitchDeg: 10,
+  });
+  assert.equal(result.ok, false);
+  assert.match(result.error, /absolute angle/);
+  assert.equal(getActiveCameraMotion(), null);
+});
+
+test('pitchDeg with a direction that agrees still tilts', (t) => {
+  const h = harness(t, { pitch: -45 });
+  const result = moveCamera({
+    motion: 'tilt',
+    direction: 'down',
+    pitchDeg: -80,
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.direction, 'down');
+  h.finish();
+  assert.ok(Math.abs(pitchDeg(h.camera) - -80) < 0.5);
+});
+
+test('the pitchDeg and direction check uses the camera pitch', (t) => {
+  // At regional range the Earth curves away and the pivot pitch is a degree
+  // or two shallower than the camera's (-30°); -29° is still up from it.
+  harness(t, { height: 150000, pitch: -30 });
+  const down = moveCamera({ motion: 'tilt', direction: 'down', pitchDeg: -29 });
+  assert.equal(down.ok, false);
+  assert.match(down.error, /tilts up, not down/);
+  const up = moveCamera({ motion: 'tilt', direction: 'up', pitchDeg: -29 });
+  assert.equal(up.ok, true);
+  assert.equal(up.direction, 'up');
+});
+
+test('after a zoom in, a pivoting tilt never lowers the camera further', (t) => {
+  const h = harness(t, { height: 1000 });
+  moveCamera({ motion: 'tilt', direction: 'up', mode: 'continuous' });
+  tickUntil(h, () => pitchDeg(h.camera) >= -30);
+  adjustOrbitRange(1 / 2.4);
+  adjustOrbitRange(1 / 2.4);
+  h.tick();
+  const afterZoom = heightM(h.camera);
+  for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) {
+    h.tick();
+    assert.ok(
+      heightM(h.camera) > afterZoom - 1,
+      `camera fell from ${afterZoom} m to ${heightM(h.camera)} m`,
+    );
+  }
+  assert.ok(Math.abs(pitchDeg(h.camera) - -5) < 0.5);
+});
+
+test('a zoom in during a close pivot tilt never pushes the camera out', (t) => {
+  // 62 m of range, under the 80 m zoom floor.
+  const h = harness(t, { height: 40, pitch: -40 });
+  moveCamera({ motion: 'tilt', direction: 'down', mode: 'continuous' });
+  h.tick();
+  const before = pivotRange(h);
+  assert.ok(before < 80, `range ${before} m`);
+  adjustOrbitRange(1 / 1.6);
+  h.tick();
+  assert.ok(pivotRange(h) <= before + 0.01, `range grew to ${pivotRange(h)} m`);
+});
+
+test('a zoom out during a far orbit never pulls the camera in', (t) => {
+  // 15,000 km up, beyond the 5,000 km zoom cap.
+  const h = harness(t, { height: 15_000_000 });
+  assert.equal(moveCamera({ motion: 'orbit', mode: 'continuous' }).ok, true);
+  h.tick();
+  const before = pivotRange(h);
+  assert.ok(before > 5_000_000, `range ${before} m`);
+  assert.deepEqual(adjustOrbitRange(2.4), { kind: 'orbit', changed: false });
+  h.tick();
+  assert.ok(pivotRange(h) >= before - 1, `range fell to ${pivotRange(h)} m`);
+});
+
+test('an out-of-range pitchDeg is clamped to the tilt limits', (t) => {
+  // The schema carries no range; 120 reads as 120° below the horizon.
+  const h = harness(t, { pitch: -45 });
+  assert.equal(moveCamera({ motion: 'tilt', pitchDeg: 120 }).ok, true);
+  h.finish();
+  assert.ok(
+    Math.abs(pitchDeg(h.camera) - -89) < 0.5,
+    `pitch ${pitchDeg(h.camera)}`,
+  );
+});
+
+test('a zoom in during a pivot tilt stops at the clearance', (t) => {
+  // 400 m of range at -40°, then "zoom in a lot" twice: unfloored, that left
+  // the camera about 107 m up, then at the 80 m zoom floor.
+  const h = harness(t, { height: 400 });
+  moveCamera({ motion: 'tilt', direction: 'up', mode: 'continuous' });
+  tickUntil(h, () => pitchDeg(h.camera) >= -40);
+  assert.deepEqual(adjustOrbitRange(1 / 2.4), { kind: 'tilt', changed: true });
+  // At -40° the floor is 150 / sin 40° ≈ 233 m, which the first zoom reached.
+  assert.deepEqual(adjustOrbitRange(1 / 2.4), { kind: 'tilt', changed: false });
+  // The camera must take that range, not just report it.
+  h.tick();
+  const floor = 150 / Math.sin(radians(40));
+  assert.ok(
+    Math.abs(pivotRange(h) - floor) < floor * 0.02,
+    `range ${pivotRange(h)} m, wanted about ${floor} m`,
+  );
+  for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) {
+    h.tick();
+    assert.ok(heightM(h.camera) > 149, `camera at ${heightM(h.camera)} m`);
+  }
+  assert.ok(Math.abs(pitchDeg(h.camera) - -5) < 0.5);
+});
+
+test('a voice zoom during a pivot tilt says what it changed', async (t) => {
+  const h = harness(t, { height: 400 });
+  const runner = createGevActionRunner({
+    viewer: h.viewer,
+    styleManager: {},
+    dataManager: { layers: new Map(), getAll: () => [] },
+  });
+  moveCamera({ motion: 'tilt', direction: 'up', mode: 'continuous' });
+  h.tick();
+  const zoom = { direction: 'in', amount: 'lot' };
+  const first = await runner('adjust_camera_zoom', zoom);
+  assert.equal(first.ok, true);
+  assert.equal(first.tiltRangeAdjusted, true);
+  assert.equal('orbitRadiusAdjusted' in first, false);
+  // 400 m → 167 m → the 150 m clearance; a third zoom in moves nothing, and
+  // says so.
+  assert.equal((await runner('adjust_camera_zoom', zoom)).ok, true);
+  const third = await runner('adjust_camera_zoom', zoom);
+  assert.equal(third.ok, false);
+  assert.match(third.error, /tilt is already at its closest range/);
+});
+
+test('from globe range a tilt happens in place', (t) => {
+  // A pivot 2,000 km out would swing the camera thousands of km.
+  const h = harness(t, { height: 2_000_000 });
+  const before = Cesium.Cartesian3.clone(h.camera.positionWC);
+  assert.equal(moveCamera({ motion: 'tilt', pitchDeg: -45 }).ok, true);
+  h.finish();
+  assert.ok(Math.abs(pitchDeg(h.camera) - -45) < 0.5);
+  assert.ok(Cesium.Cartesian3.distance(h.camera.positionWC, before) < 1e-3);
+});
+
+for (const height of [100_000, 400_000])
+  test(`from ${height / 1000} km a tilt to -5° ends with the camera at -5°`, (t) => {
+    // The pivot pitch is shallower than the camera's by up to 4° at this
+    // range; the camera reached only -5.9° and -8.6° when the swing stopped
+    // at a pivot pitch of -5°.
+    const h = harness(t, { height });
+    const result = moveCamera({ motion: 'tilt', pitchDeg: 5 });
+    assert.equal(result.pitchDeg, -5);
+    h.finish();
+    assert.ok(
+      Math.abs(pitchDeg(h.camera) - -5) < 0.5,
+      `pitch ${pitchDeg(h.camera)}`,
+    );
+    assert.ok(heightM(h.camera) > 149, `camera at ${heightM(h.camera)} m`);
+    const nudge = moveCamera({ motion: 'tilt', direction: 'up' });
+    assert.equal(nudge.ok, false);
+    assert.match(nudge.error, /upper tilt limit/);
+  });
+
+// From 550 km out the camera's -5° lies beyond the place's own horizon: the
+// swing ran into its clearance, let go of the pivot and tilted the rest in
+// place, which put the crosshair on the sky (28 to 63 km up), and a return
+// to top-down then landed 600 to 900 km from the place.
+for (const height of [600_000, 700_000, 900_000]) {
+  test(`from ${height / 1000} km a tilt to -5° keeps the place centred`, (t) => {
+    const h = harness(t, { height });
+    const result = moveCamera({ motion: 'tilt', pitchDeg: 5 });
+    assert.equal(result.ok, true);
+    h.finish();
+    assert.ok(h.viewTarget(), 'the crosshair is on the sky');
+    assert.ok(centreDrift(h) < 100, `centre drifted ${centreDrift(h)} m`);
+    assert.ok(heightM(h.camera) > 149, `camera at ${heightM(h.camera)} m`);
+    // The reply names the angle the camera reached, not the one asked for.
+    assert.ok(result.pitchDeg < -5, `reported ${result.pitchDeg}°`);
+    assert.ok(
+      Math.abs(pitchDeg(h.camera) - result.pitchDeg) < 0.5,
+      `camera at ${pitchDeg(h.camera)}°, reported ${result.pitchDeg}°`,
+    );
+    assert.match(result.note, /horizon/);
+    const nudge = moveCamera({ motion: 'tilt', direction: 'up' });
+    assert.equal(nudge.ok, false);
+    assert.match(nudge.error, /upper tilt limit/);
+    assert.equal(moveCamera({ motion: 'tilt', pitchDeg: -89 }).ok, true);
+    h.finish();
+    assert.ok(centreDrift(h) < 100, `centre drifted ${centreDrift(h)} m`);
+    // Back over the place at the range it began with (-89° is ~1° off nadir).
+    const range = Cesium.Cartesian3.distance(h.camera.positionWC, h.target);
+    assert.ok(
+      Math.abs(range - height) < height * 0.01,
+      `top-down ${range} m from the place`,
+    );
+  });
+
+  test(`a continuous tilt up from ${height / 1000} km stops with the place centred`, (t) => {
+    const h = harness(t, { height });
+    moveCamera({ motion: 'tilt', direction: 'up', mode: 'continuous' });
+    for (let i = 0; i < 1200 && getActiveCameraMotion(); i += 1) {
+      h.tick();
+      assert.ok(h.viewTarget(), `the crosshair is on the sky at frame ${i}`);
+    }
+    assert.equal(getActiveCameraMotion(), null, 'tilt must stop at its limit');
+    assert.ok(centreDrift(h) < 100, `centre drifted ${centreDrift(h)} m`);
+  });
+}
+
+test('a pitchDeg tilt toward the horizon limit says it is already there', (t) => {
+  const h = harness(t, { height: 900_000 });
+  moveCamera({ motion: 'tilt', pitchDeg: 5 });
+  h.finish();
+  const again = moveCamera({ motion: 'tilt', pitchDeg: 5 });
+  assert.equal(again.ok, false);
+  assert.match(again.error, /upper tilt limit/);
+});
+
+test('a regional tilt-up nudge goes to the camera horizon limit', (t) => {
+  // 20 km up at -7°: the pivot 186 km out sits at -5.3°, but the camera can
+  // still tilt up 2°.
+  const h = harness(t, { height: 20000, pitch: -7 });
+  assert.equal(moveCamera({ motion: 'tilt', direction: 'up' }).ok, true);
+  h.finish();
+  assert.ok(
+    Math.abs(pitchDeg(h.camera) - -5) < 0.5,
+    `pitch ${pitchDeg(h.camera)}`,
+  );
+});
+
+test('a voice tilt from a tracked view judges its limit from the camera pitch', (t) => {
+  const h = harness(t, { height: 20000, pitch: -5.2 });
+  h.viewer.trackedEntity = { id: 'tracked' };
+  // Voice releases the follow camera before the motion starts.
+  const release = (start) => {
+    h.viewer.trackedEntity = undefined;
+    return start();
+  };
+  const result = moveCamera({ motion: 'tilt', direction: 'up' }, release);
+  assert.equal(result.ok, false);
+  assert.match(result.error, /upper tilt limit/);
+});
+
+test('a zoom out during a pivoting tilt stops at the pivot range limit', (t) => {
+  // 900 km top-down, "tilt to 10°", then "zoom out a lot" twice: capped at
+  // the orbit's 5,000 km, the swing reached 2,386 km up at a real -44°.
+  const h = harness(t, { height: 900_000 });
+  assert.equal(moveCamera({ motion: 'tilt', pitchDeg: -10 }).ok, true);
+  h.tick();
+  assert.deepEqual(adjustOrbitRange(2.4), { kind: 'tilt', changed: true });
+  assert.deepEqual(adjustOrbitRange(2.4), { kind: 'tilt', changed: false });
+  let farthest = 0;
+  for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) {
+    h.tick();
+    farthest = Math.max(farthest, pivotRange(h));
+  }
+  assert.equal(getActiveCameraMotion(), null, 'tilt must finish');
+  assert.ok(farthest <= 1_000_001, `swung ${farthest} m from the pivot`);
+  assert.ok(
+    Math.abs(pitchDeg(h.camera) - -10) < 0.5,
+    `pitch ${pitchDeg(h.camera)}`,
+  );
+});
+
+test('an unchanged angle still stops a running motion through navigation', (t) => {
+  const h = harness(t);
+  moveCamera({ motion: 'tilt', direction: 'up', mode: 'continuous' });
+  tickUntil(h, () => pitchDeg(h.camera) >= -45.3);
+  let handoffs = 0;
+  const navigate = (start) => {
+    handoffs += 1;
+    return start();
+  };
+  const result = moveCamera({ motion: 'tilt', pitchDeg: -45 }, navigate);
+  assert.equal(result.ok, true);
+  assert.equal(result.unchanged, true);
+  assert.equal(handoffs, 1, 'the request must take navigation');
+  assert.equal(getActiveCameraMotion(), null, 'the tilt must stop');
+  const held = pitchDeg(h.camera);
+  for (let i = 0; i < 30; i += 1) h.tick();
+  assert.equal(pitchDeg(h.camera), held);
+});
+
+for (const direction of ['left', 'right'])
+  test(`a tilt ${direction} is refused`, (t) => {
+    harness(t, { pitch: -45 });
+    const result = moveCamera({ motion: 'tilt', direction });
+    assert.equal(result.ok, false);
+    assert.match(result.error, /tilt needs up or down/);
+    const angled = moveCamera({ motion: 'tilt', direction, pitchDeg: -30 });
+    assert.equal(angled.ok, false);
+    assert.match(angled.error, /pitchDeg alone/);
+    assert.equal(getActiveCameraMotion(), null);
+  });
+
+// The 1,000 km pivot cutoff includes its boundary: at exactly 1,000 km the
+// pivot range came back a hair over it, so the tilt ran in place and put the
+// crosshair on the sky.
+test('from exactly 1,000 km a tilt to -5° still pivots about the place', (t) => {
+  const h = harness(t, { height: 1_000_000 });
+  const result = moveCamera({ motion: 'tilt', pitchDeg: 5 });
+  assert.equal(result.ok, true);
+  h.finish();
+  assert.ok(h.viewTarget(), 'the crosshair is on the sky');
+  assert.ok(centreDrift(h) < 100, `centre drifted ${centreDrift(h)} m`);
+  assert.ok(
+    Math.abs(pitchDeg(h.camera) - result.pitchDeg) < 0.5,
+    `camera at ${pitchDeg(h.camera)}°, reported ${result.pitchDeg}°`,
+  );
+  assert.match(result.note, /horizon/);
+});
+
+// A zoom mid-tilt moves the pivot's horizon limit: the zoom's reply names the
+// angle the tilt now ends at, and the camera ends there.
+test('a zoom out during a tilt to an angle reports the angle it now ends at', (t) => {
+  const h = harness(t, { height: 400_000 });
+  const result = moveCamera({ motion: 'tilt', pitchDeg: -5 });
+  assert.equal(result.pitchDeg, -5);
+  assert.equal(result.note, undefined);
+  for (let i = 0; i < 10; i += 1) h.tick();
+  const zoom = adjustOrbitRange(2.5);
+  assert.equal(zoom.kind, 'tilt');
+  assert.equal(zoom.changed, true);
+  h.finish();
+  assert.ok(h.viewTarget(), 'the crosshair is on the sky');
+  assert.ok(zoom.pitchDeg < -5, `zoom reported ${zoom.pitchDeg}°`);
+  assert.ok(
+    Math.abs(pitchDeg(h.camera) - zoom.pitchDeg) < 0.5,
+    `camera at ${pitchDeg(h.camera)}°, zoom reported ${zoom.pitchDeg}°`,
+  );
+  assert.match(zoom.note, /horizon/);
+});
+
+test('a zoom in during a horizon-limited tilt reports the angle it now reaches', (t) => {
+  const h = harness(t, { height: 900_000 });
+  const result = moveCamera({ motion: 'tilt', pitchDeg: -5 });
+  assert.ok(result.pitchDeg < -5, `reported ${result.pitchDeg}°`);
+  for (let i = 0; i < 10; i += 1) h.tick();
+  const zoom = adjustOrbitRange(1 / 2.4);
+  assert.equal(zoom.changed, true);
+  h.finish();
+  assert.equal(zoom.pitchDeg, -5);
+  assert.ok(
+    Math.abs(pitchDeg(h.camera) - -5) < 0.5,
+    `camera at ${pitchDeg(h.camera)}°`,
+  );
+});
+
+test('a voice zoom during a tilt to an angle passes on the new end angle', async (t) => {
+  const h = harness(t, { height: 400_000 });
+  const runner = createGevActionRunner({
+    viewer: h.viewer,
+    styleManager: {},
+    dataManager: { layers: new Map(), getAll: () => [] },
+  });
+  moveCamera({ motion: 'tilt', pitchDeg: -5 });
+  for (let i = 0; i < 10; i += 1) h.tick();
+  const zoom = await runner('adjust_camera_zoom', {
+    direction: 'out',
+    amount: 'lot',
+  });
+  assert.equal(zoom.ok, true);
+  assert.equal(zoom.tiltRangeAdjusted, true);
+  h.finish();
+  assert.ok(
+    Math.abs(pitchDeg(h.camera) - zoom.pitchDeg) < 0.5,
+    `camera at ${pitchDeg(h.camera)}°, zoom reported ${zoom.pitchDeg}°`,
+  );
+  assert.match(zoom.note, /horizon/);
+});
+
+// Late in the tilt the camera is already past the angle the new range's
+// horizon allows (from 400 km at -8°, a zoom out x2.5 reported -8°): past it
+// the place is behind the Earth, so the camera steps down to that limit with
+// the zoom, then holds it with no further jump, and the zoom's reply names
+// the angle it ends at, not the one it stood at.
+test('a late zoom out during a tilt steps to the new limit and reports it', (t) => {
+  const h = harness(t, { height: 400_000 });
+  moveCamera({ motion: 'tilt', pitchDeg: -5 });
+  for (let i = 0; i < 70; i += 1) h.tick();
+  const zoom = adjustOrbitRange(2.5);
+  assert.equal(zoom.changed, true);
+  h.tick();
+  assert.equal(zoom.pitchDeg, Math.round(pitchDeg(h.camera)));
+  let last = pitchDeg(h.camera);
+  let maxStep = 0;
+  for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) {
+    h.tick();
+    maxStep = Math.max(maxStep, Math.abs(pitchDeg(h.camera) - last));
+    last = pitchDeg(h.camera);
+  }
+  assert.equal(getActiveCameraMotion(), null, 'tilt must finish');
+  assert.ok(maxStep < 0.1, `pitch jumped ${maxStep}° in one frame`);
+  assert.ok(h.viewTarget(), 'the crosshair is on the sky');
+  // Replies give whole degrees: the reported angle is the reached one rounded.
+  assert.equal(
+    zoom.pitchDeg,
+    Math.round(pitchDeg(h.camera)),
+    `camera at ${pitchDeg(h.camera)}°, zoom reported ${zoom.pitchDeg}°`,
+  );
+  assert.match(zoom.note, /horizon/);
+});
+
+// Easing from the camera's old pitch at the zoomed-out range put the camera
+// below the place's horizon: the first frame's crosshair hit the ground
+// 186 km from London, and London stayed hidden for ~11 frames.
+test('a late zoom out during a tilt keeps the place under the crosshair', (t) => {
+  const h = harness(t, { height: 400_000 });
+  moveCamera({ motion: 'tilt', pitchDeg: -5 });
+  for (let i = 0; i < 70; i += 1) h.tick();
+  const zoom = adjustOrbitRange(2.5);
+  assert.equal(zoom.changed, true);
+  for (let i = 0; i < 600 && getActiveCameraMotion(); i += 1) {
+    h.tick();
+    const hit = h.viewTarget();
+    assert.ok(hit, `frame ${i}: the crosshair is on the sky`);
+    const drift = centreDrift(h);
+    assert.ok(
+      drift < 100,
+      `frame ${i}: crosshair ${Math.round(drift)} m off the place`,
+    );
+  }
+  assert.equal(getActiveCameraMotion(), null, 'tilt must finish');
+  assert.ok(
+    Math.abs(pivotRange(h) - 1_000_000) < 1,
+    `range ${pivotRange(h)} m`,
+  );
+  assert.equal(
+    zoom.pitchDeg,
+    Math.round(pitchDeg(h.camera)),
+    `camera at ${pitchDeg(h.camera)}°, zoom reported ${zoom.pitchDeg}°`,
+  );
+  assert.match(zoom.note, /horizon/);
+});
+
+// The zoom out left the pivot pitch level with the place, so the zoom in's
+// clearance floor came out infinite and it was refused at 1,000 km.
+test('a zoom in right after a late zoom out brings the tilt back in', (t) => {
+  const h = harness(t, { height: 400_000 });
+  moveCamera({ motion: 'tilt', pitchDeg: -5 });
+  for (let i = 0; i < 70; i += 1) h.tick();
+  const range = pivotRange(h);
+  assert.equal(adjustOrbitRange(2.5).changed, true);
+  const zoomIn = adjustOrbitRange(0.4);
+  assert.equal(zoomIn.changed, true, 'the zoom in must not be refused');
+  h.finish();
+  assert.ok(
+    Math.abs(pivotRange(h) - range) < 1,
+    `range ${pivotRange(h)} m, wanted ${range} m`,
+  );
+  assert.ok(
+    centreDrift(h) < 100,
+    `crosshair ${centreDrift(h)} m off the place`,
+  );
+});

src/cameraVerbs.js

@@ -20,11 +20,19 @@
 
 import * as Cesium from 'cesium';
 import { GLOBE_VIEW } from './locations.js';
+import {
+  globeFrameShare,
+  isFreeGlobeCamera,
+  lookAngleWithinFrame,
+  lookStepLosesGlobe,
+} from './globeInView.js';
 import {
   projectEarthDiscToViewport,
   earthDiscScreenRadius,
   getKeyholeGeometry,
+  KEYHOLE_OUTER_RADIUS,
 } from './celestialRing.js';
+import { isScopeMaskEnabled } from './scopeMask.js';
 import {
   holdContinuousRender,
   releaseContinuousRender,
@@ -48,6 +56,33 @@ const ONCE = {
 };
 const PITCH_MIN = Cesium.Math.toRadians(-89);
 const PITCH_MAX = Cesium.Math.toRadians(-5);
+/** A bare "tilt the camera" / "oblique view" settles here. */
+const TILT_DEFAULT_PITCH_DEG = -45;
+/** °/s for a tilt to a requested angle; short ones keep the once duration. */
+const TILT_TO_DEG_S = 30;
+/**
+ * A pivoting tilt keeps the range, so its height above the pivot is
+ * range × sin|pitch|. It swings no lower than this; the rest tilts in place.
+ */
+const TILT_MIN_CLEARANCE_M = 150;
+/**
+ * Beyond this range a pivot would swing the camera thousands of km about the
+ * crosshair point, so the tilt happens in place instead.
+ */
+const TILT_PIVOT_MAX_RANGE_M = 1_000_000;
+/**
+ * A pivot range rebuilt from the camera's position comes back a hair off the
+ * range it was set at: a range this close past the cutoff still counts as on
+ * it.
+ */
+const TILT_PIVOT_RANGE_SLACK_M = 1;
+/**
+ * The shallowest a pivot swing goes when its clearance is not what stops it.
+ * From several hundred km the camera's own horizon limit lies past the
+ * place's horizon; tilting the rest in place there would lift the crosshair
+ * onto the sky, so the swing stops with the place this far above it.
+ */
+const TILT_MIN_PIVOT_ELEVATION = Cesium.Math.toRadians(0.5);
 
 /* ── Route dolly: cinematic tuning ──────────────────────────────────────────
  * Every knob an owner may want to retune lives in this block. The shaping is
@@ -966,6 +1001,17 @@ let _trackingRemover = null;
 let _inputRemovers = [];
 /** Monotonic id for the motion currently running; 0 means "no motion". */
 let _motionSeq = 0;
+/** Canvas grabs, touches and wheel turns since load. */
+let _manualInputCount = 0;
+
+/**
+ * Lets a caller holding a motion back (behind a fly-to) see whether the user
+ * took the camera meanwhile; Cesium does not cancel a flight on input.
+ * @returns {number} Manual camera inputs so far.
+ */
+export function manualCameraInputCount() {
+  return _manualInputCount;
+}
 
 /**
  * Install a motion and stamp it with a fresh id. The id is what lets a caller
@@ -1008,6 +1054,187 @@ export function interruptCameraMotionIfActive(
   return interruptCameraMotion(reason);
 }
 
+// The frame share that in-place voice turns measure their limit against, with
+// the pose the last voice turn left the camera in. A turn that starts where
+// the last one left off keeps that baseline (raised if the planet now fills
+// more of the frame), so repeating a request cannot take a little more each
+// time. Once anything else has moved or turned the camera, a turn starts over
+// from what is on screen.
+let _lookBaseline = null;
+
+// The pre-check's proof that a half-degree turn from this pose keeps the planet
+// in view: which way, from which position and direction. A motion that starts from that
+// pose turns at least that far, so a request reported as done really moves
+// even when a smaller first step lands in a dip of the sampled share.
+const PROVEN_TURN_RAD = Cesium.Math.toRadians(0.5);
+let _provenLook = null;
+
+/** The part of the frame a viewer can see: the scope keyhole when it is on. */
+function visibleFrame() {
+  return { keyholeRadius: isScopeMaskEnabled() ? KEYHOLE_OUTER_RADIUS : 0 };
+}
+
+/** The frame share an in-place turn from `cam`'s pose is limited against. */
+function lookBaselineShare(cam) {
+  const share = globeFrameShare(cam, visibleFrame());
+  const continues =
+    _lookBaseline &&
+    Cesium.Cartesian3.equalsEpsilon(
+      _lookBaseline.position,
+      cam.positionWC,
+      0,
+      1,
+    ) &&
+    Cesium.Cartesian3.equalsEpsilon(
+      _lookBaseline.direction,
+      cam.directionWC,
+      0,
+      1e-9,
+    );
+  _lookBaseline = {
+    position: Cesium.Cartesian3.clone(cam.positionWC),
+    direction: Cesium.Cartesian3.clone(cam.directionWC),
+    share: continues ? Math.max(_lookBaseline.share, share) : share,
+  };
+  return _lookBaseline.share;
+}
+
+/**
+ * One in-place look step of motion `m`. From orbit a free globe camera turns
+ * only as far as keeps the planet in frame, measured against the baseline the
+ * turn started from, then the motion ends there.
+ */
+function lookWithinFrame(cam, m, look, angle) {
+  let allowed = angle;
+  if (isFreeGlobeCamera(_viewer)) {
+    if (m.globeShareAtStart === undefined) {
+      m.globeShareAtStart = lookBaselineShare(cam);
+      m.provenTurnRad = lookProven(cam, look) ? PROVEN_TURN_RAD : 0;
+      m.turnedRad = 0;
+    }
+    _provenLook = null;
+    allowed = lookAngleWithinFrame(cam, look, angle, {
+      ...visibleFrame(),
+      startShare: m.globeShareAtStart,
+    });
+    const owed = Math.min(angle, m.provenTurnRad - m.turnedRad);
+    if (allowed < owed) allowed = owed;
+    m.turnedRad += allowed;
+  }
+  if (allowed > 0) cam[look](allowed);
+  // The pose this turn leaves, for a turn that continues from it.
+  if (_lookBaseline)
+    Cesium.Cartesian3.clone(cam.directionWC, _lookBaseline.direction);
+  if (allowed < angle) interruptCameraMotion('globe-out-of-frame');
+}
+
+/**
+ * The in-place look a pitch change from `fromPitch` to `goalPitch` makes:
+ * 'lookUp', 'lookDown', or null when it does not move. A tilt is judged by
+ * the way its pitch moves, whatever form or direction word it came in.
+ */
+function tiltLook(fromPitch, goalPitch) {
+  if (!Number.isFinite(fromPitch) || !Number.isFinite(goalPitch)) return null;
+  if (goalPitch > fromPitch) return 'lookUp';
+  return goalPitch < fromPitch ? 'lookDown' : null;
+}
+
+/** Tilt `m` in place to `goalPitch`, as far as the frame limit allows. */
+function tiltInPlaceWithinFrame(cam, m, goalPitch) {
+  const look = tiltLook(cam.pitch, goalPitch);
+  if (look) lookWithinFrame(cam, m, look, Math.abs(goalPitch - cam.pitch));
+}
+
+/**
+ * The pitch an in-place tilt from `cam`'s pose toward `goalPitch` reaches
+ * before the frame limit stops it, judged as its steps will be: `goalPitch`
+ * itself when the planet stays in frame the whole way, or the camera is not a
+ * free globe camera. The steps run on a copy of the camera, each looking by
+ * the pitch still to go as the tilt's frames do, because a rolled camera's
+ * look turns its pitch by less than the look angle.
+ */
+function tiltPitchWithinFrame(cam, goalPitch) {
+  const look = tiltLook(cam.pitch, goalPitch);
+  if (!look || !isFreeGlobeCamera(_viewer)) return goalPitch;
+  const frame = { ...visibleFrame(), startShare: lookBaselineShare(cam) };
+  // A proven half degree is turned whatever the sampled share says.
+  let owed = lookProven(cam, look) ? PROVEN_TURN_RAD : 0;
+  const probe = Cesium.Camera.clone(cam);
+  for (let i = 0; i < 32; i += 1) {
+    if (tiltLook(probe.pitch, goalPitch) !== look) return goalPitch;
+    const angle = Math.abs(goalPitch - probe.pitch);
+    if (angle < 1e-6) return goalPitch;
+    const allowed = Math.max(
+      lookAngleWithinFrame(probe, look, angle, frame),
+      Math.min(angle, owed),
+    );
+    owed -= allowed;
+    if (allowed > 0) probe[look](allowed);
+    if (allowed < angle) return probe.pitch;
+  }
+  return probe.pitch;
+}
+
+/** The reply's note for a tilt the frame limit stops short of its angle. */
+function tiltFrameNote(pitch) {
+  return `Stopped at ${Math.round(Cesium.Math.toDegrees(pitch))}°: from this height a shallower angle would turn the globe out of view. Zoom in to tilt further.`;
+}
+
+/** True when the pre-check proved a half-degree `look` from `cam`'s pose. */
+function lookProven(cam, look) {
+  return (
+    _provenLook?.look === look &&
+    Cesium.Cartesian3.equalsEpsilon(
+      _provenLook.position,
+      cam.positionWC,
+      0,
+      1,
+    ) &&
+    Cesium.Cartesian3.equalsEpsilon(
+      _provenLook.direction,
+      cam.directionWC,
+      0,
+      1e-9,
+    )
+  );
+}
+
+/**
+ * The check a voice in-place turn (`look`: 'lookUp', 'lookDown', 'lookLeft'
+ * or 'lookRight') must pass from orbit: refused when even half a degree would
+ * cross the frame limit, otherwise proven for that half degree from this pose.
+ * With `released`, the turn runs through a navigation that first releases a
+ * tracked or locked camera and keeps its world pose. The frame measure and the
+ * turn are the same in any reference frame, so such a camera is judged as it
+ * is, before the release, and a refusal leaves tracking as it was. Otherwise a
+ * camera that is not a free globe camera is not checked. Returns the refusal,
+ * or null.
+ */
+function checkLookFromOrbit(look, { released = false } = {}) {
+  _provenLook = null;
+  if (_viewer.scene.mode !== Cesium.SceneMode.SCENE3D) return null;
+  const cam = _viewer.camera;
+  if (!released && !isFreeGlobeCamera(_viewer)) return null;
+  if (
+    lookStepLosesGlobe(cam, look, PROVEN_TURN_RAD, {
+      ...visibleFrame(),
+      startShare: lookBaselineShare(cam),
+    })
+  )
+    return {
+      ok: false,
+      action: 'move_camera',
+      error:
+        'From this height that would turn the globe out of view — zoom in first, or turn the other way.',
+    };
+  _provenLook = {
+    look,
+    position: Cesium.Cartesian3.clone(cam.positionWC),
+    direction: Cesium.Cartesian3.clone(cam.directionWC),
+  };
+  return null;
+}
+
 function clearLookAt() {
   try {
     _viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
@@ -1052,7 +1279,9 @@ export function interruptCameraMotion(reason = 'interrupt') {
   if (
     wasActive &&
     !tracking &&
-    (_active.kind === 'orbit' || _active.kind === 'route')
+    (_active.kind === 'orbit' ||
+      _active.kind === 'route' ||
+      (_active.kind === 'tilt' && _active.hpr))
   )
     clearLookAt();
   // Instant, not eased: the user grabbed the camera, or the flight is over.
@@ -1104,7 +1333,7 @@ function onTick() {
   let scale = 1;
   if (m.mode === 'once') {
     m.elapsed = (m.elapsed || 0) + dt;
-    const t = Math.min(1, m.elapsed / ONCE.durationS);
+    const t = Math.min(1, m.elapsed / (m.durationS || ONCE.durationS));
     scale = 1 - (1 - t) * (1 - t); // ease-out progress share
     if (t >= 1) {
       interruptCameraMotion('once-complete');
@@ -1173,30 +1402,20 @@ function onTick() {
       else if (m.direction === 'right') cam.moveRight(step);
       else if (m.direction === 'up') cam.moveUp(step);
       else cam.moveDown(step);
-    } else if (
-      m.kind === 'tilt' ||
-      m.kind === 'rotate' ||
-      m.kind === 'rotate_globe'
-    ) {
+    } else if (m.kind === 'tilt') {
+      tickTilt(cam, m, scale, dt);
+    } else if (m.kind === 'rotate' || m.kind === 'rotate_globe') {
       const degS = TILT_DEG_S[m.speed];
       const stepRad =
         m.mode === 'once'
-          ? Cesium.Math.toRadians(
-              m.kind === 'tilt' ? ONCE.tiltDeg : ONCE.rotateDeg,
-            ) *
-            (scale - (m.lastScale || 0))
+          ? Cesium.Math.toRadians(ONCE.rotateDeg) * (scale - (m.lastScale || 0))
           : Cesium.Math.toRadians(degS) * dt;
       m.lastScale = scale;
       if (m.kind === 'rotate_globe') {
         // Tracking can acquire the camera without going through navigation.
         // Yield without resetting its pose/frame: the world-space arc proof
         // only describes Cesium's rotation while the frame is identity.
-        if (
-          _viewer.scene.mode !== Cesium.SceneMode.SCENE3D ||
-          _viewer.trackedEntity ||
-          _isCockpitActive?.() ||
-          !Cesium.Matrix4.equals(cam.transform, Cesium.Matrix4.IDENTITY)
-        ) {
+        if (!isFreeGlobeCamera(_viewer) || _isCockpitActive?.()) {
           interruptCameraMotion('globe-camera-owner-changed');
           return;
         }
@@ -1218,18 +1437,14 @@ function onTick() {
           return;
         }
         cam.rotate(m.rotationAxis, angle);
-      } else if (m.kind === 'tilt') {
-        const up = m.direction === 'up';
-        // Clamp pitch to [-89°, -5°]: never through the ground, never at the sky.
-        const next = cam.pitch + (up ? stepRad : -stepRad);
-        if (next > PITCH_MAX || next < PITCH_MIN) {
-          interruptCameraMotion('tilt-clamp');
-          return;
-        }
-        if (up) cam.lookUp(stepRad);
-        else cam.lookDown(stepRad);
-      } else if (m.direction === 'left') cam.lookLeft(stepRad);
-      else cam.lookRight(stepRad);
+      } else {
+        lookWithinFrame(
+          cam,
+          m,
+          m.direction === 'left' ? 'lookLeft' : 'lookRight',
+          stepRad,
+        );
+      }
     } else if (m.kind === 'route') {
       // The dolly's shaping lives in advanceRouteFlight(); the tick only
       // applies the pose and honours the same completion path as before.
@@ -1252,6 +1467,186 @@ function onTick() {
   }
 }
 
+/**
+ * One frame of tilt. With a ground pivot the camera swings about it (lookAt),
+ * so the place under the crosshair stays centred; without one it looks up or
+ * down in place. Every angle and limit is the camera's own pitch, which at
+ * regional range is several degrees steeper than the pivot's (the Earth
+ * curves away), so the swing solves for the pivot pitch that gives it. Pitch
+ * is clamped to [-89°, -5°] only in the direction of travel: a top-down view
+ * sits at -90°, below the limit, and must still be able to tilt up out of it.
+ * A pivot swing toward the horizon lowers the camera, so it stops at
+ * TILT_MIN_CLEARANCE_M and the rest tilts in place. Farther out it stops with
+ * the camera TILT_MIN_PIVOT_ELEVATION above the place's horizon instead, and
+ * keeps the place centred: tilting in place there would lift the crosshair
+ * onto the sky.
+ */
+function tickTilt(cam, m, scale, dt) {
+  const from = cam.pitch;
+  const want =
+    m.mode === 'once'
+      ? m.startPitch + (m.goalPitch - m.startPitch) * scale
+      : from +
+        Cesium.Math.toRadians(TILT_DEG_S[m.speed]) *
+          dt *
+          (m.direction === 'up' ? 1 : -1);
+  const up = want > from;
+  const limited = up
+    ? Math.min(want, Math.max(from, PITCH_MAX))
+    : Math.max(want, Math.min(from, PITCH_MIN));
+  let atLimit = false;
+  if (m.hpr) {
+    // Apply a range a zoom set since the last frame, even when the pitch
+    // then has nowhere to go (a zoom in to the clearance ends the pivot).
+    cam.lookAt(m.target, m.hpr);
+    // Up toward the horizon the swing lowers the camera: hold the clearance,
+    // and keep the place below the horizon.
+    const cap = up
+      ? Math.max(m.hpr.pitch, tiltPivotPitchMax(m.hpr.range))
+      : Infinity;
+    for (let i = 0; i < 3 && Math.abs(limited - cam.pitch) > 1e-6; i += 1) {
+      const pitch = Math.min(
+        cap,
+        Math.max(-Cesium.Math.PI_OVER_TWO, m.hpr.pitch + limited - cam.pitch),
+      );
+      if (pitch === m.hpr.pitch) break;
+      m.hpr.pitch = pitch;
+      cam.lookAt(m.target, m.hpr);
+    }
+    // A once motion that just completed released the lookAt frame before
+    // this last step re-took it.
+    if (_active !== m) clearLookAt();
+    if (up && m.hpr.pitch >= cap && cam.pitch < limited - 1e-6) {
+      if (tiltClearanceBinds(m.hpr.range)) {
+        // Down to its clearance: let go of the pivot and tilt the rest in
+        // place, which keeps the height.
+        if (_active === m) clearLookAt();
+        m.hpr = null;
+        m.target = null;
+      } else {
+        // The place is at its horizon limit: stop here, still centred.
+        atLimit = true;
+      }
+    }
+  }
+  if (!m.hpr) tiltInPlaceWithinFrame(cam, m, limited);
+  if (m.mode !== 'once' && (limited !== want || atLimit))
+    interruptCameraMotion('tilt-clamp');
+}
+
+/** The refusal for a tilt up the camera has no room left for. */
+function tiltUpLimitRefusal() {
+  return {
+    ok: false,
+    action: 'move_camera',
+    error:
+      'Already at the upper tilt limit (near the horizon) — tilt down, or zoom/pan instead.',
+  };
+}
+
+/** Shallowest pivot pitch that keeps the clearance at this range. */
+function tiltPivotPitchMax(range) {
+  return Math.min(
+    -Math.asin(Math.min(1, TILT_MIN_CLEARANCE_M / range)),
+    -TILT_MIN_PIVOT_ELEVATION,
+  );
+}
+
+/**
+ * Whether the clearance, not the horizon, stops a swing at this range. Only
+ * then does the rest of the tilt happen in place: that close in (under ~17
+ * km) the camera's -5° limit stays well below its own horizon.
+ */
+function tiltClearanceBinds(range) {
+  return TILT_MIN_CLEARANCE_M / range >= Math.sin(TILT_MIN_PIVOT_ELEVATION);
+}
+
+/**
+ * The shallowest camera pitch a tilt starting from this frame can reach with
+ * the place under the crosshair still in view: PITCH_MAX, or less where a
+ * far pivot meets its horizon limit first.
+ */
+function tiltUpLimit({ target, pivot }) {
+  if (!pivot || tiltClearanceBinds(pivot.range)) return PITCH_MAX;
+  return Math.min(
+    PITCH_MAX,
+    pivotCameraPitch(
+      target,
+      pivot,
+      Math.max(pivot.pitch, tiltPivotPitchMax(pivot.range)),
+    ),
+  );
+}
+
+/** The camera pitch lookAt gives for this pivot at the given pivot pitch. */
+function pivotCameraPitch(target, { heading, range }, pitch) {
+  const offset = new Cesium.Cartesian3(
+    -range * Math.cos(pitch) * Math.sin(heading),
+    -range * Math.cos(pitch) * Math.cos(heading),
+    -range * Math.sin(pitch),
+  );
+  const eye = Cesium.Matrix4.multiplyByPoint(
+    Cesium.Transforms.eastNorthUpToFixedFrame(target),
+    offset,
+    new Cesium.Cartesian3(),
+  );
+  const look = Cesium.Cartesian3.subtract(target, eye, new Cesium.Cartesian3());
+  Cesium.Cartesian3.normalize(look, look);
+  const ellipsoid = _viewer.scene.globe?.ellipsoid ?? Cesium.Ellipsoid.WGS84;
+  const upAtEye = ellipsoid.geodeticSurfaceNormal(eye, new Cesium.Cartesian3());
+  return Math.asin(
+    Cesium.Math.clamp(Cesium.Cartesian3.dot(look, upAtEye), -1, 1),
+  );
+}
+
+/**
+ * Where a tilt starts. It swings about the ground under the crosshair so the
+ * place stays centred. It tilts in place with no ground there, from globe
+ * range, or while an entity is tracked (the follow camera owns that frame;
+ * voice releases it before moving, so a voice tilt still pivots).
+ */
+function tiltStartFrame(cam) {
+  const target = _viewer.trackedEntity ? null : _getTarget?.(_viewer);
+  let pivot = target ? tiltPivot(cam, target) : null;
+  if (pivot && !tiltPivotInReach(pivot.range)) pivot = null;
+  return { target, pivot, from: cam.pitch };
+}
+
+/** Whether a tilt may pivot at this range: up to and including the cutoff. */
+function tiltPivotInReach(range) {
+  return range <= TILT_PIVOT_MAX_RANGE_M + TILT_PIVOT_RANGE_SLACK_M;
+}
+
+/** The reply's note for a tilt the place's horizon stops short of its angle. */
+function tiltHorizonNote(pitch) {
+  return `Stopped at ${Math.round(Cesium.Math.toDegrees(pitch))}°: from this range a shallower angle puts the place past the horizon. Zoom in to tilt further.`;
+}
+
+/** Ground pivot for a tilt: heading, pitch and range in the target's own frame. */
+function tiltPivot(cam, target) {
+  const local = Cesium.Matrix4.multiplyByPoint(
+    Cesium.Matrix4.inverseTransformation(
+      Cesium.Transforms.eastNorthUpToFixedFrame(target),
+      new Cesium.Matrix4(),
+    ),
+    cam.positionWC,
+    new Cesium.Cartesian3(),
+  );
+  const range = Cesium.Cartesian3.magnitude(local);
+  if (!(range > 1) || local.z <= 0) return null;
+  // Near straight overhead the offset's heading is float noise (it flipped a
+  // north-up London view to south); keep the camera's own.
+  const heading =
+    Math.hypot(local.x, local.y) > range * 0.01
+      ? Math.atan2(-local.x, -local.y)
+      : cam.heading;
+  return new Cesium.HeadingPitchRange(
+    heading,
+    -Math.asin(Math.min(1, local.z / range)),
+    range,
+  );
+}
+
 /** Rigid origin-centred rotation stays outside the actual ellipsoid's bounding sphere. */
 function globeRotationHasClearance(position) {
   const ellipsoid = _viewer.scene.globe?.ellipsoid ?? Cesium.Ellipsoid.WGS84;
@@ -1413,6 +1808,7 @@ export function initCameraVerbs(
   _isCockpitActive =
     typeof isCockpitActive === 'function' ? isCockpitActive : null;
   _viewer = viewer;
+  _lookBaseline = null;
   if (_tickRemover) _tickRemover();
   _tickRemover = viewer.clock.onTick.addEventListener(onTick);
   if (_trackingRemover) _trackingRemover();
@@ -1421,18 +1817,108 @@ export function initCameraVerbs(
   _trackingRemover = viewer.trackedEntityChanged?.addEventListener((entity) => {
     if (entity && _active?.kind === 'rotate_globe')
       interruptCameraMotion('globe-camera-owner-changed');
+    // A pivoting tilt's lookAt would fight the follow camera every frame.
+    else if (entity && _active?.kind === 'tilt' && _active.hpr)
+      interruptCameraMotion('tilt-camera-owner-changed');
   });
   for (const rm of _inputRemovers) rm();
   _inputRemovers = [];
   const canvas = viewer.scene.canvas;
   // ANY manual camera input reclaims control — the cancelFlight reflex.
   for (const evt of ['pointerdown', 'touchstart', 'wheel']) {
-    const h = () => interruptCameraMotion('manual-input');
+    const h = () => {
+      _manualInputCount += 1;
+      interruptCameraMotion('manual-input');
+    };
     canvas.addEventListener(evt, h, { passive: true });
     _inputRemovers.push(() => canvas.removeEventListener(evt, h));
   }
 }
 
+/**
+ * A tilt's angle: the one asked for, the default oblique view when a bare
+ * "tilt the camera" names neither angle nor direction, or null for a nudge.
+ */
+function requestedTiltPitch(args, direction) {
+  // Only a real number or numeric text: Number('') and Number(null) are 0,
+  // which would swing the camera to the horizon.
+  const raw = args.pitchDeg;
+  const requested =
+    typeof raw === 'number' || (typeof raw === 'string' && raw.trim() !== '')
+      ? Number(raw)
+      : NaN;
+  // The camera never looks above the horizon, so a positive angle can only
+  // mean the same angle below it ("tilt 45 degrees" sent as 45).
+  if (Number.isFinite(requested))
+    return Cesium.Math.clamp(
+      Cesium.Math.toRadians(-Math.abs(requested)),
+      PITCH_MIN,
+      PITCH_MAX,
+    );
+  return direction === null
+    ? Cesium.Math.toRadians(TILT_DEFAULT_PITCH_DEG)
+    : null;
+}
+
+/**
+ * Argument errors move_camera refuses whatever the camera is doing, so a
+ * caller holding a motion back behind a flight can refuse it before waiting.
+ * @param {Object} args
+ * @returns {Object|null} The refusal, or null when the arguments are usable.
+ */
+export function moveCameraArgsError(args = {}) {
+  const motion = String(args.motion || '').toLowerCase();
+  const direction = args.direction
+    ? String(args.direction).toLowerCase()
+    : null;
+  if (motion === 'stop') return null;
+  if (!['orbit', 'pan', 'tilt', 'rotate', 'rotate_globe'].includes(motion)) {
+    return {
+      ok: false,
+      action: 'move_camera',
+      error: `Unknown motion "${args.motion}" — use orbit, pan, tilt, rotate, rotate_globe, or stop.`,
+    };
+  }
+  if (
+    motion !== 'orbit' &&
+    motion !== 'rotate_globe' &&
+    (motion !== 'tilt' || requestedTiltPitch(args, direction) === null) &&
+    !['left', 'right', 'up', 'down'].includes(direction)
+  ) {
+    return {
+      ok: false,
+      action: 'move_camera',
+      error: `${motion} needs a direction (${motion === 'tilt' ? 'up/down' : motion === 'rotate' ? 'left/right' : 'left/right/up/down'}).`,
+    };
+  }
+  if (motion === 'tilt' && (direction === 'left' || direction === 'right')) {
+    return {
+      ok: false,
+      action: 'move_camera',
+      error: 'tilt needs up or down, or pitchDeg alone for an angle.',
+    };
+  }
+  if (motion === 'rotate' && !['left', 'right'].includes(direction)) {
+    return {
+      ok: false,
+      action: 'move_camera',
+      error: 'rotate needs left or right.',
+    };
+  }
+  if (
+    motion === 'rotate_globe' &&
+    direction !== null &&
+    !['left', 'right'].includes(direction)
+  ) {
+    return {
+      ok: false,
+      action: 'move_camera',
+      error: 'rotate_globe needs left or right.',
+    };
+  }
+  return null;
+}
+
 /**
  * move_camera implementation. Returns the house result shape; rejections are
  * plain-English `ok:false` errors.
@@ -1465,54 +1951,66 @@ export function moveCamera(args = {}, runNavigation = null) {
     };
     return typeof runNavigation === 'function' ? runNavigation(stop) : stop();
   }
-  if (!['orbit', 'pan', 'tilt', 'rotate', 'rotate_globe'].includes(motion)) {
-    return {
-      ok: false,
-      action: 'move_camera',
-      error: `Unknown motion "${args.motion}" — use orbit, pan, tilt, rotate, rotate_globe, or stop.`,
-    };
-  }
-  if (
-    motion !== 'orbit' &&
-    motion !== 'rotate_globe' &&
-    !['left', 'right', 'up', 'down'].includes(direction)
-  ) {
-    return {
-      ok: false,
-      action: 'move_camera',
-      error: `${motion} needs a direction (left/right${motion !== 'rotate' ? '/up/down' : ''}).`,
-    };
-  }
-  if (motion === 'rotate' && !['left', 'right'].includes(direction)) {
-    return {
-      ok: false,
-      action: 'move_camera',
-      error: 'rotate needs left or right.',
-    };
-  }
-  if (
-    motion === 'rotate_globe' &&
-    direction !== null &&
-    !['left', 'right'].includes(direction)
-  ) {
-    return {
-      ok: false,
-      action: 'move_camera',
-      error: 'rotate_globe needs left or right.',
-    };
-  }
-  if (motion === 'tilt') {
-    // Honest limits: at the clamp a tilt is a no-op — say so instead of
-    // reporting success and letting the model gaslight itself (field test).
-    const pitch = _viewer.camera.pitch;
-    if (direction === 'up' && pitch >= PITCH_MAX - Cesium.Math.toRadians(0.5)) {
+  const argsError = moveCameraArgsError(args);
+  if (argsError) return argsError;
+  const tiltToPitch =
+    motion === 'tilt' ? requestedTiltPitch(args, direction) : null;
+  if (motion === 'tilt' && tiltToPitch !== null) {
+    // Angles and limits are the camera's own pitch, whatever the swing pivots
+    // about; releasing the follow camera does not change it.
+    const from = _viewer.camera.pitch;
+    // -89 or -90 means top-down, which a -90° view already is: the clamp
+    // must not tilt it up 1°.
+    const atTopDown = tiltToPitch <= PITCH_MIN && from <= PITCH_MIN;
+    if (
+      atTopDown ||
+      Math.abs(tiltToPitch - from) < Cesium.Math.toRadians(0.5)
+    ) {
+      // Still a camera request: it stops a running motion and releases the
+      // follow camera, as a tilt that moves would.
+      const hold = () => {
+        interruptCameraMotion('replaced');
+        return {
+          ok: true,
+          action: 'move_camera',
+          motion,
+          pitchDeg: Math.round(
+            Cesium.Math.toDegrees(atTopDown ? from : tiltToPitch),
+          ),
+          unchanged: true,
+        };
+      };
+      return typeof runNavigation === 'function' ? runNavigation(hold) : hold();
+    }
+    // pitchDeg is an absolute angle, not a step: "tilt down 10 degrees" sent
+    // as {direction:'down', pitchDeg:10} would tilt up from -45°.
+    const towards = tiltToPitch > from ? 'up' : 'down';
+    if ((direction === 'up' || direction === 'down') && direction !== towards) {
+      const target = Math.round(Cesium.Math.toDegrees(tiltToPitch));
+      const now = Math.round(Cesium.Math.toDegrees(from));
       return {
         ok: false,
         action: 'move_camera',
-        error:
-          'Already at the upper tilt limit (near the horizon) — tilt down, or zoom/pan instead.',
+        error: `pitchDeg is an absolute angle, not a step: ${target}° from ${now}° tilts ${towards}, not ${direction}. Send direction alone for a nudge, or pitchDeg alone for an angle.`,
       };
     }
+    if (
+      towards === 'up' &&
+      from >=
+        tiltUpLimit(tiltStartFrame(_viewer.camera)) - Cesium.Math.toRadians(0.5)
+    )
+      return tiltUpLimitRefusal();
+  } else if (motion === 'tilt') {
+    // Honest limits: at the clamp a tilt is a no-op — say so instead of
+    // reporting success and letting the model gaslight itself (field test).
+    const pitch = _viewer.camera.pitch;
+    if (
+      direction === 'up' &&
+      pitch >=
+        tiltUpLimit(tiltStartFrame(_viewer.camera)) - Cesium.Math.toRadians(0.5)
+    ) {
+      return tiltUpLimitRefusal();
+    }
     if (
       direction === 'down' &&
       pitch <= PITCH_MIN + Cesium.Math.toRadians(0.5)
@@ -1524,6 +2022,34 @@ export function moveCamera(args = {}, runNavigation = null) {
       };
     }
   }
+  // A tilt is judged by the way its pitch will move: toward its angle, or a
+  // nudge up or down; a rotate turns left only when told to, as it runs.
+  const look =
+    motion === 'tilt'
+      ? tiltLook(
+          _viewer.camera.pitch,
+          tiltToPitch ??
+            _viewer.camera.pitch +
+              Cesium.Math.toRadians(ONCE.tiltDeg) *
+                (direction === 'up' ? 1 : -1),
+        )
+      : motion === 'rotate'
+        ? direction === 'left'
+          ? 'lookLeft'
+          : 'lookRight'
+        : null;
+  // Honest limits from orbit too: a stopped turn rests within 0.05° of its
+  // limit, so one that cannot go half a degree further is refused rather than
+  // run and reported as done, and one that can is then turned at least that
+  // far. Near the limit the sampled share wobbles as the planet's edge crosses
+  // the grid, so a turn that would keep the planet can occasionally be refused
+  // too.
+  // A camera that is tracked or locked now is judged as the navigation that
+  // runs the turn will release it, so a refusal keeps the tracking.
+  const lookRefusal =
+    look &&
+    checkLookFromOrbit(look, { released: typeof runNavigation === 'function' });
+  if (lookRefusal) return lookRefusal;
   if (
     (motion === 'rotate_globe' ||
       (motion === 'orbit' && typeof runNavigation !== 'function')) &&
@@ -1607,14 +2133,70 @@ export function moveCamera(args = {}, runNavigation = null) {
         error: 'Globe rotation requires a clear ellipsoid bounding sphere.',
       };
   }
+  // The angle a tilt to an angle stops at short of it, and why.
+  let stoppedAt = null;
+  let stopNote = null;
   const start = () => {
     interruptCameraMotion('replaced');
+    // Checked again only if the release left the camera somewhere other than
+    // where the check above expected it.
+    if (look && !lookProven(_viewer.camera, look)) {
+      const refusal = checkLookFromOrbit(look);
+      if (refusal) return refusal;
+    }
     const state = {
       kind: motion,
       direction: direction || 'right',
       speed,
       mode,
     };
+    if (motion === 'tilt') {
+      const frame = tiltStartFrame(_viewer.camera);
+      const { target, pivot, from } = frame;
+      if (pivot) {
+        state.target = target;
+        state.hpr = pivot;
+      }
+      state.startPitch = from;
+      const upLimit = tiltUpLimit(frame);
+      if (tiltToPitch !== null) {
+        // From far out the place reaches its horizon before the camera
+        // reaches the asked angle: stop there, and say so.
+        let goal =
+          tiltToPitch > from
+            ? Math.min(tiltToPitch, Math.max(from, upLimit))
+            : tiltToPitch;
+        if (goal !== tiltToPitch) stopNote = tiltHorizonNote(goal);
+        // From orbit an in-place tilt stops where the planet would leave the
+        // frame: aim it there, and say so.
+        if (!pivot) {
+          const framed = tiltPitchWithinFrame(_viewer.camera, goal);
+          if (framed !== goal) {
+            goal = framed;
+            stopNote = tiltFrameNote(goal);
+          }
+        }
+        state.mode = 'once';
+        state.direction = goal > from ? 'up' : 'down';
+        state.goalPitch = goal;
+        // A zoom mid-tilt moves the horizon limit; it re-judges the goal
+        // against the angle asked for.
+        state.askedPitch = tiltToPitch;
+        state.durationS = Math.max(
+          ONCE.durationS,
+          Math.abs(Cesium.Math.toDegrees(goal - from)) / TILT_TO_DEG_S,
+        );
+        if (goal !== tiltToPitch) stoppedAt = goal;
+      } else {
+        // A nudge stops at the limit it travels toward.
+        const step =
+          Cesium.Math.toRadians(ONCE.tiltDeg) * (direction === 'up' ? 1 : -1);
+        state.goalPitch =
+          step > 0
+            ? Math.min(from + step, Math.max(from, upLimit))
+            : Math.max(from + step, Math.min(from, PITCH_MIN));
+      }
+    }
     if (motion === 'rotate_globe') {
       // Convert an inherited ground-target frame without changing the world
       // pose. Rotation must pivot about Earth, never the previous local target.
@@ -1633,9 +2215,11 @@ export function moveCamera(args = {}, runNavigation = null) {
     }
     if (motion === 'orbit') {
       if (_viewer.scene.tweens.length > 0) {
-        // A camera flight is in progress ("fly to X and orbit it") — ALWAYS arm
-        // and capture at the destination; a target existing right now is
-        // meaningless (the globe is always under the crosshair).
+        // A camera flight is in progress — ALWAYS arm and capture at the
+        // destination; a target existing right now is meaningless (the globe
+        // is always under the crosshair). The voice runner already holds an
+        // orbit until its own fly-to lands; this covers any other
+        // flight.
         setActiveMotion({
           kind: 'orbit',
           direction: direction || 'right',
@@ -1699,7 +2283,11 @@ export function moveCamera(args = {}, runNavigation = null) {
       motion,
       direction: state.direction,
       speed,
-      mode,
+      mode: state.mode,
+      ...(tiltToPitch !== null && {
+        pitchDeg: Math.round(Cesium.Math.toDegrees(stoppedAt ?? tiltToPitch)),
+      }),
+      ...(stopNote !== null && { note: stopNote }),
     };
   };
   const preserveCameraFlight =
@@ -1714,16 +2302,93 @@ export function moveCamera(args = {}, runNavigation = null) {
 /**
  * Zoom while orbiting: scale the orbit RADIUS instead of letting the zoom
  * fight the per-frame lookAt (field test: "zoom out did literally nothing").
+ * A tilt swinging about its pivot holds a range the same way.
  * @param {number} factor  >1 zooms out (radius grows), <1 zooms in.
- * @returns {boolean} true when an orbit consumed the zoom.
+ * @returns {{kind: string, changed: boolean, pitchDeg?: number,
+ *   note?: string}|null} the motion that consumed the zoom, and whether its
+ *   range moved; null when none did. A tilt to an angle whose end the new
+ *   range moves also names the angle it now ends at (pitchDeg), with a note.
  */
 export function adjustOrbitRange(factor) {
-  if (!_active || _active.kind !== 'orbit' || !_active.hpr) return false;
-  _active.hpr.range = Math.max(
-    80,
-    Math.min(5_000_000, _active.hpr.range * factor),
+  if (!_active || !['orbit', 'tilt'].includes(_active.kind) || !_active.hpr)
+    return null;
+  // A tilt's zoom in stops at the range that keeps its clearance. The limits
+  // never move a view the wrong way: a zoom in leaves a closer view in place,
+  // and a zoom out leaves a farther one.
+  const { kind, hpr } = _active;
+  const floor =
+    kind === 'tilt'
+      ? Math.max(80, TILT_MIN_CLEARANCE_M / Math.abs(Math.sin(hpr.pitch)))
+      : 80;
+  // A tilt pivots only within TILT_PIVOT_MAX_RANGE_M; farther out the swing
+  // would carry the camera thousands of km.
+  const ceiling = kind === 'tilt' ? TILT_PIVOT_MAX_RANGE_M : 5_000_000;
+  const range = hpr.range;
+  hpr.range = Math.max(
+    Math.min(floor, range),
+    Math.min(Math.max(ceiling, range), range * factor),
   );
-  return true;
+  // Under half a metre counts as not moved, as for a plain zoom.
+  const changed = Math.abs(hpr.range - range) >= 0.5;
+  return { kind, changed, ...(changed && retargetTiltAfterZoom(_active)) };
+}
+
+/**
+ * A zoom changed the range a tilt to an angle holds, and with it the place's
+ * horizon limit: aim the tilt at the angle asked for or the new limit,
+ * whichever comes first, from where the camera is now. The pivot pitch is
+ * re-solved so the new range keeps the camera's pitch, and a limit the camera
+ * is already past is eased down to rather than jumped to. Returns the end
+ * angle and a note for the reply when that end moved, otherwise nothing.
+ */
+function retargetTiltAfterZoom(m) {
+  if (m.kind !== 'tilt' || m.mode !== 'once' || m.askedPitch === undefined)
+    return {};
+  let from = _viewer.camera.pitch;
+  if (!(m.askedPitch > from)) return {};
+  if (m.hpr) {
+    // At the same pivot pitch a longer range looks down more steeply (the
+    // Earth curves away): find the pivot pitch that holds this camera pitch.
+    // It stays below the place's horizon limit (or where the pivot already
+    // was): past it the place drops behind the Earth, so a camera the zoom
+    // leaves past that limit steps down to it with the zoom.
+    const cap = Math.max(m.hpr.pitch, tiltPivotPitchMax(m.hpr.range));
+    for (let i = 0; i < 4; i += 1) {
+      const error = from - pivotCameraPitch(m.target, m.hpr, m.hpr.pitch);
+      if (Math.abs(error) < 1e-7) break;
+      const pitch = Cesium.Math.clamp(
+        m.hpr.pitch + error,
+        -Cesium.Math.PI_OVER_TWO,
+        cap,
+      );
+      if (pitch === m.hpr.pitch) break;
+      m.hpr.pitch = pitch;
+    }
+    from = Math.min(from, pivotCameraPitch(m.target, m.hpr, m.hpr.pitch));
+  }
+  const limit =
+    m.hpr && !tiltClearanceBinds(m.hpr.range)
+      ? Math.min(
+          PITCH_MAX,
+          pivotCameraPitch(m.target, m.hpr, tiltPivotPitchMax(m.hpr.range)),
+        )
+      : PITCH_MAX;
+  const goal = Math.min(m.askedPitch, limit);
+  if (Math.abs(goal - m.goalPitch) < 1e-6) return {};
+  m.goalPitch = goal;
+  m.startPitch = from;
+  m.elapsed = 0;
+  m.durationS = Math.max(
+    ONCE.durationS,
+    Math.abs(Cesium.Math.toDegrees(goal - from)) / TILT_TO_DEG_S,
+  );
+  const limited = goal !== m.askedPitch;
+  return {
+    pitchDeg: Math.round(Cesium.Math.toDegrees(goal)),
+    note: limited
+      ? tiltHorizonNote(goal)
+      : `The tilt now reaches ${Math.round(Cesium.Math.toDegrees(goal))}°.`,
+  };
 }
 
 /**

src/cockpitMarkup.test.mjs

@@ -1306,12 +1306,12 @@ test('voice Cockpit entry honours a requested contact layer before it enters', (
     ui.indexOf("if (normalized === 'exit') {"),
   );
   assert.ok(branch, 'cockpit enter branch is missing');
-  const gateIndex = branch.indexOf('isEntryAllowed?.()');
+  const gateIndex = branch.indexOf('this._cockpitEntryRefusal()');
   const retargetIndex = branch.indexOf('_retargetCockpitEntryLayer(');
   const enterIndex = branch.indexOf('enterCockpitWithTracking({');
   assert.ok(
     gateIndex >= 0,
-    'entry consults the same gate the manual chip uses',
+    'entry refuses on the gate it can check before tracking',
   );
   assert.ok(
     retargetIndex > gateIndex,
@@ -1362,9 +1362,21 @@ test('voice Cockpit entry refuses when the entry gate is shut', () => {
     ui.indexOf("if (normalized === 'enter') {"),
     ui.indexOf("if (normalized === 'exit') {"),
   );
-  assert.match(branch, /if \(!this\.cockpitView\.isEntryAllowed\?\.\(\)\) \{/);
-  assert.match(branch, /Contacts must be active to enter Cockpit/);
-  assert.match(branch, /Contacts is still starting up/);
+  // Contacts is not required: only a Context change in flight or no aircraft
+  // layer to ride shuts the gate before tracking, and the entry itself then
+  // applies the manual chip's gate to the aircraft it rides.
+  assert.match(
+    branch,
+    /const refusal = this\._cockpitEntryRefusal\(\);\s*if \(refusal\) \{/,
+  );
+  assert.doesNotMatch(branch, /Contacts must be active/);
+  const refusal = ui.slice(
+    ui.indexOf('  _cockpitEntryRefusal() {'),
+    ui.indexOf('  getCockpitState() {'),
+  );
+  assert.match(refusal, /Context is still changing/);
+  assert.match(refusal, /No aircraft layer is on/);
+  assert.doesNotMatch(refusal, /[Cc]ontacts/);
 });
 
 test('cockpit state cannot report entryAllowed while already active', () => {
@@ -1382,7 +1394,8 @@ test('cockpit state cannot report entryAllowed while already active', () => {
   );
   assert.match(state, /entryBlockedReason:/, 'and a refusal can be explained');
   assert.match(state, /'contacts-starting'/);
-  assert.match(state, /'contacts-inactive'/);
+  assert.match(state, /'subject-layer-off'/);
+  assert.doesNotMatch(state, /'contacts-inactive'/, 'Contacts is not required');
   assert.match(state, /'no-tracked-aircraft'/);
 });
 

src/cockpitSignalFocus.test.mjs

@@ -147,6 +147,40 @@ const snapshot = (distanceM = 2000) => ({
   ],
 });
 
+test('a feed-off row leads the rebuilt rows and the list stays five long', async (t) => {
+  const f = fixture(t);
+  const crowded = {
+    ...snapshot(),
+    cohorts: [
+      {
+        id: 'flights',
+        count: 6,
+        nearest: [1, 2, 3, 4, 5, 6].map((n) => ({
+          id: `n${n}`,
+          label: `N${n}`,
+          distanceM: n * 1000,
+        })),
+      },
+    ],
+  };
+  updateCockpitSignals.call(f.owner, crowded, 0, {
+    title: 'MILITARY FEED OFF · PARTIAL PICTURE',
+    detail: 'NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR',
+  });
+  await nextTick();
+  assert.equal(f.owner.signalItems.length, 5);
+  assert.equal(f.owner.signalItems[0].key, 'feed-status');
+  assert.equal(f.owner.signalItems[0].tone, 'warning');
+  assert.equal(f.owner.signalItems[0].target, null);
+  assert.match(f.list.textContent, /MILITARY FEED OFF · PARTIAL PICTURE/);
+  updateCockpitSignals.call(f.owner, crowded, 0);
+  assert.equal(
+    f.owner.signalItems.some((item) => item.key === 'feed-status'),
+    false,
+    'with the feed back, the row goes',
+  );
+});
+
 test('rows render the signals the controller presents', async (t) => {
   const f = fixture(t);
   await render(f, [

src/contextModePolicy.js

@@ -411,30 +411,37 @@ export function contextRestoreLayerIds(snapshot = {}) {
   return restored;
 }
 
+/** The layers an aircraft Cockpit subject can come from. */
+export const COCKPIT_AIRCRAFT_LAYER_IDS = Object.freeze([
+  'flights',
+  'military',
+]);
+
 /**
- * Cockpit entry belongs to the operational Contacts context bundle. A tracked
- * aircraft alone is not sufficient: both observed-flight feeds must still be
- * active so the cockpit's surrounding-contact picture is not presented as a
- * complete context view when one source is disabled.
+ * Cockpit entry needs only the aircraft it rides: that aircraft's own layer
+ * (Live Flights for a civilian, Military Flights for a military aircraft) must
+ * be on. Contacts and the other feeds are not required. When a source the
+ * surrounding picture uses is off, the Cockpit's Contact card and Live
+ * Signals say the picture is partial instead of blocking entry, so a partial
+ * picture is never presented as complete. A Context mode change in flight
+ * still owns the camera, so entry waits it out.
  *
- * @param {object} input Current context and dependency visibility.
- * @param {string|null} input.contextMode Active Context mode.
- * @param {boolean} input.contextModeChanging Whether the Context transaction is unsettled.
- * @param {boolean} input.flightsEnabled Whether Live Flights is enabled.
- * @param {boolean} input.militaryEnabled Whether Military Flights is enabled.
+ * @param {object} input Current subject and Context state.
+ * @param {string|null} input.subjectLayerId Layer of the tracked aircraft
+ *   ('flights' or 'military'), or null with none tracked.
+ * @param {boolean} input.subjectLayerEnabled Whether that layer is enabled.
+ * @param {boolean} input.contextModeChanging Whether a Context transaction is unsettled.
  * @returns {boolean} Whether cockpit entry may be offered or activated.
  */
 export function cockpitEntryAllowed({
-  contextMode,
+  subjectLayerId,
+  subjectLayerEnabled,
   contextModeChanging,
-  flightsEnabled,
-  militaryEnabled,
 }) {
   return (
-    contextMode === 'flights' &&
-    !contextModeChanging &&
-    Boolean(flightsEnabled) &&
-    Boolean(militaryEnabled)
+    COCKPIT_AIRCRAFT_LAYER_IDS.includes(subjectLayerId) &&
+    Boolean(subjectLayerEnabled) &&
+    !contextModeChanging
   );
 }
 

src/contextModePolicy.test.mjs

@@ -400,37 +400,32 @@ test('explicit layer intent finishing during restore overrides the stale queued
   }
 });
 
-test('cockpit entry requires Contacts context with both aircraft feeds enabled', () => {
+test("cockpit entry needs only the tracked aircraft's own layer", () => {
   assert.equal(cockpitEntryAllowed({
-    contextMode: 'flights',
+    subjectLayerId: 'flights',
+    subjectLayerEnabled: true,
     contextModeChanging: false,
-    flightsEnabled: true,
-    militaryEnabled: true,
-  }), true);
+  }), true, 'a civilian needs Live Flights alone: no Contacts, no Military');
   assert.equal(cockpitEntryAllowed({
-    contextMode: 'flights',
+    subjectLayerId: 'military',
+    subjectLayerEnabled: true,
+    contextModeChanging: false,
+  }), true, 'a military aircraft needs Military Flights alone');
+  assert.equal(cockpitEntryAllowed({
+    subjectLayerId: 'flights',
+    subjectLayerEnabled: true,
     contextModeChanging: true,
-    flightsEnabled: true,
-    militaryEnabled: true,
-  }), false, 'Cockpit remains unavailable until Contacts activation settles');
+  }), false, 'Cockpit remains unavailable until a Context mode change settles');
   assert.equal(cockpitEntryAllowed({
-    contextMode: null,
+    subjectLayerId: 'military',
+    subjectLayerEnabled: false,
     contextModeChanging: false,
-    flightsEnabled: true,
-    militaryEnabled: true,
-  }), false, 'ordinary layer selection is not an operational Contacts context');
+  }), false, "the ridden aircraft's own layer is required");
   assert.equal(cockpitEntryAllowed({
-    contextMode: 'flights',
+    subjectLayerId: null,
+    subjectLayerEnabled: false,
     contextModeChanging: false,
-    flightsEnabled: true,
-    militaryEnabled: false,
-  }), false, 'the military contact feed is required');
-  assert.equal(cockpitEntryAllowed({
-    contextMode: 'flights',
-    contextModeChanging: false,
-    flightsEnabled: false,
-    militaryEnabled: true,
-  }), false, 'the civilian contact feed is required');
+  }), false, 'there is no aircraft to ride');
 });
 
 test('context teardown guard restores coordination state after success and failure', async () => {

src/data/cctv.js

@@ -67,6 +67,8 @@ export const _extractPickedCameraIdForTest =
 export const _setCctvCoverageStateForTest = layer._setCctvCoverageStateForTest;
 export const focusCctvRecord = layer.focusCctvRecord;
 export const maybeAutoHop = layer.maybeAutoHop;
+export const openingCameraId = layer.openingCameraId;
+export const reopenNearestCamera = layer.reopenNearestCamera;
 export const cctvCycleIndex = layer.cctvCycleIndex;
 export {
   CCTV_CALIBRATION_STORAGE_KEY_V1,

src/data/cctv.test.mjs

@@ -61,6 +61,8 @@ import cctvLayer, {
   materializeCctvActiveCoverageEntities,
   materializeCctvVisibleCoverageEntities,
   maybeAutoHop,
+  openingCameraId,
+  reopenNearestCamera,
   prioritizeActiveCctvGeometryRecord,
   processCctvGeometryDrainBatch,
   processCctvGeometryQueueBatch,
@@ -1296,6 +1298,120 @@ test('CCTV null-active coverage, auto-hop, cycling, and panel targets stay hones
   }
 });
 
+test('CCTV opens on the camera nearest the viewer, not the first in the catalog', () => {
+  // QA 2026-11-05: at King's Cross, turning CCTV on showed a Sydney camera,
+  // the first catalog record, instead of the TfL camera 0.3 km away.
+  const viewer = makeDeselectViewer();
+  viewer.camera.positionCartographic = Cesium.Cartographic.fromDegrees(
+    -0.1209,
+    51.5295,
+    187,
+  );
+  viewer.camera.positionWC = Cesium.Cartesian3.fromDegrees(
+    -0.1209,
+    51.5295,
+    187,
+  );
+  const sydney = makeDeselectRecord('au-sydney');
+  sydney.camera = { ...sydney.camera, lat: -34.03, lon: 151.11 };
+  const london = makeDeselectRecord('gb-kings-cross');
+  london.camera = { ...london.camera, lat: 51.5318, lon: -0.1209 };
+  try {
+    _setCctvCoverageStateForTest({
+      viewer,
+      records: [sydney, london],
+      activeCameraId: null,
+      enabled: false,
+    });
+    assert.equal(openingCameraId(), 'gb-kings-cross');
+    _setCctvCoverageStateForTest({
+      viewer: null,
+      records: [sydney, london],
+      activeCameraId: null,
+      enabled: false,
+    });
+    assert.equal(
+      openingCameraId(),
+      'au-sydney',
+      'with no viewer position the first record is the fallback',
+    );
+    _setCctvCoverageStateForTest({ viewer, records: [], enabled: false });
+    assert.equal(openingCameraId(), null);
+  } finally {
+    _setCctvCoverageStateForTest({ enabled: false });
+  }
+});
+
+test('the opening camera follows a shared view that lands after CCTV turned on, until someone picks one', () => {
+  // A share link turns CCTV on before its flight lands, so enable() picks
+  // from the startup view; the flight's settled move re-picks near London.
+  const viewer = makeDeselectViewer();
+  viewer.camera.positionCartographic = Cesium.Cartographic.fromDegrees(
+    -0.1209,
+    51.5295,
+    187,
+  );
+  const sydney = makeDeselectRecord('au-sydney');
+  sydney.camera = { ...sydney.camera, lat: -34.03, lon: 151.11 };
+  const london = makeDeselectRecord('gb-kings-cross');
+  london.camera = { ...london.camera, lat: 51.5318, lon: -0.1209 };
+  for (const record of [sydney, london])
+    Object.assign(record, {
+      groundResolved: {},
+      groundSamples: {},
+      groundPrior: 0,
+      frustumGeometry: null,
+      frustumPositions: null,
+      probeClampRangeM: null,
+    });
+  _setCctvOverlayHostForTest({
+    setEntries() {},
+    setVisible() {},
+    clearSource() {},
+  });
+  // Activation builds the projection canvas and frame image.
+  const originalDocument = globalThis.document;
+  const originalImage = globalThis.Image;
+  globalThis.document = {
+    createElement: () => ({ getContext: () => null }),
+  };
+  globalThis.Image = class {};
+  try {
+    _setCctvCoverageStateForTest({
+      viewer,
+      records: [sydney, london],
+      activeCameraId: 'au-sydney',
+      enabled: true,
+      openingCameraProvisional: true,
+    });
+    assert.equal(reopenNearestCamera(), true);
+    assert.equal(cctvLayer.getUIState().activeCameraId, 'gb-kings-cross');
+    assert.equal(reopenNearestCamera(), false, 'already the nearest');
+
+    // Someone chooses a camera: settled moves leave it alone.
+    setActiveCamera('au-sydney');
+    assert.equal(reopenNearestCamera(), false);
+    assert.equal(cctvLayer.getUIState().activeCameraId, 'au-sydney');
+
+    // A deselect is a choice too.
+    _setCctvCoverageStateForTest({
+      viewer,
+      records: [sydney, london],
+      activeCameraId: 'au-sydney',
+      enabled: true,
+      openingCameraProvisional: true,
+    });
+    deactivateActiveCamera();
+    assert.equal(reopenNearestCamera(), false);
+    assert.equal(cctvLayer.getUIState().activeCameraId, null);
+  } finally {
+    globalThis.document = originalDocument;
+    globalThis.Image = originalImage;
+    _setCctvOverlayHostForTest();
+    _setCctvCoverageStateForTest({ enabled: false });
+  }
+});
+
 test('CCTV disable clears and hides its shared-host source through the real layer lifecycle', () => {
   const calls = [];
   _setCctvOverlayHostForTest({

src/data/cctvCalgary.test.mjs

@@ -12,7 +12,7 @@ import {
   CALGARY_IMAGE_ORIGIN,
   CALGARY_MAX_CATALOG_BYTES,
   DEFAULT_CALGARY_ROWS_URL,
-  DEFAULT_CCTV_MAX_SOURCES,
+  CCTV_SHARED_SOURCE_SLOTS,
 } from '../../server/providers/cctv/constants.js';
 import { CAMERA_CODE_MAX_CHARS } from '../../server/providers/cctv/normalize.js';
 import { allocateSourceCap } from '../../server/providers/cctv/cap.js';
@@ -384,6 +384,6 @@ test('CCTV_CALGARY_ENABLED=0 keeps the lane from being loaded at all', async (t)
   }
 });
 
-test('the shipped catalog ceiling is not raised to make room for this pack', () => {
-  assert.equal(DEFAULT_CCTV_MAX_SOURCES, 4000);
+test('the shared catalog slots are not raised to make room for this pack', () => {
+  assert.equal(CCTV_SHARED_SOURCE_SLOTS, 4000);
 });

src/data/cctvCatalogCap.test.mjs

@@ -6,9 +6,12 @@ import {
 } from '../../server/providers/cctv/cap.js';
 import {
   CCTV_MAX_SOURCES_CEILING,
+  CCTV_SHARED_SOURCE_SLOTS,
   CCTV_SOURCE_CACHE_MS,
   DEFAULT_CCTV_MAX_SOURCES,
+  WORLD_CCTV_SOURCE_COUNT,
 } from '../../server/providers/cctv/constants.js';
+import { QUEBEC_CAMERA_SOURCE_COUNT } from '../../server/providers/cctv/quebec.js';
 import { createCctvCatalog } from '../../server/providers/cctv/catalog.js';
 
 const pack = (name, count, prefix = name) => ({
@@ -99,6 +102,68 @@ test('duplicate ids resolve last-pack-wins and count against the winning pack',
   ]);
 });
 
+/** Shared packs plus two reserved ones, shaped like the default catalog. */
+const reservedFixture = () => [
+  ...Array.from({ length: 20 }, (_, i) => pack(`shared${i}`, 250)),
+  { ...pack('quebec', 1120), reservedCount: 1120 },
+  { ...pack('world', 2230), reservedCount: 2230 },
+];
+const keptByName = (packs) =>
+  Object.fromEntries(packs.map(({ name, kept }) => [name, kept]));
+
+test('the default cap is the shared floor plus the reserved Québec and World packs', () => {
+  assert.equal(
+    DEFAULT_CCTV_MAX_SOURCES,
+    CCTV_SHARED_SOURCE_SLOTS +
+      QUEBEC_CAMERA_SOURCE_COUNT +
+      WORLD_CCTV_SOURCE_COUNT,
+  );
+});
+
+test('at the default cap reserved packs are whole and shared packs keep the floor', () => {
+  const { sources, packs } = allocateSourceCap(
+    reservedFixture(),
+    DEFAULT_CCTV_MAX_SOURCES,
+  );
+  const kept = keptByName(packs);
+  assert.equal(sources.length, DEFAULT_CCTV_MAX_SOURCES);
+  assert.equal(kept.quebec, 1120);
+  assert.equal(kept.world, 2230);
+  for (let i = 0; i < 20; i++) assert.equal(kept[`shared${i}`], 200);
+  assert.match(
+    sources[0].id,
+    /^shared0-/,
+    'the first camera stays in a shared pack',
+  );
+});
+
+test('a cap at the shared floor reserves nothing and thins every pack evenly', () => {
+  const { packs } = allocateSourceCap(reservedFixture(), 4000);
+  const kept = keptByName(packs);
+  // 22 lanes share 4,000 round-robin: nobody is wiped out by the reservation.
+  for (const count of Object.values(kept))
+    assert.ok(count >= 181 && count <= 182);
+});
+
+test('a small cap (dev-secure 48) still reaches the shared packs first', () => {
+  const { sources, packs } = allocateSourceCap(reservedFixture(), 48);
+  const kept = keptByName(packs);
+  assert.equal(sources.length, 48);
+  for (let i = 0; i < 20; i++) assert.ok(kept[`shared${i}`] >= 2);
+  assert.match(sources[0].id, /^shared0-/);
+});
+
+test('reservations fill only the room above the floor, round-robin between reserved packs', () => {
+  const { packs } = allocateSourceCap(reservedFixture(), 4100);
+  const kept = keptByName(packs);
+  const shared = Object.entries(kept)
+    .filter(([name]) => name.startsWith('shared'))
+    .reduce((sum, [, count]) => sum + count, 0);
+  // 100 reserved slots split between Québec and World, then 4,000 round-robin.
+  assert.ok(shared >= 4000 - 2 * 182, `shared packs kept ${shared}`);
+  assert.equal(shared + kept.quebec + kept.world, 4100);
+});
+
 test('resolveCatalogCap bounds the env value and falls back to the default', () => {
   assert.equal(resolveCatalogCap(undefined), DEFAULT_CCTV_MAX_SOURCES);
   assert.equal(resolveCatalogCap('nonsense'), DEFAULT_CCTV_MAX_SOURCES);

src/data/cctvDriveBcSource.test.mjs

@@ -14,6 +14,8 @@ import {
   DEFAULT_ONTARIO_MAX_SOURCES,
   DEFAULT_FINTRAFFIC_MAX_SOURCES,
   DEFAULT_TXDOT_MAX_SOURCES,
+  DEFAULT_OTTAWA_MAX_SOURCES,
+  CCTV_SHARED_SOURCE_SLOTS,
   DEFAULT_TALLINN_MAX_SOURCES,
   DEFAULT_TARKTEE_MAX_SOURCES,
   DEFAULT_NSW_MAX_SOURCES,
@@ -222,7 +224,7 @@ test('CCTV catalog merges DriveBC cameras and CCTV_DRIVEBC_ENABLED=0 skips the r
   );
 });
 
-test('default caps of the original packs fit inside the default catalog cap', () => {
+test('default caps of the original packs fit inside the shared catalog slots', () => {
   // Every default pack at its own cap (Warendorf ships 1 curated camera).
   const packs =
     DEFAULT_AUSTIN_MAX_SOURCES +
@@ -231,15 +233,18 @@ test('default caps of the original packs fit inside the default catalog cap', ()
     DEFAULT_ONTARIO_MAX_SOURCES +
     DEFAULT_FINTRAFFIC_MAX_SOURCES +
     DEFAULT_DRIVEBC_MAX_SOURCES +
+    DEFAULT_OTTAWA_MAX_SOURCES +
     DEFAULT_TXDOT_MAX_SOURCES +
     DEFAULT_TALLINN_MAX_SOURCES +
     DEFAULT_TARKTEE_MAX_SOURCES +
     DEFAULT_NSW_MAX_SOURCES +
     DEFAULT_CATALONIA_MAX_SOURCES +
     1;
+  // The reserved Québec and World packs sit above the shared floor, so the
+  // shared packs must fit the floor itself, not the whole default cap.
   assert.ok(
-    packs <= DEFAULT_CCTV_MAX_SOURCES,
-    `default packs (${packs}) would be thinned by the catalog cap (${DEFAULT_CCTV_MAX_SOURCES})`,
+    packs <= CCTV_SHARED_SOURCE_SLOTS,
+    `default packs (${packs}) would be thinned by the shared slots (${CCTV_SHARED_SOURCE_SLOTS})`,
   );
   assert.ok(
     DEFAULT_CCTV_MAX_SOURCES <= CCTV_MAX_SOURCES_CEILING,

src/data/cctvHk.test.mjs

@@ -10,7 +10,7 @@ import {
   parseHkCameraLocationsXml,
 } from '../../server/providers/cctv/sources.js';
 import {
-  DEFAULT_CCTV_MAX_SOURCES,
+  CCTV_SHARED_SOURCE_SLOTS,
   DEFAULT_HK_CAMERAS_URL,
   DEFAULT_HK_MAX_SOURCES,
   HK_ANCHORS,
@@ -396,8 +396,8 @@ test('CCTV_HK_ENABLED=0 keeps the lane from being loaded at all', async (t) => {
   }
 });
 
-test('the shipped catalog ceiling is not raised to make room for this pack', () => {
-  assert.equal(DEFAULT_CCTV_MAX_SOURCES, 4000);
+test('the shared catalog slots are not raised to make room for this pack', () => {
+  assert.equal(CCTV_SHARED_SOURCE_SLOTS, 4000);
 });
 
 test('the HK pack default sits above the full TD catalog and anchors the New Territories', () => {
@@ -406,7 +406,7 @@ test('the HK pack default sits above the full TD catalog and anchors the New Ter
     'default cap should keep nearly all published TD cameras',
   );
   assert.ok(
-    DEFAULT_HK_MAX_SOURCES <= DEFAULT_CCTV_MAX_SOURCES,
+    DEFAULT_HK_MAX_SOURCES <= CCTV_SHARED_SOURCE_SLOTS,
     'a single pack must not outgrow the catalog-wide ceiling alone',
   );
   const places = HK_ANCHORS.map(

src/data/cctvHlsStream.test.mjs

@@ -10,6 +10,77 @@ const playlist =
   '#EXTM3U\n#EXT-X-MEDIA-SEQUENCE:12\n#EXTINF:2,\na.ts\n#EXTINF:2,\nb.ts\n#EXTINF:2,\nc.ts\n';
 const base = 'https://camera.example/live/list.m3u8';
 
+test('high-resolution HLS segments play while the retained session cache stays bounded', async (t) => {
+  // Giroc publishes roughly ten-second TS segments; one measured 6,437,120
+  // bytes. The former 4 MiB download cap rejected it before playback began.
+  const segmentBytes = 6_437_120;
+  const master =
+    '#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=4570000\ntracks-v1a1/mono.m3u8\n';
+  const media =
+    '#EXTM3U\n#EXT-X-MEDIA-SEQUENCE:100\n' +
+    [0, 1, 2, 3, 4].map((i) => `#EXTINF:10.272,\n${i}.ts\n`).join('');
+  const manager = createHlsPuller({
+    limits: { ...HLS_LIMITS, pollMs: 100000 },
+    fetchImpl: async (url) => {
+      if (url === base) return new Response(master);
+      if (url === 'https://camera.example/live/tracks-v1a1/mono.m3u8')
+        return new Response(media);
+      const match =
+        /^https:\/\/camera\.example\/live\/tracks-v1a1\/([0-4])\.ts$/.exec(url);
+      if (!match) throw new Error('Unexpected playlist reference');
+      // No Content-Length: the actual streamed bytes must also be accepted.
+      return new Response(Buffer.alloc(segmentBytes, Number(match[1])));
+    },
+  });
+  t.after(() => manager.shutdown());
+  const entry = await manager.ensure('giroc', base);
+  await entry.polling;
+  const result = await manager.buildPlaylist(entry, 'giroc');
+  assert.ok(result, 'large valid segments should produce a playable playlist');
+  assert.match(result, /#EXT-X-MEDIA-SEQUENCE:2\n/);
+  assert.equal(manager.getSegment('giroc', entry.token, 0), null);
+  const newest = manager.getSegment('giroc', entry.token, 4);
+  assert.equal(newest.length, segmentBytes);
+  assert.equal(newest[0], 4);
+  assert.deepEqual(manager.stats(), { sessions: 1, bytes: 19_311_360 });
+});
+
+test('HLS downloads still reject declared and chunked bodies above 8 MiB', async () => {
+  for (const declared of [true, false]) {
+    let chunks = 0;
+    let cancelled = false;
+    await assert.rejects(
+      fetchHlsBytes(base, {
+        maxBytes: HLS_LIMITS.segmentBytes,
+        fetchImpl: async () =>
+          new Response(
+            declared
+              ? 'small body'
+              : new ReadableStream({
+                  pull(controller) {
+                    // Each chunk fits on its own; only their cumulative size
+                    // crosses the cap. Leave it open to verify cancellation.
+                    controller.enqueue(
+                      Buffer.alloc(4 * 1024 * 1024 + (++chunks === 2 ? 1 : 0)),
+                    );
+                  },
+                  cancel() {
+                    cancelled = true;
+                  },
+                }),
+            {
+              headers: declared
+                ? { 'content-length': String(8 * 1024 * 1024 + 1) }
+                : {},
+            },
+          ),
+      }),
+      /HLS response too large/,
+    );
+    if (!declared) assert.equal(cancelled, true);
+  }
+});
+
 test('playlist parser uses sequence, refuses escaping and unsupported references', () => {
   assert.deepEqual(
     parseHlsMedia(playlist, base).map((s) => s.seq),

src/data/cctvHouston.test.mjs

@@ -7,7 +7,7 @@ import {
   loadHoustonSourcesFromOpenData,
 } from '../../server/providers/cctv/sources.js';
 import {
-  DEFAULT_CCTV_MAX_SOURCES,
+  CCTV_SHARED_SOURCE_SLOTS,
   DEFAULT_HOUSTON_MAX_SOURCES,
   HOUSTON_CAMERAS_URL,
   HOUSTON_GROUND_ELEVATION_M,
@@ -387,8 +387,8 @@ test('Houston stays unloaded unless CCTV_HOUSTON_ENABLED=1', async (t) => {
   }
 });
 
-test('the shipped catalog ceiling is not raised to make room for this pack', () => {
-  assert.equal(DEFAULT_CCTV_MAX_SOURCES, 4000);
+test('the shared catalog slots are not raised to make room for this pack', () => {
+  assert.equal(CCTV_SHARED_SOURCE_SLOTS, 4000);
   assert.equal(DEFAULT_HOUSTON_MAX_SOURCES, 250);
 });
 

src/data/cctvIceland.test.mjs

@@ -0,0 +1,429 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createCctvCatalog } from '../../server/providers/cctv/catalog.js';
+import {
+  DEFAULT_ICELAND_MAX_SOURCES,
+  ICELAND_CAMERAS_URL,
+  ICELAND_IMAGE_ORIGIN,
+  ICELAND_MAX_CATALOG_BYTES,
+} from '../../server/providers/cctv/constants.js';
+import { fetchWithinHost } from '../../server/providers/cctv/media.js';
+import { isLikelyIcelandCoordinate } from '../../server/providers/cctv/normalize.js';
+import {
+  icelandCameraToSource,
+  icelandHeadingFromDescription,
+  loadIcelandSourcesFromOpenData,
+} from '../../server/providers/cctv/sources.js';
+
+/** Set (or, for `undefined`, delete) environment variables for one test. */
+function withEnv(t, env) {
+  for (const [name, value] of Object.entries(env)) {
+    const previous = process.env[name];
+    t.after(() => {
+      if (previous === undefined) delete process.env[name];
+      else process.env[name] = previous;
+    });
+    if (value === undefined) delete process.env[name];
+    else process.env[name] = value;
+  }
+}
+
+/** One row shaped like the live `vefmyndavelar2014_1` payload. */
+const row = (over = {}) => ({
+  Maelist_nr: 7001,
+  Myndavel: 'Hellisheiði',
+  Vegheiti: 'Hringvegur',
+  NrVegur: '1',
+  Skyring: 'Hellisheiði séð til vesturs',
+  Slod: `${ICELAND_IMAGE_ORIGIN}hellisheidi_1.jpg`,
+  PntX: 395000,
+  PntY: 390000,
+  Breidd: 64.0136,
+  Lengd: -21.4,
+  ...over,
+});
+
+/** A live response body plus a flag that flips when the stream is cancelled. */
+const streamingResponse = (init = {}) => {
+  const state = { cancelled: false };
+  const body = new ReadableStream({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode('['));
+    },
+    cancel() {
+      state.cancelled = true;
+    },
+  });
+  return { response: new Response(body, init), state };
+};
+
+const json = (value) =>
+  new Response(JSON.stringify(value), {
+    status: 200,
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+test('an Iceland row maps to a source on the pinned frame directory', () => {
+  const source = icelandCameraToSource(row());
+  assert.equal(source.id, 'is-vegagerdin-hellisheidi_1');
+  assert.equal(source.name, 'Hellisheiði séð til vesturs');
+  assert.equal(source.city, 'Iceland');
+  assert.equal(source.cityId, 'iceland');
+  assert.equal(source.provider, 'Vegagerðin (IRCA)');
+  assert.equal(source.lat, 64.0136);
+  assert.equal(source.lon, -21.4);
+  assert.equal(source.headingDeg, 270);
+  assert.equal(source.headingConfidence, 'high');
+  assert.equal(source.pitchDeg, -24);
+  assert.equal(source.fovDeg, 56);
+  assert.equal(source.rangeM, 210);
+  assert.equal(source.mountHeightM, 10);
+  assert.equal(source.feedType, 'image');
+  assert.equal(source.sourceKind, 'iceland-vegagerdin');
+  assert.equal(source.code, 'HELLISHEIÐI');
+  assert.match(source.license, /CC BY 4\.0/);
+  assert.ok(source.url.startsWith(ICELAND_IMAGE_ORIGIN));
+  assert.equal(source.snapshotUrl, source.url);
+});
+
+test('a view that states no facing takes the low-confidence id-hash pose', () => {
+  const source = icelandCameraToSource(
+    row({
+      Skyring: 'Hellisheiði séð niður á veg',
+      Slod: `${ICELAND_IMAGE_ORIGIN}hellisheidi_2.jpg`,
+    }),
+  );
+  assert.equal(source.headingConfidence, 'low');
+  assert.equal(source.headingDeg % 22.5, 0);
+  assert.equal(
+    source.headingDeg,
+    icelandCameraToSource(
+      row({ Slod: `${ICELAND_IMAGE_ORIGIN}hellisheidi_2.jpg` }),
+    ).headingDeg,
+    'the fallback depends on the id, not on the text',
+  );
+});
+
+test('the label collapses the feed’s doubled spaces and repeated words', () => {
+  assert.equal(
+    icelandCameraToSource(
+      row({ Skyring: 'Strandarheiði séð niður á veg til  til austurs' }),
+    ).name,
+    'Strandarheiði séð niður á veg til austurs',
+  );
+  const label = (Skyring) => icelandCameraToSource(row({ Skyring })).name;
+  // Repeats of words with Icelandic letters collapse too.
+  assert.equal(
+    label('Hellisheiði séð séð til austurs'),
+    'Hellisheiði séð til austurs',
+  );
+  assert.equal(label('Brú á á Jökulsá'), 'Brú á Jökulsá');
+  // A word ending in a letter the next word starts with is not a repeat.
+  for (const text of [
+    'Þverá Árnessýslu',
+    'brú Úlfarsá',
+    'Vesturlandsvegur við Elliðaá Ártúnsbrekku',
+  ])
+    assert.equal(label(text), text);
+});
+
+test('a row with no label, station or station number is named by its frame', () => {
+  const source = icelandCameraToSource(
+    row({ Skyring: '', Myndavel: '', Maelist_nr: undefined }),
+  );
+  assert.equal(source.name, 'Vegagerðin hellisheidi_1');
+});
+
+test('only an explicit facing sets a heading', () => {
+  const cases = [
+    ['Hellisheiði séð til vesturs', 270],
+    ['Holtavörðuheiði til norðurs', 0],
+    ['Klettsháls í suður', 180],
+    ['Arnarneshæð séð austur', 90],
+    ['Bústaðabrú séð norður Kringlumýrarbraut', 0],
+    ['Staður séð til norðausturs', 45],
+    ['Staður séð til suðausturs', 135],
+    ['Staður séð í suðvestur', 225],
+    ['Staður séð til norðvesturs', 315],
+    ['STAÐUR SÉÐ TIL VESTURS', 270],
+    ['Brú séð til austurs og Selfoss', 90], // "og" then a place, not a facing
+    ['Staður séð til austurs og Vesturlandsvegur', 90],
+  ];
+  for (const [text, heading] of cases) {
+    assert.equal(icelandHeadingFromDescription(text), heading, text);
+  }
+  for (const text of [
+    '',
+    null,
+    'Gautsdalur niður á veg',
+    'Miklabraut austur', // a road direction, not a facing
+    'Biskupsháls - norður',
+    'Hringtorg norðan Selfoss',
+    'Norðurárdalur niður á veg', // a place name that contains a cardinal
+    'Staður séð til suðurlands', // a longer word, not "suður"
+    'Staður séð til norðurs og til suðurs', // two facings: ambiguous
+    'Staður séð til austurs og vesturs', // the second facing shares "til"
+    'Staður séð í norður og suður',
+    'Staður séð í norður og í suður',
+    'Norðfjarðargöng séð til Eskifjarðar',
+  ]) {
+    assert.ok(Number.isNaN(icelandHeadingFromDescription(text)), String(text));
+  }
+});
+
+test('rows off the pinned directory, or with unusable frames or places, are dropped', () => {
+  const bad = [
+    { Slod: 'https://example.com/vgdata/vefmyndavelar/a_1.jpg' },
+    { Slod: 'http://www.vegagerdin.is/vgdata/vefmyndavelar/a_1.jpg' },
+    { Slod: 'https://user:[email protected]/vgdata/vefmyndavelar/a_1.jpg' },
+    { Slod: 'https://www.vegagerdin.is:8443/vgdata/vefmyndavelar/a_1.jpg' },
+    { Slod: 'https://www.vegagerdin.is/vgdata/other/a_1.jpg' },
+    { Slod: 'https://www.vegagerdin.is/vgdata/vefmyndavelar/../x/a_1.jpg' },
+    { Slod: 'https://www.vegagerdin.is/vgdata/vefmyndavelar/a%2Fb_1.jpg' },
+    { Slod: 'https://www.vegagerdin.is/vgdata/vefmyndavelar/a_1.php' },
+    { Slod: 'https://www.vegagerdin.is/vgdata/vefmyndavelar/a_1' },
+    { Slod: 'https://www.vegagerdin.is/vgdata/vefmyndavelar/' },
+    { Slod: 'https://www.vegagerdin.is/vgdata/vefmyndavelar/a b_1.jpg' },
+    { Slod: '' },
+    { Slod: null },
+    { Breidd: 0, Lengd: 0 },
+    { Breidd: null, Lengd: null },
+    { Breidd: '64.01', Lengd: '-21.4' },
+    { Breidd: '64.01' }, // each coordinate must be a number on its own
+    { Lengd: '-21.4' },
+    { Breidd: 59.9, Lengd: 10.7 }, // Oslo
+    { Breidd: 64.01, Lengd: 21.4 }, // wrong hemisphere
+  ];
+  for (const over of bad) {
+    assert.equal(icelandCameraToSource(row(over)), null, JSON.stringify(over));
+  }
+  assert.equal(icelandCameraToSource(null), null);
+  assert.equal(icelandCameraToSource({}), null);
+  assert.equal(isLikelyIcelandCoordinate(64.1466, -21.9426), true);
+  assert.equal(isLikelyIcelandCoordinate(66.3, -14.0), true);
+});
+
+test('the Iceland loader reads the list with redirects refused and keeps the nearest cameras', async (t) => {
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(console, 'warn', () => {});
+  withEnv(t, { CCTV_ICELAND_MAX_SOURCES: '8' });
+  const rows = Array.from({ length: 12 }, (_, i) =>
+    row({
+      Maelist_nr: 8000 + i,
+      Slod: `${ICELAND_IMAGE_ORIGIN}far_${i}.jpg`,
+      Skyring: `Far ${i}`,
+      Breidd: 66.2,
+      Lengd: -15.9 + i * 0.01,
+    }),
+  );
+  // Reykjavík cameras come last in the feed but first in the priority order.
+  // A frame the feed repeats keeps its last row, as the other packs do.
+  rows.push(row({ Slod: `${ICELAND_IMAGE_ORIGIN}rvk_1.jpg`, Skyring: 'Old' }));
+  rows.push(
+    row({
+      Slod: `${ICELAND_IMAGE_ORIGIN}rvk_1.jpg`,
+      Skyring: 'Kringlumýrarbraut',
+      Breidd: 64.1466,
+      Lengd: -21.9426,
+    }),
+  );
+  const seen = [];
+  t.mock.method(globalThis, 'fetch', async (url, init) => {
+    seen.push([String(url), init.redirect]);
+    return json(rows);
+  });
+  const sources = await loadIcelandSourcesFromOpenData();
+  assert.deepEqual(seen, [[ICELAND_CAMERAS_URL, 'manual']]);
+  assert.equal(sources.length, 8);
+  assert.equal(sources[0].id, 'is-vegagerdin-rvk_1');
+  assert.equal(sources[0].name, 'Kringlumýrarbraut');
+  assert.equal(sources[0].lat, 64.1466);
+  assert.equal(
+    new Set(sources.map((s) => s.id)).size,
+    sources.length,
+    'a frame the feed repeats collapses to one camera',
+  );
+  assert.equal(sources.available, 13);
+});
+
+test('the default Iceland cap is DEFAULT_ICELAND_MAX_SOURCES', async (t) => {
+  t.mock.method(console, 'log', () => {});
+  withEnv(t, { CCTV_ICELAND_MAX_SOURCES: undefined });
+  const rows = Array.from(
+    { length: DEFAULT_ICELAND_MAX_SOURCES + 40 },
+    (_, i) => row({ Slod: `${ICELAND_IMAGE_ORIGIN}cam_${i}.jpg` }),
+  );
+  t.mock.method(globalThis, 'fetch', async () => json(rows));
+  assert.equal(
+    (await loadIcelandSourcesFromOpenData()).length,
+    DEFAULT_ICELAND_MAX_SOURCES,
+  );
+});
+
+test('CCTV_ICELAND_MAX_SOURCES is clamped to 8..600 and ignored when not a number', async (t) => {
+  t.mock.method(console, 'log', () => {});
+  withEnv(t, { CCTV_ICELAND_MAX_SOURCES: undefined });
+  const rows = Array.from({ length: 650 }, (_, i) =>
+    row({ Slod: `${ICELAND_IMAGE_ORIGIN}cam_${i}.jpg` }),
+  );
+  t.mock.method(globalThis, 'fetch', async () => json(rows));
+  for (const [value, expected] of [
+    ['0', 8],
+    ['3', 8],
+    ['1000', 600],
+    ['abc', DEFAULT_ICELAND_MAX_SOURCES],
+  ]) {
+    process.env.CCTV_ICELAND_MAX_SOURCES = value;
+    assert.equal(
+      (await loadIcelandSourcesFromOpenData()).length,
+      expected,
+      value,
+    );
+  }
+});
+
+test('a redirect on the Iceland frame host stays inside vefmyndavelar/', async () => {
+  const frame = `${ICELAND_IMAGE_ORIGIN}hellisheidi_1.jpg`;
+  const redirectTo = (location) => async (url) =>
+    url === frame
+      ? new Response(null, { status: 302, headers: { location } })
+      : new Response('frame', { headers: { 'content-type': 'image/jpeg' } });
+  for (const location of [
+    '/vgdata/other/x.jpg',
+    '/vgdata/vefmyndavelar/../x.jpg',
+    '/',
+  ])
+    assert.equal(
+      await fetchWithinHost(frame, {}, redirectTo(location)),
+      null,
+      location,
+    );
+  const followed = await fetchWithinHost(
+    frame,
+    {},
+    redirectTo('/vgdata/vefmyndavelar/hellisheidi_1b.jpg'),
+  );
+  assert.equal(await followed.text(), 'frame');
+});
+
+test('the Iceland loader fails soft on HTTP errors, bad payloads and network errors', async (t) => {
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(console, 'warn', () => {});
+  t.mock.method(
+    globalThis,
+    'fetch',
+    async () => new Response('x', { status: 503 }),
+  );
+  assert.deepEqual(await loadIcelandSourcesFromOpenData(), []);
+  t.mock.restoreAll();
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(console, 'warn', () => {});
+  t.mock.method(globalThis, 'fetch', async () => json({ rows: [] }));
+  assert.deepEqual(await loadIcelandSourcesFromOpenData(), []);
+  t.mock.method(
+    globalThis,
+    'fetch',
+    async () => new Response('<html>', { status: 200 }),
+  );
+  assert.deepEqual(await loadIcelandSourcesFromOpenData(), []);
+  t.mock.method(globalThis, 'fetch', async () => {
+    throw new Error('network down');
+  });
+  assert.deepEqual(await loadIcelandSourcesFromOpenData(), []);
+});
+
+test('the Iceland catalog fetch refuses redirects and oversized bodies', async (t) => {
+  t.mock.method(console, 'warn', () => {});
+  const redirected = streamingResponse({
+    status: 302,
+    headers: {
+      location: 'http://gagnaveita.vegagerdin.is/api/vefmyndavelar2014_1',
+    },
+  });
+  t.mock.method(globalThis, 'fetch', async () => redirected.response);
+  assert.deepEqual(await loadIcelandSourcesFromOpenData(), []);
+  assert.equal(
+    redirected.state.cancelled,
+    true,
+    'the redirect body is cancelled',
+  );
+
+  t.mock.restoreAll();
+  t.mock.method(console, 'warn', () => {});
+  const failed = streamingResponse({ status: 500 });
+  t.mock.method(globalThis, 'fetch', async () => failed.response);
+  assert.deepEqual(await loadIcelandSourcesFromOpenData(), []);
+  assert.equal(failed.state.cancelled, true, 'the error body is cancelled');
+
+  const valid = JSON.stringify([row()]);
+  t.mock.restoreAll();
+  t.mock.method(console, 'warn', () => {});
+  t.mock.method(globalThis, 'fetch', async () => {
+    return new Response(valid, {
+      headers: { 'content-length': String(ICELAND_MAX_CATALOG_BYTES + 1) },
+    });
+  });
+  assert.deepEqual(await loadIcelandSourcesFromOpenData(), []);
+
+  t.mock.restoreAll();
+  t.mock.method(console, 'warn', () => {});
+  t.mock.method(globalThis, 'fetch', async () => {
+    const padded = valid + ' '.repeat(ICELAND_MAX_CATALOG_BYTES + 1024);
+    return new Response(
+      new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode(padded));
+          controller.close();
+        },
+      }),
+    );
+  });
+  assert.deepEqual(await loadIcelandSourcesFromOpenData(), []);
+});
+
+test('CCTV catalog merges Iceland cameras and CCTV_ICELAND_ENABLED=0 skips the request', async (t) => {
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(console, 'warn', () => {});
+  const sourceRoot = fs.mkdtempSync(
+    path.join(os.tmpdir(), 'gev-cctv-catalog-iceland-'),
+  );
+  t.after(() => fs.rmSync(sourceRoot, { recursive: true, force: true }));
+  withEnv(t, {
+    CCTV_SOURCES_FILE: undefined,
+    CCTV_SOURCES_JSON: undefined,
+    CCTV_FORCE_AUSTIN: undefined,
+    CCTV_PREFER_AUSTIN: undefined,
+    CCTV_MAX_SOURCES: undefined,
+    CCTV_CALTRANS_DISTRICTS: undefined,
+    CCTV_TFL_ENABLED: undefined,
+    CCTV_ICELAND_ENABLED: undefined,
+    CCTV_ICELAND_MAX_SOURCES: undefined,
+  });
+  const requested = [];
+  t.mock.method(globalThis, 'fetch', async (url, init) => {
+    requested.push([String(url), init.redirect]);
+    if (String(url) !== ICELAND_CAMERAS_URL) {
+      return new Response('unavailable', { status: 503 });
+    }
+    return json([row()]);
+  });
+
+  const sources = await createCctvCatalog({ sourceRoot })();
+  assert.deepEqual(
+    sources.map((source) => source.id),
+    ['is-vegagerdin-hellisheidi_1'],
+  );
+
+  process.env.CCTV_ICELAND_ENABLED = '0';
+  requested.length = 0;
+  assert.deepEqual(await createCctvCatalog({ sourceRoot })(), []);
+  assert.ok(requested.length > 0, 'the other live packs still load');
+  assert.equal(
+    requested.some(([url]) => url === ICELAND_CAMERAS_URL),
+    false,
+    'a disabled pack makes no request',
+  );
+});

src/data/cctvNyc.test.mjs

@@ -8,7 +8,7 @@ import {
   nycCameraToSource,
 } from '../../server/providers/cctv/sources.js';
 import {
-  DEFAULT_CCTV_MAX_SOURCES,
+  CCTV_SHARED_SOURCE_SLOTS,
   DEFAULT_NYC_MAX_SOURCES,
   NYC_CAMERAS_URL,
   NYC_GROUND_ELEVATION_M,
@@ -375,8 +375,8 @@ for (const [label, flag] of [
   });
 }
 
-test('the shipped catalog ceiling is not raised to make room for this pack', () => {
-  assert.equal(DEFAULT_CCTV_MAX_SOURCES, 4000);
+test('the shared catalog slots are not raised to make room for this pack', () => {
+  assert.equal(CCTV_SHARED_SOURCE_SLOTS, 4000);
   assert.equal(DEFAULT_NYC_MAX_SOURCES, 250);
 });
 

src/data/cctvOttawa.test.mjs

@@ -0,0 +1,255 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createCctvCatalog } from '../../server/providers/cctv/catalog.js';
+import {
+  OTTAWA_CAMERAS_URL,
+  OTTAWA_IMAGE_ORIGIN,
+} from '../../server/providers/cctv/constants.js';
+import {
+  fallbackHeadingFromId,
+  pinnedCameraUrl,
+} from '../../server/providers/cctv/normalize.js';
+import {
+  _resetOttawaCertificateWarningForTest,
+  loadOttawaSourcesFromOpenData,
+  ottawaAuthorizedFrameUrl,
+} from '../../server/providers/cctv/ottawa.js';
+
+const CERT = { OTTAWA_CAMERA_CERTIFICATE: 'CERT123' };
+
+/** Set (or, for `undefined`, delete) environment variables for one test. */
+function withEnv(t, env) {
+  for (const [name, value] of Object.entries(env)) {
+    const previous = process.env[name];
+    t.after(() => {
+      if (previous === undefined) delete process.env[name];
+      else process.env[name] = previous;
+    });
+    if (value === undefined) delete process.env[name];
+    else process.env[name] = value;
+  }
+}
+
+/** Silence the loader's progress and failure logging. */
+function quiet(t) {
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(console, 'warn', () => {});
+}
+
+/** One documented `/map/service/camera` row carrying the fields the loader reads. */
+function ottawaRow(number, lat, lon, overrides = {}) {
+  return {
+    id: number + 10000,
+    camera_number: number,
+    name: `Camera ${number}`,
+    name_french: `Caméra ${number}`,
+    cameraOwner: 'CITY',
+    latitude: lat,
+    longitude: lon,
+    ...overrides,
+  };
+}
+
+/** The feed's envelope around its rows. */
+const ottawaPayload = (rows) => Response.json({ cameras: rows });
+
+test('without OTTAWA_CAMERA_CERTIFICATE the Ottawa pack is skipped with no request, logged once', async (t) => {
+  _resetOttawaCertificateWarningForTest();
+  const lines = [];
+  t.mock.method(console, 'warn', (line) => lines.push(String(line)));
+  const fetchMock = t.mock.method(globalThis, 'fetch', async () => {
+    throw new Error('no request expected');
+  });
+  assert.deepEqual(await loadOttawaSourcesFromOpenData({}, {}), []);
+  assert.deepEqual(
+    await loadOttawaSourcesFromOpenData({}, { OTTAWA_CAMERA_CERTIFICATE: '  ' }),
+    [],
+  );
+  assert.equal(fetchMock.mock.callCount(), 0);
+  assert.equal(lines.length, 1);
+  assert.match(lines[0], /OTTAWA_CAMERA_CERTIFICATE/);
+});
+
+test('Ottawa frame URLs are signed only inside the opendata camera path', () => {
+  assert.equal(
+    ottawaAuthorizedFrameUrl('https://traffic.ottawa.ca/opendata/camera?c=16', CERT),
+    'https://traffic.ottawa.ca/opendata/camera?c=16&certificate=CERT123&id=gev',
+  );
+  assert.equal(
+    ottawaAuthorizedFrameUrl('https://traffic.ottawa.ca/opendata/camera?c=16', {}),
+    '',
+    'no certificate, no signed URL',
+  );
+  for (const url of [
+    'https://traffic.ottawa.ca/opendata/camera?c=16x',
+    'https://traffic.ottawa.ca/opendata/other?c=16',
+    'https://traffic.ottawa.ca/map/camera?id=16',
+    'https://traffic.ottawa.ca.evil.test/opendata/camera?c=16',
+    'http://traffic.ottawa.ca/opendata/camera?c=16',
+  ])
+    assert.equal(ottawaAuthorizedFrameUrl(url, CERT), '', url);
+});
+
+test('Ottawa loader keeps in-city cameras and builds keyless frame URLs from the camera number', async (t) => {
+  quiet(t);
+  withEnv(t, { CCTV_OTTAWA_MAX_SOURCES: undefined });
+  const requested = [];
+  t.mock.method(globalThis, 'fetch', async (url) => {
+    requested.push(String(url));
+    return ottawaPayload([
+      ottawaRow(2025, 45.341343, -75.81467, {
+        name: '(MTO) Hwy 416 NB ramp to Hwy 417 East',
+        cameraOwner: 'MTO',
+      }),
+      ottawaRow(1, 45.4215, -75.6972, {
+        name: 'Bank St at Somerset St',
+        camera_owner: 'CITY',
+        cameraOwner: undefined,
+      }),
+      ottawaRow(1, 45.4216, -75.6973, { name: 'duplicate number' }),
+      ottawaRow(0, 45.4215, -75.6972),
+      ottawaRow(-3, 45.4215, -75.6972),
+      ottawaRow(7, null, -75.7),
+      ottawaRow(8, 45.4, null),
+      ottawaRow(9, 43.6532, -79.3832, { description: 'Toronto' }),
+      ottawaRow(10, 45.9, -75.7),
+    ]);
+  });
+
+  const cameras = await loadOttawaSourcesFromOpenData({}, CERT);
+
+  assert.deepEqual(requested, [OTTAWA_CAMERAS_URL]);
+  assert.deepEqual(cameras.map((camera) => camera.id).sort(), [
+    'ottawa-1',
+    'ottawa-2025',
+  ]);
+
+  const mto = cameras.find((camera) => camera.id === 'ottawa-2025');
+  const city = cameras.find((camera) => camera.id === 'ottawa-1');
+  assert.equal(mto.url, 'https://traffic.ottawa.ca/opendata/camera?c=2025');
+  assert.doesNotMatch(mto.url, /certificate/, 'the catalog URL carries no key');
+  assert.equal(mto.snapshotUrl, mto.url);
+  assert.equal(mto.frameRefreshMs, 60000, 'the API allows one fetch a minute');
+  assert.equal(city.name, 'Bank St at Somerset St');
+  assert.equal(mto.name, '(MTO) Hwy 416 NB ramp to Hwy 417 East');
+  assert.equal(mto.city, 'Ottawa');
+  assert.equal(mto.provider, 'City of Ottawa');
+  assert.equal(mto.feedType, 'image');
+  assert.equal(mto.sourceKind, 'ottawa-traffic');
+  assert.equal(mto.headingConfidence, 'low');
+  assert.equal(
+    mto.headingDeg,
+    fallbackHeadingFromId('ottawa-2025'),
+    'the feed publishes no bearing, so the id-hash fallback is deterministic',
+  );
+  assert.match(mto.license, /City of Ottawa/);
+  assert.equal(
+    mto.credit,
+    'Ministry of Transportation of Ontario (MTO) camera',
+    'a provincial camera carried on the city feed names its owner',
+  );
+  assert.equal(city.credit, '', 'a city camera carries no partner credit');
+});
+
+test('Ottawa loader keeps the cameras nearest downtown under its cap', async (t) => {
+  quiet(t);
+  withEnv(t, { CCTV_OTTAWA_MAX_SOURCES: '8' });
+  const rows = [
+    // Far suburbs come first in payload order, so only distance can drop them.
+    ...[45.55, 45.54, 45.53, 45.52].map((lat, i) =>
+      ottawaRow(100 + i, lat, -76.1),
+    ),
+    ...[45.42, 45.421, 45.422, 45.423, 45.424, 45.425, 45.426, 45.427].map(
+      (lat, i) => ottawaRow(200 + i, lat, -75.7),
+    ),
+  ];
+  t.mock.method(globalThis, 'fetch', async () => ottawaPayload(rows));
+
+  const cameras = await loadOttawaSourcesFromOpenData({}, CERT);
+
+  assert.equal(cameras.length, 8);
+  assert.deepEqual(
+    cameras.map((camera) => camera.id).filter((id) => /^ottawa-10\d$/.test(id)),
+    [],
+    'the far-suburb cameras are the ones dropped',
+  );
+});
+
+test('Ottawa loader fails soft on HTTP errors, unexpected payloads and network errors', async (t) => {
+  quiet(t);
+  let respond;
+  t.mock.method(globalThis, 'fetch', (...args) => respond(...args));
+  for (respond of [
+    async () => new Response('unavailable', { status: 503 }),
+    async () => Response.json({ cameras: [] }),
+    async () => Response.json([ottawaRow(1, 45.4215, -75.6972)]),
+    async () => {
+      throw new TypeError('fetch failed');
+    },
+  ]) {
+    assert.deepEqual(await loadOttawaSourcesFromOpenData({}, CERT), []);
+  }
+});
+
+test('CCTV catalog merges Ottawa cameras with a certificate and CCTV_OTTAWA_ENABLED=0 skips the request', async (t) => {
+  quiet(t);
+  const sourceRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gev-cctv-ottawa-'));
+  t.after(() => fs.rmSync(sourceRoot, { recursive: true, force: true }));
+  withEnv(t, {
+    CCTV_SOURCES_FILE: undefined,
+    CCTV_SOURCES_JSON: undefined,
+    CCTV_FORCE_AUSTIN: undefined,
+    CCTV_PREFER_AUSTIN: undefined,
+    CCTV_MAX_SOURCES: undefined,
+    CCTV_OTTAWA_ENABLED: undefined,
+    CCTV_OTTAWA_MAX_SOURCES: undefined,
+    CCTV_QUEBEC_ENABLED: '0',
+    CCTV_WORLD_CAMERAS_ENABLED: '0',
+    OTTAWA_CAMERA_CERTIFICATE: 'CERT123',
+  });
+  const requested = [];
+  t.mock.method(globalThis, 'fetch', async (url) => {
+    requested.push(String(url));
+    // Every other live pack is down; only Ottawa answers.
+    return String(url) === OTTAWA_CAMERAS_URL
+      ? ottawaPayload([ottawaRow(1, 45.4215, -75.6972)])
+      : new Response('unavailable', { status: 503 });
+  });
+
+  const sources = await createCctvCatalog({ sourceRoot })();
+  assert.deepEqual(
+    sources.map((source) => source.id),
+    ['ottawa-1'],
+  );
+  assert.equal(sources[0].url, 'https://traffic.ottawa.ca/opendata/camera?c=1');
+
+  process.env.CCTV_OTTAWA_ENABLED = '0';
+  requested.length = 0;
+  assert.deepEqual(await createCctvCatalog({ sourceRoot })(), []);
+  assert.ok(requested.length > 0, 'the other live packs still load');
+  assert.equal(
+    requested.includes(OTTAWA_CAMERAS_URL),
+    false,
+    'a disabled pack makes no request',
+  );
+});
+
+test('Ottawa frames stay inside the city image directory', () => {
+  assert.ok(
+    pinnedCameraUrl(
+      'https://traffic.ottawa.ca/opendata/camera?c=309',
+      OTTAWA_IMAGE_ORIGIN,
+    ),
+  );
+  for (const url of [
+    'https://traffic.ottawa.ca.evil.test/opendata/camera?c=309',
+    'https://traffic.ottawa.ca/map/camera?id=309',
+    'https://user:[email protected]/opendata/camera?c=309',
+    'https://traffic.ottawa.ca:8443/opendata/camera?c=309',
+    'http://traffic.ottawa.ca/opendata/camera?c=309',
+  ])
+    assert.equal(pinnedCameraUrl(url, OTTAWA_IMAGE_ORIGIN), null, url);
+});

src/data/cctvProxy.test.mjs

@@ -313,3 +313,234 @@ test('CCTV upstream frame fetch accepts only raster image types and sends their
     assert.equal(state.cancelled, true, `${contentType}: body cancelled`);
   }
 });
+
+function multipartResponse(contentType, chunks, { onCancel = () => {} } = {}) {
+  let nextChunk = 0;
+  const body = new ReadableStream(
+    {
+      pull(controller) {
+        if (nextChunk >= chunks.length) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(chunks[nextChunk++]);
+      },
+      cancel() {
+        onCancel();
+      },
+    },
+    { highWaterMark: 0 },
+  );
+  return new Response(body, {
+    status: 200,
+    headers: { 'Content-Type': contentType },
+  });
+}
+
+function jpegPart(boundary, body, contentType = 'image/jpeg', length = body.length) {
+  return Buffer.concat([
+    Buffer.from(
+      '--' +
+        boundary +
+        '\r\nContent-Type: ' +
+        contentType +
+        '\r\nContent-Length: ' +
+        length +
+        '\r\n\r\n',
+    ),
+    body,
+    Buffer.from('\r\n'),
+  ]);
+}
+
+test('CCTV upstream frame fetch extracts only the first JPEG from MJPEG', async () => {
+  const boundary = 'DIGIEVER';
+  const first = Buffer.from([0xff, 0xd8, 0x11, 0x22, 0xff, 0xd9]);
+  const second = Buffer.from([0xff, 0xd8, 0x33, 0x44, 0xff, 0xd9]);
+  for (const type of [
+    'multipart/x-mixed-replace; boundary=DIGIEVER',
+    'multipart/x-mixed-replace; boundary="DIGIEVER"',
+  ]) {
+    let cancelled = false;
+    const result = await fetchCctvImageFromUpstream(
+      'https://cctv-ss02.thb.gov.tw/T62-9K+020',
+      {
+        allowMjpeg: true,
+        maxBytes: 1024,
+        fetchImpl: async () =>
+          multipartResponse(
+            type,
+            [
+              jpegPart(boundary, first),
+              jpegPart(boundary, second),
+              Buffer.from('--' + boundary + '--\r\n'),
+            ],
+            { onCancel: () => { cancelled = true; } },
+          ),
+      },
+    );
+    assert.equal(result?.contentType, 'image/jpeg', type);
+    assert.deepEqual(result?.body, first, type);
+    assert.equal(cancelled, true, type);
+  }
+});
+
+test('CCTV upstream frame fetch rejects malformed and non-JPEG MJPEG parts', async () => {
+  const jpeg = Buffer.from([0xff, 0xd8, 0x01, 0x02, 0xff, 0xd9]);
+  for (const [type, chunks] of [
+    ['multipart/x-mixed-replace', []],
+    [
+      'multipart/x-mixed-replace; boundary=DIGIEVER',
+      [jpegPart('DIGIEVER', jpeg, 'image/png')],
+    ],
+  ]) {
+    let cancelled = false;
+    const result = await fetchCctvImageFromUpstream(
+      'https://cctv-ss02.thb.gov.tw/T62-9K+020',
+      {
+        allowMjpeg: true,
+        fetchImpl: async () =>
+          multipartResponse(type, chunks, { onCancel: () => { cancelled = true; } }),
+      },
+    );
+    assert.equal(result, null, type);
+    assert.equal(cancelled, true, type);
+  }
+});
+
+test('CCTV upstream frame fetch rejects truncated or oversized MJPEG parts', async () => {
+  const boundary = 'DIGIEVER';
+  const full = Buffer.from([0xff, 0xd8, 0x01, 0x02, 0xff, 0xd9]);
+  const truncated = Buffer.from([0xff, 0xd8, 0x01, 0x02]);
+  for (const [chunks, maxBytes] of [
+    [jpegPart(boundary, truncated, 'image/jpeg', full.length), 1024],
+    [jpegPart(boundary, full), 5],
+  ]) {
+    let cancelled = false;
+    const result = await fetchCctvImageFromUpstream(
+      'https://cctv-ss02.thb.gov.tw/T62-9K+020',
+      {
+        allowMjpeg: true,
+        maxBytes,
+        fetchImpl: async () =>
+          multipartResponse(
+            'multipart/x-mixed-replace; boundary=' + boundary,
+            [chunks],
+            { onCancel: () => { cancelled = true; } },
+          ),
+      },
+    );
+    assert.equal(result, null);
+    assert.equal(cancelled, true);
+  }
+});
+
+test('CCTV upstream frame fetch does not cross into a later part when the first JPEG is truncated', async () => {
+  const boundary = 'DIGIEVER';
+  const truncated = Buffer.from([0xff, 0xd8, 0x01, 0x02]);
+  const valid = Buffer.from([0xff, 0xd8, 0x03, 0x04, 0xff, 0xd9]);
+  const wire = Buffer.concat([
+    Buffer.from(
+      '--' + boundary + '\r\nContent-Type: image/jpeg\r\n\r\n',
+    ),
+    truncated,
+    Buffer.from(
+      '\r\n--' +
+        boundary +
+        '\r\nContent-Type: image/jpeg\r\nContent-Length: ' +
+        valid.length +
+        '\r\n\r\n',
+    ),
+    valid,
+    Buffer.from('\r\n--' + boundary + '--\r\n'),
+  ]);
+  let cancelled = false;
+
+  const result = await fetchCctvImageFromUpstream(
+    'https://cctv-ss02.thb.gov.tw/T62-9K+020',
+    {
+      allowMjpeg: true,
+      maxBytes: 1024,
+      fetchImpl: async () =>
+        multipartResponse(
+          'multipart/x-mixed-replace; boundary=' + boundary,
+          [wire],
+          { onCancel: () => { cancelled = true; } },
+        ),
+    },
+  );
+
+  assert.equal(result, null);
+  assert.equal(cancelled, true);
+});
+test('CCTV upstream frame fetch ignores MJPEG unless the source is registered as MJPEG', async () => {
+  const boundary = 'DIGIEVER';
+  const jpeg = Buffer.from([0xff, 0xd8, 0x11, 0x22, 0xff, 0xd9]);
+  let cancelled = false;
+  const result = await fetchCctvImageFromUpstream(
+    'https://cctv-ss02.thb.gov.tw/T62-9K+020',
+    {
+      fetchImpl: async () =>
+        multipartResponse(
+          'multipart/x-mixed-replace; boundary=' + boundary,
+          [jpegPart(boundary, jpeg)],
+          { onCancel: () => { cancelled = true; } },
+        ),
+    },
+  );
+  assert.equal(result, null);
+  assert.equal(cancelled, true);
+});
+
+test('CCTV upstream frame fetch accepts a CRLF preamble and a boundary that already starts with --', async () => {
+  const jpeg = Buffer.from([0xff, 0xd8, 0x11, 0x22, 0xff, 0xd9]);
+  for (const [type, wire] of [
+    [
+      'multipart/x-mixed-replace; boundary=DIGIEVER',
+      Buffer.concat([Buffer.from('\r\n'), jpegPart('DIGIEVER', jpeg)]),
+    ],
+    [
+      'multipart/x-mixed-replace; boundary=--myboundary',
+      Buffer.concat([
+        Buffer.from(
+          '--myboundary\r\nContent-Type: image/jpeg\r\nContent-Length: ' +
+            jpeg.length +
+            '\r\n\r\n',
+        ),
+        jpeg,
+        Buffer.from('\r\n--myboundary\r\n'),
+      ]),
+    ],
+  ]) {
+    const result = await fetchCctvImageFromUpstream(
+      'https://cctv-ss02.thb.gov.tw/T62-9K+020',
+      {
+        allowMjpeg: true,
+        fetchImpl: async () => multipartResponse(type, [wire]),
+      },
+    );
+    assert.deepEqual(result?.body, jpeg, type);
+  }
+});
+
+test('CCTV MJPEG part without Content-Length ends at the next delimiter, not at an inner JPEG end marker', async () => {
+  const boundary = 'DIGIEVER';
+  // An EXIF thumbnail's own FF D9 sits inside the image.
+  const jpeg = Buffer.from([0xff, 0xd8, 0x01, 0xff, 0xd9, 0x02, 0x03, 0xff, 0xd9]);
+  const wire = Buffer.concat([
+    Buffer.from('--' + boundary + '\r\nContent-Type: image/jpeg\r\n\r\n'),
+    jpeg,
+    Buffer.from('\r\n--' + boundary + '\r\nContent-Type: image/jpeg\r\n\r\n'),
+  ]);
+  // Delivered one byte at a time, as a trickling upstream would.
+  const chunks = [...wire].map((byte) => Buffer.from([byte]));
+  const result = await fetchCctvImageFromUpstream(
+    'https://cctv-ss02.thb.gov.tw/T62-9K+020',
+    {
+      allowMjpeg: true,
+      fetchImpl: async () =>
+        multipartResponse('multipart/x-mixed-replace; boundary=' + boundary, chunks),
+    },
+  );
+  assert.deepEqual(result?.body, jpeg);
+});

src/data/cctvTaiwan.test.mjs

@@ -182,6 +182,86 @@ test('loader deduplicates cameras that share a camera number', async (t) => {
   ]);
 });
 
+test('falls back to Highway Bureau MJPEG cameras when the Freeway catalog fails', async (t) => {
+  const highwayUrl = 'https://cctv-maintain.thb.gov.tw/opendataCCTVs.xml';
+  const requests = [];
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(console, 'warn', () => {});
+  t.mock.method(globalThis, 'fetch', async (url, options) => {
+    const href = String(url);
+    requests.push(href);
+    assert.equal(options.redirect, 'manual');
+    if (href === TAIWAN_FREEWAY_CCTV_URL)
+      return new Response('', { status: 503 });
+    if (href === highwayUrl) {
+      return new Response(
+        cctvXml(
+          block({
+            id: 'CCTV-14-0620-009-002',
+            stream: 'https://cctv-ss02.thb.gov.tw:443/T62-9K+020',
+            lat: '24.9967',
+            lon: '121.4521',
+          }),
+        ),
+        { headers: { 'content-type': 'application/xml' } },
+      );
+    }
+    throw new Error('Unexpected Taiwan feed URL: ' + href);
+  });
+
+  const sources = await loadTaiwanSources();
+
+  assert.deepEqual(requests, [TAIWAN_FREEWAY_CCTV_URL, highwayUrl]);
+  assert.equal(sources.length, 1);
+  assert.equal(sources[0].id, 'tw-thb-cctv-14-0620-009-002');
+  assert.equal(sources[0].cityId, 'taiwan');
+  assert.equal(sources[0].provider, 'Highway Bureau, MOTC');
+  assert.equal(sources[0].feedType, 'mjpeg');
+  assert.equal(sources[0].sourceKind, 'taiwan-highway-motc');
+  assert.equal(new URL(sources[0].url).hostname, 'cctv-ss02.thb.gov.tw');
+  assert.equal(new URL(sources[0].url).pathname, '/T62-9K+020');
+});
+
+test('the Highway Bureau fallback registers only approved HTTPS camera servers', async (t) => {
+  const highwayUrl = 'https://cctv-maintain.thb.gov.tw/opendataCCTVs.xml';
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(console, 'warn', () => {});
+  t.mock.method(globalThis, 'fetch', async (url) => {
+    if (String(url) === TAIWAN_FREEWAY_CCTV_URL)
+      return new Response('', { status: 503 });
+    if (String(url) === highwayUrl) {
+      return new Response(
+        cctvXml(
+          block({
+            id: 'CCTV-14-0620-009-001',
+            stream: 'https://cctv-ss09.thb.gov.tw/T62-9K+019',
+          }),
+          block({
+            id: 'CCTV-14-0620-009-003',
+            stream: 'http://cctv-ss02.thb.gov.tw/T62-9K+021',
+          }),
+          block({
+            id: 'CCTV-14-0620-009-004',
+            stream: 'https://cctv-ss02.thb.gov.tw:8443/T62-9K+022',
+          }),
+          block({
+            id: 'CCTV-14-0620-009-002',
+            stream: 'https://cctv-ss02.thb.gov.tw:443/T62-9K+020',
+          }),
+        ),
+        { headers: { 'content-type': 'application/xml' } },
+      );
+    }
+    throw new Error('Unexpected Taiwan feed URL: ' + String(url));
+  });
+
+  const sources = await loadTaiwanSources();
+
+  assert.deepEqual(
+    sources.map((source) => source.id),
+    ['tw-thb-cctv-14-0620-009-002'],
+  );
+});
 test('a redirected or failed catalog contributes an empty pack', async (t) => {
   t.mock.method(console, 'warn', () => {});
   for (const status of [302, 503]) {
@@ -214,13 +294,17 @@ test('the Taiwan pack is in the catalog by default', async (t) => {
   );
 });
 
-test('CCTV_TAIWAN_ENABLED=0 makes no Freeway Bureau request', async (t) => {
+test('CCTV_TAIWAN_ENABLED=0 makes no Taiwan catalog request', async (t) => {
   const { requested, sources } = await runCatalogWithTaiwanFlag(t, '0');
   assert.ok(requested.length > 0, 'the other packs still refreshed');
   assert.equal(
     requested.some((href) => href.includes('freeway.gov.tw')),
     false,
   );
+  assert.equal(
+    requested.some((href) => href.includes('cctv-maintain.thb.gov.tw')),
+    false,
+  );
   assert.ok(!sources.some((c) => c.cityId === 'taiwan'));
 });
 
@@ -250,12 +334,12 @@ test('a failed download is not retried until the backoff ends', async (t) => {
   t.mock.method(Date, 'now', () => 1_000_000);
   assert.deepEqual(await loadTaiwanSources(), []);
   assert.deepEqual(await loadTaiwanSources(), []);
-  assert.equal(calls, 1, 'the second refresh made no request');
+  assert.equal(calls, 2, 'the second refresh made no request');
   Date.now.mock.mockImplementation(
     () => 1_000_000 + TAIWAN_RETRY_AFTER_FAILURE_MS + 1,
   );
   await loadTaiwanSources();
-  assert.equal(calls, 2, 'the backoff ends after an hour');
+  assert.equal(calls, 4, 'the backoff ends after an hour');
 });
 
 test('a failed download serves the last good table', async (t) => {

src/data/cctvToronto.test.mjs

@@ -10,7 +10,7 @@ import {
   TORONTO_RESCU_LIST_URL,
   TORONTO_RESCU_IMAGE_ORIGIN,
   TORONTO_MAX_CATALOG_BYTES,
-  DEFAULT_CCTV_MAX_SOURCES,
+  CCTV_SHARED_SOURCE_SLOTS,
 } from '../../server/providers/cctv/constants.js';
 import { CAMERA_CODE_MAX_CHARS } from '../../server/providers/cctv/normalize.js';
 import { allocateSourceCap } from '../../server/providers/cctv/cap.js';
@@ -418,6 +418,6 @@ test('CCTV_TORONTO_ENABLED=0 keeps the lane from being loaded at all', async (t)
   }
 });
 
-test('the shipped catalog ceiling is not raised to make room for this pack', () => {
-  assert.equal(DEFAULT_CCTV_MAX_SOURCES, 4000);
+test('the shared catalog slots are not raised to make room for this pack', () => {
+  assert.equal(CCTV_SHARED_SOURCE_SLOTS, 4000);
 });

src/data/cctvWorldQuebec.test.mjs

@@ -0,0 +1,316 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  DEFAULT_WORLD_CCTV_SOURCE_FILE,
+  WORLD_CCTV_SOURCE_COUNT,
+} from '../../server/providers/cctv/constants.js';
+import {
+  isMlitRiverAdjustmentImage,
+  loadWorldCameraSources,
+} from '../../server/providers/cctv/worldCameras.js';
+import {
+  loadQuebecSources,
+  QUEBEC_CAMERA_SOURCE_COUNT,
+  quebec511VideoUrl,
+  quebecBrowserVideoEnabled,
+} from '../../server/providers/cctv/quebec.js';
+import { cctvProxy } from '../../server/providers/cctv.js';
+
+const REPO_ROOT = path.resolve(import.meta.dirname, '../..');
+const JPEG = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0xff, 0xd9]);
+
+/** Silence the loaders' progress and failure logging. */
+function quiet(t) {
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(console, 'warn', () => {});
+}
+
+/** Set (or, for `undefined`, delete) environment variables for one test. */
+function withEnv(t, env) {
+  for (const [name, value] of Object.entries(env)) {
+    const previous = process.env[name];
+    t.after(() => {
+      if (previous === undefined) delete process.env[name];
+      else process.env[name] = previous;
+    });
+    if (value === undefined) delete process.env[name];
+    else process.env[name] = value;
+  }
+}
+
+/** A temporary source root holding the given World and Québec catalogs. */
+function sourceRoot(t, { world = [], quebec = null } = {}) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gev-cctv-world-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const worldFile = path.join(root, DEFAULT_WORLD_CCTV_SOURCE_FILE);
+  fs.mkdirSync(path.dirname(worldFile), { recursive: true });
+  fs.writeFileSync(worldFile, JSON.stringify(world));
+  if (quebec) {
+    fs.mkdirSync(path.join(root, 'public'), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, 'public/quebec-cameras.json'),
+      JSON.stringify({ cameras: quebec }),
+    );
+  }
+  return root;
+}
+
+const oregonRow = (overrides = {}) => ({
+  id: 'world-or-764',
+  name: '3rd St at Harwood MP18.35',
+  provider: 'TripCheck (ODOT)',
+  lat: 44.3029,
+  lon: -120.8549,
+  sourceKind: 'tripcheck-odot',
+  url: 'https://www.tripcheck.com/roadcams/cams/Harwood_pid3527.jpg',
+  snapshotUrl: 'https://www.tripcheck.com/roadcams/cams/Harwood_pid3527.jpg',
+  ...overrides,
+});
+
+test('the shipped World catalog loads every curated row', (t) => {
+  quiet(t);
+  const sources = loadWorldCameraSources({ sourceRoot: REPO_ROOT });
+  assert.equal(sources.length, WORLD_CCTV_SOURCE_COUNT);
+  const byKind = Object.groupBy(sources, (source) => source.sourceKind);
+  // Iceland comes from the live Iceland pack, never a second World copy.
+  assert.equal(byKind['vegagerdin-road'], undefined);
+  assert.equal(byKind['tripcheck-odot'].length, 1176);
+  assert.equal(byKind['mlit-river'].length, 1054);
+  for (const source of byKind['mlit-river'])
+    assert.equal(source.frameRefreshMs, 10 * 60 * 1000);
+});
+
+test('the World loader accepts a pinned row and rejects anything outside its policy', (t) => {
+  quiet(t);
+  const rejected = [
+    ['unknown kind', { sourceKind: 'nzta-journeys' }],
+    [
+      'Iceland duplicates the Iceland pack',
+      {
+        sourceKind: 'vegagerdin-road',
+        lat: 64.291877,
+        lon: -15.028035,
+        url: 'https://www.vegagerdin.is/vgdata/vefmyndavelar/almannaskard_1.jpg',
+        snapshotUrl: 'https://www.vegagerdin.is/vgdata/vefmyndavelar/almannaskard_1.jpg',
+      },
+    ],
+    ['wrong id prefix', { id: 'world-jp-river-7075' }],
+    ['outside bounds', { lat: 40, lon: -15 }],
+    ['other host', { url: 'https://evil.test/roadcams/cams/a.jpg' }],
+    ['other directory', { url: 'https://www.tripcheck.com/other/a.jpg' }],
+    ['query string', { url: oregonRow().url + '?x=1' }],
+    ['not a jpg', { url: 'https://www.tripcheck.com/roadcams/cams/a.png' }],
+    ['plain http', { url: oregonRow().url.replace('https:', 'http:') }],
+    [
+      'url and snapshot differ',
+      { snapshotUrl: 'https://www.tripcheck.com/roadcams/cams/b.jpg' },
+    ],
+  ];
+  const root = sourceRoot(t, {
+    world: [
+      oregonRow(),
+      oregonRow(), // duplicate id
+      ...rejected.map(([, overrides], i) =>
+        oregonRow({ id: `world-or-${9000 + i}`, ...overrides }),
+      ),
+    ],
+  });
+  const sources = loadWorldCameraSources({ sourceRoot: root });
+  assert.deepEqual(
+    sources.map((source) => source.id),
+    ['world-or-764'],
+  );
+  assert.equal(sources[0].frameRefreshMs, 5 * 60 * 1000);
+  assert.equal(sources[0].feedType, 'image');
+});
+
+test('the World loader fails soft on a missing or malformed catalog', (t) => {
+  quiet(t);
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gev-cctv-world-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  assert.deepEqual(loadWorldCameraSources({ sourceRoot: root }), []);
+  const file = path.join(root, DEFAULT_WORLD_CCTV_SOURCE_FILE);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, '{not json');
+  assert.deepEqual(loadWorldCameraSources({ sourceRoot: root }), []);
+});
+
+test('only the exact MLIT adjustment image is recognised', () => {
+  assert.equal(isMlitRiverAdjustmentImage({ ok: true, body: JPEG }), false);
+  assert.equal(isMlitRiverAdjustmentImage(null), false);
+  assert.equal(isMlitRiverAdjustmentImage({ ok: false, body: JPEG }), false);
+});
+
+test('the shipped Québec catalog loads every location', (t) => {
+  quiet(t);
+  const sources = loadQuebecSources({ sourceRoot: REPO_ROOT });
+  assert.equal(sources.length, QUEBEC_CAMERA_SOURCE_COUNT);
+  for (const source of sources) {
+    assert.equal(source.url, '', 'the server never fetches Québec media');
+    assert.equal(source.snapshotUrl, '');
+  }
+});
+
+test('the Québec loader maps ids by kind, keeps https viewer links, and splits the MTQ credit', (t) => {
+  quiet(t);
+  const at = { lat: 45.51651, lon: -73.5502 };
+  const root = sourceRoot(t, {
+    quebec: [
+      { id: '3735', kind: 'traffic', name: 'Route 136', viewerUrl: 'https://www.quebec511.info/Carte/Fenetres/FenetreVideo.html?id=3735', ...at },
+      { id: 'mtl-465', kind: 'montreal', name: 'Montréal 465', viewerUrl: 'http://ville.montreal.qc.ca/x', ...at },
+      { id: 'web-1', kind: 'webcam', name: 'Tremblant', operator: 'Station Mont-Tremblant', viewerUrl: 'https://user:[email protected]/', ...at },
+      { id: 'abc', kind: 'traffic', ...at }, // non-numeric traffic id
+      { id: '3735', kind: 'traffic', ...at }, // duplicate
+      { id: '9', kind: 'traffic', lat: 40, lon: -73.5 }, // outside Québec
+    ],
+  });
+  const sources = loadQuebecSources({ sourceRoot: root });
+  const byId = new Map(sources.map((source) => [source.id, source]));
+  assert.deepEqual([...byId.keys()], ['qc-511-3735', 'qc-mtl-465', 'qc-web-1']);
+
+  const mtq = byId.get('qc-511-3735');
+  assert.equal(mtq.sourceKind, 'quebec-511-browser');
+  assert.match(mtq.credit, /Locations: MTQ · CC BY 4\.0/);
+  assert.match(mtq.credit, /Video: Québec 511/);
+  assert.doesNotMatch(mtq.license, /^Données Québec \/ MTQ, CC BY 4\.0$/);
+  assert.equal(byId.get('qc-mtl-465').sourceUrl, '', 'http viewer links are dropped');
+  assert.equal(byId.get('qc-web-1').sourceUrl, '', 'credentialed links are dropped');
+  assert.equal(
+    quebec511VideoUrl('qc-511-3735'),
+    'https://www.quebec511.info/Carte/Fenetres/camera.ashx?id=3735&format=mp4',
+  );
+  assert.equal(quebec511VideoUrl('qc-mtl-465'), '');
+});
+
+test('Québec 511 browser video is opt-in', () => {
+  assert.equal(quebecBrowserVideoEnabled({}), false);
+  assert.equal(quebecBrowserVideoEnabled({ CCTV_QUEBEC_VIDEO_ENABLED: '0' }), false);
+  assert.equal(quebecBrowserVideoEnabled({ CCTV_QUEBEC_VIDEO_ENABLED: ' 1 ' }), true);
+});
+
+/** Mount the real proxy with a fixed fetch, and drive requests through it. */
+function mount(t, root, respond) {
+  withEnv(t, {
+    CCTV_SOURCES_FILE: 'absent-source-file.json',
+    CCTV_SOURCES_JSON: undefined,
+    CCTV_FORCE_AUSTIN: '0',
+    CCTV_MAX_SOURCES: undefined,
+    // A configured key makes any Street View fallback observable.
+    GOOGLE_MAPS_SERVER_API_KEY: 'test-google-key',
+  });
+  const requests = [];
+  t.mock.method(globalThis, 'fetch', async (url, init = {}) => {
+    requests.push(String(url));
+    return respond(String(url), init) || new Response('down', { status: 503 });
+  });
+  let handler;
+  cctvProxy({ sourceRoot: root }).configureServer({
+    middlewares: {
+      use(_route, fn) {
+        handler = fn;
+      },
+    },
+  });
+  const call = async (url) => {
+    const res = {
+      writeHead(status, headers) {
+        Object.assign(this, { status, headers });
+      },
+      end(body) {
+        this.body = body;
+      },
+      on() {},
+      once() {},
+    };
+    await handler({ url, method: 'GET', headers: {}, on() {} }, res);
+    return res;
+  };
+  return { call, requests };
+}
+
+test('/sources lists Québec browser media only when the operator opts in', async (t) => {
+  quiet(t);
+  const root = sourceRoot(t, {
+    quebec: [{ id: '3735', kind: 'traffic', name: 'Route 136', lat: 45.5, lon: -73.5 }],
+  });
+  withEnv(t, { CCTV_QUEBEC_VIDEO_ENABLED: undefined });
+  const app = mount(t, root, () => null);
+  const off = JSON.parse((await app.call('/sources')).body).sources;
+  assert.equal(off.find((s) => s.id === 'qc-511-3735').browserMediaUrl, '');
+
+  process.env.CCTV_QUEBEC_VIDEO_ENABLED = '1';
+  const on = JSON.parse((await app.call('/sources')).body).sources;
+  assert.match(on.find((s) => s.id === 'qc-511-3735').browserMediaUrl, /camera\.ashx\?id=3735&format=mp4$/);
+});
+
+test('a World frame is fetched once per refresh floor and the cooldown never spends Street View', async (t) => {
+  quiet(t);
+  const root = sourceRoot(t, { world: [oregonRow()] });
+  let answer = () => new Response(JPEG, { headers: { 'content-type': 'image/jpeg' } });
+  const app = mount(t, root, (url) =>
+    url === oregonRow().url ? answer() : null,
+  );
+  const frame = '/frame/world-or-764';
+  const upstreamHits = () =>
+    app.requests.filter((url) => url === oregonRow().url).length;
+
+  const first = await app.call(frame);
+  assert.equal(first.headers['X-CCTV-Source'], 'upstream-image');
+  const second = await app.call(frame);
+  assert.equal(second.headers['X-CCTV-Source'], 'upstream-image');
+  assert.equal(upstreamHits(), 1, 'the second view reuses the cached frame');
+
+  // A camera whose first fetch fails is inside its failure backoff: it gets
+  // the placeholder, not Google Street View, and no second upstream request.
+  const failRoot = sourceRoot(t, { world: [oregonRow()] });
+  answer = () => new Response('down', { status: 503 });
+  const failing = mount(t, failRoot, (url) =>
+    url === oregonRow().url ? answer() : null,
+  );
+  const failed = await failing.call(frame);
+  assert.notEqual(failed.headers['X-CCTV-Source'], 'upstream-image');
+  const retry = await failing.call(frame);
+  assert.equal(retry.headers['X-CCTV-Source'], 'synthetic');
+  assert.equal(
+    failing.requests.filter((url) => url === oregonRow().url).length,
+    1,
+    'the backoff holds the provider cadence',
+  );
+  assert.equal(
+    failing.requests.filter((url) => url.includes('maps.googleapis.com/maps/api/streetview')).length,
+    1,
+    'only the first miss, outside any cooldown, may try Street View',
+  );
+});
+
+test('Ottawa frames are signed with the certificate at fetch time only', async (t) => {
+  quiet(t);
+  const root = sourceRoot(t);
+  withEnv(t, { OTTAWA_CAMERA_CERTIFICATE: 'CERT123' });
+  const app = mount(t, root, (url) => {
+    if (url === 'https://traffic.ottawa.ca/map/service/camera')
+      return Response.json({
+        cameras: [
+          { camera_number: 16, name: 'Bank & Hunt Club', latitude: 45.35, longitude: -75.65, cameraOwner: 'CITY' },
+        ],
+      });
+    if (url.startsWith('https://traffic.ottawa.ca/opendata/camera'))
+      return new Response(JPEG, { headers: { 'content-type': 'image/jpeg' } });
+    return null;
+  });
+  const sources = JSON.parse((await app.call('/sources')).body).sources;
+  const ottawa = sources.find((source) => source.id === 'ottawa-16');
+  assert.ok(ottawa);
+  assert.doesNotMatch(JSON.stringify(sources), /CERT123/, 'no catalog field carries the certificate');
+
+  const frame = await app.call('/frame/ottawa-16');
+  assert.equal(frame.headers['X-CCTV-Source'], 'upstream-image');
+  await app.call('/frame/ottawa-16');
+  const hits = app.requests.filter((url) => url.includes('/opendata/camera'));
+  assert.deepEqual(hits, [
+    'https://traffic.ottawa.ca/opendata/camera?c=16&certificate=CERT123&id=gev',
+  ], 'one signed request per camera per minute');
+});

src/data/dataCredits.js

@@ -34,6 +34,14 @@ export const OPENMAPTILES_CREDIT = {
   html: 'Vector tiles: <a href="https://openfreemap.org" target="_blank" rel="noopener">OpenFreeMap</a> © <a href="https://openmaptiles.org" target="_blank" rel="noopener">OpenMapTiles</a>',
 };
 
+/** Conditional Salish Sea coverage; registered when its sightings first render. */
+export const ACARTIA_CREDIT = Object.freeze({
+  key: 'acartia',
+  html:
+    'Wildlife sightings: <a href="https://acartia.io" target="_blank" rel="noopener">Acartia</a> (CC BY 4.0; each provider credited per sighting) · ' +
+    '<a href="https://www.bewhalewise.org" target="_blank" rel="noopener">Be Whale Wise</a>',
+});
+
 const osmDisplays = new WeakMap();
 
 function updateOsmDisplay(viewer, state) {
@@ -188,6 +196,10 @@ export const DATA_CREDITS = [
       '<a href="https://adds-faa.opendata.arcgis.com/" target="_blank" rel="noopener">FAA Special Use Airspace</a>' +
       ' (prohibited and restricted zones; informational only)',
   },
+  {
+    key: 'inaturalist',
+    html: 'Wildlife sightings: <a href="https://www.inaturalist.org" target="_blank" rel="noopener">iNaturalist</a> contributors (licences per record; photos credited on each card)',
+  },
   OSM_CREDIT,
   OPENMAPTILES_CREDIT,
   {
@@ -287,6 +299,38 @@ export const DATA_CREDITS = [
       'CCTV static data (MOTC 2.0), released under the ' +
       '<a href="https://data.gov.tw/license" target="_blank" rel="noopener">Open Government Data License, Taiwan (Version 1.0)</a>',
   },
+  {
+    key: 'ottawa-cctv',
+    html:
+      'Traffic cameras (Ottawa, with an access certificate): ' +
+      '<a href="https://traffic.ottawa.ca/en/traffic-map-data-lists-and-resources/about-the-data" target="_blank" rel="noopener">City of Ottawa Traffic Camera Images API</a>',
+  },
+  {
+    key: 'quebec-cctv',
+    html:
+      'Camera locations (Québec): Ministère des Transports et de la Mobilité durable via ' +
+      '<a href="https://www.donneesquebec.ca/" target="_blank" rel="noopener">Données Québec</a> ' +
+      '(<a href="https://creativecommons.org/licenses/by/4.0/" target="_blank" rel="noopener">CC BY 4.0</a>); ' +
+      'Montréal camera locations © OpenStreetMap contributors (ODbL). ' +
+      'Video (when enabled) and linked webcam pages stay with ' +
+      '<a href="https://www.quebec511.info/" target="_blank" rel="noopener">Québec 511</a> and each operator, under their own terms',
+  },
+  {
+    key: 'tripcheck-cctv',
+    html:
+      'Road camera stills (Oregon): camera courtesy of ODOT, via ' +
+      '<a href="https://www.tripcheck.com/" target="_blank" rel="noopener">TripCheck</a>; ' +
+      'partner cameras (counties, cities, Caltrans, WSDOT) are named in the camera label',
+  },
+  {
+    key: 'mlit-river-cctv',
+    html:
+      'River camera stills (Japan): 出典：国土交通省 ' +
+      '<a href="https://www.river.go.jp/" target="_blank" rel="noopener">川の防災情報</a> ' +
+      '(Ministry of Land, Infrastructure, Transport and Tourism; ' +
+      '<a href="https://www.river.go.jp/kawabou/kwb_apend/html/caution.html" target="_blank" rel="noopener">terms</a>), ' +
+      'fetched on view, at most every ten minutes per camera',
+  },
   {
     key: 'calgary-cctv',
     html:
@@ -309,6 +353,15 @@ export const DATA_CREDITS = [
       '(Llicència oberta d’ús d’informació - Catalunya); some cameras are supplied by partners ' +
       '(Ajuntament de Barcelona, Ajuntament de Terrassa), each named in the CCTV panel',
   },
+  {
+    key: 'iceland-cctv',
+    html:
+      'CCTV cameras &amp; frames (Iceland): road camera images, fetched live, from the ' +
+      '<a href="https://www.vegagerdin.is/" target="_blank" rel="noopener">Icelandic Road and Coastal Administration (Vegagerðin)</a> — ' +
+      '<a href="https://creativecommons.org/licenses/by/4.0/" target="_blank" rel="noopener">CC BY 4.0</a> ' +
+      '(<a href="https://www.vegagerdin.is/vegagerdin/gagnasafn/vefthjonustur/terms-and-conditions" target="_blank" rel="noopener">terms</a>); ' +
+      'no endorsement by IRCA is implied',
+  },
   {
     key: 'kingcounty-cctv',
     html:
@@ -333,6 +386,14 @@ export const DATA_CREDITS = [
       '<a href="https://data.gov.hk/en-data/dataset/hk-td-tis_2-traffic-snapshot-images" target="_blank" rel="noopener">Transport Department / DATA.GOV.HK</a> ' +
       '(<a href="https://data.gov.hk/en/terms-and-conditions" target="_blank" rel="noopener">Terms of Use</a> — attribution required)',
   },
+  {
+    key: 'webcamromania-cctv',
+    html:
+      'Giroc camera (when configured): ' +
+      '<a href="https://webcamromania.ro/webcam-orase/webcam-giroc/" target="_blank" rel="noopener">Webcam Romania</a>. ' +
+      'Video rights remain with the camera operator; ' +
+      '<a href="https://webcamromania.ro/termeni-si-conditii/" target="_blank" rel="noopener">provider terms</a> apply.',
+  },
   {
     key: 'vegvesen-cctv',
     html:

src/data/dataCredits.test.mjs

@@ -153,3 +153,17 @@ test('every Street Level imagery source is in the attribution lightbox', () => {
       `${key} has no credit`,
     );
 });
+
+test('the PR #1506 camera packs are credited with their sources and terms', () => {
+  const html = (key) => DATA_CREDITS.find((entry) => entry.key === key)?.html;
+  assert.match(html('ottawa-cctv') || '', /traffic\.ottawa\.ca/);
+  assert.match(html('quebec-cctv') || '', /CC BY 4\.0/);
+  assert.match(html('quebec-cctv') || '', /OpenStreetMap contributors/);
+  assert.match(html('tripcheck-cctv') || '', /courtesy of ODOT/);
+  // MLIT's terms ask for the source in this form, with the page link.
+  assert.match(html('mlit-river-cctv') || '', /出典：国土交通省/);
+  assert.match(
+    html('mlit-river-cctv') || '',
+    /href="https:\/\/www\.river\.go\.jp\//,
+  );
+});

src/data/firmsCards.test.mjs

@@ -45,7 +45,7 @@ test('buildFireCard: title carries FRP, detail carries conf/age/satellite', () =
   assert.equal(card.details.length, 1);
   assert.equal(card.details[0], 'high · 2h · N20');
   assert.equal(card.selected, false);
-  assert.equal(card.accent, accentForSeverity('red'), 'FRP 1520 is red-hot');
+  assert.equal(card.accent, accentForSeverity('white-hot'), 'FRP 1520 is white-hot');
   assert.deepEqual(card.position, { x: 1, y: 2, z: 3 }, 'uses the candidate position untouched');
 });
 
@@ -69,11 +69,27 @@ test('buildFireCard: power that rounds to 10 MW drops the decimal', () => {
   assert.equal(selected.title, 'FIRE · 10 MW');
 });
 
-test('buildFireCard: SNPP satellite code renders as SNPP, weak fire is not red', () => {
+test('buildFireCard: SNPP satellite code renders as SNPP, weak fire is an ember', () => {
   const card = buildFireCard({ fire: fire({ satellite: 'N', frp: 0.8, confidence: 0.3 }), position: {} }, NOW);
   assert.match(card.details[0], /SNPP$/);
   assert.equal(card.title, '▲ 0.8 MW');
-  assert.notEqual(card.accent, accentForSeverity('red'));
+  assert.equal(card.accent, accentForSeverity('ember'));
+});
+
+test('buildFireCard: accent steps through the FRP ramp at 5 · 20 · 50 · 100 · 300 MW', () => {
+  const accentAt = (frp) =>
+    buildFireCard({ fire: fire({ frp }), position: {} }, NOW).accent;
+  assert.equal(accentAt(4.9), accentForSeverity('ember'));
+  assert.equal(accentAt(5), accentForSeverity('red'));
+  assert.equal(accentAt(20), accentForSeverity('flame'));
+  assert.equal(accentAt(50), accentForSeverity('orange'));
+  assert.equal(accentAt(100), accentForSeverity('gold'));
+  assert.equal(accentAt(300), accentForSeverity('white-hot'));
+  // Confidence never moves the color: a low-confidence 864 MW fire stays red.
+  assert.equal(
+    buildFireCard({ fire: fire({ frp: 864, confidence: 0.3 }), position: {} }, NOW).accent,
+    accentForSeverity('white-hot'),
+  );
 });
 
 test('buildSelectedFireCard: full detail card with coords, selected flag, no fade', () => {
@@ -93,12 +109,12 @@ test('buildCellCard: plural noun, max FRP and newest age, accent passthrough', (
   const candidate = {
     cell: { count: 14, maxFrp: 210.4, newestAcqMs: NOW - 3 * H, night: 2 },
     position: { x: 0, y: 0, z: 0 },
-    accent: accentForSeverity('orange'),
+    accent: accentForSeverity('gold'),
   };
   const card = buildCellCard(candidate, NOW);
   assert.equal(card.title, '14 FIRES');
   assert.equal(card.details[0], 'max 210 MW · new 3h');
-  assert.equal(card.accent, accentForSeverity('orange'));
+  assert.equal(card.accent, accentForSeverity('gold'));
 });
 
 test('buildCellCard: the count picks the plural form of the language', () => {
@@ -150,7 +166,7 @@ test('buildCellCard: singular noun and missing-age omission', () => {
   const card = buildCellCard(candidate, NOW);
   assert.equal(card.title, '1 FIRE');
   assert.equal(card.details[0], 'max 9.9 MW');
-  assert.equal(card.accent, accentForSeverity('yellow'), 'missing accent defaults to yellow');
+  assert.equal(card.accent, accentForSeverity('ember'), 'missing accent defaults to the weakest stop');
 });
 
 test('FIRMS host policy keeps ambient cards bounded and selected cards protected', () => {

src/data/firmsHeatRaster.js

@@ -0,0 +1,209 @@
+/**
+ * Snap Map–style heat raster for the Active Fires far-zoom bands: detections
+ * are linearly binned on an equirectangular grid (row 0 = north, column
+ * 0 = 180°W), blurred, normalized on a log scale and mapped through
+ * HEAT_PALETTE. Pure: no Cesium, no DOM, so the whole pipeline is unit-tested
+ * in node.
+ */
+
+/** Below this normalized heat nothing is painted: empty land stays empty. */
+export const HEAT_FLOOR = 0.03;
+
+/**
+ * The FRP marker ramp as a continuous glow, from a red edge through orange
+ * and gold to a pale white-hot core. The edge is a bright red, not the
+ * markers' dark ember, and starts more than half opaque: most of the world
+ * sits low on a scale set by the hottest regions, and a dark translucent red
+ * vanishes into forest and savanna imagery.
+ */
+export const HEAT_PALETTE = Object.freeze([
+  { at: 0.0, rgb: [232, 58, 30], alpha: 0 },
+  { at: 0.08, rgb: [232, 58, 30], alpha: 0.58 },
+  { at: 0.25, rgb: [242, 86, 34], alpha: 0.7 },
+  { at: 0.45, rgb: [248, 122, 40], alpha: 0.76 },
+  { at: 0.65, rgb: [252, 166, 52], alpha: 0.82 },
+  { at: 0.82, rgb: [254, 208, 92], alpha: 0.87 },
+  { at: 1.0, rgb: [255, 245, 190], alpha: 0.92 },
+]);
+
+export function heatColorAt(t) {
+  if (!(t > HEAT_FLOOR)) return [0, 0, 0, 0];
+  const v = Math.min(1, t);
+  let i = 1;
+  while (i < HEAT_PALETTE.length - 1 && HEAT_PALETTE[i].at < v) i += 1;
+  const a = HEAT_PALETTE[i - 1];
+  const b = HEAT_PALETTE[i];
+  const k = (v - a.at) / (b.at - a.at || 1);
+  const mix = (p, q) => Math.round(p + (q - p) * k);
+  return [
+    mix(a.rgb[0], b.rgb[0]),
+    mix(a.rgb[1], b.rgb[1]),
+    mix(a.rgb[2], b.rgb[2]),
+    Math.round((a.alpha + (b.alpha - a.alpha) * k) * 255),
+  ];
+}
+
+/** Weight of a detection with no or zero FRP, in megawatts. */
+export const HEAT_MIN_WEIGHT_MW = 0.5;
+
+/**
+ * Heat is radiated power, not a head count: each detection adds its FRP in
+ * megawatts. Weak fires carry little power, so raising the minimum-FRP slider
+ * removes most detections without dimming the areas where strong fires burn
+ * (a count-based heat collapsed there and the hot spots faded).
+ */
+const defaultWeight = (fire) =>
+  Math.max(HEAT_MIN_WEIGHT_MW, Number(fire.frp) || 0);
+
+/**
+ * Linear binning (Wand 1994): each detection's weight is shared between the
+ * four pixel centres around it in proportion to closeness, instead of
+ * dropping whole into one pixel. Spots then sit at the true position rather
+ * than snapping by up to half a pixel (~10 km), and a lone weak fire blurs
+ * into a round spot instead of a square or a plus sign. Longitude wraps;
+ * rows beyond the poles fold back onto the edge row.
+ */
+export function binFires(fires, { width, height, weight = defaultWeight }) {
+  const grid = new Float32Array(width * height);
+  const row = (y) => Math.min(height - 1, Math.max(0, y)) * width;
+  const col = (x) => ((x % width) + width) % width;
+  for (const fire of fires) {
+    if (!Number.isFinite(fire.lat) || !Number.isFinite(fire.lon)) continue;
+    const fx = ((fire.lon + 180) / 360) * width - 0.5;
+    const fy = ((90 - fire.lat) / 180) * height - 0.5;
+    const x0 = Math.floor(fx);
+    const y0 = Math.floor(fy);
+    const tx = fx - x0;
+    const ty = fy - y0;
+    const w = weight(fire);
+    const top = row(y0);
+    const bottom = row(y0 + 1);
+    const left = col(x0);
+    const right = col(x0 + 1);
+    grid[top + left] += w * (1 - tx) * (1 - ty);
+    grid[top + right] += w * tx * (1 - ty);
+    grid[bottom + left] += w * (1 - tx) * ty;
+    grid[bottom + right] += w * tx * ty;
+  }
+  return grid;
+}
+
+function kernel(sigma) {
+  const radius = Math.max(1, Math.ceil(sigma * 3));
+  const k = new Float32Array(radius * 2 + 1);
+  let sum = 0;
+  for (let i = -radius; i <= radius; i++) {
+    k[i + radius] = Math.exp(-(i * i) / (2 * sigma * sigma));
+    sum += k[i + radius];
+  }
+  for (let i = 0; i < k.length; i++) k[i] /= sum;
+  return { k, radius };
+}
+
+export function blurGaussian(grid, width, height, sigma) {
+  const { k, radius } = kernel(sigma);
+  const tmp = new Float32Array(grid.length);
+  const out = new Float32Array(grid.length);
+  for (let y = 0; y < height; y++) {
+    const row = y * width;
+    for (let x = 0; x < width; x++) {
+      const v = grid[row + x];
+      if (v === 0) continue;
+      for (let i = -radius; i <= radius; i++) {
+        const xx = (((x + i) % width) + width) % width; // longitude wraps
+        tmp[row + xx] += v * k[i + radius];
+      }
+    }
+  }
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const v = tmp[y * width + x];
+      if (v === 0) continue;
+      for (let i = -radius; i <= radius; i++) {
+        const yy = Math.min(height - 1, Math.max(0, y + i)); // poles clamp
+        out[yy * width + x] += v * k[i + radius];
+      }
+    }
+  }
+  return out;
+}
+
+/** Bins of the log-density histogram used to find the reference quantile. */
+const QUANTILE_BINS = 4096;
+
+/**
+ * The p-quantile of the non-zero values, from a histogram of log1p(value):
+ * one linear pass instead of sorting ~350k burning pixels (a sort cost
+ * 200 ms+ and dominated the build). Bin width on the log axis is
+ * max/4096, far finer than the 256-step palette it feeds.
+ */
+function percentileOfNonZero(values, p) {
+  let count = 0;
+  let max = 0;
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i];
+    if (v > 0) {
+      count += 1;
+      if (v > max) max = v;
+    }
+  }
+  if (!count) return 0;
+  const logMax = Math.log1p(max);
+  const bins = new Uint32Array(QUANTILE_BINS);
+  const toBin = (QUANTILE_BINS - 1) / logMax;
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i];
+    if (v > 0) bins[Math.floor(Math.log1p(v) * toBin)] += 1;
+  }
+  const target = Math.floor(p * (count - 1));
+  let seen = 0;
+  for (let b = 0; b < QUANTILE_BINS; b++) {
+    seen += bins[b];
+    if (seen > target) return Math.expm1((b + 1) / toBin);
+  }
+  return max;
+}
+
+/** HEAT_PALETTE sampled at 256 steps, so the per-pixel walk is one lookup. */
+const LUT_STEPS = 256;
+let paletteLut = null;
+function heatLut() {
+  if (!paletteLut) {
+    paletteLut = new Uint8ClampedArray(LUT_STEPS * 4);
+    for (let i = 0; i < LUT_STEPS; i++) {
+      paletteLut.set(heatColorAt(i / (LUT_STEPS - 1)), i * 4);
+    }
+  }
+  return paletteLut;
+}
+
+export function buildHeatRaster(
+  fires,
+  { width, height, sigmaPx, percentile = 0.995 },
+) {
+  const density = blurGaussian(
+    binFires(fires, { width, height }),
+    width,
+    height,
+    sigmaPx,
+  );
+  const reference = percentileOfNonZero(density, percentile);
+  const rgba = new Uint8ClampedArray(width * height * 4);
+  if (reference > 0) {
+    const lut = heatLut();
+    const scale = (LUT_STEPS - 1) / Math.log1p(reference);
+    for (let i = 0; i < density.length; i++) {
+      const d = density[i];
+      if (d <= 0) continue;
+      const step = Math.min(LUT_STEPS - 1, Math.round(Math.log1p(d) * scale));
+      const l = step * 4;
+      if (lut[l + 3] === 0) continue;
+      const o = i * 4;
+      rgba[o] = lut[l];
+      rgba[o + 1] = lut[l + 1];
+      rgba[o + 2] = lut[l + 2];
+      rgba[o + 3] = lut[l + 3];
+    }
+  }
+  return { width, height, rgba, reference };
+}

src/data/firmsHeatRaster.test.mjs

@@ -0,0 +1,118 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  HEAT_MIN_WEIGHT_MW,
+  HEAT_PALETTE,
+  heatColorAt,
+  binFires,
+  blurGaussian,
+  buildHeatRaster,
+} from './firmsHeatRaster.js';
+
+const fire = (lat, lon, frp = 10) => ({ lat, lon, frp });
+
+test('palette runs ember to white-hot and starts fully transparent', () => {
+  assert.equal(HEAT_PALETTE[0].at, 0);
+  assert.equal(HEAT_PALETTE.at(-1).at, 1);
+  assert.deepEqual(heatColorAt(0), [0, 0, 0, 0]);
+  assert.equal(heatColorAt(0.01)[3], 0, 'below the floor nothing is painted');
+  const low = heatColorAt(0.15);
+  const high = heatColorAt(1);
+  assert.ok(low[0] > low[1] && low[1] > low[2], 'low heat is red');
+  assert.ok(low[3] >= 0.5 * 255, 'low heat stays visible on any imagery');
+  assert.ok(high[1] > low[1] && high[2] > low[2], 'the core is paler');
+  assert.ok(high[3] > low[3], 'hotter is more opaque');
+  for (let i = 1; i <= 100; i++) {
+    const [r, , b] = heatColorAt(i / 100);
+    assert.ok(r >= b, `no cold hue at ${i}%`);
+  }
+});
+
+test('binFires puts a detection at a pixel centre wholly in that pixel', () => {
+  // 4×2 grid: pixel centres at lon −135/−45/45/135, lat ±45.
+  const grid = binFires([fire(45, -135, 1), fire(-45, 135, 1)], {
+    width: 4,
+    height: 2,
+  });
+  assert.equal(grid[0], 1, 'north-west pixel');
+  assert.equal(grid[7], 1, 'south-east pixel');
+  assert.equal(
+    grid.reduce((a, b) => a + b, 0),
+    2,
+  );
+});
+
+test('binFires shares a detection between the pixels around it', () => {
+  const between = binFires([fire(45, 0, 1)], { width: 4, height: 2 });
+  assert.equal(between[1], 0.5, 'half to the pixel west of it');
+  assert.equal(between[2], 0.5, 'half to the pixel east of it');
+  const quarter = binFires([fire(45, -112.5, 1)], { width: 4, height: 2 });
+  assert.equal(quarter[0], 0.75, 'closer centre takes more');
+  assert.equal(quarter[1], 0.25);
+  const wrapped = binFires([fire(45, 180, 1)], { width: 4, height: 2 });
+  assert.equal(wrapped[3], 0.5, 'the antimeridian wraps');
+  assert.equal(wrapped[0], 0.5);
+  const polar = binFires([fire(90, -135, 1)], { width: 4, height: 2 });
+  assert.equal(polar[0], 1, 'beyond the last row folds back onto it');
+});
+
+test('binFires weights each detection by its radiative power', () => {
+  const grid = binFires(
+    [fire(45, 45, 250), fire(45, 45, 0), fire(45, 45, Number.NaN)],
+    { width: 4, height: 2 },
+  );
+  assert.equal(grid[2], 250 + 2 * HEAT_MIN_WEIGHT_MW);
+});
+
+test('filtering out weak fires keeps a strong fire hot', () => {
+  const strong = fire(0.1, 0.1, 300);
+  const weak = Array.from({ length: 40 }, () => fire(0.1, 0.1, 2));
+  const reference = Array.from({ length: 10 }, () => fire(20.1, 20.1, 100));
+  const options = { width: 360, height: 180, sigmaPx: 2 };
+  const pixel = ((90 - 0.1) | 0) * 360 + ((0.1 + 180) | 0);
+  const red = (r) => r.rgba[pixel * 4];
+  const alpha = (r) => r.rgba[pixel * 4 + 3];
+  const unfiltered = buildHeatRaster([strong, ...weak, ...reference], options);
+  const filtered = buildHeatRaster([strong, ...reference], options);
+  assert.ok(alpha(filtered) > 0);
+  assert.ok(
+    alpha(filtered) >= alpha(unfiltered) * 0.9,
+    `alpha ${alpha(unfiltered)} -> ${alpha(filtered)}`,
+  );
+  assert.ok(
+    red(filtered) >= red(unfiltered) * 0.9,
+    `red ${red(unfiltered)} -> ${red(filtered)}`,
+  );
+});
+
+test('blurGaussian keeps mass and wraps across the antimeridian', () => {
+  const w = 16;
+  const h = 8;
+  const grid = new Float32Array(w * h);
+  grid[3 * w + 0] = 1;
+  const out = blurGaussian(grid, w, h, 1.5);
+  const sum = out.reduce((a, b) => a + b, 0);
+  assert.ok(Math.abs(sum - 1) < 1e-3, `mass ${sum}`);
+  assert.ok(out[3 * w + (w - 1)] > 0, 'spills to the east edge');
+});
+
+test('buildHeatRaster is transparent where there are no fires', () => {
+  const r = buildHeatRaster([fire(40, -120), fire(40.1, -120.1)], {
+    width: 360,
+    height: 180,
+    sigmaPx: 2,
+  });
+  assert.equal(r.rgba.length, 360 * 180 * 4);
+  const alphaAt = (lat, lon) => {
+    const x = Math.floor(((lon + 180) / 360) * 360);
+    const y = Math.floor(((90 - lat) / 180) * 180);
+    return r.rgba[(y * 360 + x) * 4 + 3];
+  };
+  assert.ok(alphaAt(40, -120) > 0, 'blob over the fires');
+  assert.equal(alphaAt(-30, 60), 0, 'empty far away');
+});
+
+test('buildHeatRaster with no fires is fully transparent', () => {
+  const r = buildHeatRaster([], { width: 8, height: 4, sigmaPx: 1 });
+  assert.ok(r.rgba.every((v) => v === 0));
+});

src/data/firmsIntensity.js

@@ -0,0 +1,212 @@
+/**
+ * @module firmsIntensity
+ * @description Fire intensity policy shared by the Active Fires layer and the
+ * agent fire tool: the six-stop ember → white-hot FRP color ramp, the log-scale
+ * slider that doubles as its legend, and the one filter every consumer
+ * (markers, cards, heat cells, the top-fires query, `get_active_fires`) runs
+ * before anything is rendered or selected. Pure — no Cesium, no DOM.
+ *
+ * The ramp (`FRP_RAMP`, stepped, not interpolated) runs like a fire cooling
+ * down: a dim ember for weak fires through red, orange and gold to a pale
+ * white-hot core, lightness rising with power, so the brightest marks are the
+ * strongest fires. No cold hues: ~90% of detections are under 20 MW and a
+ * blue start painted most of the map blue. The thresholds are GEV's own, set
+ * on a real week's percentiles so every color appears: Portolan's
+ * 0/10/50/200/500/1000 MW leaves one hottest fire a week (HAL-675).
+ */
+
+/**
+ * Stepped FRP ramp, weakest first. A detection takes the LAST stop whose
+ * `minFrp` it reaches. Names key the glow-sprite cache and the card accents.
+ */
+export const FRP_RAMP = Object.freeze([
+  Object.freeze({ name: 'ember', minFrp: 0, hex: '#9e2a1b' }),
+  Object.freeze({ name: 'red', minFrp: 5, hex: '#d2401f' }),
+  Object.freeze({ name: 'flame', minFrp: 20, hex: '#f06a28' }),
+  Object.freeze({ name: 'orange', minFrp: 50, hex: '#fb9a2e' }),
+  Object.freeze({ name: 'gold', minFrp: 100, hex: '#fdc84a' }),
+  Object.freeze({ name: 'white-hot', minFrp: 300, hex: '#fff3b0' }),
+]);
+
+/** Slider ticks: the ramp thresholds, so slider, legend and markers agree. */
+export const FRP_SLIDER_TICKS = Object.freeze(
+  FRP_RAMP.map((stop) => stop.minFrp),
+);
+
+/** Minimum-FRP values the share codec accepts, in whole megawatts. */
+export const MIN_FRP_MW_MIN = 0;
+export const MIN_FRP_MW_MAX = 10_000;
+
+/** Confidence switch positions; VIIRS reports only low / nominal / high. */
+export const FIRMS_CONFIDENCE_MODES = Object.freeze(['all', 'nominal', 'high']);
+
+/**
+ * Normalized-confidence floor for a switch position. The thresholds match
+ * `confidenceBucket` in the layer model (0.3 / 0.6 / 0.9 after firmsAdapt).
+ */
+const CONFIDENCE_FLOOR = Object.freeze({ all: 0, nominal: 0.45, high: 0.75 });
+
+export const DEFAULT_FIRE_FILTER = Object.freeze({
+  minFrp: 0,
+  confidence: 'all',
+});
+
+/**
+ * The ramp stop for a fire radiative power.
+ * @param {number} frp Megawatts; non-finite or negative reads as 0.
+ * @returns {{name: string, minFrp: number, hex: string}}
+ */
+export function frpRampStop(frp) {
+  const value = Number.isFinite(frp) ? Math.max(0, frp) : 0;
+  let stop = FRP_RAMP[0];
+  for (const candidate of FRP_RAMP) {
+    if (value >= candidate.minFrp) stop = candidate;
+    else break;
+  }
+  return stop;
+}
+
+/** `#rrggbb` → `[r, g, b]` in 0..255. */
+export function hexToRgb(hex) {
+  const text = String(hex).replace('#', '');
+  return [0, 2, 4].map((offset) =>
+    Number.parseInt(text.slice(offset, offset + 2), 16),
+  );
+}
+
+/**
+ * Log-scale slider axis: position 0 means "no minimum" (0 MW), and the rest
+ * of the track runs 1 MW → SLIDER_MAX_MW logarithmically. The axis floor is 1
+ * MW because the median detection is ~6 MW and a sub-megawatt floor hides
+ * nothing worth a tick.
+ */
+export const SLIDER_MAX_MW = 1000;
+const LOG_MAX = Math.log10(SLIDER_MAX_MW);
+
+/**
+ * Track position in 0..1 for a minimum FRP.
+ * @param {number} minFrp Megawatts.
+ * @returns {number}
+ */
+export function sliderPositionForFrp(minFrp) {
+  if (!Number.isFinite(minFrp) || minFrp < 1) return 0;
+  return Math.min(1, Math.log10(minFrp) / LOG_MAX);
+}
+
+/**
+ * Minimum FRP for a track position, rounded to whole megawatts so a slider
+ * value and its share-link form are the same number.
+ * @param {number} position 0..1.
+ * @returns {number}
+ */
+export function frpForSliderPosition(position) {
+  const p = Number.isFinite(position) ? Math.max(0, Math.min(1, position)) : 0;
+  if (p <= 0) return 0;
+  const frp = Math.pow(10, p * LOG_MAX);
+  return Math.max(1, Math.round(frp));
+}
+
+/**
+ * CSS `linear-gradient` painting the stepped ramp along the log axis, so the
+ * slider track IS the legend: the color under the thumb is the color of the
+ * weakest fire still shown.
+ * @returns {string}
+ */
+export function rampTrackGradient() {
+  const parts = [];
+  FRP_RAMP.forEach((stop, index) => {
+    const start = sliderPositionForFrp(stop.minFrp) * 100;
+    const next = FRP_RAMP[index + 1];
+    const end = next ? sliderPositionForFrp(next.minFrp) * 100 : 100;
+    parts.push(`${stop.hex} ${start.toFixed(2)}% ${end.toFixed(2)}%`);
+  });
+  return `linear-gradient(90deg, ${parts.join(', ')})`;
+}
+
+/**
+ * Minimum FRP → whole megawatts inside the codec bounds, or null.
+ * @param {*} value
+ * @returns {?number}
+ */
+export function normalizeMinFrp(value) {
+  const number =
+    typeof value === 'number'
+      ? value
+      : typeof value === 'string' && value.trim() !== ''
+        ? Number(value)
+        : NaN;
+  if (!Number.isFinite(number)) return null;
+  const rounded = Math.round(number);
+  return rounded >= MIN_FRP_MW_MIN && rounded <= MIN_FRP_MW_MAX
+    ? rounded
+    : null;
+}
+
+/**
+ * Confidence mode → one of FIRMS_CONFIDENCE_MODES, or null.
+ * @param {*} value
+ * @returns {?string}
+ */
+export function normalizeConfidenceMode(value) {
+  const text = String(value ?? '')
+    .trim()
+    .toLowerCase();
+  return FIRMS_CONFIDENCE_MODES.includes(text) ? text : null;
+}
+
+/**
+ * Sanitize a partial filter against the current one; unknown or invalid
+ * fields keep their current value.
+ * @param {Object} [params]
+ * @param {{minFrp: number, confidence: string}} [current]
+ * @returns {{minFrp: number, confidence: string}}
+ */
+export function normalizeFireFilter(
+  params = {},
+  current = DEFAULT_FIRE_FILTER,
+) {
+  const minFrp = normalizeMinFrp(params?.minFrp);
+  const confidence = normalizeConfidenceMode(params?.confidence);
+  return {
+    minFrp: minFrp === null ? current.minFrp : minFrp,
+    confidence: confidence === null ? current.confidence : confidence,
+  };
+}
+
+/**
+ * Whether one fire passes the filter. `confidence` is the normalized 0..1
+ * value firmsAdapt produces; `frp` is megawatts.
+ * @param {{frp: number, confidence: number}} fire
+ * @param {{minFrp: number, confidence: string}} filter
+ * @returns {boolean}
+ */
+export function firePassesFilter(fire, filter = DEFAULT_FIRE_FILTER) {
+  const frp = Number.isFinite(fire?.frp) ? fire.frp : 0;
+  if (frp < (filter.minFrp || 0)) return false;
+  const floor = CONFIDENCE_FLOOR[filter.confidence] ?? 0;
+  if (floor <= 0) return true;
+  const confidence = Number.isFinite(fire?.confidence) ? fire.confidence : 0;
+  return confidence >= floor;
+}
+
+/**
+ * The fires that pass the filter, in input order. Returns the SAME array when
+ * the filter is the default, so callers can tell "nothing hidden" cheaply.
+ * @template T
+ * @param {Array<T>} fires Internal records (normalized confidence).
+ * @param {{minFrp: number, confidence: string}} filter
+ * @returns {Array<T>}
+ */
+export function filterFires(fires, filter = DEFAULT_FIRE_FILTER) {
+  if (!Array.isArray(fires)) return [];
+  if (isDefaultFireFilter(filter)) return fires;
+  return fires.filter((fire) => firePassesFilter(fire, filter));
+}
+
+/** True when the filter hides nothing. */
+export function isDefaultFireFilter(filter) {
+  return (
+    !(filter?.minFrp > 0) &&
+    (filter?.confidence === 'all' || filter?.confidence == null)
+  );
+}

src/data/firmsIntensity.test.mjs

@@ -0,0 +1,221 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  DEFAULT_FIRE_FILTER,
+  FIRMS_CONFIDENCE_MODES,
+  FRP_RAMP,
+  FRP_SLIDER_TICKS,
+  filterFires,
+  firePassesFilter,
+  frpForSliderPosition,
+  frpRampStop,
+  hexToRgb,
+  isDefaultFireFilter,
+  normalizeConfidenceMode,
+  normalizeFireFilter,
+  normalizeMinFrp,
+  rampTrackGradient,
+  sliderPositionForFrp,
+} from './firmsIntensity.js';
+
+test('the ramp has six ember → white-hot stops at 0 · 5 · 20 · 50 · 100 · 300 MW', () => {
+  assert.deepEqual(
+    FRP_RAMP.map((stop) => [stop.name, stop.minFrp, stop.hex]),
+    [
+      ['ember', 0, '#9e2a1b'],
+      ['red', 5, '#d2401f'],
+      ['flame', 20, '#f06a28'],
+      ['orange', 50, '#fb9a2e'],
+      ['gold', 100, '#fdc84a'],
+      ['white-hot', 300, '#fff3b0'],
+    ],
+  );
+  assert.deepEqual([...FRP_SLIDER_TICKS], [0, 5, 20, 50, 100, 300]);
+  assert.ok(Object.isFrozen(FRP_RAMP));
+});
+
+test('every stop is warm and each is lighter than the one below', () => {
+  const luma = ([r, g, b]) => 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  let previous = -1;
+  for (const stop of FRP_RAMP) {
+    const rgb = hexToRgb(stop.hex);
+    assert.ok(rgb[0] >= rgb[2], `${stop.name} has no cold hue`);
+    assert.ok(
+      luma(rgb) > previous,
+      `${stop.name} is lighter than the stop below`,
+    );
+    previous = luma(rgb);
+  }
+});
+
+test('a detection takes the last stop it reaches; garbage reads as 0 MW', () => {
+  assert.equal(frpRampStop(0).name, 'ember');
+  assert.equal(frpRampStop(4.99).name, 'ember');
+  assert.equal(frpRampStop(5).name, 'red');
+  assert.equal(frpRampStop(19.9).name, 'red');
+  assert.equal(frpRampStop(20).name, 'flame');
+  assert.equal(frpRampStop(50).name, 'orange');
+  assert.equal(frpRampStop(100).name, 'gold');
+  assert.equal(frpRampStop(299.9).name, 'gold');
+  assert.equal(frpRampStop(300).name, 'white-hot');
+  assert.equal(frpRampStop(1246).name, 'white-hot');
+  assert.equal(frpRampStop(NaN).name, 'ember');
+  assert.equal(frpRampStop(-3).name, 'ember');
+  assert.equal(frpRampStop(undefined).name, 'ember');
+});
+
+test('hex stops convert to the "r, g, b" accents the cards paint', () => {
+  assert.deepEqual(hexToRgb('#9e2a1b'), [158, 42, 27]);
+  assert.deepEqual(hexToRgb('d1382a'), [209, 56, 42]);
+});
+
+test('the log slider pins 0 MW at the left and runs 1 → 1000 MW; values round-trip', () => {
+  assert.equal(sliderPositionForFrp(0), 0);
+  assert.equal(sliderPositionForFrp(0.5), 0);
+  assert.equal(sliderPositionForFrp(1), 0);
+  assert.ok(Math.abs(sliderPositionForFrp(10) - 1 / 3) < 1e-9);
+  assert.ok(Math.abs(sliderPositionForFrp(100) - 2 / 3) < 1e-9);
+  assert.equal(sliderPositionForFrp(1000), 1);
+  assert.equal(sliderPositionForFrp(5000), 1, 'clamped past the axis end');
+  assert.equal(frpForSliderPosition(0), 0);
+  assert.equal(frpForSliderPosition(1), 1000);
+  assert.equal(frpForSliderPosition(-1), 0);
+  assert.equal(frpForSliderPosition(2), 1000);
+  for (const frp of FRP_SLIDER_TICKS) {
+    assert.equal(
+      frpForSliderPosition(sliderPositionForFrp(frp)),
+      frp,
+      `tick ${frp} MW round-trips through the axis`,
+    );
+  }
+  // Ticks spread along the track instead of bunching at one end.
+  const positions = FRP_SLIDER_TICKS.map(sliderPositionForFrp);
+  for (let i = 1; i < positions.length; i += 1) {
+    assert.ok(positions[i] - positions[i - 1] >= 0.09, `tick gap ${i}`);
+  }
+});
+
+test('the track gradient is the stepped ramp on the log axis, so it doubles as the legend', () => {
+  const gradient = rampTrackGradient();
+  assert.match(gradient, /^linear-gradient\(90deg, /);
+  assert.match(gradient, /#9e2a1b 0\.00% 23\.3\d%/);
+  assert.match(gradient, /#d2401f 23\.3\d% 43\.3\d%/);
+  assert.match(gradient, /#fff3b0 82\.5\d% 100\.00%\)$/);
+  assert.equal(gradient.match(/#/g).length, FRP_RAMP.length);
+});
+
+test('minimum FRP normalizes to whole megawatts inside the codec bounds', () => {
+  assert.equal(normalizeMinFrp(0), 0);
+  assert.equal(normalizeMinFrp(19.6), 20);
+  assert.equal(normalizeMinFrp('100'), 100);
+  assert.equal(normalizeMinFrp(10000), 10000);
+  assert.equal(normalizeMinFrp(10001), null);
+  assert.equal(normalizeMinFrp(-1), null);
+  assert.equal(normalizeMinFrp('abc'), null);
+  assert.equal(normalizeMinFrp(''), null);
+  assert.equal(normalizeMinFrp(null), null);
+  assert.equal(normalizeMinFrp(NaN), null);
+});
+
+test('confidence modes are exactly all / nominal / high', () => {
+  assert.deepEqual([...FIRMS_CONFIDENCE_MODES], ['all', 'nominal', 'high']);
+  assert.equal(normalizeConfidenceMode(' High '), 'high');
+  assert.equal(normalizeConfidenceMode('nominal'), 'nominal');
+  assert.equal(normalizeConfidenceMode('low'), null);
+  assert.equal(normalizeConfidenceMode(0.9), null);
+  assert.equal(normalizeConfidenceMode(undefined), null);
+});
+
+test('a partial filter patches the current one and invalid fields keep their value', () => {
+  assert.deepEqual(normalizeFireFilter(), DEFAULT_FIRE_FILTER);
+  assert.deepEqual(normalizeFireFilter({ minFrp: 20 }), {
+    minFrp: 20,
+    confidence: 'all',
+  });
+  assert.deepEqual(
+    normalizeFireFilter(
+      { confidence: 'high' },
+      { minFrp: 50, confidence: 'all' },
+    ),
+    { minFrp: 50, confidence: 'high' },
+  );
+  assert.deepEqual(
+    normalizeFireFilter(
+      { minFrp: 'nope', confidence: 'medium' },
+      { minFrp: 50, confidence: 'nominal' },
+    ),
+    { minFrp: 50, confidence: 'nominal' },
+  );
+  assert.equal(isDefaultFireFilter(DEFAULT_FIRE_FILTER), true);
+  assert.equal(isDefaultFireFilter({ minFrp: 0, confidence: 'all' }), true);
+  assert.equal(isDefaultFireFilter({ minFrp: 1, confidence: 'all' }), false);
+  assert.equal(isDefaultFireFilter({ minFrp: 0, confidence: 'high' }), false);
+});
+
+test('the filter keeps a fire at or above the floor and at or above the confidence mode', () => {
+  const low = { frp: 864, confidence: 0.3 };
+  const nominal = { frp: 20, confidence: 0.6 };
+  const high = { frp: 2, confidence: 0.9 };
+  assert.equal(firePassesFilter(low), true, 'default shows everything');
+  assert.equal(
+    firePassesFilter(nominal, { minFrp: 20, confidence: 'all' }),
+    true,
+  );
+  assert.equal(
+    firePassesFilter(nominal, { minFrp: 21, confidence: 'all' }),
+    false,
+  );
+  assert.equal(
+    firePassesFilter(low, { minFrp: 0, confidence: 'nominal' }),
+    false,
+  );
+  assert.equal(
+    firePassesFilter(nominal, { minFrp: 0, confidence: 'nominal' }),
+    true,
+  );
+  assert.equal(
+    firePassesFilter(high, { minFrp: 0, confidence: 'nominal' }),
+    true,
+  );
+  assert.equal(
+    firePassesFilter(nominal, { minFrp: 0, confidence: 'high' }),
+    false,
+  );
+  assert.equal(firePassesFilter(high, { minFrp: 0, confidence: 'high' }), true);
+  assert.equal(
+    firePassesFilter(high, { minFrp: 5, confidence: 'high' }),
+    false,
+  );
+  // Missing numbers read as 0, never as a pass-through.
+  assert.equal(firePassesFilter({}, { minFrp: 1, confidence: 'all' }), false);
+  assert.equal(
+    firePassesFilter({ frp: 10 }, { minFrp: 0, confidence: 'nominal' }),
+    false,
+  );
+});
+
+test('filterFires returns the same array for the default filter and preserves order otherwise', () => {
+  const fires = [
+    { frp: 864, confidence: 0.3 },
+    { frp: 20, confidence: 0.6 },
+    { frp: 2, confidence: 0.9 },
+    { frp: 120, confidence: 0.9 },
+  ];
+  assert.equal(filterFires(fires), fires);
+  assert.equal(filterFires(fires, { minFrp: 0, confidence: 'all' }), fires);
+  assert.deepEqual(
+    filterFires(fires, { minFrp: 20, confidence: 'all' }).map((f) => f.frp),
+    [864, 20, 120],
+  );
+  assert.deepEqual(
+    filterFires(fires, { minFrp: 0, confidence: 'high' }).map((f) => f.frp),
+    [2, 120],
+  );
+  assert.deepEqual(
+    filterFires(fires, { minFrp: 100, confidence: 'nominal' }).map(
+      (f) => f.frp,
+    ),
+    [120],
+  );
+  assert.deepEqual(filterFires(null, { minFrp: 1, confidence: 'all' }), []);
+});

src/data/firmsInteraction.test.mjs

@@ -15,6 +15,7 @@ import { WORLD_FOCUS_REQUEST_EVENT } from '../worldFocus.js';
 import { readLayerSource } from '../testSupport/readLayerSource.mjs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { HEAT_REBUILD_MS } from '../layers/firms/policy.js';
 
 const LAYER_SOURCE = readLayerSource(
   path.join(path.dirname(fileURLToPath(import.meta.url)), 'firmsHeatmap.js'),
@@ -392,3 +393,153 @@ test('disable cancels a pending source and a late response cannot repopulate the
     assert.equal(h.layer.getStats().loading, false);
   } finally { h.layer.destroy(h.viewer); h.cleanup(); }
 });
+
+test('the heatmap is preloaded under the markers before the first zoom-out', (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] });
+  const priorDocument = globalThis.document;
+  globalThis.document = {
+    createElement: () => ({
+      getContext: () => ({
+        createImageData: (w, hh) => ({ data: new Uint8ClampedArray(w * hh * 4) }),
+        putImageData() {},
+        createRadialGradient: () => ({ addColorStop() {} }),
+        fillRect() {},
+      }),
+      toDataURL: () => 'data:image/png;base64,AAAA',
+    }),
+  };
+  const h = harness({
+    withDataSource: true,
+    cameraPosition: Cesium.Cartesian3.fromDegrees(-98, 30, 1_000_000),
+  });
+  h.viewer.camera = { positionCartographic: { height: 1_000_000 } };
+  h.viewer.scene.primitives = { add() {}, remove() {}, raiseToTop() {}, contains: () => true };
+  h.viewer.scene.frameState = { mode: Cesium.SceneMode.SCENE3D };
+  const added = [];
+  try {
+    h.layer.attachShellServices({
+      imageryHost: () => ({
+        kind: 'globe',
+        collection: {
+          addImageryProvider: (provider) => {
+            const layer = { provider, show: true, alpha: 1 };
+            added.push(layer);
+            return layer;
+          },
+          remove() {},
+          raiseToTop() {},
+        },
+      }),
+    });
+    h.layer._renderLodForTest('close');
+    assert.equal(added.length, 0, 'the markers paint first; the build trails');
+    t.mock.timers.tick(HEAT_REBUILD_MS);
+    assert.equal(added.length, 1, 'then the heatmap is draped');
+    assert.equal(added[0].alpha, 0, 'invisible until the hand-off');
+    assert.equal(added[0].show, true, 'but mapped onto the globe tiles');
+  } finally {
+    h.layer.destroy(h.viewer);
+    h.cleanup();
+    if (priorDocument === undefined) delete globalThis.document;
+    else globalThis.document = priorDocument;
+  }
+});
+
+test('far zoom drapes one heatmap and the hand-off cross-fades it with the markers', () => {
+  // A canvas stub for the heat drape and the detection glow sprites.
+  const priorDocument = globalThis.document;
+  const restoreDocument = () => {
+    if (priorDocument === undefined) delete globalThis.document;
+    else globalThis.document = priorDocument;
+  };
+  globalThis.document = {
+    createElement: () => ({
+      getContext: () => ({
+        createImageData: (w, hh) => ({
+          data: new Uint8ClampedArray(w * hh * 4),
+        }),
+        putImageData() {},
+        createRadialGradient: () => ({ addColorStop() {} }),
+        fillRect() {},
+      }),
+      toDataURL: () => 'data:image/png;base64,AAAA',
+    }),
+  };
+  const h = harness({
+    fires: [makeFire(), makeFire({ index: 8, lat: 30.6, lon: -98.3, frp: 12 })],
+    withDataSource: true,
+    cameraPosition: Cesium.Cartesian3.fromDegrees(-98, 30, 12_000_000),
+  });
+  const added = [];
+  const removed = [];
+  let markers = null;
+  // The fade reads the camera height; the cull reads scene.camera.
+  const setHeight = (height) => {
+    h.viewer.camera = { positionCartographic: { height } };
+  };
+  setHeight(12_000_000);
+  h.viewer.scene.primitives = {
+    add(primitive) {
+      markers = primitive;
+    },
+    remove() {},
+    raiseToTop() {},
+    contains: () => true,
+  };
+  h.viewer.scene.frameState = { mode: Cesium.SceneMode.SCENE3D };
+  try {
+    const collection = {
+      addImageryProvider: (provider) => {
+        const layer = { provider, show: true, alpha: 1 };
+        added.push(layer);
+        return layer;
+      },
+      remove: (layer, destroy) => removed.push({ layer, destroy }),
+      raiseToTop() {},
+    };
+    h.layer.attachShellServices({
+      imageryHost: () => ({ kind: 'globe', collection }),
+    });
+    h.layer._renderLodForTest('global');
+    assert.equal(added.length, 1, 'one heat imagery layer');
+    assert.equal(added[0].show, true);
+    assert.equal(added[0].alpha, 1);
+    assert.equal(h.layer._entityCountForTest(), 0, 'no rectangle entities');
+    assert.ok(h.published.length > 0, 'the far band still paints cards');
+    assert.equal(markers.length, 2, 'the markers are built under the heatmap');
+    assert.equal(markers.show, false, 'and hidden while the heatmap is whole');
+
+    h.layer._renderLodForTest('regional');
+    assert.equal(added.length, 1, 'switching far bands reuses the raster');
+
+    setHeight(1_000_000);
+    h.layer._renderLodForTest('close');
+    assert.equal(added.length, 1, 'the markers band keeps the same heat layer');
+    assert.equal(added[0].show, true, 'still mapped onto the globe tiles');
+    assert.equal(added[0].alpha, 0, 'faded out under the markers');
+    assert.equal(markers.show, true);
+    assert.equal(markers.get(0).color.alpha, 1);
+
+    // Mid hand-off both are drawn, half each, in either band.
+    setHeight(4_500_000);
+    h.layer._applyHandoffFadeForTest();
+    assert.equal(added[0].alpha, 0.5);
+    assert.equal(markers.show, true);
+    assert.equal(markers.get(0).color.alpha, 0.5);
+    h.layer._renderLodForTest('regional');
+    assert.equal(added[0].alpha, 0.5);
+    assert.equal(markers.get(1).color.alpha, 0.5, 'rebuilt markers get the fade');
+
+    h.layer.disable();
+    assert.equal(added[0].show, false, 'disable hides the heatmap');
+
+    h.layer.destroy(h.viewer);
+    assert.deepEqual(
+      removed.map((entry) => [entry.layer, entry.destroy]),
+      [[added[0], true]],
+    );
+  } finally {
+    h.cleanup();
+    restoreDocument();
+  }
+});

src/data/firmsLabels.js

@@ -4,6 +4,8 @@
  * dedicated card canvas moved into the shared world-overlay host.
  */
 
+import { FRP_RAMP, hexToRgb } from './firmsIntensity.js';
+
 /** Shipped ambient FIRMS card ceiling. Selected fires bypass this cohort. */
 export const FIRMS_AMBIENT_COHORT_LIMIT = 18;
 export const FIRMS_OVERLAY_SOURCE_ID = 'firms';
@@ -23,20 +25,23 @@ export function fireDetectionKey(fire) {
   return `firms:${lat}:${lon}:${acq}:${source}`;
 }
 
-/** Severity accent palette — matches the FIRMS glow-sprite color stops. */
-const ACCENT_RGB = Object.freeze({
-  red: '224, 82, 82',
-  orange: '240, 178, 62',
-  yellow: '244, 227, 108',
-});
+/**
+ * Severity accent palette — the FIRMS glow-sprite color stops (the six-stop
+ * FRP ramp in firmsIntensity.js) as "r, g, b" strings for card accents.
+ */
+const ACCENT_RGB = Object.freeze(
+  Object.fromEntries(
+    FRP_RAMP.map((stop) => [stop.name, hexToRgb(stop.hex).join(', ')]),
+  ),
+);
 
 /**
- * Severity stop name → "r, g, b" accent string (defaults to yellow).
- * @param {string} stopName - 'red' | 'orange' | 'yellow'.
+ * Severity stop name → "r, g, b" accent string (defaults to the weakest stop).
+ * @param {string} stopName - A FRP_RAMP stop name ('ember' … 'white-hot').
  * @returns {string}
  */
 export function accentForSeverity(stopName) {
-  return ACCENT_RGB[stopName] || ACCENT_RGB.yellow;
+  return ACCENT_RGB[stopName] || ACCENT_RGB[FRP_RAMP[0].name];
 }
 
 /**

src/data/firmsLabels.test.mjs

@@ -9,11 +9,16 @@ import {
   formatFrpMw,
 } from './firmsLabels.js';
 
-test('FIRMS formatting helpers retain the shipped severity palette', () => {
-  assert.equal(accentForSeverity('red'), '224, 82, 82');
-  assert.equal(accentForSeverity('orange'), '240, 178, 62');
-  assert.equal(accentForSeverity('yellow'), '244, 227, 108');
-  assert.equal(accentForSeverity('chartreuse'), accentForSeverity('yellow'));
+test('FIRMS card accents are the six FRP ramp stops, weakest as the fallback', () => {
+  // Ember #9e2a1b … white-hot #fff3b0, lightness rising with power.
+  assert.equal(accentForSeverity('ember'), '158, 42, 27');
+  assert.equal(accentForSeverity('red'), '210, 64, 31');
+  assert.equal(accentForSeverity('flame'), '240, 106, 40');
+  assert.equal(accentForSeverity('orange'), '251, 154, 46');
+  assert.equal(accentForSeverity('gold'), '253, 200, 74');
+  assert.equal(accentForSeverity('white-hot'), '255, 243, 176');
+  assert.equal(accentForSeverity('blue'), accentForSeverity('ember'));
+  assert.equal(accentForSeverity('chartreuse'), accentForSeverity('ember'));
 });
 
 test('FIRMS power that rounds to 10 MW drops the decimal', () => {

src/data/fixtures/README.md

@@ -1,5 +1,10 @@
 # Test fixtures
 
+- `photon-moscow-search.json` - Photon responses for `Москва`, captured
+  2026-11-05 with and without a proximity bias near the Tajikistan namesake.
+  The fixture is trimmed to the fields the keyless geocoder consumes and is
+  used only by offline search tests. Data from OpenStreetMap contributors,
+  ODbL 1.0 (https://www.openstreetmap.org/copyright).
 - `tomtom-flow-austin-12-935-1686.pbf` — one real TomTom traffic-flow vector
   tile (Mapbox Vector Tile protobuf, layer `"Traffic flow"`), downtown Austin
   z12 x935 y1686, captured 2026-07-16 from

src/data/fixtures/photon-moscow-search.json

@@ -0,0 +1,110 @@
+{
+  "biased": {
+    "features": [
+      {
+        "geometry": {
+          "type": "Point",
+          "coordinates": [71.8339931, 38.948412]
+        },
+        "properties": {
+          "name": "Москва",
+          "country": "Тоҷикистон"
+        }
+      },
+      {
+        "geometry": {
+          "type": "Point",
+          "coordinates": [37.6063916, 55.625578]
+        },
+        "properties": {
+          "name": "Москва",
+          "country": "Россия"
+        }
+      },
+      {
+        "geometry": {
+          "type": "Point",
+          "coordinates": [37.6174782, 55.7505412]
+        },
+        "properties": {
+          "name": "Москва",
+          "country": "Россия"
+        }
+      },
+      {
+        "geometry": {
+          "type": "Point",
+          "coordinates": [37.0536908, 55.7098009]
+        },
+        "properties": {
+          "name": "Москва",
+          "country": "Россия"
+        }
+      },
+      {
+        "geometry": {
+          "type": "Point",
+          "coordinates": [32.163334, 56.917778]
+        },
+        "properties": {
+          "name": "Москва",
+          "country": "Россия"
+        }
+      }
+    ]
+  },
+  "unbiased": {
+    "features": [
+      {
+        "geometry": {
+          "type": "Point",
+          "coordinates": [37.6063916, 55.625578]
+        },
+        "properties": {
+          "name": "Москва",
+          "country": "Россия"
+        }
+      },
+      {
+        "geometry": {
+          "type": "Point",
+          "coordinates": [37.6174782, 55.7505412]
+        },
+        "properties": {
+          "name": "Москва",
+          "country": "Россия"
+        }
+      },
+      {
+        "geometry": {
+          "type": "Point",
+          "coordinates": [37.0536908, 55.7098009]
+        },
+        "properties": {
+          "name": "Москва",
+          "country": "Россия"
+        }
+      },
+      {
+        "geometry": {
+          "type": "Point",
+          "coordinates": [32.163334, 56.917778]
+        },
+        "properties": {
+          "name": "Москва",
+          "country": "Россия"
+        }
+      },
+      {
+        "geometry": {
+          "type": "Point",
+          "coordinates": [71.8339931, 38.948412]
+        },
+        "properties": {
+          "name": "Москва",
+          "country": "Тоҷикистон"
+        }
+      }
+    ]
+  }
+}

src/data/infrastructure.test.mjs

@@ -82,7 +82,7 @@ test('infrastructure factory preserves identity and creates independent state wi
 
 test('dataset URLs still name the complete bundled sources', () => {
   for (const [file, count] of [
-    ['datacenters', 4351],
+    ['datacenters', 4352],
     ['dams', 704],
   ]) {
     const lines = readFileSync(

src/data/layerState.js

@@ -298,12 +298,46 @@ function satelliteFilterOption() {
 }
 
 const OPTION_GROUPS = Object.freeze({
+  // Active Fires intensity filter (HAL-676). `minFrp` is whole megawatts on
+  // the codec side; the panel's log slider rounds to it. Both default to
+  // "show everything": many of the strongest fires are rated low confidence.
+  // The bounds and modes mirror MIN_FRP_MW_MAX / FIRMS_CONFIDENCE_MODES in
+  // firmsIntensity.js (pinned by layerState.test); spelled out here because
+  // this file runs in isolation in the token-ledger tests.
+  'local-firms': Object.freeze([
+    boundedIntegerOption('minFrp', 'f', 0, { min: 0, max: 10000 }),
+    enumOption('confidence', 'c', 'all', ['all', 'nominal', 'high'], {
+      all: 'a',
+      nominal: 'n',
+      high: 'h',
+    }),
+  ]),
+  'wildlife-sightings': Object.freeze([
+    booleanOption('confirmed', 'c', false),
+    enumOption(
+      'taxa',
+      't',
+      'all',
+      ['all', 'Aves', 'Mammalia', 'whales', 'Insecta', 'Plantae'],
+      {
+        all: 'a',
+        Aves: 'b',
+        Mammalia: 'm',
+        whales: 'w',
+        Insecta: 'i',
+        Plantae: 'p',
+      },
+    ),
+  ]),
   traffic: Object.freeze([
     enumOption('roadMode', 'r', null, ['tomtom', 'osm', 'hybrid'], {
       tomtom: 't',
       osm: 'o',
       hybrid: 'h',
     }),
+    // Street Traffic row toggles: flow-colored road lines, moving dots.
+    booleanOption('lines', 'l', false),
+    booleanOption('dots', 'd', true),
   ]),
   'weather-lightning': Object.freeze([
     enumOption('opacity', 'o', 'strong', ['light', 'strong'], {
@@ -626,7 +660,12 @@ export const LAYER_STATE_REGISTRY = Object.freeze([
     token: 'd',
     disposition: 'enabled-only',
   }),
-  Object.freeze({ id: 'local-firms', token: 'w', disposition: 'enabled-only' }),
+  Object.freeze({
+    id: 'local-firms',
+    token: 'w',
+    disposition: 'enabled+options',
+    optionOwner: 'local-firms',
+  }),
   Object.freeze({
     id: 'military',
     token: 'm',
@@ -714,6 +753,12 @@ export const LAYER_STATE_REGISTRY = Object.freeze([
     disposition: 'enabled+options',
     optionOwner: 'weather-satellite',
   }),
+  Object.freeze({
+    id: 'wildlife-sightings',
+    token: '9',
+    disposition: 'enabled+options',
+    optionOwner: 'wildlife-sightings',
+  }),
   Object.freeze({
     id: 'wind',
     token: 'k',

src/data/layerState.test.mjs

@@ -29,6 +29,7 @@ import radioLayer from './radio.js';
 import { stampInitialShareGesture } from '../navigationPolicy.js';
 import { MAX_SINCE_DAYS } from '../layers/streetLevel/policy.js';
 import { SINCE_STOPS } from '../ui/streetLevelPresentation.js';
+import { FIRMS_CONFIDENCE_MODES, MIN_FRP_MW_MAX } from './firmsIntensity.js';
 
 function deferred() {
   let resolve;
@@ -202,8 +203,8 @@ function encode(state) {
 
 test('production registry is exact, canonical, and rejects incomplete contracts', async () => {
   assert.equal(validateLayerStateRegistry(), true);
-  assert.equal(REGISTERED_LAYER_IDS.length, 35);
-  assert.equal(new Set(REGISTERED_LAYER_IDS).size, 35);
+  assert.equal(REGISTERED_LAYER_IDS.length, 36);
+  assert.equal(new Set(REGISTERED_LAYER_IDS).size, 36);
   assert.ok(REGISTERED_LAYER_IDS.includes('transit'));
   assert.deepEqual(REGISTERED_LAYER_IDS, [...REGISTERED_LAYER_IDS].sort());
   assert.deepEqual(LEGACY_LAYER_STATE_TOKENS, {
@@ -242,7 +243,7 @@ test('production registry is exact, canonical, and rejects incomplete contracts'
   for (const [id, token] of Object.entries(LEGACY_LAYER_STATE_TOKENS)) {
     assert.equal(LAYER_STATE_TOKEN_RESERVATIONS[id], token);
   }
-  assert.equal(nextLayerStateToken(), '9');
+  assert.equal(nextLayerStateToken(), '00');
   assert.equal(
     nextLayerStateToken({
       ...LAYER_STATE_TOKEN_RESERVATIONS,
@@ -305,8 +306,8 @@ test('production registry is exact, canonical, and rejects incomplete contracts'
   assert.equal(
     validateLayerStateAllocations(LAYER_STATE_TOKEN_RESERVATIONS, {
       ...LAYER_STATE_TOKEN_RESERVATIONS,
-      future: '9',
-      next: '00',
+      future: '00',
+      next: '01',
     }),
     true,
   );
@@ -314,12 +315,13 @@ test('production registry is exact, canonical, and rejects incomplete contracts'
     () =>
       validateLayerStateAllocations(LAYER_STATE_TOKEN_RESERVATIONS, {
         ...LAYER_STATE_TOKEN_RESERVATIONS,
-        future: '00',
+        future: '01',
       }),
-    /next free token 9/,
+    /next free token 00/,
   );
   const beforeLastDigit = { ...digitsExhausted };
   delete beforeLastDigit['prior-9'];
+  delete beforeLastDigit['wildlife-sightings'];
   assert.equal(
     validateLayerStateAllocations(beforeLastDigit, {
       ...beforeLastDigit,
@@ -2694,6 +2696,32 @@ test('the recent-imagery split is share-link only: never stored locally, and a s
   );
 });
 
+test('wildlife confirmed and every taxa preset round-trip through the full share codec', () => {
+  assert.equal(
+    LAYER_STATE_REGISTRY.find(({ id }) => id === 'wildlife-sightings').token,
+    '9',
+  );
+  for (const taxa of [
+    'all',
+    'Aves',
+    'Mammalia',
+    'whales',
+    'Insecta',
+    'Plantae',
+  ]) {
+    const state = normalizeLayerState({
+      enabledLayerIds: ['wildlife-sightings'],
+      options: { 'wildlife-sightings': { confirmed: true, taxa } },
+    });
+    const encoded = encode(state);
+    assert.doesNotMatch(encoded, /undefined/);
+    assert.deepEqual(
+      decodeLayerStateParams(new URLSearchParams(encoded)),
+      state,
+    );
+  }
+});
+
 test('drone restrictions uses digit 8 without colliding with fire perimeters', () => {
   const decoded = decodeLayerStateParams(new URLSearchParams('v=2&l=8.2'));
   assert.deepEqual(decoded.enabledLayerIds, [
@@ -3007,9 +3035,89 @@ test('Clear All cancels a saved restore still waiting to start', async () => {
   gate.resolve();
   const results = await restore;
   for (const id of ['earthquakes', 'flights']) {
-    assert.equal(results.find((result) => result.layerId === id).succeeded, false);
+    assert.equal(
+      results.find((result) => result.layerId === id).succeeded,
+      false,
+    );
   }
   assert.deepEqual([...manager.getEnabledLayerIds()], []);
   assert.equal(enabledLayerParam(sink), '');
   coordinator.destroy();
 });
+
+/** Active Fires options decoded from a v2 link with these `lo` assignments. */
+function firmsOptions(lo) {
+  const params = new URLSearchParams([
+    ['v', '2'],
+    ['l', 'w'],
+  ]);
+  if (lo) params.set('lo', lo);
+  return decodeLayerStateParams(params).options['local-firms'];
+}
+
+test('Active Fires: the intensity filter rides share token w and round-trips', () => {
+  const state = createDefaultLayerState();
+  assert.deepEqual(state.options['local-firms'], {
+    minFrp: 0,
+    confidence: 'all',
+  });
+  state.enabledLayerIds = ['local-firms'];
+  state.options['local-firms'] = { minFrp: 20, confidence: 'high' };
+  const encoded = encode(state);
+  assert.equal(new URLSearchParams(encoded).get('l'), 'w');
+  // Other owners write their own explicit defaults into `lo` too (flights 3D,
+  // wind overlay); the fire assignments ride beside them.
+  const assignments = new URLSearchParams(encoded).get('lo').split('_');
+  assert.ok(assignments.includes('w.f.20'), assignments.join(' '));
+  assert.ok(assignments.includes('w.c.h'), assignments.join(' '));
+  const decoded = decodeLayerStateParams(new URLSearchParams(encoded));
+  assert.deepEqual(decoded.options['local-firms'], {
+    minFrp: 20,
+    confidence: 'high',
+  });
+  assert.deepEqual(
+    parseStoredLayerState(serializeStoredLayerState(state)).options[
+      'local-firms'
+    ],
+    state.options['local-firms'],
+  );
+  // Defaults are omitted from the link: a plain `l=w` is "show everything".
+  const plain = createDefaultLayerState();
+  plain.enabledLayerIds = ['local-firms'];
+  assert.equal(
+    new URLSearchParams(encode(plain))
+      .get('lo')
+      .split('_')
+      .filter((assignment) => assignment.startsWith('w.')).length,
+    0,
+  );
+  assert.deepEqual(firmsOptions(''), { minFrp: 0, confidence: 'all' });
+});
+
+test('Active Fires: the codec accepts whole megawatts in bounds and the three confidence codes', () => {
+  // The codec spells its bounds out (it runs in isolation in the ledger
+  // tests); they must stay the layer's.
+  assert.equal(MIN_FRP_MW_MAX, 10000);
+  assert.deepEqual([...FIRMS_CONFIDENCE_MODES], ['all', 'nominal', 'high']);
+  assert.equal(firmsOptions('w.f.300').minFrp, 300);
+  assert.equal(firmsOptions('w.f.10000').minFrp, 10000);
+  assert.equal(firmsOptions('w.f.10001').minFrp, 0, 'out of bounds → default');
+  assert.equal(firmsOptions('w.f.-5').minFrp, 0);
+  assert.equal(
+    firmsOptions('w.f.2.5').minFrp,
+    0,
+    'a third segment is rejected',
+  );
+  assert.equal(firmsOptions('w.c.a').confidence, 'all');
+  assert.equal(firmsOptions('w.c.n').confidence, 'nominal');
+  assert.equal(firmsOptions('w.c.h').confidence, 'high');
+  assert.equal(
+    firmsOptions('w.c.x').confidence,
+    'all',
+    'unknown code → default',
+  );
+  assert.deepEqual(firmsOptions('w.c.n_w.f.5'), {
+    minFrp: 5,
+    confidence: 'nominal',
+  });
+});

src/data/layerStateTokenLedger.test.mjs

@@ -97,6 +97,10 @@ function withPublishedBase(
   }
 }
 
+const preWildlifeRows = reservationRows.filter(
+  ([id]) => id !== 'wildlife-sightings',
+);
+
 function writeCodecFixture(cwd, rows, entries) {
   const providerCodec = path.join(cwd, 'src/data/idSwitches.js');
   mkdirSync(path.dirname(providerCodec), { recursive: true });
@@ -104,7 +108,12 @@ function writeCodecFixture(cwd, rows, entries) {
     providerCodec,
     readFileSync(new URL('./idSwitches.js', import.meta.url)),
   );
-  const source = readFileSync(CODEC_SOURCE_PATH, 'utf8');
+  let source = readFileSync(CODEC_SOURCE_PATH, 'utf8');
+  if (!rows.some(([id]) => id === 'wildlife-sightings'))
+    source = source.replace(
+      /  Object\.freeze\(\{\s*id: 'wildlife-sightings',[\s\S]*?\}\),\n/,
+      '',
+    );
   const registryEnd = ']);\n\nexport const REGISTERED_LAYER_IDS';
   assert.equal(source.split(registryEnd).length, 2);
   const additions = entries
@@ -128,7 +137,7 @@ test('reservation ledger is complete, pinned, and rejects duplicate or malformed
     { ...parseLayerStateTokenReservations(reservationRows) },
     { ...LAYER_STATE_TOKEN_RESERVATIONS },
   );
-  assert.equal(Object.keys(LAYER_STATE_TOKEN_RESERVATIONS).length, 35);
+  assert.equal(Object.keys(LAYER_STATE_TOKEN_RESERVATIONS).length, 36);
   assert.deepEqual(
     { ...LAYER_STATE_TOKEN_RESERVATIONS },
     {
@@ -140,6 +149,7 @@ test('reservation ledger is complete, pinned, and rejects duplicate or malformed
       'sea-marks': '6',
       'ski-pistes': '7',
       'drone-airspace': '8',
+      'wildlife-sightings': '9',
     },
   );
   assert.throws(
@@ -165,9 +175,9 @@ test('reservation ledger is complete, pinned, and rejects duplicate or malformed
     /Duplicate layer-state token reservation/,
   );
   assert.equal(
-    parseLayerStateTokenReservations([...reservationRows, ['future', '9']])
+    parseLayerStateTokenReservations([...reservationRows, ['future', '00']])
       .future,
-    '9',
+    '00',
   );
   assert.throws(
     () =>
@@ -185,7 +195,7 @@ test('reservation ledger is complete, pinned, and rejects duplicate or malformed
 
 test('published retired digits and competing PRs advance the merge-time allocation', () => {
   withPublishedBase(
-    { rows: [...reservationRows, ['retired-layer', '9']] },
+    { rows: [...preWildlifeRows, ['retired-layer', '9']] },
     (cwd) => {
       const published = readPublishedLayerStateReservations('HEAD', cwd);
       assert.equal(nextLayerStateToken(published), '00');
@@ -217,7 +227,7 @@ test('published retired digits and competing PRs advance the merge-time allocati
 });
 
 test('PR B manually replaces provisional 9 with 00 after PR A publishes 9', () => {
-  withPublishedBase({ rows: [...reservationRows, ['pr-a', '9']] }, (cwd) => {
+  withPublishedBase({ rows: [...preWildlifeRows, ['pr-a', '9']] }, (cwd) => {
     mkdirSync(path.join(cwd, 'scripts'));
     const fixtureChecker = path.join(
       cwd,
@@ -238,7 +248,7 @@ test('PR B manually replaces provisional 9 with 00 after PR A publishes 9', () =
 
     writeCodecFixture(
       cwd,
-      [...reservationRows, ['pr-b', '9']],
+      [...preWildlifeRows, ['pr-b', '9']],
       [{ id: 'pr-b', token: '9' }],
     );
     const beforeRebase = runCheck();
@@ -247,7 +257,7 @@ test('PR B manually replaces provisional 9 with 00 after PR A publishes 9', () =
 
     writeCodecFixture(
       cwd,
-      [...reservationRows, ['pr-a', '9'], ['pr-b', '9']],
+      [...preWildlifeRows, ['pr-a', '9'], ['pr-b', '9']],
       [
         { id: 'pr-a', token: '9' },
         { id: 'pr-b', token: '9' },
@@ -259,7 +269,7 @@ test('PR B manually replaces provisional 9 with 00 after PR A publishes 9', () =
 
     const published = readPublishedLayerStateReservations('HEAD', cwd);
     assert.equal(nextLayerStateToken(published), '00');
-    const validBaselineRows = [...reservationRows, ['pr-a', '9']];
+    const validBaselineRows = [...preWildlifeRows, ['pr-a', '9']];
     writeCodecFixture(cwd, validBaselineRows, [{ id: 'pr-a', token: '9' }]);
     const helper = spawnSync(
       process.execPath,
@@ -275,7 +285,7 @@ test('PR B manually replaces provisional 9 with 00 after PR A publishes 9', () =
     );
     writeCodecFixture(
       cwd,
-      [...reservationRows, ['pr-a', '9'], ['pr-b', '00']],
+      [...preWildlifeRows, ['pr-a', '9'], ['pr-b', '00']],
       [
         { id: 'pr-a', token: '9' },
         { id: 'pr-b', token: '00' },
@@ -290,7 +300,7 @@ test('PR B manually replaces provisional 9 with 00 after PR A publishes 9', () =
 test('allocation batches cross the last digit and base-36 pair boundaries in order', () => {
   const digitRows = [...'9'].map((digit) => [`retired-${digit}`, digit]);
   const allDigits = parseLayerStateTokenReservations([
-    ...reservationRows,
+    ...preWildlifeRows,
     ...digitRows,
   ]);
   const beforeNine = { ...allDigits };
@@ -349,7 +359,7 @@ test('an isolated valid two-character fixture round-trips an l field beyond the
       token,
     }));
     const fixtureRows = [
-      ...reservationRows,
+      ...preWildlifeRows,
       ...priorDigits,
       ...fixtureLayers.map(({ id, token }) => [id, token]),
     ];
@@ -358,13 +368,13 @@ test('an isolated valid two-character fixture round-trips an l field beyond the
     assert.equal(codec.validateLayerStateRegistry(), true);
     assert.equal(
       nextLayerStateToken(
-        parseLayerStateTokenReservations([...reservationRows, ...priorDigits]),
+        parseLayerStateTokenReservations([...preWildlifeRows, ...priorDigits]),
       ),
       '00',
     );
     assert.equal(
       validateLayerStateAllocations(
-        LAYER_STATE_TOKEN_RESERVATIONS,
+        parseLayerStateTokenReservations(preWildlifeRows),
         codec.LAYER_STATE_TOKEN_RESERVATIONS,
       ),
       true,
@@ -395,7 +405,7 @@ test('checker reads a complete future base ledger and rejects retired-token reus
     },
     (cwd) => {
       const published = readPublishedLayerStateReservations('HEAD', cwd);
-      assert.equal(Object.keys(published).length, 36);
+      assert.equal(Object.keys(published).length, 37);
       assert.equal(published['retired-layer'], '00');
       assert.throws(
         () =>

src/data/layerStateTokenReservations.json

@@ -33,5 +33,6 @@
   ["weather-lightning", "l"],
   ["weather-radar", "v"],
   ["weather-satellite", "o"],
+  ["wildlife-sightings", "9"],
   ["wind", "k"]
 ]

src/data/localGeojson.test.mjs

@@ -90,6 +90,8 @@ async function createRealLocalLayerHarness({
   globalThis.window = { dispatchEvent() {} };
   let sampleHeightImpl = sampleHeight;
   const sampleCalls = { count: 0 };
+  // The camera frustum, reduced to the one answer ground sampling asks of it.
+  let baseVisibility = Cesium.Intersect.INSIDE;
   const overlayHost = {
     setVisible: (...args) => hostCalls.push(['visible', ...args]),
     setEntries: (...args) => hostCalls.push(['entries', ...args]),
@@ -107,7 +109,19 @@ async function createRealLocalLayerHarness({
     },
     camera: {
       positionWC: Cesium.Cartesian3.fromDegrees(-97.695, 30.205, 100_000),
-      frustum: { fov: Math.PI / 3 },
+      directionWC: new Cesium.Cartesian3(),
+      upWC: new Cesium.Cartesian3(),
+      frustum: {
+        fov: Math.PI / 3,
+        // No planes: everything is in view. One plane no point satisfies:
+        // nothing is.
+        computeCullingVolume: () => ({
+          planes:
+            baseVisibility === Cesium.Intersect.OUTSIDE
+              ? [new Cesium.Cartesian4(0, 0, 0, -1)]
+              : [],
+        }),
+      },
       moveEnd,
       flyTo() {},
     },
@@ -151,6 +165,10 @@ async function createRealLocalLayerHarness({
     sampleCalls,
     /** Swap scene.sampleHeight mid-test (e.g. tiles finally arrive). */
     setSampleHeight(next) { sampleHeightImpl = next; },
+    /** Put the feature's base inside (true) or outside the camera frustum. */
+    setBaseInView(inView) {
+      baseVisibility = inView ? Cesium.Intersect.INSIDE : Cesium.Intersect.OUTSIDE;
+    },
     cleanup() {
       if (originalWindow === undefined) delete globalThis.window;
       else globalThis.window = originalWindow;
@@ -736,6 +754,136 @@ test('ground sampling waits for visible globe tiles before caching a height', as
   assert.ok(Math.abs(baseHeightM(env) - 117) < 0.01);
 });
 
+test('an unseen base is not sampled and arms no retry until it is in view', async (t) => {
+  // Out of view the scene has no surface under the base, so the depth sample
+  // would pass through the Earth (about -6,344 km) and fail on every retry.
+  const env = await createRealLocalLayerHarness({
+    sampleHeightSupported: true, sampleHeight: () => 117,
+  });
+  _resetRenderGovernorForTest();
+  const governorScene = { renders: 0, requestRender() { this.renders += 1; } };
+  installRenderGovernor({ scene: governorScene });
+  governorScene.renders = 0; // discard the governor's own install settling frame
+  t.mock.timers.enable({ apis: ['setTimeout'] });
+  const clock = installFakeClock(t);
+  t.after(() => {
+    env.layer.destroy(env.viewer);
+    env.cleanup();
+    _resetRenderGovernorForTest();
+  });
+  env.viewer.scene.globe = { show: true, tilesLoaded: true, getHeight: () => 117 };
+  setCameraAltitude(env, 20_000);
+  env.setBaseInView(false);
+  runArmedRetryChain(env, t, clock, 5);
+  assert.equal(env.sampleCalls.count, 0, 'an off-screen base must not be sampled');
+  assert.equal(governorScene.renders, 0, 'an off-screen base must not keep a parked camera rendering');
+  assert.ok(Math.abs(baseHeightM(env)) < 0.01);
+
+  // In the frustum but over the horizon: 50 m up, about 67 km away.
+  env.setBaseInView(true);
+  env.viewer.camera.positionWC = Cesium.Cartesian3.fromDegrees(-97.0, 30.205, 50);
+  runArmedRetryChain(env, t, clock, 5);
+  assert.equal(env.sampleCalls.count, 0, 'a base over the horizon must not be sampled');
+  assert.equal(governorScene.renders, 0);
+
+  setCameraAltitude(env, 20_000);
+  env.preRender.raise();
+  assert.equal(env.sampleCalls.count, 1, 'the base is sampled on the first walk that sees it');
+  assert.ok(Math.abs(baseHeightM(env) - 117) < 0.01);
+});
+
+/**
+ * Give the harness a real Cesium camera `southM` metres south of the base at
+ * `cameraM` metres above the ellipsoid, looking at the base's ground at
+ * `groundM` (or directly away from it).
+ */
+function aimRealCamera(env, { groundM, cameraM, southM, away = false, fov = Math.PI / 3 }) {
+  const entity = env.dataSources[0].entities.values[0];
+  const base = Cesium.Cartographic.fromCartesian(entity.__localBaseCartesian);
+  const ground = Cesium.Cartesian3.fromRadians(base.longitude, base.latitude, groundM);
+  const position = Cesium.Cartesian3.fromRadians(
+    base.longitude,
+    base.latitude - southM / 6_371_000,
+    cameraM,
+  );
+  const direction = Cesium.Cartesian3.normalize(
+    away
+      ? Cesium.Cartesian3.subtract(position, ground, new Cesium.Cartesian3())
+      : Cesium.Cartesian3.subtract(ground, position, new Cesium.Cartesian3()),
+    new Cesium.Cartesian3(),
+  );
+  const right = Cesium.Cartesian3.normalize(
+    Cesium.Cartesian3.cross(
+      direction,
+      Cesium.Ellipsoid.WGS84.geodeticSurfaceNormal(position),
+      new Cesium.Cartesian3(),
+    ),
+    new Cesium.Cartesian3(),
+  );
+  const up = Cesium.Cartesian3.cross(right, direction, new Cesium.Cartesian3());
+  const frustum = new Cesium.PerspectiveFrustum({
+    fov,
+    aspectRatio: 800 / 600,
+    near: 1,
+    far: 1e8,
+  });
+  Object.assign(env.viewer.camera, {
+    positionWC: position,
+    directionWC: direction,
+    upWC: up,
+    frustum,
+  });
+  return frustum
+    .computeCullingVolume(position, direction, up)
+    .computeVisibility(new Cesium.BoundingSphere(entity.__localBaseCartesian, 1));
+}
+
+const loadedTerrain = (height) => ({ show: true, tilesLoaded: true, getHeight: () => height });
+const hiddenGlobe = { show: false, tilesLoaded: true, getHeight: () => undefined };
+
+for (const { label, globe, groundM, cameraM, southM, fov, baseOffScreen } of [
+  // The Dead Sea (about -430 m) under a hidden globe, seen steeply down
+  // through a narrow view: both 0 m and 9,000 m above it are off screen.
+  { label: 'hidden-globe depression', globe: hiddenGlobe, groundM: -430, cameraM: 20, southM: 180, fov: Math.PI / 12, baseOffScreen: true },
+  // 2,500 m terrain from 3 km away at a shallow angle: the ellipsoid-height
+  // base is far below the bottom of the screen.
+  { label: 'high ground with loaded terrain', globe: loadedTerrain(2_500), groundM: 2_500, cameraM: 3_500, southM: 3_000, baseOffScreen: true },
+  { label: 'high ground under a hidden globe', globe: hiddenGlobe, groundM: 2_500, cameraM: 3_500, southM: 3_000, baseOffScreen: true },
+  // A low-geoid coast (about -63 m near Mumbai) from a camera 50 m above the
+  // ellipsoid: the ellipsoidal horizon would hide the ground itself.
+  { label: 'ground below the ellipsoid', globe: loadedTerrain(-63), groundM: -63, cameraM: 50, southM: 2_000, baseOffScreen: false },
+]) {
+  test(`${label} in view is sampled`, async (t) => {
+    const env = await createRealLocalLayerHarness({
+      sampleHeightSupported: true, sampleHeight: () => groundM,
+    });
+    const clock = installFakeClock(t);
+    t.after(() => { env.layer.destroy(env.viewer); env.cleanup(); });
+    env.viewer.scene.globe = globe;
+    const baseVisibility = aimRealCamera(env, { groundM, cameraM, southM, fov });
+    if (baseOffScreen)
+      assert.equal(baseVisibility, Cesium.Intersect.OUTSIDE, 'precondition: the ellipsoid-height base is off screen');
+
+    clock.advance(2_100);
+    env.preRender.raise();
+    assert.equal(env.sampleCalls.count, 1, 'the ground in view is sampled');
+    assert.ok(Math.abs(baseHeightM(env) - groundM) < 0.01);
+  });
+}
+
+test('under a hidden globe, ground behind the camera is not sampled', async (t) => {
+  const env = await createRealLocalLayerHarness({
+    sampleHeightSupported: true, sampleHeight: () => 2_500,
+  });
+  const clock = installFakeClock(t);
+  t.after(() => { env.layer.destroy(env.viewer); env.cleanup(); });
+  env.viewer.scene.globe = hiddenGlobe;
+  aimRealCamera(env, { groundM: 2_500, cameraM: 3_500, southM: 3_000, away: true });
+  clock.advance(2_100);
+  env.preRender.raise();
+  assert.equal(env.sampleCalls.count, 0);
+});
+
 test('settled terrain refinement lifts an already sampled stem without another GPU sample', async (t) => {
   const env = await createRealLocalLayerHarness({
     sampleHeightSupported: true, sampleHeight: () => 117,

src/data/localGeojsonCore.js

@@ -1000,9 +1000,9 @@ export function createLocalGeoJsonLayer(
             // governor the retry's preRender never arrives on a parked camera
             // and the stem stays at ellipsoid height (buried/floating) until
             // the user happens to move. Schedule the frame the retry needs.
-            // Gated on a sampleable scene and in-range records only, so a far
-            // camera (or a keyless scene) stays fully idle; the distance is
-            // only computed for still-unsampled stems.
+            // Gated on a sampleable scene and in-range, in-view records only,
+            // so a far camera (or a keyless scene) stays fully idle; the
+            // distance is only computed for still-unsampled stems.
             if (
               canSampleGround &&
               !record.groundSampled &&
@@ -1010,7 +1010,8 @@ export function createLocalGeoJsonLayer(
               Cesium.Cartesian3.distance(
                 viewer.camera.positionWC,
                 record.base,
-              ) < GROUND_SAMPLE_MAX_DISTANCE_M
+              ) < GROUND_SAMPLE_MAX_DISTANCE_M &&
+              groundSampleInView(viewer, record)
             ) {
               groundRetryPending = true;
             }
@@ -1130,9 +1131,87 @@ function refreshLocalTerrainFloor(viewer, record) {
   return true;
 }
 
+const groundSampleOccluder = new Cesium.EllipsoidalOccluder(
+  Cesium.Ellipsoid.WGS84,
+);
+
+const groundSampleCarto = new Cesium.Cartographic();
+const groundSampleLow = new Cesium.Cartesian3();
+const groundSampleHigh = new Cesium.Cartesian3();
+
+/** The record's vertical at `height` metres above the ellipsoid. */
+function groundSamplePoint(record, height, result) {
+  groundSampleCarto.longitude = record.carto.longitude;
+  groundSampleCarto.latitude = record.carto.latitude;
+  groundSampleCarto.height = height;
+  return Cesium.Cartographic.toCartesian(
+    groundSampleCarto,
+    Cesium.Ellipsoid.WGS84,
+    result,
+  );
+}
+
+/**
+ * Whether the camera can see the ground under the record: inside the view
+ * frustum and above the horizon. scene.sampleHeight reads only surface
+ * rendered for the current view, so a sample of unseen ground passes through
+ * the Earth (about -6,344 km near Ashburn on Esri) and fails on every 2 s
+ * retry, each one a full offscreen render; 110 unseen data centres there held
+ * rest frames at 58-589 ms. Unsampled bases sit on the ellipsoid, so the test
+ * uses loaded globe terrain when there is some. Otherwise (a hidden globe) it
+ * tests the vertical across +/-GROUND_SAMPLE_MAX_ABS_HEIGHT_M, every height a
+ * sample can accept, so high or below-ellipsoid ground in view is never
+ * mistaken for an unseen base. Unseen ground is sampled on the first walk that
+ * sees it.
+ */
+function groundSampleInView(viewer, record) {
+  const camera = viewer.camera;
+  const globe = viewer.scene.globe;
+  const terrain = globe?.show ? globe.getHeight?.(record.carto) : undefined;
+  const known =
+    Number.isFinite(terrain) &&
+    Math.abs(terrain) <= GROUND_SAMPLE_MAX_ABS_HEIGHT_M;
+  const low = groundSamplePoint(
+    record,
+    known ? terrain : -GROUND_SAMPLE_MAX_ABS_HEIGHT_M,
+    groundSampleLow,
+  );
+  const high = known
+    ? low
+    : groundSamplePoint(
+        record,
+        GROUND_SAMPLE_MAX_ABS_HEIGHT_M,
+        groundSampleHigh,
+      );
+  // The vertical is unseen only when both ends are outside the same plane.
+  const { planes } = camera.frustum.computeCullingVolume(
+    camera.positionWC,
+    camera.directionWC,
+    camera.upWC,
+  );
+  for (const plane of planes) {
+    if (
+      Cesium.Cartesian3.dot(plane, low) + plane.w < 0 &&
+      Cesium.Cartesian3.dot(plane, high) + plane.w < 0
+    )
+      return false;
+  }
+  // The ellipsoidal occluder hides every point below the ellipsoid from a
+  // camera near it, so ground below 0 m (low-geoid coasts, the Dead Sea) is
+  // tested at 0 m; unknown ground at the top of the vertical.
+  const horizonHeight = known
+    ? Math.max(terrain, 0)
+    : GROUND_SAMPLE_MAX_ABS_HEIGHT_M;
+  groundSampleOccluder.cameraPosition = camera.positionWC;
+  return groundSampleOccluder.isPointVisible(
+    groundSamplePoint(record, horizonHeight, groundSampleHigh),
+  );
+}
+
 function sampleLocalGroundHeight(viewer, record, now) {
   if (record.groundSampled || !viewer.scene.sampleHeightSupported) return false;
   if (now - record.lastGroundSampleMs < GROUND_SAMPLE_RETRY_MS) return false;
+  if (!groundSampleInView(viewer, record)) return false;
   record.lastGroundSampleMs = now;
   const globe = viewer.scene.globe;
   if (globe?.show && globe.tilesLoaded === false) return false;

src/data/local_data/datacenters/README.md

@@ -5,7 +5,7 @@ layer.
 
 - Source: OpenStreetMap contributors
 - License: Open Database License (ODbL) 1.0
-- Feature count: 4,351
+- Feature count: 4,352
 - Runtime file: `datacenters.geojsonl`
 
 The public-release snapshot removes contact-oriented tags such as email, phone,
@@ -16,3 +16,12 @@ ODbL 1.0 with the required OpenStreetMap attribution.
 
 The original extraction date and query were not recorded alongside this
 snapshot. Future refreshes should record both before replacing the file.
+
+## Norway refresh
+
+Features inside Geofabrik's Norway boundary (`norway.poly`, with Svalbard) come
+from a newer extract than the rest of the file. Contact tags are dropped as above.
+
+- Extract: Geofabrik `norway-261005.osm.pbf`, OSM data
+  2026-10-05T20:21:35Z, MD5 `1d2cfdeb98980fce11b8891d0f9146c0`
+- Filter: `osmium tags-filter nwr/telecom=data_center nwr/building=data_center`

src/data/local_data/datacenters/datacenters.geojsonl

@@ -3770,15 +3770,15 @@
 {"id":939340882,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[21.021364183,52.315373019],[21.02232433,52.315435883],[21.022363641,52.315209656],[21.021403578,52.315146875],[21.021364183,52.315373019]]]},"properties":{"id":11407,"tags":{"name":"T-Mobile Warszawa-Szlachecka","telecom":"data_center","building":"office","building:levels":"3"},"type":"data_center","osm_id":939340882}}
 {"id":1005973518,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[21.021325375,52.315595978],[21.022285857,52.315658423],[21.02232433,52.315435883],[21.021364183,52.315373019],[21.021325375,52.315595978]]]},"properties":{"id":11976,"tags":{"telecom":"data_center","building":"office","building:levels":"3"},"type":"data_center","osm_id":1005973518}}
 {"id":1156823776,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[21.115130857,52.235385942],[21.115189866,52.236349777],[21.115232027,52.236667954],[21.115818174,52.237174556],[21.116175578,52.237468677],[21.117262124,52.236985628],[21.11728157,52.236976576],[21.117262795,52.236960985],[21.117340495,52.236926033],[21.117360276,52.2369433],[21.117447532,52.236904491],[21.11804097,52.236654459],[21.118030996,52.236645742],[21.118041054,52.236641719],[21.116603055,52.235624072],[21.116518984,52.235676375],[21.115986231,52.235696659],[21.115954966,52.235361551],[21.115130857,52.235385942]]]},"properties":{"id":15342,"tags":{"name":"Atman Data Center Warsaw-1","telecom":"data_center","website":"https://www.atman.pl"},"type":"data_center","osm_id":1156823776}}
-{"id":7405586142,"type":"Feature","geometry":{"type":"Point","coordinates":[5.598350034,58.860111293]},"properties":{"id":24849,"tags":{"name":"Maan Group","telecom":"data_center","operator":"Privat"},"type":"data_center","osm_id":7405586142}}
+{"id":7405586142,"type":"Feature","geometry":{"type":"Point","coordinates":[5.5983501,58.8601113]},"properties":{"id":24849,"tags":{"name":"Maan Group","opening_hours":"24/7","operator":"Privat","telecom":"data_center"},"type":"data_center","osm_id":7405586142}}
 {"id":481615983,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[9.572510149,56.481777951],[9.574069938,56.484921751],[9.57465357,56.48483349],[9.574639572,56.484805243],[9.574700676,56.484795939],[9.574714925,56.484824857],[9.575298557,56.484736595],[9.57454888,56.483225422],[9.574609229,56.483216369],[9.574510155,56.483016629],[9.574449722,56.483025849],[9.573738769,56.481592795],[9.573155137,56.481680972],[9.573170643,56.481712321],[9.573109539,56.481721625],[9.573093781,56.48168969],[9.572510149,56.481777951]]]},"properties":{"id":7881,"tags":{"telecom":"data_center","building":"data_center","operator":"Apple","wikidata":"Q19721053","wikipedia":"en:Foulum Data Center","description":"Apple Datacenter"},"type":"data_center","osm_id":481615983}}
 {"id":618756435,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[10.500360092,57.318668738],[10.500399236,57.318671672],[10.500382891,57.318734871],[10.500552038,57.318744175],[10.500545249,57.318787677],[10.500501495,57.318785666],[10.500458999,57.318957746],[10.500970295,57.31899647],[10.501009187,57.318847189],[10.501084959,57.318852888],[10.50111966,57.318719197],[10.500843896,57.318698159],[10.500865521,57.318615178],[10.500859235,57.318614759],[10.500869461,57.318575699],[10.500954537,57.318582153],[10.501022347,57.31832223],[10.500736691,57.318300437],[10.500669133,57.318559689],[10.500674162,57.318560025],[10.500664272,57.318598498],[10.500383981,57.318577124],[10.500360092,57.318668738]]]},"properties":{"id":8842,"tags":{"ref":"AAL01-01","name":"Prime Data Centers - Saeby Campus AAL01","telecom":"data_center","website":"https://primedatacenters.com/locations/saeby/","building":"industrial","operator":"Prime Data Centers"},"type":"data_center","osm_id":618756435}}
-{"id":-14367602,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[11.002243225,59.633471864],[11.003903261,59.633446551],[11.007046726,59.633399696],[11.006983443,59.632420941],[11.006982772,59.63227057],[11.006911023,59.632265289],[11.006852936,59.632253973],[11.006765848,59.632228576],[11.00671782,59.632205275],[11.006119687,59.632213573],[11.006119352,59.632202592],[11.006118933,59.63219245],[11.005930424,59.632194378],[11.005923635,59.632120869],[11.005980799,59.632120031],[11.005979542,59.632104524],[11.005977027,59.63206865],[11.00597225,59.631998242],[11.005412171,59.632035541],[11.005286945,59.632043839],[11.00527848,59.632044342],[11.003707962,59.632147272],[11.003107483,59.63219178],[11.002741864,59.632235533],[11.002729375,59.63223788],[11.002345987,59.632309294],[11.002308352,59.632316251],[11.002302066,59.632477351],[11.002277088,59.632913881],[11.002243225,59.633471864]]]},"properties":{"id":107,"tags":{"name":"STACK Infrastructure OSL04","type":"multipolygon","telecom":"data_center","website":"https://www.stackinfra.com","operator":"Stack Infrastructure","operator:wikidata":"Q115477173"},"type":"data_center","osm_id":-14367602}}
+{"id":-14367602,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[11.0022433,59.6334719],[11.0022771,59.6329139],[11.0023021,59.6324774],[11.0023084,59.6323163],[11.002346,59.6323093],[11.0027294,59.6322379],[11.0027419,59.6322356],[11.0031075,59.6321918],[11.003708,59.6321473],[11.0052785,59.6320444],[11.005287,59.6320439],[11.0054122,59.6320356],[11.0059723,59.6319983],[11.0059771,59.6320687],[11.0059796,59.6321046],[11.0059808,59.6321201],[11.0059237,59.6321209],[11.0059305,59.6321944],[11.006119,59.6321925],[11.0061194,59.6322026],[11.0061197,59.6322136],[11.0067179,59.6322053],[11.0067659,59.6322286],[11.006853,59.632254],[11.0069111,59.6322653],[11.0069828,59.6322706],[11.0069835,59.632421],[11.0070468,59.6333997],[11.0039033,59.6334466],[11.0022433,59.6334719]]]},"properties":{"id":107,"tags":{"landuse":"industrial","name":"STACK Infrastructure OSL04","operator":"Stack Infrastructure","operator:wikidata":"Q115477173","telecom":"data_center","website":"https://www.stackinfra.com","type":"multipolygon"},"type":"data_center","osm_id":-14367602}}
 {"id":1028687251,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[11.004111886,59.632578437],[11.004142983,59.633037262],[11.004275166,59.633034999],[11.004274998,59.63303173],[11.00505133,59.633019157],[11.005056443,59.633099372],[11.005224416,59.63309669],[11.005190637,59.632562344],[11.005060885,59.632564439],[11.005060969,59.632567457],[11.004587978,59.632575419],[11.00458538,59.632536527],[11.004459819,59.632538623],[11.004462418,59.632576844],[11.004242476,59.6325807],[11.004242141,59.632576174],[11.004111886,59.632578437]]]},"properties":{"id":12226,"tags":{"building":"data_center","ref:bygningsnr":"300783262"},"type":"data_center","osm_id":1028687251}}
 {"id":1164840308,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[11.002600126,59.632599392],[11.002631223,59.633058217],[11.00276349,59.633055954],[11.002763238,59.633052685],[11.00353957,59.633040196],[11.003544683,59.633120327],[11.00371274,59.633117645],[11.003678961,59.632583382],[11.003549042,59.632585478],[11.003549293,59.632588495],[11.003076135,59.632596458],[11.00307362,59.632557566],[11.002948143,59.632559661],[11.002950657,59.632597883],[11.002730716,59.632601571],[11.002730465,59.632597129],[11.002600126,59.632599392]]]},"properties":{"id":15459,"tags":{"building":"data_center","ref:bygningsnr":"300783262"},"type":"data_center","osm_id":1164840308}}
 {"id":1164840309,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[11.005613672,59.632723444],[11.005644769,59.633182269],[11.005776951,59.633179922],[11.005776784,59.633176737],[11.006553199,59.633164164],[11.006558229,59.633244463],[11.006726286,59.633241781],[11.006692423,59.632707351],[11.006562671,59.632709446],[11.006562839,59.632712464],[11.006089764,59.632720426],[11.006087166,59.632681534],[11.005961772,59.632683797],[11.005964287,59.632721851],[11.005744262,59.632725623],[11.005743927,59.632721181],[11.005613672,59.632723444]]]},"properties":{"id":15460,"tags":{"building":"data_center","ref:bygningsnr":"300783262"},"type":"data_center","osm_id":1164840309}}
-{"id":935092287,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[10.991467366,59.759024056],[10.992780978,59.759406942],[10.992773937,59.759423957],[10.992948197,59.759474248],[10.993073842,59.759363859],[10.993022293,59.759348939],[10.993291688,59.759112653],[10.993128827,59.759065547],[10.993181885,59.759019027],[10.993083062,59.758990445],[10.992976947,59.759083484],[10.992845519,59.759045346],[10.992813584,59.759073342],[10.9927876,59.759065798],[10.993409789,59.758524243],[10.99263002,59.758297094],[10.991938848,59.758898663],[10.991693594,59.758827165],[10.991467366,59.759024056]]]},"properties":{"id":11377,"tags":{"name":"Green Mountain Ytre Enebakk","telecom":"data_center","website":"https://greenmountain.no/","building":"warehouse","ref:bygningsnr":"300752944"},"type":"data_center","osm_id":935092287}}
-{"id":1161764012,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[10.992826324,59.757448761],[10.994530281,59.757601396],[10.994634888,59.757303168],[10.992928332,59.757152545],[10.992826324,59.757448761]]]},"properties":{"id":15426,"tags":{"name":"Green Mountain Ytre Enebakk","telecom":"data_center","website":"https://greenmountain.no/","building":"industrial"},"type":"data_center","osm_id":1161764012}}
+{"id":935092287,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[10.9914674,59.7590241],[10.9916936,59.7588272],[10.9919389,59.7588987],[10.9926301,59.7582971],[10.9934098,59.7585243],[10.9927876,59.7590658],[10.9928136,59.7590734],[10.9928456,59.7590454],[10.992977,59.7590835],[10.9930831,59.7589905],[10.9931819,59.7590191],[10.9931289,59.7590656],[10.9932917,59.7591127],[10.9930223,59.759349],[10.9930739,59.7593639],[10.9929482,59.7594743],[10.992774,59.759424],[10.992781,59.759407],[10.9914674,59.7590241]]]},"properties":{"id":11377,"tags":{"building":"warehouse","name":"Green Mountain Ytre Enebakk","ref:bygningsnr":"300752944","source":"Norway Orthophoto 2024;https://greenmountain.no/data-center/osl1-enebakk/","telecom":"data_center","website":"https://greenmountain.no/"},"type":"data_center","osm_id":935092287}}
+{"id":1161764012,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[10.9928264,59.7574488],[10.9929284,59.7571526],[10.9946349,59.7573032],[10.9945303,59.7576014],[10.9928264,59.7574488]]]},"properties":{"id":15426,"tags":{"building":"industrial","name":"Green Mountain Ytre Enebakk","source":"Norway Orthophoto 2024;https://greenmountain.no/data-center/osl1-enebakk/","telecom":"data_center","website":"https://greenmountain.no/"},"type":"data_center","osm_id":1161764012}}
 {"id":30724580,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[10.808790995,59.924984985],[10.808893925,59.925031923],[10.80893793,59.92500594],[10.808982941,59.925025972],[10.809042955,59.92501298],[10.809083943,59.925031923],[10.809012948,59.925077856],[10.80926583,59.925189755],[10.80955115,59.925025972],[10.809676543,59.925081293],[10.81032899,59.924701928],[10.809890365,59.924508138],[10.80982155,59.924515347],[10.809691631,59.924457847],[10.808820667,59.924557592],[10.809099365,59.924699581],[10.808806418,59.924865291],[10.808918149,59.924914828],[10.808875988,59.924937962],[10.808790995,59.924984985]]]},"properties":{"id":261,"tags":{"name":"Stack Infrastructure OSLO1A","telecom":"data_center","building":"office","operator":"Stack Infrastructure","ref:bygningsnr":"80877293","building:levels":"4","operator:wikidata":"Q115477173"},"type":"data_center","osm_id":30724580}}
 {"id":80871917,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[10.83408892,59.938588981],[10.834305927,59.938720996],[10.834575992,59.938720996],[10.834574987,59.938736],[10.834581943,59.938736922],[10.834579932,59.938771958],[10.834736925,59.938771958],[10.834734997,59.93893792],[10.836717988,59.938944961],[10.836717988,59.938983937],[10.836817984,59.938983937],[10.83681899,59.938944961],[10.836844974,59.938944961],[10.836846985,59.938774976],[10.836841956,59.938774976],[10.836842962,59.938744968],[10.836849919,59.938744968],[10.836851931,59.938653941],[10.836683957,59.938652935],[10.836684125,59.938640278],[10.836686975,59.938414973],[10.83490297,59.938406926],[10.834899953,59.938646984],[10.834812949,59.938645978],[10.83481496,59.938551933],[10.834579932,59.938550927],[10.834580938,59.938564925],[10.834567946,59.938564925],[10.834567946,59.938551933],[10.834089926,59.938549922],[10.83408892,59.938588981]]]},"properties":{"id":1464,"tags":{"name":"Bulk Data Centers Oslo Internet Exchange","telecom":"data_center","website":"https://bulkinfrastructure.com/data-centers/locations/os-ix","building":"industrial","ref:bygningsnr":"80709943"},"type":"data_center","osm_id":80871917}}
 {"id":12158409495,"type":"Feature","geometry":{"type":"Point","coordinates":[9.689363435,62.59439936]},"properties":{"id":28723,"tags":{"name":"VisBook AS","telecom":"data_center","website":"https://visbook.com/"},"type":"data_center","osm_id":12158409495}}
@@ -4349,3 +4349,4 @@
 {"id":540895898,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[101.71747909,56.303855963],[101.71782015,56.304420065],[101.721113819,56.303806929],[101.720772759,56.303242994],[101.71747909,56.303855963]]]},"properties":{"id":8271,"tags":{"name":"Битривер Рус","name:en":"Bitriver Rus","name:ru":"Битривер Рус","telecom":"data_center","website":"https://bitriver.farm/","building":"data_center"},"type":"data_center","osm_id":540895898}}
 {"id":1082803064,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[123.948021193,47.340264299],[123.948354625,47.340268239],[123.948490663,47.340269831],[123.948488568,47.340349292],[123.948809762,47.340353064],[123.948811942,47.340267485],[123.948918643,47.340268658],[123.948922918,47.340137817],[123.948023959,47.340126082],[123.948021193,47.340264299]]]},"properties":{"id":13377,"tags":{"name":"联通云数据中心·齐齐哈尔","name:en":"Unicom Data Center of Qiqihar","name:zh":"联通云数据中心·齐齐哈尔","telecom":"data_center","building":"yes","name:zh-Hans":"联通云数据中心·齐齐哈尔","name:zh-Hant":"聯通雲數據中心·齊齊哈爾"},"type":"data_center","osm_id":1082803064}}
 {"id":442479059,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[142.76019226,46.910096898],[142.760192427,46.910325724],[142.760447656,46.910328155],[142.760460397,46.910102263],[142.76019226,46.910096898]]]},"properties":{"id":7471,"tags":{"telecom":"data_center","building":"yes"},"type":"data_center","osm_id":442479059}}
+{"id":1551029155,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[7.1069147,62.8627625],[7.1071207,62.8621617],[7.1075917,62.8616616],[7.1088647,62.8620476],[7.1106308,62.862645],[7.1098655,62.8632827],[7.1089604,62.8630042],[7.1086734,62.8632156],[7.1069147,62.8627625]]]},"properties":{"id":29471,"tags":{"layer":"-1","loc_name":"Troll Housing Klempertåsen","name":"Troll Housing","operator":"Troll Housing AS","telecom":"data_center","website":"https://www.trollhousing.no/"},"type":"data_center","osm_id":1551029155}}

src/data/militaryAwareness.test.mjs

@@ -98,6 +98,7 @@ function installAwarenessRuntime({
   // status its module never emits guards nothing. See the settled-but-fetching
   // tests below, which use militaryInstallations' genuine first-fetch readout.
   layerStats = {},
+  subscribe = undefined,
 } = {}) {
   const originalWindow = globalThis.window;
   const originalDocument = globalThis.document;
@@ -215,6 +216,7 @@ function installAwarenessRuntime({
     setEnabled,
     getLayerLifecycleState,
     layers,
+    ...(subscribe ? { subscribe } : {}),
   });
   militaryAwarenessLayer.setParams({ passive: true });
   militaryAwarenessLayer.init(viewer);
@@ -383,6 +385,54 @@ test('Contacts does not claim a dependency already enabling for the user', async
   }
 });
 
+test('a dependency the user adopts stays on when Contacts turns off', async () => {
+  // A direct selection, or the Cockpit riding one of its aircraft, promotes a
+  // layer Contacts turned on into the user's own (adoptLayerVisibility). The
+  // coordinator must give it up, or its OFF release tears the layer down —
+  // and the track or the Cockpit with it — before Context restores it.
+  const calls = [];
+  const subscribers = new Set();
+  const runtime = installAwarenessRuntime({
+    isEnabled: () => false,
+    isEffectivelyEnabled: () => false,
+    setEnabled: (layerId, enabled) => {
+      calls.push({ layerId, enabled });
+      return Promise.resolve(true);
+    },
+    subscribe: (listener) => {
+      subscribers.add(listener);
+      return () => subscribers.delete(listener);
+    },
+  });
+
+  try {
+    militaryAwarenessLayer.setParams({ passive: false });
+    await nextTurn();
+    for (const listener of subscribers)
+      listener({
+        type: 'visibility',
+        layerId: 'flights',
+        enabled: true,
+        origin: 'user',
+        adopted: true,
+        adoptedFromSelection: true,
+      });
+    await militaryAwarenessLayer.disable();
+    const released = calls
+      .filter(({ enabled }) => !enabled)
+      .map(({ layerId }) => layerId)
+      .sort();
+    assert.deepEqual(
+      released,
+      AWARENESS_DEPENDENCIES.filter((layerId) => layerId !== 'flights').sort(),
+      'the adopted layer is the user\'s now; the rest are still released',
+    );
+  } finally {
+    runtime.restore();
+  }
+  assert.equal(subscribers.size, 0, 'destroy drops the manager subscription');
+});
+
 test('operational awareness becomes ready after aircraft while deferred sources keep loading', async () => {
   let enabled = false;
   let releaseAircraft;

src/data/placeNames.js

@@ -11,17 +11,16 @@ const FOLD = {
 };
 
 /**
- * Comparable form of a place name, shared by the bundled packs, the
- * OpenFreeMap street and grounds matchers and the Nominatim server: case
- * folded, accents removed from Latin letters only, punctuation and symbols
- * collapsed to single spaces, and a leading "the" dropped. Other scripts keep
- * their marks, so "कुल मार्ग" and "काली मार्ग" stay distinct while "São Paulo",
- * "sao paulo" and "SÃO PAULO!" meet.
+ * Script-aware fold of a place name: case folded, accents removed from Latin
+ * letters only, punctuation and symbols collapsed to single spaces. Other
+ * scripts keep their marks, so "कुल मार्ग" and "काली मार्ग" stay distinct while
+ * "São Paulo", "sao paulo" and "SÃO PAULO!" meet. Every word is kept: "The
+ * Hague" is not "Hague".
  *
  * @param {unknown} value
  * @returns {string}
  */
-export function foldPlaceName(value) {
+export function foldPlaceText(value) {
   return String(value ?? '')
     .toLowerCase()
     .replace(/[ßøæłđıœþ]/g, (c) => FOLD[c])
@@ -29,8 +28,19 @@ export function foldPlaceName(value) {
     .replace(/(\p{Script=Latin})\p{M}+/gu, '$1')
     .normalize('NFKC')
     .replace(/[^\p{L}\p{M}\p{N}]+/gu, ' ')
-    .trim()
-    .replace(/^the /, '');
+    .trim();
+}
+
+/**
+ * Comparable form of a place name, shared by the bundled packs, the
+ * OpenFreeMap street and grounds matchers and the Nominatim server:
+ * `foldPlaceText` with a leading "the" dropped.
+ *
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function foldPlaceName(value) {
+  return foldPlaceText(value).replace(/^the /, '');
 }
 
 /**

src/data/rioRouteNames.js

@@ -0,0 +1,505 @@
+/**
+ * Rio de Janeiro route ids to the line a rider would say.
+ *
+ * SMTR's realtime feeds send internal keys (`O0731AAN0A` is SN731,
+ * `20000501110` is BRT line 50). They look decodable but are not:
+ * `O0014AAA0A` is LECD135, not 14. The table is copied from `routes.txt` in
+ * SMTR's static GTFS (https://dados.mobilidade.rio/gtfs/schedule, CC BY 4.0),
+ * valid to 2026-12-31. An id missing here renders as its raw key.
+ */
+export const RIO_ROUTE_NAMES = Object.freeze({
+  20000101130: '10',
+  20000111110: '11',
+  20000121130: '12',
+  20000131130: '13',
+  20000141130: '14',
+  20000151130: '15',
+  20000161130: '16',
+  20000171110: '17',
+  20000181130: '18',
+  20000191130: '19',
+  20000201130: '20',
+  20000221110: '22',
+  20000251130: '25',
+  20000281130: '28',
+  20000311140: '31',
+  20000351110: '35',
+  20000401130: '40',
+  20000411130: '41',
+  20000421110: '42',
+  20000431130: '43',
+  20000461130: '46',
+  20000501110: '50',
+  20000511110: '51',
+  20000521110: '52',
+  20000531130: '53',
+  20000601110: '60',
+  20000611130: '61',
+  20000671130: '67',
+  20000681130: '68',
+  20000701110: '70',
+  20000731130: '73',
+  20000801110: '80',
+  20000901110: '90',
+  '20000EXEC1110': 'ESP01',
+  E2110AAA0A: '2110',
+  E2111AAA0A: '2111',
+  E2112AAA0A: '2112',
+  E2114AAA0A: '2114',
+  E2303AAA0A: '2303',
+  E2305AAA0A: '2305',
+  E2307AAA0A: '2307',
+  E2308AAA0A: '2308',
+  E2309AAA0A: '2309',
+  E2310AAA0A: '2310',
+  E2334AAA0A: '2334',
+  E2335AAA0A: '2335',
+  E2336AAA0A: '2336',
+  E2337AAA0A: '2337',
+  E2338AAA0A: '2338',
+  E2339AAA0A: '2339',
+  E2342AAA0A: '2342',
+  E2343AAA0A: '2343',
+  E2344AAA0A: '2344',
+  E2345AAA0A: '2345',
+  E2381AAA0A: '2381',
+  E2383AAA0A: '2383',
+  E2613AAA0A: '2613',
+  E2614AAA0A: '2614',
+  E2802AAA0A: '2802',
+  E2803AAA0A: '2803',
+  E2804AAA0A: '2804',
+  O0006AAA0A: '006',
+  O0007AAA0A: '007',
+  O0007AAN0A: 'SN007',
+  O0010AAA0A: '010',
+  O0014AAA0A: 'LECD135',
+  O0100AAA0A: '100',
+  O0104AAA0A: '104',
+  O0104AAN0A: 'SN104',
+  O0107AAA0A: '107',
+  O0109AAA0A: 'LECD131',
+  O0111AAA0A: 'LECD134',
+  O0117AAA0A: '117',
+  O0133AAA0A: '133',
+  O0133AAN0A: 'SN133',
+  O0157AAA0A: 'LECD127',
+  O0160AAA0A: '160',
+  O0161AAA0A: '161',
+  O0162AAA0A: '162',
+  O0164AAA0A: 'LECD136',
+  O0165AAA0A: '165',
+  O0167AAA0A: '167',
+  O0169AAA0A: '169',
+  O0201AAA0A: '201',
+  O0202AAA0A: '202',
+  O0209AAA0A: '209',
+  O0209AAN0A: 'SN209',
+  O0210AAA0A: '210',
+  O0217AAA0A: '217',
+  O0220AAA0A: '220',
+  O0229AAA0A: '229',
+  O0232AAA0A: '232',
+  O0232AAN0A: 'SN232',
+  O0238AAA0A: '238',
+  O0238AAN0A: 'SN238',
+  O0239AAA0A: '239',
+  O0247AAA0A: '247',
+  O0249AAA0A: '249',
+  O0254AAA0A: '254',
+  O0265AAA0A: '265',
+  O0265AAN0A: 'SN265',
+  O0265AAP0A: 'SP265',
+  O0275AAA0A: '275',
+  O0277AAA0A: '277',
+  O0292AAA0A: '292',
+  O0292AAN0A: 'SN292',
+  O0296AAA0A: '296',
+  O0298AAA0A: '298',
+  O0298AAN0A: 'SN298',
+  O0300AAA0A: '300',
+  O0300AAR0A: 'SR300',
+  O0301AAA0A: '301',
+  O0302AAA0A: '302',
+  O0302AAN0A: 'SN302',
+  O0306AAA0A: '306',
+  O0311AAA0A: '311',
+  O0312AAA0A: '312',
+  O0312AAN0A: 'SN312',
+  O0313AAA0A: '313',
+  O0315AAA0A: '315',
+  O0319AAA0A: '319',
+  O0319AAN0A: 'SN319',
+  O0319AAV0A: 'SV319',
+  O0321AAA0A: '321',
+  O0323AAA0A: '323',
+  O0324AAA0A: '324',
+  O0324AAN0A: 'SN324',
+  O0324AAP0A: 'SP324',
+  O0325AAA0A: '325',
+  O0326AAA0A: '326',
+  O0326AAPBA: 'SPB326',
+  O0327AAA0A: '327',
+  O0328AAA0A: '328',
+  O0328AAN0A: 'SN328',
+  O0328AAP0A: 'SP328',
+  O0328AAR0A: 'SR328',
+  O0329AAA0A: '329',
+  O0329AAP0A: 'SP329',
+  O0335AAA0A: '335',
+  O0338AAA0A: '338',
+  O0341AAA0A: '341',
+  O0342AAA0A: '342',
+  O0342AAR0A: 'SR342',
+  O0343AAA0A: '343',
+  O0343AAP0A: 'SP343',
+  O0348AAA0A: '348',
+  O0349AAA0A: '349',
+  O0350AAA0A: '350',
+  O0352AAA0A: '352',
+  O0353AAA0A: '353',
+  O0353AAN0A: 'SN353',
+  O0355AAA0A: '355',
+  O0355AAN0A: 'SN355',
+  O0355AAR0A: 'SR355',
+  O0361AAA0A: '361',
+  O0362AAA0A: '362',
+  O0362AAR0A: 'SR362',
+  O0363AAA0A: '363',
+  O0363AAN0A: 'SN363',
+  O0363AAV0A: 'SV363',
+  O0368AAA0A: '368',
+  O0368AAN0A: 'SN368',
+  O0369AAA0A: '369',
+  O0371AAA0A: '371',
+  O0378AAA0A: '378',
+  O0378AAR0A: 'SR378',
+  O0380AAA0A: '380',
+  O0383AAA0A: '383',
+  O0383AAN0A: 'SN383',
+  O0384AAA0A: '384',
+  O0384AAR0A: 'SR384',
+  O0385AAA0A: '385',
+  O0386AAA0A: '386',
+  O0386AAR0A: 'SR386',
+  O0388AAA0A: '388',
+  O0388AAN0A: 'SN388',
+  O0388AAR0A: 'SR388',
+  O0389AAP0A: 'SP389',
+  O0390AAA0A: '390',
+  O0391AAV0A: 'SV391',
+  O0393AAA0A: '393',
+  O0393AAN0A: 'SN393',
+  O0393AAR0A: 'SR393',
+  O0397AAA0A: '397',
+  O0397AAN0A: 'SN397',
+  O0397AAR0A: 'SR397',
+  O0399AAA0A: '399',
+  O0399AAN0A: 'SN399',
+  O0399AAR0A: 'SR399',
+  O0404AAP0A: 'SP404',
+  O0409AAA0A: '409',
+  O0410AAA0A: '410',
+  O0410AAN0A: 'LECD139',
+  O0415AAA0A: '415',
+  O0415AAN0A: 'SN415',
+  O0416AAA0A: '416',
+  O0422AAA0A: '422',
+  O0422AAN0A: 'SN422',
+  O0426AAA0A: '426',
+  O0433AAA0A: 'LECD150',
+  O0435AAA0A: 'LECD151',
+  O0448AAA0A: '448',
+  O0455AAA0A: '455',
+  O0456AAA0A: 'LECD132',
+  O0457AAA0A: '457',
+  O0457AAN0A: 'SN457',
+  O0461AAA0A: '461',
+  O0472AAA0A: '472',
+  O0473AAA0A: '473',
+  O0474AAA0A: '474',
+  O0474AAN0A: 'SN474',
+  O0474AAV0A: 'SV474',
+  O0475AAA0A: 'LECD133',
+  O0476AAA0A: '476',
+  O0483AAA0A: '483',
+  O0483AAN0A: 'SN483',
+  O0483AAPAA: 'SPA483',
+  O0483AAPBA: 'SPB483',
+  O0483AAV0A: 'SV483',
+  O0484AAA0A: '484',
+  O0485AAA0A: '485',
+  O0485AAP0A: 'SP485',
+  O0486AAA0A: '486',
+  O0492AAA0A: '492',
+  O0497AAA0A: '497',
+  O0497AAN0A: 'SN497',
+  O0498AAA0A: '498',
+  O0507AAA0A: '507',
+  O0513AAA0A: '513',
+  O0518AAA0A: '518',
+  O0519AAA0A: '519',
+  O0536AAA0A: 'LECD138',
+  O0539AAA0A: '539',
+  O0550AAA0A: '550',
+  O0550AAN0A: 'SN550',
+  O0550AAPAA: 'SPA550',
+  O0550AAPBA: 'SPB550',
+  O0552AAA0A: '552',
+  O0552AAN0A: 'LECD149',
+  O0553AAA0A: '553',
+  O0554AAA0A: '554',
+  O0554AAN0A: 'SN554',
+  O0555AAA0A: '555',
+  O0557AAA0A: '557',
+  O0565AAA0A: '565',
+  O0565AAN0A: 'SN565',
+  O0583AAA0A: '583',
+  O0584AAA0A: '584',
+  O0585AAA0A: '585',
+  O0600AAA0A: '600',
+  O0600AAN0A: 'SN600',
+  O0601AAA0A: '601',
+  O0603AAA0A: '603',
+  O0606AAA0A: '606',
+  O0606AAV0A: 'SV606',
+  O0607AAA0A: '607',
+  O0608AAA0A: '608',
+  O0610AAA0A: '610',
+  O0611AAA0A: '611',
+  O0613AAA0A: '613',
+  O0613AAPAA: 'SPA613',
+  O0614AAA0A: '614',
+  O0616AAA0A: '616',
+  O0621AAA0A: '621',
+  O0622AAA0A: '622',
+  O0623AAA0A: '623',
+  O0624AAA0A: '624',
+  O0624AAN0A: 'SN624',
+  O0624AAV0A: 'SV624',
+  O0625AAA0A: '625',
+  O0626AAA0A: '626',
+  O0627AAA0A: '627',
+  O0628AAA0A: '628',
+  O0629AAA0A: '629',
+  O0629AAN0A: 'SN629',
+  O0630AAA0A: '630',
+  O0634AAA0A: '634',
+  O0635AAA0A: '635',
+  O0635AAP0A: 'SP635',
+  O0636AAA0A: '636',
+  O0636AAN0A: 'SN636',
+  O0638AAA0A: '638',
+  O0639AAA0A: '639',
+  O0639AAN0A: 'SN639',
+  O0645AAA0A: '645',
+  O0649AAA0A: 'LECD126',
+  O0650AAA0A: '650',
+  O0651AAA0A: '651',
+  O0652AAA0A: '652',
+  O0653AAA0A: '653',
+  O0663AAA0A: '663',
+  O0665AAA0A: '665',
+  O0665AAVAA: 'LECD147',
+  O0665AAVBA: 'SVB665',
+  O0669AAA0A: '669',
+  O0669AAV0A: 'SV669',
+  O0678AAA0A: '678',
+  O0679AAA0A: '679',
+  O0685AAA0A: 'LECD140',
+  O0685AAVAA: 'LECD148',
+  O0685AAVBA: 'LECD141',
+  O0687AAA0A: '687',
+  O0688AAA0A: '688',
+  O0691AAA0A: '691',
+  O0692AAA0A: '692',
+  O0692AAV0A: 'SV692',
+  O0693AAA0A: '693',
+  O0696AAA0A: '696',
+  O0696AAN0A: 'SN696',
+  O0711AAA0A: '711',
+  O0712AAA0A: '712',
+  O0721AAA0A: '721',
+  O0731AAA0A: '731',
+  O0731AAN0A: 'SN731',
+  O0737AAA0A: '737',
+  O0741AAA0A: '741',
+  O0743AAA0A: '743',
+  O0745AAA0A: '745',
+  O0746AAA0A: '746',
+  O0753AAA0A: '753',
+  O0754AAA0A: '754',
+  O0756AAA0A: '756',
+  O0757AAA0A: '757',
+  O0759AAA0A: '759',
+  O0759AAP0A: 'SP759',
+  O0764AAA0A: '764',
+  O0765AAA0A: '765',
+  O0766AAA0A: '766',
+  O0766AAP0A: 'SP766',
+  O0770AAA0A: '770',
+  O0771AAA0A: '771',
+  O0774AAA0A: '774',
+  O0774AAV0A: 'LECD142',
+  O0775AAA0A: '775',
+  O0777AAV0A: 'SV777',
+  O0778AAA0A: '778',
+  O0779AAA0A: '779',
+  O0779AAN0A: 'SN779',
+  O0780AAA0A: '780',
+  O0783AAA0A: '783',
+  O0785AAA0A: '785',
+  O0786AAA0A: '786',
+  O0788AAA0A: '788',
+  O0790AAA0A: '790',
+  O0790AAN0A: 'SN790',
+  O0790AAV0A: 'SV790',
+  O0791AAA0A: '791',
+  O0793AAA0A: '793',
+  O0794AAA0A: '794',
+  O0794AAN0A: 'SN794',
+  O0795AAP0A: 'SP795',
+  O0796AAA0A: '796',
+  O0798AAA0A: '798',
+  O0799AAA0A: '799',
+  O0801AAA0A: '801',
+  O0801AAP0A: 'SP801',
+  O0802AAA0A: '802',
+  O0803AAA0A: '803',
+  O0803AAN0A: 'SN803',
+  O0803AAP0A: 'SP803',
+  O0804AAA0A: '804',
+  O0805AAA0A: '805',
+  O0805AAN0A: 'SN805',
+  O0805AAP0A: 'SP805',
+  O0807AAA0A: '807',
+  O0808AAA0A: '808',
+  O0809AAA0A: '809',
+  O0810AAA0A: '810',
+  O0810AAN0A: 'SN810',
+  O0810AAP0A: 'SP810',
+  O0812AAA0A: '812',
+  O0817AAA0A: '817',
+  O0819AAA0A: '819',
+  O0820AAA0A: '820',
+  O0821AAA0A: '821',
+  O0821AAN0A: 'SN821',
+  O0822AAA0A: '822',
+  O0825AAA0A: '825',
+  O0825AAN0A: 'SN825',
+  O0826AAA0A: '826',
+  O0829AAA0A: '829',
+  O0830AAA0A: '830',
+  O0831AAA0A: '831',
+  O0831AAV0A: 'SV831',
+  O0833AAA0A: '833',
+  O0834AAA0A: '834',
+  O0835AAA0A: '835',
+  O0836AAA0A: '836',
+  O0837AAA0A: '837',
+  O0838AAA0A: '838',
+  O0840AAA0A: '840',
+  O0840AAN0A: 'SN840',
+  O0841AAA0A: '841',
+  O0842AAA0A: '842',
+  O0843AAA0A: '843',
+  O0844AAA0A: '844',
+  O0845AAA0A: '845',
+  O0846AAA0A: '846',
+  O0846AAN0A: 'SN846',
+  O0847AAA0A: '847',
+  O0848AAA0A: '848',
+  O0848AAN0A: 'SN848',
+  O0849AAA0A: '849',
+  O0850AAA0A: '850',
+  O0851AAA0A: '851',
+  O0852AAA0A: '852',
+  O0853AAA0A: '853',
+  O0853AAN0A: 'SN853',
+  O0853AAV0A: 'SV853',
+  O0854AAAAA: '854',
+  O0855AAA0A: '855',
+  O0856AAA0A: '856',
+  O0857AAA0A: '857',
+  O0857AAN0A: 'SN857',
+  O0859AAA0A: '859',
+  O0861AAA0A: '861',
+  O0861AAN0A: 'SN861',
+  O0862AAA0A: '862',
+  O0863AAA0A: '863',
+  O0863AAV0A: 'SV863',
+  O0864AAA0A: '864',
+  O0864AAP0A: 'SP864',
+  O0865AAA0A: '865',
+  O0866AAA0A: '866',
+  O0866AAV0A: 'SV866',
+  O0867AAA0A: '867',
+  O0867AAN0A: 'SN867',
+  O0868AAA0A: '868',
+  O0869AAA0A: '869',
+  O0870AAA0A: '870',
+  O0871AAA0A: '871',
+  O0872AAA0A: '872',
+  O0878AAA0A: '878',
+  O0878AAN0A: 'SN878',
+  O0878AAV0A: 'SV878',
+  O0880AAA0A: '880',
+  O0880AAN0A: 'SN880',
+  O0881AAA0A: '881',
+  O0883AAA0A: '883',
+  O0884AAA0A: '884',
+  O0884AAN0A: 'SN884',
+  O0885AAA0A: '885',
+  O0885AAN0A: 'SN885',
+  O0892AAA0A: '892',
+  O0893AAA0A: '893',
+  O0893AAN0A: 'SN893',
+  O0894AAA0A: '894',
+  O0895AAA0A: '895',
+  O0895AAN0A: 'SN895',
+  O0897AAA0A: '897',
+  O0897AAN0A: 'SN897',
+  O0898AAA0A: '898',
+  O0898AAN0A: 'SN898',
+  O0899AAA0A: '899',
+  O0899AAV0A: 'SV899',
+  O0900AAA0A: '900',
+  O0901AAA0A: '901',
+  O0901AAVBA: 'SVB901',
+  O0905AAA0A: '905',
+  O0906AAA0A: '906',
+  O0908AAA0A: '908',
+  O0908AAN0A: 'SN908',
+  O0908AAV0A: 'SV908',
+  O0910AAA0A: '910',
+  O0913AAA0A: '913',
+  O0915AAA0A: '915',
+  O0917AAA0A: '917',
+  O0917AAV0A: 'SV917',
+  O0918AAA0A: '918',
+  O0918AAP0A: 'SP918',
+  O0919AAA0A: '919',
+  O0919AAN0A: 'SN919',
+  O0920AAA0A: '920',
+  O0921AAA0A: '921',
+  O0921AAV0A: 'SV921',
+  O0922AAA0A: '922',
+  O0922AAV0A: 'SV922',
+  O0925AAA0A: '925',
+  O0926AAA0A: '926',
+  O0928AAA0A: '928',
+  O0932AAA0A: '932',
+  O0940AAA0A: '940',
+  O0944AAA0A: 'LECD143',
+  O0946AAA0A: '946',
+  O0950AAA0A: 'LECD144',
+  O0951AAA0A: 'LECD145',
+  O0954AAA0A: '954',
+  O0954AAN0A: 'SN954',
+  O0959AAA0A: 'LECD146',
+  O0961AAA0A: '961',
+  O0975AAA0A: '975',
+  O0979AAA0A: '979',
+  O0987AAA0A: '987',
+  O0990AAA0A: '990',
+});

src/data/sharedOsmDisplays.test.mjs

@@ -85,7 +85,7 @@ test('Warendorf webcam display introduces the shared OSM credit', (t) => {
   const v = viewer(t), empty = new Proxy({}, { get: () => noop });
   const lifecycle = createCctvLifecycle({ state: { _viewer: v, _records: [{ camera: { id: 'warendorf-marktplatz-rathaus', cityId: 'warendorf' } }], _recordById: new Map(), _cctvOverlayHost: overlayHost },
     services: { credits: { showOsmCredit, hideOsmCredit }, sprites: empty, activation: empty, picking: empty, focus: empty, render: empty },
-    parts: { selection: empty, geometryQueue: empty, rendering: empty, projection: empty, cards: empty, presentation: empty }, source: {} });
+    parts: { selection: empty, geometryQueue: empty, rendering: empty, projection: empty, cards: empty, presentation: empty, navigation: empty }, source: {} });
   lifecycle.methods.enable(); assertCredit(v); lifecycle.methods.disable();
   assert.equal(v.credits.filter(c => c.showOnScreen).length, 0);
 });

src/data/spriteOrder.js

@@ -2,6 +2,7 @@
 export const SPRITE_LAYER_ORDER = Object.freeze([
   'cctv',
   'firms',
+  'wildlife-sightings',
   'bikeshare',
   'transit',
   'transit-motion',

src/data/traffic.test.mjs

@@ -30,6 +30,28 @@ test('a superseded flow fetch is not an outage', () => {
   assert.equal(deriveTrafficFlowError(undefined), null);
 });
 
+test('hosted account limits and service failures name their own reason', () => {
+  const failure = (status, code) =>
+    deriveTrafficFlowError(
+      Object.assign(new Error(`TomTom flow unavailable (HTTP ${status})`), {
+        status,
+        code,
+      }),
+    );
+  assert.equal(
+    failure(429, 'USAGE_LIMIT_REACHED'),
+    'Monthly traffic allowance used',
+  );
+  assert.equal(failure(429, 'RATE_LIMITED'), 'Traffic rate limit reached');
+  assert.equal(failure(429, 'budget'), 'TomTom daily budget reached');
+  assert.equal(failure(503, 'no_key'), 'TomTom key unavailable');
+  assert.equal(failure(503, null), 'TomTom key unavailable');
+  assert.equal(
+    failure(503, 'USAGE_UNAVAILABLE'),
+    'Traffic service unavailable',
+  );
+});
+
 test('flow failures map onto short, specific reasons', () => {
   const reason = (message) => deriveTrafficFlowError(new Error(message));
   assert.equal(reason('flow tile 12/1/1: HTTP 503'), 'TomTom key unavailable');

src/data/transitFeeds.js

@@ -1,4 +1,5 @@
 import { greatCircleKm } from '../geoDistance.js';
+import { RIO_ROUTE_NAMES } from './rioRouteNames.js';
 
 /**
  * @module transitFeeds
@@ -376,6 +377,18 @@ function burlingtonRouteLabel(routeId) {
   return BURLINGTON_ROUTE_NAMES[routeId] || routeId;
 }
 
+/**
+ * Rio route key to the line a rider would say. One SMTR `routes.txt` covers
+ * both feeds (see rioRouteNames.js).
+ * @param {string|null} routeId
+ * @returns {string|null}
+ */
+function rioRouteLabel(routeId) {
+  return Object.hasOwn(RIO_ROUTE_NAMES, routeId)
+    ? RIO_ROUTE_NAMES[routeId]
+    : 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.
@@ -729,6 +742,52 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
     defaultMode: 'bus',
     routeLabel: burlingtonRouteLabel,
   }),
+  Object.freeze({
+    id: 'smtr-rio-onibus',
+    name: 'Rio buses (SPPO)',
+    operator: 'Secretaria Municipal de Transportes (SMTR), Rio de Janeiro',
+    region: 'Rio de Janeiro, RJ',
+    // Every vehicle in a 2026-10-29 snapshot, from Santa Cruz in the west to
+    // the Zona Sul, sat within 31 km of this point.
+    center: Object.freeze({ lat: -22.92, lon: -43.42 }),
+    loadRadiusKm: 45,
+    url: 'https://dados.mobilidade.rio/gtfs/realtime/onibus/vehicle-positions',
+    license: 'CC BY 4.0',
+    licenseUrl:
+      'https://www.data.rio/documents/997bc16cc4344a5cb0e48ab06cbdfd1f',
+    attribution: 'SMTR / Prefeitura da Cidade do Rio de Janeiro — buses (SPPO)',
+    defaultEnabled: true,
+    terms: Object.freeze({
+      quote:
+        'This work is licensed under a Creative Commons Attribution 4.0 International License',
+      note: 'The data.rio catalog page labels the feed [beta] and states a gateway limit of 5 requests a second and 60 a minute behind a 10-second cache, which the 15-second proxy TTL stays inside. SMTR relays the concessionaires’ ITS data and repairs trips with its own matching; the page places accuracy with the suppliers. Speeds are m/s, as the spec requires: checked against vehicle movement on 2026-11-05, though a 2026-10-29 snapshot read as km/h. Line names come from SMTR’s GTFS `routes.txt`, under the same CC BY 4.0 terms.',
+    }),
+    defaultMode: 'bus',
+    routeLabel: rioRouteLabel,
+  }),
+  Object.freeze({
+    id: 'smtr-rio-brt',
+    name: 'Mobi-Rio BRT',
+    operator:
+      'Secretaria Municipal de Transportes (SMTR), Rio de Janeiro, for the Mobi-Rio BRT fleet',
+    region: 'Rio de Janeiro, RJ',
+    center: Object.freeze({ lat: -22.92, lon: -43.42 }),
+    loadRadiusKm: 45,
+    url: 'https://dados.mobilidade.rio/gtfs/realtime/brt/vehicle-positions',
+    license: 'CC BY 4.0',
+    licenseUrl:
+      'https://www.data.rio/documents/8bb196cc02174d25b77437bb2f6443d4',
+    attribution:
+      'SMTR / Prefeitura da Cidade do Rio de Janeiro — BRT (Mobi-Rio)',
+    defaultEnabled: true,
+    terms: Object.freeze({
+      quote:
+        'This work is licensed under a Creative Commons Attribution 4.0 International License',
+      note: 'Same catalog terms, [beta] label and gateway limits as the bus feed. The fleet is operated by Mobi-Rio and tracked by SONDA, whose data SMTR relays. Speeds are m/s too. Line names come from the same `routes.txt`.',
+    }),
+    defaultMode: 'bus',
+    routeLabel: rioRouteLabel,
+  }),
 ]);
 
 /**

src/data/transitFeeds.test.mjs

@@ -15,6 +15,7 @@ import {
   transitModeResolved,
   transitRouteLabel,
 } from './transitFeeds.js';
+import { RIO_ROUTE_NAMES } from './rioRouteNames.js';
 
 test('every registered feed is keyless, https, licensed, and uniquely identified', () => {
   const ids = new Set();
@@ -482,3 +483,72 @@ test('Burlington is live and carries its terms link, which its licence requires'
   assert.match(bur.licenseUrl, /Open%20Data%20Terms%20of%20Use\.pdf$/);
   assert.match(bur.url, /^https:\/\//, 'port 80 has no listener at all');
 });
+
+test('Rio buses and BRT cover the city from Centro to Santa Cruz, and not São Paulo', () => {
+  const ids = (lat, lon) =>
+    transitFeedsInRange(lat, lon).map((feed) => feed.id);
+  for (const [place, lat, lon] of [
+    ['Centro', -22.9068, -43.1729],
+    ['Barra da Tijuca', -23.0004, -43.3659],
+    ['Santa Cruz', -22.9194, -43.6847],
+  ]) {
+    assert.ok(
+      ids(lat, lon).includes('smtr-rio-onibus'),
+      `buses reach ${place}`,
+    );
+    assert.ok(ids(lat, lon).includes('smtr-rio-brt'), `BRT reaches ${place}`);
+  }
+  assert.deepEqual(
+    ids(-23.5505, -46.6333).filter((id) => id.startsWith('smtr-rio')),
+    [],
+    'São Paulo, 360 km away, never polls Rio',
+  );
+});
+
+test('Rio route keys read as the line on the front of the bus', () => {
+  // Some keys look parseable and are not (`O0014AAA0A` is LECD135).
+  const buses = getTransitFeed('smtr-rio-onibus');
+  assert.equal(transitRouteLabel(buses, 'O0868AAA0A'), '868');
+  assert.equal(transitRouteLabel(buses, 'O0731AAN0A'), 'SN731');
+  assert.equal(transitRouteLabel(buses, 'O0759AAP0A'), 'SP759');
+  assert.equal(transitRouteLabel(buses, 'O0014AAA0A'), 'LECD135');
+  assert.equal(transitRouteLabel(buses, 'E2303AAA0A'), '2303');
+  const brt = getTransitFeed('smtr-rio-brt');
+  assert.equal(transitRouteLabel(brt, '20000501110'), '50');
+  assert.equal(transitRouteLabel(brt, '20000EXEC1110'), 'ESP01');
+  // Unknown ids, prototype names included, keep their raw key.
+  assert.equal(transitRouteLabel(buses, 'O9999AAA0A'), 'O9999AAA0A');
+  assert.equal(transitRouteLabel(buses, 'constructor'), 'constructor');
+  assert.equal(transitRouteLabel(brt, null), null);
+});
+
+test('the Rio route table is a clean join of published keys to names', () => {
+  const entries = Object.entries(RIO_ROUTE_NAMES);
+  assert.ok(entries.length > 400, 'the whole published table is carried');
+  for (const [id, name] of entries) {
+    assert.match(id, /^(?:[OE]\d{4}[A-Z0-9]{5}|2\d{4}[A-Z0-9]{4,8})$/, id);
+    assert.ok(name && name === name.trim(), `${id} has a name`);
+    assert.notEqual(name, id, `${id} is translated`);
+  }
+});
+
+test('Rio feeds are CC BY 4.0 and live', () => {
+  for (const id of ['smtr-rio-onibus', 'smtr-rio-brt']) {
+    const feed = getTransitFeed(id);
+    assert.equal(feed.defaultEnabled, true, `${id} is live`);
+    assert.equal(feed.license, 'CC BY 4.0');
+    assert.match(feed.licenseUrl, /^https:\/\/www\.data\.rio\/documents\//);
+    assert.match(feed.attribution, /Prefeitura da Cidade do Rio de Janeiro/);
+    assert.equal(transitModeFor(feed, null), 'bus');
+  }
+  const sources = readFileSync(
+    new URL('../../DATA_SOURCES.md', import.meta.url),
+    'utf8',
+  );
+  assert.ok(
+    sources
+      .split('\n')
+      .some((line) => line.startsWith('| **SMTR Rio de Janeiro')),
+    'Rio has a DATA_SOURCES row',
+  );
+});

src/data/transitProxy.test.mjs

@@ -137,6 +137,7 @@ function encodeFeed({
     const position = new PbfWriter();
     position.writeFloatField(1, entity.lat);
     position.writeFloatField(2, entity.lon);
+    if (entity.speed != null) position.writeFloatField(5, entity.speed);
     vehicle.writeBytesField(2, position.finish());
     if (entity.timestamp) vehicle.writeVarintField(5, entity.timestamp);
     const descriptor = new PbfWriter();
@@ -284,6 +285,15 @@ test('the snapshot builder fills timestamps from the header it decoded', () => {
   assert.equal(snapshot.feedTimestamp, 1_700_000_000);
 });
 
+test('Rio speeds pass through as the m/s they are published in', () => {
+  // Checked against vehicle movement on 2026-11-05.
+  const bytes = encodeFeed({
+    entities: [{ id: 'moving', lat: -22.9, lon: -43.2, speed: 10 }],
+  });
+  const rio = buildTransitSnapshot(getTransitFeed('smtr-rio-onibus'), bytes, 1);
+  assert.equal(rio.vehicles[0].speedMps, 10);
+});
+
 test('conditional-request validators and gzip ride along with feed identification', () => {
   const entur = getTransitFeed('entur-norway');
   const plain = transitUpstreamHeaders(entur);

src/firstRunExperience.test.mjs

@@ -1020,6 +1020,14 @@ test('the voice TOOL SCHEMA matches the pinned contract — the mission mapping
     'noir',
   ]);
   visualStyle.enum = [...visualStyle.enum, 'snow'];
+  // Tilt to an angle adds pitchDeg and rewords direction; restore
+  // the legacy camera fields to keep the pin.
+  const camera = legacyTools.find((tool) => tool.name === 'move_camera')
+    .parameters.properties;
+  assert.equal(camera.pitchDeg.type, 'number');
+  delete camera.pitchDeg;
+  camera.direction.description =
+    'Required for pan/tilt/rotate; orbit/rotate_globe default right.';
   const block = JSON.stringify(legacyTools);
   // Re-derived for the voice layer manifest (generated layer enums, alias and
   // field hints), point-and-ask's pointer/referent arguments and the prompt
@@ -1039,10 +1047,11 @@ test('the voice TOOL SCHEMA matches the pinned contract — the mission mapping
   // The Utilities panel adds one set_panel_open target; Sea Marks and Ski
   // Pistes extend the generated layer enums and alias hint; voice geometry
   // adds the analyst area scopes and the osm-places layer.
-  assert.equal(block.length, 31318, 'serialized tool schema length drifted');
+  // control_cockpit states the own-layer entry rule (Contacts not required).
+  assert.equal(block.length, 31372, 'serialized tool schema length drifted');
   assert.equal(
     crypto.createHash('sha256').update(block).digest('hex'),
-    'f5b42f41c2f575838f979e88a1dbff615a77ccd85fdf8fcd0a0a47d02f7d3ddc',
+    '7f593e78c232db972b04441f830b6a60f93916a6e5bc5a68eca7422cd1035508',
     'the first-run missions must ride EXISTING tools: no schema edit, no cache bust',
   );
   const instructions = fs.readFileSync(

src/globeInView.js

@@ -0,0 +1,179 @@
+import * as Cesium from 'cesium';
+
+// Cesium's free look (Shift+drag) turns the camera in place. Near the ground
+// that surveys a city; from orbit a few drags turn the whole planet out of
+// frame and leave only stars.
+export const FREE_LOOK_MAX_HEIGHT_METERS = 1_000_000;
+
+// A voice turn from orbit stops when about this share of the frame still shows
+// the planet's surface.
+export const MIN_GLOBE_FRAME_SHARE = 0.1;
+
+/**
+ * A free globe camera: the viewer is in 3D, follows no tracked entity, and its
+ * camera is not locked to a reference frame.
+ */
+export function isFreeGlobeCamera(viewer) {
+  return (
+    viewer.scene.mode === Cesium.SceneMode.SCENE3D &&
+    !viewer.trackedEntity &&
+    Cesium.Matrix4.equals(viewer.camera.transform, Cesium.Matrix4.IDENTITY)
+  );
+}
+
+const GRID_COLUMNS = 32;
+const GRID_ROWS = 18;
+// A turn across a sliver of planet moves its edge through sample points, so
+// the share wobbles by a cell or two without the planet leaving.
+const GRID_NOISE_CELLS = 2;
+// Whatever the baseline, a voice turn never takes the planet below this share
+// of the frame; a view that already shows less may only keep what it has.
+const LOOK_ABSOLUTE_FLOOR_SHARE = 0.01;
+const sampleRay = new Cesium.Ray();
+const sampleOffset = new Cesium.Cartesian3();
+
+/**
+ * Cast a 32×18 grid of view rays, one through the centre of each cell, at the
+ * WGS84 ellipsoid. With `keyholeRadius` (a radius around the frame centre, in
+ * units of half the frame height) only the cells inside that circle count: the
+ * scope mask hides the rest. Returns the surface hits and the cells counted, or
+ * null for a frustum other than a perspective one.
+ */
+function sampleFrame(camera, keyholeRadius) {
+  const frustum = camera.frustum;
+  if (!(frustum instanceof Cesium.PerspectiveFrustum)) return null;
+  const aspect = frustum.aspectRatio;
+  const tanY = Math.tan(frustum.fovy / 2);
+  const tanX = tanY * aspect;
+  const keyholeSquared = keyholeRadius > 0 ? keyholeRadius * keyholeRadius : 0;
+  Cesium.Cartesian3.clone(camera.positionWC, sampleRay.origin);
+  let hits = 0;
+  let cells = 0;
+  for (let row = 0; row < GRID_ROWS; row += 1) {
+    const rowY = (2 * (row + 0.5)) / GRID_ROWS - 1;
+    for (let column = 0; column < GRID_COLUMNS; column += 1) {
+      const columnX = (2 * (column + 0.5)) / GRID_COLUMNS - 1;
+      if (
+        keyholeSquared &&
+        (columnX * aspect) ** 2 + rowY * rowY > keyholeSquared
+      )
+        continue;
+      cells += 1;
+      Cesium.Cartesian3.multiplyByScalar(
+        camera.rightWC,
+        columnX * tanX,
+        sampleOffset,
+      );
+      Cesium.Cartesian3.add(
+        camera.directionWC,
+        sampleOffset,
+        sampleRay.direction,
+      );
+      Cesium.Cartesian3.multiplyByScalar(
+        camera.upWC,
+        rowY * tanY,
+        sampleOffset,
+      );
+      Cesium.Cartesian3.add(
+        sampleRay.direction,
+        sampleOffset,
+        sampleRay.direction,
+      );
+      Cesium.Cartesian3.normalize(sampleRay.direction, sampleRay.direction);
+      if (
+        Cesium.IntersectionTests.rayEllipsoid(sampleRay, Cesium.Ellipsoid.WGS84)
+      )
+        hits += 1;
+    }
+  }
+  return { hits, cells };
+}
+
+/**
+ * Share of the frame, from 0 to 1, that shows the planet's surface: the
+ * fraction of a 32×18 grid of view rays, one through the centre of each cell,
+ * that hit the WGS84 ellipsoid. With `keyholeRadius` (see `sampleFrame`) it is
+ * the share of the visible circle instead. A frustum other than a perspective
+ * one counts as fully covered.
+ */
+export function globeFrameShare(camera, { keyholeRadius = 0 } = {}) {
+  const sample = sampleFrame(camera, keyholeRadius);
+  if (!sample || sample.cells === 0) return 1;
+  return sample.hits / sample.cells;
+}
+
+/** True when none of the planet's surface is in `camera`'s visible frame. */
+export function globeOutOfFrame(camera, options) {
+  return globeFrameShare(camera, options) === 0;
+}
+
+const lookProbes = new WeakMap();
+const LOOK_EDGE_TOLERANCE = Cesium.Math.toRadians(0.05);
+
+/**
+ * How much of one in-place look step (`lookUp`, `lookDown`, `lookLeft` or
+ * `lookRight` by a non-negative `angle` in radians) keeps the planet in frame
+ * from orbit. Above the free-look height the step may not leave less than
+ * `MIN_GLOBE_FRAME_SHARE` of the visible frame on the planet, or less than
+ * `startShare` when that is lower, give or take two grid cells of sampling
+ * noise. However the baseline was taken, it never leaves less than 1% of the
+ * frame, and a view that already shows less may only keep or gain what it has.
+ * `startShare` is the baseline the turn is measured against (the current share
+ * by default): callers pass one value to every step of a motion, and to every
+ * turn that continues from where the last one left off, so the limit cannot
+ * slide down a step or a command at a time. `keyholeRadius` limits the measure
+ * to the scope's visible circle, as in `globeFrameShare`.
+ * With nothing on screen the limit is nothing either, so the step is left to
+ * the move-end recovery. Returns `angle` when the whole step fits, otherwise a
+ * smaller angle that fits, found by bisection to within 0.05°, so a stopped
+ * motion rests at the limit. Steps are tried on a copy; `camera` is not moved.
+ */
+export function lookAngleWithinFrame(
+  camera,
+  look,
+  angle,
+  { startShare, keyholeRadius = 0 } = {},
+) {
+  if (
+    !(angle > 0) ||
+    !(camera.positionCartographic?.height > FREE_LOOK_MAX_HEIGHT_METERS)
+  )
+    return angle;
+  const sample = sampleFrame(camera, keyholeRadius);
+  if (!sample || sample.cells === 0) return angle;
+  const share = sample.hits / sample.cells;
+  const baseline = startShare ?? share;
+  // Capped at what is on screen now, so a step that keeps or gains surface is
+  // never refused, even when the frame has shrunk since the baseline was taken
+  // (a resized window or a turned phone).
+  const floor = Math.min(
+    share,
+    Math.max(
+      Math.min(MIN_GLOBE_FRAME_SHARE, baseline) -
+        GRID_NOISE_CELLS / sample.cells,
+      Math.min(LOOK_ABSOLUTE_FLOOR_SHARE, baseline),
+    ),
+  );
+  const fits = (step) => {
+    const probe = Cesium.Camera.clone(camera, lookProbes.get(camera));
+    lookProbes.set(camera, probe);
+    probe[look](step);
+    // Shares are whole grid cells; the epsilon keeps rounding in `floor` from
+    // costing a cell.
+    return globeFrameShare(probe, { keyholeRadius }) >= floor - 1e-9;
+  };
+  if (fits(angle)) return angle;
+  let inside = 0;
+  let outside = angle;
+  while (outside - inside > LOOK_EDGE_TOLERANCE) {
+    const middle = (inside + outside) / 2;
+    if (fits(middle)) inside = middle;
+    else outside = middle;
+  }
+  return inside;
+}
+
+/** True when an in-place look step of `angle` would lose part of its turn. */
+export function lookStepLosesGlobe(camera, look, angle, options) {
+  return lookAngleWithinFrame(camera, look, angle, options) < angle;
+}

src/i18n/locales/ar.json

@@ -301,6 +301,8 @@
   "AVAILABLE MISSIONS": "المهام المتاحة",
   "SELECT A MISSION TO INSPECT": "اختر مهمة لفحصها",
   "LOADING 30-DAY MISSION INDEX": "جارٍ تحميل فهرس مهام 30 يومًا",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "المهام الفضائية غير متاحة: تعذّر تحميل فهرس المهام. حاول مرة أخرى لاحقًا.",
+  "30-DAY MISSION INDEX UNAVAILABLE": "فهرس مهام 30 يومًا غير متاح",
   "RADIO": "الراديو",
   "ENABLE": "تفعيل",
   "Previous filtered radio station": "محطة الراديو السابقة في القائمة المصفّاة",
@@ -1747,8 +1749,16 @@
   "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": "هجين",
+  "Lines": "خطوط",
+  "Dots": "نقاط",
+  "Road lines colored by live flow: green to red": "خطوط الطرق ملوّنة حسب التدفق المباشر: من الأخضر إلى الأحمر",
+  "Moving dots colored by live flow": "نقاط متحركة ملوّنة حسب التدفق المباشر",
+  "Moving dots": "نقاط متحركة",
   "TomTom key unavailable": "مفتاح TomTom غير متاح",
   "TomTom daily budget reached": "بلغت الحصة اليومية لـ TomTom",
+  "Monthly traffic allowance used": "تم استهلاك حصة حركة المرور الشهرية",
+  "Traffic rate limit reached": "تم بلوغ حد طلبات حركة المرور",
+  "Traffic service unavailable": "خدمة حركة المرور غير متاحة",
   "TomTom upstream unreachable": "تعذّر الوصول إلى خادم TomTom",
   "TomTom flow unavailable": "تدفق TomTom غير متاح",
   "SIMULATED — {reason}": "محاكى — {reason}",
@@ -2187,6 +2197,9 @@
   "{value} KM/H": "{value} كم/س",
   "{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": "قائمة الطائرات القريبة غير مكتملة · لا يعني أن الوضع آمن",
   "SQUAWK {code} · {status}": "SQUAWK {code} · {status}",
   "ADS-B PRIORITY · {status}": "أولوية ADS-B · {status}",
   "ADS-B EMERGENCY · {status}": "طوارئ ADS-B · {status}",
@@ -3214,6 +3227,19 @@
   "Download the timing log of the last play": "تنزيل سجل توقيت آخر تشغيل",
   "Edit anchors, data packs and shot details": "تعديل نقاط الارتكاز وحزم البيانات وتفاصيل اللقطة",
   "Download this scene as JSON or an asset bundle": "تنزيل هذا المشهد بصيغة JSON أو حزمة موارد",
+  "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)",
+  "≥ {value} MW": "{value} MW على الأقل",
+  "Confidence": "الثقة",
+  "Minimum fire radiative power, megawatts": "الحد الأدنى للقدرة الإشعاعية للحريق، بالميغاواط",
+  "fire intensity filter|All": "الكل",
+  "Detection confidence": "ثقة الرصد",
+  "{shown} of {total} shown": "المعروضة: {shown} من {total}",
   "Name of {name}": "اسم {name}",
   "Change the colour of {name}": "تغيير لون {name}",
   "Colour of {name}": "لون {name}",
@@ -3225,15 +3251,15 @@
   "Directions, drawing and your own files": "الاتجاهات والرسم وملفاتك الخاصة",
   "Voice place search (needs an Overpass server)": "البحث الصوتي عن الأماكن (يتطلب خادم Overpass)",
   "OSM Places": "أماكن OSM",
-  "state or province": "ولاية أو مقاطعة",
-  "county or district": "محافظة أو قضاء",
+  "state or province": "ولاية أو إقليم",
+  "county or district": "مقاطعة أو قضاء",
   "neighbourhood": "حي",
   "natural region": "منطقة طبيعية",
   "Which {place}?": "أي {place} تقصد؟",
   "Which place?": "أي مكان تقصد؟",
-  "Not drawn: {parts}": "لم يُرسم: {parts}",
+  "Not drawn: {parts}": "لم يُرسم المخطط: {parts}",
   "approximate": "تقريبي",
-  "{pct}% cloud": "غيوم {pct}%",
+  "{pct}% cloud": "الغيوم {pct}%",
   "Over {area}": "فوق {area}",
   "{count} of {total} acquisitions match": {
     "few": "الصور المطابقة: {count} من {total}",
@@ -3244,12 +3270,12 @@
     "other": "الصور المطابقة: {count} من {total}"
   },
   "{n} acquisitions searched": {
-    "few": "الصور التي جرى البحث فيها: {n}",
-    "many": "الصور التي جرى البحث فيها: {n}",
-    "one": "الصور التي جرى البحث فيها: {n}",
-    "two": "الصور التي جرى البحث فيها: {n}",
-    "zero": "الصور التي جرى البحث فيها: {n}",
-    "other": "الصور التي جرى البحث فيها: {n}"
+    "zero": "الصور المفحوصة: {n}",
+    "one": "الصور المفحوصة: {n}",
+    "two": "الصور المفحوصة: {n}",
+    "few": "الصور المفحوصة: {n}",
+    "many": "الصور المفحوصة: {n}",
+    "other": "الصور المفحوصة: {n}"
   },
   "No matching imagery": "لا توجد صور مطابقة",
   "Unknown number of {kind}": "{kind}: العدد غير معروف",
@@ -3257,10 +3283,10 @@
   "At least {count} {kind}": "{kind}: {count} على الأقل",
   "{count} {kind}": "{kind}: {count}",
   "In {area}": "في {area}",
-  "Area around {place}": "المنطقة المحيطة بـ{place}",
-  "Area around landmark": "المنطقة المحيطة بمعلم",
-  "Outline {place}": "تحديد مخطط {place}",
-  "Outline area": "تحديد مخطط منطقة",
+  "Area around {place}": "المنطقة حول {place}",
+  "Area around landmark": "المنطقة حول المعلم",
+  "Outline {place}": "رسم مخطط {place}",
+  "Outline area": "رسم مخطط منطقة",
   "Find {place}": "البحث عن {place}",
   "Find area": "البحث عن منطقة",
   "Find recent imagery": "البحث عن صور حديثة",
@@ -3303,19 +3329,21 @@
     "zero": "التكرارات المدمجة: {count}"
   },
   "listed the first {limit}": "عُرض أول {limit}",
-  "counted over the bounding box of {area}, not its outline": "عُدّ ضمن المستطيل المحيط ({area})، لا ضمن الحدود",
+  "counted over the bounding box of {area}, not its outline": "جرى العدّ ضمن المستطيل المحيط بمنطقة {area}، لا ضمن حدودها الفعلية",
   "Search cancelled": "أُلغي البحث",
-  "Sea Marks": "علامات بحرية",
+  "Sea Marks": "العلامات البحرية",
   "Ski Pistes": "مسارات التزلج",
-  "Fly to Tokyo": "الانتقال إلى طوكيو",
-  "Show live flights": "عرض الرحلات المباشرة",
+  "Fly to Tokyo": "انتقل إلى طوكيو",
+  "Show live flights": "اعرض تتبّع الرحلات المباشر",
+  "Reset to globe view": "ارجع إلى عرض الكرة الأرضية",
+  "Show earthquakes": "اعرض الزلازل",
   "AI chat": "دردشة الذكاء الاصطناعي",
   "GEV CHAT": "دردشة GEV",
-  "Ask about the map. Tell it where to go.": "اسأل عن الخريطة. أخبرها إلى أين تذهب.",
+  "Ask about the map. Tell it where to go.": "اسأل عن الخريطة، ووجّهها إلى حيث تريد.",
   "Close chat": "إغلاق الدردشة",
   "Conversation": "المحادثة",
   "Explore with a question": "استكشف بسؤال",
-  "Find a place, explore live data, or change your view.": "ابحث عن مكان، أو استكشف بيانات مباشرة، أو غيّر العرض.",
+  "Find a place, explore live data, or change your view.": "ابحث عن مكان، أو استكشف البيانات المباشرة، أو غيّر العرض الحالي.",
   "Attachments": "المرفقات",
   "Remove attachment": "إزالة المرفق",
   "Attach a map layer": "إرفاق طبقة خريطة",
@@ -3332,36 +3360,36 @@
   "Stop reply": "إيقاف الرد",
   "Send message": "إرسال الرسالة",
   "Panel position": "موضع اللوحة",
-  "Move above the dock": "النقل فوق الشريط",
-  "Dock to the right": "تثبيت إلى اليمين",
+  "Move above the dock": "النقل فوق الشريط السفلي",
+  "Dock to the right": "تثبيت على اليسار",
   "Expand panel": "توسيع اللوحة",
   "Minimize panel": "تصغير اللوحة",
   "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 غير فارغ.",
+  "Choose a non-empty UTF-8 text file.": "اختر ملفًا نصيًا غير فارغ بترميز UTF-8.",
   "Connecting…": "جارٍ الاتصال…",
   "Thinking…": "جارٍ التفكير…",
   "Working on the map…": "جارٍ العمل على الخريطة…",
   "Silent chat · microphone off": "دردشة صامتة · الميكروفون متوقف",
-  "Reply interrupted. You can try again.": "توقف الرد. يمكنك المحاولة مرة أخرى.",
-  "Could not connect. Try again.": "تعذّر الاتصال. حاول مرة أخرى.",
+  "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.": "انتهت مهلة الاتصال. حاول مرة أخرى.",
+  "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.": "لم تُرسل الرسالة. حاول مرة أخرى.",
+  "Message was not sent. Try again.": "لم تُرسل الرسالة. أعد المحاولة.",
   "Reply stopped.": "أُوقف الرد.",
-  "Suggestions": "اقتراحات",
+  "Suggestions": "الاقتراحات",
   "Recent": "الأخيرة",
-  "Quick commands": "أوامر سريعة",
+  "Quick commands": "الأوامر السريعة",
   "Open AI chat": "فتح دردشة الذكاء الاصطناعي",
   "CHAT": "دردشة",
   "Back to chat": "العودة إلى الدردشة",
   "Back to voice": "العودة إلى الصوت",
-  "Latest voice exchange": "آخر تبادل صوتي",
+  "Latest voice exchange": "آخر حوار صوتي",
   "Try saying": "جرّب أن تقول",
   "What am I looking at?": "ما الذي أنظر إليه؟",
   "AI Provider": "مزوّد الذكاء الاصطناعي",
@@ -3370,15 +3398,15 @@
   "Chat replies are silent. No microphone access is needed.": "ردود الدردشة صامتة. لا حاجة إلى الوصول إلى الميكروفون.",
   "Chat": "الدردشة",
   "Attach layer": "إرفاق الطبقة",
-  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "تستخدم الدردشة الكتابية مفتاح OpenAI API الخاص بك. تسجيل الدخول إلى ChatGPT يشمل الصوت فقط.",
-  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "الدردشة الكتابية غير متاحة بينما يفرض GEV_PREFER_CODEX_OAUTH استخدام ChatGPT OAuth.",
+  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "تستخدم الدردشة النصية مفتاح OpenAI API الخاص بك. تسجيل الدخول إلى ChatGPT يشمل الصوت فقط.",
+  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "الدردشة النصية غير متاحة ما دام GEV_PREFER_CODEX_OAUTH يفرض استخدام ChatGPT OAuth.",
   "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.": "تطلّب هذا الطلب خطوات كثيرة جدًا. جرّب طلبًا أبسط.",
-  "The provider rejected the API key. Check it in Provider Settings.": "رفض المزوّد مفتاح API. تحقّق منه في إعدادات المزوّد.",
-  "Too many chat requests. Try again in {seconds} s.": "طلبات دردشة كثيرة جدًا. حاول مجددًا بعد {seconds} ث.",
-  "The provider refused access for this key. Check the key's project, region or permissions.": "رفض المزوّد الوصول لهذا المفتاح. تحقّق من مشروع المفتاح أو منطقته أو أذوناته.",
+  "The provider rejected the API key. Check it in Provider Settings.": "رفض المزوّد مفتاح API. تحقّق منه في «إعدادات المزوّدين».",
+  "Too many chat requests. Try again in {seconds} s.": "طلبات دردشة كثيرة جدًا. أعد المحاولة بعد {seconds} ث.",
+  "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.": "نفد رصيد حساب المزوّد. تحقّق من الفوترة، أو اختر مزوّد ذكاء اصطناعي آخر في الإعدادات.",
-  "{lower} to {upper}": "{lower} إلى {upper}",
+  "{lower} to {upper}": "من {lower} إلى {upper}",
   "Up to {upper}": "حتى {upper}",
   "From {lower}": "من {lower}",
   "Informational only · not for flight planning": "للعلم فقط · لا يصلح لتخطيط الرحلات",
@@ -3386,8 +3414,75 @@
   "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 Map أو قيود طيران 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).": "المجال الجوي المحظور والمقيّد ذو الاستخدام الخاص لدى FAA فقط، ولا يشمل UAS Facility Map ولا قيود طيران UAS. للعلم فقط — ولا يغني عن الأدوات الرسمية لتخطيط رحلات UAS (B4UFLY / LAANC).",
   "Prohibited": "محظور",
   "Restricted": "مقيّد",
-  "Prohibited & Restricted Airspace": "المجال الجوي المحظور والمقيّد"
+  "Prohibited & Restricted Airspace": "المجال الجوي المحظور والمقيّد",
+  "SIGHTING": "مشاهدة",
+  "Show {name} sighting": "إظهار مشاهدة {name}",
+  "seen {age} ago": "شوهد قبل {age}",
+  "observed {age} ago": "رُصد قبل {age}",
+  "Be Whale Wise": "راقب الحيتان بمسؤولية",
+  "Reported by {name} ({entity})": "أبلغ عنه {name} ({entity})",
+  "Reported by {name}": "أبلغ عنه {name}",
+  "Salish Sea": "بحر ساليش",
+  "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": "إظهار المشاهدات المؤكدة مجتمعياً (بدرجة بحثية) فقط",
+  "No recent sightings in view": "لا توجد مشاهدات حديثة في العرض",
+  "Acartia feed unavailable": "تعذر الوصول إلى مصدر Acartia",
+  "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": "مشاهدات الحياة البرية",
+  "Exit cockpit to fly to a sighting": "اخرج من قمرة القيادة للانتقال إلى مشاهدة",
+  "Exit cockpit to fly to a sighting area": "اخرج من قمرة القيادة للانتقال إلى منطقة مشاهدة",
+  "Wildlife": "الحياة البرية",
+  "Zoom in for local sightings": "قرّب لرؤية المشاهدات المحلية",
+  "Loading photo...": "جارٍ تحميل الصورة…",
+  "Photo unavailable": "الصورة غير متاحة",
+  "Location obscured to a 0.2° cell": "الموقع مخفي ضمن خلية بمقدار 0.2°",
+  "Photo of {name}": "صورة {name}",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "{count} مشاهدة ضمن النطاق",
+  "Close sighting": "إغلاق المشاهدة",
+  "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° فقط؛ وتُقرّب مشاهدات الثدييات البحرية في بحر ساليش عبر Acartia إلى 0.01°. ليست إحصاءً شاملاً.",
+  "Open {name} on iNaturalist": "فتح {name} على iNaturalist",
+  "Open {name} on Acartia": "فتح {name} على Acartia",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "مساهمو iNaturalist · التراخيص لكل سجل",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "مساهمو iNaturalist · Acartia {count} (بحر ساليش) · التراخيص لكل سجل",
+  "{days}d": "{days}ي",
+  "All markers": "كل العلامات",
+  "Show markers of every age": "عرض العلامات من جميع الأعمار",
+  "Maximum event age: {days}d; undated markers are kept": "الحد الأقصى لعمر الحدث: {days} يوم؛ تُحفظ العلامات غير المؤرخة",
+  "event age filter|All": "الكل",
+  "Event age": "عمر الحدث",
+  "Event age: {days}d · undated kept": "عمر الحدث: {days} يوم · الاحتفاظ بغير المؤرخ",
+  "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 الخاص بك."
 }

src/i18n/locales/de.json

@@ -760,6 +760,8 @@
   "AVAILABLE MISSIONS": "VERFÜGBARE MISSIONEN",
   "SELECT A MISSION TO INSPECT": "MISSION ZUM ANSEHEN WÄHLEN",
   "LOADING 30-DAY MISSION INDEX": "30-TAGE-MISSIONSINDEX WIRD GELADEN",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "Raummissionen nicht verfügbar: Der Missionsindex konnte nicht geladen werden. Später erneut versuchen.",
+  "30-DAY MISSION INDEX UNAVAILABLE": "30-TAGE-MISSIONSINDEX NICHT VERFÜGBAR",
   "TAB PREVIEWS · ENTER / SPACE SELECTS": "TAB: VORSCHAU · ENTER / LEERTASTE: AUSWAHL",
   "Internet radio and local SDR": "Internetradio und lokales SDR",
   "STATION TAG": "KATEGORIE",
@@ -1665,8 +1667,16 @@
   "TomTom roads first; OpenStreetMap fills the rest, simulated": "Zuerst TomTom-Straßen; OpenStreetMap füllt den Rest, simuliert",
   "TomTom roads first; OpenStreetMap fills the rest, simulated (needs a TomTom key)": "Zuerst TomTom-Straßen; OpenStreetMap füllt den Rest, simuliert (braucht einen TomTom-Schlüssel)",
   "Hybrid": "Hybrid",
+  "Lines": "Linien",
+  "Dots": "Punkte",
+  "Road lines colored by live flow: green to red": "Straßenlinien nach Live-Verkehrsfluss gefärbt: grün bis rot",
+  "Moving dots colored by live flow": "Bewegte Punkte nach Live-Verkehrsfluss gefärbt",
+  "Moving dots": "Bewegte Punkte",
   "TomTom key unavailable": "TomTom-Schlüssel nicht verfügbar",
   "TomTom daily budget reached": "TomTom-Tagesbudget erreicht",
+  "Monthly traffic allowance used": "Monatliches Verkehrskontingent aufgebraucht",
+  "Traffic rate limit reached": "Verkehrs-Anfragelimit erreicht",
+  "Traffic service unavailable": "Verkehrsdienst nicht verfügbar",
   "TomTom upstream unreachable": "TomTom-Upstream nicht erreichbar",
   "TomTom flow unavailable": "TomTom-Verkehrsfluss nicht verfügbar",
   "SIMULATED — {reason}": "SIMULIERT – {reason}",
@@ -2087,6 +2097,9 @@
   "{value} KM/H": "{value} KM/H",
   "{label} · {radius} AIR/SEA WINDOW": "{label} · {radius} LUFT-/SEEFENSTER",
   "{scope} · INSTALLATIONS {coverage}": "{scope} · ANLAGEN {coverage}",
+  "MILITARY FEED OFF · PARTIAL PICTURE": "MILITÄR-FEED AUS · UNVOLLSTÄNDIGES LAGEBILD",
+  "FLIGHTS FEED OFF · PARTIAL PICTURE": "FLUG-FEED AUS · UNVOLLSTÄNDIGES LAGEBILD",
+  "NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR": "FLUGZEUGE IN DER NÄHE UNVOLLSTÄNDIG · KEINE ENTWARNUNG",
   "SQUAWK {code} · {status}": "SQUAWK {code} · {status}",
   "ADS-B PRIORITY · {status}": "ADS-B-PRIORITÄT · {status}",
   "ADS-B EMERGENCY · {status}": "ADS-B-NOTFALL · {status}",
@@ -2912,7 +2925,7 @@
   "From {lower}": "Ab {lower}",
   "Informational only · not for flight planning": "Nur zur Information · nicht für die Flugplanung",
   "Unnamed zone": "Unbenannte Zone",
-  "Restricted airspace source unavailable": "Quelle für Sperrgebiete nicht verfügbar",
+  "Restricted airspace source unavailable": "Quelle für Sperr- und Flugbeschränkungsgebiete nicht verfügbar",
   "Prohibited (P)": "Sperrgebiet (P)",
   "Restricted (R)": "Flugbeschränkungsgebiet (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).": "Nur Sperr- und Flugbeschränkungsgebiete der FAA (Luftraum mit besonderer Nutzung), nicht die UAS Facility Map oder UAS-Flugbeschränkungen. Nur zur Information – kein Ersatz für offizielle UAS-Flugplanungstools (B4UFLY / LAANC).",
@@ -2946,6 +2959,19 @@
   "Right panels": "Rechte Panels",
   "CONFIRMED": "BESTÄTIGT",
   "PAD / RTLS": "STARTPLATZ / RTLS",
+  "fire confidence filter|All": "Alle",
+  "fire confidence filter|Nominal+": "Mittel+",
+  "fire confidence filter|High": "Hoch",
+  "Every detection — many of the strongest fires are rated low confidence": "Alle Erkennungen – viele der stärksten Brände haben eine niedrige Konfidenz",
+  "Nominal and high confidence detections": "Erkennungen mit mittlerer und hoher Konfidenz",
+  "High confidence detections only": "Nur Erkennungen mit hoher Konfidenz",
+  "Fire intensity (FRP)": "Intensität (FRP)",
+  "≥ {value} MW": "≥ {value} MW",
+  "Confidence": "Konfidenz",
+  "Minimum fire radiative power, megawatts": "Mindestwert der Strahlungsleistung des Brandes in Megawatt",
+  "fire intensity filter|All": "Alle",
+  "Detection confidence": "Konfidenz der Erkennung",
+  "{shown} of {total} shown": "{shown} von {total} angezeigt",
   "Name of {name}": "Name von {name}",
   "Change the colour of {name}": "Farbe von {name} ändern",
   "Colour of {name}": "Farbe von {name}",
@@ -2982,9 +3008,9 @@
   "{count} {kind}": "{kind}: {count}",
   "In {area}": "Gebiet: {area}",
   "Area around {place}": "Gebiet um {place}",
-  "Area around landmark": "Gebiet um ein Wahrzeichen",
-  "Outline {place}": "{place} umreißen",
-  "Outline area": "Gebiet umreißen",
+  "Area around landmark": "Gebiet um einen Ort",
+  "Outline {place}": "Umriss von {place} zeichnen",
+  "Outline area": "Umriss zeichnen",
   "Find {place}": "{place} finden",
   "Find area": "Gebiet finden",
   "Find recent imagery": "Aktuelle Bilddaten finden",
@@ -2995,99 +3021,168 @@
   "Loading imagery": "Bilddaten werden geladen",
   "Searching OpenStreetMap": "OpenStreetMap wird durchsucht",
   "voice area|Area": "Gebiet",
-  "buffer sized to the place": "Puffer in Größe des Ortes",
+  "buffer sized to the place": "Puffer entsprechend der Ortsgröße",
   "enclosing mapped area": "umschließendes kartiertes Gebiet",
-  "the map was cleared while looking it up": "die Karte wurde während der Suche geleert",
-  "OpenStreetMap coverage varies by place": "Die Abdeckung von OpenStreetMap ist je nach Ort unterschiedlich",
+  "the map was cleared while looking it up": "die Zeichenfläche wurde während der Suche geleert",
+  "OpenStreetMap coverage varies by place": "die Abdeckung von OpenStreetMap ist je nach Ort unterschiedlich",
   "the catalog covers the last 30 days": "der Katalog umfasst die letzten 30 Tage",
   "there are more": "es gibt weitere",
-  "{radius} m around the landmark": "{radius} m um das Wahrzeichen",
+  "{radius} m around the landmark": "{radius} m um den Ort",
   "{count} parts": {
-    "one": "Teile: {count}",
-    "other": "Teile: {count}"
+    "one": "{count} Teil",
+    "other": "{count} Teile"
   },
   "{drawn} of {total} parts drawn": {
-    "one": "Gezeichnete Teile: {drawn} von {total}",
-    "other": "Gezeichnete Teile: {drawn} von {total}"
+    "one": "{drawn} von {total} Teil gezeichnet",
+    "other": "{drawn} von {total} Teilen gezeichnet"
   },
   "{count} duplicate mappings merged": {
-    "one": "Zusammengeführte Doppelkartierungen: {count}",
-    "other": "Zusammengeführte Doppelkartierungen: {count}"
+    "one": "{count} Duplikat zusammengeführt",
+    "other": "{count} Duplikate zusammengeführt"
   },
   "listed the first {limit}": "die ersten {limit} aufgelistet",
-  "counted over the bounding box of {area}, not its outline": "über das umgebende Rechteck gezählt ({area}), nicht über den Umriss",
+  "counted over the bounding box of {area}, not its outline": "im umgebenden Rechteck von {area} gezählt, nicht innerhalb des Umrisses",
   "Search cancelled": "Suche abgebrochen",
   "Sea Marks": "Seezeichen",
   "Ski Pistes": "Skipisten",
   "Fly to Tokyo": "Nach Tokio fliegen",
   "Show live flights": "Live-Flüge anzeigen",
+  "Reset to globe view": "Zur Globusansicht zurückkehren",
+  "Show earthquakes": "Erdbeben anzeigen",
   "AI chat": "KI-Chat",
   "GEV CHAT": "GEV-CHAT",
-  "Ask about the map. Tell it where to go.": "Frag zur Karte. Sag ihr, wohin es geht.",
+  "Ask about the map. Tell it where to go.": "Fragen zur Karte stellen und Ziele nennen.",
   "Close chat": "Chat schließen",
-  "Conversation": "Unterhaltung",
+  "Conversation": "Gespräch",
   "Explore with a question": "Mit einer Frage erkunden",
-  "Find a place, explore live data, or change your view.": "Finde einen Ort, erkunde Live-Daten oder ändere deine Ansicht.",
+  "Find a place, explore live data, or change your view.": "Einen Ort finden, Live-Daten erkunden oder die Ansicht ändern.",
   "Attachments": "Anhänge",
   "Remove attachment": "Anhang entfernen",
   "Attach a map layer": "Kartenebene anhängen",
   "Choose a layer…": "Ebene wählen…",
   "Attach a file": "Datei anhängen",
-  "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 oder GeoJSON · insgesamt bis zu 10 KB. Anhänge werden mit deiner Nachricht an deinen KI-Anbieter gesendet.",
+  "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 oder GeoJSON · insgesamt bis zu 10 KB. Anhänge werden mit der Nachricht an den gewählten KI-Anbieter gesendet.",
   "Latest AI response": "Neueste KI-Antwort",
-  "Expand conversation": "Unterhaltung erweitern",
+  "Expand conversation": "Gespräch ausklappen",
   "Command suggestions": "Befehlsvorschläge",
-  "Expand chat": "Chat erweitern",
+  "Expand chat": "Chat ausklappen",
   "Add attachment": "Anhang hinzufügen",
   "Message GEV": "Nachricht an GEV",
-  "Ask GEV anything about the map…": "Frag GEV alles zur Karte…",
+  "Ask GEV anything about the map…": "GEV etwas zur Karte fragen…",
   "Stop reply": "Antwort stoppen",
   "Send message": "Nachricht senden",
-  "Panel position": "Panelposition",
+  "Panel position": "Bereichsposition",
   "Move above the dock": "Über das Dock verschieben",
   "Dock to the right": "Rechts andocken",
-  "Expand panel": "Panel erweitern",
-  "Minimize panel": "Panel minimieren",
-  "You can attach up to four items.": "Du kannst bis zu vier Elemente anhängen.",
-  "Attachments are too large together. Use smaller files.": "Die Anhänge sind zusammen zu groß. Verwende kleinere Dateien.",
-  "Choose a TXT, Markdown, CSV, JSON or GeoJSON file.": "Wähle eine TXT-, Markdown-, CSV-, JSON- oder GeoJSON-Datei.",
+  "Expand panel": "Bereich ausklappen",
+  "Minimize panel": "Bereich minimieren",
+  "You can attach up to four items.": "Es können höchstens vier Elemente angehängt werden.",
+  "Attachments are too large together. Use smaller files.": "Die Anhänge sind zusammen zu groß. Kleinere Dateien verwenden.",
+  "Choose a TXT, Markdown, CSV, JSON or GeoJSON file.": "Eine TXT-, Markdown-, CSV-, JSON- oder GeoJSON-Datei wählen.",
   "Each file must be 10 KB or smaller.": "Jede Datei darf höchstens 10 KB groß sein.",
-  "Choose a non-empty UTF-8 text file.": "Wähle eine nicht leere UTF-8-Textdatei.",
-  "Connecting…": "Verbinde…",
+  "Choose a non-empty UTF-8 text file.": "Eine nicht leere UTF-8-Textdatei wählen.",
+  "Connecting…": "Verbindet…",
   "Thinking…": "Denkt nach…",
   "Working on the map…": "Arbeitet an der Karte…",
-  "Silent chat · microphone off": "Stiller Chat · Mikrofon aus",
-  "Reply interrupted. You can try again.": "Antwort unterbrochen. Du kannst es erneut versuchen.",
-  "Could not connect. Try again.": "Verbindung fehlgeschlagen. Versuch es erneut.",
-  "Session ended. Send a message to start a new conversation.": "Sitzung beendet. Sende eine Nachricht, um eine neue Unterhaltung zu beginnen.",
-  "Connection timed out. Try again.": "Zeitüberschreitung der Verbindung. Versuch es erneut.",
+  "Silent chat · microphone off": "Chat ohne Ton · Mikrofon aus",
+  "Reply interrupted. You can try again.": "Antwort unterbrochen. Erneut versuchen.",
+  "Could not connect. Try again.": "Verbindung fehlgeschlagen. Erneut versuchen.",
+  "Session ended. Send a message to start a new conversation.": "Sitzung beendet. Für ein neues Gespräch eine Nachricht senden.",
+  "Connection timed out. Try again.": "Zeitüberschreitung bei der Verbindung. Erneut versuchen.",
   "Chat closed.": "Chat geschlossen.",
   "Connection stopped.": "Verbindung beendet.",
-  "Message and attachments are too large. Remove an attachment or shorten your message.": "Nachricht und Anhänge sind zu groß. Entferne einen Anhang oder kürze deine Nachricht.",
-  "Message was not sent. Try again.": "Nachricht wurde nicht gesendet. Versuch es erneut.",
+  "Message and attachments are too large. Remove an attachment or shorten your message.": "Nachricht und Anhänge sind zu groß. Einen Anhang entfernen oder die Nachricht kürzen.",
+  "Message was not sent. Try again.": "Nachricht wurde nicht gesendet. Erneut versuchen.",
   "Reply stopped.": "Antwort gestoppt.",
   "Suggestions": "Vorschläge",
-  "Recent": "Zuletzt",
+  "Recent": "Zuletzt verwendet",
   "Quick commands": "Schnellbefehle",
   "Open AI chat": "KI-Chat öffnen",
   "CHAT": "CHAT",
   "Back to chat": "Zurück zum Chat",
   "Back to voice": "Zurück zur Sprachsteuerung",
-  "Latest voice exchange": "Letzter Sprachaustausch",
-  "Try saying": "Sag zum Beispiel",
+  "Latest voice exchange": "Letzter Sprachdialog",
+  "Try saying": "Zum Beispiel",
   "What am I looking at?": "Was sehe ich gerade?",
   "AI Provider": "KI-Anbieter",
-  "The selected AI provider is shared by voice and chat.": "Der gewählte KI-Anbieter gilt für Sprache und Chat.",
+  "The selected AI provider is shared by voice and chat.": "Der gewählte KI-Anbieter gilt für Sprachsteuerung und Chat.",
   "Show quick commands": "Schnellbefehle anzeigen",
   "Chat replies are silent. No microphone access is needed.": "Chat-Antworten sind stumm. Kein Mikrofonzugriff nötig.",
   "Chat": "Chat",
   "Attach layer": "Ebene anhängen",
-  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "Der Text-Chat nutzt deinen OpenAI-API-Schlüssel. Die ChatGPT-Anmeldung gilt nur für Sprache.",
+  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "Der Text-Chat nutzt den OpenAI-API-Schlüssel. Die ChatGPT-Anmeldung gilt nur für die Sprachsteuerung.",
   "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "Der Text-Chat ist nicht verfügbar, solange GEV_PREFER_CODEX_OAUTH ChatGPT OAuth vorschreibt.",
   "That request needed too many steps. Changes already made to the map stay in place.": "Diese Anfrage brauchte zu viele Schritte. Bereits vorgenommene Kartenänderungen bleiben erhalten.",
-  "That request needed too many steps. Try a simpler request.": "Diese Anfrage brauchte zu viele Schritte. Versuche eine einfachere Anfrage.",
-  "The provider rejected the API key. Check it in Provider Settings.": "Der Anbieter hat den API-Schlüssel abgelehnt. Prüfe ihn in den Anbieter-Einstellungen.",
+  "That request needed too many steps. Try a simpler request.": "Diese Anfrage brauchte zu viele Schritte. Eine einfachere Anfrage versuchen.",
+  "The provider rejected the API key. Check it in Provider Settings.": "Der Anbieter hat den API-Schlüssel abgelehnt. Den Schlüssel in den Anbieter-Einstellungen prüfen.",
   "Too many chat requests. Try again in {seconds} s.": "Zu viele Chat-Anfragen. In {seconds} s erneut versuchen.",
-  "The provider refused access for this key. Check the key's project, region or permissions.": "Der Anbieter hat den Zugriff für diesen Schlüssel verweigert. Prüfe Projekt, Region oder Berechtigungen des Schlüssels.",
-  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "Das Anbieterkonto hat kein Guthaben mehr. Prüfe die Abrechnung oder wähle in den Einstellungen einen anderen KI-Anbieter."
+  "The provider refused access for this key. Check the key's project, region or permissions.": "Der Anbieter hat den Zugriff für diesen Schlüssel verweigert. Projekt, Region oder Berechtigungen des Schlüssels prüfen.",
+  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "Das Anbieterkonto hat kein Guthaben mehr. Die Abrechnung prüfen oder in den Einstellungen einen anderen KI-Anbieter wählen.",
+  "SIGHTING": "BEOBACHTUNG",
+  "Show {name} sighting": "Beobachtung von {name} anzeigen",
+  "seen {age} ago": "vor {age} gesichtet",
+  "observed {age} ago": "vor {age} beobachtet",
+  "Be Whale Wise": "Wale respektvoll beobachten",
+  "Reported by {name} ({entity})": "Gemeldet von {name} ({entity})",
+  "Reported by {name}": "Gemeldet von {name}",
+  "Salish Sea": "Salish-See",
+  "Birds": "Vögel",
+  "Mammals": "Säugetiere",
+  "Reptiles": "Reptilien",
+  "Amphibians": "Amphibien",
+  "Ray-finned fishes": "Strahlenflosser",
+  "Insects": "Insekten",
+  "Arachnids": "Spinnentiere",
+  "Plants": "Pflanzen",
+  "Fungi": "Pilze",
+  "Other animals": "Andere Tiere",
+  "Other or unknown": "Andere oder unbekannt",
+  "{label} {detail} — click to retry": "{label} {detail} — zum Wiederholen klicken",
+  "Wildlife sightings source unavailable": "Quelle für Naturbeobachtungen nicht verfügbar",
+  "Show only community-confirmed (research-grade) sightings": "Nur gemeinschaftlich bestätigte Beobachtungen (Forschungsqualität) anzeigen",
+  "No recent sightings in view": "Keine aktuellen Beobachtungen im Ausschnitt",
+  "Acartia feed unavailable": "Acartia-Datenstrom nicht verfügbar",
+  "Show all taxa": "Alle Artengruppen anzeigen",
+  "BIRDS": "VÖGEL",
+  "Show only birds": "Nur Vögel anzeigen",
+  "MAMMALS": "SÄUGETIERE",
+  "Show only mammals": "Nur Säugetiere anzeigen",
+  "WHALES": "WALE",
+  "Show only whales and dolphins (7 days)": "Nur Wale und Delfine anzeigen (7 Tage)",
+  "INSECTS": "INSEKTEN",
+  "Show only insects": "Nur Insekten anzeigen",
+  "PLANTS": "PFLANZEN",
+  "Show only plants": "Nur Pflanzen anzeigen",
+  "All rights reserved": "Alle Rechte vorbehalten",
+  "Cetacean": "Wal oder Delfin",
+  "Wildlife Sightings": "Naturbeobachtungen",
+  "Exit cockpit to fly to a sighting": "Cockpit verlassen, um zu einer Beobachtung zu fliegen",
+  "Exit cockpit to fly to a sighting area": "Cockpit verlassen, um zu einem Beobachtungsgebiet zu fliegen",
+  "Wildlife": "Tierwelt",
+  "Zoom in for local sightings": "Für lokale Beobachtungen vergrößern",
+  "Loading photo...": "Foto wird geladen…",
+  "Photo unavailable": "Foto nicht verfügbar",
+  "Location obscured to a 0.2° cell": "Standort auf eine 0,2°-Rasterzelle verschleiert",
+  "Photo of {name}": "Foto von {name}",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "{count} Sichtungen im Ausschnitt",
+  "Close sighting": "Sichtung schließen",
+  "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.": "In den letzten 48 h beobachtete Wildtiere (Wale 7 Tage). Farbe und Abzeichensymbol zeigen die Artengruppe. Empfindliche Arten erscheinen nur als 0,2°-Zellen; Acartia-Meldungen zu Meeressäugern aus der Salish-See werden auf 0,01° gerundet. Keine Bestandszählung.",
+  "Open {name} on iNaturalist": "{name} auf iNaturalist öffnen",
+  "Open {name} on Acartia": "{name} auf Acartia öffnen",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "iNaturalist-Beitragende · Lizenzen je Eintrag",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "iNaturalist-Beitragende · Acartia {count} (Salish-See) · Lizenzen je Eintrag",
+  "{days}d": "{days}T",
+  "All markers": "Alle Markierungen",
+  "Show markers of every age": "Markierungen jeden Alters anzeigen",
+  "Maximum event age: {days}d; undated markers are kept": "Maximales Ereignisalter: {days} Tage; undatierte Markierungen bleiben",
+  "event age filter|All": "Alle",
+  "Event age": "Ereignisalter",
+  "Event age: {days}d · undated kept": "Ereignisalter: {days} Tage · undatierte bleiben",
+  "Close camera preview": "Kameravorschau schließen",
+  "Refresh map still": "Kartenstandbild aktualisieren",
+  "The map still uses a separate request and may show a different moment.": "Das Kartenstandbild wird separat abgerufen und kann einen anderen Moment zeigen.",
+  "Video plays from Québec 511, which sees your IP address.": "Das Video wird von Québec 511 abgespielt, das Ihre IP-Adresse sieht."
 }

src/i18n/locales/es.json

@@ -192,6 +192,8 @@
   "AVAILABLE MISSIONS": "MISIONES DISPONIBLES",
   "SELECT A MISSION TO INSPECT": "SELECCIONA UNA MISIÓN PARA INSPECCIONAR",
   "LOADING 30-DAY MISSION INDEX": "CARGANDO ÍNDICE DE MISIONES DE 30 DÍAS",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "Misiones espaciales no disponibles: no se pudo cargar el índice de misiones. Inténtalo más tarde.",
+  "30-DAY MISSION INDEX UNAVAILABLE": "ÍNDICE DE MISIONES DE 30 DÍAS NO DISPONIBLE",
   "RADIO": "RADIO",
   "ENABLE": "ACTIVAR",
   "Previous filtered radio station": "Emisora de radio filtrada anterior",
@@ -1920,6 +1922,9 @@
   "N/A": "N/D",
   "{label} · {radius} AIR/SEA WINDOW": "{label} · VENTANA AIRE/MAR {radius}",
   "{scope} · INSTALLATIONS {coverage}": "{scope} · INSTALACIONES: {coverage}",
+  "MILITARY FEED OFF · PARTIAL PICTURE": "FUENTE MILITAR DESACTIVADA · PANORAMA PARCIAL",
+  "FLIGHTS FEED OFF · PARTIAL PICTURE": "FUENTE DE VUELOS DESACTIVADA · PANORAMA PARCIAL",
+  "NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR": "AERONAVES CERCANAS INCOMPLETAS · NO IMPLICA TODO DESPEJADO",
   "{source} · LOCATION QUERY · RECENT": "{source} · CONSULTA POR UBICACIÓN · RECIENTE",
   "ft": "ft",
   "kts": "kn",
@@ -2271,6 +2276,9 @@
   "SIMULATED — {reason}": "SIMULADO — {reason}",
   "TomTom key unavailable": "Clave de TomTom no disponible",
   "TomTom daily budget reached": "Se alcanzó el límite diario de TomTom",
+  "Monthly traffic allowance used": "Cupo mensual de tráfico agotado",
+  "Traffic rate limit reached": "Límite de solicitudes de tráfico alcanzado",
+  "Traffic service unavailable": "Servicio de tráfico no disponible",
   "TomTom upstream unreachable": "Servidor de TomTom inaccesible",
   "TomTom flow unavailable": "Flujo de TomTom no disponible",
   "API key rejected — check AISSTREAM_API_KEY": "Clave de API rechazada — revisa AISSTREAM_API_KEY",
@@ -2691,6 +2699,11 @@
   "Zoom in for vector tile coverage": "Acércate para cargar las teselas vectoriales",
   "Camera coverage unavailable": "Cobertura de cámaras no disponible",
   "Hybrid": "Híbrido",
+  "Lines": "Líneas",
+  "Dots": "Puntos",
+  "Road lines colored by live flow: green to red": "Líneas de vías coloreadas por el flujo en vivo: de verde a rojo",
+  "Moving dots colored by live flow": "Puntos en movimiento coloreados por el flujo en vivo",
+  "Moving dots": "Puntos en movimiento",
   "TomTom roads only, each with its live flow": "Solo vías de TomTom, cada una con su flujo en vivo",
   "TomTom roads only, each with its live flow (needs a TomTom key)": "Solo vías de TomTom, cada una con su flujo en vivo (necesita una clave de TomTom)",
   "OpenStreetMap roads, with TomTom flow matched when available": "Vías de OpenStreetMap, con el flujo de TomTom emparejado cuando está disponible",
@@ -2983,7 +2996,20 @@
   "Voice replies appear here.": "Las respuestas de voz aparecen aquí.",
   "Preview is off.": "La vista previa está desactivada.",
   "Automatic stop is unavailable for this voice connection.": "La parada automática no está disponible para esta conexión de voz.",
-  "{lower} to {upper}": "{lower} a {upper}",
+  "fire confidence filter|All": "Todas",
+  "fire confidence filter|Nominal+": "Nominal+",
+  "fire confidence filter|High": "Alta",
+  "Every detection — many of the strongest fires are rated low confidence": "Todas las detecciones — muchos de los incendios más intensos se clasifican con confianza baja",
+  "Nominal and high confidence detections": "Detecciones de confianza nominal y alta",
+  "High confidence detections only": "Solo detecciones de confianza alta",
+  "Fire intensity (FRP)": "Intensidad (FRP)",
+  "≥ {value} MW": "≥ {value} MW",
+  "Confidence": "Confianza",
+  "Minimum fire radiative power, megawatts": "Potencia radiativa mínima del fuego, en megavatios",
+  "fire intensity filter|All": "Todo",
+  "Detection confidence": "Confianza de la detección",
+  "{shown} of {total} shown": "Mostrando {shown} de {total}",
+  "{lower} to {upper}": "De {lower} a {upper}",
   "Up to {upper}": "Hasta {upper}",
   "From {lower}": "Desde {lower}",
   "Informational only · not for flight planning": "Solo informativo · no apto para planificar vuelos",
@@ -2991,9 +3017,9 @@
   "Restricted airspace source unavailable": "Fuente de espacio aéreo restringido no disponible",
   "Prohibited (P)": "Prohibido (P)",
   "Restricted (R)": "Restringido (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).": "Solo espacio aéreo de uso especial prohibido y restringido de la FAA, sin el UAS Facility Map ni las restricciones de vuelo de UAS. Solo informativo: no sustituye a las herramientas oficiales de planificación de vuelos de UAS (B4UFLY / LAANC).",
-  "Prohibited": "Prohibido",
-  "Restricted": "Restringido",
+  "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).": "Solo espacio aéreo de uso especial prohibido y restringido de la FAA; no incluye el UAS Facility Map ni las restricciones de vuelo de UAS. Solo informativo — no sustituye a las herramientas oficiales de planificación de vuelos de UAS (B4UFLY / LAANC).",
+  "Prohibited": "Zona prohibida",
+  "Restricted": "Zona restringida",
   "Prohibited & Restricted Airspace": "Espacio aéreo prohibido y restringido",
   "routing busy — too many routes at once": "servicio de rutas ocupado: demasiadas rutas a la vez",
   "route proxy error": "error del proxy de rutas",
@@ -3031,11 +3057,11 @@
   "county or district": "condado o distrito",
   "neighbourhood": "barrio",
   "natural region": "región natural",
-  "Which {place}?": "¿Cuál {place}?",
+  "Which {place}?": "¿Qué {place}?",
   "Which place?": "¿Qué lugar?",
   "Not drawn: {parts}": "Sin dibujar: {parts}",
-  "approximate": "aproximado",
-  "{pct}% cloud": "{pct} % de nubes",
+  "approximate": "aproximada",
+  "{pct}% cloud": "{pct}% de nubes",
   "Over {area}": "Zona: {area}",
   "{count} of {total} acquisitions match": {
     "many": "Adquisiciones coincidentes: {count} de {total}",
@@ -3049,7 +3075,7 @@
   },
   "No matching imagery": "No hay imágenes que coincidan",
   "Unknown number of {kind}": "{kind}: número desconocido",
-  "About {count} {kind}": "{kind}: unos {count}",
+  "About {count} {kind}": "{kind}: aproximadamente {count}",
   "At least {count} {kind}": "{kind}: al menos {count}",
   "{count} {kind}": "{kind}: {count}",
   "In {area}": "En {area}",
@@ -3068,12 +3094,12 @@
   "Searching OpenStreetMap": "Buscando en OpenStreetMap",
   "voice area|Area": "Área",
   "buffer sized to the place": "zona aproximada del tamaño del lugar",
-  "enclosing mapped area": "zona cartografiada que lo rodea",
+  "enclosing mapped area": "zona mapeada que contiene el punto de interés",
   "the map was cleared while looking it up": "el mapa se borró durante la búsqueda",
-  "OpenStreetMap coverage varies by place": "La cobertura de OpenStreetMap varía según el lugar",
+  "OpenStreetMap coverage varies by place": "la cobertura de OpenStreetMap varía según el lugar",
   "the catalog covers the last 30 days": "el catálogo cubre los últimos 30 días",
   "there are more": "hay más",
-  "{radius} m around the landmark": "{radius} m alrededor del lugar",
+  "{radius} m around the landmark": "{radius} m alrededor del punto de interés",
   "{count} parts": {
     "many": "Partes: {count}",
     "one": "Partes: {count}",
@@ -3090,12 +3116,14 @@
     "other": "Duplicados fusionados: {count}"
   },
   "listed the first {limit}": "se listaron los primeros {limit}",
-  "counted over the bounding box of {area}, not its outline": "contado en el rectángulo que lo rodea ({area}), no en su contorno",
+  "counted over the bounding box of {area}, not its outline": "se contó en el rectángulo que abarca {area}, no dentro de su contorno",
   "Search cancelled": "Búsqueda cancelada",
   "Sea Marks": "Señales marítimas",
   "Ski Pistes": "Pistas de esquí",
-  "Fly to Tokyo": "Volar a Tokio",
-  "Show live flights": "Mostrar vuelos en vivo",
+  "Fly to Tokyo": "Vuela a Tokio",
+  "Show live flights": "Muestra los vuelos en vivo",
+  "Reset to globe view": "Vuelve a la vista del globo",
+  "Show earthquakes": "Muestra los terremotos",
   "AI chat": "Chat de IA",
   "GEV CHAT": "CHAT DE GEV",
   "Ask about the map. Tell it where to go.": "Pregunta sobre el mapa. Indica adónde ir.",
@@ -3109,12 +3137,12 @@
   "Choose a layer…": "Elige una capa…",
   "Attach a file": "Adjuntar un archivo",
   "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 o GeoJSON · hasta 10 KB en total. Los adjuntos se envían a tu proveedor de IA con el mensaje.",
-  "Latest AI response": "Última respuesta de IA",
+  "Latest AI response": "Última respuesta de la IA",
   "Expand conversation": "Expandir conversación",
   "Command suggestions": "Sugerencias de comandos",
   "Expand chat": "Expandir chat",
   "Add attachment": "Añadir adjunto",
-  "Message GEV": "Enviar mensaje a GEV",
+  "Message GEV": "Mensaje para GEV",
   "Ask GEV anything about the map…": "Pregunta a GEV lo que quieras sobre el mapa…",
   "Stop reply": "Detener respuesta",
   "Send message": "Enviar mensaje",
@@ -3124,7 +3152,7 @@
   "Expand panel": "Expandir panel",
   "Minimize panel": "Minimizar panel",
   "You can attach up to four items.": "Puedes adjuntar hasta cuatro elementos.",
-  "Attachments are too large together. Use smaller files.": "Los adjuntos juntos son demasiado grandes. Usa archivos más pequeños.",
+  "Attachments are too large together. Use smaller files.": "El tamaño total de los adjuntos es demasiado grande. Usa archivos más pequeños.",
   "Choose a TXT, Markdown, CSV, JSON or GeoJSON file.": "Elige un archivo TXT, Markdown, CSV, JSON o GeoJSON.",
   "Each file must be 10 KB or smaller.": "Cada archivo debe tener como máximo 10 KB.",
   "Choose a non-empty UTF-8 text file.": "Elige un archivo de texto UTF-8 que no esté vacío.",
@@ -3135,7 +3163,7 @@
   "Reply interrupted. You can try again.": "Respuesta interrumpida. Puedes intentarlo de nuevo.",
   "Could not connect. Try again.": "No se pudo conectar. Inténtalo de nuevo.",
   "Session ended. Send a message to start a new conversation.": "Sesión finalizada. Envía un mensaje para iniciar una nueva conversación.",
-  "Connection timed out. Try again.": "La conexión agotó el tiempo de espera. Inténtalo de nuevo.",
+  "Connection timed out. Try again.": "Se agotó el tiempo de conexión. Inténtalo de nuevo.",
   "Chat closed.": "Chat cerrado.",
   "Connection stopped.": "Conexión detenida.",
   "Message and attachments are too large. Remove an attachment or shorten your message.": "El mensaje y los adjuntos son demasiado grandes. Quita un adjunto o acorta el mensaje.",
@@ -3147,9 +3175,9 @@
   "Open AI chat": "Abrir chat de IA",
   "CHAT": "CHAT",
   "Back to chat": "Volver al chat",
-  "Back to voice": "Volver a voz",
+  "Back to voice": "Volver a la voz",
   "Latest voice exchange": "Último intercambio de voz",
-  "Try saying": "Prueba a decir",
+  "Try saying": "Intenta decir",
   "What am I looking at?": "¿Qué estoy viendo?",
   "AI Provider": "Proveedor de IA",
   "The selected AI provider is shared by voice and chat.": "El proveedor de IA seleccionado se usa tanto para voz como para chat.",
@@ -3157,12 +3185,79 @@
   "Chat replies are silent. No microphone access is needed.": "Las respuestas del chat son silenciosas. No se necesita acceso al micrófono.",
   "Chat": "Chat",
   "Attach layer": "Adjuntar capa",
-  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "El chat escrito usa tu clave de la API de OpenAI. El inicio de sesión de ChatGPT solo cubre la voz.",
-  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "El chat escrito no está disponible mientras GEV_PREFER_CODEX_OAUTH exija ChatGPT OAuth.",
-  "That request needed too many steps. Changes already made to the map stay in place.": "Esa solicitud necesitó demasiados pasos. Los cambios ya hechos en el mapa se mantienen.",
-  "That request needed too many steps. Try a simpler request.": "Esa solicitud necesitó demasiados pasos. Prueba una solicitud más sencilla.",
-  "The provider rejected the API key. Check it in Provider Settings.": "El proveedor rechazó la clave de API. Revísala en Ajustes del proveedor.",
+  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "El chat escrito usa tu clave de API de OpenAI. El inicio de sesión de ChatGPT solo sirve para la voz.",
+  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "El chat escrito no está disponible mientras GEV_PREFER_CODEX_OAUTH exija OAuth de ChatGPT.",
+  "That request needed too many steps. Changes already made to the map stay in place.": "Esa solicitud requirió demasiados pasos. Los cambios ya hechos en el mapa se mantienen.",
+  "That request needed too many steps. Try a simpler request.": "Esa solicitud requirió demasiados pasos. Prueba una solicitud más sencilla.",
+  "The provider rejected the API key. Check it in Provider Settings.": "El proveedor rechazó la clave de API. Revísala en Ajustes de proveedores.",
   "Too many chat requests. Try again in {seconds} s.": "Demasiadas solicitudes de chat. Vuelve a intentarlo en {seconds} s.",
   "The provider refused access for this key. Check the key's project, region or permissions.": "El proveedor denegó el acceso a esta clave. Revisa el proyecto, la región o los permisos de la clave.",
-  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "La cuenta del proveedor no tiene crédito. Revisa la facturación o elige otro proveedor de IA en Ajustes."
+  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "La cuenta del proveedor no tiene crédito. Revisa la facturación o elige otro proveedor de IA en Ajustes.",
+  "SIGHTING": "AVISTAMIENTO",
+  "Show {name} sighting": "Mostrar avistamiento de {name}",
+  "seen {age} ago": "visto hace {age}",
+  "observed {age} ago": "observado hace {age}",
+  "Be Whale Wise": "Observa cetáceos con respeto",
+  "Reported by {name} ({entity})": "Reportado por {name} ({entity})",
+  "Reported by {name}": "Reportado por {name}",
+  "Salish Sea": "Mar de Salish",
+  "Birds": "Aves",
+  "Mammals": "Mamíferos",
+  "Reptiles": "Reptiles",
+  "Amphibians": "Anfibios",
+  "Ray-finned fishes": "Peces de aletas radiadas",
+  "Insects": "Insectos",
+  "Arachnids": "Arácnidos",
+  "Plants": "Plantas",
+  "Fungi": "Hongos",
+  "Other animals": "Otros animales",
+  "Other or unknown": "Otros o desconocidos",
+  "{label} {detail} — click to retry": "{label} {detail} — haz clic para reintentar",
+  "Wildlife sightings source unavailable": "Fuente de avistamientos no disponible",
+  "Show only community-confirmed (research-grade) sightings": "Mostrar solo observaciones confirmadas por la comunidad (grado de investigación)",
+  "No recent sightings in view": "No hay avistamientos recientes en la vista",
+  "Acartia feed unavailable": "Fuente Acartia no disponible",
+  "Show all taxa": "Mostrar todos los grupos taxonómicos",
+  "BIRDS": "AVES",
+  "Show only birds": "Mostrar solo aves",
+  "MAMMALS": "MAMÍFEROS",
+  "Show only mammals": "Mostrar solo mamíferos",
+  "WHALES": "CETÁCEOS",
+  "Show only whales and dolphins (7 days)": "Mostrar solo ballenas y delfines (7 días)",
+  "INSECTS": "INSECTOS",
+  "Show only insects": "Mostrar solo insectos",
+  "PLANTS": "PLANTAS",
+  "Show only plants": "Mostrar solo plantas",
+  "All rights reserved": "Todos los derechos reservados",
+  "Cetacean": "Cetáceo",
+  "Wildlife Sightings": "Avistamientos de fauna y flora",
+  "Exit cockpit to fly to a sighting": "Sal de la cabina para volar a un avistamiento",
+  "Exit cockpit to fly to a sighting area": "Sal de la cabina para volar a un área de avistamiento",
+  "Wildlife": "Vida silvestre",
+  "Zoom in for local sightings": "Acerca para ver avistamientos locales",
+  "Loading photo...": "Cargando foto…",
+  "Photo unavailable": "Foto no disponible",
+  "Location obscured to a 0.2° cell": "Ubicación oculta en una celda de 0,2°",
+  "Photo of {name}": "Foto de {name}",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "{count} avistamientos en la vista",
+  "Close sighting": "Cerrar avistamiento",
+  "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.": "Fauna observada en las últimas 48 h (cetáceos 7 días). El color y el símbolo de la insignia indican el grupo taxonómico. Las especies sensibles solo se muestran en celdas de 0,2°; los informes de mamíferos marinos de Acartia en el mar de Salish se redondean a 0,01°. No es un censo.",
+  "Open {name} on iNaturalist": "Abrir {name} en iNaturalist",
+  "Open {name} on Acartia": "Abrir {name} en Acartia",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "Colaboradores de iNaturalist · licencias por registro",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "Colaboradores de iNaturalist · Acartia {count} (mar de Salish) · licencias por registro",
+  "{days}d": "{days}d",
+  "All markers": "Todos los marcadores",
+  "Show markers of every age": "Mostrar marcadores de cualquier antigüedad",
+  "Maximum event age: {days}d; undated markers are kept": "Antigüedad máxima: {days} días; se conservan los marcadores sin fecha",
+  "event age filter|All": "Todos",
+  "Event age": "Antigüedad",
+  "Event age: {days}d · undated kept": "Antigüedad: {days} días · se conservan los marcadores sin fecha",
+  "Close camera preview": "Cerrar vista previa de la cámara",
+  "Refresh map still": "Actualizar imagen fija del mapa",
+  "The map still uses a separate request and may show a different moment.": "La imagen del mapa usa una solicitud independiente y puede mostrar otro momento.",
+  "Video plays from Québec 511, which sees your IP address.": "El vídeo se reproduce desde Québec 511, que ve tu dirección IP."
 }

src/i18n/locales/fr.json

@@ -1103,8 +1103,16 @@
   "TomTom roads first; OpenStreetMap fills the rest, simulated": "Routes TomTom d'abord ; OpenStreetMap complète le reste, en simulation",
   "TomTom roads first; OpenStreetMap fills the rest, simulated (needs a TomTom key)": "Routes TomTom d'abord ; OpenStreetMap complète le reste, en simulation (nécessite une clé TomTom)",
   "Hybrid": "Hybride",
+  "Lines": "Lignes",
+  "Dots": "Points",
+  "Road lines colored by live flow: green to red": "Routes colorées selon le trafic en direct : du vert au rouge",
+  "Moving dots colored by live flow": "Points mobiles colorés selon le trafic en direct",
+  "Moving dots": "Points mobiles",
   "TomTom key unavailable": "Clé TomTom indisponible",
   "TomTom daily budget reached": "Quota quotidien TomTom atteint",
+  "Monthly traffic allowance used": "Quota mensuel de trafic épuisé",
+  "Traffic rate limit reached": "Limite de requêtes de trafic atteinte",
+  "Traffic service unavailable": "Service de trafic indisponible",
   "TomTom upstream unreachable": "Serveur TomTom injoignable",
   "TomTom flow unavailable": "Flux TomTom indisponible",
   "SIMULATED — {reason}": "SIMULÉ — {reason}",
@@ -1660,6 +1668,9 @@
   "REGIONAL NEWS": "ACTUS RÉGIONALES",
   "{label} · {radius} AIR/SEA WINDOW": "{label} · AIR/MER {radius}",
   "{scope} · INSTALLATIONS {coverage}": "{scope} · INSTALLATIONS : {coverage}",
+  "MILITARY FEED OFF · PARTIAL PICTURE": "FLUX MILITAIRE COUPÉ · SITUATION PARTIELLE",
+  "FLIGHTS FEED OFF · PARTIAL PICTURE": "FLUX DES VOLS COUPÉ · SITUATION PARTIELLE",
+  "NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR": "AÉRONEFS PROCHES INCOMPLETS · PAS UN FEU VERT",
   "CONTEXT STANDBY": "CONTEXTE EN VEILLE",
   "ENABLE GLOBAL CONTEXT FOR PROXIMITY PINGS": "ACTIVER LE CONTEXTE GLOBAL POUR LES PINGS DE PROXIMITÉ",
   "CONTACT LOST · LAST KNOWN READOUT · NOT AN ALL-CLEAR": "CONTACT PERDU · DERNIER RELEVÉ CONNU · PAS UN FEU VERT",
@@ -2799,6 +2810,8 @@
   "AVAILABLE MISSIONS": "MISSIONS DISPONIBLES",
   "SELECT A MISSION TO INSPECT": "CHOISIR UNE MISSION À EXAMINER",
   "LOADING 30-DAY MISSION INDEX": "CHARGEMENT DE L'INDEX DES MISSIONS À 30 JOURS",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "Missions spatiales indisponibles : impossible de charger l’index des missions. Réessayez plus tard.",
+  "30-DAY MISSION INDEX UNAVAILABLE": "INDEX DES MISSIONS À 30 JOURS INDISPONIBLE",
   "TAB PREVIEWS · ENTER / SPACE SELECTS": "TAB APERÇU · ENTER / SPACE SÉLECTIONNE",
   "Internet radio and local SDR": "Radio Internet et SDR local",
   "STATION TAG": "TAG DE STATION",
@@ -2977,18 +2990,18 @@
   "Tip: the GEV MIC button in the dock lets you talk to the map.": "Astuce : le bouton GEV MIC du dock permet de parler à la carte.",
   "Malformed cyclone snapshot": "Instantané cyclonique mal formé",
   "Cyclone request timed out": "Délai dépassé pour la requête cyclonique",
-  "{lower} to {upper}": "{lower} à {upper}",
-  "Up to {upper}": "Jusqu’à {upper}",
+  "{lower} to {upper}": "De {lower} à {upper}",
+  "Up to {upper}": "Jusqu'à {upper}",
   "From {lower}": "À partir de {lower}",
-  "Informational only · not for flight planning": "À titre informatif uniquement · ne pas utiliser pour la planification de vol",
-  "Unnamed zone": "Zone sans nom",
-  "Restricted airspace source unavailable": "Source de l’espace aérien réglementé indisponible",
+  "Informational only · not for flight planning": "À titre indicatif · ne pas utiliser pour la préparation des vols",
+  "Unnamed zone": "Sans nom",
+  "Restricted airspace source unavailable": "Source de l'espace aérien réglementé indisponible",
   "Prohibited (P)": "Zone interdite (P)",
   "Restricted (R)": "Zone réglementée (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).": "Uniquement les zones interdites et réglementées de la FAA (espace aérien à usage spécial), sans la UAS Facility Map ni les restrictions de vol des drones. À titre informatif uniquement — ne remplace pas les outils officiels de planification de vol des drones (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).": "Uniquement les zones interdites et réglementées de la FAA (espace aérien à usage spécial), sans la UAS Facility Map ni les restrictions de vol des drones. À titre indicatif uniquement — ne remplace pas les outils officiels de préparation des vols de drones (B4UFLY / LAANC).",
   "Prohibited": "Zone interdite",
   "Restricted": "Zone réglementée",
-  "Prohibited & Restricted Airspace": "Zones interdites et réglementées",
+  "Prohibited & Restricted Airspace": "Espaces aériens interdits et réglementés",
   "scene|PLAY": "LIRE",
   "AUTHORING": "CRÉATION",
   "Create and edit scenes": "Créer et modifier des scènes",
@@ -3016,6 +3029,19 @@
   "Right panels": "Panneaux de droite",
   "CONFIRMED": "CONFIRMÉE",
   "PAD / RTLS": "PAS DE TIR / RTLS",
+  "fire confidence filter|All": "Toutes",
+  "fire confidence filter|Nominal+": "Nominale+",
+  "fire confidence filter|High": "Élevée",
+  "Every detection — many of the strongest fires are rated low confidence": "Toutes les détections — de nombreux feux parmi les plus intenses sont classés en confiance faible",
+  "Nominal and high confidence detections": "Détections de confiance nominale et élevée",
+  "High confidence detections only": "Détections de confiance élevée uniquement",
+  "Fire intensity (FRP)": "Intensité (FRP)",
+  "≥ {value} MW": "≥ {value} MW",
+  "Confidence": "Confiance",
+  "Minimum fire radiative power, megawatts": "Puissance radiative minimale du feu, en mégawatts",
+  "fire intensity filter|All": "Toutes",
+  "Detection confidence": "Confiance de la détection",
+  "{shown} of {total} shown": "Affichés : {shown} sur {total}",
   "Name of {name}": "Nom de {name}",
   "Change the colour of {name}": "Changer la couleur de {name}",
   "Colour of {name}": "Couleur de {name}",
@@ -3025,7 +3051,7 @@
   "UTILITIES": "OUTILS",
   "Exit cockpit to fly to a drawing": "Quittez le cockpit pour rejoindre un dessin",
   "Directions, drawing and your own files": "Itinéraire, dessin et vos propres fichiers",
-  "Voice place search (needs an Overpass server)": "Recherche de lieux par la voix (nécessite un serveur Overpass)",
+  "Voice place search (needs an Overpass server)": "Recherche vocale de lieux (nécessite un serveur Overpass)",
   "OSM Places": "Lieux OSM",
   "state or province": "État ou province",
   "county or district": "comté ou district",
@@ -3033,9 +3059,9 @@
   "natural region": "région naturelle",
   "Which {place}?": "Quel lieu nommé {place} ?",
   "Which place?": "Quel lieu ?",
-  "Not drawn: {parts}": "Non dessiné : {parts}",
+  "Not drawn: {parts}": "Contour non tracé : {parts}",
   "approximate": "approximatif",
-  "{pct}% cloud": "{pct} % de nuages",
+  "{pct}% cloud": "{pct} % de nuages",
   "Over {area}": "Zone : {area}",
   "{count} of {total} acquisitions match": {
     "many": "Acquisitions correspondantes : {count} sur {total}",
@@ -3054,83 +3080,85 @@
   "{count} {kind}": "{kind} : {count}",
   "In {area}": "Zone : {area}",
   "Area around {place}": "Environs : {place}",
-  "Area around landmark": "Environs d'un repère",
+  "Area around landmark": "Environs d'un lieu",
   "Outline {place}": "Délimiter {place}",
   "Outline area": "Délimiter une zone",
   "Find {place}": "Trouver {place}",
   "Find area": "Trouver une zone",
   "Find recent imagery": "Trouver des images récentes",
-  "Find {what}": "Trouver {what}",
+  "Find {what}": "Trouver : {what}",
   "Find places": "Trouver des lieux",
   "Drawing outline": "Dessin du contour",
   "Searching imagery catalog": "Recherche dans le catalogue d'images",
   "Loading imagery": "Chargement des images",
   "Searching OpenStreetMap": "Recherche dans OpenStreetMap",
   "voice area|Area": "Zone",
-  "buffer sized to the place": "zone tampon à la taille du lieu",
+  "buffer sized to the place": "zone tampon adaptée à la taille du lieu",
   "enclosing mapped area": "zone cartographiée englobante",
   "the map was cleared while looking it up": "la carte a été effacée pendant la recherche",
-  "OpenStreetMap coverage varies by place": "La couverture OpenStreetMap varie selon les lieux",
+  "OpenStreetMap coverage varies by place": "la couverture OpenStreetMap varie selon les lieux",
   "the catalog covers the last 30 days": "le catalogue couvre les 30 derniers jours",
   "there are more": "il y en a d'autres",
   "{radius} m around the landmark": "{radius} m autour du lieu",
   "{count} parts": {
-    "many": "Parties : {count}",
-    "one": "Parties : {count}",
-    "other": "Parties : {count}"
+    "many": "Parties : {count}",
+    "one": "Parties : {count}",
+    "other": "Parties : {count}"
   },
   "{drawn} of {total} parts drawn": {
-    "many": "Parties tracées : {drawn} sur {total}",
-    "one": "Parties tracées : {drawn} sur {total}",
-    "other": "Parties tracées : {drawn} sur {total}"
+    "many": "Parties tracées : {drawn} sur {total}",
+    "one": "Parties tracées : {drawn} sur {total}",
+    "other": "Parties tracées : {drawn} sur {total}"
   },
   "{count} duplicate mappings merged": {
-    "many": "Doublons fusionnés : {count}",
-    "one": "Doublons fusionnés : {count}",
-    "other": "Doublons fusionnés : {count}"
+    "many": "Doublons fusionnés : {count}",
+    "one": "Doublons fusionnés : {count}",
+    "other": "Doublons fusionnés : {count}"
   },
-  "listed the first {limit}": "les {limit} premiers sont listés",
-  "counted over the bounding box of {area}, not its outline": "compté sur le rectangle englobant ({area}), pas sur le contour",
+  "listed the first {limit}": "liste limitée à {limit}",
+  "counted over the bounding box of {area}, not its outline": "compté dans le rectangle englobant ({area}), pas dans son contour exact",
   "Search cancelled": "Recherche annulée",
   "Sea Marks": "Balisage maritime",
   "Ski Pistes": "Pistes de ski",
   "Fly to Tokyo": "Aller à Tokyo",
   "Show live flights": "Afficher les vols en direct",
+  "Reset to globe view": "Revenir à la vue du globe",
+  "Show earthquakes": "Afficher les séismes",
   "AI chat": "Discussion IA",
   "GEV CHAT": "DISCUSSION GEV",
   "Ask about the map. Tell it where to go.": "Posez une question sur la carte. Dites-lui où aller.",
   "Close chat": "Fermer la discussion",
   "Conversation": "Conversation",
-  "Explore with a question": "Explorer avec une question",
+  "Explore with a question": "Explorez en posant une question",
   "Find a place, explore live data, or change your view.": "Trouvez un lieu, explorez des données en direct ou changez de vue.",
   "Attachments": "Pièces jointes",
   "Remove attachment": "Retirer la pièce jointe",
-  "Attach a map layer": "Joindre une couche de carte",
+  "Attach a map layer": "Joindre une couche de la carte",
   "Choose a layer…": "Choisir une couche…",
   "Attach a file": "Joindre un fichier",
-  "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 ou GeoJSON · 10 Ko max. au total. Les pièces jointes sont envoyées à votre fournisseur d’IA avec votre message.",
-  "Latest AI response": "Dernière réponse de l’IA",
-  "Expand conversation": "Agrandir la conversation",
+  "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 ou GeoJSON · 10 Ko max. au total. Les pièces jointes sont envoyées à votre fournisseur d'IA avec votre message.",
+  "Latest AI response": "Dernière réponse de l'IA",
+  "Expand conversation": "Développer la conversation",
   "Command suggestions": "Suggestions de commandes",
-  "Expand chat": "Agrandir la discussion",
+  "Expand chat": "Développer la discussion",
   "Add attachment": "Ajouter une pièce jointe",
   "Message GEV": "Message à GEV",
-  "Ask GEV anything about the map…": "Demandez à GEV ce que vous voulez sur la carte…",
+  "Ask GEV anything about the map…": "Posez à GEV toutes vos questions sur la carte…",
   "Stop reply": "Arrêter la réponse",
   "Send message": "Envoyer le message",
   "Panel position": "Position du panneau",
   "Move above the dock": "Placer au-dessus du dock",
   "Dock to the right": "Ancrer à droite",
-  "Expand panel": "Agrandir le panneau",
+  "Expand panel": "Développer le panneau",
   "Minimize panel": "Réduire le panneau",
-  "You can attach up to four items.": "Vous pouvez joindre jusqu’à quatre éléments.",
-  "Attachments are too large together. Use smaller files.": "Les pièces jointes sont trop volumineuses ensemble. Utilisez des fichiers plus petits.",
+  "You can attach up to four items.": "Vous pouvez joindre jusqu'à quatre éléments.",
+  "Attachments are too large together. Use smaller files.": "La taille totale des pièces jointes est trop importante. Utilisez des fichiers plus petits.",
   "Choose a TXT, Markdown, CSV, JSON or GeoJSON file.": "Choisissez un fichier TXT, Markdown, CSV, JSON ou GeoJSON.",
   "Each file must be 10 KB or smaller.": "Chaque fichier doit faire 10 Ko ou moins.",
   "Choose a non-empty UTF-8 text file.": "Choisissez un fichier texte UTF-8 non vide.",
   "Connecting…": "Connexion…",
   "Thinking…": "Réflexion…",
-  "Working on the map…": "Travail sur la carte…",
+  "Working on the map…": "Mise à jour de la carte…",
   "Silent chat · microphone off": "Discussion silencieuse · micro coupé",
   "Reply interrupted. You can try again.": "Réponse interrompue. Vous pouvez réessayer.",
   "Could not connect. Try again.": "Connexion impossible. Réessayez.",
@@ -3139,30 +3167,97 @@
   "Chat closed.": "Discussion fermée.",
   "Connection stopped.": "Connexion arrêtée.",
   "Message and attachments are too large. Remove an attachment or shorten your message.": "Le message et les pièces jointes sont trop volumineux. Retirez une pièce jointe ou raccourcissez votre message.",
-  "Message was not sent. Try again.": "Le message n’a pas été envoyé. Réessayez.",
+  "Message was not sent. Try again.": "Le message n'a pas été envoyé. Réessayez.",
   "Reply stopped.": "Réponse arrêtée.",
   "Suggestions": "Suggestions",
   "Recent": "Récents",
   "Quick commands": "Commandes rapides",
   "Open AI chat": "Ouvrir la discussion IA",
-  "CHAT": "DISCUSSION",
+  "CHAT": "CHAT",
   "Back to chat": "Retour à la discussion",
-  "Back to voice": "Retour à la voix",
+  "Back to voice": "Retour au mode vocal",
   "Latest voice exchange": "Dernier échange vocal",
   "Try saying": "Essayez de dire",
-  "What am I looking at?": "Qu’est-ce que je regarde ?",
-  "AI Provider": "Fournisseur d’IA",
-  "The selected AI provider is shared by voice and chat.": "Le fournisseur d’IA choisi est partagé par la voix et la discussion.",
+  "What am I looking at?": "Qu'est-ce que je regarde ?",
+  "AI Provider": "Fournisseur d'IA",
+  "The selected AI provider is shared by voice and chat.": "Le fournisseur d'IA choisi est commun à la voix et à la discussion.",
   "Show quick commands": "Afficher les commandes rapides",
-  "Chat replies are silent. No microphone access is needed.": "Les réponses de la discussion sont silencieuses. Aucun accès au micro n’est nécessaire.",
+  "Chat replies are silent. No microphone access is needed.": "Les réponses de la discussion sont silencieuses. Aucun accès au microphone n'est nécessaire.",
   "Chat": "Discussion",
   "Attach layer": "Joindre la couche",
-  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "Le chat écrit utilise votre clé d’API OpenAI. La connexion ChatGPT ne couvre que la voix.",
-  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "Le chat écrit est indisponible tant que GEV_PREFER_CODEX_OAUTH impose ChatGPT OAuth.",
-  "That request needed too many steps. Changes already made to the map stay in place.": "Cette demande a nécessité trop d’étapes. Les modifications déjà apportées à la carte sont conservées.",
-  "That request needed too many steps. Try a simpler request.": "Cette demande a nécessité trop d’étapes. Essayez une demande plus simple.",
-  "The provider rejected the API key. Check it in Provider Settings.": "Le fournisseur a refusé la clé d’API. Vérifiez-la dans les paramètres du fournisseur.",
-  "Too many chat requests. Try again in {seconds} s.": "Trop de requêtes de chat. Réessayez dans {seconds} s.",
-  "The provider refused access for this key. Check the key's project, region or permissions.": "Le fournisseur a refusé l’accès pour cette clé. Vérifiez le projet, la région ou les autorisations de la clé.",
-  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "Le compte du fournisseur n’a plus de crédit. Vérifiez la facturation ou choisissez un autre fournisseur d’IA dans les paramètres."
+  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "La discussion écrite utilise votre clé API OpenAI. La connexion ChatGPT ne couvre que la voix.",
+  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "La discussion écrite est indisponible tant que GEV_PREFER_CODEX_OAUTH impose l'OAuth ChatGPT.",
+  "That request needed too many steps. Changes already made to the map stay in place.": "Cette demande a nécessité trop d'étapes. Les modifications déjà apportées à la carte sont conservées.",
+  "That request needed too many steps. Try a simpler request.": "Cette demande a nécessité trop d'étapes. Essayez une demande plus simple.",
+  "The provider rejected the API key. Check it in Provider Settings.": "Le fournisseur a refusé la clé API. Vérifiez-la dans les paramètres des fournisseurs.",
+  "Too many chat requests. Try again in {seconds} s.": "Trop de requêtes de discussion. Réessayez dans {seconds} s.",
+  "The provider refused access for this key. Check the key's project, region or permissions.": "Le fournisseur a refusé l'accès pour cette clé. Vérifiez le projet, la région ou les autorisations de la clé.",
+  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "Le compte du fournisseur n'a plus de crédit. Vérifiez la facturation ou choisissez un autre fournisseur d'IA dans les paramètres.",
+  "SIGHTING": "OBSERVATION",
+  "Show {name} sighting": "Afficher l’observation de {name}",
+  "seen {age} ago": "vu il y a {age}",
+  "observed {age} ago": "observé il y a {age}",
+  "Be Whale Wise": "Respectez les cétacés",
+  "Reported by {name} ({entity})": "Signalé par {name} ({entity})",
+  "Reported by {name}": "Signalé par {name}",
+  "Salish Sea": "Mer des Salish",
+  "Birds": "Oiseaux",
+  "Mammals": "Mammifères",
+  "Reptiles": "Reptiles",
+  "Amphibians": "Amphibiens",
+  "Ray-finned fishes": "Poissons à nageoires rayonnées",
+  "Insects": "Insectes",
+  "Arachnids": "Arachnides",
+  "Plants": "Plantes",
+  "Fungi": "Champignons",
+  "Other animals": "Autres animaux",
+  "Other or unknown": "Autres ou inconnus",
+  "{label} {detail} — click to retry": "{label} {detail} — cliquer pour réessayer",
+  "Wildlife sightings source unavailable": "Source des observations naturalistes indisponible",
+  "Show only community-confirmed (research-grade) sightings": "Afficher uniquement les observations confirmées par la communauté (qualité recherche)",
+  "No recent sightings in view": "Aucune observation récente dans la vue",
+  "Acartia feed unavailable": "Flux Acartia indisponible",
+  "Show all taxa": "Afficher tous les groupes taxonomiques",
+  "BIRDS": "OISEAUX",
+  "Show only birds": "Afficher uniquement les oiseaux",
+  "MAMMALS": "MAMMIFÈRES",
+  "Show only mammals": "Afficher uniquement les mammifères",
+  "WHALES": "CÉTACÉS",
+  "Show only whales and dolphins (7 days)": "Afficher uniquement les baleines et dauphins (7 jours)",
+  "INSECTS": "INSECTES",
+  "Show only insects": "Afficher uniquement les insectes",
+  "PLANTS": "PLANTES",
+  "Show only plants": "Afficher uniquement les plantes",
+  "All rights reserved": "Tous droits réservés",
+  "Cetacean": "Cétacé",
+  "Wildlife Sightings": "Observations naturalistes",
+  "Exit cockpit to fly to a sighting": "Quittez le cockpit pour rejoindre une observation",
+  "Exit cockpit to fly to a sighting area": "Quittez le cockpit pour rejoindre une zone d’observation",
+  "Wildlife": "Faune et flore",
+  "Zoom in for local sightings": "Zoomez pour les observations locales",
+  "Loading photo...": "Chargement de la photo…",
+  "Photo unavailable": "Photo indisponible",
+  "Location obscured to a 0.2° cell": "Localisation masquée dans une cellule de 0,2°",
+  "Photo of {name}": "Photo de {name}",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "{count} observations dans la vue",
+  "Close sighting": "Fermer l’observation",
+  "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.": "Faune observée au cours des dernières 48 h (cétacés 7 jours). La couleur et le pictogramme du badge indiquent le groupe taxonomique. Les espèces sensibles sont limitées à des cellules de 0,2° ; les signalements de mammifères marins Acartia en mer des Salish sont arrondis à 0,01°. Pas un recensement.",
+  "Open {name} on iNaturalist": "Ouvrir {name} sur iNaturalist",
+  "Open {name} on Acartia": "Ouvrir {name} sur Acartia",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "Contributeurs iNaturalist · licences par observation",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "Contributeurs iNaturalist · Acartia {count} (mer des Salish) · licences par observation",
+  "{days}d": "{days}j",
+  "All markers": "Tous les marqueurs",
+  "Show markers of every age": "Afficher les marqueurs de tout âge",
+  "Maximum event age: {days}d; undated markers are kept": "Ancienneté maximale : {days} j ; marqueurs sans date conservés",
+  "event age filter|All": "Tous",
+  "Event age": "Ancienneté",
+  "Event age: {days}d · undated kept": "Ancienneté : {days} j · marqueurs sans date conservés",
+  "Close camera preview": "Fermer l’aperçu de la caméra",
+  "Refresh map still": "Actualiser l’image fixe sur la carte",
+  "The map still uses a separate request and may show a different moment.": "L’image fixe de la carte utilise une requête distincte et peut montrer un autre moment.",
+  "Video plays from Québec 511, which sees your IP address.": "La vidéo est lue depuis Québec 511, qui voit votre adresse IP."
 }

src/i18n/locales/it.json

@@ -1103,8 +1103,16 @@
   "TomTom roads first; OpenStreetMap fills the rest, simulated": "Prima le strade TomTom; OpenStreetMap completa il resto, simulato",
   "TomTom roads first; OpenStreetMap fills the rest, simulated (needs a TomTom key)": "Prima le strade TomTom; OpenStreetMap completa il resto, simulato (richiede una chiave TomTom)",
   "Hybrid": "Ibrido",
+  "Lines": "Linee",
+  "Dots": "Punti",
+  "Road lines colored by live flow: green to red": "Strade colorate in base al traffico in tempo reale: dal verde al rosso",
+  "Moving dots colored by live flow": "Punti in movimento colorati in base al traffico in tempo reale",
+  "Moving dots": "Punti in movimento",
   "TomTom key unavailable": "Chiave TomTom non disponibile",
   "TomTom daily budget reached": "Budget giornaliero TomTom esaurito",
+  "Monthly traffic allowance used": "Quota mensile del traffico esaurita",
+  "Traffic rate limit reached": "Limite di richieste del traffico raggiunto",
+  "Traffic service unavailable": "Servizio traffico non disponibile",
   "TomTom upstream unreachable": "Servizio TomTom irraggiungibile",
   "TomTom flow unavailable": "Flusso TomTom non disponibile",
   "SIMULATED — {reason}": "SIMULATO: {reason}",
@@ -1660,6 +1668,9 @@
   "REGIONAL NEWS": "NOTIZIE REGIONALI",
   "{label} · {radius} AIR/SEA WINDOW": "{label} · ARIA/MARE {radius}",
   "{scope} · INSTALLATIONS {coverage}": "{scope} · SITI {coverage}",
+  "MILITARY FEED OFF · PARTIAL PICTURE": "FEED MILITARE DISATTIVATO · QUADRO PARZIALE",
+  "FLIGHTS FEED OFF · PARTIAL PICTURE": "FEED VOLI DISATTIVATO · QUADRO PARZIALE",
+  "NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR": "AEREI VICINI INCOMPLETI · NON È UN VIA LIBERA",
   "CONTEXT STANDBY": "CONTESTO IN ATTESA",
   "ENABLE GLOBAL CONTEXT FOR PROXIMITY PINGS": "ATTIVA IL CONTESTO GLOBALE PER I PING DI PROSSIMITÀ",
   "CONTACT LOST · LAST KNOWN READOUT · NOT AN ALL-CLEAR": "CONTATTO PERSO · ULTIMA LETTURA NOTA · NON È UN VIA LIBERA",
@@ -2799,6 +2810,8 @@
   "AVAILABLE MISSIONS": "MISSIONI DISPONIBILI",
   "SELECT A MISSION TO INSPECT": "SELEZIONA UNA MISSIONE DA ESAMINARE",
   "LOADING 30-DAY MISSION INDEX": "CARICAMENTO INDICE MISSIONI A 30 GIORNI",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "Missioni spaziali non disponibili: impossibile caricare l’indice delle missioni. Riprova più tardi.",
+  "30-DAY MISSION INDEX UNAVAILABLE": "INDICE MISSIONI A 30 GIORNI NON DISPONIBILE",
   "TAB PREVIEWS · ENTER / SPACE SELECTS": "TAB: ANTEPRIMA · ENTER / SPACE: SELEZIONA",
   "Internet radio and local SDR": "Radio internet e SDR locale",
   "STATION TAG": "TAG STAZIONE",
@@ -2977,18 +2990,18 @@
   "Tip: the GEV MIC button in the dock lets you talk to the map.": "Suggerimento: il pulsante GEV MIC nel dock ti permette di parlare con la mappa.",
   "Malformed cyclone snapshot": "Snapshot dei cicloni non valido",
   "Cyclone request timed out": "La richiesta dei cicloni è andata in timeout",
-  "{lower} to {upper}": "da {lower} a {upper}",
+  "{lower} to {upper}": "Da {lower} a {upper}",
   "Up to {upper}": "Fino a {upper}",
   "From {lower}": "Da {lower}",
   "Informational only · not for flight planning": "Solo a scopo informativo · non per la pianificazione del volo",
-  "Unnamed zone": "Zona senza nome",
+  "Unnamed zone": "Senza nome",
   "Restricted airspace source unavailable": "Fonte dello spazio aereo regolamentato non disponibile",
-  "Prohibited (P)": "Zona proibita (P)",
+  "Prohibited (P)": "Zona vietata (P)",
   "Restricted (R)": "Zona regolamentata (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).": "Solo zone proibite e regolamentate della FAA (spazio aereo a uso speciale), non la UAS Facility Map né le restrizioni di volo UAS. Solo a scopo informativo — non sostituisce gli strumenti ufficiali di pianificazione del volo UAS (B4UFLY / LAANC).",
-  "Prohibited": "Zona proibita",
+  "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).": "Solo zone vietate e regolamentate della FAA (spazio aereo a uso speciale), non la UAS Facility Map né le restrizioni di volo UAS. Solo a scopo informativo — non sostituisce gli strumenti ufficiali di pianificazione del volo UAS (B4UFLY / LAANC).",
+  "Prohibited": "Zona vietata",
   "Restricted": "Zona regolamentata",
-  "Prohibited & Restricted Airspace": "Zone proibite e regolamentate",
+  "Prohibited & Restricted Airspace": "Spazio aereo vietato e regolamentato",
   "scene|PLAY": "AVVIA",
   "AUTHORING": "CREAZIONE",
   "Create and edit scenes": "Crea e modifica le scene",
@@ -3016,6 +3029,19 @@
   "Right panels": "Pannelli a destra",
   "CONFIRMED": "CONFERMATA",
   "PAD / RTLS": "SITO DI LANCIO / RTLS",
+  "fire confidence filter|All": "Tutti",
+  "fire confidence filter|Nominal+": "Nominale+",
+  "fire confidence filter|High": "Alta",
+  "Every detection — many of the strongest fires are rated low confidence": "Tutti i rilevamenti: molti degli incendi più intensi hanno confidenza bassa",
+  "Nominal and high confidence detections": "Rilevamenti con confidenza nominale e alta",
+  "High confidence detections only": "Solo rilevamenti con confidenza alta",
+  "Fire intensity (FRP)": "Intensità (FRP)",
+  "≥ {value} MW": "≥ {value} MW",
+  "Confidence": "Confidenza",
+  "Minimum fire radiative power, megawatts": "Potenza radiativa minima dell'incendio, in megawatt",
+  "fire intensity filter|All": "Tutti",
+  "Detection confidence": "Confidenza del rilevamento",
+  "{shown} of {total} shown": "Mostrati: {shown} su {total}",
   "Name of {name}": "Nome di {name}",
   "Change the colour of {name}": "Cambia il colore di {name}",
   "Colour of {name}": "Colore di {name}",
@@ -3033,10 +3059,10 @@
   "natural region": "regione naturale",
   "Which {place}?": "Quale {place}?",
   "Which place?": "Quale luogo?",
-  "Not drawn: {parts}": "Non disegnati: {parts}",
-  "approximate": "approssimativo",
+  "Not drawn: {parts}": "Contorno non disegnato: {parts}",
+  "approximate": "approssimata",
   "{pct}% cloud": "{pct}% di nuvole",
-  "Over {area}": "Zona: {area}",
+  "Over {area}": "Area: {area}",
   "{count} of {total} acquisitions match": {
     "many": "Acquisizioni corrispondenti: {count} su {total}",
     "one": "Acquisizioni corrispondenti: {count} su {total}",
@@ -3055,8 +3081,8 @@
   "In {area}": "Area: {area}",
   "Area around {place}": "Area intorno a {place}",
   "Area around landmark": "Area intorno a un punto di interesse",
-  "Outline {place}": "Traccia contorno di {place}",
-  "Outline area": "Traccia contorno area",
+  "Outline {place}": "Traccia il contorno di {place}",
+  "Outline area": "Traccia il contorno dell'area",
   "Find {place}": "Trova {place}",
   "Find area": "Trova area",
   "Find recent imagery": "Trova immagini recenti",
@@ -3064,16 +3090,16 @@
   "Find places": "Trova luoghi",
   "Drawing outline": "Disegno del contorno",
   "Searching imagery catalog": "Ricerca nel catalogo immagini",
-  "Loading imagery": "Caricamento immagini",
+  "Loading imagery": "Caricamento delle immagini",
   "Searching OpenStreetMap": "Ricerca in OpenStreetMap",
   "voice area|Area": "Area",
   "buffer sized to the place": "zona tampone delle dimensioni del luogo",
-  "enclosing mapped area": "area mappata circostante",
-  "the map was cleared while looking it up": "la mappa è stata cancellata durante la ricerca",
-  "OpenStreetMap coverage varies by place": "La copertura di OpenStreetMap varia da luogo a luogo",
+  "enclosing mapped area": "area mappata che contiene il punto di interesse",
+  "the map was cleared while looking it up": "la mappa è stata ripulita durante la ricerca",
+  "OpenStreetMap coverage varies by place": "la copertura di OpenStreetMap varia da luogo a luogo",
   "the catalog covers the last 30 days": "il catalogo copre gli ultimi 30 giorni",
   "there are more": "ce ne sono altri",
-  "{radius} m around the landmark": "{radius} m attorno al luogo",
+  "{radius} m around the landmark": "{radius} m intorno al punto di interesse",
   "{count} parts": {
     "many": "Parti: {count}",
     "one": "Parti: {count}",
@@ -3089,53 +3115,55 @@
     "one": "Duplicati uniti: {count}",
     "other": "Duplicati uniti: {count}"
   },
-  "listed the first {limit}": "elencati i primi {limit}",
-  "counted over the bounding box of {area}, not its outline": "contato sul riquadro di delimitazione ({area}), non sul contorno",
+  "listed the first {limit}": "elenco limitato ai primi risultati: {limit}",
+  "counted over the bounding box of {area}, not its outline": "conteggio nel riquadro di delimitazione di {area}, non entro il suo contorno",
   "Search cancelled": "Ricerca annullata",
   "Sea Marks": "Segnalamenti marittimi",
   "Ski Pistes": "Piste da sci",
   "Fly to Tokyo": "Vola a Tokyo",
-  "Show live flights": "Mostra voli in diretta",
+  "Show live flights": "Mostra i voli live",
+  "Reset to globe view": "Ripristina la vista del globo",
+  "Show earthquakes": "Mostra i terremoti",
   "AI chat": "Chat IA",
   "GEV CHAT": "CHAT GEV",
-  "Ask about the map. Tell it where to go.": "Chiedi della mappa. Dille dove andare.",
-  "Close chat": "Chiudi chat",
+  "Ask about the map. Tell it where to go.": "Fai domande sulla mappa. Digli dove andare.",
+  "Close chat": "Chiudi la chat",
   "Conversation": "Conversazione",
   "Explore with a question": "Esplora con una domanda",
-  "Find a place, explore live data, or change your view.": "Trova un luogo, esplora dati in diretta o cambia vista.",
+  "Find a place, explore live data, or change your view.": "Trova un luogo, esplora i dati live o cambia vista.",
   "Attachments": "Allegati",
-  "Remove attachment": "Rimuovi allegato",
+  "Remove attachment": "Rimuovi l'allegato",
   "Attach a map layer": "Allega un livello della mappa",
   "Choose a layer…": "Scegli un livello…",
   "Attach a file": "Allega un 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 o GeoJSON · fino a 10 KB in totale. Gli allegati vengono inviati al tuo fornitore di IA insieme al messaggio.",
-  "Latest AI response": "Ultima risposta dell’IA",
-  "Expand conversation": "Espandi conversazione",
+  "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 o GeoJSON · fino a 10 KB in totale. Gli allegati vengono inviati al tuo provider IA insieme al messaggio.",
+  "Latest AI response": "Ultima risposta dell'IA",
+  "Expand conversation": "Espandi la conversazione",
   "Command suggestions": "Suggerimenti di comandi",
-  "Expand chat": "Espandi chat",
+  "Expand chat": "Espandi la chat",
   "Add attachment": "Aggiungi allegato",
   "Message GEV": "Messaggio a GEV",
   "Ask GEV anything about the map…": "Chiedi a GEV qualsiasi cosa sulla mappa…",
-  "Stop reply": "Interrompi risposta",
-  "Send message": "Invia messaggio",
+  "Stop reply": "Interrompi la risposta",
+  "Send message": "Invia il messaggio",
   "Panel position": "Posizione del pannello",
   "Move above the dock": "Sposta sopra il dock",
   "Dock to the right": "Aggancia a destra",
-  "Expand panel": "Espandi pannello",
-  "Minimize panel": "Riduci pannello",
+  "Expand panel": "Espandi il pannello",
+  "Minimize panel": "Riduci il pannello",
   "You can attach up to four items.": "Puoi allegare fino a quattro elementi.",
-  "Attachments are too large together. Use smaller files.": "Gli allegati insieme sono troppo grandi. Usa file più piccoli.",
+  "Attachments are too large together. Use smaller files.": "Nel complesso gli allegati sono troppo grandi. Usa file più piccoli.",
   "Choose a TXT, Markdown, CSV, JSON or GeoJSON file.": "Scegli un file TXT, Markdown, CSV, JSON o GeoJSON.",
-  "Each file must be 10 KB or smaller.": "Ogni file deve essere di 10 KB o meno.",
+  "Each file must be 10 KB or smaller.": "Ogni file non deve superare i 10 KB.",
   "Choose a non-empty UTF-8 text file.": "Scegli un file di testo UTF-8 non vuoto.",
   "Connecting…": "Connessione…",
   "Thinking…": "Sto pensando…",
-  "Working on the map…": "Lavoro sulla mappa…",
+  "Working on the map…": "Sto lavorando sulla mappa…",
   "Silent chat · microphone off": "Chat silenziosa · microfono spento",
   "Reply interrupted. You can try again.": "Risposta interrotta. Puoi riprovare.",
   "Could not connect. Try again.": "Impossibile connettersi. Riprova.",
   "Session ended. Send a message to start a new conversation.": "Sessione terminata. Invia un messaggio per iniziare una nuova conversazione.",
-  "Connection timed out. Try again.": "Connessione scaduta. Riprova.",
+  "Connection timed out. Try again.": "La connessione è andata in timeout. Riprova.",
   "Chat closed.": "Chat chiusa.",
   "Connection stopped.": "Connessione interrotta.",
   "Message and attachments are too large. Remove an attachment or shorten your message.": "Messaggio e allegati sono troppo grandi. Rimuovi un allegato o accorcia il messaggio.",
@@ -3144,25 +3172,92 @@
   "Suggestions": "Suggerimenti",
   "Recent": "Recenti",
   "Quick commands": "Comandi rapidi",
-  "Open AI chat": "Apri chat IA",
+  "Open AI chat": "Apri la chat IA",
   "CHAT": "CHAT",
   "Back to chat": "Torna alla chat",
   "Back to voice": "Torna alla voce",
   "Latest voice exchange": "Ultimo scambio vocale",
   "Try saying": "Prova a dire",
   "What am I looking at?": "Cosa sto guardando?",
-  "AI Provider": "Fornitore di IA",
-  "The selected AI provider is shared by voice and chat.": "Il fornitore di IA scelto è condiviso da voce e chat.",
-  "Show quick commands": "Mostra comandi rapidi",
-  "Chat replies are silent. No microphone access is needed.": "Le risposte della chat sono silenziose. Non serve l’accesso al microfono.",
+  "AI Provider": "Provider IA",
+  "The selected AI provider is shared by voice and chat.": "Il provider IA selezionato è condiviso tra voce e chat.",
+  "Show quick commands": "Mostra i comandi rapidi",
+  "Chat replies are silent. No microphone access is needed.": "Le risposte della chat sono silenziose. Non serve l'accesso al microfono.",
   "Chat": "Chat",
   "Attach layer": "Allega livello",
-  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "La chat scritta usa la tua chiave API OpenAI. L’accesso a ChatGPT copre solo la voce.",
+  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "La chat scritta usa la tua chiave API OpenAI. L'accesso a ChatGPT vale solo per la voce.",
   "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "La chat scritta non è disponibile finché GEV_PREFER_CODEX_OAUTH richiede ChatGPT OAuth.",
-  "That request needed too many steps. Changes already made to the map stay in place.": "Questa richiesta ha richiesto troppi passaggi. Le modifiche già fatte alla mappa restano.",
-  "That request needed too many steps. Try a simpler request.": "Questa richiesta ha richiesto troppi passaggi. Prova una richiesta più semplice.",
-  "The provider rejected the API key. Check it in Provider Settings.": "Il provider ha rifiutato la chiave API. Controllala nelle impostazioni del provider.",
+  "That request needed too many steps. Changes already made to the map stay in place.": "Per questa richiesta sono serviti troppi passaggi. Le modifiche già apportate alla mappa restano.",
+  "That request needed too many steps. Try a simpler request.": "Per questa richiesta sono serviti troppi passaggi. Prova con una richiesta più semplice.",
+  "The provider rejected the API key. Check it in Provider Settings.": "Il provider ha rifiutato la chiave API. Controllala in Impostazioni provider.",
   "Too many chat requests. Try again in {seconds} s.": "Troppe richieste di chat. Riprova tra {seconds} s.",
-  "The provider refused access for this key. Check the key's project, region or permissions.": "Il provider ha negato l’accesso per questa chiave. Controlla progetto, regione o autorizzazioni della chiave.",
-  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "L’account del provider ha esaurito il credito. Controlla la fatturazione o scegli un altro provider IA nelle impostazioni."
+  "The provider refused access for this key. Check the key's project, region or permissions.": "Il provider ha negato l'accesso per questa chiave. Controlla progetto, regione o autorizzazioni della chiave.",
+  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "L'account del provider ha esaurito il credito. Controlla la fatturazione o scegli un altro provider IA in Impostazioni.",
+  "SIGHTING": "AVVISTAMENTO",
+  "Show {name} sighting": "Mostra avvistamento di {name}",
+  "seen {age} ago": "avvistato {age} fa",
+  "observed {age} ago": "osservato {age} fa",
+  "Be Whale Wise": "Rispetta i cetacei",
+  "Reported by {name} ({entity})": "Segnalato da {name} ({entity})",
+  "Reported by {name}": "Segnalato da {name}",
+  "Salish Sea": "Mare dei Salish",
+  "Birds": "Uccelli",
+  "Mammals": "Mammiferi",
+  "Reptiles": "Rettili",
+  "Amphibians": "Anfibi",
+  "Ray-finned fishes": "Pesci con pinne raggiate",
+  "Insects": "Insetti",
+  "Arachnids": "Aracnidi",
+  "Plants": "Piante",
+  "Fungi": "Funghi",
+  "Other animals": "Altri animali",
+  "Other or unknown": "Altri o sconosciuti",
+  "{label} {detail} — click to retry": "{label} {detail} — fai clic per riprovare",
+  "Wildlife sightings source unavailable": "Fonte degli avvistamenti non disponibile",
+  "Show only community-confirmed (research-grade) sightings": "Mostra solo osservazioni confermate dalla comunità (grado di ricerca)",
+  "No recent sightings in view": "Nessun avvistamento recente nella vista",
+  "Acartia feed unavailable": "Feed Acartia non disponibile",
+  "Show all taxa": "Mostra tutti i gruppi tassonomici",
+  "BIRDS": "UCCELLI",
+  "Show only birds": "Mostra solo uccelli",
+  "MAMMALS": "MAMMIFERI",
+  "Show only mammals": "Mostra solo mammiferi",
+  "WHALES": "CETACEI",
+  "Show only whales and dolphins (7 days)": "Mostra solo balene e delfini (7 giorni)",
+  "INSECTS": "INSETTI",
+  "Show only insects": "Mostra solo insetti",
+  "PLANTS": "PIANTE",
+  "Show only plants": "Mostra solo piante",
+  "All rights reserved": "Tutti i diritti riservati",
+  "Cetacean": "Cetaceo",
+  "Wildlife Sightings": "Avvistamenti naturalistici",
+  "Exit cockpit to fly to a sighting": "Esci dalla cabina per volare a un avvistamento",
+  "Exit cockpit to fly to a sighting area": "Esci dalla cabina per volare a un’area di avvistamento",
+  "Wildlife": "Natura",
+  "Zoom in for local sightings": "Ingrandisci per gli avvistamenti locali",
+  "Loading photo...": "Caricamento della foto…",
+  "Photo unavailable": "Foto non disponibile",
+  "Location obscured to a 0.2° cell": "Posizione oscurata in una cella di 0,2°",
+  "Photo of {name}": "Foto di {name}",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "{count} avvistamenti nella vista",
+  "Close sighting": "Chiudi avvistamento",
+  "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.": "Fauna osservata nelle ultime 48 h (cetacei 7 giorni). Colore e simbolo del contrassegno indicano il gruppo tassonomico. Le specie sensibili sono mostrate solo in celle di 0,2°; le segnalazioni di mammiferi marini di Acartia nel mar dei Salish sono arrotondate a 0,01°. Non è un censimento.",
+  "Open {name} on iNaturalist": "Apri {name} su iNaturalist",
+  "Open {name} on Acartia": "Apri {name} su Acartia",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "Contributori di iNaturalist · licenze per osservazione",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "Contributori di iNaturalist · Acartia {count} (Mare dei Salish) · licenze per osservazione",
+  "{days}d": "{days}g",
+  "All markers": "Tutti gli indicatori",
+  "Show markers of every age": "Mostra gli indicatori di qualsiasi età",
+  "Maximum event age: {days}d; undated markers are kept": "Età massima degli eventi: {days} giorni; indicatori senza data mantenuti",
+  "event age filter|All": "Tutti",
+  "Event age": "Età degli eventi",
+  "Event age: {days}d · undated kept": "Età degli eventi: {days} giorni · senza data mantenuti",
+  "Close camera preview": "Chiudi anteprima della telecamera",
+  "Refresh map still": "Aggiorna immagine fissa sulla mappa",
+  "The map still uses a separate request and may show a different moment.": "L’immagine sulla mappa usa una richiesta separata e può mostrare un momento diverso.",
+  "Video plays from Québec 511, which sees your IP address.": "Il video viene riprodotto da Québec 511, che vede il tuo indirizzo IP."
 }

src/i18n/locales/ja.json

@@ -1071,8 +1071,16 @@
   "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": "ハイブリッド",
+  "Lines": "ライン",
+  "Dots": "ドット",
+  "Road lines colored by live flow: green to red": "ライブの交通流で色分けした道路ライン（緑から赤）",
+  "Moving dots colored by live flow": "ライブの交通流で色分けした移動ドット",
+  "Moving dots": "移動ドット",
   "TomTom key unavailable": "TomTomキーを利用できません",
   "TomTom daily budget reached": "TomTomの1日の上限に達しました",
+  "Monthly traffic allowance used": "今月の交通情報の上限に達しました",
+  "Traffic rate limit reached": "交通情報のリクエスト上限に達しました",
+  "Traffic service unavailable": "交通情報サービスを利用できません",
   "TomTom upstream unreachable": "TomTomのサービスに接続できません",
   "TomTom flow unavailable": "TomTomの交通流を利用できません",
   "SIMULATED — {reason}": "シミュレーション：{reason}",
@@ -1612,6 +1620,9 @@
   "REGIONAL NEWS": "地域ニュース",
   "{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": "コンタクト喪失 · 最終既知の値 · 安全の保証ではありません",
@@ -1684,7 +1695,7 @@
   "Restore real aircraft": "実際の航空機に戻す",
   "Reclassify as TR-3B": "TR-3Bに再分類",
   "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": {
@@ -2657,6 +2668,8 @@
   "AVAILABLE MISSIONS": "利用可能なミッション",
   "SELECT A MISSION TO INSPECT": "ミッションを選択して詳細を表示",
   "LOADING 30-DAY MISSION INDEX": "30日間のミッション一覧を読込中",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "宇宙ミッションを利用できません：ミッション一覧を読み込めませんでした。後でもう一度お試しください。",
+  "30-DAY MISSION INDEX UNAVAILABLE": "30日間のミッション一覧を取得できません",
   "TAB PREVIEWS · ENTER / SPACE SELECTS": "Tabでプレビュー · Enter / Spaceで選択",
   "Internet radio and local SDR": "インターネットラジオとローカルSDR",
   "STATION TAG": "局タグ",
@@ -2837,18 +2850,18 @@
   "route proxy error": "ルート検索プロキシでエラーが発生しました",
   "Malformed cyclone snapshot": "サイクロンのスナップショットの形式が不正です",
   "Cyclone request timed out": "サイクロンのリクエストがタイムアウトしました",
-  "{lower} to {upper}": "{lower}～{upper}",
+  "{lower} to {upper}": "{lower}–{upper}",
   "Up to {upper}": "{upper}まで",
   "From {lower}": "{lower}から",
   "Informational only · not for flight planning": "参考情報のみ · 飛行計画には使用しないでください",
-  "Unnamed zone": "名称なしのゾーン",
+  "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 MapやUAS飛行制限は含みません。参考情報のみ — 公式のUAS飛行計画ツール（B4UFLY / LAANC）の代わりにはなりません。",
+  "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 MapやUASの飛行制限は含みません。参考情報であり、公式のUAS飛行計画ツール（B4UFLY / LAANC）の代わりにはなりません。",
   "Prohibited": "飛行禁止区域",
-  "Restricted": "制限区域",
-  "Prohibited & Restricted Airspace": "飛行禁止区域と制限区域",
+  "Restricted": "飛行制限区域",
+  "Prohibited & Restricted Airspace": "飛行禁止・飛行制限区域",
   "scene|PLAY": "再生",
   "AUTHORING": "作成",
   "Create and edit scenes": "シーンを作成・編集",
@@ -2876,6 +2889,19 @@
   "Right panels": "右パネル",
   "CONFIRMED": "確認済み",
   "PAD / RTLS": "射場 / RTLS",
+  "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）",
+  "≥ {value} MW": "≥ {value} MW",
+  "Confidence": "信頼度",
+  "Minimum fire radiative power, megawatts": "火災放射強度の最小値（メガワット）",
+  "fire intensity filter|All": "すべて",
+  "Detection confidence": "検知の信頼度",
+  "{shown} of {total} shown": "{total}件中{shown}件を表示",
   "Name of {name}": "{name}の名前",
   "Change the colour of {name}": "{name}の色を変更",
   "Colour of {name}": "{name}の色",
@@ -2887,16 +2913,16 @@
   "Directions, drawing and your own files": "ルート案内、描画、自分のファイル",
   "Voice place search (needs an Overpass server)": "音声による場所検索（Overpassサーバーが必要）",
   "OSM Places": "OSMの場所",
-  "state or province": "州・省",
+  "state or province": "州・県",
   "county or district": "郡・地区",
   "neighbourhood": "近隣地区",
   "natural region": "自然地域",
-  "Which {place}?": "どの{place}ですか？",
+  "Which {place}?": "どの「{place}」ですか？",
   "Which place?": "どの場所ですか？",
   "Not drawn: {parts}": "未描画：{parts}",
-  "approximate": "概算",
-  "{pct}% cloud": "雲量{pct}%",
-  "Over {area}": "{area}上空",
+  "approximate": "近似",
+  "{pct}% cloud": "雲量 {pct}%",
+  "Over {area}": "範囲：{area}",
   "{count} of {total} acquisitions match": {
     "other": "一致した画像：{count}/{total}件"
   },
@@ -2905,67 +2931,69 @@
   },
   "No matching imagery": "一致する画像はありません",
   "Unknown number of {kind}": "{kind}：件数不明",
-  "About {count} {kind}": "{kind}：約{count}件",
-  "At least {count} {kind}": "{kind}：{count}件以上",
-  "{count} {kind}": "{kind}：{count}件",
+  "About {count} {kind}": "{kind}：約{count}か所",
+  "At least {count} {kind}": "{kind}：{count}か所以上",
+  "{count} {kind}": "{kind}：{count}か所",
   "In {area}": "{area}内",
   "Area around {place}": "{place}周辺のエリア",
   "Area around landmark": "ランドマーク周辺のエリア",
-  "Outline {place}": "{place}の輪郭を描く",
-  "Outline area": "エリアの輪郭を描く",
+  "Outline {place}": "{place}の輪郭を描画",
+  "Outline area": "エリアの輪郭を描画",
   "Find {place}": "{place}を検索",
   "Find area": "エリアを検索",
   "Find recent imagery": "最近の衛星画像を検索",
   "Find {what}": "{what}を検索",
   "Find places": "場所を検索",
-  "Drawing outline": "輪郭を作図中",
+  "Drawing outline": "輪郭を地図に描画中",
   "Searching imagery catalog": "画像カタログを検索中",
   "Loading imagery": "画像を読み込み中",
   "Searching OpenStreetMap": "OpenStreetMapを検索中",
   "voice area|Area": "エリア",
-  "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 日分です",
+  "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": "ほかにもあります",
-  "{radius} m around the landmark": "ランドマークの周囲 {radius} m",
+  "{radius} m around the landmark": "ランドマークから半径{radius} m",
   "{count} parts": {
-    "other": "パーツ数: {count}"
+    "other": "パーツ数：{count}"
   },
   "{drawn} of {total} parts drawn": {
-    "other": "描画したパーツ: {drawn}/{total}"
+    "other": "描画したパーツ：{drawn}/{total}"
   },
   "{count} duplicate mappings merged": {
-    "other": "統合した重複: {count}"
+    "other": "重複登録{count}件を統合"
   },
-  "listed the first {limit}": "最初の {limit} 件を表示",
-  "counted over the bounding box of {area}, not its outline": "外接矩形 ({area}) で数えた結果で、輪郭ではありません",
+  "listed the first {limit}": "最初の{limit}件を表示",
+  "counted over the bounding box of {area}, not its outline": "{area}の輪郭ではなく外接矩形の範囲で数えています",
   "Search cancelled": "検索をキャンセルしました",
   "Sea Marks": "航路標識",
-  "Ski Pistes": "スキーゲレンデ",
-  "Fly to Tokyo": "東京へ移動",
-  "Show live flights": "ライブのフライトを表示",
+  "Ski Pistes": "スキーコース",
+  "Fly to Tokyo": "東京へ移動して",
+  "Show live flights": "ライブフライトを表示して",
+  "Reset to globe view": "地球全体ビューに戻して",
+  "Show earthquakes": "地震を表示して",
   "AI chat": "AIチャット",
-  "GEV CHAT": "GEV チャット",
+  "GEV CHAT": "GEVチャット",
   "Ask about the map. Tell it where to go.": "地図について質問できます。行き先を伝えてください。",
   "Close chat": "チャットを閉じる",
   "Conversation": "会話",
   "Explore with a question": "質問から探索",
   "Find a place, explore live data, or change your view.": "場所を探したり、ライブデータを見たり、表示を変えたりできます。",
-  "Attachments": "添付ファイル",
+  "Attachments": "添付",
   "Remove attachment": "添付を削除",
   "Attach a map layer": "地図レイヤーを添付",
   "Choose a 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 KB まで。添付はメッセージとともに AI プロバイダーへ送信されます。",
-  "Latest AI response": "最新の AI の応答",
+  "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 KBまで。添付はメッセージとともにAIプロバイダーへ送信されます。",
+  "Latest AI response": "AIの最新の応答",
   "Expand conversation": "会話を展開",
   "Command suggestions": "コマンドの候補",
   "Expand chat": "チャットを展開",
   "Add attachment": "添付を追加",
-  "Message GEV": "GEV へのメッセージ",
-  "Ask GEV anything about the map…": "地図について GEV に何でも質問…",
+  "Message GEV": "GEVへのメッセージ",
+  "Ask GEV anything about the map…": "地図についてGEVに何でも質問…",
   "Stop reply": "応答を停止",
   "Send message": "メッセージを送信",
   "Panel position": "パネルの位置",
@@ -2973,15 +3001,15 @@
   "Dock to the right": "右側にドッキング",
   "Expand panel": "パネルを展開",
   "Minimize panel": "パネルを最小化",
-  "You can attach up to four items.": "添付できるのは 4 件までです。",
-  "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 KB 以下にしてください。",
-  "Choose a non-empty UTF-8 text file.": "空でない UTF-8 のテキストファイルを選んでください。",
+  "You can attach up to four items.": "添付できるのは4件までです。",
+  "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 KB以下にしてください。",
+  "Choose a non-empty UTF-8 text file.": "空でないUTF-8のテキストファイルを選んでください。",
   "Connecting…": "接続中…",
   "Thinking…": "考え中…",
   "Working on the map…": "地図を操作中…",
-  "Silent chat · microphone off": "サイレントチャット · マイクオフ",
+  "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.": "セッションが終了しました。メッセージを送ると新しい会話を始められます。",
@@ -2992,7 +3020,7 @@
   "Message was not sent. Try again.": "メッセージを送信できませんでした。もう一度お試しください。",
   "Reply stopped.": "応答を停止しました。",
   "Suggestions": "候補",
-  "Recent": "最近",
+  "Recent": "履歴",
   "Quick commands": "クイックコマンド",
   "Open AI chat": "AIチャットを開く",
   "CHAT": "チャット",
@@ -3000,19 +3028,86 @@
   "Back to voice": "音声に戻る",
   "Latest voice exchange": "直近の音声のやり取り",
   "Try saying": "話しかけてみましょう",
-  "What am I looking at?": "何を見ていますか？",
-  "AI Provider": "AI プロバイダー",
-  "The selected AI provider is shared by voice and chat.": "選んだ AI プロバイダーは音声とチャットで共通です。",
+  "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.": "チャットの応答は音声なしです。マイクへのアクセスは不要です。",
+  "Chat replies are silent. No microphone access is needed.": "チャットの応答は読み上げられません。マイクへのアクセスは不要です。",
   "Chat": "チャット",
   "Attach layer": "レイヤーを添付",
-  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "テキストチャットは OpenAI API キーを使用します。ChatGPT のサインインは音声のみが対象です。",
-  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "GEV_PREFER_CODEX_OAUTH が ChatGPT OAuth を必須にしている間、テキストチャットは使えません。",
+  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "テキストチャットはOpenAI APIキーを使用します。ChatGPTのサインインは音声のみが対象です。",
+  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "GEV_PREFER_CODEX_OAUTHがChatGPT OAuthを必須にしている間、テキストチャットは使えません。",
   "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.": "このリクエストは手順が多すぎました。より簡単なリクエストを試してください。",
-  "The provider rejected the API key. Check it in Provider Settings.": "プロバイダーが API キーを拒否しました。プロバイダー設定で確認してください。",
-  "Too many chat requests. Try again in {seconds} s.": "チャットのリクエストが多すぎます。{seconds} 秒後にもう一度お試しください。",
-  "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 プロバイダーを選んでください。"
+  "The provider rejected the API key. Check it in Provider Settings.": "プロバイダーがAPIキーを拒否しました。プロバイダー設定で確認してください。",
+  "Too many chat requests. Try again in {seconds} s.": "チャットのリクエストが多すぎます。{seconds}秒後にもう一度お試しください。",
+  "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プロバイダーを選んでください。",
+  "SIGHTING": "目撃情報",
+  "Show {name} sighting": "{name}の目撃情報を表示",
+  "seen {age} ago": "{age}前に目撃",
+  "observed {age} ago": "{age}前に観察",
+  "Be Whale Wise": "クジラに配慮しましょう",
+  "Reported by {name} ({entity})": "報告元 {name}（{entity}）",
+  "Reported by {name}": "報告元 {name}",
+  "Salish Sea": "セイリッシュ海",
+  "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": "コミュニティが確認した研究グレードの目撃情報のみ表示",
+  "No recent sightings in view": "表示範囲に最近の目撃情報はありません",
+  "Acartia feed unavailable": "Acartiaのフィードを利用できません",
+  "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": "野生生物の目撃情報",
+  "Exit cockpit to fly to a sighting": "目撃地点に移動するにはコックピットを終了",
+  "Exit cockpit to fly to a sighting area": "目撃範囲に移動するにはコックピットを終了",
+  "Wildlife": "野生生物",
+  "Zoom in for local sightings": "拡大して地域の目撃情報を表示",
+  "Loading photo...": "写真を読み込み中…",
+  "Photo unavailable": "写真を表示できません",
+  "Location obscured to a 0.2° cell": "位置は0.2°のセル内に秘匿されています",
+  "Photo of {name}": "{name}の写真",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "表示範囲に{count}件の目撃情報",
+  "Close sighting": "目撃情報を閉じる",
+  "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°の区画のみ表示し、セイリッシュ海のAcartia海生哺乳類目撃情報は0.01°に丸めます。個体数調査ではありません。",
+  "Open {name} on iNaturalist": "iNaturalistで{name}を開く",
+  "Open {name} on Acartia": "Acartiaで{name}を開く",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "iNaturalist の投稿者 · ライセンスは記録ごと",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "iNaturalist の投稿者 · Acartia {count}（セイリッシュ海） · ライセンスは記録ごと",
+  "{days}d": "{days}日",
+  "All markers": "すべてのマーカー",
+  "Show markers of every age": "日付にかかわらずすべてのマーカーを表示",
+  "Maximum event age: {days}d; undated markers are kept": "イベントの最大経過日数：{days}日。日付のないマーカーは保持",
+  "event age filter|All": "すべて",
+  "Event age": "経過日数",
+  "Event age: {days}d · undated kept": "経過日数：{days}日以内 · 日付なしは保持",
+  "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 から再生され、Québec 511 にはあなたの IP アドレスが見えます。"
 }

src/i18n/locales/pt.json

@@ -1101,8 +1101,16 @@
   "TomTom roads first; OpenStreetMap fills the rest, simulated": "Primeiro as vias do TomTom; o OpenStreetMap completa o resto com fluxo simulado",
   "TomTom roads first; OpenStreetMap fills the rest, simulated (needs a TomTom key)": "Primeiro as vias do TomTom; o OpenStreetMap completa o resto com fluxo simulado (precisa de uma chave do TomTom)",
   "Hybrid": "Híbrido",
+  "Lines": "Linhas",
+  "Dots": "Pontos",
+  "Road lines colored by live flow: green to red": "Vias coloridas pelo fluxo ao vivo: do verde ao vermelho",
+  "Moving dots colored by live flow": "Pontos em movimento coloridos pelo fluxo ao vivo",
+  "Moving dots": "Pontos em movimento",
   "TomTom key unavailable": "Chave do TomTom indisponível",
   "TomTom daily budget reached": "Limite diário do TomTom atingido",
+  "Monthly traffic allowance used": "Cota mensal de trânsito esgotada",
+  "Traffic rate limit reached": "Limite de solicitações de trânsito atingido",
+  "Traffic service unavailable": "Serviço de trânsito indisponível",
   "TomTom upstream unreachable": "Servidor do TomTom inacessível",
   "TomTom flow unavailable": "Fluxo do TomTom indisponível",
   "SIMULATED — {reason}": "SIMULADO — {reason}",
@@ -1660,6 +1668,9 @@
   "REGIONAL NEWS": "NOTÍCIAS DA ÁREA",
   "{label} · {radius} AIR/SEA WINDOW": "{label} · AR/MAR {radius}",
   "{scope} · INSTALLATIONS {coverage}": "{scope} · INSTALAÇÕES: {coverage}",
+  "MILITARY FEED OFF · PARTIAL PICTURE": "FEED MILITAR DESLIGADO · QUADRO PARCIAL",
+  "FLIGHTS FEED OFF · PARTIAL PICTURE": "FEED DE VOOS DESLIGADO · QUADRO PARCIAL",
+  "NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR": "AERONAVES PRÓXIMAS INCOMPLETAS · NÃO GARANTE SEGURANÇA",
   "CONTEXT STANDBY": "CONTEXTO EM ESPERA",
   "ENABLE GLOBAL CONTEXT FOR PROXIMITY PINGS": "ATIVE O CONTEXTO GLOBAL PARA PINGS DE PROXIMIDADE",
   "CONTACT LOST · LAST KNOWN READOUT · NOT AN ALL-CLEAR": "CONTATO PERDIDO · ÚLTIMA LEITURA CONHECIDA · NÃO GARANTE SEGURANÇA",
@@ -1736,7 +1747,7 @@
   "Restore real aircraft": "Restaurar a aeronave real",
   "Reclassify as TR-3B": "Reclassificar como TR-3B",
   "TRACK ACQUIRED": "RASTRO ADQUIRIDO",
-  "{label} · COURSE {heading}°": "{label} · CURSO {heading}°",
+  "{label} · COURSE {heading}°": "{label} · RUMO {heading}°",
   "Context could not restore every layer; try again": "O contexto não conseguiu restaurar todas as camadas; tente novamente",
   "No selected data layers": "Nenhuma camada de dados selecionada",
   "{count} data layers could not be cleared": {
@@ -2801,6 +2812,8 @@
   "AVAILABLE MISSIONS": "MISSÕES DISPONÍVEIS",
   "SELECT A MISSION TO INSPECT": "SELECIONE UMA MISSÃO PARA INSPECIONAR",
   "LOADING 30-DAY MISSION INDEX": "CARREGANDO ÍNDICE DE MISSÕES DE 30 DIAS",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "Missões espaciais indisponíveis: não foi possível carregar o índice de missões. Tente novamente mais tarde.",
+  "30-DAY MISSION INDEX UNAVAILABLE": "ÍNDICE DE MISSÕES DE 30 DIAS INDISPONÍVEL",
   "TAB PREVIEWS · ENTER / SPACE SELECTS": "TAB MOSTRA PRÉVIA · ENTER / SPACE SELECIONA",
   "Internet radio and local SDR": "Rádio pela internet e SDR local",
   "STATION TAG": "TAG DA ESTAÇÃO",
@@ -2981,14 +2994,14 @@
   "Up to {upper}": "Até {upper}",
   "From {lower}": "A partir de {lower}",
   "Informational only · not for flight planning": "Apenas informativo · não usar para planejamento de voo",
-  "Unnamed zone": "Zona sem nome",
+  "Unnamed zone": "Sem nome",
   "Restricted airspace source unavailable": "Fonte de espaço aéreo restrito indisponível",
   "Prohibited (P)": "Área proibida (P)",
   "Restricted (R)": "Área restrita (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).": "Apenas áreas proibidas e restritas da FAA (espaço aéreo de uso especial), sem o UAS Facility Map ou as restrições de voo de UAS. Apenas informativo — não substitui as ferramentas oficiais de planejamento de voo de 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).": "Somente o espaço aéreo de uso especial proibido e restrito da FAA; não inclui o UAS Facility Map nem as restrições de voo de UAS. Apenas informativo — não substitui as ferramentas oficiais de planejamento de voo de UAS (B4UFLY / LAANC).",
   "Prohibited": "Área proibida",
   "Restricted": "Área restrita",
-  "Prohibited & Restricted Airspace": "Áreas proibidas e restritas",
+  "Prohibited & Restricted Airspace": "Espaço aéreo proibido e restrito",
   "scene|PLAY": "INICIAR",
   "AUTHORING": "CRIAÇÃO",
   "Create and edit scenes": "Criar e editar cenas",
@@ -3016,6 +3029,19 @@
   "Right panels": "Painéis à direita",
   "CONFIRMED": "CONFIRMADA",
   "PAD / RTLS": "PLATAFORMA / RTLS",
+  "fire confidence filter|All": "Todas",
+  "fire confidence filter|Nominal+": "Nominal+",
+  "fire confidence filter|High": "Alta",
+  "Every detection — many of the strongest fires are rated low confidence": "Todas as detecções — muitos dos incêndios mais intensos têm confiança baixa",
+  "Nominal and high confidence detections": "Detecções de confiança nominal e alta",
+  "High confidence detections only": "Somente detecções de confiança alta",
+  "Fire intensity (FRP)": "Intensidade (FRP)",
+  "≥ {value} MW": "≥ {value} MW",
+  "Confidence": "Confiança",
+  "Minimum fire radiative power, megawatts": "Potência radiativa mínima do fogo, em megawatts",
+  "fire intensity filter|All": "Todas",
+  "Detection confidence": "Confiança da detecção",
+  "{shown} of {total} shown": "Detecções exibidas: {shown} de {total}",
   "Name of {name}": "Nome de {name}",
   "Change the colour of {name}": "Mudar a cor de {name}",
   "Colour of {name}": "Cor de {name}",
@@ -3034,18 +3060,18 @@
   "Which {place}?": "Qual {place}?",
   "Which place?": "Qual lugar?",
   "Not drawn: {parts}": "Não desenhado: {parts}",
-  "approximate": "aproximado",
+  "approximate": "aproximada",
   "{pct}% cloud": "{pct}% de nuvens",
   "Over {area}": "Área: {area}",
   "{count} of {total} acquisitions match": {
-    "many": "Aquisições correspondentes: {count} de {total}",
-    "one": "Aquisições correspondentes: {count} de {total}",
-    "other": "Aquisições correspondentes: {count} de {total}"
+    "one": "Imagens correspondentes: {count} de {total}",
+    "many": "Imagens correspondentes: {count} de {total}",
+    "other": "Imagens correspondentes: {count} de {total}"
   },
   "{n} acquisitions searched": {
-    "many": "Aquisições pesquisadas: {n}",
-    "one": "Aquisições pesquisadas: {n}",
-    "other": "Aquisições pesquisadas: {n}"
+    "one": "Imagens pesquisadas: {n}",
+    "many": "Imagens pesquisadas: {n}",
+    "other": "Imagens pesquisadas: {n}"
   },
   "No matching imagery": "Nenhuma imagem correspondente",
   "Unknown number of {kind}": "{kind}: número desconhecido",
@@ -3057,23 +3083,23 @@
   "Area around landmark": "Área ao redor de um ponto de referência",
   "Outline {place}": "Traçar contorno de {place}",
   "Outline area": "Traçar contorno da área",
-  "Find {place}": "Encontrar {place}",
-  "Find area": "Encontrar área",
-  "Find recent imagery": "Encontrar imagens recentes",
-  "Find {what}": "Encontrar {what}",
-  "Find places": "Encontrar lugares",
+  "Find {place}": "Buscar {place}",
+  "Find area": "Buscar área",
+  "Find recent imagery": "Buscar imagens recentes",
+  "Find {what}": "Buscar {what}",
+  "Find places": "Buscar lugares",
   "Drawing outline": "Desenhando contorno",
   "Searching imagery catalog": "Buscando no catálogo de imagens",
   "Loading imagery": "Carregando imagens",
   "Searching OpenStreetMap": "Buscando no OpenStreetMap",
   "voice area|Area": "Área",
-  "buffer sized to the place": "zona de margem do tamanho do local",
-  "enclosing mapped area": "área mapeada envolvente",
+  "buffer sized to the place": "círculo do tamanho aproximado do lugar",
+  "enclosing mapped area": "área mapeada que contém o ponto de referência",
   "the map was cleared while looking it up": "o mapa foi limpo durante a busca",
   "OpenStreetMap coverage varies by place": "A cobertura do OpenStreetMap varia de lugar para lugar",
   "the catalog covers the last 30 days": "o catálogo cobre os últimos 30 dias",
   "there are more": "há mais",
-  "{radius} m around the landmark": "{radius} m ao redor do local",
+  "{radius} m around the landmark": "{radius} m ao redor do ponto de referência",
   "{count} parts": {
     "many": "Partes: {count}",
     "one": "Partes: {count}",
@@ -3089,20 +3115,22 @@
     "one": "Duplicatas mescladas: {count}",
     "other": "Duplicatas mescladas: {count}"
   },
-  "listed the first {limit}": "listados os primeiros {limit}",
-  "counted over the bounding box of {area}, not its outline": "contado na caixa delimitadora ({area}), não no contorno",
+  "listed the first {limit}": "lista limitada a {limit}",
+  "counted over the bounding box of {area}, not its outline": "contagem na caixa delimitadora de {area}, não no contorno",
   "Search cancelled": "Busca cancelada",
-  "Sea Marks": "Sinais marítimos",
+  "Sea Marks": "Sinalização náutica",
   "Ski Pistes": "Pistas de esqui",
-  "Fly to Tokyo": "Voar para Tóquio",
-  "Show live flights": "Mostrar voos ao vivo",
+  "Fly to Tokyo": "Voe para Tóquio",
+  "Show live flights": "Mostre os voos ao vivo",
+  "Reset to globe view": "Volte à vista do globo",
+  "Show earthquakes": "Mostre os terremotos",
   "AI chat": "Chat de IA",
   "GEV CHAT": "CHAT GEV",
   "Ask about the map. Tell it where to go.": "Pergunte sobre o mapa. Diga para onde ir.",
   "Close chat": "Fechar chat",
   "Conversation": "Conversa",
   "Explore with a question": "Explore com uma pergunta",
-  "Find a place, explore live data, or change your view.": "Encontre um lugar, explore dados ao vivo ou mude sua visão.",
+  "Find a place, explore live data, or change your view.": "Encontre um lugar, explore dados ao vivo ou mude a vista do mapa.",
   "Attachments": "Anexos",
   "Remove attachment": "Remover anexo",
   "Attach a map layer": "Anexar uma camada do mapa",
@@ -3119,8 +3147,8 @@
   "Stop reply": "Parar resposta",
   "Send message": "Enviar mensagem",
   "Panel position": "Posição do painel",
-  "Move above the dock": "Mover para cima do dock",
-  "Dock to the right": "Encaixar à direita",
+  "Move above the dock": "Posicionar acima do dock",
+  "Dock to the right": "Acoplar à direita",
   "Expand panel": "Expandir painel",
   "Minimize panel": "Minimizar painel",
   "You can attach up to four items.": "Você pode anexar até quatro itens.",
@@ -3132,14 +3160,14 @@
   "Thinking…": "Pensando…",
   "Working on the map…": "Trabalhando no mapa…",
   "Silent chat · microphone off": "Chat silencioso · microfone desligado",
-  "Reply interrupted. You can try again.": "Resposta interrompida. Você pode tentar de novo.",
-  "Could not connect. Try again.": "Não foi possível conectar. Tente de novo.",
+  "Reply interrupted. You can try again.": "Resposta interrompida. Você pode tentar novamente.",
+  "Could not connect. Try again.": "Não foi possível conectar. Tente novamente.",
   "Session ended. Send a message to start a new conversation.": "Sessão encerrada. Envie uma mensagem para iniciar uma nova conversa.",
-  "Connection timed out. Try again.": "A conexão expirou. Tente de novo.",
+  "Connection timed out. Try again.": "A conexão expirou. Tente novamente.",
   "Chat closed.": "Chat fechado.",
   "Connection stopped.": "Conexão interrompida.",
   "Message and attachments are too large. Remove an attachment or shorten your message.": "A mensagem e os anexos são grandes demais. Remova um anexo ou encurte sua mensagem.",
-  "Message was not sent. Try again.": "A mensagem não foi enviada. Tente de novo.",
+  "Message was not sent. Try again.": "A mensagem não foi enviada. Tente novamente.",
   "Reply stopped.": "Resposta interrompida.",
   "Suggestions": "Sugestões",
   "Recent": "Recentes",
@@ -3148,21 +3176,88 @@
   "CHAT": "CHAT",
   "Back to chat": "Voltar ao chat",
   "Back to voice": "Voltar à voz",
-  "Latest voice exchange": "Última troca de voz",
+  "Latest voice exchange": "Última interação por voz",
   "Try saying": "Experimente dizer",
   "What am I looking at?": "O que estou vendo?",
   "AI Provider": "Provedor de IA",
-  "The selected AI provider is shared by voice and chat.": "O provedor de IA escolhido é compartilhado por voz e chat.",
+  "The selected AI provider is shared by voice and chat.": "O provedor de IA selecionado é usado tanto pela voz quanto pelo chat.",
   "Show quick commands": "Mostrar comandos rápidos",
   "Chat replies are silent. No microphone access is needed.": "As respostas do chat são silenciosas. Não é preciso acesso ao microfone.",
   "Chat": "Chat",
   "Attach layer": "Anexar camada",
-  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "O chat por texto usa sua chave da API da OpenAI. O login do ChatGPT cobre apenas a voz.",
-  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "O chat por texto fica indisponível enquanto GEV_PREFER_CODEX_OAUTH exigir o ChatGPT OAuth.",
-  "That request needed too many steps. Changes already made to the map stay in place.": "Esse pedido precisou de etapas demais. As alterações já feitas no mapa continuam.",
+  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "O chat por texto usa sua chave de API da OpenAI. O login do ChatGPT vale apenas para a voz.",
+  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "O chat por texto fica indisponível enquanto GEV_PREFER_CODEX_OAUTH exigir o OAuth do ChatGPT.",
+  "That request needed too many steps. Changes already made to the map stay in place.": "Esse pedido precisou de etapas demais. As alterações já feitas no mapa são mantidas.",
   "That request needed too many steps. Try a simpler request.": "Esse pedido precisou de etapas demais. Tente um pedido mais simples.",
-  "The provider rejected the API key. Check it in Provider Settings.": "O provedor recusou a chave de API. Verifique-a nas configurações do provedor.",
-  "Too many chat requests. Try again in {seconds} s.": "Pedidos de chat demais. Tente de novo em {seconds} s.",
+  "The provider rejected the API key. Check it in Provider Settings.": "O provedor recusou a chave de API. Verifique-a em \"Configurações de provedores\".",
+  "Too many chat requests. Try again in {seconds} s.": "Chat: limite de requisições atingido. Tente novamente em {seconds} s.",
   "The provider refused access for this key. Check the key's project, region or permissions.": "O provedor negou o acesso para esta chave. Verifique o projeto, a região ou as permissões da chave.",
-  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "A conta do provedor está sem crédito. Verifique o faturamento ou escolha outro provedor de IA nas configurações."
+  "The provider account is out of credit. Check its billing, or choose another AI Provider in Settings.": "A conta do provedor está sem crédito. Verifique o faturamento ou escolha outro provedor de IA em \"Configurações\".",
+  "SIGHTING": "AVISTAMENTO",
+  "Show {name} sighting": "Mostrar avistamento de {name}",
+  "seen {age} ago": "visto há {age}",
+  "observed {age} ago": "observado há {age}",
+  "Be Whale Wise": "Respeite os cetáceos",
+  "Reported by {name} ({entity})": "Relatado por {name} ({entity})",
+  "Reported by {name}": "Relatado por {name}",
+  "Salish Sea": "Mar de Salish",
+  "Birds": "Aves",
+  "Mammals": "Mamíferos",
+  "Reptiles": "Répteis",
+  "Amphibians": "Anfíbios",
+  "Ray-finned fishes": "Peixes de nadadeiras raiadas",
+  "Insects": "Insetos",
+  "Arachnids": "Aracnídeos",
+  "Plants": "Plantas",
+  "Fungi": "Fungos",
+  "Other animals": "Outros animais",
+  "Other or unknown": "Outros ou desconhecidos",
+  "{label} {detail} — click to retry": "{label} {detail} — clique para tentar novamente",
+  "Wildlife sightings source unavailable": "Fonte de avistamentos indisponível",
+  "Show only community-confirmed (research-grade) sightings": "Mostrar apenas observações confirmadas pela comunidade (grau de pesquisa)",
+  "No recent sightings in view": "Nenhum avistamento recente na vista",
+  "Acartia feed unavailable": "Feed Acartia indisponível",
+  "Show all taxa": "Mostrar todos os grupos taxonômicos",
+  "BIRDS": "AVES",
+  "Show only birds": "Mostrar apenas aves",
+  "MAMMALS": "MAMÍFEROS",
+  "Show only mammals": "Mostrar apenas mamíferos",
+  "WHALES": "CETÁCEOS",
+  "Show only whales and dolphins (7 days)": "Mostrar apenas baleias e golfinhos (7 dias)",
+  "INSECTS": "INSETOS",
+  "Show only insects": "Mostrar apenas insetos",
+  "PLANTS": "PLANTAS",
+  "Show only plants": "Mostrar apenas plantas",
+  "All rights reserved": "Todos os direitos reservados",
+  "Cetacean": "Cetáceo",
+  "Wildlife Sightings": "Avistamentos de vida selvagem",
+  "Exit cockpit to fly to a sighting": "Saia da cabine para voar até um avistamento",
+  "Exit cockpit to fly to a sighting area": "Saia da cabine para voar até uma área de avistamento",
+  "Wildlife": "Vida selvagem",
+  "Zoom in for local sightings": "Amplie para ver avistamentos locais",
+  "Loading photo...": "Carregando foto…",
+  "Photo unavailable": "Foto indisponível",
+  "Location obscured to a 0.2° cell": "Localização ocultada em uma célula de 0,2°",
+  "Photo of {name}": "Foto de {name}",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "{count} avistamentos na vista",
+  "Close sighting": "Fechar avistamento",
+  "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.": "Fauna observada nas últimas 48 h (cetáceos 7 dias). A cor e o símbolo do emblema indicam o grupo taxonômico. Espécies sensíveis aparecem apenas em células de 0,2°; os relatos de mamíferos marinhos da Acartia no mar de Salish são arredondados para 0,01°. Não é um censo.",
+  "Open {name} on iNaturalist": "Abrir {name} no iNaturalist",
+  "Open {name} on Acartia": "Abrir {name} no Acartia",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "Colaboradores do iNaturalist · licenças por registro",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "Colaboradores do iNaturalist · Acartia {count} (mar de Salish) · licenças por registro",
+  "{days}d": "{days}d",
+  "All markers": "Todos os marcadores",
+  "Show markers of every age": "Mostrar marcadores de qualquer idade",
+  "Maximum event age: {days}d; undated markers are kept": "Idade máxima do evento: {days} dias; marcadores sem data mantidos",
+  "event age filter|All": "Todos",
+  "Event age": "Idade do evento",
+  "Event age: {days}d · undated kept": "Idade do evento: {days} dias · sem data mantidos",
+  "Close camera preview": "Fechar prévia da câmera",
+  "Refresh map still": "Atualizar imagem fixa no mapa",
+  "The map still uses a separate request and may show a different moment.": "A imagem no mapa usa uma solicitação separada e pode mostrar outro momento.",
+  "Video plays from Québec 511, which sees your IP address.": "O vídeo é reproduzido a partir do Québec 511, que vê o seu endereço IP."
 }

src/i18n/locales/ru.json

@@ -128,7 +128,7 @@
   "SRC {value}": "ИСТ. {value}",
   "{value} CONTEXT": "КОНТЕКСТ {value}",
   "Focus fire detection {title}, {details}": "Фокус на очаге пожара {title}, {details}",
-  "{value} conf": "увер.: {value}",
+  "{value} conf": "дост.: {value}",
   "{value} ago": "{value} назад",
   "sensor n/a": "сенсор н/д",
   "FIRE · {frp} MW": "ПОЖАР · {frp} МВт",
@@ -458,7 +458,7 @@
   "SOURCE STATUS UNAVAILABLE": "СТАТУС ИСТОЧНИКА НЕДОСТУПЕН",
   "Select flight {title}": "Выбрать рейс {title}",
   "TRACK ACQUIRED": "ЦЕЛЬ ЗАХВАЧЕНА",
-  "{label} · COURSE {heading}°": "{label} · КУРС {heading}°",
+  "{label} · COURSE {heading}°": "{label} · ПУТЕВОЙ УГОЛ {heading}°",
   "Restore real aircraft": "Вернуть реальный самолёт",
   "Reclassify as TR-3B": "Переклассифицировать как TR-3B",
   "No selected data layers": "Нет выбранных слоёв данных",
@@ -722,6 +722,8 @@
   "Contact Context actions": "Действия контекста контакта",
   "Available Space Missions": "Доступные космические миссии",
   "LOADING 30-DAY MISSION INDEX": "ЗАГРУЗКА ИНДЕКСА МИССИЙ ЗА 30 ДНЕЙ",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "Космические миссии недоступны: не удалось загрузить список миссий. Повторите попытку позже.",
+  "30-DAY MISSION INDEX UNAVAILABLE": "ИНДЕКС МИССИЙ ЗА 30 ДНЕЙ НЕДОСТУПЕН",
   "Radio playback": "Воспроизведение радио",
   "Radio volume": "Громкость радио",
   "STATION TAG": "ТЕГ СТАНЦИИ",
@@ -1953,6 +1955,9 @@
   "N/A": "Н/Д",
   "{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": "БЛИЖНИЕ ВОЗДУШНЫЕ СУДА: ДАННЫЕ НЕПОЛНЫЕ · ОТСУТСТВИЕ УГРОЗ НЕ ПОДТВЕРЖДЕНО",
   "{source} · LOCATION QUERY · RECENT": "{source} · ЗАПРОС ПО МЕСТУ · НЕДАВНИЕ",
   "ft": "фт",
   "kts": "уз",
@@ -2310,6 +2315,9 @@
   "SIMULATED — {reason}": "СИМУЛЯЦИЯ — {reason}",
   "TomTom key unavailable": "Ключ TomTom недоступен",
   "TomTom daily budget reached": "Исчерпан дневной лимит TomTom",
+  "Monthly traffic allowance used": "Месячный лимит данных о трафике исчерпан",
+  "Traffic rate limit reached": "Достигнут лимит запросов данных о трафике",
+  "Traffic service unavailable": "Сервис данных о трафике недоступен",
   "TomTom upstream unreachable": "Сервер TomTom не отвечает",
   "TomTom flow unavailable": "Поток TomTom недоступен",
   "API key rejected — check AISSTREAM_API_KEY": "Ключ API отклонён — проверьте AISSTREAM_API_KEY",
@@ -2749,6 +2757,11 @@
   "Zoom in for vector tile coverage": "Приблизьте карту, чтобы загрузить векторные тайлы",
   "Camera coverage unavailable": "Покрытие камер недоступно",
   "Hybrid": "Гибрид",
+  "Lines": "Линии",
+  "Dots": "Точки",
+  "Road lines colored by live flow: green to red": "Линии дорог по потоку онлайн: от зелёного к красному",
+  "Moving dots colored by live flow": "Движущиеся точки, окрашенные по потоку онлайн",
+  "Moving dots": "Движущиеся точки",
   "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 сопоставляется, где он есть",
@@ -3053,17 +3066,30 @@
   "Voice replies appear here.": "Здесь появляются голосовые ответы.",
   "Preview is off.": "Предпросмотр отключён.",
   "Automatic stop is unavailable for this voice connection.": "Автоматическая остановка недоступна для этого голосового подключения.",
-  "{lower} to {upper}": "от {lower} до {upper}",
+  "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)",
+  "≥ {value} MW": "≥ {value} МВт",
+  "Confidence": "Достоверность",
+  "Minimum fire radiative power, megawatts": "Минимальная мощность излучения пожара, мегаватты",
+  "fire intensity filter|All": "Все",
+  "Detection confidence": "Достоверность обнаружения",
+  "{shown} of {total} shown": "Показано {shown} из {total}",
+  "{lower} to {upper}": "От {lower} до {upper}",
   "Up to {upper}": "До {upper}",
   "From {lower}": "От {lower}",
   "Informational only · not for flight planning": "Только для информации · не для планирования полётов",
-  "Unnamed zone": "Зона без названия",
-  "Restricted airspace source unavailable": "Источник данных об ограниченном воздушном пространстве недоступен",
+  "Unnamed zone": "Без названия",
+  "Restricted airspace source unavailable": "Источник данных о зонах ограничения полётов недоступен",
   "Prohibited (P)": "Запретная зона (P)",
-  "Restricted (R)": "Зона ограничения (R)",
+  "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 Map и ограничений полётов БАС. Только для информации — не заменяет официальные инструменты планирования полётов БАС (B4UFLY / LAANC).",
   "Prohibited": "Запретная зона",
-  "Restricted": "Зона ограничения",
+  "Restricted": "Зона ограничения полётов",
   "Prohibited & Restricted Airspace": "Запретные зоны и зоны ограничения",
   "routing busy — too many routes at once": "сервис маршрутов занят: слишком много маршрутов одновременно",
   "route proxy error": "ошибка прокси маршрутов",
@@ -3097,13 +3123,13 @@
   "Directions, drawing and your own files": "Маршруты, рисование и ваши файлы",
   "Voice place search (needs an Overpass server)": "Голосовой поиск мест (нужен сервер Overpass)",
   "OSM Places": "Места OSM",
-  "state or province": "штат или провинция",
+  "state or province": "штат, провинция или область",
   "county or district": "округ или район",
   "neighbourhood": "район города",
   "natural region": "природный регион",
   "Which {place}?": "Какой из вариантов «{place}»?",
   "Which place?": "Какое место?",
-  "Not drawn: {parts}": "Не нарисовано: {parts}",
+  "Not drawn: {parts}": "Контур не нарисован: {parts}",
   "approximate": "приблизительно",
   "{pct}% cloud": "Облачность {pct}%",
   "Over {area}": "Область: {area}",
@@ -3124,7 +3150,7 @@
   "About {count} {kind}": "{kind}: около {count}",
   "At least {count} {kind}": "{kind}: не менее {count}",
   "{count} {kind}": "{kind}: {count}",
-  "In {area}": "Территория: {area}",
+  "In {area}": "Область: {area}",
   "Area around {place}": "Окрестности: {place}",
   "Area around landmark": "Окрестности ориентира",
   "Outline {place}": "Контур: {place}",
@@ -3140,12 +3166,12 @@
   "Searching OpenStreetMap": "Поиск в OpenStreetMap",
   "voice area|Area": "Область",
   "buffer sized to the place": "буферная зона по размеру места",
-  "enclosing mapped area": "охватывающая область на карте",
+  "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": "есть ещё",
-  "{radius} m around the landmark": "{radius} м вокруг объекта",
+  "there are more": "есть и другие",
+  "{radius} m around the landmark": "{radius} м вокруг ориентира",
   "{count} parts": {
     "few": "Частей: {count}",
     "many": "Частей: {count}",
@@ -3164,19 +3190,21 @@
     "one": "Объединено дублей: {count}",
     "other": "Объединено дублей: {count}"
   },
-  "listed the first {limit}": "показаны первые {limit}",
+  "listed the first {limit}": "показаны первые результаты: {limit}",
   "counted over the bounding box of {area}, not its outline": "подсчитано по ограничивающему прямоугольнику ({area}), а не по контуру",
   "Search cancelled": "Поиск отменён",
-  "Sea Marks": "Морские знаки",
-  "Ski Pistes": "Горнолыжные трассы",
-  "Fly to Tokyo": "Перелететь в Токио",
-  "Show live flights": "Показать рейсы в реальном времени",
+  "Sea Marks": "Навигационные знаки",
+  "Ski Pistes": "Лыжные трассы",
+  "Fly to Tokyo": "Перелети в Токио",
+  "Show live flights": "Покажи рейсы в реальном времени",
+  "Reset to globe view": "Вернись к виду всего глобуса",
+  "Show earthquakes": "Покажи землетрясения",
   "AI chat": "Чат с ИИ",
   "GEV CHAT": "ЧАТ GEV",
   "Ask about the map. Tell it where to go.": "Задайте вопрос о карте. Укажите, куда перейти.",
   "Close chat": "Закрыть чат",
   "Conversation": "Разговор",
-  "Explore with a question": "Начните исследование с вопроса",
+  "Explore with a question": "Начните с вопроса",
   "Find a place, explore live data, or change your view.": "Найдите место, изучите данные в реальном времени или измените вид.",
   "Attachments": "Вложения",
   "Remove attachment": "Удалить вложение",
@@ -3185,7 +3213,7 @@
   "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 КБ в сумме. Вложения отправляются провайдеру ИИ вместе с сообщением.",
   "Latest AI response": "Последний ответ ИИ",
-  "Expand conversation": "Развернуть разговор",
+  "Expand conversation": "Развернуть чат",
   "Command suggestions": "Подсказки команд",
   "Expand chat": "Развернуть чат",
   "Add attachment": "Добавить вложение",
@@ -3194,7 +3222,7 @@
   "Stop reply": "Остановить ответ",
   "Send message": "Отправить сообщение",
   "Panel position": "Положение панели",
-  "Move above the dock": "Переместить над панелью",
+  "Move above the dock": "Переместить над доком",
   "Dock to the right": "Закрепить справа",
   "Expand panel": "Развернуть панель",
   "Minimize panel": "Свернуть панель",
@@ -3204,15 +3232,15 @@
   "Each file must be 10 KB or smaller.": "Размер каждого файла не должен превышать 10 КБ.",
   "Choose a non-empty UTF-8 text file.": "Выберите непустой текстовый файл UTF-8.",
   "Connecting…": "Подключение…",
-  "Thinking…": "Обдумывание…",
-  "Working on the map…": "Работа с картой…",
+  "Thinking…": "Думаю…",
+  "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.": "Сеанс завершён. Отправьте сообщение, чтобы начать новый разговор.",
+  "Session ended. Send a message to start a new conversation.": "Сессия завершена. Отправьте сообщение, чтобы начать новый разговор.",
   "Connection timed out. Try again.": "Время ожидания подключения истекло. Попробуйте ещё раз.",
   "Chat closed.": "Чат закрыт.",
-  "Connection stopped.": "Соединение остановлено.",
+  "Connection stopped.": "Соединение прервано.",
   "Message and attachments are too large. Remove an attachment or shorten your message.": "Сообщение и вложения слишком велики. Удалите вложение или сократите сообщение.",
   "Message was not sent. Try again.": "Сообщение не отправлено. Попробуйте ещё раз.",
   "Reply stopped.": "Ответ остановлен.",
@@ -3221,9 +3249,9 @@
   "Quick commands": "Быстрые команды",
   "Open AI chat": "Открыть чат с ИИ",
   "CHAT": "ЧАТ",
-  "Back to chat": "Вернуться в чат",
+  "Back to chat": "Назад в чат",
   "Back to voice": "Назад к голосу",
-  "Latest voice exchange": "Последний голосовой обмен",
+  "Latest voice exchange": "Последние реплики голосового диалога",
   "Try saying": "Попробуйте сказать",
   "What am I looking at?": "Что я вижу?",
   "AI Provider": "Провайдер ИИ",
@@ -3234,10 +3262,77 @@
   "Attach layer": "Прикрепить слой",
   "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "Текстовый чат использует ваш ключ API OpenAI. Вход в ChatGPT действует только для голоса.",
   "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "Текстовый чат недоступен, пока GEV_PREFER_CODEX_OAUTH требует ChatGPT OAuth.",
-  "That request needed too many steps. Changes already made to the map stay in place.": "Этот запрос потребовал слишком много шагов. Уже внесённые изменения карты сохранятся.",
+  "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.": "Этот запрос потребовал слишком много шагов. Попробуйте запрос попроще.",
-  "The provider rejected the API key. Check it in Provider Settings.": "Провайдер отклонил ключ API. Проверьте его в настройках провайдера.",
-  "Too many chat requests. Try again in {seconds} s.": "Слишком много запросов чата. Повторите через {seconds} с.",
-  "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.": "На счёте провайдера закончились средства. Проверьте оплату или выберите другого провайдера ИИ в настройках."
+  "The provider rejected the API key. Check it in Provider Settings.": "Провайдер отклонил ключ API. Проверьте его в «Настройках провайдеров».",
+  "Too many chat requests. Try again in {seconds} s.": "Слишком много запросов в чате. Повторите попытку через {seconds} с.",
+  "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.": "На вашем счёте у провайдера закончились средства. Проверьте оплату или выберите другого провайдера ИИ в настройках.",
+  "SIGHTING": "НАБЛЮДЕНИЕ",
+  "Show {name} sighting": "Показать наблюдение: {name}",
+  "seen {age} ago": "замечено {age} назад",
+  "observed {age} ago": "наблюдалось {age} назад",
+  "Be Whale Wise": "Наблюдайте китов бережно",
+  "Reported by {name} ({entity})": "Сообщил: {name} ({entity})",
+  "Reported by {name}": "Сообщил: {name}",
+  "Salish Sea": "Селишское море",
+  "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": "Показать только подтверждённые сообществом наблюдения исследовательского уровня",
+  "No recent sightings in view": "Нет недавних наблюдений в области обзора",
+  "Acartia feed unavailable": "Лента Acartia недоступна",
+  "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": "Наблюдения живой природы",
+  "Exit cockpit to fly to a sighting": "Выйдите из кабины, чтобы перейти к наблюдению",
+  "Exit cockpit to fly to a sighting area": "Выйдите из кабины, чтобы перейти к области наблюдения",
+  "Wildlife": "Живая природа",
+  "Zoom in for local sightings": "Приблизьте для местных наблюдений",
+  "Loading photo...": "Загрузка фото…",
+  "Photo unavailable": "Фото недоступно",
+  "Location obscured to a 0.2° cell": "Местоположение скрыто в ячейке 0,2°",
+  "Photo of {name}": "Фото {name}",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "{count} наблюдений в области просмотра",
+  "Close sighting": "Закрыть наблюдение",
+  "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°; сообщения Acartia о морских млекопитающих моря Селиш округлены до 0,01°. Не перепись.",
+  "Open {name} on iNaturalist": "Открыть {name} в iNaturalist",
+  "Open {name} on Acartia": "Открыть {name} в Acartia",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "Участники iNaturalist · лицензия у каждой записи",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "Участники iNaturalist · Acartia {count} (море Сэлиш) · лицензия у каждой записи",
+  "{days}d": "{days}д",
+  "All markers": "Все метки",
+  "Show markers of every age": "Показать метки любого возраста",
+  "Maximum event age: {days}d; undated markers are kept": "Максимальный возраст события: {days} дн.; метки без даты сохранены",
+  "event age filter|All": "Все",
+  "Event age": "Возраст события",
+  "Event age: {days}d · undated kept": "Возраст события: {days} дн. · метки без даты сохранены",
+  "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-адрес."
 }

src/i18n/locales/uk.json

@@ -1118,8 +1118,16 @@
   "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": "Гібрид",
+  "Lines": "Лінії",
+  "Dots": "Точки",
+  "Road lines colored by live flow: green to red": "Лінії доріг за потоком онлайн: від зеленого до червоного",
+  "Moving dots colored by live flow": "Рухомі точки, забарвлені за потоком онлайн",
+  "Moving dots": "Рухомі точки",
   "TomTom key unavailable": "Ключ TomTom недоступний",
   "TomTom daily budget reached": "Вичерпано денний ліміт TomTom",
+  "Monthly traffic allowance used": "Місячний ліміт даних про трафік вичерпано",
+  "Traffic rate limit reached": "Досягнуто ліміту запитів даних про трафік",
+  "Traffic service unavailable": "Сервіс даних про трафік недоступний",
   "TomTom upstream unreachable": "Сервер TomTom не відповідає",
   "TomTom flow unavailable": "Потік TomTom недоступний",
   "SIMULATED — {reason}": "ІМІТАЦІЯ — {reason}",
@@ -1683,6 +1691,9 @@
   "REGIONAL NEWS": "РЕГІОНАЛЬНІ НОВИНИ",
   "{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": "КОНТАКТ ВТРАЧЕНО · ОСТАННІ ВІДОМІ ПОКАЗНИКИ · НЕ ОЗНАЧАЄ «УСЕ ЧИСТО»",
@@ -1761,7 +1772,7 @@
   "Restore real aircraft": "Повернути справжній літак",
   "Reclassify as TR-3B": "Перекласифікувати як TR-3B",
   "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": {
@@ -2869,6 +2880,8 @@
   "AVAILABLE MISSIONS": "ДОСТУПНІ МІСІЇ",
   "SELECT A MISSION TO INSPECT": "ВИБЕРІТЬ МІСІЮ ДЛЯ ПЕРЕГЛЯДУ",
   "LOADING 30-DAY MISSION INDEX": "ЗАВАНТАЖЕННЯ ІНДЕКСУ МІСІЙ ЗА 30 ДНІВ",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "Космічні місії недоступні: не вдалося завантажити список місій. Спробуйте пізніше.",
+  "30-DAY MISSION INDEX UNAVAILABLE": "ІНДЕКС МІСІЙ ЗА 30 ДНІВ НЕДОСТУПНИЙ",
   "TAB PREVIEWS · ENTER / SPACE SELECTS": "TAB — ОГЛЯД · ENTER / SPACE — ВИБІР",
   "Internet radio and local SDR": "Інтернет-радіо та локальний SDR",
   "STATION TAG": "ТЕГ СТАНЦІЇ",
@@ -3045,18 +3058,31 @@
   "Don't show this again": "Більше не показувати",
   "ESC to dismiss": "ESC — приховати",
   "Tip: the GEV MIC button in the dock lets you talk to the map.": "Порада: кнопка МІК у доку дає змогу говорити з картою.",
-  "{lower} to {upper}": "від {lower} до {upper}",
+  "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)",
+  "≥ {value} MW": "≥ {value} МВт",
+  "Confidence": "Достовірність",
+  "Minimum fire radiative power, megawatts": "Мінімальна потужність випромінювання пожежі, мегавати",
+  "fire intensity filter|All": "Усі",
+  "Detection confidence": "Достовірність виявлення",
+  "{shown} of {total} shown": "Показано {shown} з {total}",
+  "{lower} to {upper}": "Від {lower} до {upper}",
   "Up to {upper}": "До {upper}",
   "From {lower}": "Від {lower}",
   "Informational only · not for flight planning": "Лише для довідки · не для планування польотів",
-  "Unnamed zone": "Зона без назви",
-  "Restricted airspace source unavailable": "Джерело даних про обмежений повітряний простір недоступне",
+  "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 Map і обмежень польотів БпЛА. Лише для довідки — не замінює офіційні інструменти планування польотів БпЛА (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).": "Лише заборонені зони та зони обмеження польотів FAA (повітряний простір особливого використання), без UAS Facility Map і обмежень польотів БпЛА. Лише для довідки — не замінює офіційні інструменти планування польотів БпЛА (B4UFLY / LAANC).",
   "Prohibited": "Заборонена зона",
   "Restricted": "Зона обмеження",
-  "Prohibited & Restricted Airspace": "Заборонені зони та зони обмеження",
+  "Prohibited & Restricted Airspace": "Заборонені зони та зони обмеження польотів",
   "Malformed cyclone snapshot": "Некоректний знімок циклонів",
   "Cyclone request timed out": "Минув час очікування запиту циклонів",
   "scene|PLAY": "СТАРТ",
@@ -3097,7 +3123,7 @@
   "Directions, drawing and your own files": "Маршрути, малювання та ваші файли",
   "Voice place search (needs an Overpass server)": "Голосовий пошук місць (потрібен сервер Overpass)",
   "OSM Places": "Місця OSM",
-  "state or province": "штат або провінція",
+  "state or province": "область, штат або провінція",
   "county or district": "округ або район",
   "neighbourhood": "район міста",
   "natural region": "природний регіон",
@@ -3128,9 +3154,9 @@
   "Area around {place}": "Околиці: {place}",
   "Area around landmark": "Околиці орієнтира",
   "Outline {place}": "Контур: {place}",
-  "Outline area": "Контур області",
+  "Outline area": "Контур території",
   "Find {place}": "Пошук: {place}",
-  "Find area": "Знайти область",
+  "Find area": "Знайти територію",
   "Find recent imagery": "Знайти свіжі знімки",
   "Find {what}": "Пошук: {what}",
   "Find places": "Знайти місця",
@@ -3138,14 +3164,14 @@
   "Searching imagery catalog": "Пошук у каталозі знімків",
   "Loading imagery": "Завантаження знімків",
   "Searching OpenStreetMap": "Пошук в OpenStreetMap",
-  "voice area|Area": "Область",
+  "voice area|Area": "Територія",
   "buffer sized to the place": "буферна зона за розміром місця",
-  "enclosing mapped area": "охопна область на карті",
+  "enclosing mapped area": "нанесений контур, що охоплює орієнтир",
   "the map was cleared while looking it up": "карту було очищено під час пошуку",
-  "OpenStreetMap coverage varies by place": "Покриття OpenStreetMap відрізняється залежно від місця",
+  "OpenStreetMap coverage varies by place": "покриття OpenStreetMap різниться залежно від місця",
   "the catalog covers the last 30 days": "каталог охоплює останні 30 днів",
-  "there are more": "є ще",
-  "{radius} m around the landmark": "{radius} м навколо об’єкта",
+  "there are more": "є й інші",
+  "{radius} m around the landmark": "{radius} м навколо орієнтира",
   "{count} parts": {
     "few": "Частин: {count}",
     "many": "Частин: {count}",
@@ -3159,28 +3185,30 @@
     "other": "Намальовано частин: {drawn} з {total}"
   },
   "{count} duplicate mappings merged": {
-    "few": "Об’єднано дублікатів: {count}",
-    "many": "Об’єднано дублікатів: {count}",
-    "one": "Об’єднано дублікатів: {count}",
-    "other": "Об’єднано дублікатів: {count}"
+    "one": "Обʼєднано дублікатів: {count}",
+    "few": "Обʼєднано дублікатів: {count}",
+    "many": "Обʼєднано дублікатів: {count}",
+    "other": "Обʼєднано дублікатів: {count}"
   },
-  "listed the first {limit}": "показано перші {limit}",
+  "listed the first {limit}": "показано перші результати: {limit}",
   "counted over the bounding box of {area}, not its outline": "підраховано за обмежувальним прямокутником ({area}), а не за контуром",
   "Search cancelled": "Пошук скасовано",
-  "Sea Marks": "Морські знаки",
-  "Ski Pistes": "Гірськолижні траси",
-  "Fly to Tokyo": "Летіти до Токіо",
-  "Show live flights": "Показати рейси наживо",
+  "Sea Marks": "Навігаційні знаки",
+  "Ski Pistes": "Лижні траси",
+  "Fly to Tokyo": "Полети до Токіо",
+  "Show live flights": "Покажи рейси онлайн",
+  "Reset to globe view": "Поверни вигляд глобуса",
+  "Show earthquakes": "Покажи землетруси",
   "AI chat": "ШІ-чат",
   "GEV CHAT": "ЧАТ GEV",
-  "Ask about the map. Tell it where to go.": "Питайте про мапу. Скажіть, куди перейти.",
+  "Ask about the map. Tell it where to go.": "Питайте про карту. Скажіть, куди перейти.",
   "Close chat": "Закрити чат",
   "Conversation": "Розмова",
-  "Explore with a question": "Досліджуйте за допомогою запитання",
-  "Find a place, explore live data, or change your view.": "Знайдіть місце, перегляньте дані наживо або змініть вигляд.",
+  "Explore with a question": "Почніть із запитання",
+  "Find a place, explore live data, or change your view.": "Знайдіть місце, перегляньте дані в реальному часі або змініть вигляд.",
   "Attachments": "Вкладення",
-  "Remove attachment": "Вилучити вкладення",
-  "Attach a map layer": "Прикріпити шар мапи",
+  "Remove attachment": "Видалити вкладення",
+  "Attach a map layer": "Прикріпити шар карти",
   "Choose a 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 КБ загалом. Вкладення надсилаються вашому постачальнику ШІ разом із повідомленням.",
@@ -3190,30 +3218,30 @@
   "Expand chat": "Розгорнути чат",
   "Add attachment": "Додати вкладення",
   "Message GEV": "Повідомлення для GEV",
-  "Ask GEV anything about the map…": "Запитайте GEV будь-що про мапу…",
+  "Ask GEV anything about the map…": "Запитайте GEV будь-що про карту…",
   "Stop reply": "Зупинити відповідь",
   "Send message": "Надіслати повідомлення",
-  "Panel position": "Положення панелі",
+  "Panel position": "Розташування панелі",
   "Move above the dock": "Перемістити над доком",
   "Dock to the right": "Закріпити праворуч",
   "Expand panel": "Розгорнути панель",
   "Minimize panel": "Згорнути панель",
   "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.",
   "Connecting…": "Підключення…",
   "Thinking…": "Думаю…",
-  "Working on the map…": "Працюю з мапою…",
-  "Silent chat · microphone off": "Тихий чат · мікрофон вимкнено",
+  "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.": "Час підключення вичерпано. Спробуйте ще раз.",
+  "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.": "Відповідь зупинено.",
   "Suggestions": "Підказки",
@@ -3223,7 +3251,7 @@
   "CHAT": "ЧАТ",
   "Back to chat": "Назад до чату",
   "Back to voice": "Назад до голосу",
-  "Latest voice exchange": "Останній голосовий обмін",
+  "Latest voice exchange": "Остання голосова репліка й відповідь",
   "Try saying": "Спробуйте сказати",
   "What am I looking at?": "Що я бачу?",
   "AI Provider": "Постачальник ШІ",
@@ -3234,10 +3262,77 @@
   "Attach layer": "Прикріпити шар",
   "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "Текстовий чат використовує ваш ключ API OpenAI. Вхід у ChatGPT діє лише для голосу.",
   "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "Текстовий чат недоступний, поки GEV_PREFER_CODEX_OAUTH вимагає ChatGPT OAuth.",
-  "That request needed too many steps. Changes already made to the map stay in place.": "Цей запит потребував забагато кроків. Уже внесені зміни на мапі залишаються.",
+  "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.": "Цей запит потребував забагато кроків. Спробуйте простіший запит.",
-  "The provider rejected the API key. Check it in Provider Settings.": "Провайдер відхилив ключ API. Перевірте його в налаштуваннях провайдера.",
+  "The provider rejected the API key. Check it in Provider Settings.": "Постачальник відхилив ключ API. Перевірте його в «Налаштуваннях постачальників».",
   "Too many chat requests. Try again in {seconds} s.": "Забагато запитів до чату. Спробуйте ще раз через {seconds} с.",
-  "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.": "На рахунку провайдера закінчилися кошти. Перевірте оплату або виберіть іншого провайдера ШІ в налаштуваннях."
+  "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.": "На вашому рахунку в постачальника закінчилися кошти. Перевірте оплату або виберіть іншого постачальника ШІ в налаштуваннях.",
+  "SIGHTING": "СПОСТЕРЕЖЕННЯ",
+  "Show {name} sighting": "Показати спостереження: {name}",
+  "seen {age} ago": "помічено {age} тому",
+  "observed {age} ago": "спостерігалося {age} тому",
+  "Be Whale Wise": "Спостерігайте за китами дбайливо",
+  "Reported by {name} ({entity})": "Повідомив: {name} ({entity})",
+  "Reported by {name}": "Повідомив: {name}",
+  "Salish Sea": "Салішське море",
+  "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": "Показати лише підтверджені спільнотою спостереження дослідницького рівня",
+  "No recent sightings in view": "Немає недавніх спостережень в області огляду",
+  "Acartia feed unavailable": "Стрічка Acartia недоступна",
+  "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": "Спостереження живої природи",
+  "Exit cockpit to fly to a sighting": "Вийдіть із кабіни, щоб перейти до спостереження",
+  "Exit cockpit to fly to a sighting area": "Вийдіть із кабіни, щоб перейти до області спостереження",
+  "Wildlife": "Жива природа",
+  "Zoom in for local sightings": "Наблизьте для місцевих спостережень",
+  "Loading photo...": "Завантаження фото…",
+  "Photo unavailable": "Фото недоступне",
+  "Location obscured to a 0.2° cell": "Місцеположення приховано в комірці 0,2°",
+  "Photo of {name}": "Фото {name}",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "{count} спостережень у полі зору",
+  "Close sighting": "Закрити спостереження",
+  "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°; повідомлення Acartia про морських ссавців моря Селіш округлено до 0,01°. Не перепис.",
+  "Open {name} on iNaturalist": "Відкрити {name} в iNaturalist",
+  "Open {name} on Acartia": "Відкрити {name} в Acartia",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "Учасники iNaturalist · ліцензія в кожного запису",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "Учасники iNaturalist · Acartia {count} (море Селіш) · ліцензія в кожного запису",
+  "{days}d": "{days}д",
+  "All markers": "Усі позначки",
+  "Show markers of every age": "Показати позначки будь-якого віку",
+  "Maximum event age: {days}d; undated markers are kept": "Максимальний вік події: {days} дн.; позначки без дати збережено",
+  "event age filter|All": "Усі",
+  "Event age": "Вік події",
+  "Event age: {days}d · undated kept": "Вік події: {days} дн. · позначки без дати збережено",
+  "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-адресу."
 }

src/i18n/locales/zh-CN.json

@@ -1047,8 +1047,16 @@
   "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": "混合",
+  "Lines": "线条",
+  "Dots": "圆点",
+  "Road lines colored by live flow: green to red": "按实时路况着色的道路线条：从绿到红",
+  "Moving dots colored by live flow": "按实时路况着色的移动圆点",
+  "Moving dots": "移动圆点",
   "TomTom key unavailable": "TomTom 密钥不可用",
   "TomTom daily budget reached": "已达 TomTom 每日配额",
+  "Monthly traffic allowance used": "本月交通流量额度已用完",
+  "Traffic rate limit reached": "已达到交通数据请求频率上限",
+  "Traffic service unavailable": "交通服务不可用",
   "TomTom upstream unreachable": "TomTom 上游服务无法连接",
   "TomTom flow unavailable": "TomTom 路况不可用",
   "SIMULATED — {reason}": "模拟——{reason}",
@@ -1588,6 +1596,9 @@
   "REGIONAL NEWS": "地区新闻",
   "{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": "目标丢失 · 最后已知读数 · 不代表安全无虞",
@@ -1660,7 +1671,7 @@
   "Restore real aircraft": "恢复真实飞机",
   "Reclassify as TR-3B": "重新归类为 TR-3B",
   "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": {
@@ -2556,6 +2567,8 @@
   "AVAILABLE MISSIONS": "可用任务",
   "SELECT A MISSION TO INSPECT": "选择一项任务以查看",
   "LOADING 30-DAY MISSION INDEX": "正在加载 30 天任务索引",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "太空任务不可用：无法加载任务索引。请稍后重试。",
+  "30-DAY MISSION INDEX UNAVAILABLE": "30 天任务索引不可用",
   "TAB PREVIEWS · ENTER / SPACE SELECTS": "TAB 预览 · ENTER / 空格键选择",
   "Internet radio and local SDR": "网络电台与本地 SDR",
   "STATION TAG": "电台标签",
@@ -2843,14 +2856,27 @@
     "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 在 GitHub 发布这些 KMZ 产品。新上传的内容会在数秒内被检测到，并自动替换旧版本。点击标记查看报告。",
+  "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）",
+  "≥ {value} MW": "≥ {value} MW",
+  "Confidence": "置信度",
+  "Minimum fire radiative power, megawatts": "最小火辐射功率（兆瓦）",
+  "fire intensity filter|All": "全部",
+  "Detection confidence": "探测置信度",
+  "{shown} of {total} shown": "显示 {shown} / {total}",
   "{lower} to {upper}": "{lower} 至 {upper}",
   "Up to {upper}": "最高 {upper}",
-  "From {lower}": "自 {lower} 起",
+  "From {lower}": "最低 {lower}",
   "Informational only · not for flight planning": "仅供参考 · 不可用于飞行规划",
-  "Unnamed zone": "未命名区域",
-  "Restricted airspace source unavailable": "受限空域数据源不可用",
-  "Prohibited (P)": "禁区 (P)",
-  "Restricted (R)": "限制区 (R)",
+  "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 Map 和无人机飞行限制。仅供参考，不能替代官方无人机飞行规划工具（B4UFLY / LAANC）。",
   "Prohibited": "禁区",
   "Restricted": "限制区",
@@ -2896,7 +2922,7 @@
   "Not drawn: {parts}": "未绘制：{parts}",
   "approximate": "近似",
   "{pct}% cloud": "云量 {pct}%",
-  "Over {area}": "{area} 上空",
+  "Over {area}": "覆盖 {area}",
   "{count} of {total} acquisitions match": {
     "other": "匹配影像：{count}/{total}"
   },
@@ -2911,41 +2937,43 @@
   "In {area}": "位于 {area}",
   "Area around {place}": "{place} 周边区域",
   "Area around landmark": "地标周边区域",
-  "Outline {place}": "勾勒 {place} 轮廓",
-  "Outline area": "勾勒区域轮廓",
+  "Outline {place}": "绘制 {place} 轮廓",
+  "Outline area": "绘制区域轮廓",
   "Find {place}": "查找 {place}",
   "Find area": "查找区域",
   "Find recent imagery": "查找近期影像",
   "Find {what}": "查找 {what}",
   "Find places": "查找地点",
-  "Drawing outline": "正在勾勒轮廓",
+  "Drawing outline": "正在地图上绘制轮廓",
   "Searching imagery catalog": "正在搜索影像目录",
   "Loading imagery": "正在加载影像",
   "Searching OpenStreetMap": "正在搜索 OpenStreetMap",
   "voice area|Area": "区域",
   "buffer sized to the place": "按地点大小设置的缓冲区",
-  "enclosing mapped area": "包含该地点的地图区域",
+  "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": "还有更多",
-  "{radius} m around the landmark": "地标周围 {radius} 米",
+  "{radius} m around the landmark": "地标周围 {radius} m",
   "{count} parts": {
-    "other": "部分数：{count}"
+    "other": "{count} 个部分"
   },
   "{drawn} of {total} parts drawn": {
-    "other": "已绘制部分：{drawn}/{total}"
+    "other": "已绘制 {drawn}/{total} 个部分"
   },
   "{count} duplicate mappings merged": {
     "other": "已合并重复项：{count}"
   },
   "listed the first {limit}": "已列出前 {limit} 个",
-  "counted over the bounding box of {area}, not its outline": "按外接矩形（{area}）计数，而非其轮廓",
+  "counted over the bounding box of {area}, not its outline": "按 {area} 的外接矩形计数，而非其轮廓",
   "Search cancelled": "搜索已取消",
   "Sea Marks": "航标",
   "Ski Pistes": "滑雪道",
   "Fly to Tokyo": "飞往东京",
   "Show live flights": "显示实时航班",
+  "Reset to globe view": "重置为地球视图",
+  "Show earthquakes": "显示地震",
   "AI chat": "AI 聊天",
   "GEV CHAT": "GEV 聊天",
   "Ask about the map. Tell it where to go.": "询问地图信息，或指定前往的位置。",
@@ -2958,7 +2986,7 @@
   "Attach a map layer": "附加地图图层",
   "Choose a 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 KB。附件会随消息发送给您的 AI 服务商。",
+  "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 KB。附件会随消息发送给你的 AI 服务商。",
   "Latest AI response": "最新 AI 回复",
   "Expand conversation": "展开对话",
   "Command suggestions": "命令建议",
@@ -2969,18 +2997,18 @@
   "Stop reply": "停止回复",
   "Send message": "发送消息",
   "Panel position": "面板位置",
-  "Move above the dock": "移到底栏上方",
+  "Move above the dock": "移到停靠栏上方",
   "Dock to the right": "停靠到右侧",
   "Expand panel": "展开面板",
   "Minimize panel": "最小化面板",
   "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 KB。",
   "Choose a non-empty UTF-8 text file.": "请选择非空的 UTF-8 文本文件。",
   "Connecting…": "正在连接…",
   "Thinking…": "正在思考…",
-  "Working on the map…": "正在处理地图…",
+  "Working on the map…": "正在操作地图…",
   "Silent chat · microphone off": "静默聊天 · 麦克风已关闭",
   "Reply interrupted. You can try again.": "回复已中断。请重试。",
   "Could not connect. Try again.": "无法连接。请重试。",
@@ -3011,8 +3039,75 @@
   "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "GEV_PREFER_CODEX_OAUTH 要求使用 ChatGPT OAuth 时，文字聊天不可用。",
   "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.": "此请求所需步骤过多。请尝试更简单的请求。",
-  "The provider rejected the API key. Check it in Provider Settings.": "提供商拒绝了 API 密钥。请在提供商设置中检查。",
+  "The provider rejected the API key. Check it in Provider Settings.": "服务商拒绝了 API 密钥。请在服务商设置中检查。",
   "Too many chat requests. Try again in {seconds} s.": "聊天请求过多。请在 {seconds} 秒后重试。",
-  "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 提供商。"
+  "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 服务商。",
+  "SIGHTING": "目击",
+  "Show {name} sighting": "显示{name}目击",
+  "seen {age} ago": "{age}前目击",
+  "observed {age} ago": "{age}前观察",
+  "Be Whale Wise": "负责任地观鲸",
+  "Reported by {name} ({entity})": "报告方 {name}（{entity}）",
+  "Reported by {name}": "报告方 {name}",
+  "Salish Sea": "萨利希海",
+  "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": "仅显示社区确认（研究级）的目击",
+  "No recent sightings in view": "视野内无近期目击",
+  "Acartia feed unavailable": "Acartia数据源不可用",
+  "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": "野生生物目击",
+  "Exit cockpit to fly to a sighting": "退出驾驶舱以飞往目击地点",
+  "Exit cockpit to fly to a sighting area": "退出驾驶舱以飞往目击区域",
+  "Wildlife": "野生生物",
+  "Zoom in for local sightings": "放大查看当地目击",
+  "Loading photo...": "正在加载照片…",
+  "Photo unavailable": "照片不可用",
+  "Location obscured to a 0.2° cell": "位置已模糊至0.2°网格",
+  "Photo of {name}": "{name}的照片",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "视野内有 {count} 次目击",
+  "Close sighting": "关闭目击记录",
+  "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°网格显示；Acartia提供的萨利希海海洋哺乳动物目击位置四舍五入到0.01°。并非种群普查。",
+  "Open {name} on iNaturalist": "在 iNaturalist 上打开 {name}",
+  "Open {name} on Acartia": "在 Acartia 上打开 {name}",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "iNaturalist 贡献者 · 各记录单独授权",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "iNaturalist 贡献者 · Acartia {count}（萨利希海） · 各记录单独授权",
+  "{days}d": "{days}天",
+  "All markers": "所有标记",
+  "Show markers of every age": "显示所有时间的标记",
+  "Maximum event age: {days}d; undated markers are kept": "事件最长保留时间：{days}天；保留无日期标记",
+  "event age filter|All": "全部",
+  "Event age": "事件时间",
+  "Event age: {days}d · undated kept": "事件时间：{days}天内 · 保留无日期标记",
+  "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 播放，Québec 511 会看到你的 IP 地址。"
 }

src/i18n/locales/zh-Hant.json

@@ -1042,8 +1042,16 @@
   "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": "混合",
+  "Lines": "線條",
+  "Dots": "圓點",
+  "Road lines colored by live flow: green to red": "依即時路況著色的道路線條：由綠到紅",
+  "Moving dots colored by live flow": "依即時路況著色的移動圓點",
+  "Moving dots": "移動圓點",
   "TomTom key unavailable": "TomTom 密鑰不可用",
   "TomTom daily budget reached": "已達 TomTom 每日配額",
+  "Monthly traffic allowance used": "本月交通流量額度已用完",
+  "Traffic rate limit reached": "已達交通資料請求頻率上限",
+  "Traffic service unavailable": "交通服務無法使用",
   "TomTom upstream unreachable": "TomTom 上游服務無法連接",
   "TomTom flow unavailable": "TomTom 路況不可用",
   "SIMULATED — {reason}": "模擬——{reason}",
@@ -1578,6 +1586,9 @@
   "REGIONAL NEWS": "地區新聞",
   "{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": "目標丟失 · 最後已知讀數 · 不代表安全無虞",
@@ -1650,7 +1661,7 @@
   "Restore real aircraft": "恢復真實飛機",
   "Reclassify as TR-3B": "重新歸類為 TR-3B",
   "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": {
@@ -2544,6 +2555,8 @@
   "AVAILABLE MISSIONS": "可用任務",
   "SELECT A MISSION TO INSPECT": "選擇一項任務以查看",
   "LOADING 30-DAY MISSION INDEX": "正在加載 30 天任務索引",
+  "Space Missions unavailable: the mission index could not load. Try again later.": "太空任務無法使用：無法載入任務索引。請稍後再試。",
+  "30-DAY MISSION INDEX UNAVAILABLE": "30 天任務索引不可用",
   "TAB PREVIEWS · ENTER / SPACE SELECTS": "TAB 預覽 · ENTER / 空格鍵選擇",
   "Internet radio and local SDR": "網絡電臺與本地 SDR",
   "STATION TAG": "電臺標籤",
@@ -2847,16 +2860,16 @@
   "route proxy error": "路線代理出錯",
   "{lower} to {upper}": "{lower} 至 {upper}",
   "Up to {upper}": "最高 {upper}",
-  "From {lower}": "自 {lower} 起",
+  "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 Map 與無人機飛行限制。僅供參考，不能取代官方無人機飛行規劃工具（B4UFLY / LAANC）。",
-  "Prohibited": "禁航區",
-  "Restricted": "限航區",
-  "Prohibited & Restricted Airspace": "禁航區與限航區空域",
+  "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 Map 和無人機飛行限制。僅供參考，不能替代官方無人機飛行規劃工具（B4UFLY / LAANC）。",
+  "Prohibited": "禁區",
+  "Restricted": "限制區",
+  "Prohibited & Restricted Airspace": "禁區與限制區空域",
   "AUTHORING": "創作",
   "Create and edit scenes": "創建和編輯場景",
   "SCENE": "場景",
@@ -2882,6 +2895,19 @@
   "Download this scene as JSON or an asset bundle": "將此場景下載為 JSON 或資源包",
   "Left panels": "左側面板",
   "Right panels": "右側面板",
+  "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）",
+  "≥ {value} MW": "≥ {value} MW",
+  "Confidence": "置信度",
+  "Minimum fire radiative power, megawatts": "最小火輻射功率（兆瓦）",
+  "fire intensity filter|All": "全部",
+  "Detection confidence": "探測置信度",
+  "{shown} of {total} shown": "顯示 {shown} / {total}",
   "UTILITIES": "工具",
   "Exit cockpit to fly to a drawing": "請先退出座艙，再飛往繪製位置",
   "Directions, drawing and your own files": "路線導航、繪製和你自己的文件",
@@ -2896,7 +2922,7 @@
   "Not drawn: {parts}": "未繪製：{parts}",
   "approximate": "近似",
   "{pct}% cloud": "雲量 {pct}%",
-  "Over {area}": "{area} 上空",
+  "Over {area}": "覆蓋 {area}",
   "{count} of {total} acquisitions match": {
     "other": "匹配影像：{count}/{total}"
   },
@@ -2911,108 +2937,177 @@
   "In {area}": "位於 {area}",
   "Area around {place}": "{place} 周邊區域",
   "Area around landmark": "地標周邊區域",
-  "Outline {place}": "勾勒 {place} 輪廓",
-  "Outline area": "勾勒區域輪廓",
+  "Outline {place}": "繪製 {place} 輪廓",
+  "Outline area": "繪製區域輪廓",
   "Find {place}": "查找 {place}",
   "Find area": "查找區域",
   "Find recent imagery": "查找近期影像",
   "Find {what}": "查找 {what}",
   "Find places": "查找地點",
-  "Drawing outline": "正在勾勒輪廓",
+  "Drawing outline": "正在地圖上繪製輪廓",
   "Searching imagery catalog": "正在搜索影像目錄",
   "Loading imagery": "正在加載影像",
   "Searching OpenStreetMap": "正在搜索 OpenStreetMap",
   "voice area|Area": "區域",
   "buffer sized to the place": "按地點大小設置的緩衝區",
-  "enclosing mapped area": "包含該地點的地圖區域",
+  "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": "還有更多",
-  "{radius} m around the landmark": "地標周圍 {radius} 米",
+  "{radius} m around the landmark": "地標周圍 {radius} m",
   "{count} parts": {
-    "other": "部分數：{count}"
+    "other": "{count} 個部分"
   },
   "{drawn} of {total} parts drawn": {
-    "other": "已繪製部分：{drawn}/{total}"
+    "other": "已繪製 {drawn}/{total} 個部分"
   },
   "{count} duplicate mappings merged": {
     "other": "已合併重複項：{count}"
   },
   "listed the first {limit}": "已列出前 {limit} 個",
-  "counted over the bounding box of {area}, not its outline": "按外接矩形（{area}）計數，而非其輪廓",
+  "counted over the bounding box of {area}, not its outline": "按 {area} 的外接矩形計數，而非其輪廓",
   "Search cancelled": "搜索已取消",
   "Sea Marks": "航標",
   "Ski Pistes": "滑雪道",
   "Fly to Tokyo": "飛往東京",
-  "Show live flights": "顯示即時航班",
+  "Show live flights": "顯示實時航班",
+  "Reset to globe view": "重置為地球視圖",
+  "Show earthquakes": "顯示地震",
   "AI chat": "AI 聊天",
   "GEV CHAT": "GEV 聊天",
-  "Ask about the map. Tell it where to go.": "詢問地圖相關問題，告訴它要去哪裡。",
+  "Ask about the map. Tell it where to go.": "詢問地圖信息，或指定前往的位置。",
   "Close chat": "關閉聊天",
   "Conversation": "對話",
-  "Explore with a question": "用一個問題開始探索",
-  "Find a place, explore live data, or change your view.": "尋找地點、探索即時資料，或變更檢視。",
+  "Explore with a question": "從提問開始探索",
+  "Find a place, explore live data, or change your view.": "查找地點、探索實時數據或更改視圖。",
   "Attachments": "附件",
   "Remove attachment": "移除附件",
   "Attach a map layer": "附加地圖圖層",
   "Choose a 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 KB。附件會隨訊息傳送給你的 AI 供應商。",
+  "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 KB。附件會隨消息發送給你的 AI 服務商。",
   "Latest AI response": "最新 AI 回覆",
   "Expand conversation": "展開對話",
-  "Command suggestions": "指令建議",
+  "Command suggestions": "命令建議",
   "Expand chat": "展開聊天",
-  "Add attachment": "新增附件",
-  "Message GEV": "傳訊息給 GEV",
-  "Ask GEV anything about the map…": "問 GEV 任何關於地圖的問題…",
+  "Add attachment": "添加附件",
+  "Message GEV": "向 GEV 發送消息",
+  "Ask GEV anything about the map…": "向 GEV 詢問地圖相關問題…",
   "Stop reply": "停止回覆",
-  "Send message": "傳送訊息",
+  "Send message": "發送消息",
   "Panel position": "面板位置",
-  "Move above the dock": "移到底欄上方",
+  "Move above the dock": "移到停靠欄上方",
   "Dock to the right": "停靠到右側",
   "Expand panel": "展開面板",
   "Minimize panel": "最小化面板",
-  "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 KB。",
-  "Choose a non-empty UTF-8 text file.": "請選擇非空白的 UTF-8 文字檔。",
-  "Connecting…": "連線中…",
-  "Thinking…": "思考中…",
+  "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 KB。",
+  "Choose a non-empty UTF-8 text file.": "請選擇非空的 UTF-8 文本文件。",
+  "Connecting…": "正在連接…",
+  "Thinking…": "正在思考…",
   "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.": "連線逾時，請再試一次。",
+  "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.": "已停止回覆。",
+  "Connection stopped.": "連接已停止。",
+  "Message and attachments are too large. Remove an attachment or shorten your message.": "消息和附件過大。請移除附件或縮短消息。",
+  "Message was not sent. Try again.": "消息未發送。請重試。",
+  "Reply stopped.": "回覆已停止。",
   "Suggestions": "建議",
   "Recent": "最近",
-  "Quick commands": "快速指令",
-  "Open AI chat": "開啟 AI 聊天",
+  "Quick commands": "快捷命令",
+  "Open AI chat": "打開 AI 聊天",
   "CHAT": "聊天",
   "Back to chat": "返回聊天",
   "Back to voice": "返回語音",
   "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.": "聊天回覆不會發出聲音，不需要麥克風權限。",
+  "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.": "聊天回覆不播放聲音，無需訪問麥克風。",
   "Chat": "聊天",
   "Attach layer": "附加圖層",
-  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "文字聊天使用你的 OpenAI API 金鑰。ChatGPT 登入僅適用於語音。",
-  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "GEV_PREFER_CODEX_OAUTH 要求使用 ChatGPT OAuth 時，文字聊天無法使用。",
-  "That request needed too many steps. Changes already made to the map stay in place.": "此請求所需步驟過多。已對地圖做出的變更會保留。",
+  "Typed chat uses your OpenAI API key. ChatGPT sign-in covers voice only.": "文字聊天使用你的 OpenAI API 密鑰。ChatGPT 登錄僅適用於語音。",
+  "Typed chat is unavailable while GEV_PREFER_CODEX_OAUTH requires ChatGPT OAuth.": "GEV_PREFER_CODEX_OAUTH 要求使用 ChatGPT OAuth 時，文字聊天不可用。",
+  "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.": "此請求所需步驟過多。請嘗試更簡單的請求。",
-  "The provider rejected the API key. Check it in Provider Settings.": "供應商拒絕了 API 金鑰。請在供應商設定中檢查。",
+  "The provider rejected the API key. Check it in Provider Settings.": "服務商拒絕了 API 密鑰。請在服務商設置中檢查。",
   "Too many chat requests. Try again in {seconds} s.": "聊天請求過多。請在 {seconds} 秒後重試。",
-  "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 供應商。"
+  "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 服務商。",
+  "SIGHTING": "目擊",
+  "Show {name} sighting": "顯示{name}目擊",
+  "seen {age} ago": "{age}前目擊",
+  "observed {age} ago": "{age}前觀察",
+  "Be Whale Wise": "負責任地賞鯨",
+  "Reported by {name} ({entity})": "通報方 {name}（{entity}）",
+  "Reported by {name}": "通報方 {name}",
+  "Salish Sea": "薩利希海",
+  "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": "僅顯示社群確認（研究級）的目擊",
+  "No recent sightings in view": "視野內無近期目擊",
+  "Acartia feed unavailable": "Acartia資料來源無法使用",
+  "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": "野生生物目擊",
+  "Exit cockpit to fly to a sighting": "退出駕駛艙以飛往目擊地點",
+  "Exit cockpit to fly to a sighting area": "退出駕駛艙以飛往目擊區域",
+  "Wildlife": "野生生物",
+  "Zoom in for local sightings": "放大查看當地目擊",
+  "Loading photo...": "正在載入照片…",
+  "Photo unavailable": "照片無法使用",
+  "Location obscured to a 0.2° cell": "位置已模糊至0.2°網格",
+  "Photo of {name}": "{name}的照片",
+  "Acartia": "Acartia",
+  "CC BY 4.0": "CC BY 4.0",
+  "{count} sightings in view": "視野內有 {count} 次目擊",
+  "Close sighting": "關閉目擊紀錄",
+  "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°網格顯示；Acartia提供的薩利希海海洋哺乳動物目擊位置四捨五入到0.01°。並非族群普查。",
+  "Open {name} on iNaturalist": "在 iNaturalist 上打開 {name}",
+  "Open {name} on Acartia": "在 Acartia 上打開 {name}",
+  "iNaturalist": "iNaturalist",
+  "iNaturalist contributors · licences per record": "iNaturalist 貢獻者 · 各紀錄個別授權",
+  "iNaturalist contributors · Acartia {count} (Salish Sea) · licences per record": "iNaturalist 貢獻者 · Acartia {count}（薩利希海） · 各紀錄個別授權",
+  "{days}d": "{days}天",
+  "All markers": "所有標記",
+  "Show markers of every age": "顯示所有時間的標記",
+  "Maximum event age: {days}d; undated markers are kept": "事件最長保留時間：{days}天；保留無日期標記",
+  "event age filter|All": "全部",
+  "Event age": "事件時間",
+  "Event age: {days}d · undated kept": "事件時間：{days}天內 · 保留無日期標記",
+  "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 播放，Québec 511 會看到你的 IP 位址。"
 }

src/i18n/same-as-english.json

@@ -4,10 +4,12 @@
     "978 MHz UAT",
     "AIS: --",
     "AIS: {name}",
+    "Acartia",
     "BRG {value}°",
     "BRG —",
     "CAL {value}",
     "CAL · {badge}",
+    "CC BY 4.0",
     "CCTV",
     "CRS {value}°",
     "CRT",
@@ -28,8 +30,11 @@
     "SRC {value}",
     "Sentinel-2",
     "WHOT/BHOT",
+    "acartia.io ↗",
     "dB",
     "hPa",
+    "iNaturalist",
+    "iNaturalist ↗",
     "{source} HTTP {status}",
     "▲ {frp} MW"
   ],
@@ -40,6 +45,7 @@
     "AIS: {name}",
     "ANIME",
     "AUTO",
+    "Acartia",
     "Alternative",
     "Ambient",
     "Anime",
@@ -50,6 +56,7 @@
     "Bloom",
     "Blues",
     "Bus",
+    "CC BY 4.0",
     "CCTV",
     "CHAT",
     "COCKPIT",
@@ -178,11 +185,14 @@
     "WSW",
     "Washington DC",
     "Wind",
+    "acartia.io ↗",
     "dB",
     "feed status|live",
     "fire behavior|Minimal",
     "ft",
     "hPa",
+    "iNaturalist",
+    "iNaturalist ↗",
     "km",
     "km/h",
     "min",
@@ -201,6 +211,7 @@
     "{value} KM/S",
     "ΔN",
     "Ⅱ PAUSE",
+    "≥ {value} MW",
     "▲ {frp} MW"
   ],
   "es": [
@@ -307,6 +318,7 @@
     "WX",
     "audio {state}",
     "dB",
+    "fire confidence filter|Nominal+",
     "fire confidence|nominal",
     "ft",
     "hPa",
@@ -329,17 +341,27 @@
     "{value} KM",
     "{value} KM/H",
     "{value} KM/S",
+    "≥ {value} MW",
     "ΔE",
     "ΔN",
-    "▲ {frp} MW"
+    "▲ {frp} MW",
+    "ANIMAL · {name}",
+    "Acartia",
+    "CC BY 4.0",
+    "Reptiles",
+    "acartia.io ↗",
+    "iNaturalist ↗",
+    "iNaturalist"
   ],
   "fr": [
     "1090 MHz",
     "978 MHz UAT",
     "ALTITUDE",
     "ALTITUDE · FT",
+    "ANIMAL · {name}",
     "ANIME",
     "AUTO",
+    "Acartia",
     "Action",
     "Allocation",
     "Altitude {altitude}",
@@ -358,9 +380,11 @@
     "CALIBRATION",
     "CARGO",
     "CAUSE",
+    "CC BY 4.0",
     "CCTV",
     "CCTV OFF",
     "CCTV ON",
+    "CHAT",
     "COCKPIT",
     "COMMERCIAL",
     "CONTACT",
@@ -433,6 +457,7 @@
     "OK",
     "ON",
     "ON/OFF",
+    "Obs. {licence}",
     "Oldies",
     "PAUSE",
     "POSITION {age}",
@@ -448,8 +473,10 @@
     "RADAR · {units}",
     "RADIO",
     "REC",
+    "REPTILE · {name}",
     "Radio",
     "Reggae",
+    "Reptiles",
     "Rock",
     "S2 GhostMaps",
     "SAR",
@@ -484,10 +511,13 @@
     "VOLUME",
     "VS",
     "WHOT/BHOT",
+    "acartia.io ↗",
     "audio {state}",
     "dB",
     "ft",
     "hPa",
+    "iNaturalist",
+    "iNaturalist ↗",
     "image",
     "installation class|BASE",
     "installation class|INSTALLATION",
@@ -514,6 +544,7 @@
     "ΔE",
     "ΔN",
     "Ⅱ PAUSE",
+    "≥ {value} MW",
     "▲ {frp} MW"
   ],
   "it": [
@@ -686,19 +717,27 @@
     "{value} KM/H",
     "{value} KM/S",
     "{value} conf",
+    "≥ {value} MW",
     "ΔE",
     "ΔN",
-    "▲ {frp} MW"
+    "▲ {frp} MW",
+    "Acartia",
+    "CC BY 4.0",
+    "acartia.io ↗",
+    "iNaturalist ↗",
+    "iNaturalist"
   ],
   "ja": [
     "1090 MHz",
     "978 MHz UAT",
     "AIS: --",
     "AIS: {name}",
+    "Acartia",
     "BRG {value}°",
     "BRG —",
     "CAL {value}",
     "CAL · {badge}",
+    "CC BY 4.0",
     "CCTV",
     "CH {index} / {total}",
     "CRS {value}°",
@@ -723,9 +762,12 @@
     "Sentinel-2",
     "USB {rate} msg/s",
     "WHOT/BHOT",
+    "acartia.io ↗",
     "dB",
     "ft",
     "hPa",
+    "iNaturalist",
+    "iNaturalist ↗",
     "km",
     "km/h",
     "kt",
@@ -737,6 +779,7 @@
     "{type}  SPD: {speed}  HDG: {heading}",
     "ΔE",
     "ΔN",
+    "≥ {value} MW",
     "▲ {frp} MW"
   ],
   "pt": [
@@ -850,6 +893,7 @@
     "WHOT/BHOT",
     "WX",
     "dB",
+    "fire confidence filter|Nominal+",
     "fire confidence|nominal",
     "ft",
     "hPa",
@@ -868,11 +912,20 @@
     "{value} KM/H",
     "{value} KM/S",
     "ΔN",
-    "▲ {frp} MW"
+    "▲ {frp} MW",
+    "≥ {value} MW",
+    "ANIMAL · {name}",
+    "Acartia",
+    "CC BY 4.0",
+    "acartia.io ↗",
+    "iNaturalist ↗",
+    "iNaturalist"
   ],
   "ru": [
     "AIS: --",
     "AIS: {name}",
+    "Acartia",
+    "CC BY 4.0",
     "CCTV",
     "CRT",
     "FLIR",
@@ -886,11 +939,16 @@
     "S2 GhostMaps",
     "S2 · {name}",
     "VS",
-    "WHOT/BHOT"
+    "WHOT/BHOT",
+    "acartia.io ↗",
+    "iNaturalist",
+    "iNaturalist ↗"
   ],
   "uk": [
     "AIS: --",
     "AIS: {name}",
+    "Acartia",
+    "CC BY 4.0",
     "CCTV",
     "CRT",
     "FLIR",
@@ -899,7 +957,10 @@
     "NVG",
     "REC",
     "S2 GhostMaps",
-    "WHOT/BHOT"
+    "WHOT/BHOT",
+    "acartia.io ↗",
+    "iNaturalist",
+    "iNaturalist ↗"
   ],
   "zh-CN": [
     "1090 MHz",
@@ -927,9 +988,9 @@
     "MM",
     "NVG",
     "REC",
-    "SRC {value}",
     "S2 GhostMaps",
     "S2 · {name}",
+    "SRC {value}",
     "Sentinel-2",
     "Techno",
     "Trance",
@@ -954,9 +1015,15 @@
     "{type}  SPD: {speed}  HDG: {heading}",
     "{value} KM",
     "{value} KM/S",
+    "≥ {value} MW",
     "ΔE",
     "ΔN",
-    "▲ {frp} MW"
+    "▲ {frp} MW",
+    "Acartia",
+    "CC BY 4.0",
+    "acartia.io ↗",
+    "iNaturalist ↗",
+    "iNaturalist"
   ],
   "zh-Hant": [
     "1090 MHz",
@@ -1011,8 +1078,14 @@
     "{type}  SPD: {speed}  HDG: {heading}",
     "{value} KM",
     "{value} KM/S",
+    "≥ {value} MW",
     "ΔE",
     "ΔN",
-    "▲ {frp} MW"
+    "▲ {frp} MW",
+    "Acartia",
+    "CC BY 4.0",
+    "acartia.io ↗",
+    "iNaturalist ↗",
+    "iNaturalist"
   ]
 }

src/keylessGeocoder.js

@@ -1,3 +1,5 @@
+import { foldPlaceText } from './data/placeNames.js';
+
 /** Photon/OpenStreetMap place-search adapter. */
 const PHOTON_ENDPOINT = 'https://photon.komoot.io/api/';
 
@@ -233,19 +235,15 @@ export function photonSearchUrl(
 }
 
 /**
- * Place name reduced to comparable form: unaccented, lowercased, punctuation
- * collapsed to single spaces. "Huế" and "Hue" have to compare equal, because a
- * user typing either means the same city.
+ * Place name reduced to comparable form: lowercased, Latin accents removed,
+ * other scripts preserved, and punctuation collapsed to single spaces. "Huế"
+ * and "Hue" have to compare equal, because a user typing either means the same
+ * city.
  * @param {string} text
  * @returns {string}
  */
 export function normalizeToponym(text) {
-  return String(text ?? '')
-    .normalize('NFD')
-    .replace(/[\u0300-\u036f]/g, '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, ' ')
-    .trim();
+  return foldPlaceText(text);
 }
 
 /**

src/keylessGeocoder.test.mjs

@@ -35,6 +35,12 @@ import {
 import { geocodeNavigationMode } from './locations.js';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const MOSCOW_RESPONSES = JSON.parse(
+  fs.readFileSync(
+    path.join(ROOT, 'src/data/fixtures/photon-moscow-search.json'),
+    'utf8',
+  ),
+);
 
 /** Photon's real answer for "Hanoi", trimmed to the fields we consume. */
 const HANOI = {
@@ -249,6 +255,58 @@ test('a biased near-miss is refused, and the unbiased answer is taken instead',
   assert.equal(fetchImpl.urls.length, 2, 'the refused bias costs exactly one extra request');
 });
 
+test('a non-Latin exact match keeps the nearby namesake', async () => {
+  const fetchImpl = photonPair(
+    MOSCOW_RESPONSES.biased.features,
+    MOSCOW_RESPONSES.unbiased.features,
+  );
+
+  const result = await geocodeKeyless('Москва', {
+    bias: '38.90,71.80|39.00,71.90',
+    fetchImpl,
+  });
+
+  assert.equal(result.label, 'Москва, Тоҷикистон');
+  assert.equal(fetchImpl.urls.length, 1);
+});
+
+test('toponym folding preserves non-Latin scripts', () => {
+  const cases = [
+    ['Huế', 'hue'],
+    ['Москва', 'москва'],
+    ['Αθήνα', 'αθήνα'],
+    ['القاهرة', 'القاهرة'],
+    ['東京', '東京'],
+    ['São 東京', 'sao 東京'],
+    ['Straße', 'strasse'],
+    ['Tromsø', 'tromso'],
+    ['Łódź', 'lodz'],
+    ['The Hague', 'the hague'],
+  ];
+
+  for (const [input, expected] of cases) {
+    assert.equal(normalizeToponym(input), expected, input);
+  }
+});
+
+test('a leading "the" is part of the name a nearby match must equal', async () => {
+  // "The Hague" over upstate New York means the Dutch city, not Hague, NY.
+  const hagueNy = {
+    geometry: { type: 'Point', coordinates: [-73.5004, 43.6967] },
+    properties: { osm_key: 'place', osm_value: 'town', type: 'city', name: 'Hague', country: 'United States' },
+  };
+  const theHague = {
+    geometry: { type: 'Point', coordinates: [4.3113, 52.0799] },
+    properties: { osm_key: 'place', osm_value: 'city', type: 'city', name: 'The Hague', country: 'Nederland' },
+  };
+  const fetchImpl = photonPair([hagueNy], [theHague]);
+
+  const result = await geocodeKeyless('The Hague', { bias: '43.65,-73.55|43.75,-73.45', fetchImpl });
+
+  assert.equal(Math.round(result.lat), 52, `got ${result.label}`);
+  assert.equal(fetchImpl.urls.length, 2);
+});
+
 test('a biased match that leads with the name is taken without a second request', async () => {
   // The other half of the rule, and the reason bias exists at all: "Sixth
   // Street" over Austin must stay Austin's.

src/layers/awareness/controls.js

@@ -23,6 +23,7 @@ export function createControls({ state: layerState, services, parts, source }) {
 
     attachDataManager(dataManager) {
       layerState.dataManager = dataManager;
+      parts.dependencies.watchAdoptions(dataManager);
     },
 
     setParams(params = {}) {

src/layers/awareness/dependencies.js

@@ -79,6 +79,25 @@ export function createDependencies({
     });
   }
 
+  /**
+   * Give up a dependency the user adopts. A direct selection, or the Cockpit
+   * riding one of its aircraft, promotes a layer Contacts turned on into the
+   * user's own (`DataLayerManager.adoptLayerVisibility`). Releasing it when
+   * Contacts goes off would tear down that track or Cockpit before the
+   * Context restore could put the layer back.
+   */
+  function relinquishAdoptedDependency(change) {
+    if (change?.type === 'visibility' && change.adopted && change.enabled)
+      layerState.ownedDependencies.delete(change.layerId);
+  }
+
+  /** Follow one manager's adoptions; null stops following. */
+  function watchAdoptions(dataManager) {
+    layerState.unwatchAdoptions?.();
+    layerState.unwatchAdoptions =
+      dataManager?.subscribe?.(relinquishAdoptedDependency) || null;
+  }
+
   function activateOperationalContext() {
     const activationId = ++layerState.activationId;
     layerState.autoFocusRetryPending = false;
@@ -113,6 +132,7 @@ export function createDependencies({
     refreshAfterDeferredDependency,
     enableDependencies,
     releaseOwnedDependencies,
+    watchAdoptions,
     activateOperationalContext,
   };
 }

src/layers/awareness/lifecycle.js

@@ -340,6 +340,7 @@ export function createLifecycle({
       layerState.clearListener = null;
       layerState.subjectClearListener = null;
       layerState.viewer = null;
+      parts.dependencies.watchAdoptions(null);
       layerState.dataManager = null;
     },
   };

src/layers/awareness/model.js

@@ -196,6 +196,7 @@ export function createModel({ state: layerState, services, parts, source }) {
         id: cohort.id,
         label: cohort.label,
         source: cohort.source,
+        sourceStatus: cohort.sourceStatus || null,
         coverage: cohort.coverage || null,
         relationship: cohort.summary.relationship,
         count: cohort.summary.count,

src/layers/awareness/panel.js

@@ -8,6 +8,7 @@ import {
   t,
   translateKnown,
 } from '../../i18n/index.js';
+import { sourceStatusLabel } from '../../ui/layerNames.js';
 import { formatQuantity } from '../../ui/unitLabels.js';
 import { AWARENESS_PAGE_SIZE, AWARENESS_PAGE_ROTATE_MS } from './policy.js';
 import { distanceParts } from '../../data/distanceFormat.js';
@@ -150,7 +151,7 @@ export function createPanel({ state: layerState, parts }) {
       relationship: summary.relationship.toLowerCase(),
       label: cohort.label,
       count: `${presentAwarenessCount(summary)}${pageLabel}`,
-      detail: `${cohort.source}${coverage} · ${presentAwarenessReason(summary)}`,
+      detail: `${sourceStatusLabel(cohort.source, cohort.sourceStatus)}${coverage} · ${presentAwarenessReason(summary)}`,
       nearest,
     };
   }

src/layers/awareness/panel.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createPanel } from './panel.js';
+
+test('a Contacts row names its provider as the Layers panel does, with its feed state', () => {
+  const cohort = (id, source, sourceStatus) => ({
+    id,
+    label: id,
+    source,
+    sourceStatus,
+    summary: { relationship: 'OBSERVED', count: 1, nearest: [], reason: 'observed' },
+  });
+  const state = {
+    enabled: true,
+    results: {
+      subject: { label: 'AFR38JF' },
+      cohorts: [
+        cohort('flights', 'adsb.lol', 'fallback'),
+        cohort('military', 'adsb.lol', null),
+        cohort('ais-live-vessels', 'Datalastic', 'stale'),
+      ],
+    },
+    cohortPages: new Map(),
+    panelListeners: new Set(),
+    panelSignature: '',
+    navigationIndex: 0,
+  };
+  const parts = {
+    navigation: { canNavigateNext: () => false },
+    rendering: { hideDirectionOverlay() {} },
+  };
+  createPanel({ state, parts }).renderResults();
+  assert.deepEqual(
+    state.panelView.rows.map((row) => row.detail),
+    ['adsb.lol · FALLBACK · observed', 'adsb.lol · observed', 'Datalastic · STALE · observed'],
+  );
+  state.offPanelLocale?.();
+});

src/layers/awareness/queries.js

@@ -91,6 +91,7 @@ export function createQueries({ state: layerState, services, parts, source }) {
         stats.count ?? null,
         stats.status || null,
         stats.error || null,
+        stats.source || null,
       ];
     })
       .map((parts) => parts.join(':'))

src/layers/awareness/queries.test.mjs

@@ -81,3 +81,29 @@ test('Contacts excludes square corners and measures from the current moving subj
   assert.equal(moved.reason, 'mapped matches within 100 km of the subject');
   assert.deepEqual(installationState.contextAnchor, { latitude: 0, longitude: 0 });
 });
+
+test('Contacts cohorts carry the provider and whether it answered as a fallback or stale', () => {
+  const services = { installations: { getNearby: () => [], getStats: () => ({}) },
+    flights: { getNearby: () => [] }, military: { getNearby: () => [] }, vessels: { getNearby: () => [] } };
+  const parts = { navigation: { summarizeAwarenessCohortForNavigation: (items, source) =>
+    summarizeAwarenessCohort(items, source) } };
+  parts.queries = createQueries({ state: {}, services, parts });
+  const subjectOwner = createSubject({ state: {}, services, parts });
+  const states = {
+    // The OpenSky proxy answers from adsb.lol when OpenSky fails.
+    flights: { available: true, stats: { source: 'adsb.lol', coverage: '250nm regional fallback', count: 4, lastUpdate: 1 } },
+    military: { available: true, stats: { source: 'adsb.lol', fallback: false, count: 2, lastUpdate: 1 } },
+    'ais-live-vessels': { available: true, stats: { source: 'Datalastic', stale: true, count: 3, lastUpdate: 1 } },
+    'military-installations': { available: true, stats: { coverage: { kind: 'subject', radiusM: 100000 } } },
+  };
+  const { cohorts } = subjectOwner.evaluateSubject({
+    id: 'subject', layerId: 'flights', position: Cesium.Cartesian3.fromDegrees(0, 0, 10000),
+  }, states);
+  const byId = Object.fromEntries(cohorts.map((cohort) => [cohort.id, cohort]));
+  assert.equal(byId.flights.source, 'adsb.lol');
+  assert.equal(byId.flights.sourceStatus, 'fallback');
+  assert.equal(byId.military.sourceStatus, null);
+  assert.equal(byId['ais-live-vessels'].source, 'Datalastic');
+  assert.equal(byId['ais-live-vessels'].sourceStatus, 'stale');
+  assert.equal(byId['military-installations'].sourceStatus, null);
+});

src/layers/awareness/staleAfterLoading.test.mjs

@@ -0,0 +1,159 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { createQueries } from './queries.js';
+import { createSubject } from './subject.js';
+import { createModel } from './model.js';
+import { summarizeAwarenessCohort } from '../../data/militaryAwarenessEngine.js';
+import { layerFeedState } from '../../data/feedState.js';
+import aisLiveVesselsLayer, {
+  _setVesselStateForTest,
+  _beginAisSessionForTest,
+  _applyAisFeedSnapshotForTest,
+  _setAisRuntimeForTest,
+} from '../../data/aisLiveVessels.js';
+
+test('a poll that returns the same stale AIS snapshot restores STALE on Contacts cohorts', () => {
+  globalThis.document ??= { body: null };
+  const services = {
+    installations: { getNearby: () => [], getStats: () => ({}) },
+    flights: { getNearby: () => [] },
+    military: { getNearby: () => [] },
+    vessels: { getNearby: () => [] },
+  };
+  const layerState = {
+    enabled: true,
+    passive: true,
+    sourceRevision: '',
+    cohortPages: new Map(),
+    subject: {
+      id: 'site-1',
+      layerId: 'military-installations',
+      label: 'Site',
+      position: Cesium.Cartesian3.fromDegrees(0, 0, 0),
+    },
+  };
+  let states;
+  const parts = {
+    navigation: {
+      summarizeAwarenessCohortForNavigation: (items, source) =>
+        summarizeAwarenessCohort(items, source),
+      isFlightLayer: (id) => id === 'flights' || id === 'military',
+    },
+    rendering: { renderVisual() {}, scheduleDirectionOverlayUpdate() {} },
+    panel: { renderResults() {} },
+  };
+  const realQueries = createQueries({ state: layerState, services, parts });
+  parts.queries = { ...realQueries, collectSourceStates: () => states };
+  parts.model = createModel({ state: layerState, services, parts });
+  const subject = createSubject({ state: layerState, services, parts });
+  const flights = (lastUpdate) => ({
+    available: true, enabled: true, stale: false,
+    stats: { source: 'OpenSky Network', count: 4, lastUpdate },
+  });
+  const vessels = (loading) => ({
+    available: true, enabled: true, stale: true,
+    stats: { source: 'Datalastic', stale: true, count: 3, lastUpdate: 1000, loading },
+  });
+  const rest = {
+    military: { available: true, enabled: true, stale: false, stats: { source: 'adsb.lol', fallback: false, count: 1, lastUpdate: 1 } },
+    'military-installations': { available: true, enabled: true, stale: false, stats: { coverage: { kind: 'subject', radiusM: 100000 } } },
+  };
+  const ais = () => layerState.results.cohorts.find((c) => c.id === 'ais-live-vessels');
+
+  // 1. Stale AIS cache, nothing loading.
+  states = { flights: flights(1), 'ais-live-vessels': vessels(false), ...rest };
+  subject.refreshSelectedSubject(true);
+  assert.equal(ais().sourceStatus, 'stale');
+
+  // 2. AIS re-poll in flight while the flights poll lands (revision changes).
+  states = { flights: flights(2), 'ais-live-vessels': vessels(true), ...rest };
+  subject.refreshSelectedSubject();
+  assert.equal(ais().sourceStatus, 'stale', 'a poll in flight keeps the snapshot stale');
+
+  // 3. AIS poll returns the same stale snapshot; only loading flips back.
+  states = { flights: flights(2), 'ais-live-vessels': vessels(false), ...rest };
+  subject.refreshSelectedSubject();
+  subject.refreshSelectedSubject();
+  assert.equal(ais().sourceStatus, 'stale', 'Layers reads STALE again; Contacts/Cockpit must too');
+});
+
+function fakeRuntime() {
+  return {
+    now: () => 1000,
+    setTimeout: () => ({}),
+    clearTimeout() {},
+  };
+}
+
+test('first AIS connect (no snapshot yet) carries no STALE on the Contacts cohort', () => {
+  globalThis.document ??= { body: null };
+  _setAisRuntimeForTest(fakeRuntime());
+  _setVesselStateForTest({ viewer: {}, records: [] });
+  try {
+    _beginAisSessionForTest();
+    // What server/providers/vessels/ais-live.js answers while its socket connects.
+    _applyAisFeedSnapshotForTest({}, {
+      rows: [], source: 'AISStream', status: 'connecting', refreshing: true,
+    });
+    const vesselStats = aisLiveVesselsLayer.getStats();
+    assert.equal(vesselStats.loading, true);
+    assert.equal(vesselStats.stale, true);
+    assert.equal(vesselStats.lastUpdate, null);
+    assert.equal(layerFeedState(vesselStats), 'loading', 'Layers chip reads LOADING');
+
+    const flightsStats = { source: 'OpenSky Network', count: 2, lastUpdate: 5 };
+    const militaryStats = { source: 'adsb.lol', fallback: false, count: 1, lastUpdate: 5 };
+    const installStats = { coverage: { kind: 'subject', radiusM: 100000 } };
+    const statsById = {
+      flights: flightsStats,
+      military: militaryStats,
+      'ais-live-vessels': vesselStats,
+      'military-installations': installStats,
+    };
+    const services = {
+      installations: { getNearby: () => [], getStats: () => installStats },
+      flights: { getNearby: () => [] },
+      military: { getNearby: () => [] },
+      vessels: aisLiveVesselsLayer,
+    };
+    const layerState = {
+      enabled: true,
+      passive: true,
+      sourceRevision: '',
+      cohortPages: new Map(),
+      dataManager: {
+        isEnabled: () => true,
+        getLayerLifecycleState: () => ({ enabled: true, lifecycleState: 'enabled' }),
+        layers: new Map(Object.entries(statsById).map(([id, s]) => [id, { module: { getStats: () => s } }])),
+      },
+      subject: {
+        id: 'site-1',
+        layerId: 'military-installations',
+        label: 'Site',
+        position: Cesium.Cartesian3.fromDegrees(0, 0, 0),
+      },
+    };
+    const parts = {
+      navigation: {
+        summarizeAwarenessCohortForNavigation: (items, source) => summarizeAwarenessCohort(items, source),
+        isFlightLayer: (id) => id === 'flights' || id === 'military',
+      },
+      rendering: { renderVisual() {}, scheduleDirectionOverlayUpdate() {} },
+      panel: { renderResults() {} },
+    };
+    parts.queries = createQueries({ state: layerState, services, parts });
+    parts.model = createModel({ state: layerState, services, parts });
+    const subject = createSubject({ state: layerState, services, parts });
+
+    const vesselsSource = parts.queries.collectSourceStates()['ais-live-vessels'];
+    assert.equal(vesselsSource.available, false, 'never-answered source is unavailable');
+
+    subject.refreshSelectedSubject(true);
+    const ais = layerState.results.cohorts.find((c) => c.id === 'ais-live-vessels');
+    assert.equal(ais.sourceStatus, null, 'no snapshot yet: no STALE label, Layers says LOADING');
+  } finally {
+    _setVesselStateForTest({ enabled: false });
+    _setAisRuntimeForTest();
+  }
+});

src/layers/awareness/state.js

@@ -26,6 +26,8 @@ export function createState({ services }) {
     // layers activate only after Contacts is explicitly selected.
     passive: true,
     ownedDependencies: new Set(),
+    /** Stops following the manager's adoptions (see watchAdoptions). */
+    unwatchAdoptions: null,
     subject: null,
     results: null,
     visual: null,

src/layers/awareness/subject.js

@@ -3,6 +3,7 @@ import {
   AWARENESS_RELATIONSHIP,
 } from '../../data/militaryAwarenessEngine.js';
 import * as Cesium from 'cesium';
+import { layerFeedState } from '../../data/feedState.js';
 import { t } from '../../i18n/index.js';
 import {
   AWARENESS_QUERY_LIMIT,
@@ -52,6 +53,18 @@ export function createSubject({ state: layerState, services, parts, source }) {
     const vesselsState = sourceStates['ais-live-vessels'];
     const installationsState = sourceStates['military-installations'];
     const evaluatedAt = Date.now();
+    // A poll in flight keeps FALLBACK or STALE: the revision key ignores loading.
+    // Before the first answer there is no snapshot, so loading stays.
+    const sourceStatus = (sourceState) => {
+      const feedState = layerFeedState(
+        sourceState.available
+          ? { ...sourceState.stats, loading: false }
+          : sourceState.stats,
+      );
+      return feedState === 'fallback' || feedState === 'stale'
+        ? feedState
+        : null;
+    };
     const retainedProvenance = (id, label, sourceState, fallbackSource) => {
       const retainedSource = sourceState.stats.source || fallbackSource;
       return {
@@ -94,6 +107,7 @@ export function createSubject({ state: layerState, services, parts, source }) {
           id: 'flights',
           label: t('Flights'),
           source: flightsState.stats.source || SOURCE_LABEL.flights,
+          sourceStatus: sourceStatus(flightsState),
           provenance: retainedProvenance(
             'flights',
             'Flights',
@@ -113,6 +127,7 @@ export function createSubject({ state: layerState, services, parts, source }) {
           id: 'military',
           label: t('Military flights'),
           source: militaryState.stats.source || SOURCE_LABEL.military,
+          sourceStatus: sourceStatus(militaryState),
           provenance: retainedProvenance(
             'military',
             'Military flights',
@@ -132,6 +147,7 @@ export function createSubject({ state: layerState, services, parts, source }) {
           id: 'ais-live-vessels',
           label: t('AIS vessels'),
           source: vesselsState.stats.source || SOURCE_LABEL['ais-live-vessels'],
+          sourceStatus: sourceStatus(vesselsState),
           provenance: retainedProvenance(
             'ais-live-vessels',
             'AIS vessels',
@@ -149,6 +165,7 @@ export function createSubject({ state: layerState, services, parts, source }) {
           source:
             installationsState.stats.source ||
             SOURCE_LABEL['military-installations'],
+          sourceStatus: sourceStatus(installationsState),
           provenance: retainedProvenance(
             'military-installations',
             'Mapped installations',

src/layers/cctv/cards.js

@@ -132,9 +132,11 @@ export function createCards({ state: layerState, services, parts, source }) {
           record.camera.lon,
         ),
         inView,
-        isVideo: parts.model.isVideoFeedType(
-          parts.model.normalizeFeedType(record.camera.feedType),
-        ),
+        // Québec's browser-only sources have no registered frame endpoint;
+        // keep them out of still-card fill just like video feeds.
+        isVideo:
+          parts.model.isVideoFeedCamera(record.camera) ||
+          parts.model.isBrowserOverlayCamera(record.camera),
         sx,
         sy,
       });

src/layers/cctv/catalog.js

@@ -237,9 +237,14 @@ export function createCatalog({ state: layerState, services, parts, source }) {
         groundElevationM,
         absoluteHeightM: groundElevationM + mountHeightM,
         pitchDeg,
+        frameRefreshMs: parts.model.safeNumber(source.frameRefreshMs, NaN),
         license: String(source.license || source.licenseNote || ''),
         credit: String(source.credit || ''),
         code: String(source.code || ''),
+        sourceUrl: String(source.sourceUrl || ''),
+        browserMediaUrl: String(source.browserMediaUrl || ''),
+        accuracyM: parts.model.safeNumber(source.accuracyM, NaN),
+        positionSource: String(source.positionSource || ''),
         // Shipped precompute (see server/providers/cctv/groundHeights.js).
         groundHeights:
           source.groundHeights && typeof source.groundHeights === 'object'

src/layers/cctv/frames.js

@@ -255,11 +255,20 @@ export function createFrames({ state: layerState, services, parts, source }) {
     // clears this latch so the next normal tick can refresh.
     if (runtime.imageLoading) return;
     const now = Date.now();
-    const refreshMs =
+    const defaultRefreshMs =
       record.camera.id === layerState._activeCameraId
         ? PROJECTION_ACTIVE_REFRESH_MS
         : PROJECTION_IDLE_REFRESH_MS;
-    if (!force && now - runtime.lastImageRefreshAt < refreshMs) return;
+    const sourceRefreshMs = parts.model.safeNumber(
+      record.camera.frameRefreshMs,
+      0,
+    );
+    const refreshMs = Math.max(defaultRefreshMs, sourceRefreshMs);
+    const sinceLastRefresh = now - runtime.lastImageRefreshAt;
+    // Forced activation may skip the normal active interval, but it cannot
+    // bypass a provider's explicit minimum between image requests.
+    if (sourceRefreshMs > 0 && sinceLastRefresh < sourceRefreshMs) return;
+    if (!force && sinceLastRefresh < refreshMs) return;
     runtime.lastImageRefreshAt = now;
 
     const frameUrl = frameUrlFor(record.camera, refreshMs);

src/layers/cctv/hover.js

@@ -49,9 +49,8 @@ export function createHover({ state: layerState, services, parts, source }) {
       !!record &&
       cameraId !== layerState._activeCameraId &&
       !layerState._cardIds.has(cameraId) &&
-      !parts.model.isVideoFeedType(
-        parts.model.normalizeFeedType(record.camera.feedType),
-      );
+      !parts.model.isBrowserOverlayCamera(record.camera) &&
+      !parts.model.isVideoFeedCamera(record.camera);
     if (eligible) {
       cancelHoverRelease();
       layerState._hoverCardId = cameraId;

src/layers/cctv/index.js

@@ -112,6 +112,8 @@ export function createCctvLayer({ services, source }) {
       _setCctvCoverageStateForTest: parts.testing._setCctvCoverageStateForTest,
       focusCctvRecord: parts.navigation.focusCctvRecord,
       maybeAutoHop: parts.navigation.maybeAutoHop,
+      openingCameraId: parts.navigation.openingCameraId,
+      reopenNearestCamera: parts.navigation.reopenNearestCamera,
       cctvCycleIndex: parts.navigation.cctvCycleIndex,
     },
   );

src/layers/cctv/lifecycle.js

@@ -151,6 +151,7 @@ export function createLifecycle({
       layerState._enabled = false;
       layerState._activeCameraId = null;
       layerState._autoHopSuspended = false;
+      layerState._openingCameraProvisional = false;
       layerState._lastHopAt = 0;
       layerState._lastViewContext = '';
       layerState._calibrationById = parts.calibration.loadCalibrationStore();
@@ -299,11 +300,8 @@ export function createLifecycle({
       }
 
       layerState._count = layerState._records.length;
-      if (layerState._records.length > 0) {
-        // Projection runtime + first frame fetch are deferred to enable() so
-        // initializing the catalog stays render-cheap.
-        layerState._activeCameraId = layerState._records[0].camera.id;
-      }
+      // No camera is picked here: enable() opens on the one nearest the
+      // viewer, unless restored params selected one first.
 
       // Task 5: if the prior batch lost init's bounded race, apply it post-hoc
       // when it lands (pure recomputes — applyLateGroundPriors guards against
@@ -361,6 +359,7 @@ export function createLifecycle({
         layerState._horizonCullListener = () => {
           layerState._cameraMoving = false;
           stopViewMotionTimer();
+          parts.navigation.reopenNearestCamera();
           settleView();
         };
         layerState._viewer.camera.moveEnd.addEventListener(
@@ -508,8 +507,9 @@ export function createLifecycle({
         return Boolean(coverage && layerState._recordById.has(coverage[1]));
       });
       if (!layerState._activeCameraId && layerState._records.length) {
-        layerState._activeCameraId = layerState._records[0].camera.id;
+        layerState._activeCameraId = parts.navigation.openingCameraId();
         layerState._autoHopSuspended = false;
+        layerState._openingCameraProvisional = true;
       }
       const activeRecord = parts.selection.getActiveRecord();
       if (activeRecord) {
@@ -629,6 +629,7 @@ export function createLifecycle({
       layerState._enabled = false;
       layerState._activeCameraId = null;
       layerState._autoHopSuspended = false;
+      layerState._openingCameraProvisional = false;
       // Clear existing subscribers rather than replacing the Set —
       // replacing would silently orphan any unsubscribe() closures
       layerState._listeners.clear();

src/layers/cctv/model.js

@@ -96,6 +96,19 @@ export function createModel({ state: layerState, services, parts, source }) {
     return feedType === 'mp4' || feedType === 'hls' || feedType === 'webm';
   }
 
+  /** A browser-only source still counts as live-capable for map icon/LOD policy. */
+  function isVideoFeedCamera(camera) {
+    return (
+      isVideoFeedType(normalizeFeedType(camera?.feedType)) ||
+      Boolean(camera?.browserMediaUrl)
+    );
+  }
+
+  /** Québec source pages and browser-played MP4s use the DOM overlay path. */
+  function isBrowserOverlayCamera(camera) {
+    return String(camera?.sourceKind || '').startsWith('quebec-');
+  }
+
   /**
    * Coerces a value to a finite number or returns the fallback.
    *
@@ -447,7 +460,12 @@ export function createModel({ state: layerState, services, parts, source }) {
 
   function projectionLoopIsNeeded() {
     if (!layerState._enabled || !layerState._viewer) return false;
-    if (layerState._showProjection && parts.selection.getActiveRecord())
+    const active = parts.selection.getActiveRecord();
+    if (
+      layerState._showProjection &&
+      active &&
+      !isBrowserOverlayCamera(active.camera)
+    )
       return true;
     return focusPassIsNeeded(
       getFocusTarget(),
@@ -553,6 +571,8 @@ export function createModel({ state: layerState, services, parts, source }) {
     angularDeltaAbs,
     normalizeFeedType,
     isVideoFeedType,
+    isVideoFeedCamera,
+    isBrowserOverlayCamera,
     safeNumber,
     headingFromId,
     quantize,

src/layers/cctv/modelSpecs.js

@@ -12,20 +12,28 @@
  * Cameras without an identified model are untouched — unknown never implies
  * anything.
  *
- * Spec records are vendored verbatim from the CCTV Camera Database
+ * Specification fields are vendored from the CCTV Camera Database
  * (https://github.com/ch-bas/cctv-camera-database, CC0-1.0) — an open dataset
- * of 28,000+ camera models transcribed from manufacturer datasheets (84% with
- * FOV, as of v2.26.0). This module vendors the records that the currently integrated public
+ * of 29,000+ camera models transcribed from manufacturer datasheets (76% with
+ * FOV, as of v2.29.0). This module vendors records that the integrated public
  * catalogs publish hardware for — King County WA (Cohu, Bosch AUTODOME, Axis
  * Q6135-LE), plus the Bosch AUTODOME and Axis PTZ/multisensor models that
- * appear in Sarasota County FL and Sioux Falls SD open data; packs that
+ * appear in Sarasota County FL and Sioux Falls SD open data, plus the Bosch MIC
+ * PTZs for the City of Amsterdam camera register proposed in #251; packs that
  * publish other hardware models can grow it, or vendor the full extract.
  *
  * Scope guardrail: records describe camera PRODUCTS (optics, resolution,
  * night vision) — never endpoints, stream paths, or access/config data.
  */
 
-/** Verbatim records from the dataset's model-enrichment extract (v2.26.0). */
+/**
+ * Records from the dataset's model-enrichment extract: v2.26.0, plus the Bosch
+ * MIC records from v2.29.0 with titles shortened to model codes.
+ * A Bosch MIC order code ends in a colour letter (B, G, W; registries write
+ * `x`) on one shared datasheet. The colours are aliases of one record whose
+ * `model` leaves the letter out, so the HUD never names a variant the source
+ * did not.
+ */
 const RECORDS = [
   {
     id: 'axis-q6135-le',
@@ -264,6 +272,67 @@ const RECORDS = [
     autotracking: true,
     environment: ['outdoor'],
   },
+  {
+    id: 'bosch-mic-7130-pb4',
+    brand: 'Bosch',
+    model: 'MIC-7130-P_4',
+    type: 'ptz',
+    url: 'https://www.cctv-database.com/camera/bosch-mic-7130-pb4/',
+    aliases: [
+      'MIC IP starlight 7000 HD',
+      'MIC-7130-PB4',
+      'MIC-7130-PG4',
+      'MIC-7130-PW4',
+      'MIC-7130-Px4',
+    ],
+    fov_deg: '2.1-59',
+    resolution: { mp: 1, w: 1280, h: 720, label: '720p' },
+    ptz: true,
+    autotracking: true,
+    varifocal: true,
+    environment: ['outdoor'],
+  },
+  {
+    id: 'bosch-mic-7502-z30b',
+    brand: 'Bosch',
+    model: 'MIC-7502-Z30',
+    type: 'ptz',
+    url: 'https://www.cctv-database.com/camera/bosch-mic-7502-z30b/',
+    aliases: [
+      'MIC-7502-Z30B',
+      'MIC-7502-Z30G',
+      'MIC-7502-Z30W',
+      'MIC-7502-Z30x',
+    ],
+    fov_deg: '2.3-63.7',
+    resolution: { mp: 2.13, w: 1920, h: 1080, label: '1080p' },
+    ptz: true,
+    autotracking: true,
+    varifocal: true,
+    night_vision: { type: 'color' },
+    environment: ['outdoor'],
+  },
+  {
+    id: 'bosch-mic-7522-z30b',
+    brand: 'Bosch',
+    model: 'MIC-7522-Z30',
+    type: 'ptz',
+    url: 'https://www.cctv-database.com/camera/bosch-mic-7522-z30b/',
+    aliases: [
+      'MIC-7522-Z30B',
+      'MIC-7522-Z30G',
+      'MIC-7522-Z30W',
+      'MIC-7522-Z30x',
+    ],
+    fov_deg: '2.1-58.3',
+    // i18n-ignore: datasheet label
+    resolution: { mp: 2, w: 1920, h: 1080, label: '1080p HD' },
+    ptz: true,
+    varifocal: true,
+    night_vision: { type: 'color' },
+    environment: ['outdoor'],
+    ndaa_compliant: true,
+  },
   {
     id: 'cohu-3920-idome',
     brand: 'Cohu',
@@ -431,7 +500,7 @@ const NAME_INDEX = RECORDS.flatMap((record) => {
  * guesses).
  * @param {string} model - Hardware model as named by a source pack or seed.
  * @param {string} [manufacturer] - The source's manufacturer, when published.
- * @returns {Object|null} The verbatim spec record, or null when unknown.
+ * @returns {Object|null} The matched spec record, or null when unknown.
  */
 export function lookupModelSpec(model, manufacturer) {
   const query = words(model).map(stripVariantSuffix);