From d04939b813da2e9d5f4a0bc3e056616d78a57c90 Mon Sep 17 00:00:00 2001
From: Gaurav Patidar <patidargaurav4477@gmail.com>
Date: Wed, 9 Sep 2026 13:23:59 +0530
Subject: [PATCH 01/70] fix:docs

---
 CONTRIBUTING.md      | 19 +++++++++++++++++++
 DATA_SOURCES.md      | 30 ++++++++++++++++++++++++++++++
 docs/KNOWN-ISSUES.md |  6 +++---
 3 files changed, 52 insertions(+), 3 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 6760dfdf1..029b53514 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -27,6 +27,25 @@ through Pinokio; the terminal path above remains the contributor path.
 
 Open `http://localhost:4173`. Before sending a PR run `npm run build`, `npm test`, and `npm run test:track` (dev server must be up) — **all three must stay green.**
 
+### Test prerequisites
+
+- **`npm test`** — unit tests. Runs standalone; no dev server or credentials
+  required. Exit code is the gate.
+- **`npm run test:track`** — the 3D flight-tracking regression harness. It
+  drives the **real app** in headless Chromium, so it **requires a running
+  dev server** on the default port (`http://localhost:4173`). Pass
+  `--url <app-url>` to point it at another instance (e.g.
+  `node scripts/track-regression.mjs --url http://localhost:4272`). It does not
+  depend on live OpenSky / adsb.lol / AISStream (those are optional or
+  rate-limited locally); it installs a persistent `fetch` shim that returns
+  synthetic aircraft in the exact upstream payload shapes the layers parse.
+- **`npm run build`** — production Vite build. No server or credentials
+  required; it validates that the client bundle compiles cleanly.
+
+If you change runtime behavior, update `docs/CURRENT-STATE.md` and
+`CHANGELOG.md` in the same PR. For a deeper catalog of what each harness
+checks and what it needs to run, see [TESTING.md](TESTING.md).
+
 ## Good first contributions
 
 The highest-leverage places to jump in:
diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index faa351dca..bb0626117 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -125,6 +125,36 @@ the retrieval date (2026-07-30), exact download URL, license evidence, and the
 deterministic transform (`scripts/build-sf-neighborhoods.mjs`: `nhood` → `name`, ~2 m
 Douglas-Peucker simplification, 6-decimal rounding).
 
+### Pilot CCTV source packs (`config/`)
+
+`config/cctv_sources.shinjuku.json` is a **demo source pack** (3 cameras:
+Shinjuku Crossing, Shinjuku Station West, Shibuya Scramble) used for
+projection-pipeline testing. The feeds are Google-hosted sample MP4 videos
+(`storage.googleapis.com/gtv-videos-bucket/sample/`), not live public cameras.
+Camera poses (coordinates, heading, pitch, FOV, mount height) are fabricated
+priors placed at recognizable Tokyo intersections.
+
+Use the pack by setting:
+
+```bash
+CCTV_SOURCES_FILE=config/cctv_sources.shinjuku.json npm run dev
+```
+
+Or equivalently, via `./scripts/dev-cctv.sh`:
+
+```bash
+CCTV_SOURCES_FILE=config/cctv_sources.shinjuku.json ./scripts/dev-cctv.sh
+```
+
+The pack exercises the same CCTV registration and frustum-projection pipeline
+as live city packs without requiring network access to a camera catalog. It is
+**not** a live data source and carries no external attribution requirement. The
+sample videos are publicly available Google test media.
+
+`config/cctv_sources.austin.json` is the reference live pack. Custom source
+packs follow the same JSON schema (see either file); `CCTV_SOURCES_JSON`
+accepts inline JSON as an alternative to a file path.
+
 ---
 
 ## In-app attribution
diff --git a/docs/KNOWN-ISSUES.md b/docs/KNOWN-ISSUES.md
index 33c665f39..ca46d2ef0 100644
--- a/docs/KNOWN-ISSUES.md
+++ b/docs/KNOWN-ISSUES.md
@@ -57,9 +57,9 @@ Status: Open (owner-accepted 2026-07-08, documented)
   a few stragglers take one more poll.
 - **Born-grounded first poll:** a contact first seen on the ground with no altitude
   data renders at the geoid for ≤1 poll until its floor cell warms.
-- Full context, improvement ideas, and the verification oracle
-  (`scripts/qa-floor-verify.mjs`):
-  `docs/superpowers/reports/2026-07-08-height-datum-handover.md`.
+- Verify floor-placement behavior with `scripts/qa-floor-verify.mjs` against a
+  running local app; set `QA_BASE_URL` when it is not on the default port
+  (`http://localhost:4173`).
 
 ---
 

From e3772f806f660ade51817707208250c7b7dd9a51 Mon Sep 17 00:00:00 2001
From: Gaurav Patidar <patidargaurav4477@gmail.com>
Date: Fri, 11 Sep 2026 00:55:57 +0530
Subject: [PATCH 02/70] Clarify test:track command usage in CONTRIBUTING.md

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 CONTRIBUTING.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 029b53514..eef422a84 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -33,9 +33,8 @@ Open `http://localhost:4173`. Before sending a PR run `npm run build`, `npm test
   required. Exit code is the gate.
 - **`npm run test:track`** — the 3D flight-tracking regression harness. It
   drives the **real app** in headless Chromium, so it **requires a running
-  dev server** on the default port (`http://localhost:4173`). Pass
-  `--url <app-url>` to point it at another instance (e.g.
-  `node scripts/track-regression.mjs --url http://localhost:4272`). It does not
+  dev server** (default `http://localhost:4173`). To target another instance,
+  run `npm run test:track -- --url <app-url>` (or `node scripts/track-regression.mjs --url <app-url>`).
   depend on live OpenSky / adsb.lol / AISStream (those are optional or
   rate-limited locally); it installs a persistent `fetch` shim that returns
   synthetic aircraft in the exact upstream payload shapes the layers parse.

From 8e68a29c5079a58fe133dd4589ea0ec764d4b701 Mon Sep 17 00:00:00 2001
From: Aliciawque <166712943+Aliciawque@users.noreply.github.com>
Date: Mon, 12 Oct 2026 21:36:55 -0700
Subject: [PATCH 03/70] fix(cables): preserve feature ownership across
 multipart geometry

Associate expanded cable and landing entities through a copied source index,
retain one reference stem per feature, and cover duplicate IDs, bundled
segments and frozen provider inputs with real Cesium regressions.
---
 CHANGELOG.md                                  |   4 +
 docs/CURRENT-STATE.md                         |   8 +
 .../telegeographySubmarineCables.test.mjs     | 249 ++++++++++++++++++
 src/layers/submarineCables/ingestion.js       |  34 ++-
 4 files changed, 291 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b24ac95ed..f45d71d23 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+- Keep every submarine-cable segment associated with its source feature after
+  Cesium expands multipart geometry, correcting segment colors, click destinations
+  and horizon culling while retaining one reference stem per feature.
+
 - Treat explicitly current, complete empty vessel coverage as a successful update,
   clearing obsolete contacts while retaining stale or incomplete snapshots.
 
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 26d56e66b..33e4c36b4 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5002,6 +5002,14 @@ three Cesium data sources; enabling rebuilds from the accepted parsed cache,
 and destroying clears it. Load ownership prevents cancelled work from adding
 entities after teardown.
 
+Multipart cable and landing-point geometry retains its source feature on every
+Cesium entity, including generated IDs and IDs that collide with Cesium's
+multipart suffixes. Each segment receives its own feature's styling, click
+destination and horizon-culling reference; each source feature has one reference
+stem. Source collections and their properties are not modified. The copied input
+adds `__gevSourceFeatureIndex`, which remains observable in Cesium properties
+and default descriptions.
+
 Natural Earth regions and neighborhood polygon lookup are package exports.
 Their existing lazy loaders, retry behavior, bundled datasets and attribution
 are unchanged. The cable dataset remains CC BY-NC-SA 3.0 and is not covered by
diff --git a/src/data/telegeographySubmarineCables.test.mjs b/src/data/telegeographySubmarineCables.test.mjs
index 3850748dc..110f65f18 100644
--- a/src/data/telegeographySubmarineCables.test.mjs
+++ b/src/data/telegeographySubmarineCables.test.mjs
@@ -1754,3 +1754,252 @@ test('another GeoJSON source renders with its own label and rebuilds from accept
     env.layer.destroy(env.viewer);
   }
 });
+
+function multipartCableFixture() {
+  return [
+    {
+      type: 'Feature',
+      properties: {
+        id: 'alpha',
+        name: 'Alpha cable',
+        color: '#ff0000',
+        coordinates: [-40, 35],
+      },
+      geometry: {
+        type: 'MultiLineString',
+        coordinates: [
+          [
+            [-40, 35],
+            [-39, 36],
+          ],
+          [
+            [-38, 37],
+            [-37, 38],
+          ],
+          [
+            [-36, 39],
+            [-35, 40],
+          ],
+        ],
+      },
+    },
+    {
+      type: 'Feature',
+      properties: {
+        id: 'beta',
+        name: 'Beta cable',
+        color: '#0000ff',
+        coordinates: [140, -35],
+      },
+      geometry: {
+        type: 'LineString',
+        coordinates: [
+          [140, -35],
+          [141, -34],
+        ],
+      },
+    },
+  ];
+}
+
+function geometrySource(cables, landingPoints = []) {
+  return {
+    label: 'Multipart test source',
+    async fetch() {
+      return {
+        cables: { type: 'FeatureCollection', features: cables },
+        landingPoints: { type: 'FeatureCollection', features: landingPoints },
+      };
+    },
+  };
+}
+
+test('multipart association accepts frozen provider collections without modifying properties', async () => {
+  const payload = {
+    cables: { type: 'FeatureCollection', features: multipartCableFixture() },
+    landingPoints: {
+      type: 'FeatureCollection',
+      features: multipartCableFixture(),
+    },
+  };
+  payload.cables.features[0].properties.__gevSourceFeatureIndex =
+    'provider value';
+  const before = structuredClone(payload);
+  const freeze = (value) => {
+    if (value && typeof value === 'object') {
+      for (const child of Object.values(value)) freeze(child);
+      Object.freeze(value);
+    }
+    return value;
+  };
+  freeze(payload);
+  const env = await createRealCableLayerHarness({
+    source: { label: 'Frozen multipart source', fetch: async () => payload },
+  });
+  try {
+    for (const dataSource of env.dataSources.slice(0, 2)) {
+      assert.deepEqual(
+        dataSource.entities.values.map(
+          (entity) => entity.__gevTeleGeography?.label,
+        ),
+        ['Alpha cable', 'Alpha cable', 'Alpha cable', 'Beta cable'],
+      );
+    }
+    assert.equal(env.dataSources[2].entities.values.length, 4);
+    assert.deepEqual(payload, before);
+    const entity = env.dataSources[0].entities.values[0];
+    assert.equal(entity.properties.__gevSourceFeatureIndex.getValue(), 0);
+    assert.match(entity.description.getValue(), /__gevSourceFeatureIndex/);
+  } finally {
+    env.layer.destroy(env.viewer);
+  }
+});
+
+test('multipart cables retain their own styling, picking and culling on every segment', async () => {
+  const features = multipartCableFixture();
+  const before = JSON.stringify(features);
+  const env = await createRealCableLayerHarness({
+    source: geometrySource(features),
+  });
+  try {
+    const entities = env.dataSources[0].entities.values;
+    assert.equal(entities.length, 4);
+    for (const [index, entity] of entities.entries()) {
+      const feature = features[index < 3 ? 0 : 1];
+      const info = entity.__gevTeleGeography;
+      assert.equal(info?.label, feature.properties.name, entity.id);
+      assert.deepEqual(info.reference, {
+        lon: feature.properties.coordinates[0],
+        lat: feature.properties.coordinates[1],
+      });
+      assert.deepEqual(
+        entity.polyline.material.color.getValue(),
+        Cesium.Color.fromCssColorString(feature.properties.color).withAlpha(
+          0.92,
+        ),
+      );
+      assert.equal(entity.polyline.width.getValue(), 2.5);
+    }
+    env.raiseSweep();
+    assert.deepEqual(
+      entities.map((entity) => entity.show),
+      [true, true, true, false],
+    );
+    assert.equal(
+      env.dataSources[2].entities.values.length,
+      2,
+      'one reference per feature',
+    );
+    assert.equal(
+      JSON.stringify(features),
+      before,
+      'source features stay unchanged',
+    );
+  } finally {
+    env.layer.destroy(env.viewer);
+  }
+});
+
+test('multipart association supports missing and repeated IDs without guessing Cesium suffixes', async () => {
+  const features = multipartCableFixture();
+  features[1].id = 'alpha_2';
+  delete features[1].properties.id;
+  const generated = structuredClone(features[1]);
+  delete generated.id;
+  generated.properties.name = 'Generated cable';
+  features.push(generated);
+  const repeated = structuredClone(features[1]);
+  repeated.properties.id = 'alpha';
+  repeated.properties.name = 'Repeated ID cable';
+  features.push(repeated);
+  const env = await createRealCableLayerHarness({
+    source: geometrySource(features),
+  });
+  try {
+    const entities = env.dataSources[0].entities.values;
+    assert.deepEqual(
+      entities.map((entity) => entity.id),
+      ['alpha', 'alpha_2', 'alpha_3', 'alpha_2_2', 'cable-2', 'alpha_4'],
+    );
+    assert.deepEqual(
+      entities.map((entity) => entity.__gevTeleGeography?.label),
+      [
+        'Alpha cable',
+        'Alpha cable',
+        'Alpha cable',
+        'Beta cable',
+        'Generated cable',
+        'Repeated ID cable',
+      ],
+    );
+    assert.deepEqual(
+      env.dataSources[2].entities.values.map(
+        (entity) => entity.__gevTeleGeography.featureId,
+      ),
+      ['alpha', 'alpha_2', 'cable-2', 'alpha'],
+    );
+  } finally {
+    env.layer.destroy(env.viewer);
+  }
+});
+
+test('multipart landing geometry keeps every pick with one reference per feature', async () => {
+  const features = multipartCableFixture();
+  const env = await createRealCableLayerHarness({
+    source: geometrySource([], features),
+  });
+  try {
+    const entities = env.dataSources[1].entities.values;
+    assert.deepEqual(
+      entities.map((entity) => entity.__gevTeleGeography?.label),
+      ['Alpha cable', 'Alpha cable', 'Alpha cable', 'Beta cable'],
+    );
+    assert.ok(
+      entities.every(
+        (entity) => entity.__gevTeleGeography.kind === 'landing-point',
+      ),
+    );
+    assert.equal(env.dataSources[2].entities.values.length, 2);
+  } finally {
+    env.layer.destroy(env.viewer);
+  }
+});
+
+test('every bundled cable segment is associated with its source feature', async () => {
+  const { features } = JSON.parse(
+    readFileSync(
+      new URL(
+        './local_data/telegeography_submarine_cables/cable-geo.json',
+        import.meta.url,
+      ),
+      'utf8',
+    ),
+  );
+  // Some bundled features share a cable ID but have different references.
+  const expandedFeatures = features.flatMap((feature) =>
+    feature.geometry.coordinates.map(() => feature),
+  );
+  assert.ok(expandedFeatures.length > features.length);
+  const env = await createRealCableLayerHarness({
+    source: geometrySource(features),
+  });
+  try {
+    const entities = env.dataSources[0].entities.values;
+    assert.equal(entities.length, expandedFeatures.length);
+    for (const [index, entity] of entities.entries()) {
+      const feature = expandedFeatures[index];
+      assert.equal(
+        entity.__gevTeleGeography?.label,
+        feature.properties.name,
+        entity.id,
+      );
+      assert.deepEqual(entity.__gevTeleGeography.reference, {
+        lon: feature.properties.coordinates[0],
+        lat: feature.properties.coordinates[1],
+      });
+    }
+    assert.equal(env.dataSources[2].entities.values.length, features.length);
+  } finally {
+    env.layer.destroy(env.viewer);
+  }
+});
diff --git a/src/layers/submarineCables/ingestion.js b/src/layers/submarineCables/ingestion.js
index eaefbeb39..3779af9c9 100644
--- a/src/layers/submarineCables/ingestion.js
+++ b/src/layers/submarineCables/ingestion.js
@@ -5,6 +5,21 @@ import {
 } from './geometry.js';
 import * as Cesium from 'cesium';
 
+const SOURCE_FEATURE_INDEX = '__gevSourceFeatureIndex';
+
+function indexedCollection(features) {
+  return {
+    type: 'FeatureCollection',
+    features: features.map((feature, index) => ({
+      ...feature,
+      properties: {
+        ...feature.properties,
+        [SOURCE_FEATURE_INDEX]: index,
+      },
+    })),
+  };
+}
+
 export function createIngestion({ state, parts, source }) {
   async function load(viewer) {
     if (state._loading || state._loaded) return;
@@ -48,7 +63,7 @@ export function createIngestion({ state, parts, source }) {
       const landingFeatures = normalizeFeatures(landingJson, 'landing');
 
       const cableDataSource = await Cesium.GeoJsonDataSource.load(
-        { type: 'FeatureCollection', features: cableFeatures },
+        indexedCollection(cableFeatures),
         {
           clampToGround: true,
           stroke: state.cableColor.withAlpha(0.95),
@@ -60,7 +75,7 @@ export function createIngestion({ state, parts, source }) {
       );
       if (!owns()) return;
       const landingDataSource = await Cesium.GeoJsonDataSource.load(
-        { type: 'FeatureCollection', features: landingFeatures },
+        indexedCollection(landingFeatures),
         {
           clampToGround: true,
           stroke: state.landingColor.withAlpha(0.9),
@@ -130,7 +145,12 @@ export function createIngestion({ state, parts, source }) {
       state._referenceRecords = [];
       state._surfaceRecords = [];
 
-      cableEntities.forEach((entity, index) => {
+      // Cesium expands multipart geometry into several entities and suffixes
+      // colliding IDs. Its copied properties retain this source index even
+      // when a provider has no ID, so every segment keeps the right owner.
+      const cableReferences = new Set();
+      cableEntities.forEach((entity) => {
+        const index = entity.properties?.[SOURCE_FEATURE_INDEX]?.getValue();
         const feature = cableFeatures[index];
         const reference = featureReference(feature);
         if (!reference) return;
@@ -145,6 +165,8 @@ export function createIngestion({ state, parts, source }) {
           entity,
           base: Cesium.Cartesian3.fromDegrees(reference.lon, reference.lat, 0),
         });
+        if (cableReferences.has(index)) return;
+        cableReferences.add(index);
         parts.rendering.addReferenceStem({
           reference,
           label: featureLabel(feature),
@@ -154,7 +176,9 @@ export function createIngestion({ state, parts, source }) {
         });
       });
 
-      landingEntities.forEach((entity, index) => {
+      const landingReferences = new Set();
+      landingEntities.forEach((entity) => {
+        const index = entity.properties?.[SOURCE_FEATURE_INDEX]?.getValue();
         const feature = landingFeatures[index];
         const reference = featureReference(feature);
         if (!reference) return;
@@ -169,6 +193,8 @@ export function createIngestion({ state, parts, source }) {
           entity,
           base: Cesium.Cartesian3.fromDegrees(reference.lon, reference.lat, 0),
         });
+        if (landingReferences.has(index)) return;
+        landingReferences.add(index);
         parts.rendering.addReferenceStem({
           reference,
           label: featureLabel(feature),

From a856d54bba46424571e40227997eb576c9351396 Mon Sep 17 00:00:00 2001
From: John Leshan <johnkoolleshan@gmail.com>
Date: Sat, 17 Oct 2026 13:07:04 +0300
Subject: [PATCH 04/70] docs: add cloud setup path via GitHub Codespaces

---
 README.md | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/README.md b/README.md
index c49c53ece..75f796724 100644
--- a/README.md
+++ b/README.md
@@ -219,6 +219,38 @@ the container.
 
 </details>
 
+### Path 4 — GitHub Codespaces (cloud, no local GPU)
+
+Runs the same dev server in a cloud workspace, so integrated graphics and a
+local GPU never come into it. GitHub Free includes 120 core-hours a month with
+no card on file — about 60 hours on the default 2-core machine. Org and
+Enterprise plans include no free quota; current terms and quotas apply.
+
+1. Fork this repository, then open **your fork** on GitHub.
+2. Click the green **Code** button, the **Codespaces** tab, then **Create codespace on main**.
+3. In the codespace terminal:
+   ```bash
+   nvm install 24 && nvm use 24
+   npm ci
+   npm run doctor
+   GEV_ALLOWED_HOSTS="$CODESPACE_NAME-4173.$GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN" npm run dev
+   ```
+4. Open the **Ports** tab, find `4173`, and click the globe icon to open it in
+   the browser. The port is private by default, so the URL asks for your GitHub
+   login.
+
+`GEV_ALLOWED_HOSTS` there is required, not optional. The dev server answers only
+the hostnames it trusts, and a forwarded port arrives on
+`$CODESPACE_NAME-4173.$GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN`. Without it the
+page is `Blocked request. This host is not allowed.` Leading-dot wildcards are
+ignored on purpose, so pass that exact name.
+
+⚠️ **A codespace is reachable from the internet.** Treat it as the
+wider-publish case in [Sharing an instance](#-sharing-an-instance): leave
+Provider Settings closed to strangers, and put keys in the workspace `.env` by
+hand. `.env` is gitignored — never commit it. [SECURITY.md](SECURITY.md) has the
+threat model.
+
 ### Then power it up — in the app, not in a file
 
 Keys are upgrades, not prerequisites. When you want one, click the **POWER UP**

From 295e164fc3dac706ad51a47013e41e4f95441bd8 Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Mon, 19 Oct 2026 14:31:09 +0100
Subject: [PATCH 05/70] docs(readme): say Codespaces moves the server, not the
 rendering

The globe renders in the viewer's own browser, so a codespace does not
remove the need for local graphics. Retitle Path 4 accordingly.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 0e1f6ffe7..ce2e97ab9 100644
--- a/README.md
+++ b/README.md
@@ -219,12 +219,14 @@ the container.
 
 </details>
 
-### Path 4 — GitHub Codespaces (cloud, no local GPU)
+### Path 4 — GitHub Codespaces (cloud, no local install)
 
-Runs the same dev server in a cloud workspace, so integrated graphics and a
-local GPU never come into it. GitHub Free includes 120 core-hours a month with
-no card on file — about 60 hours on the default 2-core machine. Org and
-Enterprise plans include no free quota; current terms and quotas apply.
+Runs the same dev server in a cloud workspace, so Node and the dependencies
+never touch your machine. The globe still renders in your own browser, so it
+needs the same graphics there as any other path. GitHub Free includes 120
+core-hours a month with no card on file — about 60 hours on the default 2-core
+machine. Org and Enterprise plans include no free quota; current terms and
+quotas apply.
 
 1. Fork this repository, then open **your fork** on GitHub.
 2. Click the green **Code** button, the **Codespaces** tab, then **Create codespace on main**.

From 58a41759b52e795268e1be6cb2d1fa84547b2630 Mon Sep 17 00:00:00 2001
From: Aliciawque <166712943+Aliciawque@users.noreply.github.com>
Date: Thu, 22 Oct 2026 13:13:59 +0800
Subject: [PATCH 06/70] test: resolve sky texture file URLs on Windows

---
 src/tooling/skyAssets.paintOut.test.mjs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/tooling/skyAssets.paintOut.test.mjs b/src/tooling/skyAssets.paintOut.test.mjs
index ddb57589a..78a91519e 100644
--- a/src/tooling/skyAssets.paintOut.test.mjs
+++ b/src/tooling/skyAssets.paintOut.test.mjs
@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { fileURLToPath } from 'node:url';
 import sharp from 'sharp';
 import {
   CUBE_FACES,
@@ -24,7 +25,7 @@ test('painted-out planets leave no disc brighter than the sky around them', asyn
   }));
   for (const face of CUBE_FACES) {
     const { data, info } = await sharp(
-      new URL(`milkyway_${FACE_FILE_SUFFIX[face]}.webp`, SKY).pathname,
+      fileURLToPath(new URL(`milkyway_${FACE_FILE_SUFFIX[face]}.webp`, SKY)),
     )
       .raw()
       .toBuffer({ resolveWithObject: true });

From ea1b0d8d5506722e5672d685b5b0fe251e6ce3d0 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Tue, 27 Oct 2026 15:54:36 +0530
Subject: [PATCH 07/70] fix(voice): leave out an unreported altitude instead of
 saying 0 feet

select_nearest_aircraft passes altitudeM: null for an airborne contact
without a barometric altitude (military rows from adsb.lol can lack
alt_baro). The speech builder coerced it with Number(), and Number(null)
is 0, so the reply said "..., 0 feet." and the voice card showed
"Altitude 0 feet". Read the altitude only when it is a finite number,
so an unknown one is left out as the builder already intends.
---
 docs/CURRENT-STATE.md     |  2 ++
 src/voice/speech.js       |  6 +++---
 src/voice/speech.test.mjs | 14 ++++++++++++++
 3 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 0cb46940c..2a77faaf0 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5115,6 +5115,8 @@ and unreachable upstream (502/504) separately from road geometry.
   cannot race the nearest-aircraft query ahead of layer enablement. A healthy fallback feed is
   queried normally and its source is returned with the selection; fallback with
   no airborne records remains an honest no-data result, not an enable failure.
+  The spoken reply and the card leave out an altitude the feed did not report
+  rather than reading it as 0 feet.
 - Voice treats the parent Context panel and Contacts as separate intents. An
   explicit request to open Context expands only `global-context-panel`; it does
   not choose a mode. An explicit request to open Contacts expands that parent
diff --git a/src/voice/speech.js b/src/voice/speech.js
index c53881595..d698d863e 100644
--- a/src/voice/speech.js
+++ b/src/voice/speech.js
@@ -74,9 +74,9 @@ function listPhrase(items) {
 }
 
 function feetRounded(meters) {
-  const value = Number(meters);
-  return Number.isFinite(value)
-    ? Math.round((value * 3.28084) / 100) * 100
+  // A missing altitude is unknown, not sea level: Number(null) is 0.
+  return Number.isFinite(meters)
+    ? Math.round((meters * 3.28084) / 100) * 100
     : null;
 }
 
diff --git a/src/voice/speech.test.mjs b/src/voice/speech.test.mjs
index 36482290d..b280b2ebc 100644
--- a/src/voice/speech.test.mjs
+++ b/src/voice/speech.test.mjs
@@ -217,6 +217,20 @@ test('nearest-aircraft results name the aircraft, distance and altitude briefly'
   assert.equal(stale.say, 'Selected AAL1, 3.3 km from Austin, stale.');
 });
 
+test('nearest-aircraft results leave out an altitude the feed did not report', () => {
+  // gevActions sends `altitudeM: null` for an airborne military contact
+  // without a barometric altitude; that is unknown, not sea level.
+  const unknown = envelope('select_nearest_aircraft', {
+    ok: true,
+    location: 'Ramstein',
+    layerId: 'military',
+    feed: { state: 'nominal' },
+    aircraft: { callsign: 'RCH123', altitudeM: null, distanceKm: 8.2 },
+  });
+  assert.equal(unknown.say, 'Selected RCH123, 8.2 km from Ramstein.');
+  assert.deepEqual(unknown.display.lines, ['8.2\u00a0km from Ramstein']);
+});
+
 test('frame_overhead keeps the essential scope audible and lists referents', () => {
   const framed = envelope('frame_overhead', {
     ok: true,

From 83c4388e6412724bc5bb96394b50a5a2a6ca387c Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Tue, 27 Oct 2026 15:55:30 +0530
Subject: [PATCH 08/70] fix(awareness): show a 999.6 m contact marker as 1.0
 km, not 1000 m

The on-globe Contacts markers picked metres before rounding, so a contact
999.5 m or more away read "1000 m" while the Contacts panel read
"1.0 km". The marker label now rounds first, as the panel does.
---
 docs/CURRENT-STATE.md                     | 5 +++--
 src/data/militaryAwarenessEngine.js       | 6 ++++--
 src/data/militaryAwarenessEngine.test.mjs | 6 ++++++
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 0cb46940c..71803280c 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4461,8 +4461,9 @@ silent for five minutes are removed. Credits appear when the feed is used.
 coordinator, but it is not a user-visible Data Layers entry. Its visible entry
 point is the right-side `CONTEXT` chooser's `CONTACTS` mode.
 
-Contacts distance labels select metres or kilometres after rounding to the
-nearest metre, so a 999.5-metre contact displays as `1.0 km`, not `1000 m`.
+Contacts distance labels, in the panel and on the globe's contact markers,
+select metres or kilometres after rounding to the nearest metre, so a
+999.5-metre contact displays as `1.0 km`, not `1000 m`.
 
 At global scale, ambient Radio cluster badges are hard-opacity shared-host
 entries: count/category updates and identity replacement do not run keyhole or
diff --git a/src/data/militaryAwarenessEngine.js b/src/data/militaryAwarenessEngine.js
index 0f889d53f..059d6d437 100644
--- a/src/data/militaryAwarenessEngine.js
+++ b/src/data/militaryAwarenessEngine.js
@@ -47,8 +47,10 @@ export function findByDoublingRadius(
 /** @param {number} meters @returns {string} */
 export function formatAwarenessDistance(meters) {
   if (!Number.isFinite(meters) || meters < 0) return '—';
-  return meters < 1000
-    ? `${Math.round(meters)} m`
+  // Round before the kilometre cut. 999.6 m was printed as "1000 m".
+  const wholeMeters = Math.round(meters);
+  return wholeMeters < 1000
+    ? `${wholeMeters} m`
     : `${(meters / 1000).toFixed(meters < 10000 ? 1 : 0)} km`;
 }
 
diff --git a/src/data/militaryAwarenessEngine.test.mjs b/src/data/militaryAwarenessEngine.test.mjs
index 3415fd5d7..2fc57d0f6 100644
--- a/src/data/militaryAwarenessEngine.test.mjs
+++ b/src/data/militaryAwarenessEngine.test.mjs
@@ -24,6 +24,12 @@ test('awareness formatters preserve valid zeroes and replace missing or invalid
   assert.equal(formatAwarenessLabel(undefined), '—');
 });
 
+test('a contact marker moves a distance that rounds to 1,000 m into kilometres', () => {
+  assert.equal(formatAwarenessDistance(999.4), '999 m');
+  assert.equal(formatAwarenessDistance(999.6), '1.0 km');
+  assert.equal(formatAwarenessDistance(4600), '4.6 km');
+});
+
 test('awareness cohorts sort nearest-first and do not turn empty data into out of range', () => {
   const result = summarizeAwarenessCohort([{ id: 'far', distance: 9000 }, { id: 'near', distanceM: 1000 }]);
   assert.equal(result.relationship, 'NEARBY');

From 4f7b1bc01594cd57b75664e6840fb6352823808d Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Tue, 27 Oct 2026 16:45:33 +0530
Subject: [PATCH 09/70] fix(military): read a GNSS-sourced vertical rate when
 no baro rate is sent

readsb reports an aircraft's vertical rate as geom_rate instead of baro_rate
when its source is GNSS. The military normaliser read only baro_rate, so about
one in six live /v2/mil contacts had a null vertical rate in analyst and
tracked-aircraft data. Fall back to geom_rate, as the adsb.lol flights
fallback already does; a sent baro_rate still wins.
---
 docs/CURRENT-STATE.md              |  3 ++-
 src/sources/live/aircraft.js       |  3 ++-
 src/sources/live/contract.test.mjs | 14 ++++++++++++++
 3 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 0cb46940c..c5d66ce8e 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -1058,7 +1058,8 @@ The tracked-aircraft descriptor both flight layers hand to the cockpit carries
 `verticalRate` and military records as `verticalRateMps`; the query seam maps both to
 one name, so `resolveTrackedAircraftInfo` returns a single shape for either layer. The
 rate is reported, never derived: a blank poll keeps the last transmitted value and an
-absent rate stays null rather than reading as level flight.
+absent rate stays null rather than reading as level flight. A military readsb row
+without `baro_rate` reports its GNSS rate as `geom_rate`, which is used instead.
 
 ## Transponder emergency highlighting
 
diff --git a/src/sources/live/aircraft.js b/src/sources/live/aircraft.js
index 1af1f6b47..9da4f7a5f 100644
--- a/src/sources/live/aircraft.js
+++ b/src/sources/live/aircraft.js
@@ -48,7 +48,8 @@ export function normalizeReadsbAircraft(row, snapshotTimeMs) {
   const baroFt = finite(row.alt_baro),
     geoFt = finite(row.alt_geom);
   const speedKts = finite(row.gs),
-    rateFtMin = finite(row.baro_rate);
+    // readsb sends a GNSS-sourced rate as geom_rate instead of baro_rate.
+    rateFtMin = finite(row.baro_rate) ?? finite(row.geom_rate);
   const seen = finite(row.seen),
     seenPos = finite(row.seen_pos);
   return {
diff --git a/src/sources/live/contract.test.mjs b/src/sources/live/contract.test.mjs
index b8b1787da..79626f6b3 100644
--- a/src/sources/live/contract.test.mjs
+++ b/src/sources/live/contract.test.mjs
@@ -145,6 +145,20 @@ test('readsb units and position/contact ages are normalized once against the sou
   );
 });
 
+test('readsb vertical rate falls back to the GNSS rate when no baro rate is sent', () => {
+  // readsb reports the rate under geom_rate when the aircraft's source is
+  // GNSS; 26 of 157 positioned rows in a live /v2/mil fetch had only that.
+  const row = { hex: 'ae638d', lat: 20.3, lon: -158.5, geom_rate: -2432 };
+  assert.equal(
+    normalizeReadsbAircraft(row, now).verticalRateMps,
+    -2432 * 0.00508,
+  );
+  assert.equal(
+    normalizeReadsbAircraft({ ...row, baro_rate: -2400 }, now).verticalRateMps,
+    -2400 * 0.00508,
+  );
+});
+
 test('vessel identity, opaque reference and heading/course remain distinct, unknowns stay null', () => {
   const row = normalizeVesselObservation(
     {

From accb8983ca0fd55eeb0c475612d1cfa5457b911d Mon Sep 17 00:00:00 2001
From: Sunil56224972 <sunil56224972@users.noreply.github.com>
Date: Tue, 27 Oct 2026 18:02:32 +0530
Subject: [PATCH 10/70] fix(security): add cross-site gate to
 military-installations proxy

The /api/military-installations endpoint was the last keyless proxy without
the admitSameSite gate that protects terrain, CCTV, traffic, places, and
Celestrak. A cross-site <img>, foreign Origin, opaque origin, or
reverse-proxy-forwarded request now receives 403 before any Overpass query.
Same-origin app requests and bare tool requests continue to work.

Adds 4 integration tests (cross-site refused, same-origin admitted,
bare tool admitted, proxied refused) following the terrainHeightsBounds
test pattern.
---
 ...-military-installations-cross-site-gate.md |   6 +
 pr-body.md                                    |  75 +++++++++
 scripts/package-boundaries.json               |   4 +-
 server/providers/military-installations.js    |   2 +
 src/militaryInstallationsGate.test.mjs        | 147 ++++++++++++++++++
 5 files changed, 233 insertions(+), 1 deletion(-)
 create mode 100644 changelog.d/1427-military-installations-cross-site-gate.md
 create mode 100644 pr-body.md
 create mode 100644 src/militaryInstallationsGate.test.mjs

diff --git a/changelog.d/1427-military-installations-cross-site-gate.md b/changelog.d/1427-military-installations-cross-site-gate.md
new file mode 100644
index 000000000..3665da022
--- /dev/null
+++ b/changelog.d/1427-military-installations-cross-site-gate.md
@@ -0,0 +1,6 @@
+- The military-installations proxy (`/api/military-installations`) now refuses
+  cross-site browser requests with the same `admitSameSite` gate that protects
+  the terrain, CCTV, traffic, places, and Celestrak proxies. A cross-site
+  `<img>`, a foreign `Origin`, an opaque origin, or a reverse-proxy-forwarded
+  request receives 403 before any Overpass query runs. Same-origin app requests
+  and bare tool requests (curl, Node harness) continue to work. (Sunil56224972)
diff --git a/pr-body.md b/pr-body.md
new file mode 100644
index 000000000..28e73decc
--- /dev/null
+++ b/pr-body.md
@@ -0,0 +1,75 @@
+## Summary
+
+Adds the `admitSameSite` cross-site gate to `/api/military-installations`, as offered in the [#975 merge comment](https://github.com/bilawalsidhu/gods-eye-view/pull/975#issuecomment-6357981946).
+
+This was the last keyless proxy endpoint without the gate. After this change, every proxy that sends queries upstream now refuses cross-site browser requests before doing any work.
+
+| Endpoint | Gate before this PR | Gate after |
+|----------|-------------------|------------|
+| `/api/terrain/heights` | ✅ admitSameSite (#975) | ✅ |
+| `/api/cctv/frame/:id` | ✅ admitSameSite (#922) | ✅ |
+| `/api/traffic/*` | ✅ admitSameSite | ✅ |
+| `/api/google/*` | ✅ admitSameSite | ✅ |
+| `/api/gemini/*` | ✅ admitSameSite | ✅ |
+| `/api/space/satellites` | ✅ admitSameSite | ✅ |
+| `/api/overpass` | ✅ admitSameSite | ✅ |
+| `/api/military-installations` | ❌ **none** | ✅ admitSameSite |
+
+## The problem
+
+A cross-site page (or an `<img>` tag from any website) can query `/api/military-installations` and trigger upstream Overpass requests on the user's behalf. The endpoint has a rate limiter (90/min), but no cross-site gate — so a hostile page can burn through the user's Overpass quota and exfiltrate the response data.
+
+Every other proxy in the codebase already refuses these shapes. Military-installations was the gap.
+
+## The fix
+
+Two lines in `server/providers/military-installations.js`:
+
+```diff
+ import { makeRateLimiter, clientKey } from './common/rate-limit.js';
++import { admitSameSite } from './common/same-site.js';
+```
+
+```diff
+       if (req.method !== 'GET') {
+         res.writeHead(405, { 'Content-Type': 'application/json' });
+         res.end(JSON.stringify({ error: 'Method Not Allowed' }));
+         return;
+       }
++      if (admitSameSite(req, res)) return;
+       const url = new URL(req.url, 'http://localhost');
+```
+
+Same pattern as terrain.js, cctv.js, traffic.js, google.js, etc. Gate runs before the rate limiter, so refused requests never consume quota.
+
+`scripts/package-boundaries.json` updated to declare `server/providers/common/same-site.js` and `src/localRequestGate.mjs` as owned modules of `military-installations-provider`.
+
+## Tests
+
+New file: `src/militaryInstallationsGate.test.mjs` — 4 integration tests following the `terrainHeightsBounds.test.mjs` pattern:
+
+```
+✔ cross-site browser requests are refused with 403 (2.4ms)
+✔ same-origin browser request is admitted (not 403) (5.3ms)
+✔ bare tool request (no Origin, no Sec-Fetch) is admitted (0.9ms)
+✔ proxied same-origin requests are refused (proxy headers present) (0.5ms)
+```
+
+Tested shapes:
+- `Sec-Fetch-Site: cross-site` (the `<img>` case) → 403
+- `Sec-Fetch-Site: same-site` (cross-origin sibling) → 403
+- `Origin: https://evil.example` (fetch from hostile page) → 403
+- `Origin: null` (sandboxed iframe) → 403
+- `X-Forwarded-For` + `Sec-Fetch-Site: cross-site` (proxied cross-site) → 403
+- Same-origin with matching `Origin` → admitted
+- No `Origin`, no `Sec-Fetch` (curl / Node) → admitted
+- Proxy headers with `same-origin` → 403
+
+All 4 tests fail on `main` and pass with the fix.
+
+## Validation
+
+- `node --test src/localRequestGate.test.mjs src/militaryInstallationsGate.test.mjs`: **18 tests, 18 pass, 0 fail**
+- `npm run check:boundaries`: **pass** (military-installations-provider: 15 owned modules)
+- `npm run check:import-directions`: pass
+- Changelog fragment in `changelog.d/military-installations-cross-site-gate.md`
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index b42d90fdc..4219b311c 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -298,7 +298,9 @@
       "server/providers/overpass/transport.js",
       "src/sources/httpBody.js",
       "src/i18n/marker.js",
-      "src/sources/rateLimit.js"
+      "src/sources/rateLimit.js",
+      "server/providers/common/same-site.js",
+      "src/localRequestGate.mjs"
     ],
     "external": []
   },
diff --git a/server/providers/military-installations.js b/server/providers/military-installations.js
index 7d252b8ed..1b6c82107 100644
--- a/server/providers/military-installations.js
+++ b/server/providers/military-installations.js
@@ -1,4 +1,5 @@
 import { makeRateLimiter, clientKey } from './common/rate-limit.js';
+import { admitSameSite } from './common/same-site.js';
 import {
   MILITARY_INSTALLATION_ELEMENT_CAP,
   MILITARY_INSTALLATION_MAX_RESPONSE_BYTES,
@@ -97,6 +98,7 @@ function militaryInstallationsProxy() {
         res.end(JSON.stringify({ error: 'Method Not Allowed' }));
         return;
       }
+      if (admitSameSite(req, res)) return;
       const url = new URL(req.url, 'http://localhost');
       const requested = validMilitaryInstallationBox(url.searchParams);
       if (!requested) {
diff --git a/src/militaryInstallationsGate.test.mjs b/src/militaryInstallationsGate.test.mjs
new file mode 100644
index 000000000..4451c384b
--- /dev/null
+++ b/src/militaryInstallationsGate.test.mjs
@@ -0,0 +1,147 @@
+// Military-installations cross-site gate — verifies that the admitSameSite
+// gate added in this PR actually refuses the same request shapes the terrain
+// and CCTV proxies already refuse, and admits same-origin and bare-tool
+// requests.
+//
+// Run with: npm test
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { militaryInstallationsProxy } from '../server/providers/military-installations.js';
+
+function install(plugin) {
+  const routes = new Map();
+  plugin.configureServer({
+    middlewares: {
+      use(path, handler) {
+        routes.set(path, handler);
+      },
+    },
+  });
+  return routes;
+}
+
+function request(
+  handler,
+  { url = '/', method = 'GET', remoteAddress = '127.0.0.1', reqHeaders = {} } = {},
+) {
+  return new Promise((resolve, reject) => {
+    const headers = new Map();
+    const req = {
+      method,
+      url,
+      headers: reqHeaders,
+      socket: { remoteAddress },
+    };
+    const res = {
+      statusCode: 200,
+      headersSent: false,
+      setHeader(name, value) {
+        headers.set(String(name).toLowerCase(), String(value));
+      },
+      writeHead(status, hdrs = {}) {
+        this.statusCode = status;
+        this.headersSent = true;
+        for (const [name, value] of Object.entries(hdrs))
+          headers.set(String(name).toLowerCase(), String(value));
+      },
+      end(body = '') {
+        let parsed = null;
+        try {
+          parsed = body ? JSON.parse(String(body)) : null;
+        } catch {
+          parsed = String(body);
+        }
+        resolve({
+          statusCode: this.statusCode,
+          headers: Object.fromEntries(headers),
+          body: parsed,
+        });
+      },
+    };
+    Promise.resolve(handler(req, res)).catch(reject);
+  });
+}
+
+// A valid bbox query string for military-installations.
+const VALID_BBOX = '?south=48.8&west=2.2&north=48.9&east=2.4';
+const HOST = 'localhost:5173';
+
+test('cross-site browser requests are refused with 403', async () => {
+  const route = install(militaryInstallationsProxy()).get(
+    '/api/military-installations',
+  );
+  const refused = [
+    // <img src> from any web page
+    { host: HOST, 'sec-fetch-site': 'cross-site' },
+    // same-site but cross-origin sibling
+    { host: HOST, 'sec-fetch-site': 'same-site' },
+    // fetch from another page
+    { host: HOST, origin: 'https://evil.example' },
+    // sandboxed frame
+    { host: HOST, origin: 'null' },
+    // behind a reverse proxy with cross-site
+    { host: HOST, 'x-forwarded-for': '203.0.113.9', 'sec-fetch-site': 'cross-site' },
+  ];
+  for (const reqHeaders of refused) {
+    const answer = await request(route, { url: VALID_BBOX, reqHeaders });
+    assert.equal(
+      answer.statusCode,
+      403,
+      `expected 403 for headers ${JSON.stringify(reqHeaders)}, got ${answer.statusCode}`,
+    );
+  }
+});
+
+test('same-origin browser request is admitted (not 403)', async () => {
+  const route = install(militaryInstallationsProxy()).get(
+    '/api/military-installations',
+  );
+  // Same-origin with matching origin header
+  const answer = await request(route, {
+    url: VALID_BBOX,
+    reqHeaders: {
+      host: HOST,
+      origin: `http://${HOST}`,
+      'sec-fetch-site': 'same-origin',
+    },
+  });
+  // Should get past the gate — may be 200, 429, or 503 depending on Overpass config,
+  // but never 403.
+  assert.notEqual(answer.statusCode, 403, 'same-origin request should not be refused');
+});
+
+test('bare tool request (no Origin, no Sec-Fetch) is admitted', async () => {
+  const route = install(militaryInstallationsProxy()).get(
+    '/api/military-installations',
+  );
+  // curl / Node harness — no browser headers at all
+  const answer = await request(route, {
+    url: VALID_BBOX,
+    reqHeaders: { host: HOST },
+  });
+  assert.notEqual(answer.statusCode, 403, 'bare tool request should not be refused');
+});
+
+test('proxied same-origin requests are refused (proxy headers present)', async () => {
+  const route = install(militaryInstallationsProxy()).get(
+    '/api/military-installations',
+  );
+  const proxied = [
+    { host: HOST, 'sec-fetch-site': 'same-origin', 'x-forwarded-for': '203.0.113.9' },
+    { host: HOST, 'sec-fetch-site': 'same-origin', 'cf-connecting-ip': '203.0.113.9' },
+    {
+      host: HOST,
+      'sec-fetch-site': 'same-origin',
+      forwarded: 'for=203.0.113.9;proto=https',
+      via: '1.1 caddy',
+    },
+  ];
+  for (const reqHeaders of proxied) {
+    const answer = await request(route, { url: VALID_BBOX, reqHeaders });
+    assert.equal(
+      answer.statusCode,
+      403,
+      `expected 403 for proxied headers ${JSON.stringify(reqHeaders)}, got ${answer.statusCode}`,
+    );
+  }
+});

From 7a1a9cc7064707651921eee7f790bca5bd81fc88 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Tue, 27 Oct 2026 21:57:20 +0530
Subject: [PATCH 11/70] docs(changelog): add #1433 fragment

---
 changelog.d/1433-awareness-marker-kilometre.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1433-awareness-marker-kilometre.md

diff --git a/changelog.d/1433-awareness-marker-kilometre.md b/changelog.d/1433-awareness-marker-kilometre.md
new file mode 100644
index 000000000..86cfbd431
--- /dev/null
+++ b/changelog.d/1433-awareness-marker-kilometre.md
@@ -0,0 +1,3 @@
+- Show a Contacts marker 999.5 m or more away as 1.0 km. The on-globe marker
+  chose metres before rounding, so 999.6 m read "1000 m" while the panel read
+  "1.0 km" (Aditya, @Rohilalala, #1433).

From 5d9264e65f4c4c8d2e527a0e2ad9e1ab1ab4739a Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Tue, 27 Oct 2026 21:57:27 +0530
Subject: [PATCH 12/70] docs(changelog): add #1434 fragment

---
 changelog.d/1434-voice-unknown-altitude.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1434-voice-unknown-altitude.md

diff --git a/changelog.d/1434-voice-unknown-altitude.md b/changelog.d/1434-voice-unknown-altitude.md
new file mode 100644
index 000000000..229d31800
--- /dev/null
+++ b/changelog.d/1434-voice-unknown-altitude.md
@@ -0,0 +1,3 @@
+- Selecting the nearest aircraft by voice no longer says "0 feet" for a contact
+  whose feed reported no altitude; the reply and card leave the altitude out
+  (Aditya, @Rohilalala, #1434).

From ffbb0f9d6512346b0424c64930a9335632a78746 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Tue, 27 Oct 2026 21:57:42 +0530
Subject: [PATCH 13/70] docs(changelog): add #1436 fragment

---
 changelog.d/1436-military-geom-vertical-rate.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1436-military-geom-vertical-rate.md

diff --git a/changelog.d/1436-military-geom-vertical-rate.md b/changelog.d/1436-military-geom-vertical-rate.md
new file mode 100644
index 000000000..ddeb5b4aa
--- /dev/null
+++ b/changelog.d/1436-military-geom-vertical-rate.md
@@ -0,0 +1,3 @@
+- Military aircraft whose transponders report a GNSS vertical rate now carry it
+  in analyst and tracked-aircraft data instead of null (Aditya, @Rohilalala,
+  #1436).

From 3321affaa6351a5771018b21c966b5c22e3ed810 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:02:55 +0530
Subject: [PATCH 14/70] test(voice): check a sea-level altitude is still spoken

---
 src/voice/speech.test.mjs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/voice/speech.test.mjs b/src/voice/speech.test.mjs
index b280b2ebc..345823064 100644
--- a/src/voice/speech.test.mjs
+++ b/src/voice/speech.test.mjs
@@ -229,6 +229,20 @@ test('nearest-aircraft results leave out an altitude the feed did not report', (
   });
   assert.equal(unknown.say, 'Selected RCH123, 8.2 km from Ramstein.');
   assert.deepEqual(unknown.display.lines, ['8.2\u00a0km from Ramstein']);
+
+  // A reported sea-level altitude is still spoken.
+  const seaLevel = envelope('select_nearest_aircraft', {
+    ok: true,
+    location: 'Ramstein',
+    layerId: 'military',
+    feed: { state: 'nominal' },
+    aircraft: { callsign: 'RCH123', altitudeM: 0, distanceKm: 8.2 },
+  });
+  assert.equal(seaLevel.say, 'Selected RCH123, 8.2 km from Ramstein, 0 feet.');
+  assert.deepEqual(seaLevel.display.lines, [
+    '8.2\u00a0km from Ramstein',
+    'Altitude 0 feet',
+  ]);
 });
 
 test('frame_overhead keeps the essential scope audible and lists referents', () => {

From e244703f0812a492a880fd422db40f480b76295c Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:10:57 +0530
Subject: [PATCH 15/70] fix(bikeshare): re-derive a station's missing capacity
 on every poll
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A station whose feed publishes no capacity froze its capacity at the
first status poll's bikes + docks, or at the placeholder 15 when that
poll had no row for it, so later cards read "10 avail · 20 docks · 15
cap" and coloured by the wrong ratio. Each poll now resolves it afresh.
---
 docs/CURRENT-STATE.md                    |  2 +
 src/layers/bikeshare/proxyRoute.test.mjs | 59 ++++++++++++++++++++++++
 src/layers/bikeshare/rendering.js        |  4 +-
 3 files changed, 64 insertions(+), 1 deletion(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index c55031a6a..f91ae76b6 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -1779,6 +1779,8 @@ limit, as well as when a tile decodes or the source resets.
 GBFS null or empty availability counts retain an unknown value through station
 parsing and rendering; they use the neutral station color rather than reporting
 an empty dock. Explicit zero and caller-supplied numeric fallbacks remain valid.
+A station whose `station_information` publishes no capacity takes bikes plus
+docks from each status poll (15 until its status arrives), not from the first.
 
 ## Terrain height cache bound
 
diff --git a/src/layers/bikeshare/proxyRoute.test.mjs b/src/layers/bikeshare/proxyRoute.test.mjs
index e4153a203..718dc5034 100644
--- a/src/layers/bikeshare/proxyRoute.test.mjs
+++ b/src/layers/bikeshare/proxyRoute.test.mjs
@@ -446,3 +446,62 @@ test('unknown GBFS counts stay unknown through the source, model and station col
     assert.equal(model.toNonNegativeInteger('3'), 3);
   }
 });
+
+test('a station without a published capacity re-derives it from every status poll', async () => {
+  const { createRendering } = await import('./rendering.js');
+  const { COLOR_YELLOW } = await import('./policy.js');
+  const model = createModel({});
+  const state = {
+    _cityRuntime: new Map(),
+    _stationRenderMap: new Map(),
+    _pointCollection: { add: (options) => ({ ...options }) },
+  };
+  const rendering = createRendering({
+    state,
+    services: { render: { governorRequestRender() {} } },
+    parts: { model },
+  });
+  const info = model.parseStationInformation({
+    data: {
+      stations: [
+        { station_id: 'open', name: 'Open', lat: 30.26, lon: -97.74 },
+        {
+          station_id: 'fixed',
+          name: 'Fixed',
+          lat: 30.27,
+          lon: -97.75,
+          capacity: 13,
+        },
+      ],
+    },
+  });
+  rendering.ensureCityPoints('austin', info);
+  const poll = (stations) =>
+    rendering.applyStatusToPoints(
+      'austin',
+      model.parseStationStatus({ data: { stations } }),
+    );
+  const open = state._stationRenderMap.get('austin:open');
+  const fixed = state._stationRenderMap.get('austin:fixed');
+
+  // The first poll has no row for the station: capacity is a placeholder.
+  poll([
+    {
+      station_id: 'fixed',
+      num_bikes_available: 4,
+      num_docks_available: 9,
+    },
+  ]);
+  poll([
+    { station_id: 'open', num_bikes_available: 10, num_docks_available: 20 },
+    { station_id: 'fixed', num_bikes_available: 2, num_docks_available: 3 },
+  ]);
+  assert.equal(open.capacity, 30, 'the first poll fixed the capacity');
+  assert.equal(open.point.color, COLOR_YELLOW, '10 of 30 is not plenty');
+  assert.equal(fixed.capacity, 13, 'a published capacity is kept');
+
+  poll([
+    { station_id: 'open', num_bikes_available: 4, num_docks_available: 2 },
+  ]);
+  assert.equal(open.capacity, 6);
+});
diff --git a/src/layers/bikeshare/rendering.js b/src/layers/bikeshare/rendering.js
index f0c737d1d..c75189d4a 100644
--- a/src/layers/bikeshare/rendering.js
+++ b/src/layers/bikeshare/rendering.js
@@ -185,6 +185,7 @@ export function createRendering({
         stationName: station.name,
         point,
         capacity: parts.model.toNonNegativeInteger(station.capacity),
+        publishedCapacity: parts.model.toNonNegativeInteger(station.capacity),
         bikesAvailable: null,
         docksAvailable: null,
         isInstalled: station.isInstalled,
@@ -245,7 +246,8 @@ export function createRendering({
       if (!record) continue;
 
       const status = statusMap.get(record.stationId) || null;
-      const capacity = resolveCapacity(record.capacity, status);
+      // Resolve from the published capacity, not last poll's derived value.
+      const capacity = resolveCapacity(record.publishedCapacity, status);
       record.capacity = capacity;
 
       record.bikesAvailable = parts.model.toNonNegativeInteger(

From f73cd5935b84807a2fa0fe5efe8df0e3bf784eb5 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:13:13 +0530
Subject: [PATCH 16/70] fix(missions): run the full T-10 replay countdown after
 the tile hold

Replay Ascent schedules liftoff 15 s out: a 5 s tile-preparation hold,
then a 10 s countdown. The hold ended 5 s before liftoff instead of 10,
so the replay sat on the pad for 10 s and the countdown began at T-5.
The hold now ends at T-10, and the countdown runs T-10 to T-1.
---
 src/data/rocketLaunches.test.mjs | 12 ++++++++++++
 src/layers/launches/replay.js    |  4 +++-
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/data/rocketLaunches.test.mjs b/src/data/rocketLaunches.test.mjs
index b68a11db3..15b37420d 100644
--- a/src/data/rocketLaunches.test.mjs
+++ b/src/data/rocketLaunches.test.mjs
@@ -448,6 +448,18 @@ test('holds replay at the pad for a real-time countdown independent of replay sp
   assert.ok(liftoff.phaseProgress > 0);
 });
 
+test('runs the five-second tile hold before a full T-10 countdown', () => {
+  const launch = { launchTime: '2026-07-20T10:00:00Z', timeline: [] };
+  // REPLAY ASCENT puts liftoff 5 s (tile hold) + 10 s (countdown) ahead.
+  const hold = replayState(launch, 115000, 12, 28, 5400, 1, 104500, 5);
+  assert.equal(hold.preCountdownActive, true);
+  assert.equal(hold.countdownActive, false);
+  const countdown = replayState(launch, 115000, 12, 28, 5400, 1, 105000, 5);
+  assert.equal(countdown.preCountdownActive, false);
+  assert.equal(countdown.countdownActive, true);
+  assert.equal(countdown.countdownSeconds, 10);
+});
+
 test('hands replay directly from ascent into orbit', () => {
   const launch = { launchTime: '2026-07-20T10:00:00Z', timeline: [] };
   const orbit = replayState(launch, 0, 12, 28, 5400, 1, 16_000);
diff --git a/src/layers/launches/replay.js b/src/layers/launches/replay.js
index 5354996bd..4317de0ab 100644
--- a/src/layers/launches/replay.js
+++ b/src/layers/launches/replay.js
@@ -139,8 +139,10 @@ export function createReplay({ state: layerState, services, parts, source }) {
       0,
       Number(preCountdownDurationSec) || 0,
     );
+    // The hold precedes the whole countdown; ending it at -hold cut T-10 to T-5.
     const preCountdownActive =
-      preCountdownDuration > 0 && realSecondsSinceStart < -preCountdownDuration;
+      preCountdownDuration > 0 &&
+      realSecondsSinceStart < -REPLAY_COUNTDOWN_DURATION_SEC;
     const countdownActive = realSecondsSinceStart < 0 && !preCountdownActive;
     const countdownSeconds = countdownActive
       ? Math.ceil(-realSecondsSinceStart)

From 182e6ceddd8a9731770cc0cbe9376ea2d671b8c5 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:13:15 +0530
Subject: [PATCH 17/70] fix(tools): list a split submarine cable once in
 find_submarine_cables

TeleGeography stores 17 cables (2Africa, Echo, Hawaiki...) as several
features under one id, and the tool made a row per feature, so "Echo"
read "3 submarine cables" and area counts ran high. Rows are now unique
by cable id, and a cable still matches when any of its parts does.
---
 docs/CURRENT-STATE.md             |  3 ++
 src/tools/queries/cables.js       |  6 ++++
 src/tools/queries/cables.test.mjs | 53 +++++++++++++++++++++++++++++++
 3 files changed, 62 insertions(+)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index c55031a6a..34a8ee692 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -179,6 +179,9 @@ catalog, loaded on first use. See [tools and the MCP server](TOOLS.md).
 Aircraft altitude-band queries require a reported barometric or geometric altitude
 for each match, so a grounded contact that reports none is left out of a band too.
 Queries without an altitude band retain unknown-altitude contacts.
+`find_submarine_cables` lists and counts each cable once: TeleGeography splits
+a few cables (2Africa, Echo) into several features under one id, and such a
+cable matches when any of its parts crosses the area.
 
 Catalog calls check their cancellation signal immediately before executing a
 tool. Already-cancelled queries do not start; cancellation after execution starts
diff --git a/src/tools/queries/cables.js b/src/tools/queries/cables.js
index 8d8c0cecf..a4f020150 100644
--- a/src/tools/queries/cables.js
+++ b/src/tools/queries/cables.js
@@ -57,6 +57,7 @@ export const findSubmarineCables = defineTool({
           Number.isFinite(point.lat) &&
           (!area || areaContains(area, point)),
       );
+    const seen = new Set();
     const rows = (cables?.features || [])
       .filter((feature) => {
         const name = String(feature.properties?.name || '');
@@ -71,6 +72,11 @@ export const findSubmarineCables = defineTool({
         id: feature.properties.id ?? null,
         name: feature.properties.name,
       }))
+      // TeleGeography splits some cables into several features under one id.
+      .filter((row) => {
+        const key = row.id ?? row.name;
+        return !seen.has(key) && seen.add(key);
+      })
       .sort((a, b) => a.name.localeCompare(b.name));
     const where = area ? ` in ${area.label}` : '';
     const what = wanted ? ` matching "${args.name}"` : '';
diff --git a/src/tools/queries/cables.test.mjs b/src/tools/queries/cables.test.mjs
index f74457087..37c18fa61 100644
--- a/src/tools/queries/cables.test.mjs
+++ b/src/tools/queries/cables.test.mjs
@@ -89,6 +89,59 @@ test('cables are found by area and name, with landing points and attribution', a
   );
 });
 
+test('a cable split into several features is listed once', async () => {
+  // TeleGeography splits a few cables (2Africa, Echo, Hawaiki) into several
+  // features under one id.
+  const cable = (id, name, coordinates) => ({
+    properties: { id, name },
+    geometry: { type: 'MultiLineString', coordinates: [coordinates] },
+  });
+  const split = {
+    async fetch() {
+      return {
+        cables: {
+          features: [
+            cable('2africa', '2Africa', [
+              [60, 18],
+              [57, 22],
+            ]),
+            cable('equiano', 'Equiano', [
+              [-10, 5],
+              [3, 6],
+            ]),
+            cable('2africa', '2Africa', [
+              [-21, 16],
+              [-17, 14],
+            ]),
+          ],
+        },
+        landingPoints: { features: [] },
+      };
+    },
+  };
+  const catalog = composeCatalog({
+    tools: coreTools,
+    services: { cables: split },
+  });
+  const named = await catalog.call('find_submarine_cables', {
+    name: '2africa',
+  });
+  assert.equal(named.summary, '1 submarine cable matching "2africa".');
+  assert.deepEqual(named.data.rows, [{ id: '2africa', name: '2Africa' }]);
+  const both = await catalog.call('find_submarine_cables', {
+    area: { bbox: [-30, 0, 70, 30] },
+  });
+  assert.deepEqual(
+    both.data.rows.map((row) => row.id),
+    ['2africa', 'equiano'],
+  );
+  // Only the second part crosses this box; the cable is still found.
+  const west = await catalog.call('find_submarine_cables', {
+    area: { bbox: [-25, 10, -10, 20] },
+  });
+  assert.deepEqual(west.data.rows, [{ id: '2africa', name: '2Africa' }]);
+});
+
 test('the local fetch serves bundled data files and nothing outside them', async () => {
   const fetchImpl = createApiFetch({
     apiBase: 'http://127.0.0.1:1',

From 6364817b5b83adf099b370c951cc38170eb18cba Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:16:45 +0530
Subject: [PATCH 18/70] fix(directions): show a 9.96 km route as 10 km, not
 10.0 km

routeDistanceText picked one decimal while the raw kilometres were under
10, then rounded them for display, so 9.95 km or more read "10.0 km".
It now picks the unit from the rounded tenth, as it already does at the
metre/kilometre boundary.
---
 docs/CURRENT-STATE.md          | 4 +++-
 src/data/directions.test.mjs   | 2 ++
 src/layers/directions/index.js | 3 ++-
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index c55031a6a..ce635160b 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4172,7 +4172,9 @@ animate). Disable clears all state.
 
 At the metre/kilometre boundary, route distance labels use the rounded
 ten-metre value to select the unit, switching to kilometres at 995 metres;
-a 996-metre leg displays as `1.0 km` rather than `1000 m`.
+a 996-metre leg displays as `1.0 km` rather than `1000 m`. Whole kilometres
+start where the label would round to 10.0 km, so a 9.96 km route displays as
+`10 km` rather than `10.0 km`.
 
 **Keys needed: none.** Directions works on a keyless boot, and the layer is off
 until the operator turns it on.
diff --git a/src/data/directions.test.mjs b/src/data/directions.test.mjs
index bf6e2878e..a51796edd 100644
--- a/src/data/directions.test.mjs
+++ b/src/data/directions.test.mjs
@@ -849,6 +849,8 @@ test('route numbers follow the page language and never break from their unit', (
   assert.equal(routeDistanceText(994), '990\u00a0m');
   assert.equal(routeDistanceText(996), '1.0\u00a0km');
   assert.equal(routeDistanceText(1500), '1.5\u00a0km');
+  assert.equal(routeDistanceText(9940), '9.9\u00a0km');
+  assert.equal(routeDistanceText(9960), '10\u00a0km');
   assert.equal(routeDistanceText(2_345_000), '2345\u00a0km');
   assert.equal(routeDurationText(39), '39\u00a0s');
   assert.equal(routeDurationText(59.4), '59\u00a0s');
diff --git a/src/layers/directions/index.js b/src/layers/directions/index.js
index b8cceff02..9d0516c28 100644
--- a/src/layers/directions/index.js
+++ b/src/layers/directions/index.js
@@ -115,7 +115,8 @@ export function routeDistanceText(meters) {
   const tens = Math.round(meters / 10) * 10;
   if (tens < 1000) return formatQuantity(tens, 'm');
   const km = meters / 1000;
-  return km < 10
+  // Pick the unit from the tenth it prints: 9.96 km read "10.0 km".
+  return Math.round(meters / 100) < 100
     ? formatQuantity(km, 'km', {
         minimumFractionDigits: 1,
         maximumFractionDigits: 1,

From a2c813280e66f9aec36ea1fa64a8cbc33658a4ea Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:16:54 +0530
Subject: [PATCH 19/70] fix(missions): keep the replay countdown real-time when
 the speed changes

Moving the replay-speed slider during the pre-launch hold or countdown
rescaled the time left to liftoff, so 0.25x turned T-8 into T-32 and 4x
into T-2. The speed change now skips a replay that has not lifted off;
mission time already flown is still preserved as before.
---
 src/layers/launches/replay.js       |  3 +-
 src/layers/launches/replay.test.mjs | 47 +++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+), 1 deletion(-)
 create mode 100644 src/layers/launches/replay.test.mjs

diff --git a/src/layers/launches/replay.js b/src/layers/launches/replay.js
index 5354996bd..affcba339 100644
--- a/src/layers/launches/replay.js
+++ b/src/layers/launches/replay.js
@@ -281,7 +281,8 @@ export function createReplay({ state: layerState, services, parts, source }) {
         ? layerState._replayPausedAtMs
         : Date.now();
     for (const [launchId, startedAt] of layerState._animationStarts) {
-      if (!Number.isFinite(startedAt)) continue;
+      // A countdown runs in real time; rescaling it turned T-8 into T-32 at 0.25x.
+      if (!Number.isFinite(startedAt) || startedAt > now) continue;
       const elapsedMissionMs = (now - startedAt) * previousSpeed;
       layerState._animationStarts.set(
         launchId,
diff --git a/src/layers/launches/replay.test.mjs b/src/layers/launches/replay.test.mjs
new file mode 100644
index 000000000..4ed8e2ede
--- /dev/null
+++ b/src/layers/launches/replay.test.mjs
@@ -0,0 +1,47 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createState } from './state.js';
+import { createReplay } from './replay.js';
+import { createPaths } from './paths.js';
+
+const noop = () => {};
+
+function replayRig() {
+  const state = createState({
+    services: {
+      overlays: {
+        setOverlayEntries: noop,
+        setOverlaySourceVisible: noop,
+        clearOverlaySource: noop,
+      },
+    },
+  });
+  const parts = {};
+  parts.paths = createPaths({ state, parts });
+  return { state, replay: createReplay({ state, parts }) };
+}
+
+test('changing replay speed during the countdown keeps its real-time liftoff', (t) => {
+  t.mock.timers.enable({ apis: ['Date'], now: 1_000_000 });
+  const { state, replay } = replayRig();
+  const launch = { launchTime: '2026-07-20T10:00:00Z', timeline: [] };
+  state._animationStarts.set('countdown', 1_008_000); // T-8
+  state._animationStarts.set('flying', 990_000); // 10 s into the mission
+
+  replay.setReplaySpeed(0.25);
+
+  const startedAt = state._animationStarts.get('countdown');
+  assert.equal(startedAt, 1_008_000);
+  const countdown = replay.replayState(
+    launch,
+    startedAt,
+    12,
+    28,
+    5400,
+    state._replaySpeed,
+    Date.now(),
+  );
+  assert.equal(countdown.countdownSeconds, 8);
+  // Mission time already flown is still preserved across the change.
+  assert.equal(state._animationStarts.get('flying'), 960_000);
+});

From c7377362a5cfb8422e1ff5fa7cad403a445b661b Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:18:30 +0530
Subject: [PATCH 20/70] fix(local-adsb): show a decoder feed's GNSS-sourced
 vertical rate
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

dump1090-fa and readsb file an aircraft's vertical rate under geom_rate
instead of baro_rate when its source is GNSS. The decoder-feed adapter
read only baro_rate, so those aircraft showed "V/S —" on the Local ADS-B
card. It now falls back to geom_rate; a sent baro_rate still wins.
---
 docs/CURRENT-STATE.md            |  4 +++-
 src/sources/adsbRecords.js       |  4 +++-
 src/sources/adsbRecords.test.mjs | 14 ++++++++++++++
 3 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index c55031a6a..1d2825fcd 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -6134,7 +6134,9 @@ Receivers publish one record shape from `src/sources/adsbRecords.js`
 `lastMessageAt`, `messageCount`, `rssiDbfs`, `band`, `source`). `band` is `1090` or `978`; `source` is
 `webusb` (browser SDR) or `feed` (decoder feed).
 `normalizeDump1090Aircraft(json, nowMs, { band })` maps a dump1090/readsb/
-skyaware978 `aircraft.json` document into the same records. Voice
+skyaware978 `aircraft.json` document into the same records; a row without
+`baro_rate` reads its vertical rate from `geom_rate`, where a GNSS-sourced rate
+is sent. Voice
 `set_layer_visibility` accepts `local-adsb` ("local ADS-B", "my receiver",
 "my antenna").
 
diff --git a/src/sources/adsbRecords.js b/src/sources/adsbRecords.js
index 814da60b2..465321902 100644
--- a/src/sources/adsbRecords.js
+++ b/src/sources/adsbRecords.js
@@ -247,7 +247,9 @@ export function normalizeDump1090Aircraft(json, nowMs, { band = '1090' } = {}) {
       altitudeFt: altitude,
       groundSpeedKt: finiteOrNull(entry.gs),
       trackDeg: normalizeTrack(entry.track),
-      verticalRateFpm: finiteOrNull(entry.baro_rate),
+      // A GNSS-sourced rate is sent as geom_rate instead of baro_rate.
+      verticalRateFpm:
+        finiteOrNull(entry.baro_rate) ?? finiteOrNull(entry.geom_rate),
       lastPositionAt: hasPosition
         ? receivedAt - Math.max(0, seenPosS) * 1000
         : null,
diff --git a/src/sources/adsbRecords.test.mjs b/src/sources/adsbRecords.test.mjs
index 12070d47b..aa14133b6 100644
--- a/src/sources/adsbRecords.test.mjs
+++ b/src/sources/adsbRecords.test.mjs
@@ -169,6 +169,20 @@ test('a feed document names its band on every record', () => {
   assert.ok(uat.every((record) => record.source === 'feed'));
 });
 
+test('a decoder feed reads a GNSS-sourced vertical rate when no baro rate is sent', () => {
+  // dump1090-fa and readsb file a velocity message's rate under geom_rate
+  // instead of baro_rate when its source bit says GNSS.
+  const rate = (fields) =>
+    normalizeDump1090Aircraft(
+      { aircraft: [{ hex: 'abc123', seen: 1, ...fields }] },
+      10_000,
+    )[0].verticalRateFpm;
+  assert.equal(rate({ geom_rate: -832 }), -832);
+  assert.equal(rate({ baro_rate: -768, geom_rate: -832 }), -768);
+  assert.equal(rate({ baro_rate: 0, geom_rate: -832 }), 0);
+  assert.equal(rate({}), null);
+});
+
 function heard(overrides = {}) {
   return {
     icao: 'abc123',

From e4a964375a0fa0f50a1cf58166f5a5a27fea3eaf Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:06:47 +0530
Subject: [PATCH 21/70] fix(annotations): label a 996 m line or route as 1.0
 km, not 1000 m

Placed route, arrow and drawn-line labels picked metres before rounding
to ten metres, so anything from 995 m to 1 km read "1000 m", even where
the draw hint for the same line read "1.0 km". The label now rounds
first, then picks the unit, and does the same at the 10 km cut, where
9,960 m read "10.0 km".
---
 docs/CURRENT-STATE.md                     |  2 +-
 src/annotations/annotationEngine.js       |  7 +++++--
 src/annotations/annotationEngine.test.mjs | 15 +++++++++++++++
 3 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index c55031a6a..1b08eb7d9 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5347,7 +5347,7 @@ request viewbox and continues searching without that geographic preference.
 - **A vertex is a lon/lat, and the mark is DRAPED.** Clicks are picked through `pickWorldFromScreen` — one of two scene helpers the annotation resolver factory (`src/annotations/resolver.js`) exposes alongside `sampleGroundHeight`, so the app has ONE depth-aware pick cascade rather than a second written beside it — which returns the height the pick landed on as well as the coordinate, so the live preview hangs on the roof or hillside under the pointer instead of sinking to sea level. The world renderer draws areas and routes with `clampToGround`, so the height is dropped at finish in one place (`finishSpec`) rather than being carried downstream and discarded silently: what you get is the outline you drew, lying on the surface beneath it.
 - **Draped marks classify onto `ClassificationType.BOTH`** — terrain AND 3D tiles — not onto 3D tiles alone. With only `CESIUM_3D_TILE`, every area fill, area outline, route and arrow rendered to nothing on a keyless boot, where Cesium's own globe carries Esri/OSM imagery and there are no tiles to classify against; the labels appeared and the geometry did not. That hit spoken annotations exactly as hard as hand-drawn ones. `scripts/qa-draw-tool.mjs` counts the mark's own colour in the rendered frame before and after a shape is finished, on a keyed AND a keyless server, so "the board says there is a mark" can no longer pass for "the mark is on screen".
 - **A finished area is a CLOSED ring.** The fill polygon closes itself but the outline beside it is a polyline, so an open ring drew every edge except the one back to the first vertex — a triangle with two sides. `finishSpec` repeats the first position at the end. A line is never closed: joining its ends would invent a segment nobody drew.
-- Drawn-line distance labels select metres or kilometres after rounding to the nearest metre, so a 999.5-metre line displays as `1.0 km` rather than `1000 m`.
+- Drawn-line distance labels select metres or kilometres after rounding to the nearest metre, so a 999.5-metre line displays as `1.0 km` rather than `1000 m`. The placed mark's label (shared with spoken routes and arrows) rounds before each unit cut, so a 996-metre line is labelled `1.0 km`, not `1000 m`, and a 9,960-metre one `10 km`, not `10.0 km`.
 - **Measurements and centres are computed on unwrapped longitudes** (`unwrapLongitudes` / `wrapLongitude` in `drawMode.js`, used by `ringAreaM2`, `ringCentroid` and the engine's manual-area anchor). A ~50,000 m² rectangle straddling the antimeridian reads its 0.002° width as 359.998° under raw arithmetic: it measured thousands of square kilometres and anchored on the Greenwich meridian, half a world from the shape. Path length was already safe — haversine is periodic in the longitude delta — and a test pins that so a "fix" cannot break it.
 - **Bounds.** One shape holds at most `MAX_VERTICES` = 512 points; two clicks within 0.5 m are one vertex (that is what makes a double-click finish without leaving a stray point); a vertex that is not a finite on-globe coordinate is refused. A shape that encloses nothing is refused rather than placed: three collinear points are not an area and a line under a metre long is not a line, and the hint says which.
 - Pointer ownership: while a session is open the tool holds the single pointer claim (`claimPointer('draw')`, `src/data/inputOwnership.js`) and **every** ambient scene selection handler — the shared tracking click gesture behind flights, military and CCTV, plus vessels, satellites, launches, fires, installations, bikeshare, radio, submarine cables, the bundled GeoJSON layers and the CCTV calibration gizmo — returns before picking. A vertex over an aircraft is a vertex, not a selection.
diff --git a/src/annotations/annotationEngine.js b/src/annotations/annotationEngine.js
index b0622579d..c867782c7 100644
--- a/src/annotations/annotationEngine.js
+++ b/src/annotations/annotationEngine.js
@@ -1573,8 +1573,11 @@ function greatCircleM(a, b) {
 
 function formatDistance(m) {
   if (!Number.isFinite(m)) return null;
-  if (m >= 1000) return `${(m / 1000).toFixed(m >= 10000 ? 0 : 1)} km`;
-  return `${Math.round(m / 10) * 10} m`;
+  // Round before each unit cut: 996 m was printed as "1000 m" and
+  // 9,960 m as "10.0 km".
+  const tens = Math.round(m / 10) * 10;
+  if (tens < 1000) return `${tens} m`;
+  return `${(m / 1000).toFixed(Math.round(m / 100) >= 100 ? 0 : 1)} km`;
 }
 
 function composeRouteLabel(baseLabel, distM, durS, mode, fallback) {
diff --git a/src/annotations/annotationEngine.test.mjs b/src/annotations/annotationEngine.test.mjs
index 5f39a077a..4f5804290 100644
--- a/src/annotations/annotationEngine.test.mjs
+++ b/src/annotations/annotationEngine.test.mjs
@@ -730,3 +730,18 @@ test('only an explicit navigation request permits resolving distant annotation t
   assert.deepEqual(received.map(options => options.allowDistant), [false, true]);
   engine.destroy();
 });
+
+test('a drawn line that rounds up to the next unit is labelled in it, not as 1000 m or 10.0 km', async (t) => {
+  installAnimationFrameStubs(t);
+  const labels = [];
+  const renderer = { add(anno) { labels.push(anno.label); }, update() {}, remove() {}, sync() {}, destroy() {} };
+  const engine = createAnnotationEngine({ viewer: {}, renderer });
+  const metresPerDegree = (6371.0088 * 1000 * Math.PI) / 180;
+  for (const metres of [994, 996, 9940, 9960]) {
+    await engine.annotate([
+      { type: 'route', manual: true, path: [[0, 0], [0, metres / metresPerDegree]] },
+    ]);
+  }
+  assert.deepEqual(labels, ['990 m', '1.0 km', '9.9 km', '10 km']);
+  engine.destroy();
+});

From c6f437ed527210527c01db85800bbe767f66f375 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:16:02 +0530
Subject: [PATCH 22/70] fix(traffic): stop a few matched roads reading as "no
 matches"

The live flow status derived its wording from the rounded coverage
percent, so 1 matched dot among 300 rounded to 0% and read
"SIMULATED ... (no matches)", and 1 simulated dot among 300 rounded to
100% and dropped "Unmatched: simulated". Coverage now stays within 1-99%
whenever both matched and simulated dots are shown.
---
 docs/CURRENT-STATE.md              |  8 +++++---
 src/layers/traffic/controls.js     | 15 +++++++++++++--
 src/layers/traffic/source.test.mjs | 20 ++++++++++++++++++++
 3 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index c55031a6a..f6e61360f 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5810,9 +5810,11 @@ easier to meet (detection is now on more often), but does not create it.
   OSM choice), so Hybrid fill is never replayed as OSM roads. Failed flow
   refreshes clear old matches and report simulation. `flowCoveragePct` is the
   percentage of shown dots on roads with flow, including all unmatched dots in
-  the denominator and excluding dots hidden by closures. The OSM keyed status
-  reads `LIVE · Roads: OpenStreetMap · Flow: TomTom · N% cov`. Road fetch
-  coverage follows a 5×5 ellipsoid sample of the central screen square.
+  the denominator and excluding dots hidden by closures. It reads 1–99 whenever
+  both matched and simulated dots are shown, so rounding never turns a few
+  matches into `(no matches)` or a few simulated dots into full coverage. The
+  OSM keyed status reads `LIVE · Roads: OpenStreetMap · Flow: TomTom · N% cov`.
+  Road fetch coverage follows a 5×5 ellipsoid sample of the central screen square.
   Horizon rays are capped at 10 km from nadir (reduced if necessary to fit
   16 z12 tiles); polygon-intersecting tiles load nearest first. Up to 16 z14
   tiles provide near detail, with z12 roads beyond them. Cached tiles serve
diff --git a/src/layers/traffic/controls.js b/src/layers/traffic/controls.js
index d33e5a076..1a8eea4d6 100644
--- a/src/layers/traffic/controls.js
+++ b/src/layers/traffic/controls.js
@@ -259,7 +259,8 @@ export function createControls({ state: layerState, services, parts, source }) {
      * `error` carries this instant's health, so a live-configured layer whose
      * flow feed went down reads DEGRADED with the reason instead of a stale
      * LIVE coverage number. `flowCoveragePct` is shown dots on matched roads /
-     * all shown dots (0–100 int), excluding closures; `tilesFetched` counts flow-tile requests
+     * all shown dots (0–100 int, kept within 1–99 while both kinds are shown),
+     * excluding closures; `tilesFetched` counts flow-tile requests
      * issued to the proxy this session (decode-cache hits excluded).
      * @returns {{count:number, lastUpdate:number|null, loading:boolean,
      *   mode:'live'|'sim', error:string|null, flowCoveragePct:number,
@@ -304,8 +305,18 @@ export function createControls({ state: layerState, services, parts, source }) {
         Boolean(layerState._heightPending);
       const { free, slow, jam, sim } = layerState._bucketCounts;
       const matched = free + slow + jam;
+      // The label reads 0 as "no matches" and 100 as nothing simulated, so
+      // rounding must not reach either while both kinds of dot are shown.
       const flowCoveragePct =
-        matched + sim > 0 ? Math.round((100 * matched) / (matched + sim)) : 0;
+        matched + sim > 0
+          ? Math.min(
+              sim > 0 ? 99 : 100,
+              Math.max(
+                matched > 0 ? 1 : 0,
+                Math.round((100 * matched) / (matched + sim)),
+              ),
+            )
+          : 0;
       const feed = parts.model.trafficFeedPresentation({
         liveMode: layerState._liveMode,
         fetching: loading,
diff --git a/src/layers/traffic/source.test.mjs b/src/layers/traffic/source.test.mjs
index 927dc416e..51b24b7df 100644
--- a/src/layers/traffic/source.test.mjs
+++ b/src/layers/traffic/source.test.mjs
@@ -516,6 +516,26 @@ test('late closures hide and stop dots; coverage counts shown matched dots, and
   assert.equal(controls.getStats().flowCoveragePct, 80);
 });
 
+test('coverage never rounds to "no matches" or full coverage while both kinds of dot are shown', async () => {
+  const { state, controls } = await matchingContext(async () => []);
+  state._bucketCounts = { free: 1, slow: 0, jam: 0, sim: 300 };
+  assert.equal(controls.getStats().flowCoveragePct, 1);
+  assert.equal(
+    controls.getStats().loadingLabel,
+    'LIVE · Roads: OpenStreetMap · Flow: TomTom · 1% cov · Unmatched: simulated',
+  );
+  state._bucketCounts = { free: 300, slow: 0, jam: 0, sim: 1 };
+  assert.equal(controls.getStats().flowCoveragePct, 99);
+  assert.equal(
+    controls.getStats().loadingLabel,
+    'LIVE · Roads: OpenStreetMap · Flow: TomTom · 99% cov · Unmatched: simulated',
+  );
+  state._bucketCounts = { free: 300, slow: 0, jam: 0, sim: 0 };
+  assert.equal(controls.getStats().flowCoveragePct, 100);
+  state._bucketCounts = { free: 0, slow: 0, jam: 0, sim: 300 };
+  assert.equal(controls.getStats().flowCoveragePct, 0);
+});
+
 test('refresh failure removes cached matches and reports simulated flow', async () => {
   const { flow, state, model, controls } = await matchingContext(async () => {
     throw new Error('HTTP 429');

From 22b4169a8979a13c90d78151faea1a2c54cd58db Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 16:24:09 +0530
Subject: [PATCH 23/70] docs(changelog): add #1442 fragment

---
 changelog.d/1442-traffic-coverage-edges.md | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 changelog.d/1442-traffic-coverage-edges.md

diff --git a/changelog.d/1442-traffic-coverage-edges.md b/changelog.d/1442-traffic-coverage-edges.md
new file mode 100644
index 000000000..63890cc35
--- /dev/null
+++ b/changelog.d/1442-traffic-coverage-edges.md
@@ -0,0 +1,4 @@
+- Keep Street Traffic's flow status honest at the edges. A few TomTom-matched
+  dots among hundreds rounded to 0% and read "(no matches)", and a few
+  simulated dots rounded to "100% cov"; coverage now stays within 1–99% while
+  both are shown (Aditya, @Rohilalala, #1442).

From df71c37d27cf7027b8f72e33905a3c29da4fb81f Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 16:24:17 +0530
Subject: [PATCH 24/70] docs(changelog): add #1443 fragment

---
 changelog.d/1443-replay-countdown-ten.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1443-replay-countdown-ten.md

diff --git a/changelog.d/1443-replay-countdown-ten.md b/changelog.d/1443-replay-countdown-ten.md
new file mode 100644
index 000000000..4780f26bf
--- /dev/null
+++ b/changelog.d/1443-replay-countdown-ten.md
@@ -0,0 +1,3 @@
+- Run Space Missions' Replay Ascent countdown from T−10 after the five-second
+  tile hold; the hold ran 10 s and the countdown started at T−05 (Aditya,
+  @Rohilalala, #1443).

From 5d2f6a3ce5bffce34466de1d70a5f06a89366f0c Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 16:24:25 +0530
Subject: [PATCH 25/70] docs(changelog): add #1444 fragment

---
 changelog.d/1444-replay-speed-countdown.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1444-replay-speed-countdown.md

diff --git a/changelog.d/1444-replay-speed-countdown.md b/changelog.d/1444-replay-speed-countdown.md
new file mode 100644
index 000000000..fb35d008b
--- /dev/null
+++ b/changelog.d/1444-replay-speed-countdown.md
@@ -0,0 +1,3 @@
+- Keep Space Missions' replay countdown in real time when the replay speed
+  changes before liftoff; 0.25× had stretched T−8 to T−32 (Aditya,
+  @Rohilalala, #1444).

From 81cf79157cff29960d4e5c9174507255eed2c74b Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 16:24:34 +0530
Subject: [PATCH 26/70] docs(changelog): add #1445 fragment

---
 changelog.d/1445-annotation-label-units.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1445-annotation-label-units.md

diff --git a/changelog.d/1445-annotation-label-units.md b/changelog.d/1445-annotation-label-units.md
new file mode 100644
index 000000000..494c663db
--- /dev/null
+++ b/changelog.d/1445-annotation-label-units.md
@@ -0,0 +1,3 @@
+- Label a route, arrow or drawn line of 995 m or more as 1.0 km, and of
+  9,950 m or more as 10 km. The placed label picked the unit before rounding,
+  so it read "1000 m" and "10.0 km" (Aditya, @Rohilalala, #1445).

From f892eaa1742619275a445e93fd52b728ea231113 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 16:24:49 +0530
Subject: [PATCH 27/70] docs(changelog): add #1447 fragment

---
 changelog.d/1447-bikeshare-derived-capacity.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1447-bikeshare-derived-capacity.md

diff --git a/changelog.d/1447-bikeshare-derived-capacity.md b/changelog.d/1447-bikeshare-derived-capacity.md
new file mode 100644
index 000000000..c241b58f7
--- /dev/null
+++ b/changelog.d/1447-bikeshare-derived-capacity.md
@@ -0,0 +1,3 @@
+- Bike Share stations whose feed publishes no capacity now take it from each
+  status poll's bikes and docks instead of keeping the first poll's value or
+  the placeholder 15 (Aditya, @Rohilalala, #1447).

From 58e9f5ab2e5f5a7a1fd0c7174722e3391298b4aa Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 16:24:57 +0530
Subject: [PATCH 28/70] docs(changelog): add #1448 fragment

---
 changelog.d/1448-local-adsb-geom-rate.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1448-local-adsb-geom-rate.md

diff --git a/changelog.d/1448-local-adsb-geom-rate.md b/changelog.d/1448-local-adsb-geom-rate.md
new file mode 100644
index 000000000..276e58f3e
--- /dev/null
+++ b/changelog.d/1448-local-adsb-geom-rate.md
@@ -0,0 +1,3 @@
+- Local ADS-B decoder feeds now carry a GNSS-sourced vertical rate
+  (`geom_rate`) when no barometric rate is sent, so the card shows V/S
+  instead of a dash (Aditya, @Rohilalala, #1448).

From 0e0b82f511f79de85f81c535904fc6b351a1e4ca Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 16:25:05 +0530
Subject: [PATCH 29/70] docs(changelog): add #1449 fragment

---
 changelog.d/1449-cable-tool-duplicates.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1449-cable-tool-duplicates.md

diff --git a/changelog.d/1449-cable-tool-duplicates.md b/changelog.d/1449-cable-tool-duplicates.md
new file mode 100644
index 000000000..e3cc8df96
--- /dev/null
+++ b/changelog.d/1449-cable-tool-duplicates.md
@@ -0,0 +1,3 @@
+- List each submarine cable once in find_submarine_cables. TeleGeography
+  splits 17 cables (2Africa, Echo, Hawaiki) into several features, so a
+  search for Echo read "3 submarine cables" (Aditya, @Rohilalala, #1449).

From 50e06181c6f82780d57a1653335ebd73e46ee657 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 16:25:12 +0530
Subject: [PATCH 30/70] docs(changelog): add #1450 fragment

---
 changelog.d/1450-directions-ten-km.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1450-directions-ten-km.md

diff --git a/changelog.d/1450-directions-ten-km.md b/changelog.d/1450-directions-ten-km.md
new file mode 100644
index 000000000..1b348493e
--- /dev/null
+++ b/changelog.d/1450-directions-ten-km.md
@@ -0,0 +1,3 @@
+- Show a route of 9.95 km or more as 10 km. The Directions row and step
+  cards kept one decimal until the raw distance reached 10 km, so 9.96 km
+  read "10.0 km" (Aditya, @Rohilalala, #1450).

From 46b3864d616d6e73e1112ba70177c2218d61de89 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 17:15:42 +0530
Subject: [PATCH 31/70] fix(satellites): stop matching a mission to a namesake
 from another year

The mission orbit lookup reads each loaded satellite's launch year from its
international designator, but satellite.js never parses that field, so the
year check never ran and a new payload could take an older namesake's orbit
and position. The loaded catalog now keeps the designator from the TLE line.
---
 src/layers/satellites/catalog.js         |  2 ++
 src/layers/satellites/ingestion.js       |  2 ++
 src/layers/satellites/ingestion.test.mjs | 20 ++++++++++++++++++++
 src/layers/satellites/stale.test.mjs     | 14 ++++++++++++++
 4 files changed, 38 insertions(+)

diff --git a/src/layers/satellites/catalog.js b/src/layers/satellites/catalog.js
index 097d9e3be..008b2a19d 100644
--- a/src/layers/satellites/catalog.js
+++ b/src/layers/satellites/catalog.js
@@ -114,6 +114,8 @@ export function createCatalog({ state: layerState, services, parts, source }) {
           const entry = entries[i];
           const satrec = twoline2satrec(entry.line1, entry.line2);
           if (!satrec || satrec.error !== 0) continue;
+          // satellite.js omits the designator the launch-year match reads.
+          satrec.intldesg = entry.line1.slice(9, 17).trim();
           const noradId = noradIdFromSatnum(satrec.satnum);
           if (layerState._catalog.has(noradId)) continue; // core catalog keeps priority
           const pos = parts.orbits.propagatePosition(satrec, now);
diff --git a/src/layers/satellites/ingestion.js b/src/layers/satellites/ingestion.js
index 01653611c..168a5903b 100644
--- a/src/layers/satellites/ingestion.js
+++ b/src/layers/satellites/ingestion.js
@@ -119,6 +119,8 @@ export function createIngestion({
         for (const entry of allEntries) {
           const satrec = twoline2satrec(entry.line1, entry.line2);
           if (!satrec || satrec.error !== 0) continue;
+          // satellite.js omits the designator the launch-year match reads.
+          satrec.intldesg = entry.line1.slice(9, 17).trim();
 
           const noradId = noradIdFromSatnum(satrec.satnum);
           if (seen.has(noradId)) continue;
diff --git a/src/layers/satellites/ingestion.test.mjs b/src/layers/satellites/ingestion.test.mjs
index 313d999ee..7605b318c 100644
--- a/src/layers/satellites/ingestion.test.mjs
+++ b/src/layers/satellites/ingestion.test.mjs
@@ -2,6 +2,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { parseTleText } from '../../sources/tle.js';
 import { createIngestion } from './ingestion.js';
+import { createOrbits } from './orbits.js';
 
 // The ISS set (1 January 2024) with its catalog field swapped per satellite.
 const ISS_LINE1 =
@@ -78,3 +79,22 @@ test('every Alpha-5 satellite keeps its own catalog entry through dedupe', async
   assert.deepEqual([...state._points.keys()], [100000, 110001, 339999]);
   assert.equal(state._count, 3);
 });
+
+test('a mission payload does not match a loaded satellite from another launch year', async (t) => {
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(console, 'warn', () => {});
+  // SXM-11, international designator 2026-148A.
+  const { state, update } = ingestionFor(
+    [
+      'SXM-11',
+      '1 69728U 26148A   26208.65166678  .00000015  00000+0  00000+0 0  9990',
+      '2 69728   0.0784 264.9826 0001797 240.4588 273.9506  1.00271527   440',
+    ].join('\n'),
+  );
+  await update();
+  const { getSatelliteOrbitTrack } = createOrbits({ state });
+  const track = (launchTime) =>
+    getSatelliteOrbitTrack('Sirius SXM-11', { launchTime });
+  assert.equal(track('2026-06-29T02:25:00Z')?.noradId, 69728);
+  assert.equal(track('2030-06-29T02:25:00Z'), null);
+});
diff --git a/src/layers/satellites/stale.test.mjs b/src/layers/satellites/stale.test.mjs
index 89b4d2dbf..9cca23610 100644
--- a/src/layers/satellites/stale.test.mjs
+++ b/src/layers/satellites/stale.test.mjs
@@ -235,6 +235,20 @@ test('dense provenance belongs to its admitted records and clears on removal', a
   );
 });
 
+test('dense extras keep their launch year for mission orbit matching', async (t) => {
+  const f = await fixture(t);
+  await f.update();
+  f.state._params.catalog = 'dense';
+  assert.equal((await f.parts.catalog._loadDenseCatalog()).status, 'ready');
+  // Every fixture set carries the 1998-067A designator.
+  const track = (launchTime) =>
+    f.parts.orbits.getSatelliteOrbitTrack('OWNED ORBIT FIXTURE 25551', {
+      launchTime,
+    });
+  assert.equal(track('1998-11-20T06:40:00Z')?.noradId, 25551);
+  assert.equal(track('2026-06-29T02:25:00Z'), null);
+});
+
 test('cancelling dense replacement preserves admitted stale extras until rebuild', async (t) => {
   const f = await fixture(t);
   await f.update();

From a22f67ab6571afc14be17e30a10f1e1c6ebb116b Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 17:53:47 +0530
Subject: [PATCH 32/70] docs(changelog): add #1453 fragment

---
 changelog.d/1453-satellite-launch-year.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1453-satellite-launch-year.md

diff --git a/changelog.d/1453-satellite-launch-year.md b/changelog.d/1453-satellite-launch-year.md
new file mode 100644
index 000000000..a44745e1f
--- /dev/null
+++ b/changelog.d/1453-satellite-launch-year.md
@@ -0,0 +1,3 @@
+- Space Missions no longer shows an older satellite with a similar name as a
+  new payload's orbit: the launch-year check on loaded satellites now runs
+  (Aditya, @Rohilalala, #1453).

From ac0e124a67ea8cc45435fc0d6b51136656f19b61 Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 18:11:42 +0530
Subject: [PATCH 33/70] =?UTF-8?q?fix(flights):=20read=20a=20359.6=C2=B0=20?=
 =?UTF-8?q?track=20as=200=C2=B0=20in=20the=20voice=20context,=20not=20360?=
 =?UTF-8?q?=C2=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The voice context records for a selected flight or military contact
rounded the track without wrapping, so a contact on 359.5° or more was
described to the assistant as heading "360°". Both now wrap after
rounding: 359.6° reads "0°", 359.4° still reads "359°".
---
 docs/CURRENT-STATE.md                  |  2 +-
 src/layers/flights/ownership.test.mjs  | 22 ++++++++++++++++++++++
 src/layers/flights/tracking.js         |  3 ++-
 src/layers/military/ownership.test.mjs | 25 +++++++++++++++++++++++++
 src/layers/military/tracking.js        |  3 ++-
 5 files changed, 52 insertions(+), 3 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index c55031a6a..7bd48f5e7 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5164,7 +5164,7 @@ and unreachable upstream (502/504) separately from road geometry.
   - Pins: `src/routeCinematics.test.mjs` (26 tests), with `scripts/qa-flyroute-mutations.mjs` reverting each fix individually to prove they are load-bearing (19 named defects); rendered proof `scripts/qa-flyroute-cinema.mjs` (drives the real voice runner, measures the real Cesium camera every frame, writes a labelled contact sheet).
 - **Public control facade** on StyleManager (`setHudVisible/setHudLayout/setDetection/setMapStack/setBloom/setSharpen/setOrbit/setCleanView/getControlState` plus `runImmediateNavigation`): every setter syncs DOM sliders + share links + scene snapshots and returns `{ok, ...state}` — voice confirms only what actually happened. Validated `move_camera`, `fly_route`, `frame_overhead`, strongest-fire focus, and entity tracking use the shared navigation transaction, which refuses Cockpit before mutation, advances authority, releases follow owners, cancels stale work, and only then starts the requested action. All four entity layers expose `findByQuery/getNearby/getAllPositions/trackById|selectById/stopTracking/getTrackedInfo`.
 - **Scene context** (`get_entity_context`): selected entity from the context store, or visible entities ranked by distance to the view target (≤100km altitude); plus basemap context — view-target picking, 7-point viewport sampling, view-scale classification (global/continental/regional/metro/city/local), reverse geocoding (center ≤750km, viewport samples ≤3,000km), Google Places Nearby via `/api/google/nearby-places` (≤25km), known-landmark matching against `CITY_POIS`, coarse country inference fallback. Context assembly is capped at 1.5s with cache fallbacks; caches are deduped in-flight.
-  - **Every selectable layer writes that one slot** (2026-08-21). The tracking layers — flights, military, satellites — publish selection on their own awareness lane (`gev:awareness-subject-selected`, consumed by the readout card and the Contacts panel) and for the life of the voice tools never wrote the shared slot, so `scope:'selected'` silently answered `in_view` with a contact plainly selected on screen. They now call `selectTrackedSubjectContext` / `refreshTrackedSubjectContext` / `clearTrackedSubjectContext` (`src/data/contextStore.js`) on select / poll / deselect. **Invariants: (a)** that write path must NOT dispatch `gev:entity-selected` — tracking layers already own an event lane and a second one makes two surfaces fight over one subject; **(b)** exactly one record per tracking layer, because a frozen snapshot of a moved contact must never reach the visible-entity scan; **(c)** precedence is recency, not layer — one slot, last selection wins, so clicking an overlay entity supersedes a tracked plane as the voice subject while the plane stays tracked. Satellites refresh on the 1 s propagation beat, not per frame.
+  - **Every selectable layer writes that one slot** (2026-08-21). The tracking layers — flights, military, satellites — publish selection on their own awareness lane (`gev:awareness-subject-selected`, consumed by the readout card and the Contacts panel) and for the life of the voice tools never wrote the shared slot, so `scope:'selected'` silently answered `in_view` with a contact plainly selected on screen. They now call `selectTrackedSubjectContext` / `refreshTrackedSubjectContext` / `clearTrackedSubjectContext` (`src/data/contextStore.js`) on select / poll / deselect. **Invariants: (a)** that write path must NOT dispatch `gev:entity-selected` — tracking layers already own an event lane and a second one makes two surfaces fight over one subject; **(b)** exactly one record per tracking layer, because a frozen snapshot of a moved contact must never reach the visible-entity scan; **(c)** precedence is recency, not layer — one slot, last selection wins, so clicking an overlay entity supersedes a tracked plane as the voice subject while the plane stays tracked. Satellites refresh on the 1 s propagation beat, not per frame. The flights and military context records wrap the track after rounding to whole degrees, so a contact on 359.5° or more reads `0°` rather than `360°`.
   - **Context-mode vocabulary is symmetric** (2026-08-21). `set_context_mode` accepts `contacts`; the internal id is `flights`. Every model-readable field (`mode`, `entering`, `priorMode`, nested `context`/`contextRollback`, and the transition diagnostic text) is reported in the accepted vocabulary, with the internal id preserved as `<field>Internal`; an absent secondary mode stays `null` rather than claiming to be `off`. Mapping lives in `src/contextModePolicy.js` so UI text and voice payloads cannot drift. Reporting the internal id made the model read `mode:'flights'` as "Contacts is off" and refuse to answer from the `contactsWindow` counts in the same payload.
   - **Analyst → track handoff carries a key, not just a label** (2026-08-21). `analyst_query` items include `icao24`/`mmsi` alongside the display `id`, and contact lookup uses the shared tiered ranking in `src/data/contactMatch.js`: hex exact → callsign exact → registration exact → callsign prefix → registration prefix → callsign substring → registration substring. The tiers keep an exact callsign ahead of a colliding registration regardless of feed order, and registrations compare separator-insensitively (`G-ABCD`/`GABCD`, `05-8152`/`058152`, `N123AB`/`N-123AB`).
   - **A typed command supersedes the turn it interrupts** (2026-08-21; hardened 2026-10-17). `sendTextCommand` defers its `response.create` behind an active response instead of colliding with it, marks that response superseded so a late function call from it is refused rather than dispatched, and drops the old turn's queued follow-up. A refused call is still ANSWERED — a terminal `{ok:false, superseded:true}` `function_call_output` — because an unanswered `function_call` strands a pending call and deadlocks the model; the refusal creates no response of its own. A burst of typed commands coalesces into one response while keeping both conversation items. If the local channel rejects the user item, that command requests no response and adds no deferred answer; earlier accepted deferred input remains queued. Interruption and pointer preparation still happen before the send attempt.
diff --git a/src/layers/flights/ownership.test.mjs b/src/layers/flights/ownership.test.mjs
index 813df5641..16c1a9cc6 100644
--- a/src/layers/flights/ownership.test.mjs
+++ b/src/layers/flights/ownership.test.mjs
@@ -3,6 +3,7 @@ import assert from 'node:assert/strict';
 import { createCivilFlightLayer } from './index.js';
 import { createFlightState } from './state.js';
 import { createEnrichment } from './enrichment.js';
+import { createTracking } from './tracking.js';
 
 function services() {
   const names = [
@@ -124,3 +125,24 @@ test('a synchronous enrichment failure stays bounded and releases its slot', asy
   await new Promise((done) => setImmediate(done));
   assert.equal(flightState._enrichActive, 0);
 });
+
+test('voice context reads a track that rounds to north as 0°, not 360°', () => {
+  const tracking = createTracking({
+    flightState: {
+      feed: { _lastSource: 'Fixture aircraft' },
+      records: { data: new Map() },
+    },
+    services: services(),
+    parts: {
+      queries: {
+        _describeFlight: () => ({ track: 359.6, altitudeM: 9000 }),
+        _contactLabel: () => 'AAL1',
+      },
+    },
+    layer: {},
+  });
+  assert.equal(
+    tracking._contextSubjectMetadata('abc123').properties.heading,
+    '0°',
+  );
+});
diff --git a/src/layers/flights/tracking.js b/src/layers/flights/tracking.js
index dde8f4f95..dd61e6948 100644
--- a/src/layers/flights/tracking.js
+++ b/src/layers/flights/tracking.js
@@ -125,8 +125,9 @@ export function createTracking({
         speed: Number.isFinite(described.velocityMps)
           ? `${Math.round(described.velocityMps * 1.944)} kt`
           : '',
+        // 359.5° and above rounds to north; modulo keeps it from reading 360°.
         heading: Number.isFinite(described.track)
-          ? `${Math.round(described.track)}°`
+          ? `${Math.round(described.track) % 360}°`
           : '',
         route: route || '',
         icao24,
diff --git a/src/layers/military/ownership.test.mjs b/src/layers/military/ownership.test.mjs
index 41081c137..49aebee76 100644
--- a/src/layers/military/ownership.test.mjs
+++ b/src/layers/military/ownership.test.mjs
@@ -2,6 +2,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { createMilitaryFlightLayer } from './index.js';
 import { createFlightState } from './state.js';
+import { createTracking } from './tracking.js';
 
 function services() {
   const names = [
@@ -211,3 +212,27 @@ test('a newly seen military contact appears at its delayed position, not ahead o
     `expected about ${Math.round(expectedM)} m behind the fix, got ${Math.round(behindM)} m`,
   );
 });
+
+test('voice context reads a track that rounds to north as 0°, not 360°', () => {
+  const stubs = services();
+  stubs.aircraftPresentation = { tr3bTypeLabel: (id, type) => type };
+  const tracking = createTracking({
+    flightState: {
+      feed: { _lastSource: 'Fixture aircraft' },
+      records: { data: new Map() },
+    },
+    services: stubs,
+    parts: {
+      queries: {
+        _describeFlight: () => ({ track: 359.6, callsign: 'RCH123' }),
+        _toCleanText: (value) => value || '',
+        _formatAltitude: () => '',
+      },
+    },
+    layer: {},
+  });
+  assert.equal(
+    tracking._contextSubjectMetadata('ae1234').properties.heading,
+    '0°',
+  );
+});
diff --git a/src/layers/military/tracking.js b/src/layers/military/tracking.js
index 8c9723176..b43a4d88b 100644
--- a/src/layers/military/tracking.js
+++ b/src/layers/military/tracking.js
@@ -119,8 +119,9 @@ export function createTracking({
         speed: Number.isFinite(described.velocityMps)
           ? `${Math.round(described.velocityMps * 1.944)} kt`
           : '',
+        // 359.5° and above rounds to north; modulo keeps it from reading 360°.
         heading: Number.isFinite(described.track)
-          ? `${Math.round(described.track)}°`
+          ? `${Math.round(described.track) % 360}°`
           : '',
         icao24,
         // Honesty cue: the contact is coasting on dead reckoning, so the

From bf5cbe74233b9e986d01099302536442bb8d567d Mon Sep 17 00:00:00 2001
From: Aditya <205600203+Rohilalala@users.noreply.github.com>
Date: Wed, 28 Oct 2026 18:16:40 +0530
Subject: [PATCH 34/70] docs(changelog): add #1454 fragment

---
 changelog.d/1454-voice-context-heading-north.md | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 changelog.d/1454-voice-context-heading-north.md

diff --git a/changelog.d/1454-voice-context-heading-north.md b/changelog.d/1454-voice-context-heading-north.md
new file mode 100644
index 000000000..ee9f3a63a
--- /dev/null
+++ b/changelog.d/1454-voice-context-heading-north.md
@@ -0,0 +1,2 @@
+- Describe a selected flight or military contact on 359.5° or more to the
+  voice assistant as heading 0°, not 360° (Aditya, @Rohilalala, #1454).

From d8358048adafa95930c1be2db9b624627f51e332 Mon Sep 17 00:00:00 2001
From: Denis Groshev <denis@halfpixel.ai>
Date: Wed, 28 Oct 2026 16:07:48 +0100
Subject: [PATCH 35/70] fix(dock): show only icons on the narrow dock wings so
 labels stop covering the voice control

At 900px and narrower the Location and Visual Presets wings shrink to
--dock-side-compact (4.25rem), open or closed, but their text labels kept
their full width. Between 721px and 900px, where the desktop dock is still
shown, LOCATION and VISUAL PRESETS spilled over the idle voice control, and
the LOCATION label took taps on the left half of the mic button. The label
clip that existed was scoped to 620px, which the phone shell (720px) always
covers, so it never applied to a visible dock.

In that band the labels are now font-size 0 and lose their chevrons, so
each wing shows only its icon. The label text is unchanged, so the toggles'
"Expand/Collapse ..." aria-label and title, which panelChrome builds from
it, keep the full name. The Cyber HUD layout sets a wider
--dock-side-compact that fits its labels, so it keeps them. The
unreachable 620px clip is removed.

Found in GEV launch-readiness QA (HAL-728).
---
 docs/CURRENT-STATE.md                | 14 +++++++++++
 src/ui/styles/command-dock-trays.css | 35 ++++++++++++++++++++++------
 2 files changed, 42 insertions(+), 7 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 3e7f333a1..cfa9be32f 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -2665,6 +2665,20 @@ isCurrent })` gates BOTH halves of the map-stack switch, which is its only
 >   name the panel (`#location-bar` / `#control-panel`) to reach (2,5,0). Adding
 >   a new tray rule means checking it against the pinned variants, not just
 >   against the base rule.
+> - **Dock wings are icon-only from 900px down to 721px (2026-10-28):** at
+>   ≤900px `--dock-side-compact` shrinks the Location and Visual Presets wings
+>   to 4.25rem, open or closed (an open tray pops out above the dock), which is
+>   too narrow for their text labels. The labels used to spill over the voice
+>   control, and the LOCATION label captured taps on the left half of the mic
+>   button (HAL-728). `src/ui/styles/command-dock-trays.css` now sets the
+>   labels to `font-size: 0` and drops their `›`/`‹` chevrons in that band, so
+>   each wing shows only its icon. The text node is unchanged, so
+>   `panelChrome.js` still builds the toggles' "Expand/Collapse …" `aria-label`
+>   and `title` from it; the browser tooltip is the only visible name on hover.
+>   The Cyber HUD layout is excluded: it sets `--dock-side-compact` to
+>   9–9.75rem, which fits its labels. The former ≤620px ellipsis clip is gone:
+>   the phone shell takes over at 720px, so it never applied to a visible
+>   dock.
 > - **LOCATION mini-status is data-only today (2026-08-20):** the collapsed
 >   readout now follows a free-text geocode search as well as preset pills
 >   (`src/locationStatus.js` owns the copy for both), and every other camera
diff --git a/src/ui/styles/command-dock-trays.css b/src/ui/styles/command-dock-trays.css
index 547037de7..5575b588a 100644
--- a/src/ui/styles/command-dock-trays.css
+++ b/src/ui/styles/command-dock-trays.css
@@ -502,6 +502,34 @@ body:not(.ui-clean-view):not(.recording-mode):has(
   #command-dock .gev-voice-error-tray {
     width: min(24rem, calc(100vw - 1.5rem));
   }
+
+  /* The wings shrink to --dock-side-compact at this width, open or closed (an
+     open tray pops out above the dock), which is too narrow for the text
+     labels; they would spill over the voice control and take its taps. The
+     wings show only their icon; the toggles keep their aria-label. Cyber sets
+     a wider --dock-side-compact that fits its labels, so it keeps them. */
+  :root:not([data-ui-theme='cyber'])
+    #command-dock
+    :is(#location-bar, #control-panel)
+    .panel-title,
+  :root:not([data-ui-theme='cyber'])
+    #command-dock
+    :is(#location-bar, #control-panel)
+    .location-toolbar-label {
+    font-size: 0;
+    letter-spacing: 0;
+  }
+
+  :root:not([data-ui-theme='cyber'])
+    #command-dock
+    :is(#location-bar, #control-panel)
+    .panel-title::after,
+  :root:not([data-ui-theme='cyber'])
+    #command-dock
+    :is(#location-bar, #control-panel)
+    .location-toolbar-label::after {
+    content: none;
+  }
 }
 
 @media (max-width: 620px) {
@@ -510,13 +538,6 @@ body:not(.ui-clean-view):not(.recording-mode):has(
     --dock-voice-width: 8.75rem;
   }
 
-  #command-dock .panel-title,
-  #command-dock .location-toolbar-label {
-    max-width: 2.3rem;
-    overflow: hidden;
-    text-overflow: ellipsis;
-  }
-
   #left-panel-stack {
     bottom: calc(50vh + 8px);
   }

From ce10a46b7f1780fcdeadfaf5f47396ce79065393 Mon Sep 17 00:00:00 2001
From: Denis Groshev <denis@halfpixel.ai>
Date: Wed, 28 Oct 2026 20:22:01 +0100
Subject: [PATCH 36/70] docs(changelog): add the dock icon-only wings entry

---
 changelog.d/1457-dock-icon-only-wings.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 changelog.d/1457-dock-icon-only-wings.md

diff --git a/changelog.d/1457-dock-icon-only-wings.md b/changelog.d/1457-dock-icon-only-wings.md
new file mode 100644
index 000000000..21825669b
--- /dev/null
+++ b/changelog.d/1457-dock-icon-only-wings.md
@@ -0,0 +1,5 @@
+- Between 721px and 900px wide (tablet portrait, phone landscape), the
+  Location and Visual Presets dock wings show only their icons, so their
+  labels no longer spill over the voice control or take taps meant for the
+  mic button. The full name stays in the tooltip and accessible name, and the
+  Cyber layout keeps its labels (ZloyS, #1457).

From 2a335a8f3560ab16bc4fe5cd4956939def32ad46 Mon Sep 17 00:00:00 2001
From: Luis Ortiz <2839770+anobjectn@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:34:04 -0400
Subject: [PATCH 37/70] fix(deps): pin Node 24.22.1 for the October 21, 2026
 security release

Node.js 24.14.0 carries CVE-2026-111497 ("Node2Shell"), an out-of-bounds
write in the bundled Brotli decoder that can lead to remote code
execution, plus several high-severity DNS, TLS and URL-parsing fixes.
24.22.1 is the first patched 24.x release.

- Dockerfile: node:24.22.1-slim, digest re-pinned to the multi-arch index
- CI: 24.22.1 in the verify matrix and the other two jobs; the
  allocation-gate requirement now keys on 24.22.1
- Docs: contributor setup and the dependency baseline name 24.22.1

The engines floor and the setup doctor are unchanged.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .github/workflows/ci.yml | 8 ++++----
 CONTRIBUTING.md          | 8 +++++---
 Dockerfile               | 2 +-
 README.md                | 5 +++--
 docs/CURRENT-STATE.md    | 4 +++-
 5 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ce3563685..766f0cc51 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,10 +20,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node: [24.14.0, 26.x]
+        node: [24.22.1, 26.x]
     env:
       PUPPETEER_SKIP_DOWNLOAD: '1'
-      GEV_REQUIRE_ALLOCATION_GATE: ${{ matrix.node == '24.14.0' && '1' || '0' }}
+      GEV_REQUIRE_ALLOCATION_GATE: ${{ matrix.node == '24.22.1' && '1' || '0' }}
     steps:
       - name: Check out source
         uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
@@ -76,7 +76,7 @@ jobs:
       - name: Use Node.js
         uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
-          node-version: 24.14.0
+          node-version: 24.22.1
           cache: npm
 
       - name: Install locked dependencies and headless Chrome
@@ -131,7 +131,7 @@ jobs:
       - name: Use Node.js
         uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
-          node-version: 24.14.0
+          node-version: 24.22.1
           cache: npm
 
       - name: Run the Pinokio install path
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a7fe8ab76..591cdd85d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,13 +4,15 @@ Thanks for being here. God's Eye View is an open foundation for live spatial int
 
 ## Getting set up
 
-Use Node.js 24.14.x or 26.x (also enforced by `package.json`).
+Use Node.js 24.14.x or 26.x (also enforced by `package.json`). Prefer 24.22.1 or
+later: earlier releases lack the October 21, 2026 security fixes, including
+CVE-2026-111497 (a Brotli decoder flaw that can lead to remote code execution).
 
 ```bash
 git clone https://github.com/bilawalsidhu/gods-eye-view.git
 cd gods-eye-view
-nvm install 24.14.0
-nvm use 24.14.0
+nvm install 24.22.1
+nvm use 24.22.1
 npm install
 npm run doctor
 ./scripts/dev-fresh.sh        # or: npm run dev (keys are optional)
diff --git a/Dockerfile b/Dockerfile
index 433d170a8..e711ec1d9 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -4,7 +4,7 @@
 # proxies (ADS-B, AIS, Overpass, OpenAI Realtime, ...) as middleware, so there
 # is nothing else to containerise. See compose.yaml for the usual entry point.
 # Same Node as CI (package.json engines, .github/workflows), pinned by digest.
-FROM node:24.14.0-slim@sha256:d8e448a56fc63242f70026718378bd4b00f8c82e78d20eefb199224a4d8e33d8
+FROM node:24.22.1-slim@sha256:be8204d4bd327363357f532187b752ff62759c31bedf98e9e18fc08c9cbd605c
 
 # Puppeteer is only used by the QA scripts; skip its ~150MB Chromium download.
 ENV PUPPETEER_SKIP_DOWNLOAD=1
diff --git a/README.md b/README.md
index 0a7509efa..ee9c7819a 100644
--- a/README.md
+++ b/README.md
@@ -129,8 +129,9 @@ hardware; it does not establish a minimum GPU requirement.
 
 ### Path 2 — Terminal / coding agent
 
-Use **Node.js 24.x (24.14.0 or later) or 26.x**. The setup doctor warns about
-Node 25, which is end-of-life.
+Use **Node.js 24.x (24.14.0 or later) or 26.x**; 24.22.1 or later (26.12.1 or
+later on 26) includes the October 21, 2026 security fixes, among them
+CVE-2026-111497. The setup doctor warns about Node 25, which is end-of-life.
 
 ```bash
 git clone https://github.com/bilawalsidhu/gods-eye-view.git
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 3e7f333a1..098bd3e83 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -6024,7 +6024,9 @@ The lockfile uses DOMPurify 3.4.17, protobufjs 8.8.0, PostCSS 8.5.28,
 source-map-js 1.2.2 and nanoid 3.3.19. Cesium remains on 1.138.0. Browser QA
 uses Puppeteer 25.10.0; image-processing tools use Sharp 0.35.5. QA scripts await Puppeteer's asynchronous
 executable-path lookup before testing or passing the path to Chrome. Supported Node versions remain
-24.14.x and 26.x. Use `npm ci` to reproduce the checked-in dependency tree.
+24.14.x and 26.x; the Docker image and CI pin 24.22.1, the first 24.x release with
+the October 21, 2026 Node.js security fixes (including CVE-2026-111497). Use
+`npm ci` to reproduce the checked-in dependency tree.
 
 ### Traffic city navigation
 

From 17d0877a4cedf1b44b9ce8f0927654ef5436390d Mon Sep 17 00:00:00 2001
From: Luis Ortiz <2839770+anobjectn@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:35:06 -0400
Subject: [PATCH 38/70] docs(changelog): add the #1458 fragment

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 changelog.d/1458-node-24-22-1-security-release.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1458-node-24-22-1-security-release.md

diff --git a/changelog.d/1458-node-24-22-1-security-release.md b/changelog.d/1458-node-24-22-1-security-release.md
new file mode 100644
index 000000000..a440892a8
--- /dev/null
+++ b/changelog.d/1458-node-24-22-1-security-release.md
@@ -0,0 +1,3 @@
+- The Docker image and CI now pin Node 24.22.1, the first 24.x release with
+  the October 21, 2026 security fixes, including CVE-2026-111497 (a Brotli
+  decoder flaw that can lead to remote code execution) (anobjectn, #1458).

From 45ae1095da5eba3e9eae3b668645ee33d42bf607 Mon Sep 17 00:00:00 2001
From: quanticsoul4772 <71096528+quanticsoul4772@users.noreply.github.com>
Date: Wed, 28 Oct 2026 20:11:55 -0700
Subject: [PATCH 39/70] fix(voice): leave aliases a layer id already spells out
 of the alias hint

The set_layer_visibility layerId hint listed aliases such as "dams" for
local-dams and "weather radar" for weather-radar, which the id in the
enum already says. Leaving those out, and a layer with no other alias,
cuts the Realtime prompt from 52,000 to 51,695 characters. Aliases the id
does not spell (aqhi, hurricanes, clouds) stay, and the runner still
accepts every alias. Refs #1363.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/firstRunExperience.test.mjs  |  5 +++--
 src/voice/actionSchemas.test.mjs |  3 ++-
 src/voice/layerManifest.js       | 19 +++++++++++++++----
 src/voice/layerManifest.test.mjs | 18 ++++++++++++++++++
 4 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/src/firstRunExperience.test.mjs b/src/firstRunExperience.test.mjs
index d76a48458..9ba474dd3 100644
--- a/src/firstRunExperience.test.mjs
+++ b/src/firstRunExperience.test.mjs
@@ -1055,10 +1055,11 @@ test('the voice TOOL SCHEMA matches the pinned contract — the mission mapping
   // Panel adds timeout and named voice/provider targets; consolidated guidance
   // preserves the mission mapping and globe-rotation arguments.
   // S2 GhostMaps extends the generated layer enums; both feature contracts remain.
-  assert.equal(block.length, 31206, 'serialized tool schema length drifted');
+  // The layer alias hint leaves out aliases the layer id already spells.
+  assert.equal(block.length, 30901, 'serialized tool schema length drifted');
   assert.equal(
     crypto.createHash('sha256').update(block).digest('hex'),
-    'f772df95404494bf492e02fde1beabffdfe61986940bffd0cf9ad5a38d768746',
+    '9e1bd8fde648953c47718ba248758415a95c1484b0da6369df6b89b0505c0de2',
     'the first-run missions must ride EXISTING tools: no schema edit, no cache bust',
   );
   const instructions = fs.readFileSync(
diff --git a/src/voice/actionSchemas.test.mjs b/src/voice/actionSchemas.test.mjs
index 97e5004b5..320704d3c 100644
--- a/src/voice/actionSchemas.test.mjs
+++ b/src/voice/actionSchemas.test.mjs
@@ -45,7 +45,8 @@ test('the complete Realtime tool payload pins the manifest-generated layer relea
     // S2 GhostMaps extends the generated layer enums.
     // Panel adds named voice targets and timeout; shared Panel/Cockpit guidance
     // is consolidated without changing either feature's arguments.
-    '9ee82c4214499280c208c93751b19d7b724c81b7727a2d0c6dab0184749fbe15',
+    // The layer alias hint leaves out aliases the layer id already spells.
+    '188e9eaaee1d5c21fc88493ba244569f4af9cfba61bb240c52ecd32b49b18caa',
   );
 });
 
diff --git a/src/voice/layerManifest.js b/src/voice/layerManifest.js
index 267399e58..faa7207d0 100644
--- a/src/voice/layerManifest.js
+++ b/src/voice/layerManifest.js
@@ -529,18 +529,29 @@ const SELF_EVIDENT_IDS = new Set([
   's2-ghostmaps',
 ]);
 
+/** Lower case with spaces and hyphens removed: "Data centers" → "datacenters". */
+const spelled = (text) => text.toLowerCase().replace(/[\s-]+/g, '');
+
 /**
  * Compact model-facing alias hint: "alias/alias→id; …" for toggleable layers
  * whose id is not already the spoken word. At most two aliases per layer keep
- * the tool JSON small; the runner accepts the full alias list.
+ * the tool JSON small; the runner accepts the full alias list. An alias the id
+ * already spells ("dams"→local-dams, "weather radar"→weather-radar) is left
+ * out, and so is a layer with no other alias.
  * @returns {string} One line for the layerId description.
  */
 export function voiceLayerAliasHint() {
   return VOICE_LAYER_MANIFEST.filter(
-    (entry) =>
-      entry.toggle && entry.aliases.length && !SELF_EVIDENT_IDS.has(entry.id),
+    (entry) => entry.toggle && !SELF_EVIDENT_IDS.has(entry.id),
   )
-    .map((entry) => `${entry.aliases.slice(0, 2).join('/')}→${entry.id}`)
+    .map((entry) => ({
+      id: entry.id,
+      aliases: entry.aliases
+        .slice(0, 2)
+        .filter((alias) => !spelled(entry.id).includes(spelled(alias))),
+    }))
+    .filter((entry) => entry.aliases.length)
+    .map((entry) => `${entry.aliases.join('/')}→${entry.id}`)
     .join(';');
 }
 
diff --git a/src/voice/layerManifest.test.mjs b/src/voice/layerManifest.test.mjs
index d0222b934..ab382c460 100644
--- a/src/voice/layerManifest.test.mjs
+++ b/src/voice/layerManifest.test.mjs
@@ -9,6 +9,7 @@ import {
   VOICE_TOGGLE_LAYER_IDS,
   VOICE_CONTEXT_LAYER_IDS,
   VOICE_QUERY_LAYER_IDS,
+  voiceLayerAliasHint,
   voiceLayerAliasMap,
 } from './layerManifest.js';
 
@@ -78,6 +79,23 @@ test('tool enums are generated from the manifest', () => {
   assert.ok(panels.includes('weather-panel') && panels.includes('recent-imagery-panel'));
 });
 
+test('the alias hint leaves out names the layer id already spells', () => {
+  const hint = voiceLayerAliasHint();
+  const entries = hint.split(';').map((entry) => entry.split('→'));
+  const flat = (text) => text.toLowerCase().replace(/[\s-]+/g, '');
+  for (const [aliases, id] of entries) {
+    for (const alias of aliases.split('/')) {
+      assert.ok(!flat(id).includes(flat(alias)), `"${alias}" is already spelled by ${id}`);
+    }
+  }
+  const ids = entries.map(([, id]) => id);
+  assert.ok(!ids.includes('local-dams'), 'a layer left with no alias gets no entry');
+  assert.ok(!ids.includes('weather-radar'));
+  assert.match(hint, /(^|;)aqhi→air-quality(;|$)/, 'an alias the id does not spell stays');
+  assert.match(hint, /(^|;)hurricanes→weather-cyclones(;|$)/);
+  assert.match(hint, /(^|;)fires\/wildfires→local-firms(;|$)/);
+});
+
 test('spoken aliases resolve to real layers, keep every legacy phrase and never collide', () => {
   const aliases = voiceLayerAliasMap();
   for (const id of aliases.values()) assert.ok(manifestIds.includes(id), id);

From f976ecf9e6247433428f707d1f25e23bae9410f9 Mon Sep 17 00:00:00 2001
From: quanticsoul4772 <71096528+quanticsoul4772@users.noreply.github.com>
Date: Thu, 29 Oct 2026 00:37:43 -0700
Subject: [PATCH 40/70] docs(changelog): add the voice alias hint entry

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 changelog.d/1462-voice-alias-hint-budget.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 changelog.d/1462-voice-alias-hint-budget.md

diff --git a/changelog.d/1462-voice-alias-hint-budget.md b/changelog.d/1462-voice-alias-hint-budget.md
new file mode 100644
index 000000000..64cf56100
--- /dev/null
+++ b/changelog.d/1462-voice-alias-hint-budget.md
@@ -0,0 +1,5 @@
+- Leave layer aliases the layer id already spells, such as "dams" for
+  `local-dams`, out of the voice layer hint. The Realtime prompt drops from
+  52,000 to 51,695 characters, leaving room under the 52,000 gate for new
+  voice-toggleable layers; every alias is still accepted (quanticsoul4772,
+  #1462).

From 08dd88b2ce9a0380057ed3cf6e8c6ed7da2e972a Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Thu, 29 Oct 2026 11:12:46 +0000
Subject: [PATCH 41/70] Gather Directions, Draw and Import in a Utilities panel

UTILITIES becomes its own panel in the left column, after Data Layers and
CCTV and above Scenes. The layer panel renders the Directions row into the
panel's list instead of Data Layers, and Draw and Import move there from
DISPLAY with their ids unchanged. Radio, the other row under the old
Utilities heading, stays in Data Layers under "Audio".

The panel collapses and remembers its state like the other left panels; share
links do not carry it. It hides in clean view, recording and Cockpit, takes
the Cyber left-rail treatment, and sits collapsed in the phone's Layers sheet.
Voice focuses the Directions row in its new list. The Directions, Draw,
Import and form-field gates open UTILITIES to reach their controls.
---
 docs/CURRENT-STATE.md                  | 20 +++++-
 scripts/qa-directions.mjs              | 22 +++---
 scripts/qa-draw-tool.mjs               | 18 +++--
 scripts/qa-form-fields.mjs             | 21 +++++-
 scripts/qa-geo-import.mjs              |  8 ++-
 src/annotations/drawTool.test.mjs      | 10 +--
 src/i18n/locales/es.json               |  2 +
 src/i18n/locales/ru.json               |  2 +
 src/i18n/locales/zh-CN.json            |  2 +
 src/i18n/locales/zh-Hant.json          |  2 +
 src/i18n/same-as-english.json          |  1 +
 src/ui/cyberTheme.test.mjs             | 21 ++++--
 src/ui/geoFileImport.test.mjs          |  4 +-
 src/ui/layerPanel.js                   | 48 ++++++++++---
 src/ui/panelChrome.js                  |  1 +
 src/ui/styles/cockpit.css              |  1 +
 src/ui/styles/controls.css             |  1 +
 src/ui/styles/cyber.css                | 12 ++--
 src/ui/styles/layers.css               | 98 ++++++++++++++++++++++++++
 src/ui/styles/mobile-shell.css         |  3 +
 src/ui/styles/recording.css            |  1 +
 src/ui/styles/responsive.css           |  2 +
 src/ui/styles/scenes.css               | 18 ++++-
 src/ui/templates/display-controls.html | 35 ---------
 src/ui/templates/layer-panels.html     | 50 +++++++++++++
 src/voice/gevActions.js                |  3 +-
 26 files changed, 319 insertions(+), 87 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 146e157d8..0c3221945 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -131,6 +131,20 @@ provider registration rejects compositions that cannot fit rather than truncatin
 identities. A malformed or duplicate entry invalidates the complete custom-switch
 field. Existing whole-link size limits still apply.
 
+## Utilities panel — October 29, 2026
+
+UTILITIES is its own panel in the left column, after Data Layers and CCTV and
+above Scenes (`#utilities-panel` in `src/ui/templates/layer-panels.html`). It
+holds the Directions layer row, which `LayerPanel` renders into
+`#utilities-toggles` instead of the Data Layers list, and Draw and Import,
+which moved there from DISPLAY with their ids unchanged. Radio, formerly the
+other row under the Data Layers "Utilities" heading, stays in Data Layers under
+"Audio". The panel collapses and remembers its state like the other left
+panels; share links do not carry it. It hides in clean view, recording and
+Cockpit, and on a phone it sits collapsed in the Layers sheet under Data
+Layers. The Directions, Draw and Import QA gates open it to reach their
+controls.
+
 ## God's Eye View in conversations — October 2, 2026
 
 Tool answers that can be shown in God's Eye View include a view: camera, layers,
@@ -284,7 +298,7 @@ settings from active map/contact effects. Sonar settings are session-only and
 return to their defaults on reload. Sliders accept integer values matching the
 action's ranges.
 
-Wind appears in the Weather group before Utilities. The surface-weather prototype
+Wind appears in the Weather group before Audio. The surface-weather prototype
 uses keyless NOAA GFS or ECMWF IFS forecasts on an approximately 1° display grid.
 It defaults to 10 m wind trails over the existing basemap. Speed shading is an explicit choice; earlier v2 links retain their original speed-shading meaning.
 Weather rows contain only the toggle and source/meta line. Configuration lives
@@ -5396,7 +5410,7 @@ request viewbox and continues searching without that geographic preference.
 
 ### Manual Whiteboard Drawing (September 2026)
 
-- DISPLAY ▸ **Draw** turns the globe into a whiteboard drawn by hand. Pick a shape (Area, Line, Pin), click the vertices on the real world, type an optional label and pick a colour, and finish. **Keyboard contract, live only while Draw is on and never while you are typing in another field:** Enter finishes the shape (as does a double-click, and the two cannot both submit it — the session is replaced before the annotate call is awaited); Backspace removes the last vertex; Esc cancels the shape in progress, and a second Esc — Esc on an empty session — leaves draw mode. Typing in the label field keeps Backspace; Enter there also finishes. **Clear** wipes the board (the shape in progress and every placed mark), so removing marks does not require the console or the microphone.
+- UTILITIES ▸ **Draw** turns the globe into a whiteboard drawn by hand. Pick a shape (Area, Line, Pin), click the vertices on the real world, type an optional label and pick a colour, and finish. **Keyboard contract, live only while Draw is on and never while you are typing in another field:** Enter finishes the shape (as does a double-click, and the two cannot both submit it — the session is replaced before the annotate call is awaited); Backspace removes the last vertex; Esc cancels the shape in progress, and a second Esc — Esc on an empty session — leaves draw mode. Typing in the label field keeps Backspace; Enter there also finishes. **Clear** wipes the board (the shape in progress and every placed mark), so removing marks does not require the console or the microphone.
 - Runtime entry: `createApplicationTools` (`src/app/tools.js`, behind the `src/standalone/tools.js` shim) calls `initDrawTool({ viewer, annotations })` after `initAnnotations` and defers its `destroy()`, so disposing the shell returns every DOM listener, the Cesium handler, the preview data source, the borrowed click actions and the `window.__gevDrawTool` handle. Its markup is a DISPLAY-rail component template (`src/ui/templates/display-controls.html`), assembled into `index.html` at build time. That handle (`setActive`, `setShape`, `addVertex(lon, lat)`, `finish`, `cancel`, `clearAll`, `diagnostics`) is the no-mouse test seam.
 - Contract: a finished shape is submitted through the SAME `annotationEngine.annotate()` the voice agent uses, with geometry supplied and `manual: true` (`type: area` + `ring`, `type: route` + `path`, `type: pin` + coordinates). `resolveSpec` short-circuits manual specs (`resolveManualSpec`) so no geocoder, Places or Overpass call is made. A drawn area is a real (not synthesized) outline and drapes solid; a drawn line is a `route` with `mode: 'manual'`, labelled with its length and never a travel time; a pin is a point. Drawn marks therefore render with the whiteboard look, persist, de-dup, appear in `.list()`, and clear with `clear_annotations` / `.clear()`.
 - **A vertex is a lon/lat, and the mark is DRAPED.** Clicks are picked through `pickWorldFromScreen` — one of two scene helpers the annotation resolver factory (`src/annotations/resolver.js`) exposes alongside `sampleGroundHeight`, so the app has ONE depth-aware pick cascade rather than a second written beside it — which returns the height the pick landed on as well as the coordinate, so the live preview hangs on the roof or hillside under the pointer instead of sinking to sea level. The world renderer draws areas and routes with `clampToGround`, so the height is dropped at finish in one place (`finishSpec`) rather than being carried downstream and discarded silently: what you get is the outline you drew, lying on the surface beneath it.
@@ -5436,7 +5450,7 @@ request viewbox and continues searching without that geographic preference.
 
 ### Import Your Own Files (October 2026)
 
-- DISPLAY ▸ **Import** reads GeoJSON (`.geojson`/`.json`), KML, KMZ and GPX from the picker or a file drop anywhere in the app. Each file gets show/hide, Fly-to and Remove controls. GeoJSON and GPX use the row's color; KML/KMZ retain their styles and show a hatched swatch. The file bytes remain on the device for the page session. Rendered overlays can appear in map screenshots sent through voice or other existing screenshot tools.
+- UTILITIES ▸ **Import** reads GeoJSON (`.geojson`/`.json`), KML, KMZ and GPX from the picker or a file drop anywhere in the app. Each file gets show/hide, Fly-to and Remove controls. GeoJSON and GPX use the row's color; KML/KMZ retain their styles and show a hatched swatch. The file bytes remain on the device for the page session. Rendered overlays can appear in map screenshots sent through voice or other existing screenshot tools.
 - **Ground and height.** GeoJSON XYZ coordinates become ground footprints. KML ground lines/rings are tessellated; static recorded tracks preserve their original vertices, segment gaps and explicit altitude modes. KML with absolute/relative altitude keeps that meaning. Ground pins resolve in batches of 256 against loaded terrain and, in the nearby camera footprint on photoreal maps, `clampToHeightMostDetailed`, then draw in one owned native BillboardCollection per file, with static positions and no per-frame point Entity visualizer or clamping callbacks. Point metadata remains in `dataSource.importedEntities` for framing/style inspection; non-point geometry stays in the normal source collection. Pin collections mount only after source admission, follow file show/hide, and are destroyed on removal. Settled camera/map-source changes and completed terrain loads refresh visible files through the same serial queue; distant points retain their latest available height. No detailed worldwide terrain sweep is started. Nearby mesh sampling can add requests/time; configured photoreal providers require separate validation. The depth test is disabled for ground pins, matching Draw's marker visibility policy.
 - **Navigation.** Row Fly-to uses `runImmediateNavigation('file', …)`; Cockpit can refuse it and existing follow/track ownership is released first. Automatic Fly-to is stamped when a batch is submitted and reasserted before flying. Pointer/wheel gestures and newer navigation supersede it, including time spent in the queue. Framing uses every finite visible point/path/polygon-hole/wall vertex plus rotated overlay bounds, with viewport-aware range and a nadir view. The target uses available terrain/cached ground height and the ground guard on arrival. Empty footprints never fall back to deferred `viewer.flyTo`.
 - **Clock.** Imports expose no source clock and no entity availability. KML times/view metadata are removed before loading; recorded tracks become static lines. GPX segments remain separate and GPX times are ignored. The shared clock stays unchanged.
diff --git a/scripts/qa-directions.mjs b/scripts/qa-directions.mjs
index ca271026f..9fb8b9802 100644
--- a/scripts/qa-directions.mjs
+++ b/scripts/qa-directions.mjs
@@ -107,7 +107,7 @@ const layerState = () =>
     const manager = gev.dataManager;
     const module = manager.layers.get('directions').module;
     const row = document.querySelector(
-      '#data-toggles [data-layer-id="directions"]',
+      '#utilities-toggles [data-layer-id="directions"]',
     );
     const controls = module.getRowControls();
     const viewer = gev.viewer;
@@ -152,7 +152,7 @@ const layerState = () =>
 const clickChip = async (chipId) => {
   const clicked = await page.evaluate((id) => {
     const row = document.querySelector(
-      '#data-toggles [data-layer-id="directions"]',
+      '#utilities-toggles [data-layer-id="directions"]',
     );
     const button = row?.querySelector(`button[data-chip-id="${id}"]`);
     if (!button || button.disabled) return false;
@@ -232,24 +232,26 @@ try {
   });
   await sleep(3000);
 
-  // ── 1. Open the DATA LAYERS panel, then toggle the row on. ──────────────
+  // ── 1. Open the UTILITIES panel, then toggle the row on. ────────────────
   const opened = await page.evaluate(() => {
-    const panel = document.getElementById('data-panel');
+    const panel = document.getElementById('utilities-panel');
     if (!panel) return false;
     if (panel.classList.contains('collapsed')) {
       panel
-        .querySelector('.panel-collapse-btn[data-collapse-target="data-panel"]')
+        .querySelector(
+          '.panel-collapse-btn[data-collapse-target="utilities-panel"]',
+        )
         ?.click();
     }
     return !document
-      .getElementById('data-panel')
+      .getElementById('utilities-panel')
       .classList.contains('collapsed');
   });
   await sleep(700);
-  check('the DATA LAYERS panel opens from its own header control', opened);
+  check('the UTILITIES panel opens from its own header control', opened);
   const toggled = await page.evaluate(() => {
     const row = document.querySelector(
-      '#data-toggles [data-layer-id="directions"]',
+      '#utilities-toggles [data-layer-id="directions"]',
     );
     const button = row?.querySelector('.data-toggle-btn');
     if (!button) return false;
@@ -397,7 +399,7 @@ try {
   );
   const focused = await page.evaluate(() => {
     const row = document.querySelector(
-      '#data-toggles [data-layer-id="directions"]',
+      '#utilities-toggles [data-layer-id="directions"]',
     );
     const items = row.querySelectorAll('.data-row-list-item');
     items[2]?.focus();
@@ -776,7 +778,7 @@ try {
       }
     }
     const row = document.querySelector(
-      '#data-toggles [data-layer-id="directions"]',
+      '#utilities-toggles [data-layer-id="directions"]',
     );
     return {
       entities: left.length,
diff --git a/scripts/qa-draw-tool.mjs b/scripts/qa-draw-tool.mjs
index adb29f3af..e055f4a8f 100644
--- a/scripts/qa-draw-tool.mjs
+++ b/scripts/qa-draw-tool.mjs
@@ -196,12 +196,14 @@ try {
     );
   check('visible tile content settles before drawing', settled);
 
-  // The DISPLAY rail starts collapsed on a first run: open it the way a user does.
+  // UTILITIES starts collapsed on a first run: open it the way a user does.
   await page.evaluate(() => {
-    const rail = document.getElementById('pp-toggles');
-    if (rail?.classList.contains('collapsed'))
+    const panel = document.getElementById('utilities-panel');
+    if (panel?.classList.contains('collapsed'))
       document
-        .querySelector('.panel-collapse-btn[data-collapse-target="pp-toggles"]')
+        .querySelector(
+          '.panel-collapse-btn[data-collapse-target="utilities-panel"]',
+        )
         ?.click();
   });
   await page.waitForFunction(
@@ -480,10 +482,12 @@ try {
 
   // ── Clear wipes the board ───────────────────────────────────────────────
   await page.evaluate(() => {
-    const rail = document.getElementById('pp-toggles');
-    if (rail?.classList.contains('collapsed'))
+    const panel = document.getElementById('utilities-panel');
+    if (panel?.classList.contains('collapsed'))
       document
-        .querySelector('.panel-collapse-btn[data-collapse-target="pp-toggles"]')
+        .querySelector(
+          '.panel-collapse-btn[data-collapse-target="utilities-panel"]',
+        )
         ?.click();
   });
   await page.waitForFunction(
diff --git a/scripts/qa-form-fields.mjs b/scripts/qa-form-fields.mjs
index 3bbee3816..11bdffc2b 100644
--- a/scripts/qa-form-fields.mjs
+++ b/scripts/qa-form-fields.mjs
@@ -276,7 +276,12 @@ try {
   );
 
   await page.evaluate(() => {
-    for (const panel of ['pp-toggles', 'scene-panel', 'cctv-panel'])
+    for (const panel of [
+      'pp-toggles',
+      'utilities-panel',
+      'scene-panel',
+      'cctv-panel',
+    ])
       window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
         persist: false,
         syncShare: false,
@@ -419,14 +424,24 @@ try {
     { timeout: 60000 },
   );
   await page.evaluate(() => {
-    for (const panel of ['pp-toggles', 'scene-panel', 'cctv-panel'])
+    for (const panel of [
+      'pp-toggles',
+      'utilities-panel',
+      'scene-panel',
+      'cctv-panel',
+    ])
       window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
         persist: false,
         syncShare: false,
       });
   });
   await page.evaluate(() => {
-    for (const panel of ['pp-toggles', 'scene-panel', 'cctv-panel'])
+    for (const panel of [
+      'pp-toggles',
+      'utilities-panel',
+      'scene-panel',
+      'cctv-panel',
+    ])
       window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
         persist: false,
         syncShare: false,
diff --git a/scripts/qa-geo-import.mjs b/scripts/qa-geo-import.mjs
index 074eb8fbd..c744b4825 100644
--- a/scripts/qa-geo-import.mjs
+++ b/scripts/qa-geo-import.mjs
@@ -269,10 +269,12 @@ try {
   }, VIEW);
   await wait(4000);
   await page.evaluate(() => {
-    const rail = document.getElementById('pp-toggles');
-    if (rail?.classList.contains('collapsed'))
+    const panel = document.getElementById('utilities-panel');
+    if (panel?.classList.contains('collapsed'))
       document
-        .querySelector('.panel-collapse-btn[data-collapse-target="pp-toggles"]')
+        .querySelector(
+          '.panel-collapse-btn[data-collapse-target="utilities-panel"]',
+        )
         ?.click();
   });
   await page.waitForFunction(
diff --git a/src/annotations/drawTool.test.mjs b/src/annotations/drawTool.test.mjs
index e6ce2e9f3..2ba88d3dd 100644
--- a/src/annotations/drawTool.test.mjs
+++ b/src/annotations/drawTool.test.mjs
@@ -62,9 +62,9 @@ test('the engine resolves manual geometry before any name resolution', () => {
 });
 
 test('the Draw control markup carries the ids the tool binds to', () => {
-  // The DISPLAY rail is a component template now, assembled into index.html at
+  // UTILITIES is a component template now, assembled into index.html at
   // build time — the markup is not in index.html any more.
-  const html = read('src/ui/templates/display-controls.html');
+  const html = read('src/ui/templates/layer-panels.html');
   const ids = [
     'draw-toggle',
     'draw-mode-row',
@@ -140,8 +140,10 @@ test('nothing promises a GeoJSON export for drawn shapes', () => {
   }
   for (const file of ['README.md', 'CHANGELOG.md', 'docs/CURRENT-STATE.md']) {
     const source = read(file);
-    const at = source.indexOf('DISPLAY ▸ **Draw**');
-    const start = at >= 0 ? at : source.indexOf('DISPLAY ▸ Draw');
+    const start =
+      ['UTILITIES ▸ **Draw**', 'DISPLAY ▸ **Draw**', 'DISPLAY ▸ Draw']
+        .map((text) => source.indexOf(text))
+        .find((at) => at >= 0) ?? -1;
     assert.ok(start >= 0, `${file} should describe the Draw control`);
     const section = source.slice(start, start + 1200);
     assert.doesNotMatch(
diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json
index 696233f86..9fdfac1b1 100644
--- a/src/i18n/locales/es.json
+++ b/src/i18n/locales/es.json
@@ -761,6 +761,7 @@
   "ESC to close": "ESC para cerrar",
   "The Google Maps key buys the photorealistic planet — everything else stacks on top.": "La clave de Google Maps activa el planeta fotorrealista; todo lo demás se superpone.",
   "SCENES": "ESCENAS",
+  "UTILITIES": "UTILIDADES",
   "Scene recipe": "Receta de escena",
   "NEW": "NUEVA",
   "DEL": "BORRAR",
@@ -1470,6 +1471,7 @@
   "NOIR": "NOIR",
   "Rendered globe frames per second · toggle with `": "Fotogramas por segundo renderizados del globo · alterna con `",
   "Utilities": "Utilidades",
+  "Audio": "Audio",
   "Other layers": "Otras capas",
   "Movement": "Movimiento",
   "Infrastructure": "Infraestructura",
diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json
index 8764d9d06..baf98e27c 100644
--- a/src/i18n/locales/ru.json
+++ b/src/i18n/locales/ru.json
@@ -817,6 +817,7 @@
   "Scene recipe": "Рецепт сцены",
   "DATA LAYERS": "СЛОИ ДАННЫХ",
   "SCENES": "СЦЕНЫ",
+  "UTILITIES": "ИНСТРУМЕНТЫ",
   "Close key setup": "Закрыть настройку ключей",
   "SAVE KEYS": "СОХРАНИТЬ КЛЮЧИ",
   "Power up the globe": "Подключите потоки данных",
@@ -1492,6 +1493,7 @@
   "NOIR": "НУАР",
   "Rendered globe frames per second · toggle with `": "Кадров глобуса в секунду · переключение клавишей `",
   "Utilities": "Инструменты",
+  "Audio": "Аудио",
   "Other layers": "Другие слои",
   "Movement": "Движение",
   "Infrastructure": "Инфраструктура",
diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json
index 2e7db6b8f..d869e077a 100644
--- a/src/i18n/locales/zh-CN.json
+++ b/src/i18n/locales/zh-CN.json
@@ -1756,6 +1756,7 @@
   "Events": "事件",
   "Weather": "天气",
   "Utilities": "工具",
+  "Audio": "音频",
   "Other layers": "其他图层",
   "{state} · {source}": "{state} · {source}",
   "UNCERTAIN · {source} · lifecycle state requires reconciliation": "不确定 · {source} · 生命周期状态需要核对",
@@ -2723,6 +2724,7 @@
   "FLAT": "平面",
   "SINCE": "起始时间",
   "SCENES": "场景",
+  "UTILITIES": "工具",
   "Scene recipe": "场景方案",
   "NEW": "新建",
   "CAPTURE SHOT": "保存镜头",
diff --git a/src/i18n/locales/zh-Hant.json b/src/i18n/locales/zh-Hant.json
index 1477acd51..4e98cf9d6 100644
--- a/src/i18n/locales/zh-Hant.json
+++ b/src/i18n/locales/zh-Hant.json
@@ -1746,6 +1746,7 @@
   "Events": "事件",
   "Weather": "天氣",
   "Utilities": "工具",
+  "Audio": "音訊",
   "Other layers": "其他圖層",
   "{state} · {source}": "{state} · {source}",
   "UNCERTAIN · {source} · lifecycle state requires reconciliation": "不確定 · {source} · 生命週期狀態需要核對",
@@ -2711,6 +2712,7 @@
   "FLAT": "平面",
   "SINCE": "起始時間",
   "SCENES": "場景",
+  "UTILITIES": "工具",
   "Scene recipe": "場景方案",
   "NEW": "新建",
   "CAPTURE SHOT": "保存鏡頭",
diff --git a/src/i18n/same-as-english.json b/src/i18n/same-as-english.json
index 83c8897d8..0c18df79a 100644
--- a/src/i18n/same-as-english.json
+++ b/src/i18n/same-as-english.json
@@ -9,6 +9,7 @@
     "AUTO",
     "Ambient",
     "Anime",
+    "Audio",
     "Austin",
     "BRG {value}°",
     "BRG —",
diff --git a/src/ui/cyberTheme.test.mjs b/src/ui/cyberTheme.test.mjs
index 03ee75f08..686ee9af2 100644
--- a/src/ui/cyberTheme.test.mjs
+++ b/src/ui/cyberTheme.test.mjs
@@ -1,4 +1,9 @@
-import { getScopeMaskFeather, isScopeMaskEnabled, setScopeMaskEnabled, setScopeMaskFeather } from '../scopeMask.js';
+import {
+  getScopeMaskFeather,
+  isScopeMaskEnabled,
+  setScopeMaskEnabled,
+  setScopeMaskFeather,
+} from '../scopeMask.js';
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import test from 'node:test';
@@ -274,8 +279,14 @@ test('Display and voice HUD routes preserve explicit Cyber entry and exit author
 
 test('scope choice and expanded feather survive every HUD layout and both restore paths', async (t) => {
   const { owner } = styleOwner(t, 'tactical');
-  const previous = { enabled: isScopeMaskEnabled(), feather: getScopeMaskFeather() };
-  t.after(() => { setScopeMaskEnabled(previous.enabled); setScopeMaskFeather(previous.feather); });
+  const previous = {
+    enabled: isScopeMaskEnabled(),
+    feather: getScopeMaskFeather(),
+  };
+  t.after(() => {
+    setScopeMaskEnabled(previous.enabled);
+    setScopeMaskFeather(previous.feather);
+  });
   Object.assign(owner.services, { setScopeMaskEnabled, setScopeMaskFeather });
   owner._scopeBtn = { checked: true };
   owner._scopeFeatherSlider = { value: '11', disabled: false };
@@ -534,11 +545,11 @@ test('Cyber side panels share one width and one framed surface material', () =>
   );
   assert.match(
     cyberStyles,
-    /#left-panel-stack\s*> :is\(#data-panel, #scene-panel\)\.collapsed \{\s*width: var\(--cyber-panel-collapsed-width\);/,
+    /#left-panel-stack\s*> :is\(#data-panel, #utilities-panel, #scene-panel\)\.collapsed \{\s*width: var\(--cyber-panel-collapsed-width\);/,
   );
   assert.match(
     cyberStyles,
-    /:is\(#data-panel, #scene-panel\)\.collapsed\s+:is\(\.data-panel-inner, \.scene-panel-inner\) \{[\s\S]*?height: 50px;[\s\S]*?min-height: 50px;/,
+    /:is\(#data-panel, #utilities-panel, #scene-panel\)\.collapsed\s+:is\(\.data-panel-inner, \.scene-panel-inner\) \{[\s\S]*?height: 50px;[\s\S]*?min-height: 50px;/,
   );
   assert.match(
     cyberStyles,
diff --git a/src/ui/geoFileImport.test.mjs b/src/ui/geoFileImport.test.mjs
index eb4bdfa99..d78731af5 100644
--- a/src/ui/geoFileImport.test.mjs
+++ b/src/ui/geoFileImport.test.mjs
@@ -439,7 +439,7 @@ test('the application composition wires the import and owns its teardown', () =>
   );
   assert.ok(tools.indexOf('defer(() => geoFileImport?.destroy());') > importAt);
   const markup = fs.readFileSync(
-    new URL('./templates/display-controls.html', import.meta.url),
+    new URL('./templates/layer-panels.html', import.meta.url),
     'utf8',
   );
   for (const id of [
@@ -450,7 +450,7 @@ test('the application composition wires the import and owns its teardown', () =>
   ])
     assert.ok(
       markup.includes(`id="${id}"`),
-      `${id} missing from the DISPLAY template`,
+      `${id} missing from the UTILITIES template`,
     );
 });
 
diff --git a/src/ui/layerPanel.js b/src/ui/layerPanel.js
index 24bcad6e6..b654097b4 100644
--- a/src/ui/layerPanel.js
+++ b/src/ui/layerPanel.js
@@ -87,13 +87,20 @@ const PANEL_GROUPS = [
       'weather-cyclones',
     ],
   },
+  // Directions renders in the Utilities panel, beside Draw and Import, and
+  // needs no heading there.
   {
     label: msg('Utilities'),
-    ids: ['directions', 'radio'],
+    ids: ['directions'],
+    containerId: 'utilities-toggles',
+  },
+  {
+    label: msg('Audio'),
+    ids: ['radio'],
   },
 ];
-const PANEL_ORDER = PANEL_GROUPS.flatMap(({ label, ids }) =>
-  ids.map((id) => ({ id, label })),
+const PANEL_ORDER = PANEL_GROUPS.flatMap(({ label, ids, containerId }) =>
+  ids.map((id) => ({ id, label, containerId })),
 );
 const PANEL_POSITIONS = new Map(
   PANEL_ORDER.map(({ id }, index) => [id, index]),
@@ -226,6 +233,12 @@ export class LayerPanel {
     if (this._destroyed) return;
     this._releaseBindings();
     this._toggleContainer = container;
+    this._groupContainers = new Map();
+    for (const { containerId } of PANEL_GROUPS) {
+      const element =
+        containerId && container?.ownerDocument?.getElementById?.(containerId);
+      if (element) this._groupContainers.set(containerId, element);
+    }
     this._weatherPanel?.destroy();
     this._weatherPanel = createWeatherPanel({
       clock: this.weatherClock,
@@ -276,11 +289,27 @@ export class LayerPanel {
     this._recentImageryPanel = null;
     this._recentImageryFactory = null;
     this._toggleContainer = null;
+    this._groupContainers = null;
+  }
+  /** The list a row renders into: its group's own, else Data Layers. */
+  _containerFor(layerId) {
+    const containerId = PANEL_ORDER[PANEL_POSITIONS.get(layerId)]?.containerId;
+    return (
+      (containerId && this._groupContainers?.get(containerId)) ||
+      this._toggleContainer
+    );
+  }
+  _rowFor(layerId) {
+    return this._containerFor(layerId)?.querySelector(
+      `[data-layer-id="${layerId}"]`,
+    );
   }
   _renderToggles() {
     if (this._destroyed || !this._toggleContainer) return;
     this._releaseBindings();
     this._toggleContainer.innerHTML = '';
+    for (const element of this._groupContainers?.values() || [])
+      element.innerHTML = '';
 
     const generation = this._generation;
     const layers = this.getAll()
@@ -296,7 +325,12 @@ export class LayerPanel {
       const group =
         PANEL_ORDER[PANEL_POSITIONS.get(layer.id)]?.label ??
         msg('Other layers');
-      if (group && group !== previousGroup) {
+      const rowContainer = this._containerFor(layer.id);
+      if (
+        rowContainer === this._toggleContainer &&
+        group &&
+        group !== previousGroup
+      ) {
         const heading = document.createElement('h3');
         heading.className = 'data-layer-group-heading';
         heading.textContent = t(group);
@@ -421,7 +455,7 @@ export class LayerPanel {
         }
       }
 
-      this._toggleContainer.appendChild(row);
+      rowContainer.appendChild(row);
     }
     this._refreshWeatherPanel();
   }
@@ -600,9 +634,7 @@ export class LayerPanel {
       return;
     }
     for (const layer of this.getAll()) {
-      const row = this._toggleContainer.querySelector(
-        `[data-layer-id="${layer.id}"]`,
-      );
+      const row = this._rowFor(layer.id);
       if (!row) continue;
 
       const btn = row.querySelector('.data-toggle-btn');
diff --git a/src/ui/panelChrome.js b/src/ui/panelChrome.js
index d920e8545..edb8a4dca 100644
--- a/src/ui/panelChrome.js
+++ b/src/ui/panelChrome.js
@@ -30,6 +30,7 @@ const COCKPIT_ENTRY_COLLAPSE_PANEL_IDS = Object.freeze([
   'recent-imagery-panel',
   'street-level-panel',
   'scene-panel',
+  'utilities-panel',
   'pp-toggles',
   'global-context-panel',
   'radio-panel',
diff --git a/src/ui/styles/cockpit.css b/src/ui/styles/cockpit.css
index d54e09f8d..6736ae193 100644
--- a/src/ui/styles/cockpit.css
+++ b/src/ui/styles/cockpit.css
@@ -2007,6 +2007,7 @@ body.cockpit-mode #left-panel-stack {
   max-height: none;
   transition: none;
 }
+body.cockpit-mode #left-panel-stack > #utilities-panel,
 body.cockpit-mode #left-panel-stack > #scene-panel {
   display: none !important;
 }
diff --git a/src/ui/styles/controls.css b/src/ui/styles/controls.css
index 59f275109..8279ef30c 100644
--- a/src/ui/styles/controls.css
+++ b/src/ui/styles/controls.css
@@ -960,6 +960,7 @@ body.ui-clean-view #data-panel,
 body.ui-clean-view #cctv-panel,
 body.ui-clean-view #radio-panel,
 body.ui-clean-view #global-context-panel,
+body.ui-clean-view #utilities-panel,
 body.ui-clean-view #scene-panel {
   opacity: 0 !important;
   visibility: hidden !important;
diff --git a/src/ui/styles/cyber.css b/src/ui/styles/cyber.css
index e25bbae2d..715917b6e 100644
--- a/src/ui/styles/cyber.css
+++ b/src/ui/styles/cyber.css
@@ -1662,7 +1662,9 @@
   :root[data-ui-theme='cyber']
     body:not(.cockpit-mode)
     #left-panel-stack:has(> [data-panel-id]:not(.collapsed))
-    > :is(#data-panel, #cctv-panel, #scene-panel):not(.collapsed) {
+    > :is(#data-panel, #cctv-panel, #utilities-panel, #scene-panel):not(
+      .collapsed
+    ) {
     flex: 1 1 auto;
     height: auto;
     max-height: none;
@@ -1677,20 +1679,20 @@
 
   :root[data-ui-theme='cyber']
     #left-panel-stack
-    > :is(#data-panel, #scene-panel) {
+    > :is(#data-panel, #utilities-panel, #scene-panel) {
     --panel-expanded-width: var(--cyber-panel-width);
     width: var(--panel-expanded-width);
   }
 
   :root[data-ui-theme='cyber']
     #left-panel-stack
-    > :is(#data-panel, #scene-panel).collapsed {
+    > :is(#data-panel, #utilities-panel, #scene-panel).collapsed {
     width: var(--cyber-panel-collapsed-width);
   }
 
   :root[data-ui-theme='cyber']
     #left-panel-stack
-    > :is(#data-panel, #scene-panel).collapsed
+    > :is(#data-panel, #utilities-panel, #scene-panel).collapsed
     :is(.data-panel-inner, .scene-panel-inner) {
     box-sizing: border-box;
     height: 50px;
@@ -1718,7 +1720,7 @@
 
   :root[data-ui-theme='cyber']
     body:not(.cockpit-mode)
-    :is(#data-panel, #scene-panel)
+    :is(#data-panel, #utilities-panel, #scene-panel)
     .panel-collapse-btn {
     width: var(--cyber-panel-control-size);
     min-width: var(--cyber-panel-control-size);
diff --git a/src/ui/styles/layers.css b/src/ui/styles/layers.css
index ea64eefc5..2f4de3d18 100644
--- a/src/ui/styles/layers.css
+++ b/src/ui/styles/layers.css
@@ -1398,3 +1398,101 @@ body.recording-mode #right-context-rail > [data-panel-id] {
     width: 100%;
   }
 }
+
+/* ── Utilities Panel ─────────────────────────── */
+/* Directions (from the layer list), Draw and Import. Draw and Import read as
+   rows like Directions above them (.data-toggle-row): icon and name, their
+   options indented under the name. */
+#utilities-panel {
+  --panel-expanded-width: 280px;
+  width: var(--panel-expanded-width);
+}
+
+#utilities-panel .panel-glow {
+  position: absolute;
+  inset: -20px;
+  background: radial-gradient(
+    ellipse at center,
+    var(--accent-dim) 0%,
+    transparent 60%
+  );
+  filter: blur(20px);
+  opacity: 0.25;
+  pointer-events: none;
+}
+
+/* The layer list takes its natural height; the panel scrolls as a whole. */
+.utilities-list {
+  flex: 0 0 auto;
+  max-height: none;
+  overflow: visible;
+}
+
+.utilities-tools {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  margin-top: 2px;
+}
+
+.utilities-tools .pp-toggle-group {
+  width: 100%;
+}
+
+#utilities-panel .utilities-tools .pp-toggle-btn {
+  width: 100%;
+  min-height: 0;
+  box-sizing: border-box;
+  gap: 8px;
+  padding: 8px 10px 6px;
+  color: var(--text-primary);
+  text-align: left;
+  background: transparent;
+  border: 0;
+  border-radius: 8px;
+  box-shadow: none;
+  backdrop-filter: none;
+  -webkit-backdrop-filter: none;
+  transition: background var(--transition-fast);
+}
+
+#utilities-panel .utilities-tools .pp-toggle-btn:hover {
+  background: rgba(255, 255, 255, 0.03);
+}
+
+#utilities-panel .utilities-tools .pp-icon {
+  flex: none;
+  width: 16px;
+  font-size: 16px;
+  line-height: 1;
+  color: var(--text-primary);
+  text-align: center;
+}
+
+#utilities-panel .utilities-tools .pp-label {
+  font-family: var(--font-sans);
+  font-size: 13px;
+  font-weight: 500;
+  letter-spacing: 0.3px;
+  text-transform: none;
+  color: var(--text-primary);
+}
+
+/* Draw reads as on with the accent of an enabled layer row. */
+#utilities-panel
+  .utilities-tools
+  .pp-toggle-btn:is([aria-pressed='true'], .active) {
+  background: var(--accent-dim);
+  box-shadow: inset 2px 0 0 var(--accent);
+}
+
+#utilities-panel
+  .utilities-tools
+  :is(.pp-slider-row, .geo-import-list, .geo-import-hint) {
+  margin-left: 34px;
+  margin-right: 10px;
+}
+
+#utilities-panel.collapsed .utilities-tools {
+  display: none;
+}
diff --git a/src/ui/styles/mobile-shell.css b/src/ui/styles/mobile-shell.css
index aecfdf8d4..481535434 100644
--- a/src/ui/styles/mobile-shell.css
+++ b/src/ui/styles/mobile-shell.css
@@ -166,6 +166,9 @@ body.mobile-shell #right-context-rail > #recent-imagery-panel {
 /* Rail-scoped ids so a rail's own hiding rules (for example the Tactical HUD
    hiding collapsed siblings) never take a panel out of an open sheet. */
 body.mobile-shell[data-mobile-sheet='layers'] #left-panel-stack > #data-panel,
+body.mobile-shell[data-mobile-sheet='layers']
+  #left-panel-stack
+  > #utilities-panel,
 body.mobile-shell[data-mobile-sheet='layers'] #left-panel-stack > #scene-panel,
 body.mobile-shell[data-mobile-sheet='cameras']
   #right-context-rail
diff --git a/src/ui/styles/recording.css b/src/ui/styles/recording.css
index be806a87a..97a326fd6 100644
--- a/src/ui/styles/recording.css
+++ b/src/ui/styles/recording.css
@@ -15,6 +15,7 @@ body.recording-mode #cctv-panel,
 body.recording-mode #radio-panel,
 body.recording-mode #global-context-panel,
 body.recording-mode #gev-voice-control,
+body.recording-mode #utilities-panel,
 body.recording-mode #scene-panel {
   opacity: 0 !important;
   visibility: hidden !important;
diff --git a/src/ui/styles/responsive.css b/src/ui/styles/responsive.css
index 8278b51a7..04dbf276b 100644
--- a/src/ui/styles/responsive.css
+++ b/src/ui/styles/responsive.css
@@ -237,11 +237,13 @@
   #left-panel-stack > #cctv-panel,
   #left-panel-stack > #street-level-panel,
   #left-panel-stack > #global-context-panel,
+  #left-panel-stack > #utilities-panel,
   #left-panel-stack > #scene-panel,
   #left-panel-stack > #data-panel.collapsed,
   #left-panel-stack > #cctv-panel.collapsed,
   #left-panel-stack > #street-level-panel.collapsed,
   #left-panel-stack > #global-context-panel.collapsed,
+  #left-panel-stack > #utilities-panel.collapsed,
   #left-panel-stack > #scene-panel.collapsed {
     position: relative;
     top: auto;
diff --git a/src/ui/styles/scenes.css b/src/ui/styles/scenes.css
index 29250a636..9cd15b797 100644
--- a/src/ui/styles/scenes.css
+++ b/src/ui/styles/scenes.css
@@ -14,6 +14,7 @@
 #left-panel-stack > #data-panel,
 #left-panel-stack > #cctv-panel,
 #left-panel-stack > #global-context-panel,
+#left-panel-stack > #utilities-panel,
 #left-panel-stack > #scene-panel {
   position: relative;
   top: auto;
@@ -35,6 +36,10 @@
   order: 2;
 }
 
+#left-panel-stack > #utilities-panel {
+  order: 3;
+}
+
 #left-panel-stack > #scene-panel {
   order: 4;
 }
@@ -50,6 +55,7 @@
 
 #left-panel-stack > #data-panel:not(.collapsed),
 #left-panel-stack > #cctv-panel:not(.collapsed),
+#left-panel-stack > #utilities-panel:not(.collapsed),
 #left-panel-stack > #scene-panel:not(.collapsed) {
   box-sizing: border-box;
   flex: 0 1 var(--left-panel-allocated-height, auto);
@@ -62,7 +68,9 @@
  * the canonical control order and center their combined stack at 50vh.
  */
 #left-panel-stack.layout-tail
-  > :is(#data-panel, #cctv-panel, #scene-panel):not(.collapsed) {
+  > :is(#data-panel, #cctv-panel, #utilities-panel, #scene-panel):not(
+    .collapsed
+  ) {
   box-sizing: border-box;
   flex: 0 0 var(--left-panel-allocated-height);
   height: var(--left-panel-allocated-height);
@@ -71,6 +79,7 @@
 
 #left-panel-stack > #data-panel:not(.collapsed) .data-panel-inner,
 #left-panel-stack > #cctv-panel:not(.collapsed) .cctv-panel-inner,
+#left-panel-stack > #utilities-panel:not(.collapsed) .utilities-panel-inner,
 #left-panel-stack > #scene-panel:not(.collapsed) .scene-panel-inner {
   height: 100%;
   max-height: 100%;
@@ -81,6 +90,7 @@
 }
 
 #left-panel-stack > #cctv-panel:not(.collapsed) .cctv-panel-inner,
+#left-panel-stack > #utilities-panel:not(.collapsed) .utilities-panel-inner,
 #left-panel-stack > #scene-panel:not(.collapsed) .scene-panel-inner {
   overflow-y: auto;
   scrollbar-gutter: stable;
@@ -360,6 +370,8 @@ html:not([lang='en']) #scene-panel .scene-controls .scene-btn {
 #scene-panel.collapsed .scene-shot-list,
 #scene-panel.collapsed .scene-progress,
 #scene-panel.collapsed #scene-status,
+#utilities-panel.collapsed .utilities-list,
+#utilities-panel.collapsed .utilities-tools,
 #param-slider-panel.collapsed #param-sliders,
 #location-bar.collapsed .poi-row-container,
 #location-bar.collapsed .location-bar-divider,
@@ -370,6 +382,7 @@ html:not([lang='en']) #scene-panel .scene-controls .scene-btn {
 
 #data-panel.collapsed,
 #cctv-panel.collapsed,
+#utilities-panel.collapsed,
 #scene-panel.collapsed {
   width: var(--left-collapsed-width);
 }
@@ -381,6 +394,7 @@ html:not([lang='en']) #scene-panel .scene-controls .scene-btn {
 #data-panel.collapsed .panel-title,
 #cctv-panel.collapsed .panel-title,
 #radio-panel.collapsed .panel-title,
+#utilities-panel.collapsed .panel-title,
 #scene-panel.collapsed .panel-title {
   font-size: 8px;
   letter-spacing: 1.8px;
@@ -391,6 +405,7 @@ html:not([lang='en']) #scene-panel .scene-controls .scene-btn {
 #cctv-panel.collapsed .cctv-panel-inner,
 #radio-panel.collapsed .radio-panel-inner,
 #scene-panel.collapsed .scene-panel-inner,
+#utilities-panel.collapsed .utilities-panel-inner,
 #param-slider-panel.collapsed,
 #location-bar.collapsed .location-inner {
   padding-bottom: 10px;
@@ -402,6 +417,7 @@ html:not([lang='en']) #scene-panel .scene-controls .scene-btn {
 #radio-panel.collapsed .panel-header,
 #global-context-panel.collapsed .panel-header,
 #scene-panel.collapsed .panel-header,
+#utilities-panel.collapsed .panel-header,
 #param-slider-panel.collapsed .param-panel-header {
   margin-bottom: 2px;
 }
diff --git a/src/ui/templates/display-controls.html b/src/ui/templates/display-controls.html
index f6af31127..77361add5 100644
--- a/src/ui/templates/display-controls.html
+++ b/src/ui/templates/display-controls.html
@@ -117,41 +117,6 @@
         <span class="pp-slider-value" id="scope-feather-value">100%</span>
       </div>
     </div>
-    <div class="pp-toggle-group">
-      <button class="pp-toggle-btn" id="draw-toggle" title="Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel" aria-pressed="false" data-i18n-title>
-        <span class="pp-icon material-symbols-outlined" aria-hidden="true">draw</span>
-        <span class="pp-label" data-i18n>Draw</span>
-      </button>
-      <div class="pp-slider-row" id="draw-mode-row">
-        <span class="pp-slider-mini-label" data-i18n>Shape</span>
-        <div class="gev-segmented pp-mode-seg" role="radiogroup" aria-label="Shape to draw" data-i18n-aria-label>
-          <button class="gev-segment pp-mode-btn active" data-shape="area" role="radio" aria-checked="true" data-i18n>Area</button>
-          <button class="gev-segment pp-mode-btn" data-shape="line" role="radio" aria-checked="false" data-i18n>Line</button>
-          <button class="gev-segment pp-mode-btn" data-shape="pin" role="radio" aria-checked="false" data-i18n>Pin</button>
-        </div>
-      </div>
-      <div class="pp-slider-row" id="draw-label-row">
-        <input type="text" class="pp-text-input" id="draw-label-input" maxlength="120" placeholder="Label (optional)" aria-label="Label for the drawn shape" data-i18n-placeholder data-i18n-aria-label autocomplete="off" spellcheck="false">
-        <select class="pp-select draw-color-select gev-field gev-field--compact" id="draw-color-select" aria-label="Colour of the drawn shape" data-i18n-aria-label>
-          <option value="primary" data-i18n>Primary</option>
-          <option value="amber" data-i18n>Amber</option>
-          <option value="cyan" data-i18n>Cyan</option>
-          <option value="green" data-i18n>Green</option>
-          <option value="red" data-i18n>Red</option>
-        </select>
-        <button class="pp-mode-btn draw-clear-btn" id="draw-clear" type="button" title="Remove every mark from the board" data-i18n-title data-i18n>Clear</button>
-        <span class="draw-hint" id="draw-hint" aria-live="polite"></span>
-      </div>
-    </div>
-    <div class="pp-toggle-group" id="geo-import-group">
-      <button class="pp-toggle-btn" id="geo-import-button" type="button" title="Show your own GeoJSON, KML, KMZ or GPX files on the globe (or drop them onto it). File bytes stay on this device; overlays can appear in map screenshots shared with voice." data-i18n-title>
-        <span class="pp-icon material-symbols-outlined" aria-hidden="true">upload_file</span>
-        <span class="pp-label" data-i18n>Import</span>
-      </button>
-      <input type="file" id="geo-import-input" accept=".geojson,.json,.kml,.kmz,.gpx" multiple hidden aria-label="Choose GeoJSON, KML, KMZ or GPX files" data-i18n-aria-label>
-      <ul class="geo-import-list" id="geo-import-list" aria-label="Imported files" data-i18n-aria-label></ul>
-      <span class="draw-hint geo-import-hint" id="geo-import-hint" aria-live="polite"></span>
-    </div>
     <div class="pp-toggle-group">
       <button class="pp-toggle-btn" id="celestial-toggle" title="Celestial ring — reveal the full globe" aria-pressed="false" data-i18n-title>
         <span class="pp-icon material-symbols-outlined" aria-hidden="true">flare</span>
diff --git a/src/ui/templates/layer-panels.html b/src/ui/templates/layer-panels.html
index 9d8d15a97..eb7f7dcfd 100644
--- a/src/ui/templates/layer-panels.html
+++ b/src/ui/templates/layer-panels.html
@@ -142,6 +142,56 @@
     </div>
   </div>
 
+  <!-- Utilities Panel: Directions (from the layer list), Draw and Import -->
+  <div id="utilities-panel" class="panel-collapsible collapsed" data-panel-id="utilities-panel">
+    <div class="panel-glow"></div>
+    <div class="data-panel-inner utilities-panel-inner">
+      <div class="panel-header">
+        <span class="panel-title" data-i18n>UTILITIES</span>
+        <span class="panel-divider"></span>
+        <button class="panel-collapse-btn" data-collapse-target="utilities-panel" title="Collapse panel" data-i18n-title>+</button>
+      </div>
+      <div id="utilities-toggles" class="data-toggle-list utilities-list"></div>
+      <div class="utilities-tools">
+        <div class="pp-toggle-group">
+          <button class="pp-toggle-btn" id="draw-toggle" title="Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel" aria-pressed="false" data-i18n-title>
+            <span class="pp-icon material-symbols-outlined" aria-hidden="true">draw</span>
+            <span class="pp-label" data-i18n>Draw</span>
+          </button>
+          <div class="pp-slider-row" id="draw-mode-row">
+            <span class="pp-slider-mini-label" data-i18n>Shape</span>
+            <div class="gev-segmented pp-mode-seg" role="radiogroup" aria-label="Shape to draw" data-i18n-aria-label>
+              <button class="gev-segment pp-mode-btn active" data-shape="area" role="radio" aria-checked="true" data-i18n>Area</button>
+              <button class="gev-segment pp-mode-btn" data-shape="line" role="radio" aria-checked="false" data-i18n>Line</button>
+              <button class="gev-segment pp-mode-btn" data-shape="pin" role="radio" aria-checked="false" data-i18n>Pin</button>
+            </div>
+          </div>
+          <div class="pp-slider-row" id="draw-label-row">
+            <input type="text" class="pp-text-input" id="draw-label-input" maxlength="120" placeholder="Label (optional)" aria-label="Label for the drawn shape" data-i18n-placeholder data-i18n-aria-label autocomplete="off" spellcheck="false">
+            <select class="pp-select draw-color-select gev-field gev-field--compact" id="draw-color-select" aria-label="Colour of the drawn shape" data-i18n-aria-label>
+              <option value="primary" data-i18n>Primary</option>
+              <option value="amber" data-i18n>Amber</option>
+              <option value="cyan" data-i18n>Cyan</option>
+              <option value="green" data-i18n>Green</option>
+              <option value="red" data-i18n>Red</option>
+            </select>
+            <button class="pp-mode-btn draw-clear-btn" id="draw-clear" type="button" title="Remove every mark from the board" data-i18n-title data-i18n>Clear</button>
+            <span class="draw-hint" id="draw-hint" aria-live="polite"></span>
+          </div>
+        </div>
+        <div class="pp-toggle-group" id="geo-import-group">
+          <button class="pp-toggle-btn" id="geo-import-button" type="button" title="Show your own GeoJSON, KML, KMZ or GPX files on the globe (or drop them onto it). File bytes stay on this device; overlays can appear in map screenshots shared with voice." data-i18n-title>
+            <span class="pp-icon material-symbols-outlined" aria-hidden="true">upload_file</span>
+            <span class="pp-label" data-i18n>Import</span>
+          </button>
+          <input type="file" id="geo-import-input" accept=".geojson,.json,.kml,.kmz,.gpx" multiple hidden aria-label="Choose GeoJSON, KML, KMZ or GPX files" data-i18n-aria-label>
+          <ul class="geo-import-list" id="geo-import-list" aria-label="Imported files" data-i18n-aria-label></ul>
+          <span class="draw-hint geo-import-hint" id="geo-import-hint" aria-live="polite"></span>
+        </div>
+      </div>
+    </div>
+  </div>
+
   <!-- Scene Director Panel -->
   <div id="scene-panel" class="panel-collapsible collapsed" data-panel-id="scene-panel">
     <div class="panel-glow"></div>
diff --git a/src/voice/gevActions.js b/src/voice/gevActions.js
index 0a43f02f1..c67e1be16 100644
--- a/src/voice/gevActions.js
+++ b/src/voice/gevActions.js
@@ -3191,8 +3191,9 @@ function normalizeCockpitAction(value) {
 }
 
 function focusDataLayerRow(layerId) {
+  const selector = `[data-layer-id="${CSS.escape(layerId)}"]`;
   const row = document.querySelector(
-    `#data-toggles [data-layer-id="${CSS.escape(layerId)}"]`,
+    `#data-toggles ${selector}, #utilities-toggles ${selector}`,
   );
   if (!row) return null;
   row.scrollIntoView({ block: 'center', behavior: 'smooth' });

From d730b0ce87aee205aa49e9c9ea1a78821e857a5c Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Thu, 29 Oct 2026 11:21:42 +0000
Subject: [PATCH 42/70] Add the changelog fragment for the Utilities panel

---
 changelog.d/1469-utilities-panel.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1469-utilities-panel.md

diff --git a/changelog.d/1469-utilities-panel.md b/changelog.d/1469-utilities-panel.md
new file mode 100644
index 000000000..9be1f14bc
--- /dev/null
+++ b/changelog.d/1469-utilities-panel.md
@@ -0,0 +1,3 @@
+- Gather Directions, Draw and Import in a new UTILITIES panel in the left
+  column, between Data Layers and Scenes. Draw and Import leave DISPLAY, and
+  Radio stays in Data Layers under "Audio" (asturksever, #1469).

From 8543b7be43265f1c1b889e501f6b49975004c309 Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Thu, 29 Oct 2026 11:53:15 +0000
Subject: [PATCH 43/70] Keep Directions reachable and tested in the Utilities
 panel

Voice show_data_layers_menu opens the panel that holds the row, so asking
for Directions opens UTILITIES and reports that panel, not a hidden row
under Data Layers. In Cockpit the panel stays with Directions alone, as
Data Layers does; only Draw and Import step aside there.

Draw's options sit flat under its name instead of keeping the card that
hung under a DISPLAY button, and its Shape label no longer takes DISPLAY's
label column in other languages. Cyber marks Draw on with its red edge.

LayerPanel routing, the voice panel choice, and the panel's order, mode
and phone-sheet CSS gain tests that fail on the earlier code. The form-field
and segmented-control gates open Utilities for Draw's controls, measuring
Scenes and Utilities in turn since the left rail fits one tall panel.
README, CONTRIBUTING, the PR template, CURRENT-STATE and comments now say
UTILITIES for Draw and Import and list the Audio group, and two files
outside the format scope lose an unrelated reflow.
---
 .github/pull_request_template.md  |   3 +-
 CONTRIBUTING.md                   |   5 +-
 README.md                         |   4 +-
 docs/CURRENT-STATE.md             |  16 +++--
 scripts/qa-draw-tool.mjs          |   4 +-
 scripts/qa-form-fields.mjs        |  99 +++++++++++++++++----------
 scripts/qa-geo-import.mjs         |   4 +-
 scripts/qa-segmented-controls.mjs |  14 ++--
 src/annotations/drawTool.js       |   2 +-
 src/annotations/drawTool.test.mjs |  12 ++--
 src/app/tools.js                  |   4 +-
 src/cockpitMarkup.test.mjs        |   1 +
 src/panelStackLayout.test.mjs     |  13 ++++
 src/ui/cyberTheme.test.mjs        |  17 +----
 src/ui/geoFileImport.test.mjs     |   2 +-
 src/ui/layerPanel.test.mjs        | 109 ++++++++++++++++++++++++++++++
 src/ui/styles/cockpit.css         |   6 +-
 src/ui/styles/controls.css        |   4 +-
 src/ui/styles/cyber.css           |  12 +++-
 src/ui/styles/layers.css          |  19 +++++-
 src/voice/gevActions.js           |  19 ++++--
 src/voice/gevActions.test.mjs     |  47 +++++++++++++
 22 files changed, 319 insertions(+), 97 deletions(-)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index e8c9f8bdf..e1638adf1 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -34,7 +34,8 @@ If it's bigger, link to it instead.
 
 <!--
 Which layer-panel group should it sit in? The current groups are in PANEL_GROUPS
-in src/ui/layerPanel.js: Movement, Cameras, Infrastructure, Events, Weather, Utilities.
+in src/ui/layerPanel.js: Movement, Cameras, Infrastructure, Events, Weather, Audio,
+and Utilities (its rows render in the separate UTILITIES panel).
 If none fits, propose a new group and say why.
 -->
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a7fe8ab76..9e285bdb0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -170,8 +170,9 @@ template has a section for them.
    instead of attaching it.
 3. **The proposed category.** Say which layer-panel group the layer belongs in.
    The groups are defined in `PANEL_GROUPS` in `src/ui/layerPanel.js` (today:
-   Movement, Cameras, Infrastructure, Events, Weather and Utilities). A layer
-   that isn't listed there falls under "Other layers". If none of the groups
+   Movement, Cameras, Infrastructure, Events, Weather and Audio, plus Utilities,
+   whose rows render in the separate UTILITIES panel). A layer that isn't
+   listed there falls under "Other layers". If none of the groups
    fits, propose a new one and explain why.
 4. **The data source and licence.** Name the provider and endpoint, link its
    licence or terms, give the attribution shown in the app, and say whether it
diff --git a/README.md b/README.md
index 0a7509efa..2f47216a8 100644
--- a/README.md
+++ b/README.md
@@ -357,7 +357,7 @@ camera input stops rotation.
 
 > 🗣️ _"Outline the state of Texas."_ · _"Annotate the Texas State Capitol and its grounds"_ — it draws the **actual enclosing boundary**, not a circle. · _"How far is the Eiffel Tower from the Louvre?"_ — a connector arrow appears and it speaks the distance. Everything persists until you say _"clear the map."_
 
-**✍️ Or draw it yourself** — DISPLAY ▸ **Draw**: pick Area, Line or Pin, click the vertices on the real world, double-click to finish, label it. Same whiteboard, same persistence, no microphone needed.
+**✍️ Or draw it yourself** — UTILITIES ▸ **Draw**: pick Area, Line or Pin, click the vertices on the real world, double-click to finish, label it. Same whiteboard, same persistence, no microphone needed.
 
 ![Zilker Park and Lady Bird Lake drawing onto the 3D city as persistent vector annotations, by voice](docs/media/01-voice-annotate-zilker.gif)
 
@@ -415,7 +415,7 @@ Twenty layers and map sources. **Eighteen have a keyless path.** Some offer addi
 
 **Weather, keyless.** **Wind** animates 10 m forecast flow from NOAA GFS or ECMWF IFS, with an optional color field and a reading at map center. **Rain radar**, **Satellite clouds** and **Lightning density** are observations on one history timeline in the **WEATHER** panel (step back, **Play**, **Latest**); **Cyclone advisories** draw NHC and CPHC positions, forecast tracks and cones. On Google 3D Tiles the observed layers float above the city as translucent shells, sharpened around your view.
 
-In the app, **Data Layers** groups them as Movement, Cameras, Infrastructure, Events, Weather and Utilities.
+In the app, **Data Layers** groups them as Movement, Cameras, Infrastructure, Events, Weather and Audio; Directions sits in the separate **Utilities** panel with Draw and Import.
 
 **The basemap ladder — what each tier buys you:**
 
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 0c3221945..15c74e926 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -133,17 +133,19 @@ field. Existing whole-link size limits still apply.
 
 ## Utilities panel — October 29, 2026
 
-UTILITIES is its own panel in the left column, after Data Layers and CCTV and
-above Scenes (`#utilities-panel` in `src/ui/templates/layer-panels.html`). It
+UTILITIES is its own panel in the left column, between Data Layers and Scenes
+(`#utilities-panel` in `src/ui/templates/layer-panels.html`). It
 holds the Directions layer row, which `LayerPanel` renders into
 `#utilities-toggles` instead of the Data Layers list, and Draw and Import,
 which moved there from DISPLAY with their ids unchanged. Radio, formerly the
 other row under the Data Layers "Utilities" heading, stays in Data Layers under
 "Audio". The panel collapses and remembers its state like the other left
-panels; share links do not carry it. It hides in clean view, recording and
-Cockpit, and on a phone it sits collapsed in the Layers sheet under Data
-Layers. The Directions, Draw and Import QA gates open it to reach their
-controls.
+panels; share links do not carry it. It hides in clean view and recording. In
+Cockpit it stays with Directions alone, as Data Layers does; Draw and Import
+hide there, as DISPLAY always did. Voice `show_data_layers_menu` for
+Directions opens Utilities. On a phone it sits collapsed in the Layers sheet
+under Data Layers. The Directions, Draw, Import, form-field and
+segmented-control QA gates open it to reach their controls.
 
 ## God's Eye View in conversations — October 2, 2026
 
@@ -5411,7 +5413,7 @@ request viewbox and continues searching without that geographic preference.
 ### Manual Whiteboard Drawing (September 2026)
 
 - UTILITIES ▸ **Draw** turns the globe into a whiteboard drawn by hand. Pick a shape (Area, Line, Pin), click the vertices on the real world, type an optional label and pick a colour, and finish. **Keyboard contract, live only while Draw is on and never while you are typing in another field:** Enter finishes the shape (as does a double-click, and the two cannot both submit it — the session is replaced before the annotate call is awaited); Backspace removes the last vertex; Esc cancels the shape in progress, and a second Esc — Esc on an empty session — leaves draw mode. Typing in the label field keeps Backspace; Enter there also finishes. **Clear** wipes the board (the shape in progress and every placed mark), so removing marks does not require the console or the microphone.
-- Runtime entry: `createApplicationTools` (`src/app/tools.js`, behind the `src/standalone/tools.js` shim) calls `initDrawTool({ viewer, annotations })` after `initAnnotations` and defers its `destroy()`, so disposing the shell returns every DOM listener, the Cesium handler, the preview data source, the borrowed click actions and the `window.__gevDrawTool` handle. Its markup is a DISPLAY-rail component template (`src/ui/templates/display-controls.html`), assembled into `index.html` at build time. That handle (`setActive`, `setShape`, `addVertex(lon, lat)`, `finish`, `cancel`, `clearAll`, `diagnostics`) is the no-mouse test seam.
+- Runtime entry: `createApplicationTools` (`src/app/tools.js`, behind the `src/standalone/tools.js` shim) calls `initDrawTool({ viewer, annotations })` after `initAnnotations` and defers its `destroy()`, so disposing the shell returns every DOM listener, the Cesium handler, the preview data source, the borrowed click actions and the `window.__gevDrawTool` handle. Its markup lives in the UTILITIES panel's component template (`src/ui/templates/layer-panels.html`), assembled into `index.html` at build time. That handle (`setActive`, `setShape`, `addVertex(lon, lat)`, `finish`, `cancel`, `clearAll`, `diagnostics`) is the no-mouse test seam.
 - Contract: a finished shape is submitted through the SAME `annotationEngine.annotate()` the voice agent uses, with geometry supplied and `manual: true` (`type: area` + `ring`, `type: route` + `path`, `type: pin` + coordinates). `resolveSpec` short-circuits manual specs (`resolveManualSpec`) so no geocoder, Places or Overpass call is made. A drawn area is a real (not synthesized) outline and drapes solid; a drawn line is a `route` with `mode: 'manual'`, labelled with its length and never a travel time; a pin is a point. Drawn marks therefore render with the whiteboard look, persist, de-dup, appear in `.list()`, and clear with `clear_annotations` / `.clear()`.
 - **A vertex is a lon/lat, and the mark is DRAPED.** Clicks are picked through `pickWorldFromScreen` — one of two scene helpers the annotation resolver factory (`src/annotations/resolver.js`) exposes alongside `sampleGroundHeight`, so the app has ONE depth-aware pick cascade rather than a second written beside it — which returns the height the pick landed on as well as the coordinate, so the live preview hangs on the roof or hillside under the pointer instead of sinking to sea level. The world renderer draws areas and routes with `clampToGround`, so the height is dropped at finish in one place (`finishSpec`) rather than being carried downstream and discarded silently: what you get is the outline you drew, lying on the surface beneath it.
 - **Draped marks classify onto `ClassificationType.BOTH`** — terrain AND 3D tiles — not onto 3D tiles alone. With only `CESIUM_3D_TILE`, every area fill, area outline, route and arrow rendered to nothing on a keyless boot, where Cesium's own globe carries Esri/OSM imagery and there are no tiles to classify against; the labels appeared and the geometry did not. That hit spoken annotations exactly as hard as hand-drawn ones. `scripts/qa-draw-tool.mjs` counts the mark's own colour in the rendered frame before and after a shape is finished, on a keyed AND a keyless server, so "the board says there is a mark" can no longer pass for "the mark is on screen".
diff --git a/scripts/qa-draw-tool.mjs b/scripts/qa-draw-tool.mjs
index e055f4a8f..8a9a01b0e 100644
--- a/scripts/qa-draw-tool.mjs
+++ b/scripts/qa-draw-tool.mjs
@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-/** Rendered acceptance for DISPLAY ▸ Draw: real clicks, real keys, real teardown. */
+/** Rendered acceptance for UTILITIES ▸ Draw: real clicks, real keys, real teardown. */
 import fs from 'node:fs';
 import path from 'node:path';
 import puppeteer from 'puppeteer';
@@ -212,7 +212,7 @@ try {
     { timeout: 10_000 },
   );
   check(
-    'the Draw control is on the DISPLAY rail and starts off',
+    'the Draw control is in the UTILITIES panel and starts off',
     await page.evaluate(() => {
       const toggle = document.getElementById('draw-toggle');
       return (
diff --git a/scripts/qa-form-fields.mjs b/scripts/qa-form-fields.mjs
index 11bdffc2b..52cd059b7 100644
--- a/scripts/qa-form-fields.mjs
+++ b/scripts/qa-form-fields.mjs
@@ -275,6 +275,25 @@ try {
     await page.evaluate(() => window.__qaFormCalls.length === 2),
   );
 
+  // The left rail fits one tall panel at a time, so Scenes and Utilities
+  // take turns: each field is measured with its own panel open.
+  const LEFT_PANEL_FIELDS = [
+    [
+      'scene-panel',
+      ['scene-select', 'cctv-camera-select', 'hud-layout-select'],
+    ],
+    ['utilities-panel', ['draw-color-select']],
+  ];
+  const showLeftPanel = (open) =>
+    page.evaluate((open) => {
+      for (const panel of ['scene-panel', 'utilities-panel'])
+        window.__godsEyeView.styleManager.setPanelCollapsed(
+          panel,
+          panel !== open,
+          { persist: false, syncShare: false },
+        );
+    }, open);
+
   await page.evaluate(() => {
     for (const panel of [
       'pp-toggles',
@@ -287,6 +306,7 @@ try {
         syncShare: false,
       });
   });
+  await showLeftPanel('utilities-panel');
   if (
     await page.$eval(
       '#draw-toggle',
@@ -300,25 +320,31 @@ try {
     }, lang);
     for (const width of [1440, 620, 390]) {
       await page.setViewport({ width, height: 900 });
-      const layout = await page.evaluate(() => {
-        const ids = [
-          'scene-select',
-          'cctv-camera-select',
-          'hud-layout-select',
-          'draw-color-select',
-        ];
-        return ids.map((id) => {
-          const node = document.getElementById(id),
-            rect = node.getBoundingClientRect(),
-            panel = node.closest('.panel-collapsible')?.getBoundingClientRect();
-          return {
-            id,
-            width: rect.width,
-            fits: rect.width > 0 && rect.width <= (panel?.width || innerWidth),
-            radius: getComputedStyle(node).borderRadius,
-          };
-        });
-      });
+      const layout = [];
+      for (const [open, ids] of LEFT_PANEL_FIELDS) {
+        await showLeftPanel(open);
+        layout.push(
+          ...(await page.evaluate(
+            (ids) =>
+              ids.map((id) => {
+                const node = document.getElementById(id),
+                  rect = node.getBoundingClientRect(),
+                  panel = node
+                    .closest('.panel-collapsible')
+                    ?.getBoundingClientRect();
+                return {
+                  id,
+                  width: rect.width,
+                  fits:
+                    rect.width > 0 &&
+                    rect.width <= (panel?.width || innerWidth),
+                  radius: getComputedStyle(node).borderRadius,
+                };
+              }),
+            ids,
+          )),
+        );
+      }
       check(
         `${lang} fields fit their panels at ${width}px`,
         layout.every((item) => item.fits),
@@ -360,6 +386,7 @@ try {
   );
   // Scene selection can restore application settings. Exercise it after the
   // fixture-owned CCTV phase so those asynchronous effects cannot replace ports.
+  await showLeftPanel('scene-panel');
   page.once('dialog', (dialog) => dialog.accept('Baseline selection fixture'));
   await page.click('#scene-new-btn');
   await page.waitForFunction(() =>
@@ -447,6 +474,7 @@ try {
         syncShare: false,
       });
   });
+  await showLeftPanel('utilities-panel');
   if (
     await page.$eval(
       '#draw-toggle',
@@ -454,23 +482,22 @@ try {
     )
   )
     await page.click('#draw-toggle');
-  const translated = await page.evaluate(() => {
-    const nodes = [
-      'scene-select',
-      'cctv-camera-select',
-      'hud-layout-select',
-      'draw-color-select',
-    ].map((id) => document.getElementById(id));
-    return (
-      document.documentElement.lang === 'ru' &&
-      nodes.every(
-        (node) =>
-          node.clientWidth > 0 &&
-          node.getBoundingClientRect().width <=
-            node.closest('.panel-collapsible').getBoundingClientRect().width,
-      )
-    );
-  });
+  let translated = true;
+  for (const [open, ids] of LEFT_PANEL_FIELDS) {
+    await showLeftPanel(open);
+    translated &&= await page.evaluate((ids) => {
+      const nodes = ids.map((id) => document.getElementById(id));
+      return (
+        document.documentElement.lang === 'ru' &&
+        nodes.every(
+          (node) =>
+            node.clientWidth > 0 &&
+            node.getBoundingClientRect().width <=
+              node.closest('.panel-collapsible').getBoundingClientRect().width,
+        )
+      );
+    }, ids);
+  }
   check('real Russian labels and fields fit at 390px', translated);
   await page.screenshot({ path: 'qa-shots/form-fields/ru-390.png' });
   check('no uncaught browser errors', errors.length === 0, errors);
diff --git a/scripts/qa-geo-import.mjs b/scripts/qa-geo-import.mjs
index c744b4825..88a3c4d13 100644
--- a/scripts/qa-geo-import.mjs
+++ b/scripts/qa-geo-import.mjs
@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Rendered acceptance for DISPLAY ▸ Import: real files through the real file
+ * Rendered acceptance for UTILITIES ▸ Import: real files through the real file
  * input and a real drop, parsed by Cesium in the page.
  *
  * Proves: GeoJSON, KML, KMZ (with a packed icon and ground overlay) and GPX
@@ -285,7 +285,7 @@ try {
   );
   const before = await state();
   check(
-    'Import is on the DISPLAY rail with an empty, hidden list',
+    'Import is in the UTILITIES panel with an empty, hidden list',
     before.rows === 0 &&
       !(await page.evaluate(() =>
         document
diff --git a/scripts/qa-segmented-controls.mjs b/scripts/qa-segmented-controls.mjs
index 8612c2f23..5f8bbbe6d 100644
--- a/scripts/qa-segmented-controls.mjs
+++ b/scripts/qa-segmented-controls.mjs
@@ -35,12 +35,14 @@ try {
       document.getElementById('loading-screen')?.classList.contains('hidden'),
     { timeout: 60000 },
   );
-  await page.evaluate(() =>
-    window.__godsEyeView.styleManager.setPanelCollapsed('pp-toggles', false, {
-      persist: false,
-      syncShare: false,
-    }),
-  );
+  // DISPLAY holds most segmented controls; Draw's shape group is in UTILITIES.
+  await page.evaluate(() => {
+    for (const panel of ['pp-toggles', 'utilities-panel'])
+      window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
+        persist: false,
+        syncShare: false,
+      });
+  });
 
   const surface = await page.evaluate(() => {
     const groups = [...document.querySelectorAll('[role="radiogroup"]')];
diff --git a/src/annotations/drawTool.js b/src/annotations/drawTool.js
index 9467406dd..b123c0695 100644
--- a/src/annotations/drawTool.js
+++ b/src/annotations/drawTool.js
@@ -1,7 +1,7 @@
 /**
  * Manual whiteboard drawing: the Cesium + DOM half.
  *
- * DISPLAY ▸ Draw turns the globe into a whiteboard you draw on by hand: pick a
+ * UTILITIES ▸ Draw turns the globe into a whiteboard you draw on by hand: pick a
  * shape (area, line or pin), click the vertices on the real world, double-click
  * or press Enter to finish, type a label. Each finished shape goes through the
  * SAME `annotationEngine.annotate()` the voice agent uses, with its geometry
diff --git a/src/annotations/drawTool.test.mjs b/src/annotations/drawTool.test.mjs
index 2ba88d3dd..c1a1b7681 100644
--- a/src/annotations/drawTool.test.mjs
+++ b/src/annotations/drawTool.test.mjs
@@ -138,12 +138,14 @@ test('nothing promises a GeoJSON export for drawn shapes', () => {
       `${file} still claims a GeoJSON export`,
     );
   }
-  for (const file of ['README.md', 'CHANGELOG.md', 'docs/CURRENT-STATE.md']) {
+  // Draw lives in UTILITIES; only the changelog's history still says DISPLAY.
+  for (const [file, heading] of [
+    ['README.md', 'UTILITIES ▸ **Draw**'],
+    ['CHANGELOG.md', 'DISPLAY ▸ Draw'],
+    ['docs/CURRENT-STATE.md', 'UTILITIES ▸ **Draw**'],
+  ]) {
     const source = read(file);
-    const start =
-      ['UTILITIES ▸ **Draw**', 'DISPLAY ▸ **Draw**', 'DISPLAY ▸ Draw']
-        .map((text) => source.indexOf(text))
-        .find((at) => at >= 0) ?? -1;
+    const start = source.indexOf(heading);
     assert.ok(start >= 0, `${file} should describe the Draw control`);
     const section = source.slice(start, start + 1200);
     assert.doesNotMatch(
diff --git a/src/app/tools.js b/src/app/tools.js
index 7aea39c22..b69a933bf 100644
--- a/src/app/tools.js
+++ b/src/app/tools.js
@@ -53,12 +53,12 @@ export function createApplicationTools({
     if (window.__gevAnnotations === annotations) delete window.__gevAnnotations;
     annotations.destroy();
   });
-  // DISPLAY ▸ Draw: the same whiteboard, drawn by hand. It claims the pointer
+  // UTILITIES ▸ Draw: the same whiteboard, drawn by hand. It claims the pointer
   // while a session is open, so its teardown belongs to the application
   // lifetime rather than to whoever last pressed the button.
   const drawTool = initDrawTool({ viewer, annotations });
   defer(() => drawTool?.destroy());
-  // DISPLAY ▸ Import: the person's own GeoJSON/KML/KMZ/GPX files, each its
+  // UTILITIES ▸ Import: the person's own GeoJSON/KML/KMZ/GPX files, each its
   // own data source. They live for the page session, so the application
   // lifetime removes them and the drop listeners on the viewer container.
   const geoFileImport = initGeoFileImport({
diff --git a/src/cockpitMarkup.test.mjs b/src/cockpitMarkup.test.mjs
index 0b376d9fc..051206053 100644
--- a/src/cockpitMarkup.test.mjs
+++ b/src/cockpitMarkup.test.mjs
@@ -680,6 +680,7 @@ test('fresh Cockpit entry temporarily collapses map panels and exit restores the
   for (const panelId of [
     'data-panel',
     'cctv-panel',
+    'utilities-panel',
     'scene-panel',
     'pp-toggles',
     'global-context-panel',
diff --git a/src/panelStackLayout.test.mjs b/src/panelStackLayout.test.mjs
index a13f5c04b..617609bad 100644
--- a/src/panelStackLayout.test.mjs
+++ b/src/panelStackLayout.test.mjs
@@ -294,3 +294,16 @@ test('expanded right panels highlight the title divider without changing collaps
     /#param-slider-panel:not\(\.collapsed\) \.param-panel-divider\s*\{[\s\S]*?linear-gradient\(\s*90deg,\s*rgb\(0 212 255 \/ 28%\),\s*rgba\(0, 212, 255, 0\.18\) 58%,\s*transparent\s*\);/,
   );
 });
+
+test('Utilities sits between Data Layers and Scenes and follows the left panels through every mode', () => {
+  const css = readStylesheet(new URL('../style.css', import.meta.url));
+  const order = (id) => Number(new RegExp(`#left-panel-stack > #${id} \\{\\s*order: (\\d+);`).exec(css)?.[1]);
+  assert.ok(order('data-panel') < order('utilities-panel'));
+  assert.ok(order('utilities-panel') < order('scene-panel'));
+  assert.match(css, /body\.ui-clean-view #utilities-panel,/);
+  assert.match(css, /body\.recording-mode #utilities-panel,/);
+  // Directions stays reachable in Cockpit; only Draw and Import step aside.
+  assert.match(css, /body\.cockpit-mode #utilities-panel \.utilities-tools \{\s*display: none !important;/);
+  assert.doesNotMatch(css, /body\.cockpit-mode #left-panel-stack > #utilities-panel[,\s{]/);
+  assert.match(css, /body\.mobile-shell\[data-mobile-sheet='layers'\]\s+#left-panel-stack\s+> #utilities-panel,/);
+});
diff --git a/src/ui/cyberTheme.test.mjs b/src/ui/cyberTheme.test.mjs
index 686ee9af2..569fbc11c 100644
--- a/src/ui/cyberTheme.test.mjs
+++ b/src/ui/cyberTheme.test.mjs
@@ -1,9 +1,4 @@
-import {
-  getScopeMaskFeather,
-  isScopeMaskEnabled,
-  setScopeMaskEnabled,
-  setScopeMaskFeather,
-} from '../scopeMask.js';
+import { getScopeMaskFeather, isScopeMaskEnabled, setScopeMaskEnabled, setScopeMaskFeather } from '../scopeMask.js';
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import test from 'node:test';
@@ -279,14 +274,8 @@ test('Display and voice HUD routes preserve explicit Cyber entry and exit author
 
 test('scope choice and expanded feather survive every HUD layout and both restore paths', async (t) => {
   const { owner } = styleOwner(t, 'tactical');
-  const previous = {
-    enabled: isScopeMaskEnabled(),
-    feather: getScopeMaskFeather(),
-  };
-  t.after(() => {
-    setScopeMaskEnabled(previous.enabled);
-    setScopeMaskFeather(previous.feather);
-  });
+  const previous = { enabled: isScopeMaskEnabled(), feather: getScopeMaskFeather() };
+  t.after(() => { setScopeMaskEnabled(previous.enabled); setScopeMaskFeather(previous.feather); });
   Object.assign(owner.services, { setScopeMaskEnabled, setScopeMaskFeather });
   owner._scopeBtn = { checked: true };
   owner._scopeFeatherSlider = { value: '11', disabled: false };
diff --git a/src/ui/geoFileImport.test.mjs b/src/ui/geoFileImport.test.mjs
index d78731af5..bc764ef48 100644
--- a/src/ui/geoFileImport.test.mjs
+++ b/src/ui/geoFileImport.test.mjs
@@ -1,4 +1,4 @@
-// Behavioral tests for DISPLAY ▸ Import: the controller is driven against
+// Behavioral tests for UTILITIES ▸ Import: the controller is driven against
 // fake DOM and viewer doubles with an injected loader, and its observable
 // effects are asserted — data sources added and removed, list rows, the hint,
 // drop handling, the file limit, and what destroy() gives back. Real parsing
diff --git a/src/ui/layerPanel.test.mjs b/src/ui/layerPanel.test.mjs
index bd90f0777..ddf3b884e 100644
--- a/src/ui/layerPanel.test.mjs
+++ b/src/ui/layerPanel.test.mjs
@@ -378,3 +378,112 @@ test('the Weather readout receives enabled air-quality alongside weather layers'
     ],
   );
 });
+
+// Directions renders in the Utilities panel's list; Data Layers keeps the rest.
+async function utilitiesFixture({ withUtilities = true } = {}) {
+  const { LayerPanel } = await import('./layerPanel.js');
+  const { railFixture } = await import('./railTestFixture.mjs');
+  const f = railFixture();
+  // Rows are looked up by layer id on refresh; a render clears with innerHTML.
+  const findable = (node) => {
+    Object.defineProperty(node, 'innerHTML', {
+      set(html) {
+        if (html === '') for (const child of [...node.children]) child.remove();
+      },
+    });
+    const querySelector = node.querySelector.bind(node);
+    node.querySelector = (selector) => {
+      const id = /^\[data-layer-id="(.+)"\]$/.exec(selector)?.[1];
+      return id
+        ? f.find((child) => child.dataset?.layerId === id, node)
+        : querySelector(selector);
+    };
+    return node;
+  };
+  findable(f.container);
+  const utilities = findable(f.document.createElement('div'));
+  f.document.getElementById = (id) =>
+    withUtilities && id === 'utilities-toggles' ? utilities : null;
+  const previousDocument = globalThis.document;
+  globalThis.document = f.document;
+  const layers = ['radio', 'directions', 'flights'].map((id) => ({
+    id,
+    name: id,
+    icon: '*',
+    source: 'S',
+    enabled: false,
+    showInTogglePanel: true,
+    stats: {},
+  }));
+  const panel = new LayerPanel({
+    getLayers: () => layers,
+    isEnabled: (id) => layers.find((layer) => layer.id === id).enabled,
+    setEnabled() {},
+    setLayerParams() {},
+    getRowControls: () => null,
+    hasRowControls: () => false,
+    subscribeRowControls: () => () => {},
+  });
+  panel.mount(f.container);
+  const headings = (root) =>
+    root.children
+      .filter((node) => node.tagName === 'H3')
+      .map((node) => node.textContent);
+  const rowIds = (root) =>
+    root.children
+      .filter((node) => node.dataset?.layerId)
+      .map((node) => node.dataset.layerId);
+  const restore = () => {
+    panel.destroy();
+    globalThis.document = previousDocument;
+  };
+  return { f, panel, utilities, layers, headings, rowIds, restore };
+}
+
+test('Directions renders in the Utilities list without a heading, and Radio under Audio', async () => {
+  const { f, panel, utilities, headings, rowIds, restore } =
+    await utilitiesFixture();
+  try {
+    assert.deepEqual(rowIds(utilities), ['directions']);
+    assert.deepEqual(headings(utilities), []);
+    assert.deepEqual(rowIds(f.container), ['flights', 'radio']);
+    assert.deepEqual(headings(f.container), ['Movement', 'Audio']);
+    panel.mount(f.container);
+    assert.deepEqual(
+      rowIds(utilities),
+      ['directions'],
+      'a remount replaces it',
+    );
+  } finally {
+    restore();
+  }
+});
+
+test('a refresh updates the Directions row in the Utilities list', async () => {
+  const { f, panel, utilities, layers, restore } = await utilitiesFixture();
+  try {
+    const row = f.find(
+      (node) => node.dataset?.layerId === 'directions',
+      utilities,
+    );
+    const toggle = row.querySelector('.data-toggle-btn');
+    assert.ok(!toggle.className.includes('active'));
+    layers.find(({ id }) => id === 'directions').enabled = true;
+    panel._refreshTogglePanel();
+    assert.ok(toggle.className.includes('active'));
+  } finally {
+    restore();
+  }
+});
+
+test('without the Utilities list, Directions stays in Data Layers under Utilities', async () => {
+  const { f, headings, rowIds, restore } = await utilitiesFixture({
+    withUtilities: false,
+  });
+  try {
+    assert.deepEqual(rowIds(f.container), ['flights', 'directions', 'radio']);
+    assert.deepEqual(headings(f.container), ['Movement', 'Utilities', 'Audio']);
+  } finally {
+    restore();
+  }
+});
diff --git a/src/ui/styles/cockpit.css b/src/ui/styles/cockpit.css
index 6736ae193..587f6c041 100644
--- a/src/ui/styles/cockpit.css
+++ b/src/ui/styles/cockpit.css
@@ -2007,10 +2007,14 @@ body.cockpit-mode #left-panel-stack {
   max-height: none;
   transition: none;
 }
-body.cockpit-mode #left-panel-stack > #utilities-panel,
 body.cockpit-mode #left-panel-stack > #scene-panel {
   display: none !important;
 }
+/* Directions stays reachable in Cockpit, as in Data Layers; Draw and Import
+   were never there (DISPLAY sits in the hidden right rail). */
+body.cockpit-mode #utilities-panel .utilities-tools {
+  display: none !important;
+}
 body.cockpit-mode #right-context-rail {
   display: none !important;
 }
diff --git a/src/ui/styles/controls.css b/src/ui/styles/controls.css
index 8279ef30c..15d8bb48d 100644
--- a/src/ui/styles/controls.css
+++ b/src/ui/styles/controls.css
@@ -750,7 +750,7 @@ html:not([lang='en']) .pp-slider-row > .pp-slider-mini-label {
   min-width: 0;
 }
 
-/* DISPLAY ▸ Draw: shape segment, label field, colour, and the one-line hint */
+/* UTILITIES ▸ Draw: shape segment, label field, colour, and the one-line hint */
 #draw-mode-row {
   min-width: 184px;
 }
@@ -801,7 +801,7 @@ body.gev-drawing #cesiumContainer canvas {
   cursor: crosshair;
 }
 
-/* DISPLAY ▸ Import: one row per imported file, and the drop-target outline */
+/* UTILITIES ▸ Import: one row per imported file, and the drop-target outline */
 .geo-import-list {
   display: none;
   flex-direction: column;
diff --git a/src/ui/styles/cyber.css b/src/ui/styles/cyber.css
index 715917b6e..64510af6c 100644
--- a/src/ui/styles/cyber.css
+++ b/src/ui/styles/cyber.css
@@ -519,6 +519,14 @@
   color: #f7f8f7;
 }
 
+:root[data-ui-theme='cyber']
+  #utilities-panel
+  .utilities-tools
+  .pp-toggle-btn:is([aria-pressed='true'], .active) {
+  background: rgba(64, 45, 46, 0.94);
+  box-shadow: 3px 0 0 var(--cyber-red) inset;
+}
+
 :root[data-ui-theme='cyber'] .pp-toggle-btn.active .pp-label {
   color: #f5f7f6;
 }
@@ -1662,9 +1670,7 @@
   :root[data-ui-theme='cyber']
     body:not(.cockpit-mode)
     #left-panel-stack:has(> [data-panel-id]:not(.collapsed))
-    > :is(#data-panel, #cctv-panel, #utilities-panel, #scene-panel):not(
-      .collapsed
-    ) {
+    > :is(#data-panel, #cctv-panel, #utilities-panel, #scene-panel):not(.collapsed) {
     flex: 1 1 auto;
     height: auto;
     max-height: none;
diff --git a/src/ui/styles/layers.css b/src/ui/styles/layers.css
index 2f4de3d18..a787c2b3d 100644
--- a/src/ui/styles/layers.css
+++ b/src/ui/styles/layers.css
@@ -1478,7 +1478,8 @@ body.recording-mode #right-context-rail > [data-panel-id] {
   color: var(--text-primary);
 }
 
-/* Draw reads as on with the accent of an enabled layer row. */
+/* Draw marks its on state with an accent edge, like an active DISPLAY
+   button; Cyber swaps in its red edge (cyber.css). */
 #utilities-panel
   .utilities-tools
   .pp-toggle-btn:is([aria-pressed='true'], .active) {
@@ -1493,6 +1494,18 @@ body.recording-mode #right-context-rail > [data-panel-id] {
   margin-right: 10px;
 }
 
-#utilities-panel.collapsed .utilities-tools {
-  display: none;
+/* Draw's options sit flat under its name, like a layer row's controls, not
+   as the card that hangs under a DISPLAY button. DISPLAY's shared label
+   column means nothing here, so the Shape label takes its own width. */
+#utilities-panel .utilities-tools .pp-slider-row {
+  padding: 4px 0;
+  background: none;
+  border: 0;
+  border-radius: 0;
+  backdrop-filter: none;
+  -webkit-backdrop-filter: none;
+}
+
+#utilities-panel .utilities-tools .pp-slider-mini-label {
+  min-width: 0;
 }
diff --git a/src/voice/gevActions.js b/src/voice/gevActions.js
index c67e1be16..0ee73ab9e 100644
--- a/src/voice/gevActions.js
+++ b/src/voice/gevActions.js
@@ -1046,15 +1046,18 @@ export function createGevActionRunner({
 
     if (name === 'show_data_layers_menu') {
       const layerId = normalizeLayerId(args.layerId || args.layer);
-      setPanelOpen(styleManager, 'data-panel', true);
-      const focusedLayer =
+      const row =
         layerId && dataManager.layers.has(layerId)
-          ? focusDataLayerRow(layerId)
+          ? findDataLayerRow(layerId)
           : null;
+      // Open the panel that holds the row: Directions lives in Utilities.
+      const panelId = row?.closest('[data-panel-id]')?.id || 'data-panel';
+      setPanelOpen(styleManager, panelId, true);
+      const focusedLayer = row ? focusDataLayerRow(row, layerId) : null;
       return {
         ok: true,
         action: 'show_data_layers_menu',
-        panelId: 'data-panel',
+        panelId,
         focusedLayer,
         layers: dataManager
           .getAll()
@@ -3190,12 +3193,14 @@ function normalizeCockpitAction(value) {
   return null;
 }
 
-function focusDataLayerRow(layerId) {
+function findDataLayerRow(layerId) {
   const selector = `[data-layer-id="${CSS.escape(layerId)}"]`;
-  const row = document.querySelector(
+  return document.querySelector(
     `#data-toggles ${selector}, #utilities-toggles ${selector}`,
   );
-  if (!row) return null;
+}
+
+function focusDataLayerRow(row, layerId) {
   row.scrollIntoView({ block: 'center', behavior: 'smooth' });
   row.classList.remove('gev-voice-focus');
   void row.offsetWidth;
diff --git a/src/voice/gevActions.test.mjs b/src/voice/gevActions.test.mjs
index 4a3a8ec72..1866b0b8a 100644
--- a/src/voice/gevActions.test.mjs
+++ b/src/voice/gevActions.test.mjs
@@ -743,6 +743,53 @@ test('Data Layers voice inventory hides the Context coordinator while current-vi
   assert.deepEqual(current.cockpit, { active: false, entryAllowed: true });
 });
 
+test('showing a layer opens the panel that holds its row: Directions lives in Utilities', async () => {
+  globalThis.window = globalThis.window || { clearTimeout, setTimeout, requestIdleCallback: null };
+  const previous = { document: globalThis.document, CSS: globalThis.CSS };
+  const focused = [];
+  const rowIn = (panelId) => ({
+    dataset: { layerName: panelId === 'utilities-panel' ? 'Directions' : 'Live Flights' },
+    classList: { add: (name) => focused.push(name), remove() {} },
+    scrollIntoView() {},
+    closest: (selector) => (selector === '[data-panel-id]' ? { id: panelId } : null),
+  });
+  const rows = { directions: rowIn('utilities-panel'), flights: rowIn('data-panel') };
+  globalThis.CSS = { escape: (value) => value };
+  globalThis.document = {
+    querySelector: (selector) => rows[/data-layer-id="([^"]+)"/.exec(selector)?.[1]] || null,
+  };
+  try {
+    const opened = [];
+    const layers = [
+      { id: 'flights', name: 'Live Flights', enabled: false, showInTogglePanel: true, stats: {} },
+      { id: 'directions', name: 'Directions', enabled: false, showInTogglePanel: true, stats: {} },
+    ];
+    const dataManager = {
+      layers: new Map(layers.map((layer) => [layer.id, { module: {} }])),
+      getAll: () => layers,
+    };
+    const styleManager = {
+      setPanelCollapsed: (panelId, collapsed) => opened.push([panelId, collapsed]),
+    };
+    const viewer = {
+      clock: { onTick: { addEventListener: () => () => {} } },
+      scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
+      camera: { moveEnd: { addEventListener() {} } },
+    };
+    const runner = createGevActionRunner({ viewer, styleManager, dataManager });
+    const directions = await runner('show_data_layers_menu', { layerId: 'directions' });
+    assert.equal(directions.panelId, 'utilities-panel');
+    assert.deepEqual(directions.focusedLayer, { id: 'directions', name: 'Directions' });
+    const flights = await runner('show_data_layers_menu', { layerId: 'flights' });
+    assert.equal(flights.panelId, 'data-panel');
+    assert.deepEqual(opened, [['utilities-panel', false], ['data-panel', false]]);
+    assert.deepEqual(focused, ['gev-voice-focus', 'gev-voice-focus']);
+  } finally {
+    globalThis.document = previous.document;
+    globalThis.CSS = previous.CSS;
+  }
+});
+
 test('generic layer visibility forwards cancellation and reports semantic failure', async () => {
   globalThis.window = globalThis.window || { clearTimeout, setTimeout, requestIdleCallback: null };
   const viewer = {

From 95ed686da5234690bf09acf193f93d0e083ac7f1 Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Thu, 29 Oct 2026 12:41:12 +0000
Subject: [PATCH 44/70] List drawn shapes under Draw, with icon shapes and
 colour swatches

Each shape drawn by hand gets a row under Draw, as Import's files do: its
colour swatch, its name, and show/hide, fly-to and remove. A shape is named
in its row, and its swatch opens the five colours there, so labelling and
colouring happen after a shape is drawn and can be seen, instead of in a
field filled in beforehand. Area, Line and Pin become icon buttons, named
for screen readers and tooltips, and the colour for the next shape is a row
of swatches instead of a dropdown.

The annotation engine gains per-mark remove, setHidden, restyle and frame,
and onChange so the list follows the board. A hidden mark stays on the board
at alpha 0, a renamed line keeps its length, and fly-to frames a line by its
whole path. Voice marks are not listed.

The Draw, form-field and segmented-control gates drive the new controls;
swatches are checked as chips, not segments.
---
 README.md                                  |   2 +-
 docs/CURRENT-STATE.md                      |   5 +-
 index.html                                 |   2 +-
 scripts/format-scope.json                  |   2 +
 scripts/package-boundaries.json            |   1 +
 scripts/qa-draw-tool.mjs                   |  88 +++++--
 scripts/qa-form-fields.mjs                 | 133 +++-------
 scripts/qa-segmented-controls.mjs          |  31 ++-
 src/annotations/annotationEngine.js        | 111 ++++++++
 src/annotations/annotationEngine.test.mjs  |  73 ++++++
 src/annotations/drawMarkList.js            | 259 +++++++++++++++++++
 src/annotations/drawMarkList.test.mjs      | 280 +++++++++++++++++++++
 src/annotations/drawTool.js                |  63 +++--
 src/annotations/drawTool.test.mjs          |  25 +-
 src/annotations/drawToolBehaviour.test.mjs |   3 +-
 src/i18n/locales/es.json                   |   9 +-
 src/i18n/locales/ru.json                   |   9 +-
 src/i18n/locales/zh-CN.json                |   9 +-
 src/i18n/locales/zh-Hant.json              |   9 +-
 src/ui/styles/controls.css                 | 125 +++++++--
 src/ui/styles/english-css-parity.test.mjs  |   2 -
 src/ui/styles/layers.css                   |   7 +-
 src/ui/templates/layer-panels.html         |  27 +-
 23 files changed, 1061 insertions(+), 214 deletions(-)
 create mode 100644 src/annotations/drawMarkList.js
 create mode 100644 src/annotations/drawMarkList.test.mjs

diff --git a/README.md b/README.md
index 2f47216a8..494fcda46 100644
--- a/README.md
+++ b/README.md
@@ -357,7 +357,7 @@ camera input stops rotation.
 
 > 🗣️ _"Outline the state of Texas."_ · _"Annotate the Texas State Capitol and its grounds"_ — it draws the **actual enclosing boundary**, not a circle. · _"How far is the Eiffel Tower from the Louvre?"_ — a connector arrow appears and it speaks the distance. Everything persists until you say _"clear the map."_
 
-**✍️ Or draw it yourself** — UTILITIES ▸ **Draw**: pick Area, Line or Pin, click the vertices on the real world, double-click to finish, label it. Same whiteboard, same persistence, no microphone needed.
+**✍️ Or draw it yourself** — UTILITIES ▸ **Draw**: pick Area, Line or Pin and a colour, click the vertices on the real world, double-click to finish, then name, recolour, hide or fly to each shape from its row. Same whiteboard, same persistence, no microphone needed.
 
 ![Zilker Park and Lady Bird Lake drawing onto the 3D city as persistent vector annotations, by voice](docs/media/01-voice-annotate-zilker.gif)
 
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 15c74e926..f32d50acb 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5412,7 +5412,8 @@ request viewbox and continues searching without that geographic preference.
 
 ### Manual Whiteboard Drawing (September 2026)
 
-- UTILITIES ▸ **Draw** turns the globe into a whiteboard drawn by hand. Pick a shape (Area, Line, Pin), click the vertices on the real world, type an optional label and pick a colour, and finish. **Keyboard contract, live only while Draw is on and never while you are typing in another field:** Enter finishes the shape (as does a double-click, and the two cannot both submit it — the session is replaced before the annotate call is awaited); Backspace removes the last vertex; Esc cancels the shape in progress, and a second Esc — Esc on an empty session — leaves draw mode. Typing in the label field keeps Backspace; Enter there also finishes. **Clear** wipes the board (the shape in progress and every placed mark), so removing marks does not require the console or the microphone.
+- UTILITIES ▸ **Draw** turns the globe into a whiteboard drawn by hand. Pick a shape (icon buttons for Area, Line and Pin) and a colour swatch for the next shape, click the vertices on the real world, and finish. **Keyboard contract, live only while Draw is on and never while you are typing in another field:** Enter finishes the shape (as does a double-click, and the two cannot both submit it — the session is replaced before the annotate call is awaited); Backspace removes the last vertex; Esc cancels the shape in progress, and a second Esc — Esc on an empty session — leaves draw mode. **Clear** wipes the board (the shape in progress and every placed mark), so removing marks does not require the console or the microphone.
+- **Drawn shapes are listed under Draw like Import's files** (`src/annotations/drawMarkList.js`): one row per hand-drawn mark (`manual: true`; voice marks are not listed) with its colour swatch, its name, and show/hide, fly-to and remove. The name is typed in the row (Enter or leaving the field saves it, Esc restores it and stays in the field); an unnamed shape shows its kind, and an unnamed line its length. The swatch opens the five colours in the row. The list reads the engine's board and redraws on `onChange`; it asks for changes through the engine's per-mark `remove`, `setHidden`, `frame` and `restyle`. A hidden mark stays on the board at alpha 0, so it keeps its place and comes back at once; `restyle` re-adds the mark with the new name or colour, and a renamed line keeps its length (`Name — 1.2 km`). Fly-to frames a line by its whole path, not its first point.
 - Runtime entry: `createApplicationTools` (`src/app/tools.js`, behind the `src/standalone/tools.js` shim) calls `initDrawTool({ viewer, annotations })` after `initAnnotations` and defers its `destroy()`, so disposing the shell returns every DOM listener, the Cesium handler, the preview data source, the borrowed click actions and the `window.__gevDrawTool` handle. Its markup lives in the UTILITIES panel's component template (`src/ui/templates/layer-panels.html`), assembled into `index.html` at build time. That handle (`setActive`, `setShape`, `addVertex(lon, lat)`, `finish`, `cancel`, `clearAll`, `diagnostics`) is the no-mouse test seam.
 - Contract: a finished shape is submitted through the SAME `annotationEngine.annotate()` the voice agent uses, with geometry supplied and `manual: true` (`type: area` + `ring`, `type: route` + `path`, `type: pin` + coordinates). `resolveSpec` short-circuits manual specs (`resolveManualSpec`) so no geocoder, Places or Overpass call is made. A drawn area is a real (not synthesized) outline and drapes solid; a drawn line is a `route` with `mode: 'manual'`, labelled with its length and never a travel time; a pin is a point. Drawn marks therefore render with the whiteboard look, persist, de-dup, appear in `.list()`, and clear with `clear_annotations` / `.clear()`.
 - **A vertex is a lon/lat, and the mark is DRAPED.** Clicks are picked through `pickWorldFromScreen` — one of two scene helpers the annotation resolver factory (`src/annotations/resolver.js`) exposes alongside `sampleGroundHeight`, so the app has ONE depth-aware pick cascade rather than a second written beside it — which returns the height the pick landed on as well as the coordinate, so the live preview hangs on the roof or hillside under the pointer instead of sinking to sea level. The world renderer draws areas and routes with `clampToGround`, so the height is dropped at finish in one place (`finishSpec`) rather than being carried downstream and discarded silently: what you get is the outline you drew, lying on the surface beneath it.
@@ -5424,7 +5425,7 @@ request viewbox and continues searching without that geographic preference.
 - Pointer ownership: while a session is open the tool holds the single pointer claim (`claimPointer('draw')`, `src/data/inputOwnership.js`) and **every** ambient scene selection handler — the shared tracking click gesture behind flights, military and CCTV, plus vessels, satellites, launches, fires, installations, bikeshare, radio, submarine cables, the bundled GeoJSON layers and the CCTV calibration gizmo — returns before picking. A vertex over an aircraft is a vertex, not a selection.
 - **The claim is a LEASE.** `claimPointer(owner)` returns an opaque token or `null`; `releasePointer(lease)` takes that token. A second claim fails even under the same owner name, because two live instances of one tool — an old one mid-teardown and its replacement — are two owners; releasing by name let the old instance free the claim its successor was holding, and every layer started selecting through the live session's vertices. A superseded lease now releases nothing.
 - **Cesium's own click actions are borrowed too.** The Viewer binds a selecting LEFT_CLICK and a tracking LEFT_DOUBLE_CLICK on its own handler, outside every layer and therefore outside the shared claim — guarding the layers alone still left a drawn vertex selecting the entity under it. Both are removed for the session and restored, as the same function objects, when it ends or the tool is destroyed.
-- **Enter belongs to whatever has the keyboard.** The finish key is taken only from the canvas, the page body and the tool's own label field. With a control focused — Clear, a shape button — Enter activates that control, as a keyboard user expects; it does not quietly finish the shape.
+- **Enter belongs to whatever has the keyboard.** The finish key is taken only from the canvas and the page body. With a control focused — Clear, a shape button — Enter activates that control, as a keyboard user expects; it does not quietly finish the shape.
 - Pure half: `src/annotations/drawMode.js` (session, minimum vertices, double-click de-dup at 0.5 m, vertex ceiling, degenerate-geometry refusal, ring closing, dateline-safe length/area/centroid, hint text). Regression surface: `src/annotations/drawMode.test.mjs` and `src/data/inputOwnership.test.mjs` (pure), `src/annotations/drawToolBehaviour.test.mjs` (the tool driven against DOM and viewer doubles — leases, borrowed input actions, teardown, the Enter key, preview heights), `src/annotations/drawTool.test.mjs` (structural: where files live, which ids the markup carries, what the docs may claim), and the rendered harness `scripts/qa-draw-tool.mjs`.
 - The annotation tree is a declared ownership group: `./annotations` → `src/annotations/index.js` in `package.json`, with its module graph listed in `scripts/package-boundaries.json`, so an annotation module reaching outside that graph is a gate failure rather than a surprise in a layer's bundle. `drawMode.js`, `drawTool.js` and their tests are in `scripts/format-scope.json`.
 
diff --git a/index.html b/index.html
index 26cf734fb..f8b73362d 100644
--- a/index.html
+++ b/index.html
@@ -26,7 +26,7 @@
        with the sources: src/materialSymbolsSubset.test.mjs fails when a source
        names a glyph this list is missing, because a missing glyph does not draw
        a box — the ligature never forms and the element renders the literal word. -->
-  <link href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20,400,0,0&icon_names=adjust,arrow_drop_down,arrow_forward,arrow_left,arrow_right,bolt,chevron_left,chevron_right,close,close_fullscreen,dark_mode,draw,east,flare,flight,layers,layers_clear,light_mode,local_fire_department,more_horiz,my_location,navigation,normal,on,open_in_full,public,radar,radio,right_panel_close,right_panel_open,rocket_launch,search,settings,skip_next,skip_previous,upload_file,videocam,view_in_ar,visibility,visibility_off" rel="stylesheet" />
+  <link href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20,400,0,0&icon_names=adjust,arrow_drop_down,arrow_forward,arrow_left,arrow_right,bolt,chevron_left,chevron_right,close,close_fullscreen,dark_mode,draw,east,flare,flight,layers,layers_clear,light_mode,local_fire_department,location_on,more_horiz,my_location,navigation,normal,on,open_in_full,pentagon,public,radar,radio,right_panel_close,right_panel_open,rocket_launch,search,settings,skip_next,skip_previous,timeline,upload_file,videocam,view_in_ar,visibility,visibility_off" rel="stylesheet" />
 </head>
 <body>
   <!-- gev:template scene-chrome -->
diff --git a/scripts/format-scope.json b/scripts/format-scope.json
index 5947f8811..10ecace71 100644
--- a/scripts/format-scope.json
+++ b/scripts/format-scope.json
@@ -29,6 +29,8 @@
   "src/data/localGeojsonCore.js",
   "src/data/localGeojsonLod.js",
   "src/data/inputOwnership.js",
+  "src/annotations/drawMarkList.js",
+  "src/annotations/drawMarkList.test.mjs",
   "src/annotations/drawMode.js",
   "src/annotations/drawMode.test.mjs",
   "src/annotations/drawTool.js",
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index 4b63663ce..7bcaa1e2d 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -2371,6 +2371,7 @@
       "src/layers/vessels/recordPolicy.js",
       "src/layers/vessels/snapshotRenderer.js",
       "src/data/inputOwnership.js",
+      "src/annotations/drawMarkList.js",
       "src/annotations/drawMode.js",
       "src/annotations/drawTool.js",
       "src/data/geoFileImport.js",
diff --git a/scripts/qa-draw-tool.mjs b/scripts/qa-draw-tool.mjs
index 8a9a01b0e..7e22dc072 100644
--- a/scripts/qa-draw-tool.mjs
+++ b/scripts/qa-draw-tool.mjs
@@ -300,8 +300,6 @@ try {
   // ── a pin, finished with Enter ──────────────────────────────────────────
   await page.click('#draw-toggle');
   await page.click('.pp-mode-btn[data-shape="pin"]');
-  await page.click('#draw-label-input');
-  await page.keyboard.type('Pin one');
   await clickWorld(520, 330);
   check(
     'the pointer is claimed while a session is open',
@@ -328,16 +326,9 @@ try {
     `${beforeBackspace} → ${afterBackspace}`,
   );
   await clickWorld(640, 500);
-  await page.click('#draw-label-input');
-  await page.keyboard.type('Market St');
   await page.keyboard.press('Enter');
-  check(
-    'a line finished from the label field lands on the board',
-    await waitForMarks(2),
-  );
-  const lineMark = (await marks()).find((mark) =>
-    mark.label?.startsWith('Market St'),
-  );
+  check('a line finished with Enter lands on the board', await waitForMarks(2));
+  const lineMark = (await marks()).find((mark) => mark.type === 'route');
   check(
     'a drawn line reports its length and never a travel time',
     Boolean(lineMark) &&
@@ -349,10 +340,8 @@ try {
 
   // ── an area, coloured and labelled, finished with a double-click ────────
   await page.click('.pp-mode-btn[data-shape="area"]');
-  await page.select('#draw-color-select', 'amber');
+  await page.click('.draw-color[data-color="amber"]');
   const amberBefore = await amberPixels();
-  await page.click('#draw-label-input');
-  await page.keyboard.type('Civic Center block');
   await clickWorld(400, 280);
   await clickWorld(700, 290);
   await clickWorld(720, 520);
@@ -375,14 +364,34 @@ try {
     afterDoubleClick === 3,
     `${afterDoubleClick} marks`,
   );
+  // ── each drawn shape gets a row: named, recoloured, hidden from there ──
+  const rowIds = () =>
+    page.evaluate(() =>
+      [...document.querySelectorAll('#draw-mark-list [data-mark-id]')].map(
+        (row) => row.dataset.markId,
+      ),
+    );
+  const ids = await rowIds();
+  check('every drawn shape has a row under Draw', ids.length === 3, ids);
+  const areaId = ids[2];
+  const rowControl = (id, control) =>
+    `#draw-mark-list [data-mark-id="${id}"] [data-control="${control}"]`;
+  await page.click(rowControl(areaId, 'name'));
+  await page.keyboard.type('Civic Center block');
+  await page.keyboard.press('Enter');
+  await wait(300);
   const areaMark = (await marks()).find(
     (mark) => mark.label === 'Civic Center block',
   );
   check(
-    'the label and colour chosen in the panel are what is drawn',
+    'the name typed in its row and the colour picked before drawing are what is drawn',
     areaMark?.color === 'amber',
     JSON.stringify(areaMark),
   );
+  check(
+    'naming a shape keeps Draw on and the shape in progress untouched',
+    (await drawState()).active === true,
+  );
   await wait(1200);
   const amberAfter = await amberPixels();
   check(
@@ -391,6 +400,49 @@ try {
     `${amberBefore} → ${amberAfter} amber pixels (+${amberAfter - amberBefore})`,
   );
   await shot('01-area-with-label');
+
+  // ── the row's own controls: recolour, hide and show, fly to ─────────────
+  const markState = (id) =>
+    page.evaluate((id) => {
+      const mark = window.__gevAnnotations.list().find((m) => m.id === id);
+      return (
+        mark && { color: mark.color, hidden: mark.hidden, alpha: mark.alpha }
+      );
+    }, id);
+  await page.click(rowControl(areaId, 'swatch'));
+  await page.click(rowControl(areaId, 'color-green'));
+  await wait(300);
+  check(
+    'a colour picked in the row recolours that shape',
+    (await markState(areaId))?.color === 'green',
+  );
+  await page.click(rowControl(areaId, 'toggle'));
+  await wait(600);
+  const hidden = await markState(areaId);
+  check(
+    'hiding a shape keeps it on the board but draws it at zero alpha',
+    hidden?.hidden === true && hidden.alpha === 0,
+    JSON.stringify(hidden),
+  );
+  await page.click(rowControl(areaId, 'toggle'));
+  await wait(600);
+  check(
+    'showing it again brings it straight back',
+    (await markState(areaId))?.alpha === 1,
+  );
+  const cameraAt = () =>
+    page.evaluate(() => {
+      const p = window.__godsEyeView.viewer.camera.positionWC;
+      return [p.x, p.y, p.z];
+    });
+  const beforeFly = await cameraAt();
+  await page.click(rowControl(ids[1], 'fly'));
+  await wait(2600);
+  const afterFly = await cameraAt();
+  check(
+    'fly to frames that shape',
+    Math.hypot(...afterFly.map((v, i) => v - beforeFly[i])) > 1,
+  );
   await shot('03-pins-and-shapes');
 
   // ── Escape cancels the shape, a second Escape leaves draw mode ──────────
@@ -421,6 +473,12 @@ try {
     afterSecondEscape.marks === 3,
     `${afterSecondEscape.marks} marks`,
   );
+  await page.click(rowControl(ids[0], 'remove'));
+  await waitForMarks(2);
+  check(
+    'remove in a row takes that one shape off the board and out of the list',
+    (await rowIds()).join() === ids.slice(1).join(),
+  );
 
   // ── a click that would select something selects nothing while drawing ───
   const target = await findClickableTarget();
diff --git a/scripts/qa-form-fields.mjs b/scripts/qa-form-fields.mjs
index 52cd059b7..c2d3af6e5 100644
--- a/scripts/qa-form-fields.mjs
+++ b/scripts/qa-form-fields.mjs
@@ -39,14 +39,13 @@ try {
       'scene-select',
       'cctv-camera-select',
       'hud-layout-select',
-      'draw-color-select',
       'radio-filter',
       'sdr-gain-select',
     ].map((id) => document.getElementById(id));
     return {
       ids: selects.map((node) => node.id),
       shared:
-        selects.length === 6 &&
+        selects.length === 5 &&
         selects.every((node) => node.classList.contains('gev-field')),
       native: selects.every(
         (node) =>
@@ -58,7 +57,7 @@ try {
     };
   });
   check(
-    'all six panel dropdowns retain native select semantics and shared surface',
+    'all five panel dropdowns retain native select semantics and shared surface',
     inventory.shared && inventory.native,
     inventory,
   );
@@ -275,76 +274,33 @@ try {
     await page.evaluate(() => window.__qaFormCalls.length === 2),
   );
 
-  // The left rail fits one tall panel at a time, so Scenes and Utilities
-  // take turns: each field is measured with its own panel open.
-  const LEFT_PANEL_FIELDS = [
-    [
-      'scene-panel',
-      ['scene-select', 'cctv-camera-select', 'hud-layout-select'],
-    ],
-    ['utilities-panel', ['draw-color-select']],
-  ];
-  const showLeftPanel = (open) =>
-    page.evaluate((open) => {
-      for (const panel of ['scene-panel', 'utilities-panel'])
-        window.__godsEyeView.styleManager.setPanelCollapsed(
-          panel,
-          panel !== open,
-          { persist: false, syncShare: false },
-        );
-    }, open);
-
   await page.evaluate(() => {
-    for (const panel of [
-      'pp-toggles',
-      'utilities-panel',
-      'scene-panel',
-      'cctv-panel',
-    ])
+    for (const panel of ['pp-toggles', 'scene-panel', 'cctv-panel'])
       window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
         persist: false,
         syncShare: false,
       });
   });
-  await showLeftPanel('utilities-panel');
-  if (
-    await page.$eval(
-      '#draw-toggle',
-      (node) => node.getAttribute('aria-pressed') !== 'true',
-    )
-  )
-    await page.click('#draw-toggle');
   for (const lang of ['en']) {
     await page.evaluate((lang) => {
       document.documentElement.lang = lang;
     }, lang);
     for (const width of [1440, 620, 390]) {
       await page.setViewport({ width, height: 900 });
-      const layout = [];
-      for (const [open, ids] of LEFT_PANEL_FIELDS) {
-        await showLeftPanel(open);
-        layout.push(
-          ...(await page.evaluate(
-            (ids) =>
-              ids.map((id) => {
-                const node = document.getElementById(id),
-                  rect = node.getBoundingClientRect(),
-                  panel = node
-                    .closest('.panel-collapsible')
-                    ?.getBoundingClientRect();
-                return {
-                  id,
-                  width: rect.width,
-                  fits:
-                    rect.width > 0 &&
-                    rect.width <= (panel?.width || innerWidth),
-                  radius: getComputedStyle(node).borderRadius,
-                };
-              }),
-            ids,
-          )),
-        );
-      }
+      const layout = await page.evaluate(() => {
+        const ids = ['scene-select', 'cctv-camera-select', 'hud-layout-select'];
+        return ids.map((id) => {
+          const node = document.getElementById(id),
+            rect = node.getBoundingClientRect(),
+            panel = node.closest('.panel-collapsible')?.getBoundingClientRect();
+          return {
+            id,
+            width: rect.width,
+            fits: rect.width > 0 && rect.width <= (panel?.width || innerWidth),
+            radius: getComputedStyle(node).borderRadius,
+          };
+        });
+      });
       check(
         `${lang} fields fit their panels at ${width}px`,
         layout.every((item) => item.fits),
@@ -386,7 +342,6 @@ try {
   );
   // Scene selection can restore application settings. Exercise it after the
   // fixture-owned CCTV phase so those asynchronous effects cannot replace ports.
-  await showLeftPanel('scene-panel');
   page.once('dialog', (dialog) => dialog.accept('Baseline selection fixture'));
   await page.click('#scene-new-btn');
   await page.waitForFunction(() =>
@@ -451,53 +406,35 @@ try {
     { timeout: 60000 },
   );
   await page.evaluate(() => {
-    for (const panel of [
-      'pp-toggles',
-      'utilities-panel',
-      'scene-panel',
-      'cctv-panel',
-    ])
+    for (const panel of ['pp-toggles', 'scene-panel', 'cctv-panel'])
       window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
         persist: false,
         syncShare: false,
       });
   });
   await page.evaluate(() => {
-    for (const panel of [
-      'pp-toggles',
-      'utilities-panel',
-      'scene-panel',
-      'cctv-panel',
-    ])
+    for (const panel of ['pp-toggles', 'scene-panel', 'cctv-panel'])
       window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
         persist: false,
         syncShare: false,
       });
   });
-  await showLeftPanel('utilities-panel');
-  if (
-    await page.$eval(
-      '#draw-toggle',
-      (node) => node.getAttribute('aria-pressed') !== 'true',
-    )
-  )
-    await page.click('#draw-toggle');
-  let translated = true;
-  for (const [open, ids] of LEFT_PANEL_FIELDS) {
-    await showLeftPanel(open);
-    translated &&= await page.evaluate((ids) => {
-      const nodes = ids.map((id) => document.getElementById(id));
-      return (
-        document.documentElement.lang === 'ru' &&
-        nodes.every(
-          (node) =>
-            node.clientWidth > 0 &&
-            node.getBoundingClientRect().width <=
-              node.closest('.panel-collapsible').getBoundingClientRect().width,
-        )
-      );
-    }, ids);
-  }
+  const translated = await page.evaluate(() => {
+    const nodes = [
+      'scene-select',
+      'cctv-camera-select',
+      'hud-layout-select',
+    ].map((id) => document.getElementById(id));
+    return (
+      document.documentElement.lang === 'ru' &&
+      nodes.every(
+        (node) =>
+          node.clientWidth > 0 &&
+          node.getBoundingClientRect().width <=
+            node.closest('.panel-collapsible').getBoundingClientRect().width,
+      )
+    );
+  });
   check('real Russian labels and fields fit at 390px', translated);
   await page.screenshot({ path: 'qa-shots/form-fields/ru-390.png' });
   check('no uncaught browser errors', errors.length === 0, errors);
diff --git a/scripts/qa-segmented-controls.mjs b/scripts/qa-segmented-controls.mjs
index 5f8bbbe6d..d60b574fd 100644
--- a/scripts/qa-segmented-controls.mjs
+++ b/scripts/qa-segmented-controls.mjs
@@ -45,7 +45,11 @@ try {
   });
 
   const surface = await page.evaluate(() => {
-    const groups = [...document.querySelectorAll('[role="radiogroup"]')];
+    // Colour swatches are one-of-many too, but chips, not segments: they are
+    // checked on their own below.
+    const groups = [
+      ...document.querySelectorAll('[role="radiogroup"]:not(.draw-colors)'),
+    ];
     const buttons = groups.flatMap((group) => [
       ...group.querySelectorAll('[role="radio"]'),
     ]);
@@ -71,6 +75,31 @@ try {
     JSON.stringify(surface),
   );
 
+  const swatches = await page.evaluate(() => {
+    const group = document.getElementById('draw-colors');
+    const chips = [...(group?.querySelectorAll('[role="radio"]') || [])];
+    return {
+      count: chips.length,
+      round: chips.every(
+        (chip) => getComputedStyle(chip).borderRadius === '50%',
+      ),
+      colours: new Set(
+        chips.map((chip) => getComputedStyle(chip).backgroundColor),
+      ).size,
+      checked: chips.filter(
+        (chip) => chip.getAttribute('aria-checked') === 'true',
+      ).length,
+    };
+  });
+  check(
+    "Draw's colour swatches are five round chips, one checked",
+    swatches.count === 5 &&
+      swatches.round &&
+      swatches.colours === 5 &&
+      swatches.checked === 1,
+    JSON.stringify(swatches),
+  );
+
   await page.evaluate(() =>
     document.getElementById('models3d-mode-all').click(),
   );
diff --git a/src/annotations/annotationEngine.js b/src/annotations/annotationEngine.js
index b0622579d..4125986ad 100644
--- a/src/annotations/annotationEngine.js
+++ b/src/annotations/annotationEngine.js
@@ -144,6 +144,17 @@ export function createAnnotationEngine({
   // task with the FINAL outcome — resolved or failed — so narration that said
   // "tracing the boundary now" can later honestly confirm or correct itself.
   const outlineListeners = new Set();
+  // Told whenever the set of marks, or one mark's look, changes (Draw's list).
+  const changeListeners = new Set();
+  const notifyChange = () => {
+    for (const listener of changeListeners) {
+      try {
+        listener();
+      } catch {
+        /* one listener's failure must not stop the others */
+      }
+    }
+  };
 
   function emitOutlineEvent(evt) {
     for (const listener of outlineListeners) {
@@ -219,6 +230,7 @@ export function createAnnotationEngine({
       const now = performance.now();
       let changed = false;
       let pending = false; // any mark still fading in / out, or with a TTL fade ahead
+      let expired = false;
       for (const anno of annotations.values()) {
         const next = computeAlpha(anno, now);
         if (next !== anno.alpha) {
@@ -229,6 +241,7 @@ export function createAnnotationEngine({
           annotations.delete(anno.id);
           renderer.remove(anno);
           changed = true;
+          expired = true;
           continue;
         }
         if (pendingAnimation(anno, now)) pending = true;
@@ -237,6 +250,7 @@ export function createAnnotationEngine({
         renderer.sync(annotations);
         syncAnnotationHold();
       }
+      if (expired) notifyChange();
       // Stop once the board is STABLE — persistent marks (persist=true is the default)
       // finish fading in after ~260ms and never change again, so without this the loop
       // would spin O(N) every frame forever. ensureTicking() restarts on the next
@@ -466,6 +480,7 @@ export function createAnnotationEngine({
     if (ids.length) {
       renderer.sync(annotations);
       ensureTicking();
+      notifyChange();
     }
     if (opts.flyTo && firstAnchor) frameAnnotation(firstAnchor);
     else if (ids.length) ensureMarksVisible(ids);
@@ -885,6 +900,11 @@ export function createAnnotationEngine({
       alpha: 0, // animate in
       bornAt: now,
       expiring: false,
+      // Drawn by hand (drawTool.js): listed under Draw, renamed and recoloured
+      // there. `name` is the person's own label, before any distance is added.
+      manual: spec?.manual === true,
+      name: spec?.manual === true ? cleanLabel(spec?.label) || null : null,
+      hidden: false,
     };
 
     if (type === 'route') {
@@ -970,6 +990,85 @@ export function createAnnotationEngine({
     annotations.clear();
     renderer.sync(annotations);
     syncAnnotationHold();
+    notifyChange();
+  }
+
+  /** Take one mark off the board at once. */
+  function remove(id) {
+    const anno = annotations.get(id);
+    if (!anno) return false;
+    annotations.delete(id);
+    renderer.remove(anno);
+    renderer.sync(annotations);
+    syncAnnotationHold();
+    notifyChange();
+    return true;
+  }
+
+  /** Hide or show one mark; a hidden mark stays on the board at alpha 0. */
+  function setHidden(id, hidden) {
+    const anno = annotations.get(id);
+    if (!anno) return false;
+    anno.hidden = Boolean(hidden);
+    // Skip the fade-in, so showing it again is immediate.
+    anno.bornAt = Math.min(anno.bornAt, performance.now() - 260);
+    ensureTicking();
+    notifyChange();
+    return true;
+  }
+
+  /**
+   * Rename or recolour a hand-drawn mark. The renderers build a mark's look
+   * when it is added, so the mark is added again with the new look.
+   */
+  function restyle(id, { name, color } = {}) {
+    const anno = annotations.get(id);
+    if (!anno?.manual) return false;
+    if (name !== undefined) {
+      anno.name = cleanLabel(name) || null;
+      anno.label =
+        anno.type === 'route'
+          ? composeRouteLabel(anno.name, anno.distanceM, null, 'manual', false)
+          : anno.name;
+    }
+    if (color !== undefined && COLORS.has(color)) anno.color = color;
+    renderer.remove(anno);
+    try {
+      renderer.add(anno);
+    } catch (error) {
+      rollbackRendererState(anno);
+      annotations.delete(id);
+      syncAnnotationHold();
+      notifyChange();
+      throw error;
+    }
+    renderer.sync(annotations);
+    ensureTicking();
+    notifyChange();
+    return true;
+  }
+
+  /** Fly the camera to one mark; a line is framed whole, not by its start. */
+  function frame(id) {
+    const anno = annotations.get(id);
+    if (!anno) return false;
+    if (anno.type === 'route' && anno.path?.length) {
+      const ring = anno.path.map((p) => [p.lon, p.lat]);
+      const lons = ring.map(([lon]) => lon);
+      const lats = ring.map(([, lat]) => lat);
+      frameAnnotation({
+        ...anno,
+        to: null,
+        ring,
+        polygons: null,
+        anchor: {
+          lon: (Math.min(...lons) + Math.max(...lons)) / 2,
+          lat: (Math.min(...lats) + Math.max(...lats)) / 2,
+          height: 0,
+        },
+      });
+    } else frameAnnotation(anno);
+    return true;
   }
 
   /** Begin a graceful fade-out of everything, then remove. */
@@ -1100,6 +1199,16 @@ export function createAnnotationEngine({
   const engine = {
     annotate,
     clear,
+    remove,
+    setHidden,
+    restyle,
+    frame,
+    /** Subscribe to board changes; returns an unsubscribe fn. */
+    onChange(listener) {
+      if (destroyed || typeof listener !== 'function') return () => {};
+      changeListeners.add(listener);
+      return () => changeListeners.delete(listener);
+    },
     destroy() {
       if (destroyed) return;
       destroyed = true;
@@ -1109,6 +1218,7 @@ export function createAnnotationEngine({
         if (tickHandle != null) cancelAnimationFrame(tickHandle);
         tickHandle = null;
         outlineListeners.clear();
+        changeListeners.clear();
         releaseContinuousRender('annotations');
         renderer.destroy();
       }
@@ -1364,6 +1474,7 @@ function normalizeType(type) {
 }
 
 function computeAlpha(anno, now) {
+  if (anno.hidden) return 0;
   const inT = (now - anno.bornAt) / 260;
   const fadeIn = inT >= 1 ? 1 : Math.max(0, inT);
 
diff --git a/src/annotations/annotationEngine.test.mjs b/src/annotations/annotationEngine.test.mjs
index 5f39a077a..6e435fcd4 100644
--- a/src/annotations/annotationEngine.test.mjs
+++ b/src/annotations/annotationEngine.test.mjs
@@ -730,3 +730,76 @@ test('only an explicit navigation request permits resolving distant annotation t
   assert.deepEqual(received.map(options => options.allowDistant), [false, true]);
   engine.destroy();
 });
+
+// Draw's list works one hand-drawn mark at a time: hide, rename, recolour,
+// frame and remove it, and hear about every change to the board.
+test('hand-drawn marks: one mark can be hidden, renamed, recoloured, framed and removed', async (t) => {
+  installAnimationFrameStubs(t);
+  _resetRenderGovernorForTest();
+  t.after(() => _resetRenderGovernorForTest());
+  const { renderer, calls } = fakeRenderer();
+  const flights = [];
+  const engine = createAnnotationEngine({
+    viewer: { camera: { heading: 0, flyToBoundingSphere: (sphere) => flights.push(sphere) } },
+    renderer,
+  });
+  let changes = 0;
+  const unsubscribe = engine.onChange(() => { changes += 1; });
+
+  const drawn = await engine.annotate([
+    { type: 'route', manual: true, path: [[-97.75, 30.26], [-97.73, 30.27]], label: '' },
+    { type: 'pin', manual: true, latitude: 30.27, longitude: -97.74, label: 'Camp', color: 'amber' },
+  ], { persist: true });
+  assert.equal(drawn.drawn, 2);
+  assert.equal(changes, 1, 'one annotate, one change');
+  const [line, pin] = engine.list();
+  assert.equal(line.manual, true);
+  assert.equal(line.name, null);
+  assert.match(line.label, /km|m$/, 'an unnamed line is labelled by its length');
+  assert.equal(pin.name, 'Camp');
+
+  assert.equal(engine.setHidden(pin.id, true), true);
+  assert.equal(pin.hidden, true);
+  assert.equal(changes, 2);
+
+  const addsBefore = calls.add;
+  assert.equal(engine.restyle(line.id, { name: 'Ridge walk', color: 'green' }), true);
+  assert.equal(line.name, 'Ridge walk');
+  assert.match(line.label, /^Ridge walk — /, 'a renamed line keeps its length');
+  assert.equal(line.color, 'green');
+  assert.equal(calls.add, addsBefore + 1, 'the new look is drawn again');
+  assert.equal(engine.restyle(line.id, { color: 'not-a-colour' }), true);
+  assert.equal(line.color, 'green', 'an unknown colour is ignored');
+
+  assert.equal(engine.frame(line.id), true);
+  assert.equal(flights.length, 1);
+  assert.equal(engine.frame('anno-missing'), false);
+
+  assert.equal(engine.remove(pin.id), true);
+  assert.deepEqual(engine.list().map(({ id }) => id), [line.id]);
+  assert.equal(engine.remove(pin.id), false);
+
+  engine.clear();
+  assert.equal(engine.list().length, 0);
+  const seen = changes;
+  unsubscribe();
+  await engine.annotate([{ type: 'pin', manual: true, latitude: 1, longitude: 1 }], { persist: true });
+  assert.equal(changes, seen, 'an unsubscribed listener hears nothing');
+});
+
+test('hand-drawn marks: only a manual mark can be restyled', async (t) => {
+  installAnimationFrameStubs(t);
+  _resetRenderGovernorForTest();
+  t.after(() => _resetRenderGovernorForTest());
+  const { renderer } = fakeRenderer();
+  const engine = createAnnotationEngine({
+    viewer: {},
+    renderer,
+    resolveTarget: async () => ({ ...FIXED_POINT }),
+  });
+  await engine.annotate([{ type: 'point', target: 'Texas Capitol', label: 'Capitol' }]);
+  const [voiceMark] = engine.list();
+  assert.equal(voiceMark.manual, false);
+  assert.equal(engine.restyle(voiceMark.id, { name: 'Renamed' }), false);
+  assert.equal(voiceMark.label, 'Capitol');
+});
diff --git a/src/annotations/drawMarkList.js b/src/annotations/drawMarkList.js
new file mode 100644
index 000000000..dc6c24a72
--- /dev/null
+++ b/src/annotations/drawMarkList.js
@@ -0,0 +1,259 @@
+/**
+ * The shapes drawn by hand, listed under Draw the way Import lists its files:
+ * one row per shape with its colour, its name, and show/hide, fly-to and
+ * remove. The name is edited in place and the colour picked from the row, so
+ * a shape is labelled and coloured after it is drawn, when it can be seen.
+ *
+ * The board is the annotation engine's: this list only reads `list()`, asks
+ * for changes through `remove`, `setHidden`, `frame` and `restyle`, and
+ * re-renders on `onChange`. Voice marks are not listed; only `manual` ones.
+ */
+import { msg, t } from '../i18n/index.js';
+
+export const DRAW_COLORS = Object.freeze([
+  'primary',
+  'amber',
+  'cyan',
+  'green',
+  'red',
+]);
+/** The swatch for each colour, matching the preview and the drawn shape. */
+export const DRAW_COLOR_CSS = Object.freeze({
+  primary: '#8be9ff',
+  amber: '#ffb547',
+  cyan: '#39d0ff',
+  green: '#5dff9f',
+  red: '#ff6b6b',
+});
+const COLOR_NAMES = Object.freeze({
+  primary: msg('Primary'),
+  amber: msg('Amber'),
+  cyan: msg('Cyan'),
+  green: msg('Green'),
+  red: msg('Red'),
+});
+const SHAPE_NAMES = Object.freeze({
+  area: msg('Area'),
+  route: msg('Line'),
+  pin: msg('Pin'),
+});
+
+/** What a row calls a shape that has no name of its own. */
+export function drawMarkFallbackName(mark) {
+  const shape = t(SHAPE_NAMES[mark?.type] || SHAPE_NAMES.pin);
+  // An unnamed line's label is its length; keep it, it is the useful part.
+  return mark?.type === 'route' && !mark.name && mark.label
+    ? `${shape} · ${mark.label}`
+    : shape;
+}
+
+/**
+ * @param {{
+ *   listEl: HTMLElement,
+ *   annotations: {list: Function, remove: Function, setHidden: Function,
+ *     frame: Function, restyle: Function, onChange?: Function},
+ *   listen: (target: EventTarget, type: string, listener: Function, options?: object) => void,
+ * }} deps
+ * @returns {{render: Function, marks: Function, destroy: Function}}
+ */
+export function createDrawMarkList({ listEl, annotations, listen }) {
+  const doc = listEl.ownerDocument;
+  let destroyed = false;
+  let picking = null; // the id whose colour picker is open
+
+  const marks = () =>
+    (annotations.list?.() || []).filter((mark) => mark?.manual === true);
+  const find = (id) => marks().find((mark) => mark.id === id) || null;
+
+  /** Which row control has focus, so a re-render can give it back. */
+  function focusedControl() {
+    const active = doc.activeElement;
+    if (!active || !listEl.contains?.(active)) return null;
+    const row = active.closest?.('[data-mark-id]');
+    return row
+      ? { id: row.dataset.markId, control: active.dataset?.control }
+      : null;
+  }
+
+  function restoreFocus(was) {
+    if (!was) return;
+    const row = [...listEl.querySelectorAll('[data-mark-id]')].find(
+      (node) => node.dataset.markId === was.id,
+    );
+    row?.querySelector?.(`[data-control="${was.control}"]`)?.focus?.();
+  }
+
+  function actionButton(icon, label, control) {
+    const button = doc.createElement('button');
+    button.type = 'button';
+    button.className = 'geo-import-action';
+    button.dataset.control = control;
+    button.title = label;
+    button.setAttribute('aria-label', label);
+    const glyph = doc.createElement('span');
+    glyph.className = 'material-symbols-outlined';
+    glyph.setAttribute('aria-hidden', 'true');
+    glyph.textContent = icon;
+    button.append(glyph);
+    return button;
+  }
+
+  function colorPicker(mark) {
+    const picker = doc.createElement('div');
+    picker.className = 'draw-colors draw-mark-colors';
+    picker.setAttribute('role', 'radiogroup');
+    picker.setAttribute(
+      'aria-label',
+      t('Colour of {name}', { name: label(mark) }),
+    );
+    for (const color of DRAW_COLORS) {
+      const swatch = doc.createElement('button');
+      swatch.type = 'button';
+      swatch.className = `draw-color${color === mark.color ? ' active' : ''}`;
+      swatch.dataset.color = color;
+      swatch.dataset.control = `color-${color}`;
+      swatch.setAttribute('role', 'radio');
+      swatch.setAttribute('aria-checked', String(color === mark.color));
+      const name = t(COLOR_NAMES[color]);
+      swatch.title = name;
+      swatch.setAttribute('aria-label', name);
+      picker.append(swatch);
+    }
+    return picker;
+  }
+
+  const label = (mark) => mark.name || drawMarkFallbackName(mark);
+
+  function render() {
+    if (destroyed) return;
+    const keep = focusedControl();
+    const list = marks();
+    if (picking && !list.some((mark) => mark.id === picking)) picking = null;
+    listEl.replaceChildren(
+      ...list.map((mark) => {
+        const row = doc.createElement('li');
+        row.className = 'geo-import-row draw-mark-row';
+        row.dataset.markId = mark.id;
+        if (mark.hidden) row.classList.add('hidden-mark');
+
+        const swatch = doc.createElement('button');
+        swatch.type = 'button';
+        swatch.className = 'geo-import-swatch draw-mark-swatch';
+        swatch.dataset.control = 'swatch';
+        swatch.style.background = DRAW_COLOR_CSS[mark.color] || '';
+        const swatchLabel = t('Change the colour of {name}', {
+          name: label(mark),
+        });
+        swatch.title = swatchLabel;
+        swatch.setAttribute('aria-label', swatchLabel);
+        swatch.setAttribute('aria-expanded', String(picking === mark.id));
+
+        // textContent and value only, never markup: the name is typed text.
+        const name = doc.createElement('input');
+        name.type = 'text';
+        name.className = 'geo-import-name draw-mark-name';
+        name.dataset.control = 'name';
+        name.maxLength = 120;
+        name.autocomplete = 'off';
+        name.spellcheck = false;
+        name.value = mark.name || '';
+        name.placeholder = drawMarkFallbackName(mark);
+        name.setAttribute(
+          'aria-label',
+          t('Name of {name}', { name: label(mark) }),
+        );
+
+        const visible = !mark.hidden;
+        const toggle = actionButton(
+          visible ? 'visibility' : 'visibility_off',
+          visible
+            ? t('Hide {name}', { name: label(mark) })
+            : t('Show {name}', { name: label(mark) }),
+          'toggle',
+        );
+        toggle.setAttribute('aria-pressed', String(visible));
+        row.append(
+          swatch,
+          name,
+          toggle,
+          actionButton(
+            'my_location',
+            t('Fly to {name}', { name: label(mark) }),
+            'fly',
+          ),
+          actionButton(
+            'close',
+            t('Remove {name}', { name: label(mark) }),
+            'remove',
+          ),
+        );
+        if (picking === mark.id) row.append(colorPicker(mark));
+        return row;
+      }),
+    );
+    listEl.classList.toggle('visible', list.length > 0);
+    restoreFocus(keep);
+  }
+
+  const rowId = (node) => node?.closest?.('[data-mark-id]')?.dataset.markId;
+
+  /** Commit a typed name; an unchanged one costs nothing. */
+  function commitName(input) {
+    const id = rowId(input);
+    const mark = id && find(id);
+    if (!mark) return;
+    const next = input.value.trim();
+    if (next === (mark.name || '')) return;
+    annotations.restyle(id, { name: next });
+  }
+
+  listen(listEl, 'click', (event) => {
+    const control = event.target?.closest?.('[data-control]');
+    const id = rowId(control);
+    if (!control || !id) return;
+    const kind = control.dataset.control;
+    if (kind === 'swatch') {
+      picking = picking === id ? null : id;
+      render();
+    } else if (kind.startsWith('color-')) {
+      picking = null;
+      annotations.restyle(id, { color: control.dataset.color });
+      render();
+    } else if (kind === 'toggle') annotations.setHidden(id, !find(id)?.hidden);
+    else if (kind === 'fly') annotations.frame(id);
+    else if (kind === 'remove') annotations.remove(id);
+  });
+  listen(listEl, 'keydown', (event) => {
+    const input = event.target;
+    if (input?.dataset?.control !== 'name') return;
+    if (event.key === 'Enter') {
+      event.preventDefault();
+      commitName(input);
+      input.blur?.();
+    } else if (event.key === 'Escape') {
+      // Escape undoes the edit; it must not also leave Draw or cancel a shape.
+      event.preventDefault();
+      event.stopPropagation();
+      input.value = find(rowId(input))?.name || '';
+      input.blur?.();
+    }
+  });
+  listen(listEl, 'focusout', (event) => {
+    if (event.target?.dataset?.control === 'name') commitName(event.target);
+  });
+
+  const unsubscribe = annotations.onChange?.(render) || (() => {});
+  render();
+
+  return {
+    render,
+    marks,
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      unsubscribe();
+      listEl.replaceChildren();
+      listEl.classList.remove('visible');
+    },
+  };
+}
diff --git a/src/annotations/drawMarkList.test.mjs b/src/annotations/drawMarkList.test.mjs
new file mode 100644
index 000000000..fb7567e60
--- /dev/null
+++ b/src/annotations/drawMarkList.test.mjs
@@ -0,0 +1,280 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createDrawMarkList, drawMarkFallbackName } from './drawMarkList.js';
+
+/** Just enough DOM for the list: rows, inputs, buttons, attributes, focus. */
+function fakeDocument() {
+  const doc = { activeElement: null };
+  const matches = (node, selector) => {
+    const attr = /^\[data-([a-z-]+)(?:="([^"]*)")?\]$/.exec(selector);
+    if (!attr) return false;
+    const key = attr[1].replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    return attr[2] === undefined
+      ? node.dataset[key] !== undefined
+      : node.dataset[key] === attr[2];
+  };
+  doc.createElement = (tag) => {
+    const classes = new Set();
+    const node = {
+      tagName: tag.toUpperCase(),
+      ownerDocument: doc,
+      parent: null,
+      children: [],
+      dataset: {},
+      style: {},
+      attributes: new Map(),
+      value: '',
+      placeholder: '',
+      title: '',
+      textContent: '',
+      classList: {
+        add: (name) => classes.add(name),
+        remove: (name) => classes.delete(name),
+        contains: (name) => classes.has(name),
+        toggle: (name, on) => (on ? classes.add(name) : classes.delete(name)),
+      },
+      set className(value) {
+        classes.clear();
+        for (const name of String(value).split(/\s+/).filter(Boolean))
+          classes.add(name);
+      },
+      get className() {
+        return [...classes].join(' ');
+      },
+      setAttribute(key, value) {
+        this.attributes.set(key, String(value));
+      },
+      getAttribute(key) {
+        return this.attributes.get(key) ?? null;
+      },
+      append(...nodes) {
+        for (const child of nodes) {
+          child.parent = this;
+          this.children.push(child);
+        }
+      },
+      replaceChildren(...nodes) {
+        this.children = [];
+        this.append(...nodes);
+      },
+      closest(selector) {
+        let node = this;
+        while (node && !matches(node, selector)) node = node.parent;
+        return node || null;
+      },
+      querySelectorAll(selector) {
+        const found = [];
+        const walk = (node) => {
+          for (const child of node.children) {
+            if (matches(child, selector)) found.push(child);
+            walk(child);
+          }
+        };
+        walk(this);
+        return found;
+      },
+      querySelector(selector) {
+        return this.querySelectorAll(selector)[0] || null;
+      },
+      contains(other) {
+        for (let node = other; node; node = node.parent)
+          if (node === this) return true;
+        return false;
+      },
+      focus() {
+        doc.activeElement = this;
+      },
+      blur() {
+        if (doc.activeElement === this) doc.activeElement = null;
+      },
+    };
+    return node;
+  };
+  return doc;
+}
+
+function harness(initial) {
+  const doc = fakeDocument();
+  const listEl = doc.createElement('ul');
+  const listeners = {};
+  const listen = (target, type, listener) => {
+    listeners[type] = listener;
+  };
+  let marks = initial.map((mark) => ({ hidden: false, ...mark }));
+  const changeListeners = new Set();
+  const changed = () => changeListeners.forEach((listener) => listener());
+  const calls = [];
+  const annotations = {
+    list: () => marks,
+    onChange: (listener) => {
+      changeListeners.add(listener);
+      return () => changeListeners.delete(listener);
+    },
+    remove(id) {
+      calls.push(['remove', id]);
+      marks = marks.filter((mark) => mark.id !== id);
+      changed();
+    },
+    setHidden(id, hidden) {
+      calls.push(['hide', id, hidden]);
+      marks.find((mark) => mark.id === id).hidden = hidden;
+      changed();
+    },
+    frame(id) {
+      calls.push(['frame', id]);
+    },
+    restyle(id, change) {
+      calls.push(['restyle', id, change]);
+      Object.assign(
+        marks.find((mark) => mark.id === id),
+        change,
+      );
+      changed();
+    },
+  };
+  const list = createDrawMarkList({ listEl, annotations, listen });
+  const rows = () => listEl.children;
+  const control = (row, name) => row.querySelector(`[data-control="${name}"]`);
+  const click = (target) => listeners.click({ target });
+  return { list, listEl, listeners, rows, control, click, calls, changed };
+}
+
+const LINE = {
+  id: 'a1',
+  type: 'route',
+  manual: true,
+  name: null,
+  label: '1.2 km',
+  color: 'primary',
+};
+const PIN = {
+  id: 'a2',
+  type: 'pin',
+  manual: true,
+  name: 'Camp',
+  label: 'Camp',
+  color: 'amber',
+};
+const VOICE = {
+  id: 'a3',
+  type: 'area',
+  manual: false,
+  label: 'Texas',
+  color: 'primary',
+};
+
+test('lists only hand-drawn marks, named or by shape, with Import-style actions', () => {
+  const { rows, control, listEl } = harness([LINE, PIN, VOICE]);
+  assert.deepEqual(
+    rows().map((row) => row.dataset.markId),
+    ['a1', 'a2'],
+  );
+  assert.ok(listEl.classList.contains('visible'));
+  const [line, pin] = rows();
+  assert.equal(control(line, 'name').value, '');
+  assert.equal(control(line, 'name').placeholder, 'Line · 1.2 km');
+  assert.equal(control(pin, 'name').value, 'Camp');
+  assert.equal(control(pin, 'swatch').style.background, '#ffb547');
+  assert.equal(control(pin, 'toggle').getAttribute('aria-pressed'), 'true');
+  assert.equal(control(pin, 'fly').getAttribute('aria-label'), 'Fly to Camp');
+  assert.equal(
+    control(pin, 'remove').getAttribute('aria-label'),
+    'Remove Camp',
+  );
+});
+
+test('show/hide, fly to and remove act on that one mark', () => {
+  const { rows, control, click, calls } = harness([LINE, PIN]);
+  click(control(rows()[1], 'toggle'));
+  assert.deepEqual(calls.at(-1), ['hide', 'a2', true]);
+  assert.equal(
+    control(rows()[1], 'toggle').getAttribute('aria-pressed'),
+    'false',
+  );
+  assert.ok(rows()[1].classList.contains('hidden-mark'));
+  click(control(rows()[0], 'fly'));
+  assert.deepEqual(calls.at(-1), ['frame', 'a1']);
+  click(control(rows()[0], 'remove'));
+  assert.deepEqual(calls.at(-1), ['remove', 'a1']);
+  assert.deepEqual(
+    rows().map((row) => row.dataset.markId),
+    ['a2'],
+  );
+});
+
+test('the swatch opens a colour picker in the row; a colour restyles the mark', () => {
+  const { rows, control, click, calls } = harness([LINE]);
+  click(control(rows()[0], 'swatch'));
+  assert.equal(
+    control(rows()[0], 'swatch').getAttribute('aria-expanded'),
+    'true',
+  );
+  const red = control(rows()[0], 'color-red');
+  assert.ok(red, 'the picker offers every colour');
+  click(red);
+  assert.deepEqual(calls.at(-1), ['restyle', 'a1', { color: 'red' }]);
+  assert.equal(
+    control(rows()[0], 'color-red'),
+    null,
+    'choosing closes the picker',
+  );
+  assert.equal(control(rows()[0], 'swatch').style.background, '#ff6b6b');
+});
+
+test('a name is committed on Enter or blur, and Escape undoes the edit without leaving Draw', () => {
+  const { rows, control, listeners, calls } = harness([LINE, PIN]);
+  const name = control(rows()[0], 'name');
+  name.value = '  Ridge walk ';
+  listeners.keydown({ key: 'Enter', target: name, preventDefault() {} });
+  assert.deepEqual(calls.at(-1), ['restyle', 'a1', { name: 'Ridge walk' }]);
+
+  const pinName = control(rows()[1], 'name');
+  pinName.value = 'Base';
+  let stopped = false;
+  listeners.keydown({
+    key: 'Escape',
+    target: pinName,
+    preventDefault() {},
+    stopPropagation() {
+      stopped = true;
+    },
+  });
+  assert.equal(pinName.value, 'Camp', 'Escape restores the name');
+  assert.ok(stopped, 'Escape stays in the field');
+
+  const count = calls.length;
+  listeners.focusout({ target: control(rows()[1], 'name') });
+  assert.equal(calls.length, count, 'an unchanged name costs nothing');
+  control(rows()[1], 'name').value = 'Base';
+  listeners.focusout({ target: control(rows()[1], 'name') });
+  assert.deepEqual(calls.at(-1), ['restyle', 'a2', { name: 'Base' }]);
+});
+
+test('a re-render keeps focus on the same control, and destroy stops listening', () => {
+  const { rows, control, list, listEl, changed } = harness([LINE]);
+  control(rows()[0], 'fly').focus();
+  changed();
+  assert.equal(listEl.ownerDocument.activeElement, control(rows()[0], 'fly'));
+  list.destroy();
+  assert.equal(rows().length, 0);
+  assert.ok(!listEl.classList.contains('visible'));
+  changed();
+  assert.equal(rows().length, 0, 'a destroyed list does not re-render');
+});
+
+test('an unnamed shape is called by its kind', () => {
+  assert.equal(drawMarkFallbackName({ type: 'area' }), 'Area');
+  assert.equal(drawMarkFallbackName({ type: 'pin' }), 'Pin');
+  assert.equal(
+    drawMarkFallbackName({ type: 'route', label: '300 m' }),
+    'Line · 300 m',
+  );
+  assert.equal(
+    drawMarkFallbackName({
+      type: 'route',
+      name: 'Walk',
+      label: 'Walk — 300 m',
+    }),
+    'Line',
+  );
+});
diff --git a/src/annotations/drawTool.js b/src/annotations/drawTool.js
index b123c0695..c352f26e8 100644
--- a/src/annotations/drawTool.js
+++ b/src/annotations/drawTool.js
@@ -3,7 +3,8 @@
  *
  * UTILITIES ▸ Draw turns the globe into a whiteboard you draw on by hand: pick a
  * shape (area, line or pin), click the vertices on the real world, double-click
- * or press Enter to finish, type a label. Each finished shape goes through the
+ * or press Enter to finish, then name and colour it in its row. Each finished
+ * shape goes through the
  * SAME `annotationEngine.annotate()` the voice agent uses, with its geometry
  * supplied and `manual: true`, so it renders with the whiteboard look,
  * persists, de-dups, shows up in `.list()`, and clears with the board.
@@ -50,19 +51,18 @@ import {
   removeLastVertex,
 } from './drawMode.js';
 
+import {
+  DRAW_COLORS,
+  DRAW_COLOR_CSS,
+  createDrawMarkList,
+} from './drawMarkList.js';
+
 import { msg, registerUnsavedWork, t, translateKnown } from '../i18n/index.js';
 /** The id this tool claims the pointer under. */
 const DRAW_POINTER_OWNER = 'draw';
 const PREVIEW_DATA_SOURCE_NAME = 'gev-draw-preview';
 
-const COLORS = ['primary', 'amber', 'cyan', 'green', 'red'];
-const PREVIEW = {
-  primary: '#8be9ff',
-  amber: '#ffb547',
-  cyan: '#39d0ff',
-  green: '#5dff9f',
-  red: '#ff6b6b',
-};
+const PREVIEW = DRAW_COLOR_CSS;
 
 /**
  * Wire the Draw control. Returns a handle with a `destroy()` the application
@@ -74,8 +74,8 @@ export function initDrawTool({ viewer, annotations }) {
   const toggle = document.getElementById('draw-toggle');
   const modeRow = document.getElementById('draw-mode-row');
   const labelRow = document.getElementById('draw-label-row');
-  const labelInput = document.getElementById('draw-label-input');
-  const colorSelect = document.getElementById('draw-color-select');
+  const colorRow = document.getElementById('draw-colors');
+  const markListEl = document.getElementById('draw-mark-list');
   const clearButton = document.getElementById('draw-clear');
   const hint = document.getElementById('draw-hint');
   if (!viewer || !annotations || !toggle) return null;
@@ -238,14 +238,14 @@ export function initDrawTool({ viewer, annotations }) {
       if (reason !== 'too-few') setHint(drawHint(session));
       return null;
     }
-    const spec = finishSpec(session, { label: labelInput?.value || '', color });
+    // Named afterwards, in the shape's row.
+    const spec = finishSpec(session, { label: '', color });
     if (!spec) return null;
     // Start a fresh session BEFORE awaiting, so a second Enter or the second
     // half of a double-click cannot submit the same shape twice.
     session = createDrawSession(shape);
     cursor = null;
     syncPreview();
-    if (labelInput) labelInput.value = '';
     const attempt = generation;
     try {
       const result = await annotations.annotate([spec], {
@@ -285,7 +285,7 @@ export function initDrawTool({ viewer, annotations }) {
   // ---- keys: only while drawing, never while typing in another field ----
   const typingElsewhere = (event) => {
     const t = event.target;
-    if (!t || t === labelInput) return false;
+    if (!t) return false;
     return (
       t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable
     );
@@ -293,12 +293,12 @@ export function initDrawTool({ viewer, annotations }) {
   /**
    * Enter is the finish key, but on a focused control Enter means "press this
    * control". Keyboard-focusing Clear and pressing Enter must clear the board,
-   * not finish the shape — so the finish key is only taken from the canvas,
-   * the page body, or the label field this tool owns.
+   * not finish the shape — so the finish key is only taken from the canvas or
+   * the page body.
    */
   const enterBelongsToDrawing = (event) => {
     const t = event.target;
-    if (!t || t === labelInput) return true;
+    if (!t) return true;
     if (
       typeof t.closest === 'function' &&
       t.closest('button, a, select, [role="button"], [role="radio"]')
@@ -328,7 +328,7 @@ export function initDrawTool({ viewer, annotations }) {
       else setActive(false);
       return;
     }
-    if (event.key === 'Backspace' && event.target !== labelInput) {
+    if (event.key === 'Backspace') {
       if (removeLastVertex(session)) {
         event.preventDefault();
         syncPreview();
@@ -448,18 +448,21 @@ export function initDrawTool({ viewer, annotations }) {
       }
     },
   });
-  listen(colorSelect, 'change', () => {
-    color = COLORS.includes(colorSelect.value) ? colorSelect.value : 'primary';
-    syncPreview();
+  const colorControl = createSegmentedControl({
+    buttons: [...(colorRow?.querySelectorAll('.draw-color[data-color]') || [])],
+    valueOf: (button) => button.dataset.color,
+    listen,
+    onChange: (value) => {
+      color = DRAW_COLORS.includes(value) ? value : 'primary';
+      colorControl.update(color);
+      syncPreview();
+    },
   });
   listen(clearButton, 'click', clearAll);
-  listen(labelInput, 'keydown', (event) => {
-    if (event.key === 'Enter' && session?.vertices?.length) {
-      event.preventDefault();
-      void finish();
-    }
-  });
   setHint(drawHint(null));
+  const markList = markListEl
+    ? createDrawMarkList({ listEl: markListEl, annotations, listen })
+    : null;
 
   const api = {
     get active() {
@@ -488,6 +491,11 @@ export function initDrawTool({ viewer, annotations }) {
     finish,
     cancel,
     clearAll,
+    /** The hand-drawn marks the list shows. */
+    marks: () => markList?.marks() || [],
+    setColor(next) {
+      colorRow?.querySelector(`.draw-color[data-color="${next}"]`)?.click();
+    },
     shapes: DRAW_SHAPES,
     /** What this tool currently holds — for teardown and leak assertions. */
     diagnostics() {
@@ -527,6 +535,7 @@ export function initDrawTool({ viewer, annotations }) {
       if (active) setActive(false);
       destroyed = true;
       unregisterUnsavedWork();
+      markList?.destroy();
       releaseSceneHandler();
       releasePointer(lease);
       lease = null;
diff --git a/src/annotations/drawTool.test.mjs b/src/annotations/drawTool.test.mjs
index c1a1b7681..709004200 100644
--- a/src/annotations/drawTool.test.mjs
+++ b/src/annotations/drawTool.test.mjs
@@ -69,8 +69,8 @@ test('the Draw control markup carries the ids the tool binds to', () => {
     'draw-toggle',
     'draw-mode-row',
     'draw-label-row',
-    'draw-label-input',
-    'draw-color-select',
+    'draw-colors',
+    'draw-mark-list',
     'draw-clear',
     'draw-hint',
   ];
@@ -81,13 +81,25 @@ test('the Draw control markup carries the ids the tool binds to', () => {
       `#${id} missing from index.html`,
     );
   }
-  for (const shape of ['area', 'line', 'pin']) {
+  // Shapes are icons, named for screen readers and tooltips.
+  for (const [shape, name] of [
+    ['area', 'Area'],
+    ['line', 'Line'],
+    ['pin', 'Pin'],
+  ]) {
     assert.match(
       html,
-      new RegExp(`data-shape="${shape}"`),
+      new RegExp(
+        `data-shape="${shape}"[^>]*aria-label="${name}"[^>]*title="${name}"`,
+      ),
       `shape button ${shape} missing`,
     );
   }
+  for (const color of ['primary', 'amber', 'cyan', 'green', 'red'])
+    assert.match(
+      html,
+      new RegExp(`class="draw-color[^"]*" type="button" data-color="${color}"`),
+    );
   for (const id of ids) {
     assert.match(
       tool(),
@@ -108,14 +120,15 @@ test('the DISPLAY rail styles live in their current owner, not the shim', () =>
   );
   assert.doesNotMatch(
     shim,
-    /draw-hint|pp-text-input/,
+    /draw-hint|draw-color/,
     'draw styles belong to a component stylesheet',
   );
   const controls = read('src/ui/styles/controls.css');
   for (const rule of [
     '#draw-mode-row',
     '#draw-label-row',
-    '.pp-text-input',
+    '.draw-color',
+    '.draw-mark-name',
     '.draw-clear-btn',
     '.draw-hint',
     'body.gev-drawing',
diff --git a/src/annotations/drawToolBehaviour.test.mjs b/src/annotations/drawToolBehaviour.test.mjs
index f8b9afcd1..fad1cc41d 100644
--- a/src/annotations/drawToolBehaviour.test.mjs
+++ b/src/annotations/drawToolBehaviour.test.mjs
@@ -116,8 +116,7 @@ function fakeDom() {
     modeRow.children.push(button);
   }
   make('draw-label-row');
-  make('draw-label-input', 'INPUT');
-  make('draw-color-select', 'SELECT');
+  make('draw-colors');
   make('draw-clear', 'BUTTON');
   make('draw-hint', 'SPAN');
 
diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json
index 9fdfac1b1..b3631bff2 100644
--- a/src/i18n/locales/es.json
+++ b/src/i18n/locales/es.json
@@ -902,14 +902,15 @@
   "Board cleared.": "Tablero borrado.",
   "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "Dibuja sobre el mundo: haz clic en los vértices, doble clic o Enter para terminar, Esc para cancelar",
   "Draw": "Dibujo",
-  "Shape": "Forma",
   "Shape to draw": "Forma a dibujar",
   "Area": "Área",
   "Line": "Línea",
   "Pin": "Marcador",
-  "Label (optional)": "Etiqueta (opcional)",
-  "Label for the drawn shape": "Etiqueta de la forma dibujada",
-  "Colour of the drawn shape": "Color de la forma dibujada",
+  "Colour of {name}": "Color de {name}",
+  "Change the colour of {name}": "Cambiar el color de {name}",
+  "Name of {name}": "Nombre de {name}",
+  "Colour of the next shape": "Color de la próxima forma",
+  "Drawn shapes": "Formas dibujadas",
   "Primary": "Principal",
   "Amber": "Ámbar",
   "Cyan": "Cian",
diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json
index baf98e27c..e62edc23d 100644
--- a/src/i18n/locales/ru.json
+++ b/src/i18n/locales/ru.json
@@ -910,14 +910,15 @@
   "Board cleared.": "Доска очищена.",
   "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "Рисовать на карте мира — щёлкайте по вершинам, двойной щелчок или Enter — завершить, Esc — отменить",
   "Draw": "Рисование",
-  "Shape": "Фигура",
   "Shape to draw": "Фигура для рисования",
   "Area": "Зона",
   "Line": "Линия",
   "Pin": "Метка",
-  "Label (optional)": "Подпись (необязательно)",
-  "Label for the drawn shape": "Подпись нарисованной фигуры",
-  "Colour of the drawn shape": "Цвет нарисованной фигуры",
+  "Colour of {name}": "Цвет: {name}",
+  "Change the colour of {name}": "Изменить цвет: {name}",
+  "Name of {name}": "Название: {name}",
+  "Colour of the next shape": "Цвет следующей фигуры",
+  "Drawn shapes": "Нарисованные фигуры",
   "Primary": "Основной",
   "Amber": "Янтарный",
   "Cyan": "Голубой",
diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json
index d869e077a..9ea6d3b00 100644
--- a/src/i18n/locales/zh-CN.json
+++ b/src/i18n/locales/zh-CN.json
@@ -2657,14 +2657,15 @@
   "Scope edge feather": "视域边缘羽化",
   "Scope edge feather as a percentage of the keyhole radius": "视域边缘羽化，以视域半径的百分比表示",
   "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "在地球上绘制——单击放置顶点，双击或按 Enter 完成，按 Esc 取消",
-  "Shape": "形状",
   "Shape to draw": "要绘制的形状",
   "Area": "面",
   "Line": "线",
   "Pin": "图钉",
-  "Label (optional)": "标签（可选）",
-  "Label for the drawn shape": "绘制形状的标签",
-  "Colour of the drawn shape": "绘制形状的颜色",
+  "Colour of {name}": "{name} 的颜色",
+  "Change the colour of {name}": "更改 {name} 的颜色",
+  "Name of {name}": "{name} 的名称",
+  "Colour of the next shape": "下一个形状的颜色",
+  "Drawn shapes": "已绘制的形状",
   "Primary": "主题色",
   "Amber": "琥珀色",
   "Cyan": "青色",
diff --git a/src/i18n/locales/zh-Hant.json b/src/i18n/locales/zh-Hant.json
index 4e98cf9d6..47770da7b 100644
--- a/src/i18n/locales/zh-Hant.json
+++ b/src/i18n/locales/zh-Hant.json
@@ -2645,14 +2645,15 @@
   "Scope edge feather": "視域邊緣羽化",
   "Scope edge feather as a percentage of the keyhole radius": "視域邊緣羽化，以視域半徑的百分比表示",
   "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "在地球上繪製——單擊放置頂點，雙擊或按 Enter 完成，按 Esc 取消",
-  "Shape": "形狀",
   "Shape to draw": "要繪製的形狀",
   "Area": "面",
   "Line": "線",
   "Pin": "圖釘",
-  "Label (optional)": "標籤（可選）",
-  "Label for the drawn shape": "繪製形狀的標籤",
-  "Colour of the drawn shape": "繪製形狀的顏色",
+  "Colour of {name}": "{name} 的顏色",
+  "Change the colour of {name}": "更改 {name} 的顏色",
+  "Name of {name}": "{name} 的名稱",
+  "Colour of the next shape": "下一個形狀的顏色",
+  "Drawn shapes": "已繪製的形狀",
   "Primary": "主題色",
   "Amber": "琥珀色",
   "Cyan": "青色",
diff --git a/src/ui/styles/controls.css b/src/ui/styles/controls.css
index 15d8bb48d..df214e5cd 100644
--- a/src/ui/styles/controls.css
+++ b/src/ui/styles/controls.css
@@ -750,38 +750,117 @@ html:not([lang='en']) .pp-slider-row > .pp-slider-mini-label {
   min-width: 0;
 }
 
-/* UTILITIES ▸ Draw: shape segment, label field, colour, and the one-line hint */
+/* UTILITIES ▸ Draw: shape icons and colour swatches for the next shape, the
+   hint with Clear, then one row per drawn shape (named and recoloured there) */
 #draw-mode-row {
-  min-width: 184px;
-}
-#draw-label-row {
   flex-wrap: wrap;
   row-gap: 6px;
+  column-gap: 10px;
 }
-.pp-text-input {
-  flex: 1 1 110px;
-  min-width: 0;
-  height: 24px;
-  background: rgba(255, 255, 255, 0.06);
-  border: 1px solid rgba(255, 255, 255, 0.14);
-  border-radius: 6px;
-  color: var(--text-primary);
-  font-family: var(--font-mono);
-  font-size: 10px;
-  letter-spacing: 0.6px;
-  padding: 2px 6px;
+#draw-mode-row .draw-shape-seg {
+  flex: 0 0 auto;
+}
+#draw-mode-row .draw-shape-seg .gev-segment {
+  min-width: 30px;
+  padding: 3px 6px;
+}
+.draw-shape-seg .material-symbols-outlined {
+  display: block;
+  font-size: 16px;
+  line-height: 1;
+}
+.draw-colors {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+#utilities-panel .draw-color {
+  flex: 0 0 auto;
+  width: 16px;
+  height: 16px;
+  padding: 0;
+  border: 1px solid rgba(0, 0, 0, 0.45);
+  border-radius: 50%;
+  cursor: pointer;
+}
+#utilities-panel .draw-color[data-color='primary'] {
+  background: #8be9ff;
+}
+#utilities-panel .draw-color[data-color='amber'] {
+  background: #ffb547;
+}
+#utilities-panel .draw-color[data-color='cyan'] {
+  background: #39d0ff;
+}
+#utilities-panel .draw-color[data-color='green'] {
+  background: #5dff9f;
+}
+#utilities-panel .draw-color[data-color='red'] {
+  background: #ff6b6b;
+}
+/* The swatch keeps its own colour in every theme; only a ring marks it. */
+#utilities-panel .draw-color:is(.active, :hover, :focus-visible) {
+  border-color: rgba(0, 0, 0, 0.45);
+  box-shadow: none;
+}
+#utilities-panel .draw-color.active,
+#utilities-panel .draw-color:focus-visible {
+  outline: 2px solid var(--text-primary);
+  outline-offset: 2px;
+}
+#draw-label-row {
+  justify-content: space-between;
+  gap: 8px;
+}
+#draw-label-row .draw-hint {
+  flex: 1 1 auto;
+}
+.draw-mark-row {
+  flex-wrap: wrap;
+}
+.draw-mark-swatch {
+  flex: 0 0 10px;
+  width: 10px;
+  height: 10px;
+  padding: 0;
+  border: 0;
+  border-radius: 3px;
+  cursor: pointer;
+}
+.draw-mark-swatch:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+}
+/* The name reads as text until it is clicked into, and gives way so the
+   row's buttons stay on its line. */
+.draw-mark-row .draw-mark-name {
+  flex: 1 1 0;
+  width: 0;
+  height: 22px;
+  padding: 0 4px;
+  background: transparent;
+  border: 1px solid transparent;
+  border-radius: 5px;
   outline: none;
 }
-.pp-text-input:focus {
+.draw-mark-name::placeholder {
+  color: var(--text-primary);
+  opacity: 0.85;
+}
+.draw-mark-name:hover {
+  border-color: rgba(255, 255, 255, 0.14);
+}
+.draw-mark-name:focus {
   border-color: var(--accent);
+  background: rgba(255, 255, 255, 0.06);
 }
-.draw-color-select {
-  flex: 0 0 74px;
+.draw-mark-row.hidden-mark .draw-mark-name,
+.draw-mark-row.hidden-mark .draw-mark-swatch {
+  opacity: 0.45;
 }
-/* Sized to its longest colour name so a translated one is never clipped. */
-html:not([lang='en']) .draw-color-select {
-  flex: 0 0 auto;
-  min-width: 74px;
+.draw-mark-colors {
+  flex-basis: 100%;
+  padding: 2px 0 4px 16px;
 }
 .draw-clear-btn {
   flex: 0 0 auto;
diff --git a/src/ui/styles/english-css-parity.test.mjs b/src/ui/styles/english-css-parity.test.mjs
index 7d9a1ae4c..e06926c03 100644
--- a/src/ui/styles/english-css-parity.test.mjs
+++ b/src/ui/styles/english-css-parity.test.mjs
@@ -105,8 +105,6 @@ test('Display and parameter rows keep their English layout', () => {
   assert.equal(unguardedRules(source, '#param-sliders').length, 0);
   const [row] = unguardedRules(source, '.param-slider-row');
   assert.equal(declaration(row, 'display'), 'flex');
-  const [color] = unguardedRules(source, '.draw-color-select');
-  assert.equal(declaration(color, 'flex'), '0 0 74px');
 });
 
 test('weather setting rows keep the 56px English label column', () => {
diff --git a/src/ui/styles/layers.css b/src/ui/styles/layers.css
index a787c2b3d..9d8b66166 100644
--- a/src/ui/styles/layers.css
+++ b/src/ui/styles/layers.css
@@ -1495,8 +1495,7 @@ body.recording-mode #right-context-rail > [data-panel-id] {
 }
 
 /* Draw's options sit flat under its name, like a layer row's controls, not
-   as the card that hangs under a DISPLAY button. DISPLAY's shared label
-   column means nothing here, so the Shape label takes its own width. */
+   as the card that hangs under a DISPLAY button. */
 #utilities-panel .utilities-tools .pp-slider-row {
   padding: 4px 0;
   background: none;
@@ -1505,7 +1504,3 @@ body.recording-mode #right-context-rail > [data-panel-id] {
   backdrop-filter: none;
   -webkit-backdrop-filter: none;
 }
-
-#utilities-panel .utilities-tools .pp-slider-mini-label {
-  min-width: 0;
-}
diff --git a/src/ui/templates/layer-panels.html b/src/ui/templates/layer-panels.html
index eb7f7dcfd..c5284d97d 100644
--- a/src/ui/templates/layer-panels.html
+++ b/src/ui/templates/layer-panels.html
@@ -159,25 +159,24 @@
             <span class="pp-label" data-i18n>Draw</span>
           </button>
           <div class="pp-slider-row" id="draw-mode-row">
-            <span class="pp-slider-mini-label" data-i18n>Shape</span>
-            <div class="gev-segmented pp-mode-seg" role="radiogroup" aria-label="Shape to draw" data-i18n-aria-label>
-              <button class="gev-segment pp-mode-btn active" data-shape="area" role="radio" aria-checked="true" data-i18n>Area</button>
-              <button class="gev-segment pp-mode-btn" data-shape="line" role="radio" aria-checked="false" data-i18n>Line</button>
-              <button class="gev-segment pp-mode-btn" data-shape="pin" role="radio" aria-checked="false" data-i18n>Pin</button>
+            <div class="gev-segmented pp-mode-seg draw-shape-seg" role="radiogroup" aria-label="Shape to draw" data-i18n-aria-label>
+              <button class="gev-segment pp-mode-btn active" data-shape="area" role="radio" aria-checked="true" aria-label="Area" title="Area" data-i18n-aria-label data-i18n-title><span class="material-symbols-outlined" aria-hidden="true">pentagon</span></button>
+              <button class="gev-segment pp-mode-btn" data-shape="line" role="radio" aria-checked="false" aria-label="Line" title="Line" data-i18n-aria-label data-i18n-title><span class="material-symbols-outlined" aria-hidden="true">timeline</span></button>
+              <button class="gev-segment pp-mode-btn" data-shape="pin" role="radio" aria-checked="false" aria-label="Pin" title="Pin" data-i18n-aria-label data-i18n-title><span class="material-symbols-outlined" aria-hidden="true">location_on</span></button>
+            </div>
+            <div class="draw-colors" id="draw-colors" role="radiogroup" aria-label="Colour of the next shape" data-i18n-aria-label>
+              <button class="draw-color active" type="button" data-color="primary" role="radio" aria-checked="true" aria-label="Primary" title="Primary" data-i18n-aria-label data-i18n-title></button>
+              <button class="draw-color" type="button" data-color="amber" role="radio" aria-checked="false" aria-label="Amber" title="Amber" data-i18n-aria-label data-i18n-title></button>
+              <button class="draw-color" type="button" data-color="cyan" role="radio" aria-checked="false" aria-label="Cyan" title="Cyan" data-i18n-aria-label data-i18n-title></button>
+              <button class="draw-color" type="button" data-color="green" role="radio" aria-checked="false" aria-label="Green" title="Green" data-i18n-aria-label data-i18n-title></button>
+              <button class="draw-color" type="button" data-color="red" role="radio" aria-checked="false" aria-label="Red" title="Red" data-i18n-aria-label data-i18n-title></button>
             </div>
           </div>
           <div class="pp-slider-row" id="draw-label-row">
-            <input type="text" class="pp-text-input" id="draw-label-input" maxlength="120" placeholder="Label (optional)" aria-label="Label for the drawn shape" data-i18n-placeholder data-i18n-aria-label autocomplete="off" spellcheck="false">
-            <select class="pp-select draw-color-select gev-field gev-field--compact" id="draw-color-select" aria-label="Colour of the drawn shape" data-i18n-aria-label>
-              <option value="primary" data-i18n>Primary</option>
-              <option value="amber" data-i18n>Amber</option>
-              <option value="cyan" data-i18n>Cyan</option>
-              <option value="green" data-i18n>Green</option>
-              <option value="red" data-i18n>Red</option>
-            </select>
-            <button class="pp-mode-btn draw-clear-btn" id="draw-clear" type="button" title="Remove every mark from the board" data-i18n-title data-i18n>Clear</button>
             <span class="draw-hint" id="draw-hint" aria-live="polite"></span>
+            <button class="pp-mode-btn draw-clear-btn" id="draw-clear" type="button" title="Remove every mark from the board" data-i18n-title data-i18n>Clear</button>
           </div>
+          <ul class="geo-import-list draw-mark-list" id="draw-mark-list" aria-label="Drawn shapes" data-i18n-aria-label></ul>
         </div>
         <div class="pp-toggle-group" id="geo-import-group">
           <button class="pp-toggle-btn" id="geo-import-button" type="button" title="Show your own GeoJSON, KML, KMZ or GPX files on the globe (or drop them onto it). File bytes stay on this device; overlays can appear in map screenshots shared with voice." data-i18n-title>

From 6f93c21aaa212e857cb0e80fb952c77a2b8b2c61 Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Thu, 29 Oct 2026 13:59:37 +0000
Subject: [PATCH 45/70] Describe the Draw shape list in the Utilities panel
 changelog entry

---
 changelog.d/1469-utilities-panel.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/changelog.d/1469-utilities-panel.md b/changelog.d/1469-utilities-panel.md
index 9be1f14bc..cf11b327c 100644
--- a/changelog.d/1469-utilities-panel.md
+++ b/changelog.d/1469-utilities-panel.md
@@ -1,3 +1,6 @@
 - Gather Directions, Draw and Import in a new UTILITIES panel in the left
   column, between Data Layers and Scenes. Draw and Import leave DISPLAY, and
-  Radio stays in Data Layers under "Audio" (asturksever, #1469).
+  Radio stays in Data Layers under "Audio". Each drawn shape now gets a row
+  under Draw, like an imported file: name it, recolour it, hide it, fly to it
+  or remove it there. Area, Line and Pin are icon buttons, and the colour for
+  the next shape is a row of swatches (asturksever, #1469).

From 328894d566df8cac43f373f73f942ac37fb1fbdc Mon Sep 17 00:00:00 2001
From: quanticsoul4772 <71096528+quanticsoul4772@users.noreply.github.com>
Date: Thu, 29 Oct 2026 08:59:48 -0700
Subject: [PATCH 46/70] docs(changelog): state the voice hint saving without
 main's size

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 changelog.d/1462-voice-alias-hint-budget.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/changelog.d/1462-voice-alias-hint-budget.md b/changelog.d/1462-voice-alias-hint-budget.md
index 64cf56100..82628c52c 100644
--- a/changelog.d/1462-voice-alias-hint-budget.md
+++ b/changelog.d/1462-voice-alias-hint-budget.md
@@ -1,5 +1,5 @@
 - Leave layer aliases the layer id already spells, such as "dams" for
-  `local-dams`, out of the voice layer hint. The Realtime prompt drops from
-  52,000 to 51,695 characters, leaving room under the 52,000 gate for new
+  `local-dams`, out of the voice layer hint. The Realtime prompt is 305
+  characters shorter, leaving room under the 52,000 gate for new
   voice-toggleable layers; every alias is still accepted (quanticsoul4772,
   #1462).

From 94470ff00e0e6f09ee60ae6a79e0a327857b79cb Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Fri, 30 Oct 2026 15:18:11 +0000
Subject: [PATCH 47/70] Translate the Utilities panel and Draw list strings in
 de, fr, it, ja, pt and uk

---
 src/i18n/locales/de.json      | 13 ++++++++-----
 src/i18n/locales/fr.json      | 13 ++++++++-----
 src/i18n/locales/it.json      | 13 ++++++++-----
 src/i18n/locales/ja.json      | 13 ++++++++-----
 src/i18n/locales/pt.json      | 13 ++++++++-----
 src/i18n/locales/uk.json      | 13 ++++++++-----
 src/i18n/same-as-english.json |  3 +++
 7 files changed, 51 insertions(+), 30 deletions(-)

diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json
index 8e383aded..c28967f23 100644
--- a/src/i18n/locales/de.json
+++ b/src/i18n/locales/de.json
@@ -2879,14 +2879,10 @@
   "Sector": "Sektor",
   "Sonar sector width": "Breite des Sonarsektors",
   "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "Auf die Welt zeichnen – Eckpunkte anklicken, Doppelklick oder Enter zum Beenden, Esc zum Abbrechen",
-  "Shape": "Form",
   "Shape to draw": "Zu zeichnende Form",
   "Area": "Fläche",
   "Line": "Linie",
   "Pin": "Pin",
-  "Label (optional)": "Beschriftung (optional)",
-  "Label for the drawn shape": "Beschriftung der gezeichneten Form",
-  "Colour of the drawn shape": "Farbe der gezeichneten Form",
   "Primary": "Primär",
   "Amber": "Bernstein",
   "Cyan": "Cyan",
@@ -2926,5 +2922,12 @@
   "Malformed cyclone snapshot": "Fehlerhafter Wirbelsturm-Snapshot",
   "STALE · Roads: {source} · Flow: cached TomTom tiles": "VERALTET · Straßen: {source} · Verkehrsfluss: TomTom-Kacheln aus dem Cache",
   "routing busy — too many routes at once": "Routing-Dienst ausgelastet – zu viele Routen gleichzeitig",
-  "route proxy error": "Fehler des Routen-Proxys"
+  "route proxy error": "Fehler des Routen-Proxys",
+  "Colour of {name}": "Farbe von {name}",
+  "Change the colour of {name}": "Farbe von {name} ändern",
+  "Name of {name}": "Name von {name}",
+  "Audio": "Audio",
+  "UTILITIES": "WERKZEUGE",
+  "Colour of the next shape": "Farbe der nächsten Form",
+  "Drawn shapes": "Gezeichnete Formen"
 }
diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json
index 931e7c3ff..507f6ac96 100644
--- a/src/i18n/locales/fr.json
+++ b/src/i18n/locales/fr.json
@@ -2892,14 +2892,10 @@
   "Scope edge feather": "Adoucissement du bord de la lunette",
   "Scope edge feather as a percentage of the keyhole radius": "Adoucissement du bord de la lunette, en pourcentage du rayon de l'ouverture",
   "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "Dessinez sur le monde — cliquez sur les sommets, double-clic ou Enter pour terminer, Esc pour annuler",
-  "Shape": "Forme",
   "Shape to draw": "Forme à dessiner",
   "Area": "Zone",
   "Line": "Ligne",
   "Pin": "Épingle",
-  "Label (optional)": "Étiquette (facultative)",
-  "Label for the drawn shape": "Étiquette de la forme dessinée",
-  "Colour of the drawn shape": "Couleur de la forme dessinée",
   "Primary": "Principale",
   "Amber": "Ambre",
   "Cyan": "Cyan",
@@ -2996,5 +2992,12 @@
   "ESC to dismiss": "ESC pour fermer",
   "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"
+  "Cyclone request timed out": "Délai dépassé pour la requête cyclonique",
+  "Colour of {name}": "Couleur de {name}",
+  "Change the colour of {name}": "Changer la couleur de {name}",
+  "Name of {name}": "Nom de {name}",
+  "Audio": "Audio",
+  "UTILITIES": "OUTILS",
+  "Colour of the next shape": "Couleur de la prochaine forme",
+  "Drawn shapes": "Formes dessinées"
 }
diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json
index 62c9931c1..ef0928f95 100644
--- a/src/i18n/locales/it.json
+++ b/src/i18n/locales/it.json
@@ -2892,14 +2892,10 @@
   "Scope edge feather": "Sfumatura del bordo dello scope",
   "Scope edge feather as a percentage of the keyhole radius": "Sfumatura del bordo dello scope, come percentuale del raggio del foro",
   "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "Disegna sul mondo: fai clic sui vertici, doppio clic o Enter per finire, Esc per annullare",
-  "Shape": "Forma",
   "Shape to draw": "Forma da disegnare",
   "Area": "Area",
   "Line": "Linea",
   "Pin": "Segnaposto",
-  "Label (optional)": "Etichetta (opzionale)",
-  "Label for the drawn shape": "Etichetta della forma disegnata",
-  "Colour of the drawn shape": "Colore della forma disegnata",
   "Primary": "Principale",
   "Amber": "Ambra",
   "Cyan": "Ciano",
@@ -2996,5 +2992,12 @@
   "ESC to dismiss": "ESC per chiudere",
   "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"
+  "Cyclone request timed out": "La richiesta dei cicloni è andata in timeout",
+  "Colour of {name}": "Colore di {name}",
+  "Change the colour of {name}": "Cambia il colore di {name}",
+  "Name of {name}": "Nome di {name}",
+  "Audio": "Audio",
+  "UTILITIES": "STRUMENTI",
+  "Colour of the next shape": "Colore della prossima forma",
+  "Drawn shapes": "Forme disegnate"
 }
diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json
index 5a48dc886..5b583fc30 100644
--- a/src/i18n/locales/ja.json
+++ b/src/i18n/locales/ja.json
@@ -2750,14 +2750,10 @@
   "Scope edge feather": "スコープ縁のぼかし",
   "Scope edge feather as a percentage of the keyhole radius": "スコープ縁のぼかし（キーホール半径に対する割合）",
   "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "地球上に描画：クリックで頂点を追加、ダブルクリックまたはEnterで完了、Escでキャンセル",
-  "Shape": "図形",
   "Shape to draw": "描画する図形",
   "Area": "範囲",
   "Line": "線",
   "Pin": "ピン",
-  "Label (optional)": "ラベル（任意）",
-  "Label for the drawn shape": "描画した図形のラベル",
-  "Colour of the drawn shape": "描画した図形の色",
   "Primary": "プライマリー",
   "Amber": "アンバー",
   "Cyan": "シアン",
@@ -2856,5 +2852,12 @@
   "routing busy — too many routes at once": "ルート検索サービスが混雑しています。同時に要求されたルートが多すぎます",
   "route proxy error": "ルート検索プロキシでエラーが発生しました",
   "Malformed cyclone snapshot": "サイクロンのスナップショットの形式が不正です",
-  "Cyclone request timed out": "サイクロンのリクエストがタイムアウトしました"
+  "Cyclone request timed out": "サイクロンのリクエストがタイムアウトしました",
+  "Colour of {name}": "{name}の色",
+  "Change the colour of {name}": "{name}の色を変更",
+  "Name of {name}": "{name}の名前",
+  "Audio": "オーディオ",
+  "UTILITIES": "ユーティリティ",
+  "Colour of the next shape": "次の図形の色",
+  "Drawn shapes": "描いた図形"
 }
diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json
index de42b5aab..4397fc49c 100644
--- a/src/i18n/locales/pt.json
+++ b/src/i18n/locales/pt.json
@@ -2894,14 +2894,10 @@
   "Scope edge feather": "Suavização da borda da mira",
   "Scope edge feather as a percentage of the keyhole radius": "Suavização da borda da mira, em porcentagem do raio do visor",
   "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "Desenhar sobre o mundo — clique nos vértices, clique duplo ou Enter para concluir, Esc para cancelar",
-  "Shape": "Forma",
   "Shape to draw": "Forma a desenhar",
   "Area": "Área",
   "Line": "Linha",
   "Pin": "Marcador",
-  "Label (optional)": "Rótulo (opcional)",
-  "Label for the drawn shape": "Rótulo da forma desenhada",
-  "Colour of the drawn shape": "Cor da forma desenhada",
   "Primary": "Principal",
   "Amber": "Âmbar",
   "Cyan": "Ciano",
@@ -2996,5 +2992,12 @@
   "Begin with a clean globe": "Comece com um globo limpo",
   "Don't show this again": "Não mostrar novamente",
   "ESC to dismiss": "ESC para fechar",
-  "Tip: the GEV MIC button in the dock lets you talk to the map.": "Dica: o botão GEV MIC no dock permite falar com o mapa."
+  "Tip: the GEV MIC button in the dock lets you talk to the map.": "Dica: o botão GEV MIC no dock permite falar com o mapa.",
+  "Colour of {name}": "Cor de {name}",
+  "Change the colour of {name}": "Mudar a cor de {name}",
+  "Name of {name}": "Nome de {name}",
+  "Audio": "Áudio",
+  "UTILITIES": "UTILITÁRIOS",
+  "Colour of the next shape": "Cor da próxima forma",
+  "Drawn shapes": "Formas desenhadas"
 }
diff --git a/src/i18n/locales/uk.json b/src/i18n/locales/uk.json
index 6041d339f..aa5f9dba9 100644
--- a/src/i18n/locales/uk.json
+++ b/src/i18n/locales/uk.json
@@ -2962,14 +2962,10 @@
   "Scope edge feather": "Розмиття краю прицілу",
   "Scope edge feather as a percentage of the keyhole radius": "Розмиття краю прицілу у відсотках від його радіуса",
   "Draw on the world — click vertices, double-click or Enter to finish, Esc to cancel": "Малювати на карті світу — клацайте вершини, подвійне клацання або Enter — завершити, Esc — скасувати",
-  "Shape": "Фігура",
   "Shape to draw": "Фігура для малювання",
   "Area": "Зона",
   "Line": "Лінія",
   "Pin": "Мітка",
-  "Label (optional)": "Підпис (необовʼязково)",
-  "Label for the drawn shape": "Підпис намальованої фігури",
-  "Colour of the drawn shape": "Колір намальованої фігури",
   "Primary": "Основний",
   "Amber": "Бурштиновий",
   "Cyan": "Блакитний",
@@ -3066,5 +3062,12 @@
   "ESC to dismiss": "ESC — приховати",
   "Tip: the GEV MIC button in the dock lets you talk to the map.": "Порада: кнопка МІК у доку дає змогу говорити з картою.",
   "Malformed cyclone snapshot": "Некоректний знімок циклонів",
-  "Cyclone request timed out": "Минув час очікування запиту циклонів"
+  "Cyclone request timed out": "Минув час очікування запиту циклонів",
+  "Colour of {name}": "Колір: {name}",
+  "Change the colour of {name}": "Змінити колір: {name}",
+  "Name of {name}": "Назва: {name}",
+  "Audio": "Аудіо",
+  "UTILITIES": "ІНСТРУМЕНТИ",
+  "Colour of the next shape": "Колір наступної фігури",
+  "Drawn shapes": "Намальовані фігури"
 }
diff --git a/src/i18n/same-as-english.json b/src/i18n/same-as-english.json
index 8e35e1303..1bf1e98bf 100644
--- a/src/i18n/same-as-english.json
+++ b/src/i18n/same-as-english.json
@@ -9,6 +9,7 @@
     "Alternative",
     "Ambient",
     "Anime",
+    "Audio",
     "Austin",
     "BRG {value}°",
     "BRG —",
@@ -303,6 +304,7 @@
     "Altitude {altitude}",
     "Ambient",
     "Anime",
+    "Audio",
     "Austin",
     "Aviation / Marine",
     "BRG {value}°",
@@ -486,6 +488,7 @@
     "Ambient",
     "Anime",
     "Area",
+    "Audio",
     "Austin",
     "BRG {value}°",
     "BRG —",

From bdbbc3d7673561f56ee7ff487ec72f59796e8660 Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Fri, 30 Oct 2026 15:23:56 +0000
Subject: [PATCH 48/70] Keep Draw rows in place across board changes, and frame
 lines across the antimeridian

The shape list rebuilt every row on each board change. A name being typed was
lost when a voice mark landed or expired, and a click right after typing only
committed the name, because the button under the pointer was replaced. Rows
are now updated in place, a re-entrant render is deferred, picking a colour or
Esc returns focus to the swatch, and keys on the list no longer reach Draw.

Fly-to on a line across the antimeridian flew to longitude 0. A drawn mark
and a voice mark are no longer deduplicated into one another, so a voice TTL
cannot expire a drawn pin, and a new pin on a hidden one is drawn.

The engine tests now check effects (renderer calls, alpha, notifications on
clear and expiry, the framed centre), not only return values.
---
 docs/CURRENT-STATE.md                     |   4 +-
 src/annotations/annotationEngine.js       |  14 +-
 src/annotations/annotationEngine.test.mjs | 168 +++++++++++++++
 src/annotations/drawMarkList.js           | 237 +++++++++++++---------
 src/annotations/drawMarkList.test.mjs     | 110 +++++++++-
 src/annotations/drawTool.js               |   3 +
 6 files changed, 428 insertions(+), 108 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 5286affe3..93489dd5e 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5420,8 +5420,8 @@ request viewbox and continues searching without that geographic preference.
 ### Manual Whiteboard Drawing (September 2026)
 
 - UTILITIES ▸ **Draw** turns the globe into a whiteboard drawn by hand. Pick a shape (icon buttons for Area, Line and Pin) and a colour swatch for the next shape, click the vertices on the real world, and finish. **Keyboard contract, live only while Draw is on and never while you are typing in another field:** Enter finishes the shape (as does a double-click, and the two cannot both submit it — the session is replaced before the annotate call is awaited); Backspace removes the last vertex; Esc cancels the shape in progress, and a second Esc — Esc on an empty session — leaves draw mode. **Clear** wipes the board (the shape in progress and every placed mark), so removing marks does not require the console or the microphone.
-- **Drawn shapes are listed under Draw like Import's files** (`src/annotations/drawMarkList.js`): one row per hand-drawn mark (`manual: true`; voice marks are not listed) with its colour swatch, its name, and show/hide, fly-to and remove. The name is typed in the row (Enter or leaving the field saves it, Esc restores it and stays in the field); an unnamed shape shows its kind, and an unnamed line its length. The swatch opens the five colours in the row. The list reads the engine's board and redraws on `onChange`; it asks for changes through the engine's per-mark `remove`, `setHidden`, `frame` and `restyle`. A hidden mark stays on the board at alpha 0, so it keeps its place and comes back at once; `restyle` re-adds the mark with the new name or colour, and a renamed line keeps its length (`Name — 1.2 km`). Fly-to frames a line by its whole path, not its first point.
-- Runtime entry: `createApplicationTools` (`src/app/tools.js`, behind the `src/standalone/tools.js` shim) calls `initDrawTool({ viewer, annotations })` after `initAnnotations` and defers its `destroy()`, so disposing the shell returns every DOM listener, the Cesium handler, the preview data source, the borrowed click actions and the `window.__gevDrawTool` handle. Its markup lives in the UTILITIES panel's component template (`src/ui/templates/layer-panels.html`), assembled into `index.html` at build time. That handle (`setActive`, `setShape`, `addVertex(lon, lat)`, `finish`, `cancel`, `clearAll`, `diagnostics`) is the no-mouse test seam.
+- **Drawn shapes are listed under Draw like Import's files** (`src/annotations/drawMarkList.js`): one row per hand-drawn mark (`manual: true`; voice marks are not listed) with its colour swatch, its name, and show/hide, fly-to and remove. The name is typed in the row (Enter or leaving the field saves it, Esc restores it and leaves the field without leaving Draw); an unnamed shape shows its kind, and an unnamed line its length. The swatch opens the five colours in the row; choosing one, or Esc, closes them and returns focus to the swatch. The list reads the engine's board on `onChange` and updates its rows in place rather than rebuilding them, so a click that is half done, or a name being typed, survives a board change; keys on the list's controls are the list's, not the drawing's. it asks for changes through the engine's per-mark `remove`, `setHidden`, `frame` and `restyle`. A hidden mark stays on the board at alpha 0, so it keeps its place and comes back at once; `restyle` re-adds the mark with the new name or colour, and a renamed line keeps its length (`Name — 1.2 km`). Fly-to frames a line by its whole path, not its first point, and centres a line across the antimeridian there. A drawn mark and a voice mark are never deduplicated into one another, and a hidden mark is never refreshed by a new one.
+- Runtime entry: `createApplicationTools` (`src/app/tools.js`, behind the `src/standalone/tools.js` shim) calls `initDrawTool({ viewer, annotations })` after `initAnnotations` and defers its `destroy()`, so disposing the shell returns every DOM listener, the Cesium handler, the preview data source, the borrowed click actions and the `window.__gevDrawTool` handle. Its markup lives in the UTILITIES panel's component template (`src/ui/templates/layer-panels.html`), assembled into `index.html` at build time. That handle (`setActive`, `setShape`, `addVertex(lon, lat)`, `finish`, `cancel`, `clearAll`, `marks`, `setColor`, `diagnostics`) is the no-mouse test seam.
 - Contract: a finished shape is submitted through the SAME `annotationEngine.annotate()` the voice agent uses, with geometry supplied and `manual: true` (`type: area` + `ring`, `type: route` + `path`, `type: pin` + coordinates). `resolveSpec` short-circuits manual specs (`resolveManualSpec`) so no geocoder, Places or Overpass call is made. A drawn area is a real (not synthesized) outline and drapes solid; a drawn line is a `route` with `mode: 'manual'`, labelled with its length and never a travel time; a pin is a point. Drawn marks therefore render with the whiteboard look, persist, de-dup, appear in `.list()`, and clear with `clear_annotations` / `.clear()`.
 - **A vertex is a lon/lat, and the mark is DRAPED.** Clicks are picked through `pickWorldFromScreen` — one of two scene helpers the annotation resolver factory (`src/annotations/resolver.js`) exposes alongside `sampleGroundHeight`, so the app has ONE depth-aware pick cascade rather than a second written beside it — which returns the height the pick landed on as well as the coordinate, so the live preview hangs on the roof or hillside under the pointer instead of sinking to sea level. The world renderer draws areas and routes with `clampToGround`, so the height is dropped at finish in one place (`finishSpec`) rather than being carried downstream and discarded silently: what you get is the outline you drew, lying on the surface beneath it.
 - **Draped marks classify onto `ClassificationType.BOTH`** — terrain AND 3D tiles — not onto 3D tiles alone. With only `CESIUM_3D_TILE`, every area fill, area outline, route and arrow rendered to nothing on a keyless boot, where Cesium's own globe carries Esri/OSM imagery and there are no tiles to classify against; the labels appeared and the geometry did not. That hit spoken annotations exactly as hard as hand-drawn ones. `scripts/qa-draw-tool.mjs` counts the mark's own colour in the rendered frame before and after a shape is finished, on a keyed AND a keyless server, so "the board says there is a mark" can no longer pass for "the mark is on screen".
diff --git a/src/annotations/annotationEngine.js b/src/annotations/annotationEngine.js
index 4125986ad..a3d726701 100644
--- a/src/annotations/annotationEngine.js
+++ b/src/annotations/annotationEngine.js
@@ -828,6 +828,10 @@ export function createAnnotationEngine({
     };
     for (const ex of annotations.values()) {
       if (ex.type !== anno.type || !ex.anchor) continue;
+      // A shape drawn by hand and a voice mark are never the same mark: a
+      // match would let a voice TTL expire the drawn one, or replace it. A
+      // hidden mark is not refreshed either; a new shape there is new.
+      if (Boolean(ex.manual) !== Boolean(anno.manual) || ex.hidden) continue;
       // Identity is GEOMETRY, not label: "Marina" and "Marina District" resolve to the SAME
       // polygon/anchor and must collapse to one mark (the caller replaces label/color in place
       // so the latest caption wins). Resolution is deterministic, so the same place re-resolves
@@ -1054,15 +1058,21 @@ export function createAnnotationEngine({
     if (!anno) return false;
     if (anno.type === 'route' && anno.path?.length) {
       const ring = anno.path.map((p) => [p.lon, p.lat]);
-      const lons = ring.map(([lon]) => lon);
+      // Unwrap around the first vertex, as ringRange does, so a line across
+      // the antimeridian is centred on it, not on the far side of the globe.
+      const ref = ring[0][0];
+      const lons = ring.map(
+        ([lon]) => lon - 360 * Math.round((lon - ref) / 360),
+      );
       const lats = ring.map(([, lat]) => lat);
+      const midLon = (Math.min(...lons) + Math.max(...lons)) / 2;
       frameAnnotation({
         ...anno,
         to: null,
         ring,
         polygons: null,
         anchor: {
-          lon: (Math.min(...lons) + Math.max(...lons)) / 2,
+          lon: ((((midLon + 180) % 360) + 360) % 360) - 180,
           lat: (Math.min(...lats) + Math.max(...lats)) / 2,
           height: 0,
         },
diff --git a/src/annotations/annotationEngine.test.mjs b/src/annotations/annotationEngine.test.mjs
index 6e435fcd4..3c5dd82bb 100644
--- a/src/annotations/annotationEngine.test.mjs
+++ b/src/annotations/annotationEngine.test.mjs
@@ -12,6 +12,7 @@ import { createStandalonePlaceSearch } from '../standalone/placeSearch.js';
 //
 // Run with: npm test   (node --test)
 import { test } from 'node:test';
+import * as Cesium from 'cesium';
 import assert from 'node:assert/strict';
 import {
   createAnnotationEngine,
@@ -787,6 +788,173 @@ test('hand-drawn marks: one mark can be hidden, renamed, recoloured, framed and
   assert.equal(changes, seen, 'an unsubscribed listener hears nothing');
 });
 
+// The list trusts these calls to change the globe, not just the list: each
+// is checked by its effect (renderer calls, alpha, camera, notifications).
+test('hand-drawn marks: remove, hide, clear, expiry and framing have their effect', async (t) => {
+  const frames = [];
+  const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
+  const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
+  globalThis.requestAnimationFrame = (callback) => frames.push(callback);
+  globalThis.cancelAnimationFrame = () => {};
+  let now = 1_000_000;
+  t.mock.method(performance, 'now', () => now);
+  _resetRenderGovernorForTest();
+  t.after(() => {
+    globalThis.requestAnimationFrame = originalRequestAnimationFrame;
+    globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
+    _resetRenderGovernorForTest();
+  });
+  const runFrames = () => {
+    for (let i = 0; i < 5 && frames.length; i += 1) frames.shift()();
+  };
+  const { renderer, calls } = fakeRenderer();
+  const flights = [];
+  const engine = createAnnotationEngine({
+    viewer: {
+      camera: {
+        heading: 0,
+        flyToBoundingSphere: (sphere) => flights.push(sphere),
+      },
+    },
+    renderer,
+  });
+  let changes = 0;
+  engine.onChange(() => {
+    changes += 1;
+  });
+
+  await engine.annotate(
+    [
+      {
+        type: 'pin',
+        manual: true,
+        latitude: 30.27,
+        longitude: -97.74,
+        label: 'Camp',
+      },
+      {
+        type: 'pin',
+        manual: true,
+        latitude: 30.3,
+        longitude: -97.7,
+        label: 'Base',
+      },
+    ],
+    { persist: true },
+  );
+  now += 1000;
+  runFrames();
+  const [camp, base] = engine.list();
+  assert.equal(camp.alpha, 1);
+
+  engine.setHidden(camp.id, true);
+  runFrames();
+  assert.equal(camp.alpha, 0, 'a hidden mark is drawn at alpha 0');
+  assert.ok(engine.list().includes(camp), 'and stays on the board');
+  engine.setHidden(camp.id, false);
+  runFrames();
+  assert.equal(camp.alpha, 1, 'showing it again is immediate, with no fade-in');
+
+  const removes = calls.remove;
+  let seen = changes;
+  engine.remove(base.id);
+  assert.equal(calls.remove, removes + 1, 'remove takes it off the globe');
+  assert.equal(changes, seen + 1, 'and tells the list');
+
+  seen = changes;
+  engine.clear();
+  assert.equal(changes, seen + 1, 'a clear tells the list');
+
+  // A voice mark with a TTL: its expiry must reach the list too.
+  await engine.annotate(
+    [{ type: 'pin', latitude: 1, longitude: 1, label: 'Brief' }],
+    {
+      persist: false,
+      ttlMs: 2000,
+    },
+  );
+  seen = changes;
+  now += 60_000;
+  runFrames();
+  assert.equal(engine.list().length, 0, 'the mark expired');
+  assert.equal(changes, seen + 1, 'expiry tells the list');
+
+  // A line across the antimeridian is framed there, not on the far side.
+  await engine.annotate(
+    [
+      {
+        type: 'route',
+        manual: true,
+        path: [
+          [179.9, -17],
+          [-179.9, -17.1],
+        ],
+        label: '',
+      },
+    ],
+    { persist: true },
+  );
+  const [line] = engine.list();
+  engine.frame(line.id);
+  const centre = Cesium.Cartographic.fromCartesian(flights.at(-1).center);
+  assert.ok(
+    Math.abs(Math.abs(Cesium.Math.toDegrees(centre.longitude)) - 180) < 0.5,
+    `framed at ${Cesium.Math.toDegrees(centre.longitude)}°, not near 180°`,
+  );
+});
+
+test('hand-drawn marks: a voice mark or a hidden mark is not taken as their duplicate', async (t) => {
+  installAnimationFrameStubs(t);
+  _resetRenderGovernorForTest();
+  t.after(() => _resetRenderGovernorForTest());
+  const { renderer } = fakeRenderer();
+  const engine = createAnnotationEngine({ viewer: {}, renderer });
+  await engine.annotate(
+    [
+      {
+        type: 'pin',
+        manual: true,
+        latitude: 30.27,
+        longitude: -97.74,
+        label: 'Camp',
+      },
+    ],
+    { persist: true },
+  );
+  const [drawn] = engine.list();
+  // The agent marks the same spot with the same label, briefly.
+  await engine.annotate(
+    [{ type: 'pin', latitude: 30.27, longitude: -97.74, label: 'Camp' }],
+    {
+      persist: false,
+    },
+  );
+  assert.equal(engine.list().length, 2, 'the voice mark is its own mark');
+  assert.equal(drawn.ttlMs, null, 'the drawn pin keeps persisting');
+  assert.equal(drawn.manual, true);
+
+  engine.setHidden(drawn.id, true);
+  const again = await engine.annotate(
+    [
+      {
+        type: 'pin',
+        manual: true,
+        latitude: 30.27,
+        longitude: -97.74,
+        label: 'Camp',
+      },
+    ],
+    { persist: true },
+  );
+  assert.equal(again.drawn, 1);
+  const visible = engine.list().filter((mark) => mark.manual && !mark.hidden);
+  assert.equal(
+    visible.length,
+    1,
+    'a pin dropped on a hidden one is a new, visible pin',
+  );
+});
+
 test('hand-drawn marks: only a manual mark can be restyled', async (t) => {
   installAnimationFrameStubs(t);
   _resetRenderGovernorForTest();
diff --git a/src/annotations/drawMarkList.js b/src/annotations/drawMarkList.js
index dc6c24a72..6706f1b2a 100644
--- a/src/annotations/drawMarkList.js
+++ b/src/annotations/drawMarkList.js
@@ -60,36 +60,20 @@ export function createDrawMarkList({ listEl, annotations, listen }) {
   const doc = listEl.ownerDocument;
   let destroyed = false;
   let picking = null; // the id whose colour picker is open
+  /** @type {Map<string, object>} each listed mark's row nodes */
+  const rows = new Map();
+  let rendering = false;
+  let rerender = false;
 
   const marks = () =>
     (annotations.list?.() || []).filter((mark) => mark?.manual === true);
   const find = (id) => marks().find((mark) => mark.id === id) || null;
 
-  /** Which row control has focus, so a re-render can give it back. */
-  function focusedControl() {
-    const active = doc.activeElement;
-    if (!active || !listEl.contains?.(active)) return null;
-    const row = active.closest?.('[data-mark-id]');
-    return row
-      ? { id: row.dataset.markId, control: active.dataset?.control }
-      : null;
-  }
-
-  function restoreFocus(was) {
-    if (!was) return;
-    const row = [...listEl.querySelectorAll('[data-mark-id]')].find(
-      (node) => node.dataset.markId === was.id,
-    );
-    row?.querySelector?.(`[data-control="${was.control}"]`)?.focus?.();
-  }
-
-  function actionButton(icon, label, control) {
+  function actionButton(icon, control) {
     const button = doc.createElement('button');
     button.type = 'button';
     button.className = 'geo-import-action';
     button.dataset.control = control;
-    button.title = label;
-    button.setAttribute('aria-label', label);
     const glyph = doc.createElement('span');
     glyph.className = 'material-symbols-outlined';
     glyph.setAttribute('aria-hidden', 'true');
@@ -98,25 +82,24 @@ export function createDrawMarkList({ listEl, annotations, listen }) {
     return button;
   }
 
-  function colorPicker(mark) {
+  function setLabel(node, label) {
+    node.title = label;
+    node.setAttribute('aria-label', label);
+  }
+
+  function colorPicker() {
     const picker = doc.createElement('div');
     picker.className = 'draw-colors draw-mark-colors';
+    picker.dataset.control = 'picker';
     picker.setAttribute('role', 'radiogroup');
-    picker.setAttribute(
-      'aria-label',
-      t('Colour of {name}', { name: label(mark) }),
-    );
     for (const color of DRAW_COLORS) {
       const swatch = doc.createElement('button');
       swatch.type = 'button';
-      swatch.className = `draw-color${color === mark.color ? ' active' : ''}`;
+      swatch.className = 'draw-color';
       swatch.dataset.color = color;
       swatch.dataset.control = `color-${color}`;
       swatch.setAttribute('role', 'radio');
-      swatch.setAttribute('aria-checked', String(color === mark.color));
-      const name = t(COLOR_NAMES[color]);
-      swatch.title = name;
-      swatch.setAttribute('aria-label', name);
+      setLabel(swatch, t(COLOR_NAMES[color]));
       picker.append(swatch);
     }
     return picker;
@@ -124,75 +107,118 @@ export function createDrawMarkList({ listEl, annotations, listen }) {
 
   const label = (mark) => mark.name || drawMarkFallbackName(mark);
 
+  /** One row's nodes, built once and kept while its mark is on the board. */
+  function createRow(id) {
+    const row = doc.createElement('li');
+    row.className = 'geo-import-row draw-mark-row';
+    row.dataset.markId = id;
+
+    const swatch = doc.createElement('button');
+    swatch.type = 'button';
+    swatch.className = 'geo-import-swatch draw-mark-swatch';
+    swatch.dataset.control = 'swatch';
+
+    // textContent and value only, never markup: the name is typed text.
+    const name = doc.createElement('input');
+    name.type = 'text';
+    name.className = 'geo-import-name draw-mark-name';
+    name.dataset.control = 'name';
+    name.maxLength = 120;
+    name.autocomplete = 'off';
+    name.spellcheck = false;
+
+    const toggle = actionButton('visibility', 'toggle');
+    const fly = actionButton('my_location', 'fly');
+    const remove = actionButton('close', 'remove');
+    row.append(swatch, name, toggle, fly, remove);
+    return { row, swatch, name, toggle, fly, remove, picker: null };
+  }
+
+  function updateRow(nodes, mark) {
+    const { row, swatch, name, toggle, fly, remove } = nodes;
+    const title = label(mark);
+    row.classList.toggle('hidden-mark', Boolean(mark.hidden));
+    swatch.style.background = DRAW_COLOR_CSS[mark.color] || '';
+    setLabel(swatch, t('Change the colour of {name}', { name: title }));
+    swatch.setAttribute('aria-expanded', String(picking === mark.id));
+    // A name being typed is the person's draft: a board change elsewhere
+    // must not overwrite it.
+    if (doc.activeElement !== name) name.value = mark.name || '';
+    name.placeholder = drawMarkFallbackName(mark);
+    name.setAttribute('aria-label', t('Name of {name}', { name: title }));
+    const visible = !mark.hidden;
+    toggle.children[0].textContent = visible ? 'visibility' : 'visibility_off';
+    setLabel(
+      toggle,
+      visible
+        ? t('Hide {name}', { name: title })
+        : t('Show {name}', { name: title }),
+    );
+    toggle.setAttribute('aria-pressed', String(visible));
+    setLabel(fly, t('Fly to {name}', { name: title }));
+    setLabel(remove, t('Remove {name}', { name: title }));
+
+    if (picking === mark.id) {
+      nodes.picker ||= colorPicker();
+      nodes.picker.setAttribute(
+        'aria-label',
+        t('Colour of {name}', { name: title }),
+      );
+      for (const button of nodes.picker.children) {
+        const on = button.dataset.color === mark.color;
+        button.classList.toggle('active', on);
+        button.setAttribute('aria-checked', String(on));
+      }
+      if (nodes.picker.parentNode !== row) row.append(nodes.picker);
+    } else if (nodes.picker) {
+      nodes.picker.remove();
+      nodes.picker = null;
+    }
+  }
+
+  /**
+   * Bring the rows in line with the board. Rows are updated in place, never
+   * rebuilt: a rebuild would detach the button under a click that is half
+   * done, and the name field someone is typing in.
+   */
   function render() {
     if (destroyed) return;
-    const keep = focusedControl();
+    if (rendering) {
+      rerender = true;
+      return;
+    }
+    rendering = true;
+    try {
+      do {
+        rerender = false;
+        reconcile();
+      } while (rerender && !destroyed);
+    } finally {
+      rendering = false;
+    }
+  }
+
+  function reconcile() {
     const list = marks();
     if (picking && !list.some((mark) => mark.id === picking)) picking = null;
-    listEl.replaceChildren(
-      ...list.map((mark) => {
-        const row = doc.createElement('li');
-        row.className = 'geo-import-row draw-mark-row';
-        row.dataset.markId = mark.id;
-        if (mark.hidden) row.classList.add('hidden-mark');
-
-        const swatch = doc.createElement('button');
-        swatch.type = 'button';
-        swatch.className = 'geo-import-swatch draw-mark-swatch';
-        swatch.dataset.control = 'swatch';
-        swatch.style.background = DRAW_COLOR_CSS[mark.color] || '';
-        const swatchLabel = t('Change the colour of {name}', {
-          name: label(mark),
-        });
-        swatch.title = swatchLabel;
-        swatch.setAttribute('aria-label', swatchLabel);
-        swatch.setAttribute('aria-expanded', String(picking === mark.id));
-
-        // textContent and value only, never markup: the name is typed text.
-        const name = doc.createElement('input');
-        name.type = 'text';
-        name.className = 'geo-import-name draw-mark-name';
-        name.dataset.control = 'name';
-        name.maxLength = 120;
-        name.autocomplete = 'off';
-        name.spellcheck = false;
-        name.value = mark.name || '';
-        name.placeholder = drawMarkFallbackName(mark);
-        name.setAttribute(
-          'aria-label',
-          t('Name of {name}', { name: label(mark) }),
-        );
-
-        const visible = !mark.hidden;
-        const toggle = actionButton(
-          visible ? 'visibility' : 'visibility_off',
-          visible
-            ? t('Hide {name}', { name: label(mark) })
-            : t('Show {name}', { name: label(mark) }),
-          'toggle',
-        );
-        toggle.setAttribute('aria-pressed', String(visible));
-        row.append(
-          swatch,
-          name,
-          toggle,
-          actionButton(
-            'my_location',
-            t('Fly to {name}', { name: label(mark) }),
-            'fly',
-          ),
-          actionButton(
-            'close',
-            t('Remove {name}', { name: label(mark) }),
-            'remove',
-          ),
-        );
-        if (picking === mark.id) row.append(colorPicker(mark));
-        return row;
-      }),
-    );
+    const live = new Set(list.map((mark) => mark.id));
+    for (const [id, nodes] of rows) {
+      if (live.has(id)) continue;
+      nodes.row.remove();
+      rows.delete(id);
+    }
+    list.forEach((mark, index) => {
+      let nodes = rows.get(mark.id);
+      if (!nodes) {
+        nodes = createRow(mark.id);
+        rows.set(mark.id, nodes);
+      }
+      updateRow(nodes, mark);
+      // Move a row only when it is out of place, so a focused one stays put.
+      if (listEl.children[index] !== nodes.row)
+        listEl.insertBefore(nodes.row, listEl.children[index] || null);
+    });
     listEl.classList.toggle('visible', list.length > 0);
-    restoreFocus(keep);
   }
 
   const rowId = (node) => node?.closest?.('[data-mark-id]')?.dataset.markId;
@@ -203,10 +229,18 @@ export function createDrawMarkList({ listEl, annotations, listen }) {
     const mark = id && find(id);
     if (!mark) return;
     const next = input.value.trim();
+    input.value = next;
     if (next === (mark.name || '')) return;
     annotations.restyle(id, { name: next });
   }
 
+  /** Close a row's colour picker and give focus back to its swatch. */
+  function closePicker(id) {
+    picking = null;
+    render();
+    rows.get(id)?.swatch.focus?.();
+  }
+
   listen(listEl, 'click', (event) => {
     const control = event.target?.closest?.('[data-control]');
     const id = rowId(control);
@@ -216,15 +250,23 @@ export function createDrawMarkList({ listEl, annotations, listen }) {
       picking = picking === id ? null : id;
       render();
     } else if (kind.startsWith('color-')) {
+      const color = control.dataset.color;
       picking = null;
-      annotations.restyle(id, { color: control.dataset.color });
-      render();
+      if (find(id)?.color !== color) annotations.restyle(id, { color });
+      closePicker(id);
     } else if (kind === 'toggle') annotations.setHidden(id, !find(id)?.hidden);
     else if (kind === 'fly') annotations.frame(id);
     else if (kind === 'remove') annotations.remove(id);
   });
   listen(listEl, 'keydown', (event) => {
     const input = event.target;
+    if (event.key === 'Escape' && picking && rowId(input) === picking) {
+      // Escape closes the picker; it must not also leave Draw.
+      event.preventDefault();
+      event.stopPropagation();
+      closePicker(picking);
+      return;
+    }
     if (input?.dataset?.control !== 'name') return;
     if (event.key === 'Enter') {
       event.preventDefault();
@@ -252,6 +294,7 @@ export function createDrawMarkList({ listEl, annotations, listen }) {
       if (destroyed) return;
       destroyed = true;
       unsubscribe();
+      rows.clear();
       listEl.replaceChildren();
       listEl.classList.remove('visible');
     },
diff --git a/src/annotations/drawMarkList.test.mjs b/src/annotations/drawMarkList.test.mjs
index fb7567e60..68334b5c0 100644
--- a/src/annotations/drawMarkList.test.mjs
+++ b/src/annotations/drawMarkList.test.mjs
@@ -47,14 +47,31 @@ function fakeDocument() {
       getAttribute(key) {
         return this.attributes.get(key) ?? null;
       },
+      get parentNode() {
+        return this.parent;
+      },
       append(...nodes) {
-        for (const child of nodes) {
-          child.parent = this;
-          this.children.push(child);
-        }
+        for (const child of nodes) this.insertBefore(child, null);
+      },
+      insertBefore(child, before) {
+        child.remove();
+        child.parent = this;
+        const at = before ? this.children.indexOf(before) : -1;
+        if (at < 0) this.children.push(child);
+        else this.children.splice(at, 0, child);
+      },
+      remove() {
+        // Like a browser, taking the focused node out of the page blurs it.
+        if (doc.activeElement && this.contains(doc.activeElement))
+          doc.activeElement = null;
+        if (this.parent)
+          this.parent.children = this.parent.children.filter(
+            (node) => node !== this,
+          );
+        this.parent = null;
       },
       replaceChildren(...nodes) {
-        this.children = [];
+        for (const child of [...this.children]) child.remove();
         this.append(...nodes);
       },
       closest(selector) {
@@ -136,7 +153,22 @@ function harness(initial) {
   const rows = () => listEl.children;
   const control = (row, name) => row.querySelector(`[data-control="${name}"]`);
   const click = (target) => listeners.click({ target });
-  return { list, listEl, listeners, rows, control, click, calls, changed };
+  const addMark = (mark) => {
+    marks = [...marks, { hidden: false, ...mark }];
+    changed();
+  };
+  return {
+    list,
+    listEl,
+    listeners,
+    rows,
+    control,
+    click,
+    calls,
+    changed,
+    addMark,
+    changeListeners,
+  };
 }
 
 const LINE = {
@@ -251,11 +283,14 @@ test('a name is committed on Enter or blur, and Escape undoes the edit without l
 });
 
 test('a re-render keeps focus on the same control, and destroy stops listening', () => {
-  const { rows, control, list, listEl, changed } = harness([LINE]);
+  const { rows, control, list, listEl, changed, changeListeners } = harness([
+    LINE,
+  ]);
   control(rows()[0], 'fly').focus();
   changed();
   assert.equal(listEl.ownerDocument.activeElement, control(rows()[0], 'fly'));
   list.destroy();
+  assert.equal(changeListeners.size, 0, 'destroy unsubscribes from the board');
   assert.equal(rows().length, 0);
   assert.ok(!listEl.classList.contains('visible'));
   changed();
@@ -278,3 +313,64 @@ test('an unnamed shape is called by its kind', () => {
     'Line',
   );
 });
+
+test('a board change while a name is being typed keeps the draft and the row', () => {
+  const { rows, control, listEl, addMark, calls } = harness([LINE, PIN]);
+  const name = control(rows()[0], 'name');
+  name.focus();
+  name.value = 'Half-typ';
+  // A voice mark lands, and another hand-drawn one: neither may wipe the draft.
+  addMark(VOICE);
+  addMark({ ...PIN, id: 'a4', name: null, label: '' });
+  assert.equal(control(rows()[0], 'name'), name, 'the row is not rebuilt');
+  assert.equal(name.value, 'Half-typ', 'the typed text survives');
+  assert.equal(listEl.ownerDocument.activeElement, name, 'focus stays');
+  assert.equal(calls.length, 0, 'nothing is committed early');
+  assert.deepEqual(
+    rows().map((row) => row.dataset.markId),
+    ['a1', 'a2', 'a4'],
+  );
+});
+
+test('a click right after typing a name still reaches its button', () => {
+  const { rows, control, listeners, click, calls } = harness([LINE, PIN]);
+  const name = control(rows()[0], 'name');
+  name.focus();
+  name.value = 'Home';
+  const hide = control(rows()[1], 'toggle');
+  const remove = control(rows()[0], 'remove');
+  // mousedown on a button blurs the field first, which commits the name.
+  name.blur();
+  listeners.focusout({ target: name });
+  assert.deepEqual(calls.at(-1), ['restyle', 'a1', { name: 'Home' }]);
+  assert.equal(control(rows()[1], 'toggle'), hide, 'the button is still there');
+  click(hide);
+  assert.deepEqual(calls.at(-1), ['hide', 'a2', true]);
+  click(remove);
+  assert.deepEqual(calls.at(-1), ['remove', 'a1']);
+});
+
+test('picking a colour returns focus to the swatch; Escape closes the picker', () => {
+  const { rows, control, click, listeners, listEl, calls } = harness([LINE]);
+  const doc = listEl.ownerDocument;
+  click(control(rows()[0], 'swatch'));
+  click(control(rows()[0], 'color-primary'));
+  assert.equal(calls.length, 0, 'the colour it already has costs nothing');
+  assert.equal(doc.activeElement, control(rows()[0], 'swatch'));
+
+  click(control(rows()[0], 'swatch'));
+  const amber = control(rows()[0], 'color-amber');
+  amber.focus();
+  let stopped = false;
+  listeners.keydown({
+    key: 'Escape',
+    target: amber,
+    preventDefault() {},
+    stopPropagation() {
+      stopped = true;
+    },
+  });
+  assert.ok(stopped, 'Escape does not reach Draw');
+  assert.equal(control(rows()[0], 'color-amber'), null, 'the picker closed');
+  assert.equal(doc.activeElement, control(rows()[0], 'swatch'));
+});
diff --git a/src/annotations/drawTool.js b/src/annotations/drawTool.js
index c352f26e8..75419764a 100644
--- a/src/annotations/drawTool.js
+++ b/src/annotations/drawTool.js
@@ -310,6 +310,9 @@ export function initDrawTool({ viewer, annotations }) {
   };
   const onKey = (event) => {
     if (!active || destroyed || typingElsewhere(event)) return;
+    // Keys on the shape list's own controls are the list's (Esc closes a
+    // colour picker there), not the drawing's.
+    if (markListEl?.contains?.(event.target)) return;
     // Enter goes to finish() once a shape has been started; finish() owns the
     // decision and says WHY it refused. Swallowing the key on a degenerate
     // shape left the person pressing Enter at a silent panel. A focused button

From 0e90a03de702cccbc007ee19ed93d991379f9ab1 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Sun, 1 Nov 2026 21:03:12 -0800
Subject: [PATCH 49/70] Round every heading readout through one shared helper
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The transit, ALPR, vessel, CCTV and flight/military context fixes each
wrapped 359.5° to north with an inline Math.round(x) % 360. They now call
roundHeadingDegrees in src/data/headingDegrees.js, which also wraps negative
and multi-turn bearings. normalizeHeading moves there with it, and
cockpitMath re-exports it so existing imports keep working. It now adds a
turn only to a negative remainder, so a bearing just under half a degree
keeps its precision.

The awareness, Local ADS-B, cockpit wind, cockpit heading and Street Level
readouts use the same helper. The Cockpit's TRACK ACQUIRED signal rounded
without wrapping and could read COURSE 360°; it now uses
formatHeadingReadout, which shows --- for a track that is not finite.
---
 .../1454-voice-context-heading-north.md       |  3 ++
 docs/CURRENT-STATE.md                         |  1 +
 scripts/format-scope.json                     |  3 +-
 scripts/package-boundaries.json               | 14 ++++++
 src/cockpitMath.js                            | 14 +++---
 src/cockpitMath.test.mjs                      |  1 +
 src/data/headingDegrees.js                    | 19 ++++++++
 src/data/headingDegrees.test.mjs              | 47 +++++++++++++++++++
 src/layers/alpr/visuals.js                    |  4 +-
 src/layers/awareness/presentation.js          |  5 +-
 src/layers/cctv/headingConfidence.js          |  4 +-
 src/layers/flights/tracking.js                |  4 +-
 src/layers/localAdsb/card.js                  |  3 +-
 src/layers/military/tracking.js               |  4 +-
 src/layers/transit/policy.js                  |  4 +-
 src/layers/vessels/cards.js                   | 11 +++--
 src/ui/cctvPresentation.js                    |  3 +-
 src/ui/cockpitInstruments.js                  |  2 +-
 src/ui/cockpitPresentation.js                 |  9 ++--
 src/ui/cockpitTrackingController.js           |  5 +-
 src/ui/streetLevelPresentation.js             |  4 +-
 21 files changed, 128 insertions(+), 36 deletions(-)
 create mode 100644 src/data/headingDegrees.js
 create mode 100644 src/data/headingDegrees.test.mjs

diff --git a/changelog.d/1454-voice-context-heading-north.md b/changelog.d/1454-voice-context-heading-north.md
index ee9f3a63a..5653c4785 100644
--- a/changelog.d/1454-voice-context-heading-north.md
+++ b/changelog.d/1454-voice-context-heading-north.md
@@ -1,2 +1,5 @@
 - Describe a selected flight or military contact on 359.5° or more to the
   voice assistant as heading 0°, not 360° (Aditya, @Rohilalala, #1454).
+- Heading and bearing readouts share one rounding helper, so the Cockpit's
+  TRACK ACQUIRED course no longer reads 360°, and a negative bearing wraps
+  instead of printing a minus sign (#1454).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 1f30047d8..d243a3a51 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5757,6 +5757,7 @@ apply to `public/` assets or built-preview serving.
 - **Cockpit camera anchor:** first-person mode does not write feed-boundary corrections directly into the camera. A cockpit-only inertial anchor advances from the selected aircraft's displayed course and speed, then converges toward the authoritative delayed track with correction capped below forward motion. The displayed kinematics are derived from the same consecutive fix segment as the rendered position, with raw feed speed/course used only as fallback; a transient zero/missing feed speed therefore cannot freeze a visibly moving aircraft after layer enable or a map/cockpit handoff. Rendered altitude continues to come from that interpolated track position. Late ADS-B fixes and short render stalls can remove drift without accelerating or reversing the view. Camera placement runs before scene update/culling at a bounded 20 Hz so a moving cockpit does not force Photoreal 3D Tiles to retraverse on every display frame; textual instruments update at 10 Hz and context/layout work at 4 Hz. Every far Cockpit contact pip shares one stable Cesium texture-atlas entry and skips unused screen-projected course calculations, while only in-range 2D aircraft silhouettes pay the screen-projected rotation cost; ambient glTF collections are hidden/retained rather than synchronously destroyed at cockpit entry, and context rails lay out only on explicit content/state changes and viewport resize. The deliberate 15/30-second layer interpolation delays and per-Cesium-frame position caches remain unchanged.
 - **Cockpit route, vision, and view controls:** visible on-screen `COCKPIT`, `RESET`, and `EXIT COCKPIT` controls replace reliance on the `C` shortcut. RESET uses the same canonical globe route as the map and voice actions, exits Cockpit, and releases its camera ownership rather than exposing the hidden map-style top action. When the tracked commercial flight has a plausible ADSBDB route, the top of the right briefing rail shows a compact `FROM → TO` airport strip and the visor shows a centered estimated-destination chevron with its relative bearing; its destination label rounds to whole degrees in 000–359, wrapping rounded north to 000° while the chevron continues to use the relative bearing independently of label rounding; absent or implausible route data hides the strip and cue rather than guessing. The cockpit-local vision control is an interactive `PREV / CURRENT / NEXT` carousel over `NORMAL`, `CRT`, `NVG`, `FLIR`, `ANIME`, and `NOIR`; its previous/next actions wrap, and activating the current value advances to the next style. Cockpit enters on the active map preset, so a Cyber FLIR map opens Cockpit on FLIR while Normal remains a distinct option instead of producing a second FLIR entry. Cockpit choices temporarily activate the existing Cesium post-process stages, while exiting Cockpit through either EXIT or RESET restores the pre-entry map style. The regional-news page uses a free Google News RSS locality query first, with the existing GDELT query retained only as a fail-soft fallback; linked headlines remain reporting, not verified incidents or risk intelligence.
 - Cockpit wind-direction labels wrap after rounding to whole degrees, so a direction of 359.5° displays as `N · 0°` rather than `N · 360°`.
+- The transit, ALPR, vessel, CCTV, Local ADS-B, flight and military context, awareness, Cockpit and Street Level heading readouts round through `roundHeadingDegrees` in `src/data/headingDegrees.js` (whole degrees 0–359, `null` when not finite, so each caller keeps its own placeholder); `normalizeHeading` lives there too and `cockpitMath.js` re-exports it. The Cockpit's `TRACK ACQUIRED` signal uses `formatHeadingReadout`, so a 359.6° track reads `COURSE 000°`.
 - **Cockpit missing observations:** missing local weather observations remain unknown rather than being converted to zero or clear skies, in the briefing and in the cloud effects; a missing temperature drops the whole local weather record, including its wind and condition.
 - **Cockpit weather status:** the earlier multi-canvas atmospheric compositor remains fail-closed and is not attached to the live viewer. Cockpit clouds are a separate transparent WebGL pass with a capped 520×320 framebuffer, 24 ray steps, three FBM octaves, and a 12 FPS ceiling. It defaults off and starts only when local storage explicitly contains the persisted `WX ON` opt-in (`'1'`). When opted in, observations refresh after five minutes or 25 km of aircraft movement, fail transparent when unavailable or clear, and stop on exit or disable. `WX OFF` governs atmospheric rendering only: the briefing still fetches source-backed Natural Earth region, headline, and Open-Meteo local-information data, aborting and replacing any in-flight request when the selected aircraft changes. No weather effect runs in map mode and no synthetic fallback is shown.
 - **Cockpit trail visibility:** entering cockpit hides the selected aircraft's trail body and head so they cannot cross the first-person view; exit restores them. This cockpit-only presentation change does not alter the normal map-mode invariant that aircraft trails render through terrain using their depth-fail material.
diff --git a/scripts/format-scope.json b/scripts/format-scope.json
index c6ae4b493..abe454fe2 100644
--- a/scripts/format-scope.json
+++ b/scripts/format-scope.json
@@ -1180,5 +1180,6 @@
   "src/testSupport/hudReadouts.mjs",
   "src/ui/stores/firstRun.js",
   "src/firstRunLauncherView.test.mjs",
-  "src/firstRunCopy.js"
+  "src/firstRunCopy.js",
+  "src/data/headingDegrees.test.mjs"
 ]
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index c8783bde9..bf1eb1a3c 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -745,6 +745,7 @@
   "cctv-controls": {
     "exports": ["./ui/cctv"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/ui/cctv.js",
       "src/ui/cctvBindings.js",
       "src/ui/cctvCalibration.js",
@@ -814,6 +815,7 @@
       "./ui/cockpit/vision"
     ],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/ui/cockpit.js",
       "src/ui/cockpitBriefing.js",
       "src/ui/cockpitBriefPages.js",
@@ -883,6 +885,7 @@
   "ui-shell": {
     "exports": ["./ui/shell"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/i18n/marker.js",
       "src/ui/mobileShell.js",
       "src/exclusiveSurfaces.js",
@@ -1253,6 +1256,7 @@
   "civil-flights": {
     "exports": ["./layers/flights"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/i18n/marker.js",
       "src/cyberSonar.js",
       "src/data/aircraftClass.js",
@@ -1315,6 +1319,7 @@
   "military-flights": {
     "exports": ["./layers/military"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/i18n/marker.js",
       "src/cyberSonar.js",
       "src/data/aircraftClass.js",
@@ -1400,6 +1405,7 @@
   "vessel-layer": {
     "exports": ["./layers/vessels"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/layers/vessels/cards.js",
       "src/layers/vessels/evidence.js",
       "src/layers/vessels/index.js",
@@ -1645,6 +1651,7 @@
   "awareness-layer": {
     "exports": ["./layers/awareness"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/i18n/marker.js",
       "src/cyberSonar.js",
       "src/cockpitMath.js",
@@ -1783,6 +1790,7 @@
   "cctv-layer": {
     "exports": ["./layers/cctv"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/data/cctvCards.js",
       "src/data/cctvGizmo.js",
       "src/data/cctvLod.js",
@@ -1911,6 +1919,7 @@
   "alpr-cameras": {
     "exports": ["./layers/alpr"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/layers/alpr/index.js",
       "src/layers/alpr/model.js",
       "src/layers/alpr/policy.js",
@@ -2189,6 +2198,7 @@
       "./standalone/catalog"
     ],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/ui/placeNames.js",
       "src/cyberSonarScene.js",
       "src/cyberSonar.js",
@@ -3163,6 +3173,7 @@
   "application-layer-construction": {
     "exports": ["./application/layers"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/cyberSonar.js",
       "src/data/approxDistance.js",
       "src/data/bhoteKoshiEvent.js",
@@ -4319,6 +4330,7 @@
   "transit-standalone": {
     "exports": ["./layers/transit/standalone"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/cyberSonar.js",
       "src/celestialRing.js",
       "src/data/approxDistance.js",
@@ -4396,6 +4408,7 @@
   "transit-layer": {
     "exports": ["./layers/transit"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/data/iconOrientation.js",
       "src/data/inputOwnership.js",
       "src/data/transitFeeds.js",
@@ -4623,6 +4636,7 @@
   "tools": {
     "exports": ["./tools"],
     "modules": [
+      "src/data/headingDegrees.js",
       "src/tools/index.js",
       "src/tools/catalog.js",
       "src/tools/schema.js",
diff --git a/src/cockpitMath.js b/src/cockpitMath.js
index 888c33ead..3186b1f3c 100644
--- a/src/cockpitMath.js
+++ b/src/cockpitMath.js
@@ -1,10 +1,10 @@
-export { resolveHudRailLayout } from './ui/panelRailGeometry.js';
+import {
+  normalizeHeading,
+  roundHeadingDegrees,
+} from './data/headingDegrees.js';
 
-/** Normalize a heading into the [0, 360) range. */
-export function normalizeHeading(value) {
-  if (!Number.isFinite(value)) return 0;
-  return ((value % 360) + 360) % 360;
-}
+export { resolveHudRailLayout } from './ui/panelRailGeometry.js';
+export { normalizeHeading };
 
 /**
  * Three-digit heading readout, 000–359.
@@ -12,7 +12,7 @@ export function normalizeHeading(value) {
  */
 export function formatHeadingReadout(degrees) {
   if (!Number.isFinite(degrees)) return '---';
-  return String(Math.round(normalizeHeading(degrees)) % 360).padStart(3, '0');
+  return String(roundHeadingDegrees(degrees)).padStart(3, '0');
 }
 
 /** Advance a displayed heading along the shortest arc without exceeding a slew rate. */
diff --git a/src/cockpitMath.test.mjs b/src/cockpitMath.test.mjs
index e49b91a57..5a7f029c0 100644
--- a/src/cockpitMath.test.mjs
+++ b/src/cockpitMath.test.mjs
@@ -161,6 +161,7 @@ test('a heading that rounds to north reads 000, not 360', () => {
   assert.equal(formatHeadingReadout(359.4), '359');
   assert.equal(formatHeadingReadout(0), '000');
   assert.equal(formatHeadingReadout(10.2), '010');
+  assert.equal(formatHeadingReadout(-0.6), '359');
   assert.equal(formatHeadingReadout(Number.NaN), '---');
 });
 
diff --git a/src/data/headingDegrees.js b/src/data/headingDegrees.js
new file mode 100644
index 000000000..af2c1203a
--- /dev/null
+++ b/src/data/headingDegrees.js
@@ -0,0 +1,19 @@
+/** Normalize a heading into the [0, 360) range; 0 when it is not finite. */
+export function normalizeHeading(value) {
+  if (!Number.isFinite(value)) return 0;
+  // Only a negative remainder takes the extra turn, so a positive bearing
+  // keeps its precision (0.49999999999999 must not become 360.5).
+  const remainder = value % 360;
+  const wrapped = remainder < 0 ? remainder + 360 : remainder;
+  return wrapped === 360 ? 0 : wrapped;
+}
+
+/**
+ * Whole degrees for display, 0–359. 359.5° and above rounds to north (0),
+ * and negative or multi-turn values wrap. Null when the value is not finite,
+ * so each caller keeps its own placeholder.
+ */
+export function roundHeadingDegrees(value) {
+  if (!Number.isFinite(value)) return null;
+  return Math.round(normalizeHeading(value)) % 360;
+}
diff --git a/src/data/headingDegrees.test.mjs b/src/data/headingDegrees.test.mjs
new file mode 100644
index 000000000..021813eff
--- /dev/null
+++ b/src/data/headingDegrees.test.mjs
@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { normalizeHeading, roundHeadingDegrees } from './headingDegrees.js';
+
+test('normalizeHeading wraps into [0, 360) and reads a non-finite value as 0', () => {
+  assert.equal(normalizeHeading(370), 10);
+  assert.equal(normalizeHeading(-10), 350);
+  assert.equal(normalizeHeading(720), 0);
+  assert.equal(normalizeHeading(Number.NaN), 0);
+  assert.equal(normalizeHeading(Infinity), 0);
+});
+
+test('roundHeadingDegrees reads 359.5° and above as north, never 360', () => {
+  assert.equal(roundHeadingDegrees(359.4), 359);
+  assert.equal(roundHeadingDegrees(359.5), 0);
+  assert.equal(roundHeadingDegrees(359.6), 0);
+  assert.equal(roundHeadingDegrees(360), 0);
+  assert.equal(roundHeadingDegrees(0), 0);
+  assert.equal(roundHeadingDegrees(194.2), 194);
+});
+
+test('roundHeadingDegrees wraps negative and multi-turn bearings', () => {
+  assert.equal(Object.is(roundHeadingDegrees(-0.4), 0), true);
+  assert.equal(roundHeadingDegrees(-0.6), 359);
+  assert.equal(roundHeadingDegrees(-1), 359);
+  assert.equal(roundHeadingDegrees(719.6), 0);
+  assert.equal(roundHeadingDegrees(-360.6), 359);
+});
+
+test('roundHeadingDegrees returns null for a value that is not finite', () => {
+  for (const value of [
+    Number.NaN,
+    Infinity,
+    -Infinity,
+    null,
+    undefined,
+    '12',
+  ]) {
+    assert.equal(roundHeadingDegrees(value), null);
+  }
+});
+
+test('normalizeHeading keeps a positive bearing just under a half degree', () => {
+  assert.equal(roundHeadingDegrees(0.49999999999999), 0);
+  assert.equal(roundHeadingDegrees(359.49999999999994), 359);
+  assert.equal(normalizeHeading(-1e-15) < 360, true);
+});
diff --git a/src/layers/alpr/visuals.js b/src/layers/alpr/visuals.js
index 2a9202d92..9f4d9899a 100644
--- a/src/layers/alpr/visuals.js
+++ b/src/layers/alpr/visuals.js
@@ -5,6 +5,7 @@ import {
   DIRECTION_CONE_HALF_ANGLE_DEG,
   MARKER_SCALE_BY_DISTANCE,
 } from './policy.js';
+import { roundHeadingDegrees } from '../../data/headingDegrees.js';
 
 /**
  * Badge scale at a camera distance, matching Cesium's NearFarScalar for the
@@ -49,9 +50,8 @@ export function alprLabelDetails(record, source) {
   const details = [
     sourceName === 'OpenStreetMap' ? 'OSM MAPPED' : `Source: ${sourceName}`,
   ];
-  // Wrap after rounding: 359.6° rounds to 360°, which is north.
   if (Number.isFinite(record.directionDeg))
-    details.push(`DIRECTION ${Math.round(record.directionDeg) % 360}°`);
+    details.push(`DIRECTION ${roundHeadingDegrees(record.directionDeg)}°`);
   const equipment = [
     ...new Set(
       [record.manufacturer, record.operator, record.cameraType]
diff --git a/src/layers/awareness/presentation.js b/src/layers/awareness/presentation.js
index 7439907d9..854fee3b8 100644
--- a/src/layers/awareness/presentation.js
+++ b/src/layers/awareness/presentation.js
@@ -1,3 +1,5 @@
+import { roundHeadingDegrees } from '../../data/headingDegrees.js';
+
 /**
  * Format a compass direction for the awareness overlay.
  * @param {number} degrees
@@ -5,6 +7,5 @@
  */
 export function formatAwarenessDirection(degrees) {
   if (!Number.isFinite(degrees)) return '—';
-  const normalized = ((degrees % 360) + 360) % 360;
-  return String(Math.round(normalized) % 360).padStart(3, '0');
+  return String(roundHeadingDegrees(degrees)).padStart(3, '0');
 }
diff --git a/src/layers/cctv/headingConfidence.js b/src/layers/cctv/headingConfidence.js
index fad0867de..1c9be36fe 100644
--- a/src/layers/cctv/headingConfidence.js
+++ b/src/layers/cctv/headingConfidence.js
@@ -1,4 +1,5 @@
 import { t } from '../../i18n/index.js';
+import { roundHeadingDegrees } from '../../data/headingDegrees.js';
 
 /**
  * @module headingConfidence
@@ -44,8 +45,7 @@ export function isHeadingEstimated(camera) {
  * @returns {string}
  */
 export function headingHudToken(camera) {
-  // 359.5° and above rounds to north; modulo keeps it from printing 360°.
-  const hdg = Math.round(Number(camera?.headingDeg) || 0) % 360;
+  const hdg = roundHeadingDegrees(Number(camera?.headingDeg)) ?? 0;
   return isHeadingEstimated(camera)
     ? t('HDG {value}° (ESTIMATED)', { value: hdg })
     : t('HDG {value}°', { value: hdg });
diff --git a/src/layers/flights/tracking.js b/src/layers/flights/tracking.js
index dd61e6948..59270892e 100644
--- a/src/layers/flights/tracking.js
+++ b/src/layers/flights/tracking.js
@@ -24,6 +24,7 @@ import {
   TRAIL_COLOR,
   CYAN_TRANSPARENT,
 } from './policy.js';
+import { roundHeadingDegrees } from '../../data/headingDegrees.js';
 
 export function createTracking({
   flightState,
@@ -125,9 +126,8 @@ export function createTracking({
         speed: Number.isFinite(described.velocityMps)
           ? `${Math.round(described.velocityMps * 1.944)} kt`
           : '',
-        // 359.5° and above rounds to north; modulo keeps it from reading 360°.
         heading: Number.isFinite(described.track)
-          ? `${Math.round(described.track) % 360}°`
+          ? `${roundHeadingDegrees(described.track)}°`
           : '',
         route: route || '',
         icao24,
diff --git a/src/layers/localAdsb/card.js b/src/layers/localAdsb/card.js
index c1c923a8c..a17ba93c1 100644
--- a/src/layers/localAdsb/card.js
+++ b/src/layers/localAdsb/card.js
@@ -1,6 +1,7 @@
 import { AIRCRAFT_CLASS_LABELS } from '../../data/aircraftClass.js';
 import { formatNumber, t, tn } from '../../i18n/index.js';
 import { BAND_LABELS, LOCAL_ADSB_COLOR, SOURCE_LABELS } from './policy.js';
+import { roundHeadingDegrees } from '../../data/headingDegrees.js';
 
 const DASH = '—';
 
@@ -152,7 +153,7 @@ export function localAdsbCardModel(
       t('ALT {altitude} FT · GS {speed} KT · TRK {track}', {
         altitude: grouped(altitude),
         speed: speed === null ? DASH : speed,
-        track: track === null ? DASH : `${track % 360}°`,
+        track: track === null ? DASH : `${roundHeadingDegrees(track)}°`,
       }),
       vertical === null
         ? t('V/S {rate}', { rate: DASH })
diff --git a/src/layers/military/tracking.js b/src/layers/military/tracking.js
index b43a4d88b..5ad60adf9 100644
--- a/src/layers/military/tracking.js
+++ b/src/layers/military/tracking.js
@@ -25,6 +25,7 @@ import {
   AMBER_TRANSPARENT,
   TRACKED_ICON_COLOR,
 } from './policy.js';
+import { roundHeadingDegrees } from '../../data/headingDegrees.js';
 
 export function createTracking({
   flightState,
@@ -119,9 +120,8 @@ export function createTracking({
         speed: Number.isFinite(described.velocityMps)
           ? `${Math.round(described.velocityMps * 1.944)} kt`
           : '',
-        // 359.5° and above rounds to north; modulo keeps it from reading 360°.
         heading: Number.isFinite(described.track)
-          ? `${Math.round(described.track) % 360}°`
+          ? `${roundHeadingDegrees(described.track)}°`
           : '',
         icao24,
         // Honesty cue: the contact is coasting on dead reckoning, so the
diff --git a/src/layers/transit/policy.js b/src/layers/transit/policy.js
index 33e03aab4..eabe5df4a 100644
--- a/src/layers/transit/policy.js
+++ b/src/layers/transit/policy.js
@@ -9,6 +9,7 @@ import {
   transitRouteLabel,
 } from '../../data/transitFeeds.js';
 import { displayMotion, playbackPosition } from './movement.js';
+import { roundHeadingDegrees } from '../../data/headingDegrees.js';
 
 export const TRANSIT_SELECTED_OVERLAY_SOURCE_ID = 'transit-selected';
 export const TRANSIT_SELECTED_OVERLAY_SOURCE_OPTIONS = Object.freeze({
@@ -405,11 +406,10 @@ export function buildTransitSelectionCopy(
     reportedMotion.push(
       t('reported {speed} km/h', { speed: Math.round(record.speedMps * 3.6) }),
     );
-  // 359.5° and above rounds to north; modulo keeps it from printing 360°.
   if (Number.isFinite(record.bearing))
     reportedMotion.push(
       t('reported hdg {heading}°', {
-        heading: Math.round(record.bearing) % 360,
+        heading: roundHeadingDegrees(record.bearing),
       }),
     );
   // The operator's own claim, kept as a REPORT rather than as the live state.
diff --git a/src/layers/vessels/cards.js b/src/layers/vessels/cards.js
index 2cab53ed1..bcf3459f1 100644
--- a/src/layers/vessels/cards.js
+++ b/src/layers/vessels/cards.js
@@ -4,6 +4,7 @@ import {
   normalizeVesselType,
 } from '../../data/vesselLabels.js';
 import { formatNumber, t } from '../../i18n/index.js';
+import { roundHeadingDegrees } from '../../data/headingDegrees.js';
 
 export function createCards({
   vesselState,
@@ -55,10 +56,8 @@ export function createCards({
     if (record.speed !== null && record.speed !== undefined)
       parts.push(formatSpeed(record.speed));
     const direction = record.heading ?? record.course;
-    // A course of 359.5° and above rounds to north; modulo keeps it from
-    // printing 360°. The selected card and the HUD wrap the same way.
     if (Number.isFinite(direction))
-      parts.push(`${Math.round(direction) % 360}°`);
+      parts.push(`${roundHeadingDegrees(direction)}°`);
     return {
       id: vesselOverlayEntryId(record),
       actionable: Boolean(record?.mmsi),
@@ -89,7 +88,9 @@ export function createCards({
       [
         vesselTypeShort(record) || t('VESSEL'),
         formatSpeed(record.speed),
-        Number.isFinite(direction) ? `${Math.round(direction) % 360}°` : '--°',
+        Number.isFinite(direction)
+          ? `${roundHeadingDegrees(direction)}°`
+          : '--°',
       ].join(' · '),
     ];
     const destination = String(record.destination || '').trim();
@@ -179,7 +180,7 @@ export function createCards({
 
   function formatHeading(heading) {
     return t('{heading}DEG', {
-      heading: Number.isFinite(heading) ? Math.round(heading) % 360 : '--',
+      heading: roundHeadingDegrees(heading) ?? '--',
     });
   }
 
diff --git a/src/ui/cctvPresentation.js b/src/ui/cctvPresentation.js
index cd298e108..2d5b398cc 100644
--- a/src/ui/cctvPresentation.js
+++ b/src/ui/cctvPresentation.js
@@ -3,6 +3,7 @@ import { cctvSourceLabelText, cctvSourceMessageText } from './cctvFrames.js';
 
 import { createCctvVideoSurface } from './cctvVideo.js';
 import { presentCctvCalibration } from './cctvCalibration.js';
+import { roundHeadingDegrees } from '../data/headingDegrees.js';
 export function _calBadgeLabel(badge) {
   switch (badge) {
     case 'calibrated':
@@ -107,7 +108,7 @@ function metaText(state, enabled, activeCamera, catalogCount) {
         '{city} · HDG {heading} · FOV {fov} · RANGE {range}m · {projection}{calBadge} · {provider}{status}',
         {
           city: activeCamera.city,
-          heading: `${Math.round(activeCamera.headingDeg) % 360}°`,
+          heading: `${roundHeadingDegrees(Number(activeCamera.headingDeg)) ?? 0}°`,
           fov: `${Math.round(activeCamera.fovDeg)}°`,
           range: Math.round(activeCamera.rangeM),
           projection: projLabel,
diff --git a/src/ui/cockpitInstruments.js b/src/ui/cockpitInstruments.js
index 484125db1..dc9964ff8 100644
--- a/src/ui/cockpitInstruments.js
+++ b/src/ui/cockpitInstruments.js
@@ -120,7 +120,7 @@ export function updateHud(
     (tick) => formatAltitudeRulerTick(tick.valueFt),
   );
   view.heading = {
-    text: String(Math.round(heading) % 360).padStart(3, '0'),
+    text: formatHeadingReadout(heading),
     value: heading,
     immediate: forceContext,
   };
diff --git a/src/ui/cockpitPresentation.js b/src/ui/cockpitPresentation.js
index e787b79e0..6b557de7d 100644
--- a/src/ui/cockpitPresentation.js
+++ b/src/ui/cockpitPresentation.js
@@ -1,6 +1,10 @@
 /** Pure formatting and fixed presentation constants used by Cockpit components. */
 import { formatNumber, getLocale, isolate, t, msg } from '../i18n/index.js';
 import { formatQuantity } from './unitLabels.js';
+import {
+  normalizeHeading,
+  roundHeadingDegrees,
+} from '../data/headingDegrees.js';
 
 export const COCKPIT_HEADING_SLEW_DPS = 28;
 
@@ -135,8 +139,7 @@ export function cockpitUnitCase(text) {
 export function formatCockpitWindDirection(value) {
   if (!Number.isFinite(value)) return t('DIR UNKNOWN');
   const labels = Object.keys(COMPASS_POINT_LABELS);
-  const normalized = ((value % 360) + 360) % 360;
-  // 359.5° and above is north. Modulo keeps that from printing 360°.
-  const degrees = Math.round(normalized) % 360;
+  const normalized = normalizeHeading(value);
+  const degrees = roundHeadingDegrees(value);
   return `${compassPointLabel(labels[Math.round(normalized / 45) % labels.length])} · ${degrees}°`;
 }
diff --git a/src/ui/cockpitTrackingController.js b/src/ui/cockpitTrackingController.js
index b945da4de..f308b0d2f 100644
--- a/src/ui/cockpitTrackingController.js
+++ b/src/ui/cockpitTrackingController.js
@@ -1,6 +1,7 @@
 /** Tracking identity, entry, exit and contact navigation for the Cockpit controller. */
 import { t } from '../i18n/index.js';
 import {
+  formatHeadingReadout,
   normalizeHeading,
   resolveTrackedAircraftInfo,
 } from '../cockpitMath.js';
@@ -186,9 +187,7 @@ export function enter() {
   this.startBriefRotation();
   const trackLabel =
     info.callsign || info.registration || info.icao24 || t('AIRCRAFT');
-  const trackHeading = String(
-    Math.round(normalizeHeading(info.track ?? 0)),
-  ).padStart(3, '0');
+  const trackHeading = formatHeadingReadout(info.track ?? 0);
   this.pushCockpitSignal(
     'track',
     'track',
diff --git a/src/ui/streetLevelPresentation.js b/src/ui/streetLevelPresentation.js
index d7359dfec..95af86b1a 100644
--- a/src/ui/streetLevelPresentation.js
+++ b/src/ui/streetLevelPresentation.js
@@ -7,6 +7,7 @@ import {
   translateKnown,
 } from '../i18n/index.js';
 import { keyGuidanceText, keyRequirementText } from './keyGuidance.js';
+import { roundHeadingDegrees } from '../data/headingDegrees.js';
 
 // Street Level UI state to panel strings and flags. Pure, so it is testable.
 
@@ -175,9 +176,8 @@ function presentViewer(state) {
   const { street } = state;
   const right = [];
   if (street.isPano) right.push('360°');
-  // 359.5° and above rounds to north; modulo keeps it from printing 360°.
   if (Number.isFinite(street.bearing))
-    right.push(`${Math.round(street.bearing) % 360}°`);
+    right.push(`${roundHeadingDegrees(street.bearing)}°`);
   if (street.capturedAt)
     right.push(formatDate(street.capturedAt, street.capturedAtPrecision));
   const left = [];

From d546d65380bb9247d783f9c694da6fb9fac949eb Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Sun, 1 Nov 2026 20:45:03 -0800
Subject: [PATCH 50/70] feat(kit): show the panel rails as labelled pills until
 a panel opens

UiRail takes `collapsible`: while no panel on its side is open, each item
shows its icon and label as a pill, and once one opens the labels fold away
to the icon rail, making room for the panel. The tip is not shown while the
label is on screen; the button keeps its accessible name and the visible
label is hidden from assistive technology. The side panel rails turn it on.

Each rail is now placed by its screen-side edge, at the rail clearance, so a
rail that widens grows toward the middle of the screen; collapsed, it sits
6px outside its stack as before.
---
 docs/CURRENT-STATE.md      |  4 +++
 src/ui/PanelRailView.vue   |  1 +
 src/ui/kit/UiRail.test.mjs | 72 ++++++++++++++++++++++++++++++++++++++
 src/ui/kit/UiRail.vue      | 61 ++++++++++++++++++++++++++++++--
 src/ui/rtlLayout.test.mjs  | 14 +++++---
 src/ui/styles/kit.css      | 45 ++++++++++++++++++++++++
 src/ui/styles/layers.css   |  7 ++--
 7 files changed, 195 insertions(+), 9 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 567de41e4..a89d18892 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -1582,6 +1582,10 @@ Imagery (while shown), Street Level and Context on the right. Selecting an item
 opens its panel through `setPanelCollapsed(id, false, {explicit: true})`;
 selecting the open panel's item closes it. The item of the open panel is
 pressed (`aria-pressed`), and its tooltip is suppressed while the panel is open.
+While no panel on its side is open, the rail shows each item as a labelled pill
+(icon and title, `UiRail`'s `collapsible`); opening a panel folds the labels away
+to the icon rail. The rail is placed by its screen-side edge, so the pills grow
+toward the middle of the screen, over the closed side's empty corridor.
 
 One panel is open per desktop side, in every HUD layout. Opening a side panel
 by any route (rail, header, keyboard, voice) collapses its peers; restored or
diff --git a/src/ui/PanelRailView.vue b/src/ui/PanelRailView.vue
index 8f43dabb2..8ac9fb256 100644
--- a/src/ui/PanelRailView.vue
+++ b/src/ui/PanelRailView.vue
@@ -42,6 +42,7 @@ const label = computed(() =>
     :side="side"
     :label="label"
     :panel-open="active !== null"
+    collapsible
     @select="onSelect"
   />
 </template>
diff --git a/src/ui/kit/UiRail.test.mjs b/src/ui/kit/UiRail.test.mjs
index 6c443286a..57a0ff09d 100644
--- a/src/ui/kit/UiRail.test.mjs
+++ b/src/ui/kit/UiRail.test.mjs
@@ -71,3 +71,75 @@ test('tips open toward the screen, and not for the open panel', async () => {
   await other.trigger('focusout');
   assert.equal(wrapper.find('[role="tooltip"]').exists(), false);
 });
+
+test('a collapsible rail shows labelled pills until a panel opens', async () => {
+  const wrapper = mountRail({ collapsible: true });
+  const nav = wrapper.get('nav');
+  assert.ok(nav.classes().includes('ui-rail--collapsible'));
+  assert.ok(nav.classes().includes('ui-rail--expanded'));
+  assert.deepEqual(
+    wrapper.findAll('.ui-rail__label').map((label) => label.text()),
+    ['DATA LAYERS', 'AUTHORING', 'CCTV'],
+  );
+  // The label is on screen, so its tip would only repeat it.
+  await wrapper.findAll('.ui-tooltip')[0].trigger('focusin');
+  assert.equal(wrapper.find('[role="tooltip"]').exists(), false);
+  // The button keeps its own accessible name; the visible label is hidden
+  // from assistive technology so the name is not read twice.
+  const button = wrapper.get('[data-rail-item="layers"]');
+  assert.equal(button.attributes('aria-label'), 'DATA LAYERS');
+  assert.equal(button.get('.ui-rail__label').attributes('aria-hidden'), 'true');
+
+  await wrapper.setProps({ active: 'layers', panelOpen: true });
+  assert.ok(nav.classes().includes('ui-rail--collapsible'));
+  assert.equal(nav.classes().includes('ui-rail--expanded'), false);
+  // Collapsed, the other items' tips come back.
+  await wrapper.findAll('.ui-tooltip')[1].trigger('focusin');
+  await new Promise((resolve) => setTimeout(resolve, 450));
+  assert.equal(wrapper.get('[role="tooltip"]').text(), 'AUTHORING');
+});
+
+test('a label cut short by the pill keeps its tip', async (t) => {
+  const observers = [];
+  const original = globalThis.ResizeObserver;
+  globalThis.ResizeObserver = class {
+    constructor(callback) {
+      this.callback = callback;
+      this.targets = [];
+      observers.push(this);
+    }
+    observe(target) {
+      this.targets.push(target);
+    }
+    unobserve() {}
+    disconnect() {}
+  };
+  t.after(() => (globalThis.ResizeObserver = original));
+  const wrapper = mountRail({ collapsible: true });
+  const [observer] = observers;
+  const [layers, scenes] = observer.targets;
+  Object.defineProperties(layers, {
+    scrollWidth: { value: 260 },
+    clientWidth: { value: 220 },
+  });
+  Object.defineProperties(scenes, {
+    scrollWidth: { value: 90 },
+    clientWidth: { value: 90 },
+  });
+  observer.callback([{ target: layers }, { target: scenes }]);
+  await wrapper.vm.$nextTick();
+  await wrapper.findAll('.ui-tooltip')[0].trigger('focusin');
+  assert.equal(wrapper.get('[role="tooltip"]').text(), 'DATA LAYERS');
+  await wrapper.findAll('.ui-tooltip')[0].trigger('focusout');
+  await wrapper.findAll('.ui-tooltip')[1].trigger('focusin');
+  assert.equal(wrapper.find('[role="tooltip"]').exists(), false);
+});
+
+test('a plain rail has no labels', () => {
+  const wrapper = mountRail();
+  assert.equal(wrapper.find('.ui-rail__label').exists(), false);
+  assert.equal(
+    wrapper.get('nav').classes().includes('ui-rail--expanded'),
+    false,
+  );
+});
diff --git a/src/ui/kit/UiRail.vue b/src/ui/kit/UiRail.vue
index af740aae3..4e2bf6836 100644
--- a/src/ui/kit/UiRail.vue
+++ b/src/ui/kit/UiRail.vue
@@ -1,9 +1,10 @@
 <script setup>
+import { computed, onBeforeUnmount, reactive } from 'vue';
 import UiIcon from './UiIcon.vue';
 import UiTooltip from './UiTooltip.vue';
 import { RAIL_PANEL_OPEN_TOOLTIP_DELAY_MS } from './rail.js';
 
-defineProps({
+const props = defineProps({
   /** @type {import('vue').PropType<import('./rail.js').UiRailItem[]>} */
   items: { type: Array, required: true },
   /** The selected item's id, or null. */
@@ -17,18 +18,65 @@ defineProps({
    * panel's title, and the other tips wait for the pointer to rest.
    */
   panelOpen: { type: Boolean, default: false },
+  /**
+   * Show each item as a labelled pill while no panel is open, and collapse to
+   * icons once one is, making room for the panel.
+   */
+  collapsible: { type: Boolean, default: false },
 });
 const emit = defineEmits(['select']);
+const expanded = computed(() => props.collapsible && !props.panelOpen);
+
+// A label cut short by the pill's width keeps its tip, so the full name can
+// still be read. Each label is measured whenever its box changes size, which
+// includes the moment it settles after expanding.
+const truncated = reactive(new Set());
+const labelIds = new WeakMap();
+const labelElements = new Map();
+const labelObserver =
+  typeof ResizeObserver === 'function'
+    ? new ResizeObserver((entries) => {
+        for (const { target } of entries) {
+          const id = labelIds.get(target);
+          if (target.scrollWidth > target.clientWidth) truncated.add(id);
+          else truncated.delete(id);
+        }
+      })
+    : null;
+function trackLabel(id, element) {
+  const previous = labelElements.get(id);
+  if (previous === element) return;
+  if (previous) {
+    labelObserver?.unobserve(previous);
+    labelElements.delete(id);
+    truncated.delete(id);
+  }
+  if (!element) return;
+  labelElements.set(id, element);
+  labelIds.set(element, id);
+  labelObserver?.observe(element);
+}
+onBeforeUnmount(() => labelObserver?.disconnect());
+const tipHidden = (item) =>
+  (expanded.value && !truncated.has(item.id)) ||
+  (props.panelOpen && item.id === props.active);
 </script>
 
 <template>
-  <nav class="ui-rail" :class="`ui-rail--${side}`" :aria-label="label">
+  <nav
+    class="ui-rail"
+    :class="[
+      `ui-rail--${side}`,
+      { 'ui-rail--collapsible': collapsible, 'ui-rail--expanded': expanded },
+    ]"
+    :aria-label="label"
+  >
     <template v-for="item in items" :key="item.id">
       <i v-if="item.separatorBefore" class="ui-rail__sep" aria-hidden="true" />
       <UiTooltip
         :text="item.label"
         :side="side === 'left' ? 'right' : 'left'"
-        :disabled="panelOpen && item.id === active"
+        :disabled="tipHidden(item)"
         :delay="panelOpen ? RAIL_PANEL_OPEN_TOOLTIP_DELAY_MS : 0"
       >
         <button
@@ -42,6 +90,13 @@ const emit = defineEmits(['select']);
           @click="emit('select', item.id)"
         >
           <UiIcon :name="item.icon" />
+          <span
+            v-if="collapsible"
+            :ref="(element) => trackLabel(item.id, element)"
+            class="ui-rail__label"
+            aria-hidden="true"
+            >{{ item.label }}</span
+          >
           <span v-if="item.badge !== undefined" class="ui-rail__badge">{{
             item.badge
           }}</span>
diff --git a/src/ui/rtlLayout.test.mjs b/src/ui/rtlLayout.test.mjs
index a28ddcaa5..79341ad12 100644
--- a/src/ui/rtlLayout.test.mjs
+++ b/src/ui/rtlLayout.test.mjs
@@ -66,13 +66,19 @@ test('the Cyber cockpit keeps Data Layers on the left edge in every language', (
 
 test('the panel rails stay on the outer side of their stacks in right-to-left', () => {
   const layers = sheet('layers.css');
-  // Each rail is placed against its stack's outer edge; a physical side
-  // would put it over the panels once the stacks swap sides.
+  // Each rail is placed by its screen-side edge; a physical side would put
+  // it over the panels once the stacks swap sides.
   const left = ruleBody(layers, '.gev-panel-rail--left');
-  assert.match(left, /inset-inline-end: calc\(100% \+ 6px\);/);
+  assert.match(
+    left,
+    /inset-inline-start: calc\(-1 \* var\(--panel-rail-clearance\)\);/,
+  );
   assert.doesNotMatch(left, /(?:^|\s)(?:left|right):/);
   const right = ruleBody(layers, '.gev-panel-rail--right');
-  assert.match(right, /inset-inline-start: calc\(100% \+ 6px\);/);
+  assert.match(
+    right,
+    /inset-inline-end: calc\(-1 \* var\(--panel-rail-clearance\)\);/,
+  );
   assert.doesNotMatch(right, /(?:^|\s)(?:left|right):/);
   // Their tips open toward the middle of the screen.
   const kit = sheet('kit.css');
diff --git a/src/ui/styles/kit.css b/src/ui/styles/kit.css
index 4ceb796d7..0f1622c79 100644
--- a/src/ui/styles/kit.css
+++ b/src/ui/styles/kit.css
@@ -116,6 +116,51 @@
   opacity: 0.35;
   cursor: default;
 }
+
+/* A collapsible rail shows each item as an icon and its label while no panel
+   is open, and folds the labels away once one is. The collapsed item keeps
+   the plain rail's 32px square. */
+.ui-rail--collapsible {
+  transition: border-radius var(--transition-fast);
+}
+.ui-rail--collapsible .ui-rail__item {
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+  width: 100%;
+  min-width: 32px;
+  padding: 0 6px;
+  transition:
+    color var(--transition-fast),
+    background var(--transition-fast),
+    border-color var(--transition-fast),
+    border-radius var(--transition-fast);
+}
+.ui-rail__label {
+  max-width: 0;
+  overflow: hidden;
+  opacity: 0;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  font: var(--dock-label-font-weight) var(--dock-label-font-size) / 1
+    var(--font-sans);
+  letter-spacing: var(--dock-label-letter-spacing);
+  transition:
+    max-width var(--transition-fast),
+    margin var(--transition-fast),
+    opacity var(--transition-fast);
+}
+.ui-rail--expanded {
+  border-radius: 21px;
+}
+.ui-rail--expanded .ui-rail__item {
+  border-radius: 16px;
+}
+.ui-rail--expanded .ui-rail__label {
+  max-width: 220px;
+  margin-inline: 8px 8px;
+  opacity: 1;
+}
 .ui-rail__badge {
   position: absolute;
   top: 1px;
diff --git a/src/ui/styles/layers.css b/src/ui/styles/layers.css
index 42e633754..51e4bfc8d 100644
--- a/src/ui/styles/layers.css
+++ b/src/ui/styles/layers.css
@@ -255,11 +255,14 @@
   pointer-events: auto;
   transition: top var(--transition-fast);
 }
+/* Each rail keeps its outer edge at the screen-side clearance, so a rail that
+   widens (labelled pills while its side has no open panel) grows toward the
+   middle of the screen. Collapsed, it sits 6px outside its stack. */
 .gev-panel-rail--left {
-  inset-inline-end: calc(100% + 6px);
+  inset-inline-start: calc(-1 * var(--panel-rail-clearance));
 }
 .gev-panel-rail--right {
-  inset-inline-start: calc(100% + 6px);
+  inset-inline-end: calc(-1 * var(--panel-rail-clearance));
 }
 body.mobile-shell #left-panel-stack > .gev-panel-rail,
 body.mobile-shell #right-context-rail > .gev-panel-rail,

From c6fff6e7b8e1ca67fe1710271aef3d1bdb9dfaff Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Sun, 1 Nov 2026 21:37:30 -0800
Subject: [PATCH 51/70] changelog: note the rail pills

---
 changelog.d/1501-rail-pills.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 changelog.d/1501-rail-pills.md

diff --git a/changelog.d/1501-rail-pills.md b/changelog.d/1501-rail-pills.md
new file mode 100644
index 000000000..61d23a38b
--- /dev/null
+++ b/changelog.d/1501-rail-pills.md
@@ -0,0 +1,3 @@
+- The side panel rails show each panel as a labelled pill while no panel on
+  that side is open, and fold to icons once one opens. `UiRail` takes
+  `collapsible` for this (samehkhamis, #1501).

From d14205160a7f904e8714b076bd0d734125aadca2 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Sun, 1 Nov 2026 21:14:16 -0800
Subject: [PATCH 52/70] Format every metre/kilometre distance through one
 shared helper

Directions, the Contacts marker and panel, placed annotation labels, the
drawn-line measure, the Cockpit and formatRouteDistance each chose the unit
and precision on their own, and most chose before rounding: #1450, #1433 and
formatDistanceText or kilometreDigits from src/data/distanceFormat.js, which
cut after rounding. Each keeps its own metre step and rendering.

That also fixes the 10 km cut the Contacts marker and panel, the drawn-line
measure and the Cockpit still had (9,960 m read 10.0 km). The helper returns
kilometres already rounded, so the plain marker and the localized panel no
longer disagree on half-tenths such as 1,450 m.

A negative annotation distance now leaves the label without a distance, and
a drawn line with a coordinate that is not a number shows no measure, rather
than printing 0 m or NaN km. The HUD altitude tag and the spoken view height
keep their own unit choice.
---
 .../1433-awareness-marker-kilometre.md        |  3 ++
 docs/CURRENT-STATE.md                         | 16 +++++-
 scripts/format-scope.json                     |  3 +-
 scripts/package-boundaries.json               |  8 +++
 src/annotations/annotationEngine.js           |  8 +--
 src/annotations/drawMode.js                   |  7 +--
 src/annotations/drawMode.test.mjs             |  8 +++
 src/data/distanceFormat.js                    | 43 ++++++++++++++++
 src/data/distanceFormat.test.mjs              | 50 +++++++++++++++++++
 src/data/militaryAwareness.test.mjs           |  3 ++
 src/data/militaryAwarenessEngine.js           |  8 +--
 src/data/militaryAwarenessEngine.test.mjs     |  3 ++
 src/data/routeSteps.js                        |  8 ++-
 src/data/routeSteps.test.mjs                  |  2 +
 src/layers/awareness/panel.js                 | 13 +++--
 src/layers/directions/index.js                | 19 +++----
 src/ui/cockpitPresentation.js                 |  3 +-
 src/ui/cockpitPresentation.test.mjs           | 10 +++-
 18 files changed, 169 insertions(+), 46 deletions(-)
 create mode 100644 src/data/distanceFormat.js
 create mode 100644 src/data/distanceFormat.test.mjs

diff --git a/changelog.d/1433-awareness-marker-kilometre.md b/changelog.d/1433-awareness-marker-kilometre.md
index 86cfbd431..a62cdd90c 100644
--- a/changelog.d/1433-awareness-marker-kilometre.md
+++ b/changelog.d/1433-awareness-marker-kilometre.md
@@ -1,3 +1,6 @@
 - Show a Contacts marker 999.5 m or more away as 1.0 km. The on-globe marker
   chose metres before rounding, so 999.6 m read "1000 m" while the panel read
   "1.0 km" (Aditya, @Rohilalala, #1433).
+- Distance labels share one formatter that takes each unit cut after rounding,
+  so the Contacts panel and markers, the drawn-line measure and the Cockpit
+  show 9.96 km as 10 km rather than 10.0 km (#1433).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 86ee39dc3..e2f776810 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -4614,7 +4614,19 @@ point is the right-side `CONTEXT` chooser's `CONTACTS` mode.
 
 Contacts distance labels, in the panel and on the globe's contact markers,
 select metres or kilometres after rounding to the nearest metre, so a
-999.5-metre contact displays as `1.0 km`, not `1000 m`.
+999.5-metre contact displays as `1.0 km`, not `1000 m`, and drop the
+kilometre decimal from 9.95 km, so 9,960 m displays as `10 km`.
+
+Distance labels that switch between metres and kilometres share
+`distanceParts` / `formatDistanceText` in `src/data/distanceFormat.js`: the
+Contacts panel and markers, Directions rows and step cards, placed annotation
+labels, the drawn-line measure and `formatRouteDistance`. Each cut is taken on
+the value as it prints, and kilometres come back already rounded, so the
+plain and localized labels agree. Callers choose the metre step (whole metres;
+tens, as annotation labels use; or tens with whole metres under 100, as
+Directions uses) and keep their own rendering; the Cockpit's kilometre-only
+distance uses `kilometreDigits`. The HUD altitude tag and the spoken view
+height still choose their own unit.
 
 At global scale, ambient Radio cluster badges are hard-opacity shared-host
 entries: count/category updates and identity replacement do not run keyhole or
@@ -5500,7 +5512,7 @@ request viewbox and continues searching without that geographic preference.
 - **A vertex is a lon/lat, and the mark is DRAPED.** Clicks are picked through `pickWorldFromScreen` — one of two scene helpers the annotation resolver factory (`src/annotations/resolver.js`) exposes alongside `sampleGroundHeight`, so the app has ONE depth-aware pick cascade rather than a second written beside it — which returns the height the pick landed on as well as the coordinate, so the live preview hangs on the roof or hillside under the pointer instead of sinking to sea level. The world renderer draws areas and routes with `clampToGround`, so the height is dropped at finish in one place (`finishSpec`) rather than being carried downstream and discarded silently: what you get is the outline you drew, lying on the surface beneath it.
 - **Draped marks classify onto `ClassificationType.BOTH`** — terrain AND 3D tiles — not onto 3D tiles alone. With only `CESIUM_3D_TILE`, every area fill, area outline, route and arrow rendered to nothing on a keyless boot, where Cesium's own globe carries Esri/OSM imagery and there are no tiles to classify against; the labels appeared and the geometry did not. That hit spoken annotations exactly as hard as hand-drawn ones. `scripts/qa-draw-tool.mjs` counts the mark's own colour in the rendered frame before and after a shape is finished, on a keyed AND a keyless server, so "the board says there is a mark" can no longer pass for "the mark is on screen".
 - **A finished area is a CLOSED ring.** The fill polygon closes itself but the outline beside it is a polyline, so an open ring drew every edge except the one back to the first vertex — a triangle with two sides. `finishSpec` repeats the first position at the end. A line is never closed: joining its ends would invent a segment nobody drew.
-- Drawn-line distance labels select metres or kilometres after rounding to the nearest metre, so a 999.5-metre line displays as `1.0 km` rather than `1000 m`. The placed mark's label (shared with spoken routes and arrows) rounds before each unit cut, so a 996-metre line is labelled `1.0 km`, not `1000 m`, and a 9,960-metre one `10 km`, not `10.0 km`.
+- Drawn-line distance labels select metres or kilometres after rounding to the nearest metre, so a 999.5-metre line displays as `1.0 km` rather than `1000 m`, and drop the kilometre decimal from 9.95 km. The placed mark's label (shared with spoken routes and arrows) rounds before each unit cut, so a 996-metre line is labelled `1.0 km`, not `1000 m`, and a 9,960-metre one `10 km`, not `10.0 km`.
 - **Measurements and centres are computed on unwrapped longitudes** (`unwrapLongitudes` / `wrapLongitude` in `drawMode.js`, used by `ringAreaM2`, `ringCentroid` and the engine's manual-area anchor). A ~50,000 m² rectangle straddling the antimeridian reads its 0.002° width as 359.998° under raw arithmetic: it measured thousands of square kilometres and anchored on the Greenwich meridian, half a world from the shape. Path length was already safe — haversine is periodic in the longitude delta — and a test pins that so a "fix" cannot break it.
 - **Bounds.** One shape holds at most `MAX_VERTICES` = 512 points; two clicks within 0.5 m are one vertex (that is what makes a double-click finish without leaving a stray point); a vertex that is not a finite on-globe coordinate is refused. A shape that encloses nothing is refused rather than placed: three collinear points are not an area and a line under a metre long is not a line, and the hint says which.
 - Drawn-area measures round before choosing m², ha or km², so 9,999.6 m² displays as `1.0 ha`, not `10000 m²`, and 999,960 m² as `1.00 km²`, not `100.0 ha`.
diff --git a/scripts/format-scope.json b/scripts/format-scope.json
index f78a6a70c..0cd9edca5 100644
--- a/scripts/format-scope.json
+++ b/scripts/format-scope.json
@@ -1182,5 +1182,6 @@
   "src/ui/stores/firstRun.js",
   "src/firstRunLauncherView.test.mjs",
   "src/firstRunCopy.js",
-  "src/data/headingDegrees.test.mjs"
+  "src/data/headingDegrees.test.mjs",
+  "src/data/distanceFormat.test.mjs"
 ]
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index bf1eb1a3c..96057df6c 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -205,6 +205,7 @@
     "runtime": "node",
     "exports": ["./server/providers/places"],
     "modules": [
+      "src/data/distanceFormat.js",
       "server/providers/places.js",
       "server/providers/places/google.js",
       "server/providers/places/google-key.js",
@@ -391,6 +392,7 @@
     "runtime": "node",
     "exports": ["./server/providers/overpass"],
     "modules": [
+      "src/data/distanceFormat.js",
       "server/providers/common/geo.js",
       "server/providers/common/http.js",
       "server/providers/common/rate-limit.js",
@@ -816,6 +818,7 @@
     ],
     "modules": [
       "src/data/headingDegrees.js",
+      "src/data/distanceFormat.js",
       "src/ui/cockpit.js",
       "src/ui/cockpitBriefing.js",
       "src/ui/cockpitBriefPages.js",
@@ -886,6 +889,7 @@
     "exports": ["./ui/shell"],
     "modules": [
       "src/data/headingDegrees.js",
+      "src/data/distanceFormat.js",
       "src/i18n/marker.js",
       "src/ui/mobileShell.js",
       "src/exclusiveSurfaces.js",
@@ -1652,6 +1656,7 @@
     "exports": ["./layers/awareness"],
     "modules": [
       "src/data/headingDegrees.js",
+      "src/data/distanceFormat.js",
       "src/i18n/marker.js",
       "src/cyberSonar.js",
       "src/cockpitMath.js",
@@ -2199,6 +2204,7 @@
     ],
     "modules": [
       "src/data/headingDegrees.js",
+      "src/data/distanceFormat.js",
       "src/ui/placeNames.js",
       "src/cyberSonarScene.js",
       "src/cyberSonar.js",
@@ -3174,6 +3180,7 @@
     "exports": ["./application/layers"],
     "modules": [
       "src/data/headingDegrees.js",
+      "src/data/distanceFormat.js",
       "src/cyberSonar.js",
       "src/data/approxDistance.js",
       "src/data/bhoteKoshiEvent.js",
@@ -4054,6 +4061,7 @@
   "directions-layer": {
     "exports": ["./layers/directions"],
     "modules": [
+      "src/data/distanceFormat.js",
       "src/i18n/marker.js",
       "src/layers/directions/index.js",
       "src/data/pointerOwnerNames.js",
diff --git a/src/annotations/annotationEngine.js b/src/annotations/annotationEngine.js
index c867782c7..c80d2a1a8 100644
--- a/src/annotations/annotationEngine.js
+++ b/src/annotations/annotationEngine.js
@@ -12,6 +12,7 @@ import {
   sampleGroundHeight,
 } from './annotationResolver.js';
 import { ringCentroid } from './drawMode.js';
+import { formatDistanceText } from '../data/distanceFormat.js';
 
 // Dev convenience: expose the app's Cesium instance for console/preview probing
 // (single shared module instance — avoids dual-Cesium state bugs when testing).
@@ -1572,12 +1573,7 @@ function greatCircleM(a, b) {
 }
 
 function formatDistance(m) {
-  if (!Number.isFinite(m)) return null;
-  // Round before each unit cut: 996 m was printed as "1000 m" and
-  // 9,960 m as "10.0 km".
-  const tens = Math.round(m / 10) * 10;
-  if (tens < 1000) return `${tens} m`;
-  return `${(m / 1000).toFixed(Math.round(m / 100) >= 100 ? 0 : 1)} km`;
+  return formatDistanceText(m, { metreStep: 10 });
 }
 
 function composeRouteLabel(baseLabel, distM, durS, mode, fallback) {
diff --git a/src/annotations/drawMode.js b/src/annotations/drawMode.js
index 93f75dbdc..f22a39696 100644
--- a/src/annotations/drawMode.js
+++ b/src/annotations/drawMode.js
@@ -21,6 +21,7 @@ import { t, tn } from '../i18n/index.js';
  */
 
 import { greatCircleMeters } from '../geoDistance.js';
+import { formatDistanceText } from '../data/distanceFormat.js';
 
 export const DRAW_SHAPES = Object.freeze(['area', 'line', 'pin']);
 export const MIN_VERTICES = Object.freeze({ area: 3, line: 2, pin: 1 });
@@ -207,11 +208,7 @@ export function ringCentroid(vertices) {
 export function formatMeasure(session) {
   if (!session) return '';
   if (session.shape === 'line') {
-    const m = pathLengthM(session.vertices);
-    // Round before the kilometre cut. 999.6 m was printed as "1000 m".
-    const whole = Math.round(m);
-    if (whole < 1000) return `${whole} m`;
-    return `${(m / 1000).toFixed(m >= 10000 ? 0 : 1)} km`;
+    return formatDistanceText(pathLengthM(session.vertices)) ?? '';
   }
   if (session.shape === 'area') {
     const m2 = ringAreaM2(session.vertices);
diff --git a/src/annotations/drawMode.test.mjs b/src/annotations/drawMode.test.mjs
index 8018b4527..57b89751b 100644
--- a/src/annotations/drawMode.test.mjs
+++ b/src/annotations/drawMode.test.mjs
@@ -346,6 +346,14 @@ test('a line that rounds up to a kilometre reads 1.0 km, not 1000 m', () => {
   assert.match(drawHint(line), /^1\.0 km · /);
 });
 
+test('a line that rounds to 10.0 km reads in whole kilometres', () => {
+  const metresPerDegree = (6371.0088 * 1000 * Math.PI) / 180;
+  const line = createDrawSession('line');
+  addVertex(line, { lon: 0, lat: 0 });
+  addVertex(line, { lon: 0, lat: 9960 / metresPerDegree });
+  assert.equal(formatMeasure(line), '10 km');
+});
+
 test('an area that rounds up to the next unit reads in that unit', () => {
   // A square on the equator whose shoelace area is about `m2`.
   const square = (m2) => {
diff --git a/src/data/distanceFormat.js b/src/data/distanceFormat.js
new file mode 100644
index 000000000..efd9d78f9
--- /dev/null
+++ b/src/data/distanceFormat.js
@@ -0,0 +1,43 @@
+/**
+ * Kilometre decimals for a distance: one below 10 km, none from there on.
+ * The cut is taken on the tenth that prints, so 9.96 km reads 10 km, not 10.0.
+ * @param {number} meters
+ * @returns {0|1}
+ */
+export function kilometreDigits(meters) {
+  return Math.round(meters / 100) < 100 ? 1 : 0;
+}
+
+/**
+ * The unit and precision a distance prints with: metres below 1 km, then
+ * kilometres with `kilometreDigits`. Metres round to `metreStep` (10 for tens),
+ * except below `exactBelowM`, where they stay whole. Each cut is taken after
+ * rounding, so 999.6 m reads 1.0 km rather than 1000 m.
+ * @param {number} meters
+ * @param {{metreStep?: number, exactBelowM?: number}} [options]
+ * @returns {{value: number, unit: 'm'|'km', digits: 0|1}|null} null for a
+ *   distance that is negative or not finite. The value is already rounded to
+ *   `digits`, so toFixed and Intl render it the same way.
+ */
+export function distanceParts(meters, { metreStep = 1, exactBelowM = 0 } = {}) {
+  if (!Number.isFinite(meters) || meters < 0) return null;
+  const step = meters < exactBelowM ? 1 : metreStep;
+  const shownMeters = Math.round(meters / step) * step;
+  if (shownMeters < 1000) return { value: shownMeters, unit: 'm', digits: 0 };
+  const digits = kilometreDigits(meters);
+  const value =
+    digits === 1 ? Math.round(meters / 100) / 10 : Math.round(meters / 1000);
+  return { value, unit: 'km', digits };
+}
+
+/**
+ * Plain `850 m` / `4.6 km` / `12 km` text for labels that are not localized.
+ * @param {number} meters
+ * @param {{metreStep?: number, exactBelowM?: number}} [options]
+ * @returns {string|null}
+ */
+export function formatDistanceText(meters, options) {
+  const parts = distanceParts(meters, options);
+  if (!parts) return null;
+  return `${parts.value.toFixed(parts.digits)} ${parts.unit}`;
+}
diff --git a/src/data/distanceFormat.test.mjs b/src/data/distanceFormat.test.mjs
new file mode 100644
index 000000000..92a027662
--- /dev/null
+++ b/src/data/distanceFormat.test.mjs
@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  distanceParts,
+  formatDistanceText,
+  kilometreDigits,
+} from './distanceFormat.js';
+
+test('a distance switches to kilometres where its metres round to 1,000', () => {
+  assert.equal(formatDistanceText(999.4), '999 m');
+  assert.equal(formatDistanceText(999.5), '1.0 km');
+  assert.equal(formatDistanceText(999.6), '1.0 km');
+  assert.equal(formatDistanceText(994, { metreStep: 10 }), '990 m');
+  assert.equal(formatDistanceText(995, { metreStep: 10 }), '1.0 km');
+});
+
+test('kilometres drop their decimal where the tenth rounds to 10.0', () => {
+  assert.equal(kilometreDigits(9949), 1);
+  assert.equal(kilometreDigits(9950), 0);
+  assert.equal(formatDistanceText(9949), '9.9 km');
+  assert.equal(formatDistanceText(9950), '10 km');
+  assert.equal(formatDistanceText(9960), '10 km');
+  assert.equal(formatDistanceText(99950), '100 km');
+});
+
+test('metres below exactBelowM stay whole while the rest round to the step', () => {
+  const options = { metreStep: 10, exactBelowM: 100 };
+  assert.equal(formatDistanceText(8, options), '8 m');
+  assert.equal(formatDistanceText(99.4, options), '99 m');
+  assert.equal(formatDistanceText(846, options), '850 m');
+  assert.deepEqual(distanceParts(846, options), {
+    value: 850,
+    unit: 'm',
+    digits: 0,
+  });
+});
+
+test('a negative or non-finite distance has no parts', () => {
+  for (const value of [-1, Number.NaN, Infinity, -Infinity, null, undefined]) {
+    assert.equal(distanceParts(value), null);
+    assert.equal(formatDistanceText(value), null);
+  }
+  assert.equal(formatDistanceText(0), '0 m');
+});
+
+test('kilometres come back rounded, so toFixed and Intl agree', () => {
+  assert.deepEqual(distanceParts(1450), { value: 1.5, unit: 'km', digits: 1 });
+  assert.equal(formatDistanceText(1450), '1.5 km');
+  assert.equal(formatDistanceText(1150), '1.2 km');
+});
diff --git a/src/data/militaryAwareness.test.mjs b/src/data/militaryAwareness.test.mjs
index ea63280dc..05fd97dc0 100644
--- a/src/data/militaryAwareness.test.mjs
+++ b/src/data/militaryAwareness.test.mjs
@@ -79,6 +79,9 @@ test('Contacts moves a distance that rounds to 1,000 m into kilometres', () => {
   assert.equal(presentAwarenessDistance(999.4), '999\u00a0m');
   assert.equal(presentAwarenessDistance(999.6), '1.0\u00a0km');
   assert.equal(presentAwarenessDistance(4600), '4.6\u00a0km');
+  assert.equal(presentAwarenessDistance(9949), '9.9\u00a0km');
+  assert.equal(presentAwarenessDistance(9950), '10\u00a0km');
+  assert.equal(presentAwarenessDistance(9960), '10\u00a0km');
 });
 
 function installAwarenessRuntime({
diff --git a/src/data/militaryAwarenessEngine.js b/src/data/militaryAwarenessEngine.js
index f5a0a3a5b..136e9d2fa 100644
--- a/src/data/militaryAwarenessEngine.js
+++ b/src/data/militaryAwarenessEngine.js
@@ -2,6 +2,7 @@
 
 import { msg, t } from '../i18n/index.js';
 import { UNNAMED_PLACE_NAMES } from './installationNames.js';
+import { formatDistanceText } from './distanceFormat.js';
 
 const UNNAMED_NAMES = new Set(UNNAMED_PLACE_NAMES);
 
@@ -46,12 +47,7 @@ export function findByDoublingRadius(
 
 /** @param {number} meters @returns {string} */
 export function formatAwarenessDistance(meters) {
-  if (!Number.isFinite(meters) || meters < 0) return '—';
-  // Round before the kilometre cut. 999.6 m was printed as "1000 m".
-  const wholeMeters = Math.round(meters);
-  return wholeMeters < 1000
-    ? `${wholeMeters} m`
-    : `${(meters / 1000).toFixed(meters < 10000 ? 1 : 0)} km`;
+  return formatDistanceText(meters) ?? '—';
 }
 
 /**
diff --git a/src/data/militaryAwarenessEngine.test.mjs b/src/data/militaryAwarenessEngine.test.mjs
index 3c9f6ad3f..92e89355b 100644
--- a/src/data/militaryAwarenessEngine.test.mjs
+++ b/src/data/militaryAwarenessEngine.test.mjs
@@ -29,6 +29,9 @@ test('a contact marker moves a distance that rounds to 1,000 m into kilometres',
   assert.equal(formatAwarenessDistance(999.4), '999 m');
   assert.equal(formatAwarenessDistance(999.6), '1.0 km');
   assert.equal(formatAwarenessDistance(4600), '4.6 km');
+  assert.equal(formatAwarenessDistance(9949), '9.9 km');
+  assert.equal(formatAwarenessDistance(9950), '10 km');
+  assert.equal(formatAwarenessDistance(9960), '10 km');
 });
 
 test('awareness cohorts sort nearest-first and do not turn empty data into out of range', () => {
diff --git a/src/data/routeSteps.js b/src/data/routeSteps.js
index 736d812ee..119a599df 100644
--- a/src/data/routeSteps.js
+++ b/src/data/routeSteps.js
@@ -13,6 +13,8 @@
  * roundabout turn, exit roundabout, exit rotary, notification, use lane.
  */
 
+import { formatDistanceText } from './distanceFormat.js';
+
 /** Cap on steps returned for one route — a 2,500 km drive rarely needs more. */
 export const ROUTE_STEPS_MAX = 200;
 
@@ -216,11 +218,7 @@ export function normalizeOsrmSteps(route) {
  * @returns {string}
  */
 export function formatRouteDistance(meters) {
-  if (!Number.isFinite(meters) || meters < 0) return '';
-  if (meters < 100) return `${Math.round(meters)} m`;
-  if (meters < 1000) return `${Math.round(meters / 10) * 10} m`;
-  const km = meters / 1000;
-  return `${km < 10 ? km.toFixed(1) : Math.round(km)} km`;
+  return formatDistanceText(meters, { metreStep: 10, exactBelowM: 100 }) ?? '';
 }
 
 /**
diff --git a/src/data/routeSteps.test.mjs b/src/data/routeSteps.test.mjs
index c0eb445dc..dea5256da 100644
--- a/src/data/routeSteps.test.mjs
+++ b/src/data/routeSteps.test.mjs
@@ -236,6 +236,8 @@ test('distance and duration formatting', () => {
   assert.equal(formatRouteDistance(8), '8 m');
   assert.equal(formatRouteDistance(846), '850 m');
   assert.equal(formatRouteDistance(1234), '1.2 km');
+  assert.equal(formatRouteDistance(996), '1.0 km');
+  assert.equal(formatRouteDistance(9960), '10 km');
   assert.equal(formatRouteDistance(21479), '21 km');
   assert.equal(formatRouteDistance(-1), '');
   assert.equal(formatRouteDuration(40), '40 s');
diff --git a/src/layers/awareness/panel.js b/src/layers/awareness/panel.js
index af8f8bd84..c0c71ed01 100644
--- a/src/layers/awareness/panel.js
+++ b/src/layers/awareness/panel.js
@@ -10,6 +10,7 @@ import {
 } from '../../i18n/index.js';
 import { formatQuantity } from '../../ui/unitLabels.js';
 import { AWARENESS_PAGE_SIZE, AWARENESS_PAGE_ROTATE_MS } from './policy.js';
+import { distanceParts } from '../../data/distanceFormat.js';
 
 /** Format a cohort total without presenting a retained cap as exact. */
 export function formatAwarenessCount(summary = {}) {
@@ -31,13 +32,11 @@ function presentAwarenessCount(summary = {}) {
 
 /** A distance as the panel shows it: 850 m, 4.6 km, 120 km, in the UI language. */
 export function presentAwarenessDistance(meters) {
-  if (!Number.isFinite(meters) || meters < 0) return '—';
-  const wholeMeters = Math.round(meters);
-  if (wholeMeters < 1000) return formatQuantity(wholeMeters, 'm');
-  const digits = meters < 10000 ? 1 : 0;
-  return formatQuantity(meters / 1000, 'km', {
-    minimumFractionDigits: digits,
-    maximumFractionDigits: digits,
+  const parts = distanceParts(meters);
+  if (!parts) return '—';
+  return formatQuantity(parts.value, parts.unit, {
+    minimumFractionDigits: parts.digits,
+    maximumFractionDigits: parts.digits,
   });
 }
 
diff --git a/src/layers/directions/index.js b/src/layers/directions/index.js
index cad09e4e9..1dcb9e347 100644
--- a/src/layers/directions/index.js
+++ b/src/layers/directions/index.js
@@ -31,6 +31,7 @@ import {
   quantitySeparator,
   unitLabel,
 } from '../../ui/unitLabels.js';
+import { distanceParts } from '../../data/distanceFormat.js';
 
 export const DIRECTIONS_STEP_OVERLAY_SOURCE_ID = 'directions-step';
 export const DIRECTIONS_STEP_OVERLAY_SOURCE_OPTIONS = Object.freeze({
@@ -108,18 +109,12 @@ export const FLIGHT_PROGRESS_MS = 250;
  * @returns {string}
  */
 export function routeDistanceText(meters) {
-  if (!Number.isFinite(meters) || meters < 0) return '';
-  if (meters < 100) return formatQuantity(Math.round(meters), 'm');
-  const tens = Math.round(meters / 10) * 10;
-  if (tens < 1000) return formatQuantity(tens, 'm');
-  const km = meters / 1000;
-  // Pick the unit from the tenth it prints: 9.96 km read "10.0 km".
-  return Math.round(meters / 100) < 100
-    ? formatQuantity(km, 'km', {
-        minimumFractionDigits: 1,
-        maximumFractionDigits: 1,
-      })
-    : formatQuantity(Math.round(km), 'km');
+  const parts = distanceParts(meters, { metreStep: 10, exactBelowM: 100 });
+  if (!parts) return '';
+  return formatQuantity(parts.value, parts.unit, {
+    minimumFractionDigits: parts.digits,
+    maximumFractionDigits: parts.digits,
+  });
 }
 
 /**
diff --git a/src/ui/cockpitPresentation.js b/src/ui/cockpitPresentation.js
index 6b557de7d..fc62ceaad 100644
--- a/src/ui/cockpitPresentation.js
+++ b/src/ui/cockpitPresentation.js
@@ -5,6 +5,7 @@ import {
   normalizeHeading,
   roundHeadingDegrees,
 } from '../data/headingDegrees.js';
+import { kilometreDigits } from '../data/distanceFormat.js';
 
 export const COCKPIT_HEADING_SLEW_DPS = 28;
 
@@ -120,7 +121,7 @@ export function formatCockpitCoordinate(value, positive, negative) {
  * (`4,2 КМ`): one decimal under 10 km, whole kilometres beyond.
  */
 export function formatCockpitDistance(distanceM) {
-  const digits = distanceM < 10000 ? 1 : 0;
+  const digits = kilometreDigits(distanceM);
   const distance = formatQuantity(distanceM / 1000, 'km', {
     minimumFractionDigits: digits,
     maximumFractionDigits: digits,
diff --git a/src/ui/cockpitPresentation.test.mjs b/src/ui/cockpitPresentation.test.mjs
index da5c8e53b..d94209f0d 100644
--- a/src/ui/cockpitPresentation.test.mjs
+++ b/src/ui/cockpitPresentation.test.mjs
@@ -1,6 +1,9 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { formatCockpitWindDirection } from './cockpitPresentation.js';
+import {
+  formatCockpitDistance,
+  formatCockpitWindDirection,
+} from './cockpitPresentation.js';
 
 test('wind just west of north reads 0°, not 360°', () => {
   assert.equal(formatCockpitWindDirection(90), 'E · 90°');
@@ -8,3 +11,8 @@ test('wind just west of north reads 0°, not 360°', () => {
   assert.equal(formatCockpitWindDirection(359.4), 'N · 359°');
   assert.equal(formatCockpitWindDirection(359.6), 'N · 0°');
 });
+
+test('a cockpit distance that rounds to 10.0 km drops the decimal', () => {
+  assert.match(formatCockpitDistance(9949), /^9\.9\s?KM$/);
+  assert.match(formatCockpitDistance(9960), /^10\s?KM$/);
+});

From e40bff37d2d98d4b413c7e03b04c662f34affe71 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Sun, 1 Nov 2026 20:47:51 -0800
Subject: [PATCH 53/70] test(traffic): keep the timing test's Vite cache out of
 the package tree

The traffic timing test starts a Vite server rooted at the package, which
wrote its dependency cache to node_modules/.vite and kept writing after the
server closed. A host running Core's suite then finds files inside Core and
its check refuses them. The server now uses a temporary cache directory,
removed afterwards, and skips dependency discovery, which the SSR-loaded
modules never need.

The HUD place-lookup changelog note credits its PR, #1459.
---
 changelog.d/1459-hud-place-lookups.md |  2 +-
 src/data/trafficTiming.test.mjs       | 11 +++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/changelog.d/1459-hud-place-lookups.md b/changelog.d/1459-hud-place-lookups.md
index b0ff71f09..023e2f2e6 100644
--- a/changelog.d/1459-hud-place-lookups.md
+++ b/changelog.d/1459-hud-place-lookups.md
@@ -2,4 +2,4 @@
   looks up place names when no OpenAI key is configured, reverse-geocodes at
   most two points instead of up to four, and looks up again only once the view
   shows a different area, not after every small pan, so a small pan no longer
-  asks OpenAI for a new summary either (samehkhamis, #0000).
+  asks OpenAI for a new summary either (samehkhamis, #1459).
diff --git a/src/data/trafficTiming.test.mjs b/src/data/trafficTiming.test.mjs
index 3cadbfb81..808fb1300 100644
--- a/src/data/trafficTiming.test.mjs
+++ b/src/data/trafficTiming.test.mjs
@@ -1,5 +1,8 @@
 import assert from 'node:assert/strict';
 import { readLayerSource } from '../testSupport/readLayerSource.mjs';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
 import test from 'node:test';
 import { fileURLToPath } from 'node:url';
 
@@ -136,6 +139,7 @@ test('traffic timing pairs real ordering to the scheduling change and guards re-
   const timeouts = new Map();
   let timerId = 0;
   let server;
+  const cacheDir = mkdtempSync(path.join(tmpdir(), 'gev-traffic-timing-vite-'));
   let trafficLayer;
   let viewer;
 
@@ -159,6 +163,12 @@ test('traffic timing pairs real ordering to the scheduling change and guards re-
     };
     server = await createServer({
       root: fileURLToPath(new URL('../..', import.meta.url)),
+      // Its own optimizer cache, not node_modules/.vite in the package tree:
+      // a host running Core's suite refuses files inside Core.
+      cacheDir,
+      // The test loads modules over SSR; the browser dependency optimizer would
+      // keep writing its cache after the server closes.
+      optimizeDeps: { noDiscovery: true, include: [] },
       configFile: false,
       appType: 'custom',
       logLevel: 'silent',
@@ -328,6 +338,7 @@ test('traffic timing pairs real ordering to the scheduling change and guards re-
     console.warn = originalWarn;
     performance.clearMarks();
     performance.clearMeasures();
+    rmSync(cacheDir, { recursive: true, force: true, maxRetries: 3 });
   }
 });
 

From 98173afd6bbd8979fe780c496b987e0d07dd654c Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Sun, 1 Nov 2026 22:51:37 -0800
Subject: [PATCH 54/70] test(launches): stub the replay panel the speed control
 now publishes to

On main, setReplaySpeed publishes the speed control through
parts.panel.publishPanel, so the replay rig needs a panel stub.
---
 src/layers/launches/replay.test.mjs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/layers/launches/replay.test.mjs b/src/layers/launches/replay.test.mjs
index 4ed8e2ede..b0700d0f3 100644
--- a/src/layers/launches/replay.test.mjs
+++ b/src/layers/launches/replay.test.mjs
@@ -16,7 +16,7 @@ function replayRig() {
       },
     },
   });
-  const parts = {};
+  const parts = { panel: { publishPanel: noop } };
   parts.paths = createPaths({ state, parts });
   return { state, replay: createReplay({ state, parts }) };
 }

From 4779432e48ae8ba64bfdcd7ec2d2fac23fe30f2b Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Sun, 1 Nov 2026 22:53:35 -0800
Subject: [PATCH 55/70] Read a satellite's launch year from one TLE parser

The catalog stored the designator on satrec.intldesg for
internationalDesignatorYear, while the active-TLE lookup parsed the same
columns with tleLineLaunchYear. Each catalog entry now keeps launchYear from
tleLineLaunchYear, which moves to src/sources/tle.js beside the other TLE
field readers, and internationalDesignatorYear goes.

A blank designator now reads as an unknown year in both lookups; the
active-TLE lookup read it as 2000.
---
 src/layers/satellites/catalog.js         |  5 ++---
 src/layers/satellites/ingestion.js       |  6 +++---
 src/layers/satellites/ingestion.test.mjs | 23 ++++++++++++++++++++++-
 src/layers/satellites/orbits.js          | 22 ++++++----------------
 src/sources/tle.js                       | 13 +++++++++++++
 5 files changed, 46 insertions(+), 23 deletions(-)

diff --git a/src/layers/satellites/catalog.js b/src/layers/satellites/catalog.js
index 008b2a19d..f4a347af2 100644
--- a/src/layers/satellites/catalog.js
+++ b/src/layers/satellites/catalog.js
@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
 import { twoline2satrec } from 'satellite.js';
-import { noradIdFromSatnum } from '../../sources/tle.js';
+import { noradIdFromSatnum, tleLineLaunchYear } from '../../sources/tle.js';
 import {
   DENSE_REFRESH_FRAMES,
   DENSE_GROUP_PATH,
@@ -114,8 +114,6 @@ export function createCatalog({ state: layerState, services, parts, source }) {
           const entry = entries[i];
           const satrec = twoline2satrec(entry.line1, entry.line2);
           if (!satrec || satrec.error !== 0) continue;
-          // satellite.js omits the designator the launch-year match reads.
-          satrec.intldesg = entry.line1.slice(9, 17).trim();
           const noradId = noradIdFromSatnum(satrec.satnum);
           if (layerState._catalog.has(noradId)) continue; // core catalog keeps priority
           const pos = parts.orbits.propagatePosition(satrec, now);
@@ -125,6 +123,7 @@ export function createCatalog({ state: layerState, services, parts, source }) {
             name: entry.name,
             satrec,
             group: 'dense',
+            launchYear: tleLineLaunchYear(entry.line1),
           });
           const point = layerState._pointCollection.add({
             position: Cesium.Cartesian3.fromDegrees(
diff --git a/src/layers/satellites/ingestion.js b/src/layers/satellites/ingestion.js
index 168a5903b..d2cc16e15 100644
--- a/src/layers/satellites/ingestion.js
+++ b/src/layers/satellites/ingestion.js
@@ -1,7 +1,7 @@
 import { twoline2satrec } from 'satellite.js';
 import * as Cesium from 'cesium';
 import { msg } from '../../i18n/index.js';
-import { noradIdFromSatnum } from '../../sources/tle.js';
+import { noradIdFromSatnum, tleLineLaunchYear } from '../../sources/tle.js';
 import { CATALOG_GROUPS, ISS_NORAD, POINT_STYLES } from './policy.js';
 
 export function createIngestion({
@@ -119,8 +119,6 @@ export function createIngestion({
         for (const entry of allEntries) {
           const satrec = twoline2satrec(entry.line1, entry.line2);
           if (!satrec || satrec.error !== 0) continue;
-          // satellite.js omits the designator the launch-year match reads.
-          satrec.intldesg = entry.line1.slice(9, 17).trim();
 
           const noradId = noradIdFromSatnum(satrec.satnum);
           if (seen.has(noradId)) continue;
@@ -131,6 +129,8 @@ export function createIngestion({
             name: entry.name,
             satrec,
             group: entry.group,
+            // satellite.js does not keep the designator the year match reads.
+            launchYear: tleLineLaunchYear(entry.line1),
           });
 
           coreStale ||= entry.stale;
diff --git a/src/layers/satellites/ingestion.test.mjs b/src/layers/satellites/ingestion.test.mjs
index 7605b318c..beea1a518 100644
--- a/src/layers/satellites/ingestion.test.mjs
+++ b/src/layers/satellites/ingestion.test.mjs
@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { parseTleText } from '../../sources/tle.js';
+import { parseTleText, tleLineLaunchYear } from '../../sources/tle.js';
 import { createIngestion } from './ingestion.js';
 import { createOrbits } from './orbits.js';
 
@@ -98,3 +98,24 @@ test('a mission payload does not match a loaded satellite from another launch ye
   assert.equal(track('2026-06-29T02:25:00Z')?.noradId, 69728);
   assert.equal(track('2030-06-29T02:25:00Z'), null);
 });
+
+test('a satellite with a blank designator keeps matching by name', async (t) => {
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(console, 'warn', () => {});
+  const { state, update } = ingestionFor(
+    [
+      'SXM-11',
+      '1 69728U          26208.65166678  .00000015  00000+0  00000+0 0  9990',
+      '2 69728   0.0784 264.9826 0001797 240.4588 273.9506  1.00271527   440',
+    ].join('\n'),
+  );
+  await update();
+  const { getSatelliteOrbitTrack } = createOrbits({ state });
+  assert.equal(tleLineLaunchYear('1 69728U          26208.65166678'), null);
+  assert.equal(
+    getSatelliteOrbitTrack('Sirius SXM-11', {
+      launchTime: '2030-06-29T02:25:00Z',
+    })?.noradId,
+    69728,
+  );
+});
diff --git a/src/layers/satellites/orbits.js b/src/layers/satellites/orbits.js
index 0e4461e85..a2bfbd939 100644
--- a/src/layers/satellites/orbits.js
+++ b/src/layers/satellites/orbits.js
@@ -8,7 +8,11 @@ import {
   twoline2satrec,
 } from 'satellite.js';
 import { findNextSatellitePass } from '../../data/satellitePass.js';
-import { noradIdFromSatnum, parseTleText } from '../../sources/tle.js';
+import {
+  noradIdFromSatnum,
+  parseTleText,
+  tleLineLaunchYear,
+} from '../../sources/tle.js';
 import { ORBIT_PATH_STEPS, ISS_NORAD } from './policy.js';
 
 export function createOrbits({ state: layerState, services, parts, source }) {
@@ -258,13 +262,6 @@ export function createOrbits({ state: layerState, services, parts, source }) {
     return score;
   }
 
-  function internationalDesignatorYear(satrec) {
-    const match = String(satrec?.intldesg || '').match(/^(\d{2})/);
-    if (!match) return null;
-    const shortYear = Number(match[1]);
-    return shortYear >= 57 ? 1900 + shortYear : 2000 + shortYear;
-  }
-
   function lookupTleEntries(tleText) {
     if (tleText !== layerState._lookupTleText) {
       layerState._lookupTleText = tleText;
@@ -273,12 +270,6 @@ export function createOrbits({ state: layerState, services, parts, source }) {
     return layerState._lookupTleEntries;
   }
 
-  function tleLineLaunchYear(line1) {
-    const shortYear = Number(String(line1 || '').slice(9, 11));
-    if (!Number.isFinite(shortYear)) return null;
-    return shortYear >= 57 ? 1900 + shortYear : 2000 + shortYear;
-  }
-
   function orbitTrackFromRecord(name, satrec) {
     const referenceDate = new Date();
     const current = propagatePosition(satrec, referenceDate);
@@ -350,7 +341,7 @@ export function createOrbits({ state: layerState, services, parts, source }) {
         : null;
       let bestScore = 0;
       for (const [id, sat] of layerState._catalog) {
-        const designatorYear = internationalDesignatorYear(sat.satrec);
+        const designatorYear = sat.launchYear ?? null;
         if (
           launchYear !== null &&
           designatorYear !== null &&
@@ -379,7 +370,6 @@ export function createOrbits({ state: layerState, services, parts, source }) {
     getNextSatellitePass,
     resolveSatelliteForPass,
     scoreSatelliteNameMatch,
-    internationalDesignatorYear,
     lookupTleEntries,
     tleLineLaunchYear,
     orbitTrackFromRecord,
diff --git a/src/sources/tle.js b/src/sources/tle.js
index 61c409a2b..b34280787 100644
--- a/src/sources/tle.js
+++ b/src/sources/tle.js
@@ -72,3 +72,16 @@ export function tleCatalogNumber(line) {
   const field = String(line).slice(2, 7);
   return decodeCatalogField(field.replace(/^ +/, ''));
 }
+
+/**
+ * Launch year from TLE line 1's international designator (columns 10-11);
+ * null when the designator is blank.
+ * @param {string} line1
+ * @returns {number|null}
+ */
+export function tleLineLaunchYear(line1) {
+  const digits = String(line1 || '').slice(9, 11);
+  if (!/^\d{2}$/.test(digits)) return null;
+  const shortYear = Number(digits);
+  return shortYear >= 57 ? 1900 + shortYear : 2000 + shortYear;
+}

From 411cfd850b4b30b8aa1235b6f6ea4478b9f1f80a Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Sun, 1 Nov 2026 23:53:25 -0800
Subject: [PATCH 56/70] Record the shared launch-year parser in the state doc
 and fragment

---
 changelog.d/1453-satellite-launch-year.md | 9 ++++++---
 docs/CURRENT-STATE.md                     | 2 +-
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/changelog.d/1453-satellite-launch-year.md b/changelog.d/1453-satellite-launch-year.md
index a44745e1f..6b51770c5 100644
--- a/changelog.d/1453-satellite-launch-year.md
+++ b/changelog.d/1453-satellite-launch-year.md
@@ -1,3 +1,6 @@
-- Space Missions no longer shows an older satellite with a similar name as a
-  new payload's orbit: the launch-year check on loaded satellites now runs
-  (Aditya, @Rohilalala, #1453).
+- Space Missions no longer shows an older satellite with a similar name and a
+  different known launch year as a new payload's orbit: the launch-year check
+  on loaded satellites now runs (Aditya, @Rohilalala, #1453).
+- Satellite launch years come from one TLE designator parser for both the
+  loaded catalog and the active-TLE fallback; a blank designator is an
+  unknown year instead of 2000 (#1453).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 32625fd91..6dbed2900 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5060,7 +5060,7 @@ silently demoting every later lookup for the session.
   protected-card path. Disable tears the tier down completely.
   Coverage/viewshed semantics unchanged.
 - **Satellites**: orbit rings rotate about Earth's Z by ΔGMST every ~1s (exact inertial→ECEF compensation; no SGP4 re-runs); the tracked satellite propagates per frame with one shared epoch for dot/label/camera. Verified: ISS holds <1km perpendicular to its ring while tracked. Pass prediction (`src/data/satellitePass.js`; `getNextSatellitePass`, `getNextIssPass`) scans at 20s, bisects rise/set to ~0.2s, fits the peak with a parabola, and marks a pass visible when the satellite is outside a cylindrical Earth shadow while the observer's Sun is at or below −6°. `next_iss_pass` preserves its geometric-pass ordering and appends visibility metadata. General `next_satellite_pass` accepts a loaded NORAD ID or unambiguous name, searches 24 hours and optionally requires estimated visibility. These estimates do not account for weather or satellite brightness.
-- **Space Missions (30d)**: recent launches render as bounded shared-host, horizon-occluded mission markers using Launch Library 2 v2.3 detailed records. Enabling the layer selects the unified right-side Context panel's Space Missions mode and enables the required satellite layer. Before applying its temporary dense/hidden Satellite mode, Space Missions snapshots the complete standalone Satellite parameter set and exact enabled-layer set. Disabling Space Missions from either Context or the left Data Layers rail restores those parameters and the exact prior enabled state, so a Satellite layer that was already on stays on while a mode-owned dependency returns off; enabling Satellites by itself remains independent. Selecting a mission isolates its launch-to-orbit transfer and dashed satellite orbit, fills that same panel with navigation/details, and animates a small phase-colored marker along the exact displayed Cartesian samples. Marker hit testing drill-picks through photorealistic tiles so the depth-test-free tactical dot remains reliably selectable; its text is non-interactive shared-host presentation. The selected pad is the camera's zoom pivot: the overview remains centered on its launch site, wheel zoom approaches that site instead of drifting elsewhere, and camera pitch progressively changes from global nadir to an oblique close 3D view. Its protected shared-host callout remains visible and expands to include both mission and launch-site names. `FOCUS` flies directly to a 12 km oblique frame around the selected launch site and retains the same anchored zoom/orbit behavior. `REPLAY ASCENT` resets the selected marker at the pad, frames it from an oblique third-person angle, and follows it through the mission-specific compressed ascent directly into one orbital lap at the default `1×` rate. A live `0.25×`–`4×` slider changes ascent and orbit playback speed; adjusting it mid-replay preserves the current path position and historical mission timestamp. Re-entry/recovery cannot be inserted into replay. At orbit insertion the camera smoothly pulls back over the first fifth of the orbital replay and pitches to a globe-scale nadir view while continuing to target the moving replay point. Replay Cancel, mission navigation, deselection, layer disable, and data refresh all release camera ownership. Reconstructed paths are one continuous 128-sample geodetic curve: horizontal departure begins near zero while altitude rises quickly, then the climb progressively bends toward insertion without the former hard 120 km corner. Unmatched orbit fallbacks are smooth planar inclined rings rather than longitude/latitude ground-track curves. The panel lists disclosed payload names, types, operators/manufacturers, mass, multiplicity, and destination when supplied; an empty LL2 payload collection is shown as `CLASSIFIED / MULTI-PAYLOAD`. Launcher, spacecraft, and recoverable payload stages appear in a compact stage table with serial/flight/reuse details, recovery outcome/type, destination, and final coordinates when those records exist; an empty recovery collection omits the section. Stage recoveries with confirmed coordinates use those coordinates; return-to-launch-site records use the pad; downrange-only records receive an explicitly labeled estimated endpoint along the ascent azimuth. Available endpoints render as static 2 px dashed descent/recovery paths with a fixed final-position dot and an estimated atmospheric-interface segment when applicable. The ascent is geodetically densified above the ellipsoid toward the orbit's nearest insertion point, then rendered with `ArcType.NONE`, so it neither cuts through Earth nor separates from the marker. Because LL2 does not normally supply continuous ascent telemetry, pad-to-insertion paths without upstream trajectory samples are labeled `RECONSTRUCTED ESTIMATE` / `ASCENT ESTIMATE`; only supplied trajectory samples receive the replay wording. Selected-orbit framing fits the complete ring, rear-side linework uses normal scene depth occlusion, and current distance, speed, and callout data come only from a launch-year-validated satellite match. Speed is the magnitude of the SGP4 inertial velocity vector at the same propagation epoch as position, displayed in km/s with km/h available as hover detail. Unavailable operator, site, launch-time, orbit, current-altitude, and speed values omit their detail rows instead of reserving panel space with placeholders. Newly launched payloads absent from the core operational groups use CelesTrak's cached active TLE feed as a lookup-only fallback; weak constellation-name matches are rejected. The replay callout maps compressed animation progress onto Launch Library's mission-relative timeline, showing the historical UTC date/time at the marker's current path position; unavailable timelines remain explicit. Matched live satellite positions propagate at one-second cadence and use a distinct green dot/callout with the current UTC date/time.
+- **Space Missions (30d)**: recent launches render as bounded shared-host, horizon-occluded mission markers using Launch Library 2 v2.3 detailed records. Enabling the layer selects the unified right-side Context panel's Space Missions mode and enables the required satellite layer. Before applying its temporary dense/hidden Satellite mode, Space Missions snapshots the complete standalone Satellite parameter set and exact enabled-layer set. Disabling Space Missions from either Context or the left Data Layers rail restores those parameters and the exact prior enabled state, so a Satellite layer that was already on stays on while a mode-owned dependency returns off; enabling Satellites by itself remains independent. Selecting a mission isolates its launch-to-orbit transfer and dashed satellite orbit, fills that same panel with navigation/details, and animates a small phase-colored marker along the exact displayed Cartesian samples. Marker hit testing drill-picks through photorealistic tiles so the depth-test-free tactical dot remains reliably selectable; its text is non-interactive shared-host presentation. The selected pad is the camera's zoom pivot: the overview remains centered on its launch site, wheel zoom approaches that site instead of drifting elsewhere, and camera pitch progressively changes from global nadir to an oblique close 3D view. Its protected shared-host callout remains visible and expands to include both mission and launch-site names. `FOCUS` flies directly to a 12 km oblique frame around the selected launch site and retains the same anchored zoom/orbit behavior. `REPLAY ASCENT` resets the selected marker at the pad, frames it from an oblique third-person angle, and follows it through the mission-specific compressed ascent directly into one orbital lap at the default `1×` rate. A live `0.25×`–`4×` slider changes ascent and orbit playback speed; adjusting it mid-replay preserves the current path position and historical mission timestamp. Re-entry/recovery cannot be inserted into replay. At orbit insertion the camera smoothly pulls back over the first fifth of the orbital replay and pitches to a globe-scale nadir view while continuing to target the moving replay point. Replay Cancel, mission navigation, deselection, layer disable, and data refresh all release camera ownership. Reconstructed paths are one continuous 128-sample geodetic curve: horizontal departure begins near zero while altitude rises quickly, then the climb progressively bends toward insertion without the former hard 120 km corner. Unmatched orbit fallbacks are smooth planar inclined rings rather than longitude/latitude ground-track curves. The panel lists disclosed payload names, types, operators/manufacturers, mass, multiplicity, and destination when supplied; an empty LL2 payload collection is shown as `CLASSIFIED / MULTI-PAYLOAD`. Launcher, spacecraft, and recoverable payload stages appear in a compact stage table with serial/flight/reuse details, recovery outcome/type, destination, and final coordinates when those records exist; an empty recovery collection omits the section. Stage recoveries with confirmed coordinates use those coordinates; return-to-launch-site records use the pad; downrange-only records receive an explicitly labeled estimated endpoint along the ascent azimuth. Available endpoints render as static 2 px dashed descent/recovery paths with a fixed final-position dot and an estimated atmospheric-interface segment when applicable. The ascent is geodetically densified above the ellipsoid toward the orbit's nearest insertion point, then rendered with `ArcType.NONE`, so it neither cuts through Earth nor separates from the marker. Because LL2 does not normally supply continuous ascent telemetry, pad-to-insertion paths without upstream trajectory samples are labeled `RECONSTRUCTED ESTIMATE` / `ASCENT ESTIMATE`; only supplied trajectory samples receive the replay wording. Selected-orbit framing fits the complete ring, rear-side linework uses normal scene depth occlusion, and current distance, speed, and callout data come only from a launch-year-validated satellite match. Both the loaded-catalog and active-TLE lookups read the launch year from the TLE international designator through one parser (`src/sources/tle.js`); a blank or malformed designator is an unknown year, which skips the year check rather than rejecting the match. Speed is the magnitude of the SGP4 inertial velocity vector at the same propagation epoch as position, displayed in km/s with km/h available as hover detail. Unavailable operator, site, launch-time, orbit, current-altitude, and speed values omit their detail rows instead of reserving panel space with placeholders. Newly launched payloads absent from the core operational groups use CelesTrak's cached active TLE feed as a lookup-only fallback; weak constellation-name matches are rejected. The replay callout maps compressed animation progress onto Launch Library's mission-relative timeline, showing the historical UTC date/time at the marker's current path position; unavailable timelines remain explicit. Matched live satellite positions propagate at one-second cadence and use a distinct green dot/callout with the current UTC date/time.
   When no mission is selected, the Context panel presents a scrollable newest-first roster of every launch in the rolling window, including the smaller 5 px operator-colored marker, provider, and launch date. Hovering or keyboard-focusing a row shows four compact cyan corner brackets on both that roster row and its corresponding globe dot, rotates the globe at the current zoom to center it, and gives its label declutter priority without selecting it; the globe label remains unbracketed. Selecting a roster row invokes the same mission isolation and full-orbit framing as clicking its globe marker. The replay vehicle is one screen-space SVG/CSS HUD overlay rather than separate Cesium billboard, label, and reticle graphics. It is hidden during ordinary Focus and manual close views, where the standard selected launch-site label remains visible, and exists only while ascent replay is active. Its fixed pixel scale is shared by ascent and insertion, so camera range never resizes the rocket on screen before the phase boundary. Generic Launch Library pad names are reduced to their identifying suffix, and replay timestamps use a cyan state title over unprefixed white UTC date/time values. `REPLAY ASCENT` holds the unframed cyan/white rocket at the pad for a real-time `T−10` countdown, transitions through `LIFTOFF`, and attaches six tapered cyan/white ellipse waves directly below it from liftoff through insertion to convey thrust without adding scene geometry. While replay is active, the single start button is replaced by compact Play, Pause, and Cancel icon controls. Pause freezes countdown or mission time, vehicle/stage positions, camera target, labels, and thrust-wave animation; Play resumes from that exact frame, and Cancel releases replay camera ownership. The rocket and thrust group rotates from the path's live screen-space tangent, so its nose follows the visible ascent curve while the adjacent text remains upright. The camera begins as a close oblique launch chase, then smoothly widens between roughly 120 and 420 km vehicle altitude into a higher oblique context view that keeps the moving rocket targeted while exposing the ascent bend and orbit connection. At insertion the rocket/thrust glyph is replaced by the fixed-size cyan orbit dot, which the camera follows through the existing globe-scale orbit pullback. The chase camera limits per-frame yaw changes across heading wraps so it cannot abruptly cross in front of the vehicle and make ascent read in reverse; the replay-speed slider affects mission playback but not countdown duration.
   Mission world text has no native `LabelGraphics`: overview launch markers publish at most 48 ambient candidates for a 24-winner budget, while selecting a mission clears that overview source and publishes its launch-site callout, stage re-entry annotations, live/estimated payload-position readout, and orbit annotation as protected selected-lane entries. The source retains the exact former strings and colors. Static anchors reuse the Cartesian values used to build their mission geometry; the moving payload entry reads the layer's per-frame live-position cache; catalog-backed orbit annotation positions are cached in the same one-second matrix update that realigns the orbit primitive. Keyhole edge fade, horizon culling, final collision placement, and UI exclusion are owned by the shared host. Deselect restores the bounded overview, and refresh, disable, and destroy replace or clear both mission sources.
   A selected mission renders its orbit as four repeating tactical sectors, each containing one prominent cyan dot followed by one hundred thin translucent dashes. The bright dots act as orbit anchors while the subdued dash field remains depth-tested against the globe and is shown only for the selected mission.

From d479c1c6f66d6407436fd40e531e0386287036de Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Sun, 1 Nov 2026 22:58:52 -0800
Subject: [PATCH 57/70] Read an ADS-B vertical rate from one shared field
 reader

---
 changelog.d/1448-local-adsb-geom-rate.md |  3 +++
 scripts/format-scope.json                |  3 ++-
 scripts/package-boundaries.json          |  7 ++++-
 src/data/adsbLolFallback.js              |  5 ++--
 src/sources/adsbFields.js                | 16 ++++++++++++
 src/sources/adsbFields.test.mjs          | 33 ++++++++++++++++++++++++
 src/sources/adsbRecords.js               |  6 ++---
 src/sources/live/aircraft.js             |  4 +--
 8 files changed, 68 insertions(+), 9 deletions(-)
 create mode 100644 src/sources/adsbFields.js
 create mode 100644 src/sources/adsbFields.test.mjs

diff --git a/changelog.d/1448-local-adsb-geom-rate.md b/changelog.d/1448-local-adsb-geom-rate.md
index 276e58f3e..a4a0c54f8 100644
--- a/changelog.d/1448-local-adsb-geom-rate.md
+++ b/changelog.d/1448-local-adsb-geom-rate.md
@@ -1,3 +1,6 @@
 - Local ADS-B decoder feeds now carry a GNSS-sourced vertical rate
   (`geom_rate`) when no barometric rate is sent, so the card shows V/S
   instead of a dash (Aditya, @Rohilalala, #1448).
+- Local ADS-B, military and the adsb.lol flight fallback read the vertical
+  rate through one shared readsb field reader, so all three prefer the
+  barometric rate and fall back to the GNSS rate the same way (#1448).
diff --git a/scripts/format-scope.json b/scripts/format-scope.json
index 0cd9edca5..11134114f 100644
--- a/scripts/format-scope.json
+++ b/scripts/format-scope.json
@@ -1183,5 +1183,6 @@
   "src/firstRunLauncherView.test.mjs",
   "src/firstRunCopy.js",
   "src/data/headingDegrees.test.mjs",
-  "src/data/distanceFormat.test.mjs"
+  "src/data/distanceFormat.test.mjs",
+  "src/sources/adsbFields.test.mjs"
 ]
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json
index 96057df6c..303107647 100644
--- a/scripts/package-boundaries.json
+++ b/scripts/package-boundaries.json
@@ -179,6 +179,7 @@
     "runtime": "node",
     "exports": ["./server/providers/live"],
     "modules": [
+      "src/sources/adsbFields.js",
       "server/providers/live.js",
       "server/providers/common/http.js",
       "server/providers/common/query.js",
@@ -198,7 +199,7 @@
   },
   "adsb-lol-source": {
     "exports": ["./sources/adsb-lol"],
-    "modules": ["src/data/adsbLolFallback.js"],
+    "modules": ["src/data/adsbLolFallback.js", "src/sources/adsbFields.js"],
     "external": []
   },
   "place-providers": {
@@ -1247,6 +1248,7 @@
   "live-observations": {
     "exports": ["./sources/live"],
     "modules": [
+      "src/sources/adsbFields.js",
       "src/i18n/marker.js",
       "src/data/aircraftEmergency.js",
       "src/sources/live/aircraft.js",
@@ -2203,6 +2205,7 @@
       "./standalone/catalog"
     ],
     "modules": [
+      "src/sources/adsbFields.js",
       "src/data/headingDegrees.js",
       "src/data/distanceFormat.js",
       "src/ui/placeNames.js",
@@ -3179,6 +3182,7 @@
   "application-layer-construction": {
     "exports": ["./application/layers"],
     "modules": [
+      "src/sources/adsbFields.js",
       "src/data/headingDegrees.js",
       "src/data/distanceFormat.js",
       "src/cyberSonar.js",
@@ -4721,6 +4725,7 @@
   "tools-services": {
     "exports": ["./tools/services"],
     "modules": [
+      "src/sources/adsbFields.js",
       "src/tools/services.js",
       "src/layers/bikeshare/registry.js",
       "src/layers/bikeshare/source.js",
diff --git a/src/data/adsbLolFallback.js b/src/data/adsbLolFallback.js
index 40dd2bbc0..61d07387f 100644
--- a/src/data/adsbLolFallback.js
+++ b/src/data/adsbLolFallback.js
@@ -1,3 +1,5 @@
+import { readAdsbVerticalRateFpm } from '../sources/adsbFields.js';
+
 const KNOT_TO_MPS = 0.514444;
 const FOOT_TO_M = 0.3048;
 const FPM_TO_MPS = 0.00508;
@@ -61,8 +63,7 @@ export function normalizeAdsbLolAircraftState(aircraft, nowSeconds) {
   const barometricFeet = onGround ? null : finiteNumber(aircraft?.alt_baro);
   const geometricFeet = finiteNumber(aircraft?.alt_geom);
   const groundSpeedKnots = finiteNumber(aircraft?.gs);
-  const verticalRateFpm =
-    finiteNumber(aircraft?.baro_rate) ?? finiteNumber(aircraft?.geom_rate);
+  const verticalRateFpm = readAdsbVerticalRateFpm(aircraft);
   const track = finiteNumber(aircraft?.track);
 
   return [
diff --git a/src/sources/adsbFields.js b/src/sources/adsbFields.js
new file mode 100644
index 000000000..4d4822e2a
--- /dev/null
+++ b/src/sources/adsbFields.js
@@ -0,0 +1,16 @@
+/** A readsb rate field: a finite JSON number, else null. */
+function rateField(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+/**
+ * Vertical rate in ft/min from a readsb-style aircraft row (readsb, tar1090,
+ * adsb.lol): the barometric `baro_rate`, else the GNSS-sourced `geom_rate`
+ * readsb sends instead when it has no barometric rate. A barometric 0 is kept.
+ * Only a finite number counts; null when neither field has one.
+ * @param {object|null|undefined} row
+ * @returns {number|null}
+ */
+export function readAdsbVerticalRateFpm(row) {
+  return rateField(row?.baro_rate) ?? rateField(row?.geom_rate);
+}
diff --git a/src/sources/adsbFields.test.mjs b/src/sources/adsbFields.test.mjs
new file mode 100644
index 000000000..68fc52f79
--- /dev/null
+++ b/src/sources/adsbFields.test.mjs
@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readAdsbVerticalRateFpm } from './adsbFields.js';
+
+test('the barometric rate wins, a barometric 0 included', () => {
+  assert.equal(
+    readAdsbVerticalRateFpm({ baro_rate: -640, geom_rate: -832 }),
+    -640,
+  );
+  assert.equal(readAdsbVerticalRateFpm({ baro_rate: 0, geom_rate: 600 }), 0);
+});
+
+test('a GNSS rate stands in when no barometric rate is usable', () => {
+  for (const baro_rate of [
+    undefined,
+    null,
+    Number.NaN,
+    Infinity,
+    '300',
+    false,
+  ]) {
+    assert.equal(readAdsbVerticalRateFpm({ baro_rate, geom_rate: -832 }), -832);
+  }
+});
+
+test('no usable rate reads as null', () => {
+  assert.equal(readAdsbVerticalRateFpm({}), null);
+  assert.equal(readAdsbVerticalRateFpm(null), null);
+  assert.equal(
+    readAdsbVerticalRateFpm({ baro_rate: '300', geom_rate: true }),
+    null,
+  );
+});
diff --git a/src/sources/adsbRecords.js b/src/sources/adsbRecords.js
index 465321902..afa952503 100644
--- a/src/sources/adsbRecords.js
+++ b/src/sources/adsbRecords.js
@@ -30,6 +30,8 @@
  * This module is portable: no Cesium, DOM, network or storage access.
  */
 
+import { readAdsbVerticalRateFpm } from './adsbFields.js';
+
 /** A marker is dropped once its newest position is this old. */
 export const LOCAL_ADSB_POSITION_STALE_MS = 60_000;
 /** An aircraft is forgotten once no message has arrived for this long. */
@@ -247,9 +249,7 @@ export function normalizeDump1090Aircraft(json, nowMs, { band = '1090' } = {}) {
       altitudeFt: altitude,
       groundSpeedKt: finiteOrNull(entry.gs),
       trackDeg: normalizeTrack(entry.track),
-      // A GNSS-sourced rate is sent as geom_rate instead of baro_rate.
-      verticalRateFpm:
-        finiteOrNull(entry.baro_rate) ?? finiteOrNull(entry.geom_rate),
+      verticalRateFpm: readAdsbVerticalRateFpm(entry),
       lastPositionAt: hasPosition
         ? receivedAt - Math.max(0, seenPosS) * 1000
         : null,
diff --git a/src/sources/live/aircraft.js b/src/sources/live/aircraft.js
index 9da4f7a5f..19472a92a 100644
--- a/src/sources/live/aircraft.js
+++ b/src/sources/live/aircraft.js
@@ -6,6 +6,7 @@ import {
   epoch,
   finite,
 } from './contract.js';
+import { readAdsbVerticalRateFpm } from '../adsbFields.js';
 
 const openSkyId = (row) =>
   Array.isArray(row) ? cleanText(row[0]).toLowerCase() : '';
@@ -48,8 +49,7 @@ export function normalizeReadsbAircraft(row, snapshotTimeMs) {
   const baroFt = finite(row.alt_baro),
     geoFt = finite(row.alt_geom);
   const speedKts = finite(row.gs),
-    // readsb sends a GNSS-sourced rate as geom_rate instead of baro_rate.
-    rateFtMin = finite(row.baro_rate) ?? finite(row.geom_rate);
+    rateFtMin = readAdsbVerticalRateFpm(row);
   const seen = finite(row.seen),
     seenPos = finite(row.seen_pos);
   return {

From 91269cda241f567918c11d0f73ebc7e6c6f043f0 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 2 Nov 2026 07:02:34 -0800
Subject: [PATCH 58/70] Keep the Codespaces port private, say Provider Settings
 stays shut there, and credit the path

---
 README.md                           | 11 ++++++-----
 changelog.d/980-codespaces-setup.md |  3 +++
 2 files changed, 9 insertions(+), 5 deletions(-)
 create mode 100644 changelog.d/980-codespaces-setup.md

diff --git a/README.md b/README.md
index 1d3c3667c..dcd9ff400 100644
--- a/README.md
+++ b/README.md
@@ -89,7 +89,7 @@ Start with the included data sources, then add your own. Each layer is a separat
 
 ## ⚡ Quick Start
 
-**Start without an account or API keys.** Both paths open the same app with
+**Start without an account or API keys.** Every path opens the same app with
 Esri satellite imagery and keyless terrain. OSM is the fallback if Esri is
 unreachable. Flights, military traffic, satellites, earthquakes, public
 cameras, radio, and launches are available without keys.
@@ -253,7 +253,8 @@ quotas apply.
    ```
 4. Open the **Ports** tab, find `4173`, and click the globe icon to open it in
    the browser. The port is private by default, so the URL asks for your GitHub
-   login.
+   login. Keep it private: a public port lets anyone use the app and the keys
+   in your `.env`.
 
 `GEV_ALLOWED_HOSTS` there is required, not optional. The dev server answers only
 the hostnames it trusts, and a forwarded port arrives on
@@ -262,9 +263,9 @@ page is `Blocked request. This host is not allowed.` Leading-dot wildcards are
 ignored on purpose, so pass that exact name.
 
 ⚠️ **A codespace is reachable from the internet.** Treat it as the
-wider-publish case in [Sharing an instance](#-sharing-an-instance): leave
-Provider Settings closed to strangers, and put keys in the workspace `.env` by
-hand. `.env` is gitignored — never commit it. [SECURITY.md](SECURITY.md) has the
+wider-publish case in [Sharing an instance](#-sharing-an-instance). Provider
+Settings does not open on the forwarded URL, so put keys in the workspace
+`.env` by hand. `.env` is gitignored — never commit it. [SECURITY.md](SECURITY.md) has the
 threat model.
 
 ### Then power it up — in the app, not in a file
diff --git a/changelog.d/980-codespaces-setup.md b/changelog.d/980-codespaces-setup.md
new file mode 100644
index 000000000..57acd7094
--- /dev/null
+++ b/changelog.d/980-codespaces-setup.md
@@ -0,0 +1,3 @@
+- Document GitHub Codespaces as a fourth setup path in the README: a cloud
+  workspace runs the dev server while the globe renders in your own browser
+  (John Leshan, @johnleshan, #980).

From 8a23328ed13319c91f07295feba76f6a06961a4d Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 2 Nov 2026 07:00:48 -0800
Subject: [PATCH 59/70] Describe multipart cable ownership by behaviour and
 credit the author's handle

---
 .../1093-multipart-cable-feature-ownership.md       |  2 +-
 docs/CURRENT-STATE.md                               | 13 +++++--------
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/changelog.d/1093-multipart-cable-feature-ownership.md b/changelog.d/1093-multipart-cable-feature-ownership.md
index 65892e9a9..777a159d0 100644
--- a/changelog.d/1093-multipart-cable-feature-ownership.md
+++ b/changelog.d/1093-multipart-cable-feature-ownership.md
@@ -1,4 +1,4 @@
 - Keep every submarine-cable segment associated with its source feature after
   Cesium expands multipart geometry, correcting segment colors, click destinations
   and horizon culling while retaining one reference stem per feature
-  (Aliciawque, #1093).
+  (@Aliciawque, #1093).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 6d6a52f09..3b66fc24d 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -6371,14 +6371,11 @@ three Cesium data sources; enabling rebuilds from the accepted parsed cache,
 and destroying clears it. Load ownership prevents cancelled work from adding
 entities after teardown.
 
-Multipart cable and landing-point geometry retains its source feature on every
-Cesium entity, including generated IDs and IDs that collide with Cesium's
-multipart suffixes. Each segment receives its own feature's styling, click
-destination and horizon-culling reference; each source feature has one reference
-stem. Source collections and their properties are not modified. The copied input
-adds `__gevSourceFeatureIndex`, which remains observable in Cesium properties
-and default descriptions. The application viewer disables the Cesium info box,
-so those default descriptions are not shown in the app.
+Every Cesium entity from multipart cable or landing-point geometry stays tied
+to its source feature, including generated IDs and IDs that collide with
+Cesium's multipart suffixes. Each segment gets its own feature's styling, click
+destination and horizon-culling reference, and each source feature has one
+reference stem. The source collections are not modified.
 
 Natural Earth regions and neighborhood polygon lookup are package exports.
 Their existing lazy loaders, retry behavior, bundled datasets and attribution

From 16756bb790adb557208e55c2506994e3993cccf8 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 2 Nov 2026 07:03:49 -0800
Subject: [PATCH 60/70] Align the doctor, state doc and bug template with the
 24.22.1 pin, and credit the author

---
 .github/ISSUE_TEMPLATE/bug_report.yml             | 2 +-
 CONTRIBUTING.md                                   | 6 +++---
 changelog.d/1458-node-24-22-1-security-release.md | 4 ++--
 docs/CURRENT-STATE.md                             | 5 +++--
 scripts/setup-doctor.mjs                          | 2 +-
 5 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index 016576bf8..9069c648d 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -40,7 +40,7 @@ body:
     attributes:
       label: OS, Node version, browser
       description: Include the versions you can find. Write "unknown" for anything unavailable.
-      placeholder: "Windows 11, Node 24.14.0, Chrome 151"
+      placeholder: "Windows 11, Node 24.22.1, Chrome 151"
     validations:
       required: true
   - type: input
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 341252ba4..5850fe650 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,9 +4,9 @@ Thanks for being here. God's Eye View is an open foundation for live spatial int
 
 ## Getting set up
 
-Use Node.js 24.14.x or 26.x (also enforced by `package.json`). Prefer 24.22.1 or
-later: earlier releases lack the October 21, 2026 security fixes, including
-CVE-2026-111497 (a Brotli decoder flaw that can lead to remote code execution).
+Use Node.js 24 (24.14.0 or later) or 26.x (also enforced by `package.json`).
+Prefer 24.22.1 or later: earlier releases lack the October 21, 2026 security
+fixes, including CVE-2026-111497 (a Brotli decoder flaw).
 
 ```bash
 git clone https://github.com/bilawalsidhu/gods-eye-view.git
diff --git a/changelog.d/1458-node-24-22-1-security-release.md b/changelog.d/1458-node-24-22-1-security-release.md
index a440892a8..8c8cdd318 100644
--- a/changelog.d/1458-node-24-22-1-security-release.md
+++ b/changelog.d/1458-node-24-22-1-security-release.md
@@ -1,3 +1,3 @@
 - The Docker image and CI now pin Node 24.22.1, the first 24.x release with
-  the October 21, 2026 security fixes, including CVE-2026-111497 (a Brotli
-  decoder flaw that can lead to remote code execution) (anobjectn, #1458).
+  the October 21, 2026 security fixes, including CVE-2026-111497 in the Brotli
+  decoder (Luis Ortiz, @anobjectn, #1458).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index c872b609c..bf5d99fc7 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -3433,7 +3433,8 @@ down | auth-failed` (plus the unchanged `missing-key`/`unsupported`) with
 >   style-switch persistence state. Browser/GPU performance comparison remains
 >   operator-side; the final accounting records only comparable population
 >   reductions and deterministic Node allocation/solve measurements. Those
->   allocation gates are calibrated on Node.js 24.14.x; `package.json` permits
+>   allocation gates were calibrated on Node.js 24.14.x and run in CI on the
+>   pinned Node.js 24.22.1 with the same ceilings; `package.json` permits
 >   supported product runtimes on Node 24 or 26, while the allocation runner
 >   separately enforces Node 24 for these two calibrated probes. Each probe
 >   compiles synchronously and discards explicit-GC
@@ -6180,7 +6181,7 @@ The lockfile uses DOMPurify 3.4.17, protobufjs 8.8.0, PostCSS 8.5.28,
 source-map-js 1.2.2 and nanoid 3.3.19. Cesium remains on 1.138.0. Browser QA
 uses Puppeteer 25.10.0; image-processing tools use Sharp 0.35.5. QA scripts await Puppeteer's asynchronous
 executable-path lookup before testing or passing the path to Chrome. Supported Node versions remain
-24.14.x and 26.x; the Docker image and CI pin 24.22.1, the first 24.x release with
+Node 24 (24.14.0 or later) and 26.x; the Docker image and CI pin 24.22.1, the first 24.x release with
 the October 21, 2026 Node.js security fixes (including CVE-2026-111497). Use
 `npm ci` to reproduce the checked-in dependency tree.
 
diff --git a/scripts/setup-doctor.mjs b/scripts/setup-doctor.mjs
index 7075be2c1..600e96b09 100644
--- a/scripts/setup-doctor.mjs
+++ b/scripts/setup-doctor.mjs
@@ -57,7 +57,7 @@ export function classifyNodeVersion(version = process.versions.node) {
   // NEWER than this release has verified is a warning, never a refusal: a
   // future Node must not brick a no-terminal install with advice its user
   // cannot follow. Too-old stays an error above — old runtimes genuinely fail.
-  return { level: 'warn', summary: 'newer than this release has verified; Node 24.14.x or 26.x is the tested path' };
+  return { level: 'warn', summary: 'newer than this release has verified; Node 24.22.x or 26.x is the tested path' };
 }
 
 /** Verify that every direct package declared by this checkout is present. */

From 9fecc9c4ee7c469d0cc9cee3f571ff6a2b6fa6df Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 2 Nov 2026 07:00:03 -0800
Subject: [PATCH 61/70] Say the alias hint filters only the first two aliases,
 and drop an id the filter now covers

---
 changelog.d/1462-voice-alias-hint-budget.md | 2 +-
 src/voice/layerManifest.js                  | 8 +++-----
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/changelog.d/1462-voice-alias-hint-budget.md b/changelog.d/1462-voice-alias-hint-budget.md
index 82628c52c..ae0b1be38 100644
--- a/changelog.d/1462-voice-alias-hint-budget.md
+++ b/changelog.d/1462-voice-alias-hint-budget.md
@@ -1,5 +1,5 @@
 - Leave layer aliases the layer id already spells, such as "dams" for
   `local-dams`, out of the voice layer hint. The Realtime prompt is 305
   characters shorter, leaving room under the 52,000 gate for new
-  voice-toggleable layers; every alias is still accepted (quanticsoul4772,
+  voice-toggleable layers; every alias is still accepted (@quanticsoul4772,
   #1462).
diff --git a/src/voice/layerManifest.js b/src/voice/layerManifest.js
index faa7207d0..962bf6949 100644
--- a/src/voice/layerManifest.js
+++ b/src/voice/layerManifest.js
@@ -525,8 +525,6 @@ const SELF_EVIDENT_IDS = new Set([
   'radio',
   'wind',
   'directions',
-  // The brand is already the layer id; all spoken aliases remain accepted.
-  's2-ghostmaps',
 ]);
 
 /** Lower case with spaces and hyphens removed: "Data centers" → "datacenters". */
@@ -535,9 +533,9 @@ const spelled = (text) => text.toLowerCase().replace(/[\s-]+/g, '');
 /**
  * Compact model-facing alias hint: "alias/alias→id; …" for toggleable layers
  * whose id is not already the spoken word. At most two aliases per layer keep
- * the tool JSON small; the runner accepts the full alias list. An alias the id
- * already spells ("dams"→local-dams, "weather radar"→weather-radar) is left
- * out, and so is a layer with no other alias.
+ * the tool JSON small; the runner accepts the full alias list. Of those two,
+ * an alias the id already spells ("dams"→local-dams, "weather radar"→
+ * weather-radar) is left out, and a layer with neither left gets no hint.
  * @returns {string} One line for the layerId description.
  */
 export function voiceLayerAliasHint() {

From e9c6f2541f10ebc06ffbb9a9885bfc856224c835 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 2 Nov 2026 07:10:40 -0800
Subject: [PATCH 62/70] Drop the gap beside the icon-only dock wings, point the
 state doc at the Vue dock, and credit the author

---
 changelog.d/1457-dock-icon-only-wings.md | 2 +-
 docs/CURRENT-STATE.md                    | 8 ++++----
 src/ui/styles/command-dock-trays.css     | 2 ++
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/changelog.d/1457-dock-icon-only-wings.md b/changelog.d/1457-dock-icon-only-wings.md
index 21825669b..3d82cb934 100644
--- a/changelog.d/1457-dock-icon-only-wings.md
+++ b/changelog.d/1457-dock-icon-only-wings.md
@@ -2,4 +2,4 @@
   Location and Visual Presets dock wings show only their icons, so their
   labels no longer spill over the voice control or take taps meant for the
   mic button. The full name stays in the tooltip and accessible name, and the
-  Cyber layout keeps its labels (ZloyS, #1457).
+  Cyber layout keeps its labels (Denis Groshev, @ZloyS, #1457).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index a284cfbe5..c6accd22c 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -2801,11 +2801,11 @@ isCurrent })` gates BOTH halves of the map-stack switch, which is its only
 >   to 4.25rem, open or closed (an open tray pops out above the dock), which is
 >   too narrow for their text labels. The labels used to spill over the voice
 >   control, and the LOCATION label captured taps on the left half of the mic
->   button (HAL-728). `src/ui/styles/command-dock-trays.css` now sets the
+>   button. `src/ui/styles/command-dock-trays.css` now sets the
 >   labels to `font-size: 0` and drops their `›`/`‹` chevrons in that band, so
->   each wing shows only its icon. The text node is unchanged, so
->   `panelChrome.js` still builds the toggles' "Expand/Collapse …" `aria-label`
->   and `title` from it; the browser tooltip is the only visible name on hover.
+>   each wing shows only its icon. `CommandDockView.vue` still gives the toggles
+>   their "Expand/Collapse …" `aria-label` and `title` (`trayWords`), so the
+>   browser tooltip is the only visible name on hover.
 >   The Cyber HUD layout is excluded: it sets `--dock-side-compact` to
 >   9–9.75rem, which fits its labels. The former ≤620px ellipsis clip is gone:
 >   the phone shell takes over at 720px, so it never applied to a visible
diff --git a/src/ui/styles/command-dock-trays.css b/src/ui/styles/command-dock-trays.css
index 2f8585f4a..fb41acb8e 100644
--- a/src/ui/styles/command-dock-trays.css
+++ b/src/ui/styles/command-dock-trays.css
@@ -511,6 +511,8 @@ body:not(.ui-clean-view):not(.recording-mode):has(
     .location-toolbar-label {
     font-size: 0;
     letter-spacing: 0;
+    /* The empty text is still a flex item; drop the gap it would claim. */
+    gap: 0;
   }
 
   :root:not([data-ui-theme='cyber'])

From 799273b3017523b02b5e6414a4af13d2e1d198a5 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 2 Nov 2026 07:06:06 -0800
Subject: [PATCH 63/70] Test the installations gate with the Overpass proxy
 tests, drop the stray PR body, and correct the fragment

---
 ...-military-installations-cross-site-gate.md |  10 +-
 docs/CURRENT-STATE.md                         |   2 +
 pr-body.md                                    |  75 ---------
 src/militaryInstallationsGate.test.mjs        | 147 ------------------
 src/overpassOffload.test.mjs                  |  44 +++++-
 5 files changed, 47 insertions(+), 231 deletions(-)
 delete mode 100644 pr-body.md
 delete mode 100644 src/militaryInstallationsGate.test.mjs

diff --git a/changelog.d/1427-military-installations-cross-site-gate.md b/changelog.d/1427-military-installations-cross-site-gate.md
index 3665da022..35d9e73e7 100644
--- a/changelog.d/1427-military-installations-cross-site-gate.md
+++ b/changelog.d/1427-military-installations-cross-site-gate.md
@@ -1,6 +1,4 @@
-- The military-installations proxy (`/api/military-installations`) now refuses
-  cross-site browser requests with the same `admitSameSite` gate that protects
-  the terrain, CCTV, traffic, places, and Celestrak proxies. A cross-site
-  `<img>`, a foreign `Origin`, an opaque origin, or a reverse-proxy-forwarded
-  request receives 403 before any Overpass query runs. Same-origin app requests
-  and bare tool requests (curl, Node harness) continue to work. (Sunil56224972)
+- The military-installations proxy (`/api/military-installations`) now refuses
+  cross-site and reverse-proxy-forwarded browser requests with 403 before any
+  Overpass work, through the same shared gate as `/api/overpass`. Same-origin
+  app requests and local tools such as curl still work (@Sunil56224972, #1427).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 84d42cb7b..c771dc02a 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5084,6 +5084,8 @@ repointing `OVERPASS_UPSTREAMS` refetches instead of serving another instance's
 answers; untagged entries stop serving once an instance is configured.
 
 The shared transport guards `/api/overpass` and `/api/military-installations`.
+Both query handlers refuse cross-site and forwarded browser requests through
+the shared local-request gate, before any rate-limit, cache or upstream work.
 With no configured upstream, each route serves existing cache data (including
 expired entries, marked stale with the original cache/retrieval date) without
 refresh. An annotation miss returns HTTP 503, `OVERPASS_NOT_CONFIGURED`,
diff --git a/pr-body.md b/pr-body.md
deleted file mode 100644
index 28e73decc..000000000
--- a/pr-body.md
+++ /dev/null
@@ -1,75 +0,0 @@
-## Summary
-
-Adds the `admitSameSite` cross-site gate to `/api/military-installations`, as offered in the [#975 merge comment](https://github.com/bilawalsidhu/gods-eye-view/pull/975#issuecomment-6357981946).
-
-This was the last keyless proxy endpoint without the gate. After this change, every proxy that sends queries upstream now refuses cross-site browser requests before doing any work.
-
-| Endpoint | Gate before this PR | Gate after |
-|----------|-------------------|------------|
-| `/api/terrain/heights` | ✅ admitSameSite (#975) | ✅ |
-| `/api/cctv/frame/:id` | ✅ admitSameSite (#922) | ✅ |
-| `/api/traffic/*` | ✅ admitSameSite | ✅ |
-| `/api/google/*` | ✅ admitSameSite | ✅ |
-| `/api/gemini/*` | ✅ admitSameSite | ✅ |
-| `/api/space/satellites` | ✅ admitSameSite | ✅ |
-| `/api/overpass` | ✅ admitSameSite | ✅ |
-| `/api/military-installations` | ❌ **none** | ✅ admitSameSite |
-
-## The problem
-
-A cross-site page (or an `<img>` tag from any website) can query `/api/military-installations` and trigger upstream Overpass requests on the user's behalf. The endpoint has a rate limiter (90/min), but no cross-site gate — so a hostile page can burn through the user's Overpass quota and exfiltrate the response data.
-
-Every other proxy in the codebase already refuses these shapes. Military-installations was the gap.
-
-## The fix
-
-Two lines in `server/providers/military-installations.js`:
-
-```diff
- import { makeRateLimiter, clientKey } from './common/rate-limit.js';
-+import { admitSameSite } from './common/same-site.js';
-```
-
-```diff
-       if (req.method !== 'GET') {
-         res.writeHead(405, { 'Content-Type': 'application/json' });
-         res.end(JSON.stringify({ error: 'Method Not Allowed' }));
-         return;
-       }
-+      if (admitSameSite(req, res)) return;
-       const url = new URL(req.url, 'http://localhost');
-```
-
-Same pattern as terrain.js, cctv.js, traffic.js, google.js, etc. Gate runs before the rate limiter, so refused requests never consume quota.
-
-`scripts/package-boundaries.json` updated to declare `server/providers/common/same-site.js` and `src/localRequestGate.mjs` as owned modules of `military-installations-provider`.
-
-## Tests
-
-New file: `src/militaryInstallationsGate.test.mjs` — 4 integration tests following the `terrainHeightsBounds.test.mjs` pattern:
-
-```
-✔ cross-site browser requests are refused with 403 (2.4ms)
-✔ same-origin browser request is admitted (not 403) (5.3ms)
-✔ bare tool request (no Origin, no Sec-Fetch) is admitted (0.9ms)
-✔ proxied same-origin requests are refused (proxy headers present) (0.5ms)
-```
-
-Tested shapes:
-- `Sec-Fetch-Site: cross-site` (the `<img>` case) → 403
-- `Sec-Fetch-Site: same-site` (cross-origin sibling) → 403
-- `Origin: https://evil.example` (fetch from hostile page) → 403
-- `Origin: null` (sandboxed iframe) → 403
-- `X-Forwarded-For` + `Sec-Fetch-Site: cross-site` (proxied cross-site) → 403
-- Same-origin with matching `Origin` → admitted
-- No `Origin`, no `Sec-Fetch` (curl / Node) → admitted
-- Proxy headers with `same-origin` → 403
-
-All 4 tests fail on `main` and pass with the fix.
-
-## Validation
-
-- `node --test src/localRequestGate.test.mjs src/militaryInstallationsGate.test.mjs`: **18 tests, 18 pass, 0 fail**
-- `npm run check:boundaries`: **pass** (military-installations-provider: 15 owned modules)
-- `npm run check:import-directions`: pass
-- Changelog fragment in `changelog.d/military-installations-cross-site-gate.md`
diff --git a/src/militaryInstallationsGate.test.mjs b/src/militaryInstallationsGate.test.mjs
deleted file mode 100644
index 4451c384b..000000000
--- a/src/militaryInstallationsGate.test.mjs
+++ /dev/null
@@ -1,147 +0,0 @@
-// Military-installations cross-site gate — verifies that the admitSameSite
-// gate added in this PR actually refuses the same request shapes the terrain
-// and CCTV proxies already refuse, and admits same-origin and bare-tool
-// requests.
-//
-// Run with: npm test
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { militaryInstallationsProxy } from '../server/providers/military-installations.js';
-
-function install(plugin) {
-  const routes = new Map();
-  plugin.configureServer({
-    middlewares: {
-      use(path, handler) {
-        routes.set(path, handler);
-      },
-    },
-  });
-  return routes;
-}
-
-function request(
-  handler,
-  { url = '/', method = 'GET', remoteAddress = '127.0.0.1', reqHeaders = {} } = {},
-) {
-  return new Promise((resolve, reject) => {
-    const headers = new Map();
-    const req = {
-      method,
-      url,
-      headers: reqHeaders,
-      socket: { remoteAddress },
-    };
-    const res = {
-      statusCode: 200,
-      headersSent: false,
-      setHeader(name, value) {
-        headers.set(String(name).toLowerCase(), String(value));
-      },
-      writeHead(status, hdrs = {}) {
-        this.statusCode = status;
-        this.headersSent = true;
-        for (const [name, value] of Object.entries(hdrs))
-          headers.set(String(name).toLowerCase(), String(value));
-      },
-      end(body = '') {
-        let parsed = null;
-        try {
-          parsed = body ? JSON.parse(String(body)) : null;
-        } catch {
-          parsed = String(body);
-        }
-        resolve({
-          statusCode: this.statusCode,
-          headers: Object.fromEntries(headers),
-          body: parsed,
-        });
-      },
-    };
-    Promise.resolve(handler(req, res)).catch(reject);
-  });
-}
-
-// A valid bbox query string for military-installations.
-const VALID_BBOX = '?south=48.8&west=2.2&north=48.9&east=2.4';
-const HOST = 'localhost:5173';
-
-test('cross-site browser requests are refused with 403', async () => {
-  const route = install(militaryInstallationsProxy()).get(
-    '/api/military-installations',
-  );
-  const refused = [
-    // <img src> from any web page
-    { host: HOST, 'sec-fetch-site': 'cross-site' },
-    // same-site but cross-origin sibling
-    { host: HOST, 'sec-fetch-site': 'same-site' },
-    // fetch from another page
-    { host: HOST, origin: 'https://evil.example' },
-    // sandboxed frame
-    { host: HOST, origin: 'null' },
-    // behind a reverse proxy with cross-site
-    { host: HOST, 'x-forwarded-for': '203.0.113.9', 'sec-fetch-site': 'cross-site' },
-  ];
-  for (const reqHeaders of refused) {
-    const answer = await request(route, { url: VALID_BBOX, reqHeaders });
-    assert.equal(
-      answer.statusCode,
-      403,
-      `expected 403 for headers ${JSON.stringify(reqHeaders)}, got ${answer.statusCode}`,
-    );
-  }
-});
-
-test('same-origin browser request is admitted (not 403)', async () => {
-  const route = install(militaryInstallationsProxy()).get(
-    '/api/military-installations',
-  );
-  // Same-origin with matching origin header
-  const answer = await request(route, {
-    url: VALID_BBOX,
-    reqHeaders: {
-      host: HOST,
-      origin: `http://${HOST}`,
-      'sec-fetch-site': 'same-origin',
-    },
-  });
-  // Should get past the gate — may be 200, 429, or 503 depending on Overpass config,
-  // but never 403.
-  assert.notEqual(answer.statusCode, 403, 'same-origin request should not be refused');
-});
-
-test('bare tool request (no Origin, no Sec-Fetch) is admitted', async () => {
-  const route = install(militaryInstallationsProxy()).get(
-    '/api/military-installations',
-  );
-  // curl / Node harness — no browser headers at all
-  const answer = await request(route, {
-    url: VALID_BBOX,
-    reqHeaders: { host: HOST },
-  });
-  assert.notEqual(answer.statusCode, 403, 'bare tool request should not be refused');
-});
-
-test('proxied same-origin requests are refused (proxy headers present)', async () => {
-  const route = install(militaryInstallationsProxy()).get(
-    '/api/military-installations',
-  );
-  const proxied = [
-    { host: HOST, 'sec-fetch-site': 'same-origin', 'x-forwarded-for': '203.0.113.9' },
-    { host: HOST, 'sec-fetch-site': 'same-origin', 'cf-connecting-ip': '203.0.113.9' },
-    {
-      host: HOST,
-      'sec-fetch-site': 'same-origin',
-      forwarded: 'for=203.0.113.9;proto=https',
-      via: '1.1 caddy',
-    },
-  ];
-  for (const reqHeaders of proxied) {
-    const answer = await request(route, { url: VALID_BBOX, reqHeaders });
-    assert.equal(
-      answer.statusCode,
-      403,
-      `expected 403 for proxied headers ${JSON.stringify(reqHeaders)}, got ${answer.statusCode}`,
-    );
-  }
-});
diff --git a/src/overpassOffload.test.mjs b/src/overpassOffload.test.mjs
index 602bab8e4..7ef6b0c2b 100644
--- a/src/overpassOffload.test.mjs
+++ b/src/overpassOffload.test.mjs
@@ -54,14 +54,22 @@ async function call(handlers, url, init = {}) {
   Object.assign(req, {
     method: init.method || 'GET',
     url: parsed.pathname.slice(mount.length) + parsed.search || '/',
-    headers: {},
+    headers: init.headers || {},
     socket: { remoteAddress: '127.0.0.1' },
   });
-  let status, headers, body;
+  let status, body;
+  let headers = {};
   await handlers.get(mount)(req, {
+    // The cross-site gate answers through statusCode/setHeader, not writeHead.
+    set statusCode(s) {
+      status = s;
+    },
+    setHeader(name, value) {
+      headers[name] = value;
+    },
     writeHead(s, h) {
       status = s;
-      headers = h;
+      headers = { ...headers, ...h };
     },
     end(b) {
       body = b;
@@ -166,6 +174,36 @@ test('zero egress: every Overpass consumer reaches real default handlers, and re
   );
 });
 
+test('the installations proxy refuses cross-site and forwarded requests before any Overpass work', async (t) => {
+  env(t);
+  t.mock.method(globalThis, 'fetch', () =>
+    assert.fail('unexpected upstream fetch'),
+  );
+  const handlers = routes(militaryInstallationsProxy());
+  const url =
+    '/api/military-installations?south=48.8&west=2.2&north=48.9&east=2.4';
+  for (const headers of [
+    { 'sec-fetch-site': 'cross-site' },
+    { 'sec-fetch-site': 'same-site' },
+    { origin: 'https://foreign.example' },
+    { origin: 'null' },
+    { 'sec-fetch-site': 'same-origin', 'x-forwarded-for': '203.0.113.9' },
+  ]) {
+    const response = await call(handlers, url, { headers });
+    assert.equal(response.status, 403, JSON.stringify(headers));
+    assert.equal(response.headers.get('cache-control'), 'no-store');
+  }
+  for (const headers of [
+    {},
+    { origin: 'http://localhost:4173', 'sec-fetch-site': 'same-origin' },
+  ]) {
+    const response = await call(handlers, url, {
+      headers: { host: 'localhost:4173', ...headers },
+    });
+    assert.notEqual(response.status, 403, JSON.stringify(headers));
+  }
+});
+
 test('an unconfigured server is probed once and never sent a feature query', async (t) => {
   env(t);
   t.mock.method(globalThis, 'fetch', () =>

From c572a28e4484b45009d8ab71eb42e906109a7cff Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 2 Nov 2026 07:13:44 -0800
Subject: [PATCH 64/70] Mend the test prerequisites, document local CCTV packs
 without the dead demo feed, and credit the author

---
 CONTRIBUTING.md                             | 16 +++++-----
 DATA_SOURCES.md                             | 35 +++++----------------
 changelog.d/210-contributor-docs-refresh.md |  4 +++
 3 files changed, 20 insertions(+), 35 deletions(-)
 create mode 100644 changelog.d/210-contributor-docs-refresh.md

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5e625cd84..49c0b8ce3 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -34,16 +34,18 @@ Open `http://localhost:4173`. Before sending a PR run `npm run build`, `npm test
 - **`npm run test:track`** — the 3D flight-tracking regression harness. It
   drives the **real app** in headless Chromium, so it **requires a running
   dev server** (default `http://localhost:4173`). To target another instance,
-  run `npm run test:track -- --url <app-url>` (or `node scripts/track-regression.mjs --url <app-url>`).
-  depend on live OpenSky / adsb.lol / AISStream (those are optional or
-  rate-limited locally); it installs a persistent `fetch` shim that returns
-  synthetic aircraft in the exact upstream payload shapes the layers parse.
+  run `npm run test:track -- --url <app-url>` (or
+  `node scripts/track-regression.mjs --url <app-url>`). It does not depend on
+  live OpenSky / adsb.lol / AISStream (those are optional or rate-limited
+  locally); it installs a persistent `fetch` shim that returns synthetic
+  aircraft in the exact upstream payload shapes the layers parse.
 - **`npm run build`** — production Vite build. No server or credentials
   required; it validates that the client bundle compiles cleanly.
 
-If you change runtime behavior, update `docs/CURRENT-STATE.md` and
-`CHANGELOG.md` in the same PR. For a deeper catalog of what each harness
-checks and what it needs to run, see [TESTING.md](TESTING.md).
+Each feature also has its own headless gate; see
+[Feature regression gates](#feature-regression-gates) below. Docs and changelog
+rules are under [Pull requests](#pull-requests).
+
 ## Checking a built app locally
 
 Run `npm run build` followed by `npm run preview`. Preview serves the built
diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md
index 0ae94b746..403972d5e 100644
--- a/DATA_SOURCES.md
+++ b/DATA_SOURCES.md
@@ -304,35 +304,14 @@ the retrieval date (2026-07-30), exact download URL, license evidence, and the
 deterministic transform (`scripts/build-sf-neighborhoods.mjs`: `nhood` → `name`, ~2 m
 Douglas-Peucker simplification, 6-decimal rounding).
 
-### Pilot CCTV source packs (`config/`)
+### Local CCTV source packs (`config/`)
 
-`config/cctv_sources.shinjuku.json` is a **demo source pack** (3 cameras:
-Shinjuku Crossing, Shinjuku Station West, Shibuya Scramble) used for
-projection-pipeline testing. The feeds are Google-hosted sample MP4 videos
-(`storage.googleapis.com/gtv-videos-bucket/sample/`), not live public cameras.
-Camera poses (coordinates, heading, pitch, FOV, mount height) are fabricated
-priors placed at recognizable Tokyo intersections.
-
-Use the pack by setting:
-
-```bash
-CCTV_SOURCES_FILE=config/cctv_sources.shinjuku.json npm run dev
-```
-
-Or equivalently, via `./scripts/dev-cctv.sh`:
-
-```bash
-CCTV_SOURCES_FILE=config/cctv_sources.shinjuku.json ./scripts/dev-cctv.sh
-```
-
-The pack exercises the same CCTV registration and frustum-projection pipeline
-as live city packs without requiring network access to a camera catalog. It is
-**not** a live data source and carries no external attribution requirement. The
-sample videos are publicly available Google test media.
-
-`config/cctv_sources.austin.json` is the reference live pack. Custom source
-packs follow the same JSON schema (see either file); `CCTV_SOURCES_JSON`
-accepts inline JSON as an alternative to a file path.
+The server can read a local camera list from `CCTV_SOURCES_FILE` (default
+`config/cctv_sources.austin.json`, which ships empty) and inline JSON from
+`CCTV_SOURCES_JSON`; the two are merged, and inline entries win on a duplicate
+id. A non-empty local pack replaces the live open-data camera packs unless
+`CCTV_FORCE_AUSTIN=1` is set. The packs under `config/` show the schema, and a
+pack's cameras keep their own source's license and attribution.
 
 ---
 
diff --git a/changelog.d/210-contributor-docs-refresh.md b/changelog.d/210-contributor-docs-refresh.md
new file mode 100644
index 000000000..ed6dbe354
--- /dev/null
+++ b/changelog.d/210-contributor-docs-refresh.md
@@ -0,0 +1,4 @@
+- Contributor docs: CONTRIBUTING lists what each of the three baseline checks
+  needs to run, DATA_SOURCES documents loading a local CCTV source pack, and
+  KNOWN-ISSUES points the floor-placement note at its verification script
+  instead of a missing report (Gaurav Patidar, @gaurav7902, #210).

From d646fdbe60c40e7194a387067ed494100efb5e97 Mon Sep 17 00:00:00 2001
From: Sameh Khamis <sameh@halfpixel.ai>
Date: Mon, 2 Nov 2026 07:39:02 -0800
Subject: [PATCH 65/70] Pin Node 24.22.2, the current 24 LTS patch, keeping
 24.22.1 as the security floor

---
 .github/ISSUE_TEMPLATE/bug_report.yml             | 2 +-
 .github/workflows/ci.yml                          | 8 ++++----
 CONTRIBUTING.md                                   | 4 ++--
 Dockerfile                                        | 2 +-
 changelog.d/1458-node-24-22-1-security-release.md | 7 ++++---
 docs/CURRENT-STATE.md                             | 7 ++++---
 6 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index 9069c648d..b753f8fef 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -40,7 +40,7 @@ body:
     attributes:
       label: OS, Node version, browser
       description: Include the versions you can find. Write "unknown" for anything unavailable.
-      placeholder: "Windows 11, Node 24.22.1, Chrome 151"
+      placeholder: "Windows 11, Node 24.22.2, Chrome 151"
     validations:
       required: true
   - type: input
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 766f0cc51..63d1eb29b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,10 +20,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node: [24.22.1, 26.x]
+        node: [24.22.2, 26.x]
     env:
       PUPPETEER_SKIP_DOWNLOAD: '1'
-      GEV_REQUIRE_ALLOCATION_GATE: ${{ matrix.node == '24.22.1' && '1' || '0' }}
+      GEV_REQUIRE_ALLOCATION_GATE: ${{ matrix.node == '24.22.2' && '1' || '0' }}
     steps:
       - name: Check out source
         uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
@@ -76,7 +76,7 @@ jobs:
       - name: Use Node.js
         uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
-          node-version: 24.22.1
+          node-version: 24.22.2
           cache: npm
 
       - name: Install locked dependencies and headless Chrome
@@ -131,7 +131,7 @@ jobs:
       - name: Use Node.js
         uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
-          node-version: 24.22.1
+          node-version: 24.22.2
           cache: npm
 
       - name: Run the Pinokio install path
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5850fe650..9361e1f3c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -11,8 +11,8 @@ fixes, including CVE-2026-111497 (a Brotli decoder flaw).
 ```bash
 git clone https://github.com/bilawalsidhu/gods-eye-view.git
 cd gods-eye-view
-nvm install 24.22.1
-nvm use 24.22.1
+nvm install 24.22.2
+nvm use 24.22.2
 npm install
 npm run doctor
 ./scripts/dev-fresh.sh        # or: npm run dev (keys are optional)
diff --git a/Dockerfile b/Dockerfile
index e711ec1d9..a9b8aebd9 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -4,7 +4,7 @@
 # proxies (ADS-B, AIS, Overpass, OpenAI Realtime, ...) as middleware, so there
 # is nothing else to containerise. See compose.yaml for the usual entry point.
 # Same Node as CI (package.json engines, .github/workflows), pinned by digest.
-FROM node:24.22.1-slim@sha256:be8204d4bd327363357f532187b752ff62759c31bedf98e9e18fc08c9cbd605c
+FROM node:24.22.2-slim@sha256:c86ecead9e55a5210ac1727de38a4ca840bf03dcaf34dc9749addbf383b1920c
 
 # Puppeteer is only used by the QA scripts; skip its ~150MB Chromium download.
 ENV PUPPETEER_SKIP_DOWNLOAD=1
diff --git a/changelog.d/1458-node-24-22-1-security-release.md b/changelog.d/1458-node-24-22-1-security-release.md
index 8c8cdd318..d379a26f1 100644
--- a/changelog.d/1458-node-24-22-1-security-release.md
+++ b/changelog.d/1458-node-24-22-1-security-release.md
@@ -1,3 +1,4 @@
-- The Docker image and CI now pin Node 24.22.1, the first 24.x release with
-  the October 21, 2026 security fixes, including CVE-2026-111497 in the Brotli
-  decoder (Luis Ortiz, @anobjectn, #1458).
+- The Docker image and CI now pin Node 24.22.2, the current 24 LTS patch. It
+  carries the October 21, 2026 security fixes first released in 24.22.1,
+  including CVE-2026-111497 in the Brotli decoder (Luis Ortiz, @anobjectn,
+  #1458).
diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 11df591b0..1792c73de 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -3436,7 +3436,7 @@ down | auth-failed` (plus the unchanged `missing-key`/`unsupported`) with
 >   operator-side; the final accounting records only comparable population
 >   reductions and deterministic Node allocation/solve measurements. Those
 >   allocation gates were calibrated on Node.js 24.14.x and run in CI on the
->   pinned Node.js 24.22.1 with the same ceilings; `package.json` permits
+>   pinned Node.js 24.22.2 with the same ceilings; `package.json` permits
 >   supported product runtimes on Node 24 or 26, while the allocation runner
 >   separately enforces Node 24 for these two calibrated probes. Each probe
 >   compiles synchronously and discards explicit-GC
@@ -6183,8 +6183,9 @@ The lockfile uses DOMPurify 3.4.17, protobufjs 8.8.0, PostCSS 8.5.28,
 source-map-js 1.2.2 and nanoid 3.3.19. Cesium remains on 1.138.0. Browser QA
 uses Puppeteer 25.10.0; image-processing tools use Sharp 0.35.5. QA scripts await Puppeteer's asynchronous
 executable-path lookup before testing or passing the path to Chrome. Supported Node versions remain
-Node 24 (24.14.0 or later) and 26.x; the Docker image and CI pin 24.22.1, the first 24.x release with
-the October 21, 2026 Node.js security fixes (including CVE-2026-111497). Use
+Node 24 (24.14.0 or later) and 26.x; the Docker image and CI pin 24.22.2,
+the current 24 LTS patch, which carries the October 21, 2026 Node.js security
+fixes first released in 24.22.1 (including CVE-2026-111497). Use
 `npm ci` to reproduce the checked-in dependency tree.
 
 ### Traffic city navigation

From 38eb98b8f805c513dc4072fa7a2248b997acc2d2 Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Mon, 2 Nov 2026 16:43:39 +0000
Subject: [PATCH 66/70] Take a hidden shape off the globe whole, and keep every
 drawn shape

Answers the review of bdbbc3d7 and the IC8 pass after it.

A shape hidden from Draw's list was only set to alpha 0, so the line's
flowing stroke, which keeps its own colour, stayed painted. Now:
- the world renderer's sync() sets every entity of a hidden mark to
  show = false, and FlowMaterialProperty follows the mark's alpha;
- the screen renderer does not project a hidden callout, so it is not drawn
  and cannot push a visible label aside;
- hiding acts at once, even before a mark's first frame, and with every
  mark hidden the annotations render hold is released after one last frame;
- fly_route skips a hidden route.

Hand-drawn shapes are never merged as duplicates: every one is drawn on
purpose and unnamed until its row names it, so a second pin dropped near
the first was dropped, or replaced the first when its colour differed. A
restyle the renderer cannot draw now also syncs the renderer.

Tests cover each: renderer show/hide and flow alpha, the screen skip, the
render hold and its last frame, a show with no fade-in, hidden routes, two
nearby pins, and the restyle rollback.
---
 src/annotations/annotationEngine.js           |  20 +++-
 src/annotations/annotationEngine.test.mjs     | 105 ++++++++++++++++++
 src/annotations/screenAnnotationRenderer.js   |   4 +-
 .../screenAnnotationRenderer.test.mjs         |  46 ++++++++
 src/annotations/worldAnnotationRenderer.js    |  25 ++++-
 .../worldAnnotationRenderer.test.mjs          |  70 ++++++++++++
 src/cameraVerbs.js                            |   7 +-
 src/routeCinematics.test.mjs                  |  17 +++
 8 files changed, 288 insertions(+), 6 deletions(-)
 create mode 100644 src/annotations/worldAnnotationRenderer.test.mjs

diff --git a/src/annotations/annotationEngine.js b/src/annotations/annotationEngine.js
index 62bbef31f..fdca91f08 100644
--- a/src/annotations/annotationEngine.js
+++ b/src/annotations/annotationEngine.js
@@ -5,6 +5,7 @@ import { greatCircleMeters } from '../geoDistance.js';
 import {
   holdContinuousRender,
   releaseContinuousRender,
+  governorRequestRender,
 } from '../renderGovernor.js';
 import {
   isRateLimitedOutcome,
@@ -201,8 +202,11 @@ export function createAnnotationEngine({
   // World annotations carry persistent per-frame scene animation (pulsing
   // live colors, camera-scaled rings, route-flow uniforms in the renderer),
   // so the scene must render continuously while any mark exists. (perf wave 2)
+  // Only a mark someone can see needs every frame drawn: a board of marks
+  // hidden from Draw's list lets the scene idle.
   function syncAnnotationHold() {
-    if (annotations.size > 0) holdContinuousRender('annotations');
+    const visible = [...annotations.values()].some((anno) => !anno.hidden);
+    if (visible) holdContinuousRender('annotations');
     else releaseContinuousRender('annotations');
   }
 
@@ -250,6 +254,9 @@ export function createAnnotationEngine({
       if (changed) {
         renderer.sync(annotations);
         syncAnnotationHold();
+        // The frame that takes a just-hidden mark off: with every mark hidden
+        // the hold is gone, and nothing else would draw it.
+        governorRequestRender('annotations');
       }
       if (expired) notifyChange();
       // Stop once the board is STABLE — persistent marks (persist=true is the default)
@@ -811,6 +818,11 @@ export function createAnnotationEngine({
    *  degenerate geocode stacks on one point (several Capitol monuments) would erase each other. */
   function findDuplicate(anno) {
     if (!anno.anchor) return null;
+    // A shape drawn by hand is always new: each click is meant, and every
+    // shape is unnamed until its row names it, so two nearby pins would
+    // otherwise read as one and the second would replace or vanish into the
+    // first.
+    if (anno.manual) return null;
     const near = (a, b) =>
       a &&
       b &&
@@ -1017,6 +1029,11 @@ export function createAnnotationEngine({
     anno.hidden = Boolean(hidden);
     // Skip the fade-in, so showing it again is immediate.
     anno.bornAt = Math.min(anno.bornAt, performance.now() - 260);
+    // Take it off (or put it back) now, not when its alpha next changes: a
+    // mark hidden before its first frame has no alpha change to wait for.
+    renderer.sync(annotations);
+    syncAnnotationHold();
+    governorRequestRender('annotations');
     ensureTicking();
     notifyChange();
     return true;
@@ -1043,6 +1060,7 @@ export function createAnnotationEngine({
     } catch (error) {
       rollbackRendererState(anno);
       annotations.delete(id);
+      renderer.sync(annotations);
       syncAnnotationHold();
       notifyChange();
       throw error;
diff --git a/src/annotations/annotationEngine.test.mjs b/src/annotations/annotationEngine.test.mjs
index 1f0a6958f..833c66146 100644
--- a/src/annotations/annotationEngine.test.mjs
+++ b/src/annotations/annotationEngine.test.mjs
@@ -987,3 +987,108 @@ test('a drawn line that rounds up to the next unit is labelled in it, not as 100
   assert.deepEqual(labels, ['990 m', '1.0 km', '9.9 km', '10 km']);
   engine.destroy();
 });
+
+test('hand-drawn marks: two unnamed pins close together are two pins, whatever their colours', async (t) => {
+  installAnimationFrameStubs(t);
+  _resetRenderGovernorForTest();
+  t.after(() => _resetRenderGovernorForTest());
+  const { renderer } = fakeRenderer();
+  const engine = createAnnotationEngine({ viewer: {}, renderer });
+  const pin = (lon, color) => ({ type: 'pin', manual: true, latitude: 30.27, longitude: lon, label: '', color });
+  await engine.annotate([pin(-97.74, 'primary')], { persist: true });
+  await engine.annotate([pin(-97.7402, 'primary')], { persist: true });
+  await engine.annotate([pin(-97.7404, 'red')], { persist: true });
+  assert.deepEqual(
+    engine.list().map(({ color }) => color),
+    ['primary', 'primary', 'red'],
+    'no drawn pin is dropped or replaced by the next',
+  );
+});
+
+test('hand-drawn marks: hiding a mark before its first frame takes it off at once', async (t) => {
+  installAnimationFrameStubs(t);
+  _resetRenderGovernorForTest();
+  t.after(() => _resetRenderGovernorForTest());
+  let syncs = 0;
+  const renderer = { add() {}, update() {}, remove() {}, sync() { syncs += 1; }, destroy() {} };
+  const engine = createAnnotationEngine({ viewer: {}, renderer });
+  await engine.annotate([{ type: 'pin', manual: true, latitude: 1, longitude: 1 }], { persist: true });
+  const [mark] = engine.list();
+  const before = syncs;
+  engine.setHidden(mark.id, true);
+  assert.ok(syncs > before, 'the renderer hears about it now');
+  assert.ok(
+    !getRenderGovernorDiagnostics().holds.includes('annotations'),
+    'and the render hold goes with the last visible mark',
+  );
+});
+
+test('hand-drawn marks: with every mark hidden the scene idles, and showing one wakes it', async (t) => {
+  installAnimationFrameStubs(t);
+  _resetRenderGovernorForTest();
+  t.after(() => _resetRenderGovernorForTest());
+  let renders = 0;
+  installRenderGovernor({ scene: { requestRenderMode: true, requestRender: () => (renders += 1) } });
+  const { renderer } = fakeRenderer();
+  const engine = createAnnotationEngine({ viewer: {}, renderer });
+  await engine.annotate([
+    { type: 'pin', manual: true, latitude: 1, longitude: 1 },
+    { type: 'pin', manual: true, latitude: 2, longitude: 2 },
+  ], { persist: true });
+  const [first, second] = engine.list();
+  const held = () => getRenderGovernorDiagnostics().holds.includes('annotations');
+  assert.ok(held(), 'visible marks keep the scene drawing');
+  engine.setHidden(first.id, true);
+  assert.ok(held(), 'one visible mark is enough');
+  const before = renders;
+  engine.setHidden(second.id, true);
+  assert.equal(held(), false, 'every mark hidden: the scene idles');
+  assert.ok(renders > before, 'after one last frame that takes them off');
+  engine.setHidden(second.id, false);
+  assert.ok(held(), 'showing one wakes it again');
+});
+
+test('hand-drawn marks: a restyle the renderer cannot draw takes the mark off and says so', async (t) => {
+  installAnimationFrameStubs(t);
+  _resetRenderGovernorForTest();
+  t.after(() => _resetRenderGovernorForTest());
+  const { renderer, failAddOnce } = throwingRendererHarness();
+  let syncs = 0;
+  renderer.sync = () => (syncs += 1);
+  const engine = createAnnotationEngine({ viewer: {}, renderer });
+  await engine.annotate([{ type: 'pin', manual: true, latitude: 1, longitude: 1 }], { persist: true });
+  const [mark] = engine.list();
+  let changes = 0;
+  engine.onChange(() => (changes += 1));
+  const before = syncs;
+  failAddOnce();
+  assert.throws(() => engine.restyle(mark.id, { color: 'red' }), /WebGL context lost/);
+  assert.equal(engine.list().length, 0, 'no ghost row is left behind');
+  assert.equal(changes, 1, 'the list hears about it');
+  assert.ok(syncs > before, 'and the renderer is told');
+});
+
+test('hand-drawn marks: a mark shown again right after it was drawn appears at once, not fading in', async (t) => {
+  _resetRenderGovernorForTest();
+  t.after(() => _resetRenderGovernorForTest());
+  const queued = [];
+  const raf = globalThis.requestAnimationFrame;
+  const caf = globalThis.cancelAnimationFrame;
+  globalThis.requestAnimationFrame = (callback) => queued.push(callback);
+  globalThis.cancelAnimationFrame = () => {};
+  t.after(() => {
+    globalThis.requestAnimationFrame = raf;
+    globalThis.cancelAnimationFrame = caf;
+  });
+  const tick = () => queued.splice(0).forEach((callback) => callback());
+  const { renderer } = fakeRenderer();
+  const engine = createAnnotationEngine({ viewer: {}, renderer });
+  await engine.annotate([{ type: 'pin', manual: true, latitude: 1, longitude: 1 }], { persist: true });
+  const [mark] = engine.list();
+  engine.setHidden(mark.id, true);
+  tick();
+  assert.equal(mark.alpha, 0);
+  engine.setHidden(mark.id, false);
+  tick();
+  assert.equal(mark.alpha, 1, 'no fade-in after a hide');
+});
diff --git a/src/annotations/screenAnnotationRenderer.js b/src/annotations/screenAnnotationRenderer.js
index f6c780c8f..2ae61f751 100644
--- a/src/annotations/screenAnnotationRenderer.js
+++ b/src/annotations/screenAnnotationRenderer.js
@@ -483,7 +483,9 @@ export function createScreenAnnotationRenderer(
 
     for (const rec of records.values()) {
       const { anno, group, parts } = rec;
-      if (rec.hidden) {
+      // A mark hidden from Draw's list is not projected, so it neither shows
+      // nor pushes a visible callout aside in the placement below.
+      if (rec.hidden || anno.hidden) {
         group.display = 'none';
         continue;
       }
diff --git a/src/annotations/screenAnnotationRenderer.test.mjs b/src/annotations/screenAnnotationRenderer.test.mjs
index 8f2431b7f..ed1bb7948 100644
--- a/src/annotations/screenAnnotationRenderer.test.mjs
+++ b/src/annotations/screenAnnotationRenderer.test.mjs
@@ -390,3 +390,49 @@ test("an earlier renderer leaves a later renderer's board alone", async (t) => {
   assert.equal(groups().length, 1);
   assert.equal(groups()[0].querySelector('text').textContent, 'Kept');
 });
+
+test('a mark hidden from Draw is not drawn or placed, and comes back when shown', async (t) => {
+  // happy-dom measures every SVG box the same, so callout spreading cannot
+  // settle here; a hidden mark simply has to stay out of drawing and
+  // placement, which is what keeps it from pushing a visible callout aside.
+  const { store, svg } = board(t);
+  projectTo(t, { x: 200, y: 300 });
+  const camera = cameraOver(0, 0);
+  let project = null;
+  const renderer = createScreenAnnotationRenderer(
+    {
+      scene: sceneFor(camera, {
+        postRender: {
+          addEventListener: (listener) => (project = listener),
+          removeEventListener() {},
+        },
+      }),
+      camera,
+      trackedEntity: null,
+    },
+    { store, activeTrackedReadoutId: () => null },
+  );
+  t.after(() => renderer.destroy());
+  const camp = {
+    id: 'camp',
+    type: 'pin',
+    color: 'amber',
+    label: 'Camp',
+    alpha: 1,
+    hidden: true,
+    anchor: { lon: 0, lat: 0, height: 0 },
+  };
+  renderer.add(camp);
+  project();
+  await settle();
+  const drawn = () =>
+    [...svg().querySelectorAll('g.gev-anno')].some(
+      (group) =>
+        group.textContent.includes('Camp') && group.style.display !== 'none',
+    );
+  assert.equal(drawn(), false, 'the hidden mark is not drawn');
+  camp.hidden = false;
+  project();
+  await settle();
+  assert.equal(drawn(), true, 'shown again, it is drawn');
+});
diff --git a/src/annotations/worldAnnotationRenderer.js b/src/annotations/worldAnnotationRenderer.js
index 9e077acce..692b3d4ff 100644
--- a/src/annotations/worldAnnotationRenderer.js
+++ b/src/annotations/worldAnnotationRenderer.js
@@ -51,6 +51,8 @@ export function createWorldAnnotationRenderer(viewer) {
   const dataSource = new Cesium.CustomDataSource('gev-annotations');
   viewer.dataSources.add(dataSource);
   const osmAnnotations = new Set();
+  // Every mark with entities on the globe, so sync() can take a hidden one out.
+  const drawn = new Set();
 
   // Register the GevRouteFlow fabric once so Cesium's Material.fromType() can build the
   // material the route pipeline renders. The animated `time` uniform is read straight
@@ -89,6 +91,7 @@ export function createWorldAnnotationRenderer(viewer) {
     // path cannot reach them and they stay on the globe forever.
     const entities = [];
     anno._entities = entities;
+    drawn.add(anno);
 
     if (
       anno.ring &&
@@ -247,6 +250,7 @@ export function createWorldAnnotationRenderer(viewer) {
             width: 9,
             material: new FlowMaterialProperty(
               PALETTE[anno.color] || PALETTE.primary,
+              () => anno.alpha ?? 1,
             ),
             clampToGround: true,
             classificationType: CLASSIFY,
@@ -320,6 +324,7 @@ export function createWorldAnnotationRenderer(viewer) {
   function remove(anno) {
     hideOsmCredit(viewer, anno);
     osmAnnotations.delete(anno);
+    drawn.delete(anno);
     if (!anno?._entities) return;
     for (const entity of anno._entities) {
       try {
@@ -331,13 +336,23 @@ export function createWorldAnnotationRenderer(viewer) {
     anno._entities = null;
   }
 
+  /**
+   * CallbackProperty drives per-frame alpha and pulse. A hidden mark is taken
+   * out whole, so no material that keeps its own colour (the route's flow),
+   * ground classification or pick can still show it.
+   */
   function sync() {
-    // No-op: CallbackProperty drives per-frame alpha/pulse animation.
+    for (const anno of drawn) {
+      const show = !anno.hidden;
+      for (const entity of anno._entities || [])
+        if (entity.show !== show) entity.show = show;
+    }
   }
 
   function destroy() {
     for (const anno of osmAnnotations) hideOsmCredit(viewer, anno);
     osmAnnotations.clear();
+    drawn.clear();
     try {
       viewer.dataSources.remove(dataSource, true);
     } catch {
@@ -407,8 +422,11 @@ export function ensureFlowFabricRegistered() {
  * returned a standalone Material Cesium never rendered, or treated `result` as a
  * Material — both left the real uniforms untouched, so nothing animated.)
  */
-export function FlowMaterialProperty(colorCss) {
+export function FlowMaterialProperty(colorCss, alphaOf = () => 1) {
   this._color = Cesium.Color.fromCssColorString(colorCss).withAlpha(0.95);
+  // The mark's live alpha (fade in and out, hidden), applied every frame.
+  this._alphaOf = alphaOf;
+  this._live = this._color.clone();
   this._definitionChanged = new Cesium.Event();
 }
 Object.defineProperties(FlowMaterialProperty.prototype, {
@@ -431,7 +449,8 @@ FlowMaterialProperty.prototype.getValue = function getValue(time, result) {
   // `time` is read straight from the wall clock so the dashes flow every rendered
   // frame (the scene renders continuously; no requestRenderMode here).
   if (!Cesium.defined(result)) result = {};
-  result.color = this._color;
+  this._live.alpha = this._color.alpha * this._alphaOf();
+  result.color = this._live;
   result.time = performance.now() / 1000; // the per-frame animated value
   result.repeat = 64.0;
   result.duty = 0.46;
diff --git a/src/annotations/worldAnnotationRenderer.test.mjs b/src/annotations/worldAnnotationRenderer.test.mjs
new file mode 100644
index 000000000..a05c52373
--- /dev/null
+++ b/src/annotations/worldAnnotationRenderer.test.mjs
@@ -0,0 +1,70 @@
+// A mark hidden from Draw's list leaves the globe whole: every entity it put
+// there is taken out on sync and comes back when shown, and the line's
+// flowing stroke, which keeps its own colour, follows the mark's alpha.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as C from 'cesium';
+import {
+  FlowMaterialProperty,
+  createWorldAnnotationRenderer,
+} from './worldAnnotationRenderer.js';
+
+const noop = () => {};
+function viewer(t) {
+  for (const name of ['HTMLCanvasElement', 'HTMLImageElement', 'ImageBitmap', 'OffscreenCanvas']) {
+    const original = globalThis[name];
+    globalThis[name] = class {};
+    t.after(() => { if (original === undefined) delete globalThis[name]; else globalThis[name] = original; });
+  }
+  const before = globalThis.document;
+  globalThis.document = { addEventListener: noop, removeEventListener: noop };
+  t.after(() => { if (before === undefined) delete globalThis.document; else globalThis.document = before; });
+  return {
+    creditDisplay: { addStaticCredit: noop, removeStaticCredit: noop },
+    entities: new C.EntityCollection(),
+    dataSources: new C.DataSourceCollection(),
+    camera: { moveEnd: new C.Event(), positionCartographic: { height: 1000 } },
+    scene: { requestRender: noop, canvas: { addEventListener: noop, removeEventListener: noop }, preRender: new C.Event(),
+      primitives: { add: (p) => p, remove: noop }, screenSpaceCameraController: { enableInputs: true } },
+  };
+}
+
+const marks = () => [
+  { id: 'route', type: 'route', color: 'amber', alpha: 1, anchor: { lat: 0, lon: 0 }, path: [{ lat: 0, lon: 0 }, { lat: 0.01, lon: 0.01 }] },
+  { id: 'area', type: 'area', color: 'green', alpha: 1, anchor: { lat: 0.005, lon: 0.005 }, ring: [[0, 0], [0.01, 0], [0.01, 0.01], [0, 0]] },
+  { id: 'pin', type: 'pin', color: 'primary', alpha: 1, anchor: { lat: 0.02, lon: 0.02 } },
+];
+
+test('a hidden mark has every entity taken off on sync, and back when shown', (t) => {
+  const renderer = createWorldAnnotationRenderer(viewer(t));
+  const [route, area, pin] = marks();
+  for (const anno of [route, area, pin]) renderer.add(anno);
+  const shown = (anno) => anno._entities.map((entity) => entity.show);
+  for (const anno of [route, area, pin]) assert.ok(anno._entities.length > 0, anno.id);
+
+  route.hidden = true;
+  area.hidden = true;
+  renderer.sync();
+  assert.ok(shown(route).every((show) => show === false), 'the line is off');
+  assert.ok(shown(area).every((show) => show === false), 'the area is off');
+  assert.ok(shown(pin).every((show) => show === true), 'a visible mark stays');
+
+  route.hidden = false;
+  renderer.sync();
+  assert.ok(shown(route).every((show) => show === true), 'the line is back');
+  renderer.remove(area);
+  renderer.sync();
+  assert.equal(area._entities, null, 'a removed mark is no longer synced');
+  renderer.destroy();
+});
+
+test('the line\'s flowing stroke follows its mark\'s alpha', () => {
+  let alpha = 1;
+  const material = new FlowMaterialProperty('#ffb547', () => alpha);
+  assert.ok(Math.abs(material.getValue(null, {}).color.alpha - 0.95) < 1e-9);
+  alpha = 0;
+  assert.equal(material.getValue(null, {}).color.alpha, 0, 'hidden: nothing painted');
+  alpha = 0.5;
+  assert.ok(Math.abs(material.getValue(null, {}).color.alpha - 0.475) < 1e-9, 'fading');
+  assert.equal(new FlowMaterialProperty('#fff').getValue(null, {}).color.alpha, 0.95, 'no alpha source: opaque as before');
+});
diff --git a/src/cameraVerbs.js b/src/cameraVerbs.js
index 231d9357d..e037472cb 100644
--- a/src/cameraVerbs.js
+++ b/src/cameraVerbs.js
@@ -1746,8 +1746,13 @@ export function flyRoute(
   const speed = ROUTE_M_S[String(args.speed || 'normal').toLowerCase()]
     ? String(args.speed || 'normal').toLowerCase()
     : 'normal';
+  // A route hidden from Draw's list is not on screen, so it is not flown.
   const routes = (annoList || []).filter(
-    (a) => a.type === 'route' && Array.isArray(a.path) && a.path.length >= 2,
+    (a) =>
+      a.type === 'route' &&
+      !a.hidden &&
+      Array.isArray(a.path) &&
+      a.path.length >= 2,
   );
   if (!routes.length) {
     return {
diff --git a/src/routeCinematics.test.mjs b/src/routeCinematics.test.mjs
index fa3e9d823..622c8ab63 100644
--- a/src/routeCinematics.test.mjs
+++ b/src/routeCinematics.test.mjs
@@ -1078,3 +1078,20 @@ test('a new viewer lifetime drops the previous view-target getter', () => {
   interruptCameraMotion('test-cleanup');
   second.restore();
 });
+
+test('a route hidden from Draw is not flown; the newest visible one is', () => {
+  const viewer = createTickableViewer();
+  initCameraVerbs(viewer.viewer, () => null);
+  const route = (label, hidden) => ({
+    type: 'route',
+    label,
+    hidden,
+    path: TWO_TURN_ROUTE.map(([lon, lat]) => ({ lon, lat, height: 0 })),
+  });
+  const onlyHidden = flyRoute([route('hidden walk', true)]);
+  assert.equal(onlyHidden.ok, false, 'a board of hidden routes has none to fly');
+  const started = flyRoute([route('shown walk', false), route('hidden walk', true)]);
+  assert.equal(started.ok, true);
+  assert.match(JSON.stringify(started), /shown walk/, 'the visible route is flown');
+  interruptCameraMotion?.('test');
+});

From 46b23ccc06b3d67d44df362ff32b16f7cdf585ab Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Mon, 2 Nov 2026 16:43:49 +0000
Subject: [PATCH 67/70] Let voice open the Utilities panel

Draw and Import used to be reachable by voice through DISPLAY. set_panel_open
now takes 'utilities-panel', and "utilities", "draw", "drawing" and "import"
reach it. This adds one value to the Realtime tool schema, so the pinned
payload digest, enum list and serialized length are re-derived with a note.

The show_data_layers_menu test now finds a row only inside the list that
really holds it, so dropping #utilities-toggles from the lookup fails it.
---
 src/firstRunExperience.test.mjs  |  5 +++--
 src/radioMarkup.test.mjs         |  2 +-
 src/voice/actionSchemas.js       |  1 +
 src/voice/actionSchemas.test.mjs |  4 +++-
 src/voice/gevActions.js          |  7 +++++++
 src/voice/gevActions.test.mjs    | 33 +++++++++++++++++++++++++++++++-
 6 files changed, 47 insertions(+), 5 deletions(-)

diff --git a/src/firstRunExperience.test.mjs b/src/firstRunExperience.test.mjs
index 81c1cfda5..87229e5c5 100644
--- a/src/firstRunExperience.test.mjs
+++ b/src/firstRunExperience.test.mjs
@@ -1030,10 +1030,11 @@ test('the voice TOOL SCHEMA matches the pinned contract — the mission mapping
   // preserves the mission mapping and globe-rotation arguments.
   // S2 GhostMaps extends the generated layer enums; both feature contracts remain.
   // The layer alias hint leaves out aliases the layer id already spells.
-  assert.equal(block.length, 30901, 'serialized tool schema length drifted');
+  // The Utilities panel adds one set_panel_open target.
+  assert.equal(block.length, 30919, 'serialized tool schema length drifted');
   assert.equal(
     crypto.createHash('sha256').update(block).digest('hex'),
-    '9e1bd8fde648953c47718ba248758415a95c1484b0da6369df6b89b0505c0de2',
+    'dbf9a45649179e626b2e3d938c43903f573c50ffa279b3245b18244dbe9a9284',
     'the first-run missions must ride EXISTING tools: no schema edit, no cache bust',
   );
   const instructions = fs.readFileSync(
diff --git a/src/radioMarkup.test.mjs b/src/radioMarkup.test.mjs
index 40acc6619..74a44e77d 100644
--- a/src/radioMarkup.test.mjs
+++ b/src/radioMarkup.test.mjs
@@ -152,7 +152,7 @@ test('the edited existing tools changed exactly as intended', () => {
   const panel = byName.get('set_panel_open');
   assert.deepEqual(
     panel.parameters.properties.panelId.enum,
-    ['data-panel', 'location-bar', 'control-panel', 'cctv-panel', 'radio-panel', 'scene-panel', 'pp-toggles', 'global-context-panel', 'weather-panel', 'recent-imagery-panel', 'voice-settings', 'voice-preview', 'provider-settings'],
+    ['data-panel', 'location-bar', 'control-panel', 'cctv-panel', 'radio-panel', 'scene-panel', 'utilities-panel', 'pp-toggles', 'global-context-panel', 'weather-panel', 'recent-imagery-panel', 'voice-settings', 'voice-preview', 'provider-settings'],
   );
   assert.deepEqual(panel.parameters.required, ['panelId', 'open']);
 
diff --git a/src/voice/actionSchemas.js b/src/voice/actionSchemas.js
index a27907666..9ec47028c 100644
--- a/src/voice/actionSchemas.js
+++ b/src/voice/actionSchemas.js
@@ -174,6 +174,7 @@ const schemas = [
             'cctv-panel',
             'radio-panel',
             'scene-panel',
+            'utilities-panel',
             'pp-toggles',
             'global-context-panel',
             'weather-panel',
diff --git a/src/voice/actionSchemas.test.mjs b/src/voice/actionSchemas.test.mjs
index 6f16f7606..d15a7c25e 100644
--- a/src/voice/actionSchemas.test.mjs
+++ b/src/voice/actionSchemas.test.mjs
@@ -43,12 +43,13 @@ test('the complete Realtime tool payload pins the manifest-generated layer relea
     // Globe rotation adds one motion; visual keyhole fit and explicit
     // reset guidance/defaults update only move_camera and mode descriptions.
     // S2 GhostMaps extends the generated layer enums.
+    // The Utilities panel (Directions, Draw, Import) adds one panel target.
     // Panel adds named voice targets and timeout; shared Panel/Cockpit guidance
     // is consolidated without changing either feature's arguments.
     // Snow leaves the set_visual_style enum.
     // The Operator HUD layout leaves set_hud's layout enum.
     // The layer alias hint leaves out aliases the layer id already spells.
-    'e65812db60a2702cebb496fca257cb04a28f1bbbf250cb9ab65a3db33005e0c8',
+    'dc2bac1be93a503dc88d637beea2f1bc457e1f9167422bd91548b44756a8aca5',
   );
 });
 
@@ -142,6 +143,7 @@ test('all legacy action arguments are byte-identical after removing the delibera
         'voice-settings',
         'voice-preview',
         'provider-settings',
+        'utilities-panel',
       ].includes(id),
   );
   for (const tool of legacy) {
diff --git a/src/voice/gevActions.js b/src/voice/gevActions.js
index 0ec5a0586..fbb6cc5ce 100644
--- a/src/voice/gevActions.js
+++ b/src/voice/gevActions.js
@@ -99,6 +99,12 @@ const PANEL_ALIASES = new Map([
   ['global context', 'global-context-panel'],
   ['right context', 'global-context-panel'],
   ['context right panel', 'global-context-panel'],
+  ['utilities', 'utilities-panel'],
+  ['utilities panel', 'utilities-panel'],
+  ['draw', 'utilities-panel'],
+  ['drawing', 'utilities-panel'],
+  ['import', 'utilities-panel'],
+  ['import files', 'utilities-panel'],
   ['authoring', 'scene-panel'],
   ['scenes', 'scene-panel'],
   ['scene', 'scene-panel'],
@@ -122,6 +128,7 @@ const PANEL_IDS = new Set([
   'cctv-panel',
   'radio-panel',
   'global-context-panel',
+  'utilities-panel',
   'scene-panel',
   'pp-toggles',
   'weather-panel',
diff --git a/src/voice/gevActions.test.mjs b/src/voice/gevActions.test.mjs
index 17fd43305..f6bccdfa9 100644
--- a/src/voice/gevActions.test.mjs
+++ b/src/voice/gevActions.test.mjs
@@ -754,9 +754,17 @@ test('showing a layer opens the panel that holds its row: Directions lives in Ut
     closest: (selector) => (selector === '[data-panel-id]' ? { id: panelId } : null),
   });
   const rows = { directions: rowIn('utilities-panel'), flights: rowIn('data-panel') };
+  // Each row is found only inside the list that really holds it.
+  const lists = { directions: '#utilities-toggles', flights: '#data-toggles' };
   globalThis.CSS = { escape: (value) => value };
   globalThis.document = {
-    querySelector: (selector) => rows[/data-layer-id="([^"]+)"/.exec(selector)?.[1]] || null,
+    querySelector: (selector) => {
+      for (const part of selector.split(',')) {
+        const [, list, id] = /^\s*(#[\w-]+) \[data-layer-id="([^"]+)"\]\s*$/.exec(part) || [];
+        if (id && lists[id] === list) return rows[id];
+      }
+      return null;
+    },
   };
   try {
     const opened = [];
@@ -4001,3 +4009,26 @@ test('set_panel_open accepts the Authoring name for the scene panel', async () =
   }
   assert.deepEqual(calls.at(-1), ['scene-panel', false, { explicit: true }]);
 });
+
+test('set_panel_open reaches the Utilities panel by its name, Draw or Import', async () => {
+  const calls = [];
+  const runner = createGevActionRunner({
+    viewer: {
+      clock: { onTick: { addEventListener: () => () => {} } },
+      scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
+      camera: {
+        moveEnd: { addEventListener() {} },
+        positionWC: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 1000),
+      },
+    },
+    styleManager: {
+      setPanelCollapsed: (...args) => calls.push(args),
+    },
+    dataManager: { layers: new Map(), isEnabled: () => false, getAll: () => [] },
+  });
+  for (const panel of ['utilities-panel', 'utilities', 'drawing', 'import']) {
+    const result = await runner('set_panel_open', { panelId: panel, open: true });
+    assert.equal(result.panelId, 'utilities-panel', panel);
+  }
+  assert.deepEqual(calls.at(-1), ['utilities-panel', false, { explicit: true }]);
+});

From e35483d37d63ee92b9a6e14d23b731529c29d28e Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Mon, 2 Nov 2026 16:43:49 +0000
Subject: [PATCH 68/70] Give Utilities the room Data Layers gets in Cockpit

Utilities stays in Cockpit for Directions, but only Data Layers folded the
Cockpit context rail away when opened, set its top below the open panel and
took Cyber's Cockpit size. Utilities now does all three, and Contact
expanding closes it as it closes Data Layers.
---
 src/cockpitMarkup.test.mjs | 11 ++++++++---
 src/ui/cockpitLayout.js    |  3 ++-
 src/ui/cyberTheme.test.mjs |  2 +-
 src/ui/panelChrome.js      |  9 +++++++--
 src/ui/radioBindings.js    |  2 ++
 src/ui/styles/cyber.css    |  9 ++++++---
 6 files changed, 26 insertions(+), 10 deletions(-)

diff --git a/src/cockpitMarkup.test.mjs b/src/cockpitMarkup.test.mjs
index 034cf3d00..70641642c 100644
--- a/src/cockpitMarkup.test.mjs
+++ b/src/cockpitMarkup.test.mjs
@@ -633,17 +633,22 @@ test('Cockpit side surfaces behave as two single-expanded accordions', () => {
   );
   assert.match(
     radioBindings,
-    /'gev:cockpit-context-expanded'[\s\S]*?setPanelCollapsed\('data-panel', true\);/,
+    /'gev:cockpit-context-expanded'[\s\S]*?setPanelCollapsed\('data-panel', true\);\s*this\.actions\.setPanelCollapsed\('utilities-panel', true\);/,
   );
   assert.match(
     ui,
-    /!nextCollapsed\s*&&\s*this\.cockpitView\?\.active\s*&&\s*panelId === 'data-panel'[\s\S]*?_cockpitContextCollapsedForDataPanel =\s*!this\.cockpitView\.contextCollapsed[\s\S]*?this\.cockpitView\.setContextCollapsed\(true\);/,
+    /!nextCollapsed\s*&&\s*this\.cockpitView\?\.active\s*&&\s*COCKPIT_LEFT_PANEL_IDS\.has\(panelId\)[\s\S]*?_cockpitContextCollapsedForDataPanel =\s*!this\.cockpitView\.contextCollapsed[\s\S]*?this\.cockpitView\.setContextCollapsed\(true\);/,
   );
   assert.match(
     ui,
-    /nextCollapsed\s*&&\s*this\.cockpitView\?\.active\s*&&\s*panelId === 'data-panel'[\s\S]*?_cockpitContextCollapsedForDataPanel[\s\S]*?this\.cockpitView\.setContextCollapsed\(false\);/,
+    /nextCollapsed\s*&&\s*this\.cockpitView\?\.active\s*&&\s*COCKPIT_LEFT_PANEL_IDS\.has\(panelId\)[\s\S]*?_cockpitContextCollapsedForDataPanel[\s\S]*?this\.cockpitView\.setContextCollapsed\(false\);/,
     'closing Data Layers must restore Contact only after an automatic collapse',
   );
+  assert.match(
+    ui,
+    /const COCKPIT_LEFT_PANEL_IDS = new Set\(\['data-panel', 'utilities-panel'\]\);/,
+    'Utilities folds Contact away in Cockpit as Data Layers does',
+  );
   assert.match(
     setContextCollapsed.toString(),
     /const wasCollapsed = this\.contextCollapsed;[\s\S]*?this\.active && wasCollapsed && !this\.contextCollapsed[\s\S]*?'gev:cockpit-context-expanded'/,
diff --git a/src/ui/cockpitLayout.js b/src/ui/cockpitLayout.js
index c0a00299d..2c5300b8a 100644
--- a/src/ui/cockpitLayout.js
+++ b/src/ui/cockpitLayout.js
@@ -84,8 +84,9 @@ export function syncContextLayout() {
     return;
   }
   const defaultTop = Math.max(255, Math.min(300, window.innerHeight * 0.28));
+  // An open left panel Cockpit keeps (Data Layers or Utilities).
   const dataPanel = document.querySelector(
-    '#left-panel-stack > #data-panel:not(.collapsed)',
+    '#left-panel-stack > :is(#data-panel, #utilities-panel):not(.collapsed)',
   );
   let desiredTop = defaultTop;
   if (this.contextCollapsed && dataPanel) {
diff --git a/src/ui/cyberTheme.test.mjs b/src/ui/cyberTheme.test.mjs
index eabd3df38..75746b6e3 100644
--- a/src/ui/cyberTheme.test.mjs
+++ b/src/ui/cyberTheme.test.mjs
@@ -854,7 +854,7 @@ test('Cyber Cockpit keeps Data Layers inside its bounded rail', () => {
   );
   assert.match(
     cyberStyles,
-    /body\.cockpit-mode #left-panel-stack > #data-panel \{[\s\S]*?max-height: min\(64vh, 610px\);/,
+    /body\.cockpit-mode\s+#left-panel-stack\s+> :is\(#data-panel, #utilities-panel\) \{[\s\S]*?max-height: min\(64vh, 610px\);/,
   );
 });
 
diff --git a/src/ui/panelChrome.js b/src/ui/panelChrome.js
index f2adef3bf..e83083865 100644
--- a/src/ui/panelChrome.js
+++ b/src/ui/panelChrome.js
@@ -25,6 +25,11 @@ const SHARE_PANEL_STATE_SPECS = Object.freeze([
   { id: 'pp-toggles' },
   { id: 'param-slider-panel' },
 ]);
+/**
+ * The left panels Cockpit keeps (Data Layers, and Utilities for Directions):
+ * opening one there folds the Cockpit context rail away until it closes.
+ */
+const COCKPIT_LEFT_PANEL_IDS = new Set(['data-panel', 'utilities-panel']);
 /** The command dock trays with a pin button. */
 const PINNABLE_PANEL_IDS = new Set(
   SHARE_PANEL_STATE_SPECS.filter((spec) => spec.pinnable).map(
@@ -497,7 +502,7 @@ export class PanelChrome {
     if (
       !nextCollapsed &&
       this.cockpitView?.active &&
-      panelId === 'data-panel'
+      COCKPIT_LEFT_PANEL_IDS.has(panelId)
     ) {
       this._cockpitContextCollapsedForDataPanel =
         !this.cockpitView.contextCollapsed;
@@ -528,7 +533,7 @@ export class PanelChrome {
     if (
       nextCollapsed &&
       this.cockpitView?.active &&
-      panelId === 'data-panel' &&
+      COCKPIT_LEFT_PANEL_IDS.has(panelId) &&
       this._cockpitContextCollapsedForDataPanel
     ) {
       this._cockpitContextCollapsedForDataPanel = false;
diff --git a/src/ui/radioBindings.js b/src/ui/radioBindings.js
index 05a211537..ac3c7c151 100644
--- a/src/ui/radioBindings.js
+++ b/src/ui/radioBindings.js
@@ -380,7 +380,9 @@ export function bindRadioControls() {
     window,
     'gev:cockpit-context-expanded',
     () => {
+      // Contact takes the room the open left panel had.
       this.actions.setPanelCollapsed('data-panel', true);
+      this.actions.setPanelCollapsed('utilities-panel', true);
     },
     tunerListenerOptions,
   );
diff --git a/src/ui/styles/cyber.css b/src/ui/styles/cyber.css
index dbaf12146..4957cd769 100644
--- a/src/ui/styles/cyber.css
+++ b/src/ui/styles/cyber.css
@@ -2771,7 +2771,10 @@
   border-inline-start: 0;
 }
 
-:root[data-ui-theme='cyber'] body.cockpit-mode #left-panel-stack > #data-panel {
+:root[data-ui-theme='cyber']
+  body.cockpit-mode
+  #left-panel-stack
+  > :is(#data-panel, #utilities-panel) {
   --panel-expanded-width: var(--cyber-panel-width);
   width: var(--cyber-panel-width);
   max-height: min(64vh, 610px);
@@ -2780,7 +2783,7 @@
 :root[data-ui-theme='cyber']
   body.cockpit-mode
   #left-panel-stack
-  > #data-panel.collapsed {
+  > :is(#data-panel, #utilities-panel).collapsed {
   width: var(--cyber-panel-collapsed-width);
 }
 
@@ -2813,7 +2816,7 @@
   :root[data-ui-theme='cyber']
     body.cockpit-mode
     #left-panel-stack
-    > #data-panel:not(.collapsed) {
+    > :is(#data-panel, #utilities-panel):not(.collapsed) {
     flex: 0 0 var(--cyber-cockpit-panel-height, 40vh);
     height: var(--cyber-cockpit-panel-height, 40vh);
     max-height: var(--cyber-cockpit-panel-height, 40vh);

From 345d5db593cad6966c91ab14e776d2b51d6864b0 Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Mon, 2 Nov 2026 16:43:49 +0000
Subject: [PATCH 69/70] Point the Draw and layer panel gates at Utilities and
 at what is drawn

qa-draw-tool drives the rows, waits on a mark's state instead of fixed
sleeps, checks that fly-to centres the line, and compares two screenshots to
show a hidden Line's pixels go and come back. Its clicks and pixel clip stay
clear of the Utilities panel beside the left rail. qa-layer-panel checks
that Directions returns to the Utilities list after a reassembly.
---
 scripts/qa-draw-tool.mjs   | 141 +++++++++++++++++++++++++++++++++----
 scripts/qa-layer-panel.mjs |   8 +++
 2 files changed, 134 insertions(+), 15 deletions(-)

diff --git a/scripts/qa-draw-tool.mjs b/scripts/qa-draw-tool.mjs
index 7e22dc072..fb2febbf4 100644
--- a/scripts/qa-draw-tool.mjs
+++ b/scripts/qa-draw-tool.mjs
@@ -66,6 +66,47 @@ const CANVAS_CLIP = { x: 340, y: 200, width: 560, height: 380 };
  * the board. Decoding happens in the page because Node here has no image
  * decoder.
  */
+/** The canvas clip as a PNG, for comparing two moments of the same view. */
+// Clear of the open UTILITIES panel (x 100–380), whose own amber swatch
+// dims when its row's shape is hidden.
+const LINE_CLIP = { x: 390, y: 200, width: 510, height: 380 };
+const canvasShot = () =>
+  page.screenshot({ clip: LINE_CLIP, type: 'png', encoding: 'base64' });
+
+/**
+ * Amber pixels in one shot that are not amber in another of the same view:
+ * a mark's own pixels, apart from imagery and panels that both shots share.
+ */
+function amberOnlyIn(shotA, shotB) {
+  return page.evaluate(
+    async (a, b) => {
+      const pixels = async (base64) => {
+        const bitmap = await createImageBitmap(
+          await (await fetch(`data:image/png;base64,${base64}`)).blob(),
+        );
+        const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+        const context = canvas.getContext('2d');
+        context.drawImage(bitmap, 0, 0);
+        return context.getImageData(0, 0, bitmap.width, bitmap.height).data;
+      };
+      const amber = (d, i) =>
+        d[i] > 150 &&
+        d[i + 1] > 90 &&
+        d[i + 1] < 220 &&
+        d[i + 2] < 130 &&
+        d[i] - d[i + 2] > 70 &&
+        d[i] - d[i + 1] > 20;
+      const [da, db] = [await pixels(a), await pixels(b)];
+      let only = 0;
+      for (let i = 0; i < da.length; i += 4)
+        if (amber(da, i) && !amber(db, i)) only += 1;
+      return only;
+    },
+    shotA,
+    shotB,
+  );
+}
+
 async function amberPixels() {
   const shot64 = await page.screenshot({
     clip: CANVAS_CLIP,
@@ -313,7 +354,8 @@ try {
 
   // ── a line along a road, with Backspace ─────────────────────────────────
   await page.click('.pp-mode-btn[data-shape="line"]');
-  await clickWorld(360, 300);
+  // Clear of the open UTILITIES panel, which sits beside the left rail.
+  await clickWorld(420, 300);
   await clickWorld(470, 380);
   await clickWorld(600, 470);
   const beforeBackspace = (await drawState()).vertices;
@@ -409,15 +451,34 @@ try {
         mark && { color: mark.color, hidden: mark.hidden, alpha: mark.alpha }
       );
     }, id);
+  // Wait for a mark to reach a state rather than for a fixed time.
+  const markReaches = (id, want) =>
+    page
+      .waitForFunction(
+        (id, want) => {
+          const mark = window.__gevAnnotations.list().find((m) => m.id === id);
+          return (
+            mark &&
+            Object.entries(want).every(([key, value]) => mark[key] === value)
+          );
+        },
+        { timeout: 10_000 },
+        id,
+        want,
+      )
+      .then(
+        () => true,
+        () => false,
+      );
   await page.click(rowControl(areaId, 'swatch'));
   await page.click(rowControl(areaId, 'color-green'));
-  await wait(300);
+  await markReaches(areaId, { color: 'green' });
   check(
     'a colour picked in the row recolours that shape',
     (await markState(areaId))?.color === 'green',
   );
   await page.click(rowControl(areaId, 'toggle'));
-  await wait(600);
+  await markReaches(areaId, { hidden: true, alpha: 0 });
   const hidden = await markState(areaId);
   check(
     'hiding a shape keeps it on the board but draws it at zero alpha',
@@ -425,23 +486,73 @@ try {
     JSON.stringify(hidden),
   );
   await page.click(rowControl(areaId, 'toggle'));
-  await wait(600);
   check(
     'showing it again brings it straight back',
-    (await markState(areaId))?.alpha === 1,
+    await markReaches(areaId, { hidden: false, alpha: 1 }),
   );
-  const cameraAt = () =>
-    page.evaluate(() => {
-      const p = window.__godsEyeView.viewer.camera.positionWC;
-      return [p.x, p.y, p.z];
-    });
-  const beforeFly = await cameraAt();
+  // Fly-to frames the line by its whole path: once the flight settles, the
+  // middle of the line sits near the middle of the view.
   await page.click(rowControl(ids[1], 'fly'));
-  await wait(2600);
-  const afterFly = await cameraAt();
+  await page
+    .waitForFunction(() => !window.__godsEyeView.viewer.camera._currentFlight, {
+      timeout: 15_000,
+    })
+    .catch(() => {});
+  await wait(300);
+  const framed = await page.evaluate((id) => {
+    const { viewer } = window.__godsEyeView;
+    // No Cesium global in the page: borrow Cartesian3 from a live object.
+    const Cartesian3 = viewer.camera.positionWC.constructor;
+    const mark = window.__gevAnnotations.list().find((m) => m.id === id);
+    const lons = mark.path.map((p) => p.lon);
+    const lats = mark.path.map((p) => p.lat);
+    const middle = Cartesian3.fromDegrees(
+      (Math.min(...lons) + Math.max(...lons)) / 2,
+      (Math.min(...lats) + Math.max(...lats)) / 2,
+    );
+    const at = viewer.scene.cartesianToCanvasCoordinates(middle);
+    const canvas = viewer.scene.canvas;
+    return (
+      at && {
+        dx: Math.abs(at.x - canvas.clientWidth / 2) / canvas.clientWidth,
+        dy: Math.abs(at.y - canvas.clientHeight / 2) / canvas.clientHeight,
+      }
+    );
+  }, ids[1]);
   check(
-    'fly to frames that shape',
-    Math.hypot(...afterFly.map((v, i) => v - beforeFly[i])) > 1,
+    'fly to frames that shape: its middle is near the middle of the view',
+    Boolean(framed) && framed.dx < 0.2 && framed.dy < 0.2,
+    JSON.stringify(framed),
+  );
+
+  // ── a hidden Line leaves the globe: its flowing stroke keeps its own
+  // colour, so the check is the pixels, not the mark's state ─────────────
+  const lineId = ids[1];
+  await page.click(rowControl(lineId, 'swatch'));
+  await page.click(rowControl(lineId, 'color-amber'));
+  await markReaches(lineId, { color: 'amber', alpha: 1 });
+  await wait(800);
+  const shown = await canvasShot();
+  await page.click(rowControl(lineId, 'toggle'));
+  await markReaches(lineId, { hidden: true, alpha: 0 });
+  await wait(800);
+  const hiddenShot = await canvasShot();
+  // Amber the shown line had and the hidden one lost; amber that appears
+  // only once it is hidden is noise, and must stay small beside it.
+  const gone = await amberOnlyIn(shown, hiddenShot);
+  const noise = await amberOnlyIn(hiddenShot, shown);
+  check(
+    'a hidden Line is no longer painted',
+    gone > 40 && noise < gone * 0.2,
+    `${gone} amber pixels went with the line, ${noise} appeared`,
+  );
+  await page.click(rowControl(lineId, 'toggle'));
+  await wait(1200);
+  const back = await amberOnlyIn(await canvasShot(), hiddenShot);
+  check(
+    'and paints again when shown',
+    back > gone * 0.5,
+    `${back} of ${gone} line pixels back`,
   );
   await shot('03-pins-and-shapes');
 
diff --git a/scripts/qa-layer-panel.mjs b/scripts/qa-layer-panel.mjs
index 5cfa08905..6f69f60bc 100644
--- a/scripts/qa-layer-panel.mjs
+++ b/scripts/qa-layer-panel.mjs
@@ -126,6 +126,14 @@ try {
       'ordinary layer rows return after reassembly',
       container.querySelectorAll('.data-toggle-row').length > 10,
     ]);
+    result.push([
+      'Directions returns to the Utilities list after reassembly',
+      Boolean(
+        document.querySelector(
+          '#utilities-toggles [data-layer-id="directions"]',
+        ) && !container.querySelector('[data-layer-id="directions"]'),
+      ),
+    ]);
     return result;
   });
   for (const [name, passed] of results) check(name, passed);

From 672a1452547938f81c25169c75fc2657e77f31d7 Mon Sep 17 00:00:00 2001
From: Said Turksever <asturksever@gmail.com>
Date: Mon, 2 Nov 2026 17:01:31 +0000
Subject: [PATCH 70/70] Keep Contact folded until both Cockpit left panels
 close, and keep focus in a renamed row

Opening Utilities while Data Layers is open no longer forgets that Contact
was folded for the first, and closing one of them leaves Contact folded
while the other is still open. Enter and Esc in a drawn shape's name keep
focus in the field instead of dropping it to the page. The draw tool's
destroy test now checks it stops following the board, and the Draw gate's
amber-count comment sits on its function again.
---
 docs/CURRENT-STATE.md                      |  2 +-
 scripts/qa-draw-tool.mjs                   | 18 +++++++--------
 src/annotations/drawToolBehaviour.test.mjs |  3 +++
 src/cockpitMarkup.test.mjs                 | 24 +++++++++++++++++++
 src/ui/panelChrome.js                      | 27 +++++++++++++++++++---
 src/ui/views/panels/DrawMarkList.test.mjs  |  4 ++++
 src/ui/views/panels/DrawMarkList.vue       |  5 ++--
 7 files changed, 68 insertions(+), 15 deletions(-)

diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md
index 5396b5bbf..974011ad6 100644
--- a/docs/CURRENT-STATE.md
+++ b/docs/CURRENT-STATE.md
@@ -5539,7 +5539,7 @@ request viewbox and continues searching without that geographic preference.
 ### Manual Whiteboard Drawing (September 2026)
 
 - UTILITIES ▸ **Draw** turns the globe into a whiteboard drawn by hand. Pick a shape (icon buttons for Area, Line and Pin) and a colour swatch for the next shape, click the vertices on the real world, and finish. **Keyboard contract, live only while Draw is on and never while you are typing in another field:** Enter finishes the shape (as does a double-click, and the two cannot both submit it — the session is replaced before the annotate call is awaited); Backspace removes the last vertex; Esc cancels the shape in progress, and a second Esc — Esc on an empty session — leaves draw mode. **Clear** wipes the board (the shape in progress and every placed mark), so removing marks does not require the console or the microphone.
-- **Drawn shapes are listed under Draw like Import's files** (`src/ui/views/panels/DrawMarkList.vue`, rows worded by `presentDrawMarks` in `src/annotations/drawMarks.js`): one row per hand-drawn mark (`manual: true`; voice marks are not listed) with its colour swatch, its name, and show/hide, fly-to and remove. The draw tool publishes the rows with the rest of its controls and answers the row actions (`renameDrawMark`, `recolorDrawMark`, `toggleDrawMark`, `flyToDrawMark`, `removeDrawMark`) through the display store; it republishes on the engine's `onChange`, so a voice clear or an expiry updates the list. Rows are keyed and updated in place: a board change never takes a name being typed (the field keeps its draft while focused) or the button under a click. The name is saved on Enter or on leaving the field, once; Esc restores it, before anything else and with the row's colours open too, and stays in the list. The swatch opens the five colours right after it (shown at the end of the row), with the current colour focused; the arrows, Home and End try another, and a click or Esc closes them and returns focus to the swatch. Both colour groups (the next shape's and a row's) are one `DrawSwatches` radio group with a single tab stop, coloured from `DRAW_COLOR_CSS`; on touch screens each dot answers a 24 px target. An unnamed shape shows its kind, and an unnamed line its length; a renamed line keeps its length (`Ridge walk — 950 m`). **Hidden** keeps a mark on the board at alpha 0, and the world renderer takes every one of its entities out (`show = false`), so no material that keeps its own colour (the line's flowing stroke) still paints it; the screen renderer does not project a hidden callout, so it cannot push a visible label aside; `fly_route` skips a hidden route; and with every mark hidden the annotations render hold is released. **Fly to** is an immediate navigation (`runImmediateNavigation('drawing', …)`), like Import's: Cockpit refuses it and a running orbit, follow or track lets go first. A line is framed by its whole path, across the antimeridian too.
+- **Drawn shapes are listed under Draw like Import's files** (`src/ui/views/panels/DrawMarkList.vue`, rows worded by `presentDrawMarks` in `src/annotations/drawMarks.js`): one row per hand-drawn mark (`manual: true`; voice marks are not listed) with its colour swatch, its name, and show/hide, fly-to and remove. The draw tool publishes the rows with the rest of its controls and answers the row actions (`renameDrawMark`, `recolorDrawMark`, `toggleDrawMark`, `flyToDrawMark`, `removeDrawMark`) through the display store; it republishes on the engine's `onChange`, so a voice clear or an expiry updates the list. Rows are keyed and updated in place: a board change never takes a name being typed (the field keeps its draft while focused) or the button under a click. The name is saved on Enter or on leaving the field, once; Esc restores it, before anything else and with the row's colours open too. Both keep focus in the field, so neither drops it to the page or leaves Draw. The swatch opens the five colours right after it (shown at the end of the row), with the current colour focused; the arrows, Home and End try another, and a click or Esc closes them and returns focus to the swatch. Both colour groups (the next shape's and a row's) are one `DrawSwatches` radio group with a single tab stop, coloured from `DRAW_COLOR_CSS`; on touch screens each dot answers a 24 px target. An unnamed shape shows its kind, and an unnamed line its length; a renamed line keeps its length (`Ridge walk — 950 m`). **Hidden** keeps a mark on the board at alpha 0, and the world renderer takes every one of its entities out (`show = false`), so no material that keeps its own colour (the line's flowing stroke) still paints it; the screen renderer does not project a hidden callout, so it cannot push a visible label aside; `fly_route` skips a hidden route; and with every mark hidden the annotations render hold is released. **Fly to** is an immediate navigation (`runImmediateNavigation('drawing', …)`), like Import's: Cockpit refuses it and a running orbit, follow or track lets go first. A line is framed by its whole path, across the antimeridian too.
 - Runtime entry: `createApplicationTools` (`src/app/tools.js`, behind the `src/standalone/tools.js` shim) calls `initDrawTool({ viewer, annotations, navigation, publish, connect })` after `initAnnotations` and defers its `destroy()`, so disposing the shell returns every DOM listener, the Cesium handler, the preview data source, the borrowed click actions and the `window.__gevDrawTool` handle. Its controls are Vue views in the UTILITIES panel (`DrawControls.vue`, `DrawMarkList.vue`) that render what the tool publishes to the display store and call its actions. That handle (`setActive`, `setShape`, `addVertex(lon, lat)`, `finish`, `cancel`, `clearAll`, `marks`, `setColor`, `diagnostics`) is the no-mouse test seam.
 - Contract: a finished shape is submitted through the SAME `annotationEngine.annotate()` the voice agent uses, with geometry supplied and `manual: true` (`type: area` + `ring`, `type: route` + `path`, `type: pin` + coordinates). `resolveSpec` short-circuits manual specs (`resolveManualSpec`) so no geocoder, Places or Overpass call is made. A drawn area is a real (not synthesized) outline and drapes solid; a drawn line is a `route` with `mode: 'manual'`, labelled with its length and never a travel time; a pin is a point. Drawn marks therefore render with the whiteboard look, persist, appear in `.list()`, and clear with `clear_annotations` / `.clear()`. A drawn shape is never merged with another as a duplicate: every one is drawn on purpose, and every one is unnamed until its row names it, so two pins dropped close together are two pins.
 - **A vertex is a lon/lat, and the mark is DRAPED.** Clicks are picked through `pickWorldFromScreen` — one of two scene helpers the annotation resolver factory (`src/annotations/resolver.js`) exposes alongside `sampleGroundHeight`, so the app has ONE depth-aware pick cascade rather than a second written beside it — which returns the height the pick landed on as well as the coordinate, so the live preview hangs on the roof or hillside under the pointer instead of sinking to sea level. The world renderer draws areas and routes with `clampToGround`, so the height is dropped at finish in one place (`finishSpec`) rather than being carried downstream and discarded silently: what you get is the outline you drew, lying on the surface beneath it.
diff --git a/scripts/qa-draw-tool.mjs b/scripts/qa-draw-tool.mjs
index fb2febbf4..5985730ec 100644
--- a/scripts/qa-draw-tool.mjs
+++ b/scripts/qa-draw-tool.mjs
@@ -58,18 +58,10 @@ const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /** A clip of the globe canvas, clear of the panels on every side. */
 const CANVAS_CLIP = { x: 340, y: 200, width: 560, height: 380 };
 
-/**
- * How many amber pixels the clip contains. The drawn area's stroke and fill are
- * the only amber in this scene, so the count going UP after a shape is finished
- * is the shape actually painting — which is what CESIUM_3D_TILE-only
- * classification failed to do on a keyless boot while still reporting a mark on
- * the board. Decoding happens in the page because Node here has no image
- * decoder.
- */
-/** The canvas clip as a PNG, for comparing two moments of the same view. */
 // Clear of the open UTILITIES panel (x 100–380), whose own amber swatch
 // dims when its row's shape is hidden.
 const LINE_CLIP = { x: 390, y: 200, width: 510, height: 380 };
+/** The canvas clip as a PNG, for comparing two moments of the same view. */
 const canvasShot = () =>
   page.screenshot({ clip: LINE_CLIP, type: 'png', encoding: 'base64' });
 
@@ -107,6 +99,14 @@ function amberOnlyIn(shotA, shotB) {
   );
 }
 
+/**
+ * How many amber pixels the clip contains. The drawn area's stroke and fill are
+ * the only amber in this scene, so the count going UP after a shape is finished
+ * is the shape actually painting — which is what CESIUM_3D_TILE-only
+ * classification failed to do on a keyless boot while still reporting a mark on
+ * the board. Decoding happens in the page because Node here has no image
+ * decoder.
+ */
 async function amberPixels() {
   const shot64 = await page.screenshot({
     clip: CANVAS_CLIP,
diff --git a/src/annotations/drawToolBehaviour.test.mjs b/src/annotations/drawToolBehaviour.test.mjs
index a8ab18b63..811142193 100644
--- a/src/annotations/drawToolBehaviour.test.mjs
+++ b/src/annotations/drawToolBehaviour.test.mjs
@@ -183,6 +183,7 @@ function fakeAnnotations() {
   return {
     calls,
     marks,
+    listeners,
     changed,
     async annotate(specs, options) {
       calls.annotate.push({ specs, options });
@@ -459,6 +460,7 @@ test('destroy releases the pointer, the handler, the listeners and the stock act
     h.tool.addVertex(-97.75, 30.26);
     assert.equal(pointerOwner(), 'draw');
     assert.ok(h.tool.diagnostics().domListeners > 0);
+    assert.equal(h.annotations.listeners.size, 1, 'the rows follow the board');
 
     await h.tool.destroy();
     await Promise.resolve();
@@ -476,6 +478,7 @@ test('destroy releases the pointer, the handler, the listeners and the stock act
       'the viewer got its selecting click back',
     );
     assert.equal(h.viewer._attached.length, 0, 'the preview data source is detached');
+    assert.equal(h.annotations.listeners.size, 0, 'and it no longer follows the board');
 
     // Idempotent: a second destroy is harmless.
     await h.tool.destroy();
diff --git a/src/cockpitMarkup.test.mjs b/src/cockpitMarkup.test.mjs
index 70641642c..64d03914b 100644
--- a/src/cockpitMarkup.test.mjs
+++ b/src/cockpitMarkup.test.mjs
@@ -1385,3 +1385,27 @@ test('cockpit state cannot report entryAllowed while already active', () => {
   assert.match(state, /'contacts-inactive'/);
   assert.match(state, /'no-tracked-aircraft'/);
 });
+
+test('Contact folded for one Cockpit left panel comes back only once neither is open', async () => {
+  assert.match(
+    ui,
+    /if \(!this\._cockpitContextCollapsedForDataPanel\)\s*this\._cockpitContextCollapsedForDataPanel =\s*!this\.cockpitView\.contextCollapsed;/,
+    'opening the second left panel keeps the fold the first recorded',
+  );
+  const { PanelChrome } = await import('./ui/panelChrome.js');
+  const previous = globalThis.document;
+  const panels = {};
+  globalThis.document = { getElementById: (id) => panels[id] ?? null };
+  const panel = (...classes) => ({ classList: { contains: (name) => classes.includes(name) } });
+  try {
+    const otherOpen = (id) => PanelChrome.prototype._otherCockpitLeftPanelOpen(id);
+    panels['data-panel'] = panel('collapsed');
+    assert.equal(otherOpen('utilities-panel'), false, 'Data Layers closed: restore');
+    panels['data-panel'] = panel('collapsed', 'layout-auto-collapsed');
+    assert.equal(otherOpen('utilities-panel'), true, 'Data Layers comes back: keep Contact folded');
+    panels['data-panel'] = panel();
+    assert.equal(otherOpen('utilities-panel'), true, 'Data Layers open: keep it folded');
+  } finally {
+    globalThis.document = previous;
+  }
+});
diff --git a/src/ui/panelChrome.js b/src/ui/panelChrome.js
index e83083865..439c1d77c 100644
--- a/src/ui/panelChrome.js
+++ b/src/ui/panelChrome.js
@@ -52,6 +52,23 @@ const COCKPIT_ENTRY_COLLAPSE_PANEL_IDS = Object.freeze([
 
 /** Own panel disclosure, docking, persistence and Cockpit rail restoration. */
 export class PanelChrome {
+  /**
+   * Whether another left panel Cockpit keeps is open, or only folded aside
+   * for this one and coming back when it closes.
+   * @param {string} panelId The panel closing.
+   */
+  _otherCockpitLeftPanelOpen(panelId) {
+    return [...COCKPIT_LEFT_PANEL_IDS].some((id) => {
+      if (id === panelId) return false;
+      const panel = document.getElementById(id);
+      return (
+        !!panel &&
+        (!panel.classList.contains('collapsed') ||
+          panel.classList.contains('layout-auto-collapsed'))
+      );
+    });
+  }
+
   constructor({
     elements,
     operations,
@@ -504,8 +521,11 @@ export class PanelChrome {
       this.cockpitView?.active &&
       COCKPIT_LEFT_PANEL_IDS.has(panelId)
     ) {
-      this._cockpitContextCollapsedForDataPanel =
-        !this.cockpitView.contextCollapsed;
+      // Record the fold once: opening the other left panel after the first
+      // must not forget that Contact was folded for them.
+      if (!this._cockpitContextCollapsedForDataPanel)
+        this._cockpitContextCollapsedForDataPanel =
+          !this.cockpitView.contextCollapsed;
       if (this._cockpitContextCollapsedForDataPanel) {
         this.cockpitView.setContextCollapsed(true);
       }
@@ -534,7 +554,8 @@ export class PanelChrome {
       nextCollapsed &&
       this.cockpitView?.active &&
       COCKPIT_LEFT_PANEL_IDS.has(panelId) &&
-      this._cockpitContextCollapsedForDataPanel
+      this._cockpitContextCollapsedForDataPanel &&
+      !this._otherCockpitLeftPanelOpen(panelId)
     ) {
       this._cockpitContextCollapsedForDataPanel = false;
       this.cockpitView.setContextCollapsed(false);
diff --git a/src/ui/views/panels/DrawMarkList.test.mjs b/src/ui/views/panels/DrawMarkList.test.mjs
index bf174ec7a..64cc998a8 100644
--- a/src/ui/views/panels/DrawMarkList.test.mjs
+++ b/src/ui/views/panels/DrawMarkList.test.mjs
@@ -101,6 +101,9 @@ test('a name is saved on Enter or leaving the field; an unchanged one costs noth
   name.value = '  Ridge walk ';
   key(name, 'Enter');
   assert.deepEqual(calls, [['renameDrawMark', 'a1', 'Ridge walk']]);
+  assert.equal(document.activeElement, name, 'Enter keeps focus in the field');
+  name.blur();
+  assert.equal(calls.length, 1, 'the blur after Enter saves nothing more');
   const pinName = control('a2', 'name');
   pinName.focus();
   pinName.blur();
@@ -122,6 +125,7 @@ test('Escape drops the draft and stays in the list, even with the row\'s colours
   const event = key(name, 'Escape');
   assert.equal(event.defaultPrevented, true);
   assert.equal(name.value, 'Camp', 'the saved name comes back');
+  assert.equal(document.activeElement, name, 'focus stays in the field');
   await nextTick();
   assert.deepEqual(calls, [], 'the draft is not saved');
   // Escape in the open colours closes them and gives focus to the swatch.
diff --git a/src/ui/views/panels/DrawMarkList.vue b/src/ui/views/panels/DrawMarkList.vue
index 52e15b07b..19811c761 100644
--- a/src/ui/views/panels/DrawMarkList.vue
+++ b/src/ui/views/panels/DrawMarkList.vue
@@ -42,15 +42,16 @@ function onNameKey(row, event) {
   const input = event.currentTarget;
   if (event.key === 'Enter') {
     event.preventDefault();
+    // Saved, and focus stays here: blurring would drop it to the page.
     commit(row, input);
-    input.blur();
+    input.select();
   } else if (event.key === 'Escape') {
     // Escape drops the draft before anything else, an open colour picker
     // included, and stays in the list: it must not leave Draw.
     event.preventDefault();
     event.stopPropagation();
     input.value = rowOf(row.id)?.name ?? row.name;
-    input.blur();
+    input.select();
   }
 }