Merge main into prereq-10-osm-overlays and port Open Map Overlays

Main moved on since this PR opened; the overlay layer is ported to the
current contracts:

- Layer-state token 6 (j belongs to transit; new single-character
  tokens are digits) with a reservation-ledger row, and the option owner
  renamed to the layer id so the compact share codec can encode it.
- Constructed per catalog by createOsmOverlaysLayer() in
  constructCatalog.js; src/standalone/data.js no longer registers layers.
- Drapes through maps/imageryHost.js, so the overlays show on Google 3D
  (tileset imagery) as well as the globe stacks, and follow map-stack
  switches. Imagery layers are created on enable and destroyed on
  disable/destroy.
- Translated chip labels and layer name in every locale, LAYER_NAME_KEYS,
  Infrastructure panel group, voice manifest entry.
- Attribution: OpenSeaMap tiles CC BY-SA 2.0, OpenSnowMap credit as
  required, OSM ODbL credit for both; bulk-download note in DATA_SOURCES.
- CURRENT-STATE row, changelog fragment, share-codec absent defaults,
  updated token-ledger fixtures and voice schema pins.

src/app/constructCatalog.test.mjs

@@ -0,0 +1,234 @@
+import { createSurfaceServices } from './surfaceServices.js';
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createApplicationCatalog } from './constructCatalog.js';
+import { createStandaloneLayerSources } from '../standalone/layerSources.js';
+import { catalogControlServices } from './catalog.js';
+import { LayerLifecycle } from '../data/lifecycle.js';
+import { fakeStreetLevelProvider } from '../testSupport/streetLevelFakes.mjs';
+
+function fixtureSources(ids, calls) {
+  const sources = createStandaloneLayerSources();
+  sources.military = {
+    getSnapshot: async () => {
+      throw new Error('Use identity acquisition');
+    },
+    async getIdentities(_query, { signal }) {
+      calls.push(signal);
+      return ids;
+    },
+  };
+  return sources;
+}
+
+test('catalogs construct distinct layers and classification from their supplied source', async (t) => {
+  const a = new AbortController();
+  const b = new AbortController();
+  t.after(() => {
+    a.abort();
+    b.abort();
+  });
+  const callsA = [];
+  const callsB = [];
+  const first = createApplicationCatalog({
+    sources: fixtureSources(['abc123'], callsA),
+    signal: a.signal,
+    surface: fixtureSurface(a.signal),
+  });
+  const second = createApplicationCatalog({
+    sources: fixtureSources(['def456'], callsB),
+    signal: b.signal,
+    surface: fixtureSurface(b.signal),
+  });
+  assert.equal(first.layers.length, 34);
+  assert.ok(first.get('local-adsb'), 'Local ADS-B is registered');
+  assert.deepEqual(
+    first.metadata.find(({ id }) => id === 'local-adsb'),
+    { id: 'local-adsb', disposition: 'local-only' },
+    'the hardware-local layer is never serialized into links',
+  );
+  assert.notEqual(first.weatherClock, second.weatherClock);
+  await first.weatherClock.setTarget('2026-09-21T12:00:00.000Z');
+  assert.match(
+    first.get('wind').getRowControls().info,
+    /Forecast · does not follow history/,
+  );
+  assert.equal(second.get('wind').getRowControls().summary.status, null);
+  for (const id of ['weather-radar', 'weather-satellite', 'weather-lightning'])
+    assert.equal(
+      first.get(id).getDiagnostics().clock.target,
+      '2026-09-21T12:00:00.000Z',
+    );
+  assert.ok(first.get('fire-perimeters'));
+  assert.ok(first.get('gnss-integrity'));
+  assert.ok(first.get('s2-ghostmaps'));
+  assert.ok(first.get('transit'));
+  const order = first.layers.map(({ id }) => id);
+  assert.deepEqual(
+    order.slice(order.indexOf('traffic'), order.indexOf('directions') + 1),
+    ['traffic', 'cctv', 'radio', 'transit', 'bikeshare', 'directions'],
+  );
+  assert.ok(first.get('bhote-koshi-2026'));
+  assert.ok(first.get('bhote-koshi-locator'));
+  const lifecycle = new LayerLifecycle({});
+  for (const layer of first.layers) lifecycle.register(layer);
+  const rows = lifecycle.getAll();
+  for (const id of ['bhote-koshi-2026', 'bhote-koshi-locator']) {
+    assert.equal(
+      rows.find((row) => row.id === id)?.showInTogglePanel,
+      false,
+      `${id} remains registered for Scenes but is absent from Data Layers`,
+    );
+    assert.equal(typeof first.get(id).enable, 'function');
+    assert.equal(typeof first.get(id).setParams, 'function');
+  }
+  assert.equal(
+    rows.find((row) => row.id === 'flights')?.showInTogglePanel,
+    true,
+    'ordinary data layer entries remain visible',
+  );
+  assert.deepEqual(
+    first.layers.map(({ id }) => id),
+    second.layers.map(({ id }) => id),
+  );
+  for (const layer of first.layers)
+    assert.notEqual(layer, second.get(layer.id));
+  assert.equal(
+    catalogControlServices(first).satellitesLayer,
+    first.get('satellites'),
+  );
+  assert.equal(callsA.length, 0, 'construction must not acquire');
+  await first.militaryRegistry.refreshMilitaryRegistryIfStale();
+  await second.militaryRegistry.refreshMilitaryRegistryIfStale();
+  assert.equal(first.militaryRegistry.isMilitaryIcao('abc123'), true);
+  assert.equal(first.militaryRegistry.isMilitaryIcao('def456'), false);
+  assert.equal(second.militaryRegistry.isMilitaryIcao('def456'), true);
+  a.abort();
+  assert.equal(
+    await first.weatherClock.setTarget('2026-09-21T13:00:00.000Z'),
+    false,
+  );
+  assert.equal(callsA[0].aborted, true);
+  assert.equal(first.militaryRegistry.isMilitaryIcao('abc123'), false);
+  assert.equal(callsB[0].aborted, false);
+  assert.equal(second.militaryRegistry.isMilitaryIcao('def456'), true);
+});
+
+test('invalid or already cancelled construction fails before classification can acquire', () => {
+  const lifetime = new AbortController();
+  assert.throws(
+    () =>
+      createApplicationCatalog({
+        sources: { flights: {} },
+        signal: lifetime.signal,
+        surface: fixtureSurface(lifetime.signal),
+      }),
+    /catalog source/,
+  );
+  lifetime.abort();
+  assert.throws(
+    () =>
+      createApplicationCatalog({
+        sources: createStandaloneLayerSources(),
+        signal: lifetime.signal,
+      }),
+    { name: 'AbortError' },
+  );
+});
+
+function fixtureSurface(signal) {
+  return createSurfaceServices({
+    terrainSource: { getHeights: async () => [] },
+    signal,
+    eventTarget: null,
+  });
+}
+
+test('Mapillary can be omitted or replaced without changing catalog membership', (t) => {
+  const lifetime = new AbortController();
+  t.after(() => lifetime.abort());
+  const sources = fixtureSources([], []);
+  delete sources.mapillary;
+  const options = {
+    sources,
+    signal: lifetime.signal,
+    surface: fixtureSurface(lifetime.signal),
+  };
+  const catalog = createApplicationCatalog(options);
+  assert.equal(catalog.layers.length, 34);
+  assert.deepEqual(catalog.get('street-level').providerIds, []);
+  assert.equal(
+    catalogControlServices(catalog).streetLevelLayer,
+    catalog.get('street-level'),
+  );
+  assert.match(
+    catalog.get('street-level').getUIState().coverage.hint,
+    /No street-level imagery providers/,
+  );
+  const provider = fakeStreetLevelProvider({
+    id: 'example',
+    pickPrefix: 'example:',
+  });
+  const replacement = createApplicationCatalog({
+    ...options,
+    streetLevelProviders: [provider],
+  });
+  assert.deepEqual(replacement.get('street-level').providerIds, ['example']);
+  assert.deepEqual(replacement.metadata, catalog.metadata);
+  assert.equal(provider.calls.activate, 0, 'construction must not acquire');
+  assert.deepEqual(
+    createApplicationCatalog({
+      ...options,
+      sources: fixtureSources([], []),
+      streetLevelProviders: [],
+    }).get('street-level').providerIds,
+    [],
+  );
+  assert.throws(
+    () =>
+      createApplicationCatalog({
+        ...options,
+        sources: { ...sources, mapillary: {} },
+      }),
+    /Mapillary source/,
+  );
+});
+
+test('a GNSS integrity source can set the layer evidence window', (t) => {
+  const lifetime = new AbortController();
+  t.after(() => lifetime.abort());
+  const gnssLayer = (descriptor) => {
+    const sources = fixtureSources([], []);
+    sources['gnss-integrity'] = {
+      getSnapshot: async () => ({}),
+      ...descriptor,
+    };
+    return createApplicationCatalog({
+      sources,
+      signal: lifetime.signal,
+      surface: fixtureSurface(lifetime.signal),
+    }).get('gnss-integrity');
+  };
+  const shows = (layer, minutes) => {
+    assert.equal(layer.provenance.window.minutes, minutes);
+    const { info, legend } = layer.getRowControls();
+    assert.match(info, new RegExp(`visited views over ${minutes} min`));
+    assert.match(legend[0].blurb, new RegExp(`over ${minutes} minutes`));
+  };
+  shows(gnssLayer({ windowMs: 65 * 60_000 }), 65);
+  shows(gnssLayer({}), 30);
+  for (const windowMs of [
+    undefined,
+    null,
+    NaN,
+    Infinity,
+    0,
+    -60_000,
+    '3600000',
+  ])
+    assert.equal(
+      gnssLayer({ windowMs }).provenance.window.minutes,
+      30,
+      `${String(windowMs)} falls back to the default`,
+    );
+});