i18n: fix review findings and polish ru/es strings

Fixes the 51 P0–P2 findings from the full review of the i18n branch and
the issues found while checking every new string on screen in ru and es.

- Translate errors and statuses that still reached ru/es in English:
  feed and tile errors, provider statuses, the ALPR chip, the traffic
  mode chip, voice plan step labels, fire feed values, receiver bands,
  scene save reasons and the Cesium attribution link.
- Show preset city names in the UI language (src/ui/placeNames.js);
  data and everything sent to the model stay English.
- Share layer names between the layer panel, HUD and voice card
  (src/ui/layerNames.js).
- Keep long ru/es strings whole: voice card error lines, analyst
  titles, the voice tier status, the Nepal evidence button, the ALPR
  retry chip. English layout is unchanged.
- Ask before a language switch drops unsaved work.
- Catalog fixes: glossary terms (пуск, пресет), gender agreement and
  consistent "peticiones" in es, fewer calques in both languages.
- Fix English text that was itself wrong (e.g. "Exit cockpit to fly to
  a weather", raw tool ids in voice plan steps).

Catalogs: es/ru 2535 messages each, complete.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

src/layers/traffic/controls.js

@@ -8,15 +8,17 @@ import {
   trafficStyleProfile,
 } from '../../data/trafficPresetStyle.js';
 import { TRAFFIC_TIMING_ENABLED } from './policy.js';
+import { t, translateKnown } from '../../i18n/index.js';
 
 export function createControls({ state: layerState, services, parts, source }) {
   /** One status line: feed, drawn road source, then degraded-coverage notes. */
   function roadStatusLabel(feed) {
     const source = layerState._roadSource;
     if (layerState._roadError)
-      return `UNAVAILABLE · ${source} · Roads unavailable`;
+      return t('UNAVAILABLE · {source} · Roads unavailable', { source });
     const notes = [feed.loadingLabel];
-    if (!layerState._liveMode || feed.error) notes.push(`Roads: ${source}`);
+    if (!layerState._liveMode || feed.error)
+      notes.push(t('Roads: {source}', { source }));
     // An explicit TomTom or Hybrid choice without a key draws OpenStreetMap.
     if (
       !layerState._liveMode &&
@@ -24,16 +26,24 @@ export function createControls({ state: layerState, services, parts, source }) {
     )
       notes.push(
         layerState._flowStatusUnavailable
-          ? `${layerState._roadMode === 'tomtom' ? 'TomTom roads' : 'Hybrid'} unavailable while the traffic service is unreachable`
+          ? layerState._roadMode === 'tomtom'
+            ? t(
+                'TomTom roads unavailable while the traffic service is unreachable',
+              )
+            : t('Hybrid unavailable while the traffic service is unreachable')
           : layerState._roadMode === 'tomtom'
-            ? 'TomTom roads need a TomTom key'
-            : 'Hybrid needs a TomTom key',
+            ? t('TomTom roads need a TomTom key')
+            : t('Hybrid needs a TomTom key'),
       );
-    if (layerState._surfacePending) notes.push('Local surface still loading');
-    if (layerState._roadWarning) notes.push(layerState._roadWarning);
-    else if (layerState._roadPartial) notes.push('Partial coverage');
-    if (layerState._detailError) notes.push('Detailed roads unavailable');
-    else if (layerState._detailLimited) notes.push('Reduced detail coverage');
+    if (layerState._surfacePending)
+      notes.push(t('Local surface still loading'));
+    // The warning is a road-source message (source.js marks the known ones).
+    if (layerState._roadWarning)
+      notes.push(translateKnown(layerState._roadWarning));
+    else if (layerState._roadPartial) notes.push(t('Partial coverage'));
+    if (layerState._detailError) notes.push(t('Detailed roads unavailable'));
+    else if (layerState._detailLimited)
+      notes.push(t('Reduced detail coverage'));
     return notes.join(' · ');
   }
 
@@ -161,13 +171,22 @@ export function createControls({ state: layerState, services, parts, source }) {
     getRowControls() {
       const selected =
         layerState._roadMode || resolveRoadMode(null, layerState._liveMode);
-      const needsKey = layerState._liveMode ? '' : ' (needs a TomTom key)';
+      const live = layerState._liveMode;
       const titles = {
-        tomtom: `TomTom roads only, each with its live flow${needsKey}`,
-        osm: 'OpenStreetMap roads, with TomTom flow matched when available',
-        hybrid: `TomTom roads first; OpenStreetMap fills the rest, simulated${needsKey}`,
+        tomtom: live
+          ? t('TomTom roads only, each with its live flow')
+          : t(
+              'TomTom roads only, each with its live flow (needs a TomTom key)',
+            ),
+        osm: t('OpenStreetMap roads, with TomTom flow matched when available'),
+        hybrid: live
+          ? t('TomTom roads first; OpenStreetMap fills the rest, simulated')
+          : t(
+              'TomTom roads first; OpenStreetMap fills the rest, simulated (needs a TomTom key)',
+            ),
       };
-      const labels = { tomtom: 'TomTom', osm: 'OSM', hybrid: 'Hybrid' };
+      // TomTom and OSM are provider names and stay as they are.
+      const labels = { tomtom: 'TomTom', osm: 'OSM', hybrid: t('Hybrid') };
       return {
         chips: TRAFFIC_ROAD_MODES.map((mode) => ({
           id: `roads-${mode}`,

src/layers/traffic/flow.js

@@ -11,6 +11,7 @@ import {
   FAST_FETCH_ALTITUDE,
   roadDotBudget,
 } from './policy.js';
+import { msg } from '../../i18n/index.js';
 
 export function createFlow({ state: layerState, services, parts, source }) {
   const { registerDynamicCredit, TOMTOM_CREDIT } = services.credits;
@@ -36,11 +37,13 @@ export function createFlow({ state: layerState, services, parts, source }) {
     const status = Number.isFinite(error.status)
       ? error.status
       : Number(message.match(/HTTP (\d{3})/)?.[1]);
-    if (status === 503) return 'TomTom key unavailable';
-    if (status === 429) return 'TomTom daily budget reached';
-    if (status === 502 || status === 504) return 'TomTom upstream unreachable';
+    // English in state; trafficFeedPresentation translates it for the panel.
+    if (status === 503) return msg('TomTom key unavailable');
+    if (status === 429) return msg('TomTom daily budget reached');
+    if (status === 502 || status === 504)
+      return msg('TomTom upstream unreachable');
     if (Number.isFinite(status)) return `TomTom flow error (HTTP ${status})`;
-    return 'TomTom flow unavailable';
+    return msg('TomTom flow unavailable');
   }
 
   /**

src/layers/traffic/model.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
 import { roadSurfaceChunks } from './surface.js';
-import { t } from '../../i18n/index.js';
+import { t, translateKnown } from '../../i18n/index.js';
 import {
   flowDensityMult,
   flowBucket,
@@ -252,7 +252,10 @@ export function createModel({ state: layerState, services, parts, source }) {
       // drops `loadingLabel` in its error branch, so the owner's SIMULATED copy
       // has to BE the error text or the steady state reverts to a bare
       // "TomTom daily budget reached" that never says what is on screen.
-      const degraded = `SIMULATED — ${flowError}`;
+      // The reason is ours (flow.js marks it) or carries an HTTP code.
+      const degraded = t('SIMULATED — {reason}', {
+        reason: translateKnown(flowError),
+      });
       return { mode, error: degraded, loadingLabel: degraded };
     }
     // TomTom and Hybrid name their geometry; OpenStreetMap keeps its match copy.

src/layers/traffic/roadStatus.i18n.test.mjs

@@ -0,0 +1,126 @@
+// K-37: the traffic road-status notes follow the UI language; English keeps
+// its wording.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { setLocale } from '../../i18n/index.js';
+import { createState } from './state.js';
+import { createControls } from './controls.js';
+
+function loadingLabel(overrides) {
+  const state = createState({ services: {} });
+  Object.assign(state, overrides);
+  const controls = createControls({
+    state,
+    services: {},
+    source: { getFlowSessionStats: () => ({}) },
+    parts: { model: { trafficFeedPresentation: () => ({ loadingLabel: '' }) } },
+  });
+  return controls.methods.getStats().loadingLabel;
+}
+
+const DEGRADED = {
+  _liveMode: false,
+  _roadMode: 'tomtom',
+  _roadSource: 'OpenStreetMap',
+  _roadPartial: true,
+  _detailLimited: true,
+  _surfacePending: 2,
+};
+
+test('en: road status notes keep their English wording', () => {
+  setLocale('en');
+  assert.equal(
+    loadingLabel(DEGRADED),
+    ' · Roads: OpenStreetMap · TomTom roads need a TomTom key · Local surface still loading · Partial coverage · Reduced detail coverage',
+  );
+  assert.equal(
+    loadingLabel({ _roadError: 'x', _roadSource: 'OpenStreetMap' }),
+    'UNAVAILABLE · OpenStreetMap · Roads unavailable',
+  );
+});
+
+for (const locale of ['es', 'ru']) {
+  test(`${locale}: road status notes are in the UI language`, () => {
+    setLocale(locale);
+    try {
+      const label = loadingLabel({
+        ...DEGRADED,
+        _roadPartial: false,
+        _roadWarning: 'OpenFreeMap tiles rate-limited',
+      });
+      for (const english of [
+        'Roads:',
+        'TomTom key',
+        'still loading',
+        'rate-limited',
+        'detail coverage',
+      ])
+        assert.ok(
+          !label.includes(english),
+          `${locale}: "${english}" in ${label}`,
+        );
+    } finally {
+      setLocale('en');
+    }
+  });
+}
+
+function roadChips(liveMode) {
+  const state = createState({ services: {} });
+  state._liveMode = liveMode;
+  const controls = createControls({
+    state,
+    services: {},
+    source: { getFlowSessionStats: () => ({}) },
+    parts: {},
+  });
+  return controls.methods.getRowControls().chips;
+}
+
+test('en: road-source chips keep their English labels and titles', () => {
+  setLocale('en');
+  assert.deepEqual(
+    roadChips(false).map((chip) => [chip.label, chip.title]),
+    [
+      [
+        'TomTom',
+        'TomTom roads only, each with its live flow (needs a TomTom key)',
+      ],
+      ['OSM', 'OpenStreetMap roads, with TomTom flow matched when available'],
+      [
+        'Hybrid',
+        'TomTom roads first; OpenStreetMap fills the rest, simulated (needs a TomTom key)',
+      ],
+    ],
+  );
+  assert.equal(
+    roadChips(true)[2].title,
+    'TomTom roads first; OpenStreetMap fills the rest, simulated',
+  );
+});
+
+for (const [locale, hybrid] of [
+  ['ru', 'Гибрид'],
+  ['es', 'Híbrido'],
+]) {
+  test(`${locale}: the Hybrid chip and every chip title are translated`, () => {
+    setLocale(locale);
+    try {
+      for (const live of [false, true]) {
+        const chips = roadChips(live);
+        assert.deepEqual(
+          chips.map((chip) => chip.label),
+          ['TomTom', 'OSM', hybrid],
+        );
+        for (const chip of chips)
+          assert.doesNotMatch(
+            chip.title,
+            /roads only|roads, with|fills the rest|needs a/,
+            `${locale}: ${chip.title}`,
+          );
+      }
+    } finally {
+      setLocale('en');
+    }
+  });
+}

src/layers/traffic/source.js

@@ -59,16 +59,20 @@ export class RoadRequestError extends Error {
   }
 }
 
+// AI tool services import this module, so it marks its English with a local
+// msg(); the traffic panel translates the message (controls.js).
+const msg = (text) => text;
+
 /** Name the road upstream without exposing raw transport errors or missing codes. */
 export function roadRequestError(status, cause) {
   const code = Number.isFinite(status) ? status : null;
   const message =
     code === 429
-      ? 'OpenFreeMap tiles rate-limited'
+      ? msg('OpenFreeMap tiles rate-limited')
       : code === 504 || cause?.name === 'TimeoutError'
-        ? 'OpenFreeMap tiles timed out'
+        ? msg('OpenFreeMap tiles timed out')
         : code === null
-          ? 'OpenFreeMap tiles unavailable'
+          ? msg('OpenFreeMap tiles unavailable')
           : `OpenFreeMap tiles unavailable (HTTP ${code})`;
   return Object.assign(new RoadRequestError(message, { status: code, cause }), {
     retryable: cause?.retryable !== false,