Merge upstream/main into feat/cctv-a22-autobrennero

Resolve conflicts with the NYC, Toronto, Lithuania, Florida, Taiwan and
Kartverket work on main. The CHANGELOG entry moves to
changelog.d/956-a22-brennero-webcams.md, as main now asks.

scripts/assemble-changelog.mjs

@@ -0,0 +1,204 @@
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+/**
+ * Release-time assembly of changelog fragments.
+ *
+ * A pull request adds `changelog.d/<pull request>-<slug>.md` instead of editing
+ * `CHANGELOG.md`. Distinct filenames never conflict, so two pull requests in
+ * flight no longer write into the same few lines at the top of one file. A
+ * release splices the fragments in and empties the directory.
+ *
+ * Fragment text is copied through unchanged apart from trailing whitespace:
+ * `src/annotations/drawTool.test.mjs` reads `CHANGELOG.md` as prose and slices a
+ * fixed window after a heading, so reflowing an entry here could move text
+ * across that window.
+ *
+ * A write is staged so that a failure at any point leaves a rerun unable to
+ * duplicate or lose an entry. The assembled file is written into
+ * `changelog.d/.assembling/` first, the fragments are renamed in beside it, and
+ * renaming the assembled file over `CHANGELOG.md` is the single commit point.
+ * While the assembled file is still staged the batch has not landed, so
+ * recovery moves the fragments back; once it is gone the batch has landed, and
+ * the staged fragments are leftovers to delete. Either way they are out of the
+ * input directory, so they are never assembled twice.
+ */
+export const FRAGMENT_DIR = 'changelog.d';
+export const STAGING_DIR = '.assembling';
+const STAGED_CHANGELOG = 'CHANGELOG.md';
+const FRAGMENT_NAME = /^(\d+)-[a-z0-9]+(?:-[a-z0-9]+)*\.md$/;
+const HEADING = '# Changelog\n';
+
+/** Fragment file names a release may consume, highest pull request first. */
+export function orderFragmentNames(names) {
+  const claimed = new Map();
+  for (const name of names) {
+    if (name === 'README.md') continue;
+    const match = FRAGMENT_NAME.exec(name);
+    if (!match) {
+      throw new Error(
+        `Unexpected file in ${FRAGMENT_DIR}/: ${name}` +
+          ' — expected <pull request>-<slug>.md with a lowercase slug',
+      );
+    }
+    const number = Number(match[1]);
+    const prior = claimed.get(number);
+    if (prior) {
+      throw new Error(
+        `Two fragments claim pull request ${number}: ${prior} and ${name}`,
+      );
+    }
+    claimed.set(number, name);
+  }
+  return [...claimed.entries()]
+    .sort(([a], [b]) => b - a)
+    .map(([, name]) => name);
+}
+
+/** Splice fragment bodies above the existing entries, newest batch on top. */
+export function assembleChangelog(changelog, fragments) {
+  if (!fragments.length) return changelog;
+  if (!changelog.startsWith(HEADING)) {
+    throw new Error('CHANGELOG.md must start with "# Changelog"');
+  }
+  const entries = changelog.slice(HEADING.length).replace(/^\n+/, '');
+  const batch = fragments.map((text) => text.replace(/\s+$/, '')).join('\n\n');
+  return `${HEADING}\n${batch}\n\n${entries}`;
+}
+
+/**
+ * Finish or roll back a batch an earlier `--write` left in the staging
+ * directory. A no-op when there is none.
+ *
+ * @returns {Promise<'none'|'rolled-back'|'cleaned-up'>}
+ */
+export async function recoverInterruptedBatch(root, io = fs) {
+  const directory = path.join(root, FRAGMENT_DIR);
+  const staging = path.join(directory, STAGING_DIR);
+  let staged;
+  try {
+    staged = await io.readdir(staging);
+  } catch (error) {
+    if (error.code === 'ENOENT') return 'none';
+    throw error;
+  }
+  if (!staged.includes(STAGED_CHANGELOG)) {
+    // The assembled file was renamed over CHANGELOG.md: the batch landed.
+    await io.rm(staging, { recursive: true, force: true });
+    return 'cleaned-up';
+  }
+  // The batch never reached CHANGELOG.md, so every fragment goes back.
+  const pending = new Set(await io.readdir(directory));
+  const fragments = staged.filter((name) => name !== STAGED_CHANGELOG);
+  const clash = fragments.filter((name) => pending.has(name));
+  if (clash.length) {
+    throw new Error(
+      `Cannot roll back ${FRAGMENT_DIR}/${STAGING_DIR}/: ${clash.join(', ')}` +
+        ` also exist in ${FRAGMENT_DIR}/ — resolve by hand`,
+    );
+  }
+  for (const name of fragments) {
+    await io.rename(path.join(staging, name), path.join(directory, name));
+  }
+  await io.rm(staging, { recursive: true, force: true });
+  return 'rolled-back';
+}
+
+/**
+ * Report or apply the pending fragments in `<root>/changelog.d`.
+ *
+ * The batch is validated in full before anything is written, so a malformed
+ * filename or a duplicate pull request number leaves the directory untouched.
+ * `--write` first recovers any batch an interrupted run left staged.
+ *
+ * @param {string} root repository root
+ * @param {'--check'|'--write'} mode `--check` reports and changes nothing
+ * @param {typeof fs} [io] filesystem calls, replaceable for failure injection
+ * @returns {Promise<{ consumed: string[], changelog: string }>}
+ */
+export async function assembleFragments(root, mode, io = fs) {
+  if (!['--check', '--write'].includes(mode)) {
+    throw new Error(
+      'Usage: node scripts/assemble-changelog.mjs --check|--write',
+    );
+  }
+  const directory = path.join(root, FRAGMENT_DIR);
+  const staging = path.join(directory, STAGING_DIR);
+  const changelogFile = path.join(root, 'CHANGELOG.md');
+  if (mode === '--write') {
+    await recoverInterruptedBatch(root, io);
+  }
+  const names = await io.readdir(directory);
+  if (names.includes(STAGING_DIR)) {
+    throw new Error(
+      `${FRAGMENT_DIR}/${STAGING_DIR}/ holds a batch an interrupted release` +
+        ' left behind — `npm run changelog` finishes or rolls it back',
+    );
+  }
+  const consumed = orderFragmentNames(names);
+  const bodies = [];
+  for (const name of consumed) {
+    bodies.push(await io.readFile(path.join(directory, name), 'utf8'));
+  }
+  const changelog = assembleChangelog(
+    await io.readFile(changelogFile, 'utf8'),
+    bodies,
+  );
+  if (mode === '--write' && consumed.length) {
+    try {
+      await io.mkdir(staging);
+      await io.writeFile(
+        path.join(staging, STAGED_CHANGELOG),
+        changelog,
+        'utf8',
+      );
+      for (const name of consumed) {
+        await io.rename(path.join(directory, name), path.join(staging, name));
+      }
+      await io.rename(path.join(staging, STAGED_CHANGELOG), changelogFile);
+      await io.rm(staging, { recursive: true, force: true });
+    } catch (error) {
+      try {
+        await recoverInterruptedBatch(root, io);
+      } catch {
+        throw new Error(
+          `${error.message} — the batch is staged in ${FRAGMENT_DIR}/${STAGING_DIR}/,` +
+            ' and the next `npm run changelog` finishes or rolls it back',
+          { cause: error },
+        );
+      }
+      throw error;
+    }
+  }
+  return { consumed, changelog };
+}
+
+const invoked = process.argv[1]
+  ? pathToFileURL(path.resolve(process.argv[1])).href
+  : '';
+if (import.meta.url === invoked) {
+  try {
+    if (process.argv.length !== 3) {
+      throw new Error(
+        'Usage: node scripts/assemble-changelog.mjs --check|--write',
+      );
+    }
+    const mode = process.argv[2];
+    const { consumed } = await assembleFragments(
+      fileURLToPath(new URL('../', import.meta.url)),
+      mode,
+    );
+    if (!consumed.length) {
+      console.log(`No fragments in ${FRAGMENT_DIR}/.`);
+    } else {
+      console.log(
+        `${mode === '--write' ? 'Assembled' : 'Would assemble'} ${consumed.length} fragment(s), in order:` +
+          `\n  ${consumed.join('\n  ')}`,
+      );
+    }
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}

scripts/build-bright-stars.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * Build src/data/local_data/sky/bright_stars.json from the Yale Bright Star
+ * Catalogue, 5th Revised Edition (Hoffleit & Warren 1991).
+ *
+ * Source:   CDS VizieR catalogue V/50, https://cdsarc.cds.unistra.fr/viz-bin/cat/V/50
+ * Fetched:  https://cdsarc.cds.unistra.fr/ftp/V/50/catalog.gz
+ * Format:   fixed-width ASCII, 197 bytes per record, byte layout in
+ *           https://cdsarc.cds.unistra.fr/ftp/V/50/ReadMe
+ * License:  public domain (Yale University Observatory / NASA ADC); CDS asks
+ *           for an acknowledgement, which the Data attribution popover carries.
+ *
+ * Transform (deterministic):
+ *   1. J2000 RA/Dec (bytes 76-90), V magnitude (103-107) and B−V (110-114).
+ *   2. The 14 records without a J2000 position (novae and other objects later
+ *      found not to be stars) are dropped.
+ *   3. RA/Dec rounded to 3 decimals of a degree (3.6″ — a fraction of a pixel
+ *      at any field of view the globe uses), magnitudes to 2.
+ *   4. Missing B−V is stored as null; the renderer gives it a neutral colour.
+ *   5. Records keep catalogue (HR) order for a stable diff.
+ *
+ * Usage:
+ *   node scripts/build-bright-stars.mjs [catalog | catalog.gz]
+ * With no argument it downloads the catalogue from CDS.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import zlib from 'node:zlib';
+import { fileURLToPath } from 'node:url';
+
+const SOURCE_URL = 'https://cdsarc.cds.unistra.fr/ftp/V/50/catalog.gz';
+const OUT = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..',
+  'src',
+  'data',
+  'local_data',
+  'sky',
+  'bright_stars.json',
+);
+
+/** Slice 1-based inclusive byte columns the way the CDS ReadMe numbers them. */
+function columns(line, from, to) {
+  return line.slice(from - 1, to).trim();
+}
+
+/** Parse a fixed-width float; blank fields are null. */
+function parseField(text) {
+  if (text === '') return null;
+  const value = Number(text);
+  return Number.isFinite(value) ? value : null;
+}
+
+/**
+ * Parse one BSC5 record. Returns null for records without a J2000 position
+ * or V magnitude.
+ */
+export function parseBscRecord(line) {
+  const hr = parseField(columns(line, 1, 4));
+  const raH = parseField(columns(line, 76, 77));
+  const raM = parseField(columns(line, 78, 79));
+  const raS = parseField(columns(line, 80, 83));
+  const sign = columns(line, 84, 84);
+  const deD = parseField(columns(line, 85, 86));
+  const deM = parseField(columns(line, 87, 88));
+  const deS = parseField(columns(line, 89, 90));
+  const vmag = parseField(columns(line, 103, 107));
+  const bv = parseField(columns(line, 110, 114));
+  if (
+    hr === null ||
+    raH === null ||
+    raM === null ||
+    raS === null ||
+    deD === null ||
+    deM === null ||
+    deS === null ||
+    vmag === null ||
+    (sign !== '+' && sign !== '-')
+  )
+    return null;
+  const raDeg = (raH + raM / 60 + raS / 3600) * 15;
+  const decDeg = (sign === '-' ? -1 : 1) * (deD + deM / 60 + deS / 3600);
+  return { hr, raDeg, decDeg, vmag, bv };
+}
+
+const round = (value, decimals) => {
+  const scale = 10 ** decimals;
+  return Math.round(value * scale) / scale;
+};
+
+/** Build the committed pack from the raw catalogue text. */
+export function buildStarPack(text, { fetched = null } = {}) {
+  const stars = [];
+  let dropped = 0;
+  for (const line of text.split('\n')) {
+    if (line.trim() === '') continue;
+    const record = parseBscRecord(line);
+    if (!record) {
+      dropped += 1;
+      continue;
+    }
+    stars.push(
+      round(record.raDeg, 3),
+      round(record.decDeg, 3),
+      round(record.vmag, 2),
+      record.bv === null ? null : round(record.bv, 2),
+    );
+  }
+  return {
+    meta: {
+      source:
+        'Yale Bright Star Catalogue, 5th Revised Ed. (Hoffleit & Warren 1991), CDS V/50',
+      url: SOURCE_URL,
+      license: 'public domain',
+      fetched,
+      frame: 'ICRF/J2000, epoch 2000.0',
+      columns: ['raDeg', 'decDeg', 'vmag', 'bv'],
+      count: stars.length / 4,
+      dropped,
+    },
+    stars,
+  };
+}
+
+async function readCatalogue(file) {
+  if (!file) {
+    const response = await fetch(SOURCE_URL);
+    if (!response.ok) throw new Error(`${SOURCE_URL}: HTTP ${response.status}`);
+    return zlib
+      .gunzipSync(Buffer.from(await response.arrayBuffer()))
+      .toString('latin1');
+  }
+  const bytes = fs.readFileSync(file);
+  return (file.endsWith('.gz') ? zlib.gunzipSync(bytes) : bytes).toString(
+    'latin1',
+  );
+}
+
+async function main() {
+  const [file] = process.argv.slice(2);
+  const text = await readCatalogue(file);
+  const pack = buildStarPack(text, {
+    fetched: new Date().toISOString().slice(0, 10),
+  });
+  // One star per line keeps the JSON compact and the diff readable.
+  const rows = [];
+  for (let i = 0; i < pack.stars.length; i += 4)
+    rows.push(JSON.stringify(pack.stars.slice(i, i + 4)).slice(1, -1));
+  const body = `{"meta":${JSON.stringify(pack.meta)},\n"stars":[\n${rows.join(',\n')}\n]}\n`;
+  fs.mkdirSync(path.dirname(OUT), { recursive: true });
+  fs.writeFileSync(OUT, body);
+  console.log(
+    `wrote ${pack.meta.count} stars (${pack.meta.dropped} dropped) → ${path.relative(process.cwd(), OUT)} (${body.length} bytes)`,
+  );
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main();

scripts/build-milky-way.mjs

@@ -0,0 +1,415 @@
+#!/usr/bin/env node
+/**
+ * Build the soft Milky Way cube map in src/data/local_data/sky/ from the ESO
+ * all-sky Milky Way panorama.
+ *
+ * Source page: https://www.eso.org/public/images/eso0932a/
+ * Fetched:     https://cdn.eso.org/images/original/eso0932a.tif
+ *              (6000×3000 8-bit sRGB TIFF, 27.7 MB; sha256 in README.md)
+ * Credit:      ESO/S. Brunier
+ * License:     CC BY 4.0 (https://www.eso.org/public/outreach/copyright/).
+ *              Modified: stars removed, blurred, reprojected to ICRF cube
+ *              faces and tone-mapped, as below.
+ * Frame:       plate carrée in galactic coordinates, centred on the Galactic
+ *              Centre, galactic longitude increasing to the left.
+ *
+ * Transform (deterministic):
+ *   1. Resample to WORK_WIDTH×WORK_WIDTH/2, sRGB to linear light.
+ *   2. Remove stars with a morphological opening: the renderer draws
+ *      catalogue stars itself, sharp and in the right place.
+ *   3. Paint out the planets the 2008–2010 exposures caught (PLANETS).
+ *   4. Blur, round on the sphere: σ = BLUR_DEG, widening to FAINT_BLUR_DEG
+ *      in the faint glow so unresolved stars leave no clumps.
+ *   5. Resample into six WebGL cube faces (uploaded without flipY) with the
+ *      ICRF axes: +X to the March equinox, +Z to the north celestial pole.
+ *   6. Median sky to black with a soft knee, brightest 0.01 % to ~97 %
+ *      white, on luminance to keep the hue; gamma 1/2.2, dither, WebP.
+ *
+ * Usage:
+ *   node scripts/build-milky-way.mjs <eso0932a.tif>
+ * Needs the sharp dev dependency.
+ */
+
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const FACE_SIZE = 1024;
+export const BLUR_DEG = 0.4;
+// Faint glow is grain of unresolved stars and needs the wide blur; bright
+// parts keep the fine one and their dust lanes. FAINT_RANGE (fraction of
+// black-to-white) is where the two blend.
+export const FAINT_BLUR_DEG = 2;
+const FAINT_RANGE = [0.005, 0.08];
+const WORK_WIDTH = 4096;
+const OPEN_RADIUS = 3;
+const WEBP_QUALITY = 96;
+// The median sky is black: above it the glow away from the plane reads as
+// grey blotches. SOFT_KNEE eases the cut in so it draws no edges.
+const BLACK_PERCENTILE = 0.5;
+const SOFT_KNEE = 0.03;
+const WHITE_PERCENTILE = 0.9999;
+const OUT_DIR = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..',
+  'src',
+  'data',
+  'local_data',
+  'sky',
+);
+
+/**
+ * Bright planets in the panorama, galactic longitude/latitude in degrees and
+ * the radius painted over with the surrounding sky. By position both are
+ * Jupiter, in Sagittarius (2008) and Aquarius (2010); no catalogue star lies
+ * under either.
+ */
+export const PLANETS = Object.freeze([
+  { l: 13.4, b: -16.6, radiusDeg: 2.5 },
+  { l: 69.0, b: -58.4, radiusDeg: 2.5 },
+]);
+
+/** Cube faces in WebGL upload order. */
+export const CUBE_FACES = Object.freeze([
+  'positiveX',
+  'negativeX',
+  'positiveY',
+  'negativeY',
+  'positiveZ',
+  'negativeZ',
+]);
+export const FACE_FILE_SUFFIX = Object.freeze({
+  positiveX: 'px',
+  negativeX: 'nx',
+  positiveY: 'py',
+  negativeY: 'ny',
+  positiveZ: 'pz',
+  negativeZ: 'nz',
+});
+
+/**
+ * ICRF (J2000 equatorial) → galactic rotation, rows = galactic axes
+ * (Hipparcos catalogue, ESA SP-1200 vol. 1 §1.5.3).
+ */
+export const ICRF_TO_GALACTIC = Object.freeze([
+  [-0.0548755604162154, -0.873437090234885, -0.4838350155487132],
+  [0.4941094278755837, -0.4448296299600112, 0.7469822444972189],
+  [-0.867666149019004, -0.1980763734312015, 0.4559837761750669],
+]);
+
+/**
+ * Direction (not normalized) that the WebGL cube-map lookup sends to texel
+ * coordinate (s, t) ∈ [0, 1]² of `face`, t = 0 being the first image row.
+ * Inverse of the OpenGL ES 3.0 §3.8.10 major-axis table.
+ */
+export function cubeFaceDirection(face, s, t) {
+  const sc = 2 * s - 1;
+  const tc = 2 * t - 1;
+  switch (face) {
+    case 'positiveX':
+      return [1, -tc, -sc];
+    case 'negativeX':
+      return [-1, -tc, sc];
+    case 'positiveY':
+      return [sc, 1, tc];
+    case 'negativeY':
+      return [sc, -1, -tc];
+    case 'positiveZ':
+      return [sc, -tc, 1];
+    case 'negativeZ':
+      return [-sc, -tc, -1];
+    default:
+      throw new RangeError(`Unknown cube face ${face}`);
+  }
+}
+
+/** Rotate an ICRF direction into galactic coordinates. */
+export function icrfToGalactic([x, y, z]) {
+  return ICRF_TO_GALACTIC.map((row) => row[0] * x + row[1] * y + row[2] * z);
+}
+
+/**
+ * Map a direction to (u, v) ∈ [0, 1)² of a plate carrée centred on
+ * longitude 0 with longitude increasing to the left and v = 0 at +90°.
+ */
+export function directionToPlateCarree(x, y, z) {
+  const longitude = Math.atan2(y, x);
+  const latitude = Math.atan2(z, Math.hypot(x, y));
+  let u = 0.5 - longitude / (2 * Math.PI);
+  u -= Math.floor(u);
+  return [u, 0.5 - latitude / Math.PI];
+}
+
+/** Box widths whose three passes approximate a Gaussian of `sigma` (Kovesi). */
+function boxRadii(sigma) {
+  const ideal = Math.sqrt((12 * sigma * sigma) / 3 + 1);
+  let lower = Math.floor(ideal);
+  if (lower % 2 === 0) lower -= 1;
+  const upper = lower + 2;
+  const m = Math.round(
+    (12 * sigma * sigma - 3 * lower * lower - 12 * lower - 9) /
+      (-4 * lower - 4),
+  );
+  return [0, 1, 2].map((i) => ((i < m ? lower : upper) - 1) / 2);
+}
+
+/** Index along a line, wrapped or clamped at the ends. */
+function lineIndex(i, length, wrap) {
+  if (wrap) return ((i % length) + length) % length;
+  return i < 0 ? 0 : i >= length ? length - 1 : i;
+}
+
+/** Running-sum box blur of one strided line. */
+function boxLine(src, dst, offset, stride, length, radius, wrap) {
+  if (radius < 1) {
+    for (let i = 0; i < length; i++)
+      dst[offset + i * stride] = src[offset + i * stride];
+    return;
+  }
+  const r = wrap ? Math.min(radius, Math.floor((length - 1) / 2)) : radius;
+  const at = (i) => src[offset + lineIndex(i, length, wrap) * stride];
+  let sum = 0;
+  for (let i = -r; i <= r; i++) sum += at(i);
+  const scale = 1 / (2 * r + 1);
+  for (let i = 0; i < length; i++) {
+    dst[offset + i * stride] = sum * scale;
+    sum += at(i + r + 1) - at(i - r);
+  }
+}
+
+/** Minimum or maximum over a (2r+1) window of one strided line. */
+function extremumLine(src, dst, offset, stride, length, radius, wrap, pick) {
+  for (let i = 0; i < length; i++) {
+    let value = src[offset + lineIndex(i - radius, length, wrap) * stride];
+    for (let k = -radius + 1; k <= radius; k++)
+      value = pick(
+        value,
+        src[offset + lineIndex(i + k, length, wrap) * stride],
+      );
+    dst[offset + i * stride] = value;
+  }
+}
+
+/** Separable minimum or maximum filter over a plate-carrée plane, in place. */
+function extremumPlane(plane, width, height, radius, pick) {
+  const scratch = new Float32Array(plane.length);
+  for (let y = 0; y < height; y++)
+    extremumLine(plane, scratch, y * width, 1, width, radius, true, pick);
+  for (let x = 0; x < width; x++)
+    extremumLine(scratch, plane, x, width, height, radius, false, pick);
+}
+
+/** Blur one plate-carrée channel in place, round on the sphere. */
+function blurPlane(plane, width, height, sigmaPx) {
+  const scratch = new Float32Array(plane.length);
+  for (let y = 0; y < height; y++) {
+    const latitude = (0.5 - (y + 0.5) / height) * Math.PI;
+    const sigmaX = Math.min(
+      width / 4,
+      sigmaPx / Math.max(Math.cos(latitude), 1e-3),
+    );
+    for (const radius of boxRadii(sigmaX)) {
+      boxLine(plane, scratch, y * width, 1, width, Math.round(radius), true);
+      plane.set(scratch.subarray(y * width, (y + 1) * width), y * width);
+    }
+  }
+  for (const radius of boxRadii(sigmaPx)) {
+    for (let x = 0; x < width; x++)
+      boxLine(plane, scratch, x, width, height, Math.round(radius), false);
+    plane.set(scratch);
+  }
+}
+
+/** Unit vector for galactic longitude and latitude in degrees. */
+function galacticVector(l, b) {
+  const lr = (l * Math.PI) / 180;
+  const br = (b * Math.PI) / 180;
+  return [
+    Math.cos(br) * Math.cos(lr),
+    Math.cos(br) * Math.sin(lr),
+    Math.sin(br),
+  ];
+}
+
+/**
+ * Replace a disc of the sky with the median of the ring just outside it, per
+ * channel. A median, not a mean: the planet's diffraction spikes reach far
+ * past the disc and would lift a mean well above the sky. The blur that
+ * follows hides the seam.
+ */
+function paintOut(planes, width, height, { l, b, radiusDeg }) {
+  const centre = galacticVector(l, b);
+  const inner = Math.cos((radiusDeg * Math.PI) / 180);
+  const outer = Math.cos(((radiusDeg + 1) * Math.PI) / 180);
+  const disc = [];
+  const ring = [];
+  const span = Math.ceil(((radiusDeg + 1) / 180) * height);
+  const row = Math.round((0.5 - b / 180) * height);
+  for (let y = Math.max(0, row - span); y < Math.min(height, row + span); y++) {
+    const latitude = 90 - ((y + 0.5) * 180) / height;
+    for (let x = 0; x < width; x++) {
+      const longitude = (0.5 - (x + 0.5) / width) * 360;
+      const p = galacticVector(longitude, latitude);
+      const cos = p[0] * centre[0] + p[1] * centre[1] + p[2] * centre[2];
+      if (cos >= inner) disc.push(y * width + x);
+      else if (cos >= outer) ring.push(y * width + x);
+    }
+  }
+  for (const plane of planes) {
+    const values = Float32Array.from(ring, (index) => plane[index]).sort();
+    const median = values[values.length >> 1];
+    for (const index of disc) plane[index] = median;
+  }
+}
+
+/** Bilinear sample with longitude wrap and latitude clamp. */
+function samplePlane(plane, width, height, u, v) {
+  const fx = u * width - 0.5;
+  const fy = Math.min(Math.max(v * height - 0.5, 0), height - 1);
+  const x0 = Math.floor(fx);
+  const y0 = Math.floor(fy);
+  const ax = fx - x0;
+  const ay = fy - y0;
+  const xa = ((x0 % width) + width) % width;
+  const xb = (xa + 1) % width;
+  const yb = Math.min(y0 + 1, height - 1);
+  const top = plane[y0 * width + xa] * (1 - ax) + plane[y0 * width + xb] * ax;
+  const bottom =
+    plane[yb * width + xa] * (1 - ax) + plane[yb * width + xb] * ax;
+  return top * (1 - ay) + bottom * ay;
+}
+
+/** Deterministic hash noise in [-0.5, 0.5) for dithering. */
+function dither(index, channel) {
+  let h = (index * 374761393 + channel * 668265263) | 0;
+  h = Math.imul(h ^ (h >>> 13), 1274126177);
+  h ^= h >>> 16;
+  return (h >>> 0) / 4294967296 - 0.5;
+}
+
+/**
+ * Black level with a soft knee: 0 at and below the level, then a quadratic
+ * ease that joins the straight line, so faint sky fades out instead of
+ * ending in a contour.
+ */
+export function softBlack(x, knee = SOFT_KNEE) {
+  return x <= 0 ? 0 : (x * x) / (x + knee);
+}
+
+export function smoothstep(edge0, edge1, x) {
+  const t = Math.min(Math.max((x - edge0) / (edge1 - edge0), 0), 1);
+  return t * t * (3 - 2 * t);
+}
+
+/**
+ * Per pixel, keep `fine` where `weight(luminance of coarse)` is 1 and take
+ * `coarse` where it is 0, blending in between. The weight follows the coarse
+ * copy, so it is smooth itself and draws no seams along dark lanes. Writes
+ * into `fine`.
+ */
+function blendByBrightness(fine, coarse, weight) {
+  const [r] = fine;
+  for (let i = 0; i < r.length; i++) {
+    const w = weight((coarse[0][i] + coarse[1][i] + coarse[2][i]) / 3);
+    for (let c = 0; c < 3; c++)
+      fine[c][i] = coarse[c][i] + (fine[c][i] - coarse[c][i]) * w;
+  }
+}
+
+/** Value at `fraction` of the sorted luminance. */
+function luminancePercentile(planes, fraction) {
+  const [r, g, b] = planes;
+  const lum = new Float32Array(r.length);
+  for (let i = 0; i < lum.length; i++) lum[i] = (r[i] + g[i] + b[i]) / 3;
+  lum.sort();
+  return lum[Math.min(lum.length - 1, Math.floor(fraction * lum.length))];
+}
+
+const srgbToLinear = (value) =>
+  value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+
+async function decodePanorama(sharp, file) {
+  const width = WORK_WIDTH;
+  const height = WORK_WIDTH / 2;
+  const raw = await sharp(file)
+    .resize(width, height, { fit: 'fill', kernel: 'lanczos3' })
+    .removeAlpha()
+    .raw()
+    .toBuffer();
+  const lut = Float32Array.from({ length: 256 }, (_, i) =>
+    srgbToLinear(i / 255),
+  );
+  const planes = [0, 1, 2].map(() => new Float32Array(width * height));
+  for (let i = 0; i < width * height; i++)
+    for (let c = 0; c < 3; c++) planes[c][i] = lut[raw[i * 3 + c]];
+  return { width, height, planes };
+}
+
+async function main() {
+  const [file] = process.argv.slice(2);
+  if (!file) throw new Error('usage: build-milky-way.mjs <eso0932a.tif>');
+  const { default: sharp } = await import('sharp');
+  const { width, height, planes } = await decodePanorama(sharp, file);
+  const sigmaPx = (BLUR_DEG / 180) * height;
+  for (const plane of planes) {
+    extremumPlane(plane, width, height, OPEN_RADIUS, Math.min);
+    extremumPlane(plane, width, height, OPEN_RADIUS, Math.max);
+  }
+  // After the opening: it sinks the starry sky to the dark gaps between
+  // stars, and a fill taken before it would stay brighter than the sky.
+  for (const planet of PLANETS) paintOut(planes, width, height, planet);
+  const wide = planes.map((plane) => Float32Array.from(plane));
+  for (const plane of planes) blurPlane(plane, width, height, sigmaPx);
+  for (const plane of wide)
+    blurPlane(plane, width, height, (FAINT_BLUR_DEG / 180) * height);
+  // Levels from the fine blur, so the blend weight and the output share
+  // them; the blend moves the median only in the faint sky it smooths.
+  const black = luminancePercentile(planes, BLACK_PERCENTILE);
+  const white = luminancePercentile(planes, WHITE_PERCENTILE);
+  blendByBrightness(planes, wide, (luminance) =>
+    smoothstep(
+      FAINT_RANGE[0],
+      FAINT_RANGE[1],
+      (luminance - black) / (white - black),
+    ),
+  );
+  let total = 0;
+  for (const face of CUBE_FACES) {
+    const pixels = Buffer.alloc(FACE_SIZE * FACE_SIZE * 3);
+    for (let j = 0; j < FACE_SIZE; j++) {
+      for (let i = 0; i < FACE_SIZE; i++) {
+        const direction = cubeFaceDirection(
+          face,
+          (i + 0.5) / FACE_SIZE,
+          (j + 0.5) / FACE_SIZE,
+        );
+        const [u, v] = directionToPlateCarree(...icrfToGalactic(direction));
+        const index = j * FACE_SIZE + i;
+        const rgb = [0, 1, 2].map((c) =>
+          samplePlane(planes[c], width, height, u, v),
+        );
+        const luminance = (rgb[0] + rgb[1] + rgb[2]) / 3;
+        const level = softBlack((luminance - black) / (white - black));
+        for (let c = 0; c < 3; c++) {
+          // Scale every channel by the luminance curve to keep the hue.
+          const linear = luminance > 0 ? (rgb[c] / luminance) * level : 0;
+          const encoded = Math.min(linear, 1) ** (1 / 2.2) * 255;
+          pixels[index * 3 + c] = Math.min(
+            255,
+            Math.max(0, Math.round(encoded + dither(index, c))),
+          );
+        }
+      }
+    }
+    const out = path.join(OUT_DIR, `milkyway_${FACE_FILE_SUFFIX[face]}.webp`);
+    const info = await sharp(pixels, {
+      raw: { width: FACE_SIZE, height: FACE_SIZE, channels: 3 },
+    })
+      .webp({ quality: WEBP_QUALITY, smartSubsample: true, effort: 6 })
+      .toFile(out);
+    total += info.size;
+    console.log(`${path.relative(process.cwd(), out)}: ${info.size} bytes`);
+  }
+  console.log(`total ${total} bytes`);
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main();

scripts/check-import-directions.mjs

@@ -24,11 +24,10 @@ const renderer = (file) =>
   /^src\/layers\/[^/]+\/(?:index|rendering|snapshotRenderer|overlay|presentation|cards|controls)\.js$/.test(
     file,
   );
-// Two compatibility composition entries intentionally select standalone defaults.
+// One compatibility composition entry intentionally selects standalone defaults.
 const compatibilityEdge = (from, to) =>
-  (from === 'server/providers/local.js' &&
-    to === 'server/standalone/key-setup.js') ||
-  (from === 'src/ui.js' && to === 'src/standalone/catalog.js');
+  from === 'server/providers/local.js' &&
+  to === 'server/standalone/key-setup.js';
 const portableExport = (key) =>
   key.startsWith('./sources/') ||
   /\/source$/.test(key) ||
@@ -154,14 +153,6 @@ export function checkImportDirections(root) {
           file,
           'Actions must consume feed state without the manager facade',
         );
-      if (
-        file === 'src/app/constructCatalog.js' &&
-        to === 'src/data/localGeojson.js'
-      )
-        report(
-          file,
-          'Catalog must use the services owner without compatibility layer construction',
-        );
     }
     return record;
   }

scripts/docker-start.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * Docker launcher — the container's entry point (see Dockerfile).
+ *
+ * `compose.yaml` publishes the port on the host's loopback, but Docker still
+ * delivers the host's own browser to the container FROM the container
+ * network's gateway address, never from 127.0.0.1. Provider Settings admits
+ * loopback only, so without this the POWER UP panel refuses the very machine
+ * running the container. This launcher reads the gateway out of the kernel
+ * routing table and declares exactly that one address trusted, then starts
+ * Vite the way scripts/pinokio-start.mjs does.
+ */
+import { accessSync, constants, readFileSync, realpathSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isDirectInvocation } from './pinokio-install.mjs';
+import { loadViteFromCanonicalRoot } from './pinokio-start.mjs';
+
+const MODULE_PATH = fileURLToPath(import.meta.url);
+const ROOT = realpathSync(path.resolve(path.dirname(MODULE_PATH), '..'));
+const ROUTE_TABLE = '/proc/net/route';
+
+/**
+ * Extract the IPv4 default gateway from Linux `/proc/net/route` text. The
+ * addresses there are little-endian hex and only the default route (a
+ * destination of 00000000 on an interface flagged up) names a gateway.
+ * Returns null when there is none — the `--network none` case, which must
+ * never fabricate an address.
+ * @param {string} text Raw routing-table contents.
+ * @returns {string|null} Dotted-quad gateway, or null.
+ */
+export function defaultGatewayFromRouteTable(text) {
+  const lines = String(text || '').split(/\r?\n/).slice(1);
+  for (const line of lines) {
+    const fields = line.trim().split(/\s+/);
+    if (fields.length < 4) continue;
+    const [, destination, gateway, flags] = fields;
+    if (destination !== '00000000' || !/^[0-9a-f]{8}$/i.test(gateway)) continue;
+    if ((Number.parseInt(flags, 16) & 0x1) === 0) continue; // RTF_UP
+    const octets = [6, 4, 2, 0].map((offset) =>
+      Number.parseInt(gateway.slice(offset, offset + 2), 16),
+    );
+    if (octets.every((octet) => octet === 0)) continue;
+    return octets.join('.');
+  }
+  return null;
+}
+
+/**
+ * Decide this launch's trusted-peer list. An operator value always wins, so a
+ * compose override stays authoritative; `none` trusts no additional peers.
+ * An unset or blank value means the gateway alone is
+ * trusted. No gateway trusts nothing and Provider Settings stays loopback-only,
+ * exactly as under `npm run dev`.
+ * @param {{env?: NodeJS.ProcessEnv, routeTable?: string}} input
+ * @returns {string} Value for GEV_KEY_SETUP_TRUSTED_PEERS ('' trusts nothing).
+ */
+export function resolveTrustedPeers({ env = process.env, routeTable = '' } = {}) {
+  const explicit = String(env.GEV_KEY_SETUP_TRUSTED_PEERS ?? '').trim();
+  if (explicit.toLowerCase() === 'none') return '';
+  if (explicit) return explicit;
+  return defaultGatewayFromRouteTable(routeTable) ?? '';
+}
+
+/**
+ * A checkout the container cannot write fails quietly: Provider Settings
+ * answers 500 and `.gev-cache` is never created, with nothing in the log. The
+ * usual cause is a clone made as root on a NAS or Proxmox host while the
+ * container runs as 1000:1000. Say so at start, naming both sets of ids.
+ * @param {{root: string, writable: boolean, owner: {uid: number, gid: number}, runAs: {uid: number, gid: number}}} input
+ * @returns {string|null} A warning, or null when the checkout is writable.
+ */
+export function unwritableRootWarning({ root, writable, owner, runAs }) {
+  if (writable) return null;
+  return (
+    `[Docker] ${root} is owned by ${owner.uid}:${owner.gid} but the container runs as ` +
+    `${runAs.uid}:${runAs.gid}, so saving keys and caching will fail. Either give ` +
+    `the checkout to that user (chown -R ${runAs.uid}:${runAs.gid} on the host) or ` +
+    `run as its owner (env UID=${owner.uid} GID=${owner.gid} docker compose up)`
+  );
+}
+
+function readRouteTable() {
+  try {
+    return readFileSync(ROUTE_TABLE, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+async function start() {
+  let writable = true;
+  try {
+    accessSync(ROOT, constants.W_OK);
+  } catch {
+    writable = false;
+  }
+  if (!writable) {
+    const { uid, gid } = statSync(ROOT);
+    console.warn(
+      unwritableRootWarning({
+        root: ROOT,
+        writable,
+        owner: { uid, gid },
+        runAs: { uid: process.getuid?.() ?? -1, gid: process.getgid?.() ?? -1 },
+      }),
+    );
+  }
+
+  const fromOperator = Boolean(
+    String(process.env.GEV_KEY_SETUP_TRUSTED_PEERS ?? '').trim(),
+  );
+  const trustedPeers = resolveTrustedPeers({ routeTable: readRouteTable() });
+  // Set even an empty list before Vite loads .env: the resolved launcher policy
+  // must remain authoritative when there is no trusted gateway.
+  process.env.GEV_KEY_SETUP_TRUSTED_PEERS = trustedPeers;
+  if (trustedPeers) {
+    console.log(
+      fromOperator
+        ? `[Docker] Provider Settings trusted peers: ${trustedPeers} (GEV_KEY_SETUP_TRUSTED_PEERS).`
+        : `[Docker] Provider Settings trusts the container gateway (${trustedPeers}).`,
+    );
+  } else if (fromOperator) {
+    console.log('[Docker] Provider Settings trusts no additional peers (GEV_KEY_SETUP_TRUSTED_PEERS=none).');
+  } else {
+    console.log('[Docker] No default gateway; Provider Settings stays loopback-only.');
+  }
+
+  const port = Number.parseInt(process.env.PORT, 10) || 4173;
+  const { createServer } = await loadViteFromCanonicalRoot(ROOT);
+  const server = await createServer({
+    root: ROOT,
+    server: {
+      // The container's own namespace. compose publishes this to the host's
+      // 127.0.0.1 only; widening that mapping is the LAN opt-in.
+      host: '0.0.0.0',
+      port,
+      strictPort: true,
+    },
+  });
+  await server.listen();
+  server.printUrls();
+  console.log(`[Docker] Ready at http://localhost:${port}/`);
+
+  for (const signal of ['SIGINT', 'SIGTERM']) {
+    process.once(signal, async () => {
+      await server.close();
+      process.exit(0);
+    });
+  }
+}
+
+if (isDirectInvocation(process.argv[1], MODULE_PATH)) {
+  start().catch((error) => {
+    console.error(`[Docker] Start refused: ${error.message}`);
+    process.exitCode = 1;
+  });
+}

scripts/fixtures/street-level/kartaView.mjs

@@ -0,0 +1,366 @@
+import { deflateSync } from 'node:zlib';
+import { tileBounds } from '../../../src/layers/streetLevel/tileMath.js';
+import { metresApart, photoJpeg } from './mapillaryGraph.mjs';
+
+/**
+ * KartaView's API, image proxy and photo storage answered from fixtures, so
+ * the gate's KartaView steps need no network. One drive runs north along
+ * KV_LINE; every tenth photo is a 360° one. Photos live on storage2 while
+ * their `fileurl*` name storage1, as KartaView's API does, so the gate also
+ * proves the provider builds addresses from `storage`. Every odd-indexed
+ * photo is archived (storage answers 409, the image proxy still serves it),
+ * so the nearest photo opened is even and › must skip the one after it. The
+ * first nearest-photo lookup is rate-limited (429, Retry-After: 0), as
+ * KartaView does under load.
+ *
+ * Beside the drive runs KV_OLD_STREET, photographed flat in 2019 only: the
+ * imagery filter drops it. KartaView filters coverage only in its PNG
+ * tiles, so filtered PNG tiles are drawn here for the streets that pass.
+ */
+
+export const KV_SEQUENCE_ID = '900001';
+export const KV_LINE = Object.freeze({
+  lon: -121.4931,
+  south: 38.5795,
+  north: 38.5875,
+});
+/** A street ~130 m east of the drive with only flat 2019 photos. */
+export const KV_OLD_STREET = Object.freeze({
+  lon: -121.4916,
+  south: 38.58,
+  north: 38.587,
+});
+const OLD_STREET_UPLOADED = '2019-06-01';
+const KV_SPACING_M = 25;
+const METRES_PER_DEG_LAT = 110_540;
+/** KartaView's time format for `ms`. */
+const kartaViewTime = (ms) =>
+  new Date(ms).toISOString().replace('T', ' ').slice(0, 23);
+/** The drive is a month old, whenever the gate runs: LAST YEAR keeps it. */
+const SHOT = kartaViewTime(Date.now() - 30 * 86_400_000);
+
+const CORS = Object.freeze({ 'Access-Control-Allow-Origin': '*' });
+
+/** Lookups answered so far: the first one is rate-limited. */
+let nearestLookups = 0;
+
+/** Forget the lookups answered, so the next one is rate-limited again. */
+export function resetKartaViewFixture() {
+  nearestLookups = 0;
+}
+
+/** The drive's photos, south to north; every tenth is 360°, every odd one archived. */
+export function kartaViewPhotos() {
+  const step = KV_SPACING_M / METRES_PER_DEG_LAT;
+  const count = Math.floor((KV_LINE.north - KV_LINE.south) / step) + 1;
+  return Array.from({ length: count }, (_, i) => ({
+    id: String(77_000_000 + i),
+    index: i,
+    lon: KV_LINE.lon,
+    lat: Number((KV_LINE.south + i * step).toFixed(7)),
+    isPano: i % 10 === 5,
+    archived: i % 2 === 1,
+  }));
+}
+
+function record(photo) {
+  const name = `${KV_SEQUENCE_ID}_${photo.id}.jpg`;
+  const folder = photo.isPano ? 'wrapped_proc' : 'proc';
+  const path = (prefix) => `2024/5/2/${prefix}/${name}`;
+  const storage1 = (prefix) =>
+    `https://storage1.openstreetcam.org/files/photo/${path(prefix)}`;
+  return {
+    id: photo.id,
+    sequenceId: KV_SEQUENCE_ID,
+    sequenceIndex: String(photo.index),
+    lat: String(photo.lat),
+    lng: String(photo.lon),
+    matchLat: String(photo.lat),
+    matchLng: String(photo.lon),
+    // A dashcam phone's compass, disturbed by the car: the drive runs north.
+    heading: '200',
+    fieldOfView: photo.isPano ? '360' : '0',
+    projection: photo.isPano ? 'SPHERE' : 'PLANE',
+    shotDate: SHOT,
+    dateAdded: SHOT,
+    storage: 'storage2',
+    filepath: path('{{sizeprefix}}'),
+    filepathLTh: path('lth'),
+    filepathProc: path(folder),
+    fileurl: storage1('{{sizeprefix}}'),
+    fileurlLTh: storage1('lth'),
+    fileurlProc: storage1(folder),
+  };
+}
+
+const ok = (result) => ({
+  status: 200,
+  contentType: 'application/json',
+  headers: CORS,
+  body: JSON.stringify({ status: { apiCode: 600, httpCode: 200 }, result }),
+});
+const raw = (status, body) => ({
+  status,
+  contentType: 'application/json',
+  headers: CORS,
+  body: JSON.stringify(body),
+});
+
+/** The streets with photos: the drive, and the old street beside it. */
+function streets() {
+  return [
+    { line: KV_LINE, uploaded: SHOT.slice(0, 10), views: ['360', 'plane'] },
+    { line: KV_OLD_STREET, uploaded: OLD_STREET_UPLOADED, views: ['plane'] },
+  ];
+}
+
+/** A street's stretch inside tile `z/x/y`, as [from, to] latitudes, or null. */
+function stretch(line, z, x, y) {
+  const { west, east, south, north } = tileBounds(x, y, z);
+  if (line.lon < west || line.lon > east) return null;
+  const from = Math.max(line.south, south);
+  const to = Math.min(line.north, north);
+  return from < to ? [from, to] : null;
+}
+
+/** The streets' tracks inside tile `z/x/y`, as KartaView's JSON tile. */
+function tileLines(z, x, y) {
+  const lines = [];
+  for (const { line } of streets()) {
+    const inside = stretch(line, z, x, y);
+    if (!inside) continue;
+    const [from, to] = inside;
+    // Two segments meeting end to start, as KartaView splits ways.
+    const mid = (from + to) / 2;
+    const at = (lat) => ({ lat: String(lat), lng: String(line.lon) });
+    lines.push(
+      { track: [at(from), at(mid)], matched: '1' },
+      { track: [at(mid), at(to)], matched: '1' },
+    );
+  }
+  return lines;
+}
+
+/** Whether a street has photos passing a filtered tile's query. */
+function passesTileQuery(street, query) {
+  const view = query.get('fieldOfView');
+  if (view && !street.views.includes(view)) return false;
+  const since = query.get('startDate');
+  return !since || street.uploaded >= since;
+}
+
+const CRC_TABLE = Array.from({ length: 256 }, (_, n) => {
+  let c = n;
+  for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+  return c >>> 0;
+});
+function crc32(bytes) {
+  let c = 0xffffffff;
+  for (const byte of bytes) c = CRC_TABLE[(c ^ byte) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+function pngChunk(type, data) {
+  const head = Buffer.alloc(8);
+  head.writeUInt32BE(data.length, 0);
+  head.write(type, 4, 'ascii');
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), data])), 0);
+  return Buffer.concat([head, data, crc]);
+}
+
+/**
+ * A filtered coverage tile as KartaView draws it: 512 px, transparent, the
+ * passing streets three pixels wide.
+ */
+export function maskTilePng(z, x, y, query) {
+  const size = 512;
+  const rgba = Buffer.alloc(size * size * 4);
+  const { west, east } = tileBounds(x, y, z);
+  const n = 2 ** z;
+  const row = (lat) => {
+    const sin = Math.sin((lat * Math.PI) / 180);
+    const my = 0.5 - Math.log((1 + sin) / (1 - sin)) / (4 * Math.PI);
+    return Math.round((my * n - y) * size);
+  };
+  for (const street of streets()) {
+    if (!passesTileQuery(street, query)) continue;
+    const inside = stretch(street.line, z, x, y);
+    if (!inside) continue;
+    const column = Math.round(
+      ((street.line.lon - west) / (east - west)) * size,
+    );
+    const top = Math.max(0, row(inside[1]));
+    const bottom = Math.min(size - 1, row(inside[0]));
+    for (let py = top; py <= bottom; py++)
+      for (let px = column - 1; px <= column + 1; px++) {
+        if (px < 0 || px >= size) continue;
+        rgba.set([99, 91, 255, 255], (py * size + px) * 4);
+      }
+  }
+  const rows = Buffer.alloc(size * (size * 4 + 1));
+  for (let py = 0; py < size; py++)
+    rgba.copy(
+      rows,
+      py * (size * 4 + 1) + 1,
+      py * size * 4,
+      (py + 1) * size * 4,
+    );
+  const header = Buffer.alloc(13);
+  header.writeUInt32BE(size, 0);
+  header.writeUInt32BE(size, 4);
+  header.set([8, 6, 0, 0, 0], 8);
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    pngChunk('IHDR', header),
+    pngChunk('IDAT', deflateSync(rows)),
+    pngChunk('IEND', Buffer.alloc(0)),
+  ]);
+}
+
+/** A call named by host, path shape and parameter names. */
+export function describeKartaViewCall(method, url) {
+  const keys = [...url.searchParams.keys()].sort();
+  const path = url.pathname
+    .replace(/\/tiles\/\d+\/\d+\/\d+\.json$/, '/tiles/{x}/{y}/{z}.json')
+    .replace(/\/tiles\/\d+\/\d+\/\d+\.png$/, '/tiles/{x}/{y}/{z}.png')
+    .replace(/\/photo\/\d+$/, '/photo/{id}')
+    .replace(/\/sequence\/\d+\/photos$/, '/sequence/{id}/photos')
+    .replace(/\/sequence\/\d+$/, '/sequence/{id}')
+    .replace(/^\/files\/photo\/.*$/, '/files/photo/{path}')
+    .replace(
+      /^\/pr:sharp\/rs:fit:\d+:\d+\/.*$/,
+      '/pr:sharp/rs:fit:{w}:{h}/{address}',
+    );
+  return `${method} ${url.hostname}${path}${keys.length ? `?${keys.join('&')}` : ''}`;
+}
+
+/**
+ * Answer one KartaView request; `known` is false for a call no fixture
+ * covers, so the gate fails on a new one instead of missing it.
+ */
+export function answerKartaViewRequest({ method, url }) {
+  const address = new URL(url);
+  const photos = kartaViewPhotos();
+  if (method === 'OPTIONS')
+    return { status: 204, headers: CORS, body: '', known: true };
+  const image = {
+    status: 200,
+    contentType: 'image/jpeg',
+    headers: CORS,
+    body: photoJpeg(),
+    known: true,
+  };
+  if (address.hostname === 'cdn.kartaview.org')
+    return /^\/pr:sharp\/rs:fit:\d+:\d+\/[\w-]+$/.test(address.pathname)
+      ? image
+      : { ...raw(404, {}), known: false };
+  if (address.hostname === 'storage2.openstreetcam.org') {
+    if (!address.pathname.includes(KV_SEQUENCE_ID))
+      return { ...raw(404, {}), known: false };
+    const archived = photos.some(
+      (photo) =>
+        photo.archived && address.pathname.endsWith(`_${photo.id}.jpg`),
+    );
+    // An archived photo's file is gone from storage: KartaView answers 409.
+    return archived ? { ...raw(409, {}), known: true } : image;
+  }
+  if (/^storage\d+\.openstreetcam\.org$/.test(address.hostname))
+    // The wrong host the API names: KartaView answers 404 there.
+    return { ...raw(404, {}), known: false };
+  if (address.hostname !== 'api.kartaview.org')
+    return { ...raw(404, {}), known: false };
+  const path = address.pathname;
+  const tile = path.match(
+    /^\/2\.0\/sequence\/tiles\/(\d+)\/(\d+)\/(\d+)\.json$/,
+  );
+  if (tile)
+    return {
+      ...raw(200, {
+        lines: tileLines(Number(tile[3]), Number(tile[1]), Number(tile[2])),
+      }),
+      known: true,
+    };
+  // Filtered coverage: KartaView filters only its PNG tiles.
+  const mask = path.match(
+    /^\/2\.0\/sequence\/tiles\/(\d+)\/(\d+)\/(\d+)\.png$/,
+  );
+  if (mask)
+    return {
+      status: 200,
+      contentType: 'image/png',
+      headers: CORS,
+      body: maskTilePng(
+        Number(mask[3]),
+        Number(mask[1]),
+        Number(mask[2]),
+        address.searchParams,
+      ),
+      known: true,
+    };
+  if (path === '/2.0/photo/') {
+    if (nearestLookups++ === 0)
+      return {
+        ...raw(429, {}),
+        headers: {
+          ...CORS,
+          'Retry-After': '0',
+          'Access-Control-Expose-Headers': 'Retry-After',
+        },
+        known: true,
+      };
+    const q = address.searchParams;
+    const at = { lat: Number(q.get('lat')), lon: Number(q.get('lng')) };
+    // Its own filter, as KartaView's: projection, and upload date.
+    const projection = q.get('projection');
+    const since = q.get('startDate');
+    const near = photos
+      .filter(
+        (photo) =>
+          (!projection || projection === (photo.isPano ? 'SPHERE' : 'PLANE')) &&
+          (!since || SHOT.slice(0, 10) >= since),
+      )
+      .map((photo) => ({ photo, metres: metresApart(at, photo) }))
+      .filter(({ metres }) => metres < 200)
+      .sort((a, b) => a.metres - b.metres)
+      .slice(0, Number(q.get('itemsPerPage')) || 10)
+      .map(({ photo, metres }) => ({
+        ...record(photo),
+        distance: metres.toFixed(2),
+      }));
+    return { ...ok({ data: near, hasMoreData: false }), known: true };
+  }
+  const one = path.match(/^\/2\.0\/photo\/(\d+)$/);
+  if (one) {
+    const photo = photos.find((p) => p.id === one[1]);
+    return photo
+      ? { ...ok({ data: record(photo) }), known: true }
+      : { ...raw(200, { status: { apiCode: 601 }, result: {} }), known: true };
+  }
+  const sequence = path.match(/^\/2\.0\/sequence\/(\d+)$/);
+  if (sequence)
+    return {
+      ...ok({
+        data: {
+          id: sequence[1],
+          countActivePhotos:
+            sequence[1] === KV_SEQUENCE_ID ? String(photos.length) : '0',
+        },
+      }),
+      known: true,
+    };
+  const page = path.match(/^\/2\.0\/sequence\/(\d+)\/photos$/);
+  if (page) {
+    const q = address.searchParams;
+    const size = Number(q.get('itemsPerPage')) || 100;
+    const number = Number(q.get('page')) || 1;
+    const rows = page[1] === KV_SEQUENCE_ID ? photos : [];
+    return {
+      ...ok({
+        data: rows.slice((number - 1) * size, number * size).map(record),
+        hasMoreData: number * size < rows.length,
+      }),
+      known: true,
+    };
+  }
+  return { ...raw(404, {}), known: false };
+}

scripts/fixtures/street-level/mapillaryGraph.mjs

@@ -2,8 +2,8 @@ import { readFileSync } from 'node:fs';
 
 /**
  * Mapillary Graph API and image CDN answered from fixtures, covering every
- * request the provider and MapillaryJS make while opening, stepping and
- * closing a photo, so the gate needs no network and no real token.
+ * request the provider and MapillaryJS make while opening and closing a
+ * photo, so the gate needs no network and no real token.
  *
  * No `merge_cc` or `sfm_cluster` means MapillaryJS never asks for a mesh or
  * cluster, and empty S2 cells mean no spatial edges, which the gate does not
@@ -21,7 +21,7 @@ export const PHOTO_LINE = Object.freeze({
   north: 38.591,
 });
 /** Metres between consecutive photos on the line (≥ the 3 m cone thinning). */
-export const PHOTO_SPACING_M = 30;
+const PHOTO_SPACING_M = 30;
 /** Fixture thumbnail host (answered, never reached). */
 export const THUMB_HOST = 'qa-fixture.mapillary.com';
 
@@ -181,18 +181,6 @@ export function answerMapillaryRequest({ method, url, images }) {
         : [];
       return { ...json(200, { data }), known: true };
     }
-    if (q.has('lat') && q.has('lng')) {
-      const at = { lat: Number(q.get('lat')), lon: Number(q.get('lng')) };
-      const radius = Math.min(50, Number(q.get('radius')) || 50);
-      const limit = Number(q.get('limit')) || 10;
-      // In no particular order, as the real API answers.
-      const data = photos
-        .filter((image) => metresApart(at, image) <= radius)
-        .reverse()
-        .slice(0, limit)
-        .map((image) => withFields(imageRecord(image), fields));
-      return { ...json(200, { data }), known: true };
-    }
     if (q.has('s2')) return { ...json(200, { data: [] }), known: true };
     return {
       ...json(400, { error: 'unsupported images query' }),

scripts/fixtures/street-level/panoramax.mjs

@@ -0,0 +1,283 @@
+import { tileBounds } from '../../../src/layers/streetLevel/tileMath.js';
+import { encodePanoramaxTile } from '../../../src/testSupport/panoramaxFixtures.mjs';
+import { metresApart, photoJpeg } from './mapillaryGraph.mjs';
+
+/**
+ * Panoramax's meta-catalogue and one instance's pictures answered from
+ * fixtures, so the gate's Panoramax steps need no network. Two sequences
+ * drive east along the same Paris street (PNX_LINE), their pictures
+ * interleaved, so a click on one line must open that line's picture, not
+ * the other's that is as near. Every seventh picture of the first is 360°.
+ * The meta-catalogue's pictures live on panoramax.openstreetmap.fr; the
+ * first sequence is CC BY-SA 4.0 by "Fixture Mapper", the second Licence
+ * Ouverte by an account named by an email address (never shown).
+ */
+
+export const PNX_SEQUENCES = Object.freeze([
+  'a1a1a1a1-0000-4000-8000-000000000001',
+  'b2b2b2b2-0000-4000-8000-000000000002',
+]);
+export const PNX_LINE = Object.freeze({
+  lat: 48.8874,
+  west: 2.3445,
+  east: 2.3545,
+});
+export const PNX_PARK = Object.freeze({
+  lon: 2.3495,
+  lat: 48.8874,
+  height: 700,
+  pitch: -1.4,
+});
+const PNX_CREATOR = 'Fixture Mapper';
+const PNX_SPACING_M = 10;
+const METRES_PER_DEG_LON = 111_320 * Math.cos((PNX_LINE.lat * Math.PI) / 180);
+const API = 'https://api.panoramax.xyz/api';
+const HOST = 'https://panoramax.openstreetmap.fr';
+
+const CORS = Object.freeze({ 'Access-Control-Allow-Origin': '*' });
+
+/** Calls answered since the last reset, by kind. */
+let asked = { search: 0, hd: 0 };
+
+export function resetPanoramaxFixture() {
+  asked = { search: 0, hd: 0 };
+}
+
+/** How many HD originals were downloaded since the last reset. */
+export function panoramaxHdDownloads() {
+  return asked.hd;
+}
+
+/**
+ * Both sequences' pictures, west to east. The second's sit 5 m along from
+ * the first's, on the same street.
+ */
+export function panoramaxPictures() {
+  const step = PNX_SPACING_M / METRES_PER_DEG_LON;
+  const count = Math.floor((PNX_LINE.east - PNX_LINE.west) / step);
+  return PNX_SEQUENCES.flatMap((sequenceId, s) =>
+    Array.from({ length: count }, (_, i) => ({
+      id: `${sequenceId.slice(0, 8)}-${String(i).padStart(4, '0')}`,
+      sequenceId,
+      index: i,
+      count,
+      lon: Number((PNX_LINE.west + (i + s / 2) * step).toFixed(7)),
+      lat: PNX_LINE.lat,
+      isPano: s === 0 && i % 7 === 3,
+      datetime:
+        s === 0 ? '2025-06-01T10:00:00+00:00' : '2023-03-01T09:00:00+00:00',
+    })),
+  );
+}
+
+function item(picture, pictures) {
+  const sibling = (delta) =>
+    pictures.find(
+      (p) =>
+        p.sequenceId === picture.sequenceId &&
+        p.index === picture.index + delta,
+    );
+  const link = (rel, other) =>
+    other
+      ? [
+          {
+            rel,
+            href: `${API}/collections/${other.sequenceId}/items/${other.id}`,
+          },
+        ]
+      : [];
+  const first = picture.sequenceId === PNX_SEQUENCES[0];
+  const files = `${HOST}/derivates/${picture.id}`;
+  return {
+    type: 'Feature',
+    id: picture.id,
+    collection: picture.sequenceId,
+    geometry: { type: 'Point', coordinates: [picture.lon, picture.lat] },
+    providers: [
+      {
+        name: first ? PNX_CREATOR : '[email protected]',
+        roles: ['producer'],
+      },
+    ],
+    properties: {
+      datetime: picture.datetime,
+      license: first ? 'CC-BY-SA-4.0' : 'etalab-2.0',
+      'view:azimuth': 90,
+      'pers:interior_orientation': picture.isPano
+        ? { field_of_view: 360, sensor_array_dimensions: [5760, 2880] }
+        : { field_of_view: 70, sensor_array_dimensions: [4032, 3024] },
+    },
+    assets: {
+      hd: { href: `${files}/hd.jpg` },
+      sd: { href: `${files}/sd.jpg` },
+      thumb: { href: `${files}/thumb.jpg` },
+    },
+    links: [
+      ...link('prev', sibling(-1)),
+      ...link('next', sibling(1)),
+      { rel: 'via', href: HOST },
+    ],
+  };
+}
+
+/** The tile `z/x/y` in the meta-catalogue's shape. */
+export function panoramaxTile(z, x, y) {
+  const tile = { x, y, z };
+  const { west, east, south, north } = tileBounds(x, y, z);
+  if (PNX_LINE.lat < south || PNX_LINE.lat > north) return new Uint8Array(0);
+  const from = Math.max(PNX_LINE.west, west);
+  const to = Math.min(PNX_LINE.east, east);
+  if (from >= to) return new Uint8Array(0);
+  if (z <= 5)
+    return encodePanoramaxTile(tile, {
+      grid: [{ lon: (from + to) / 2, lat: PNX_LINE.lat, pano: 30, flat: 170 }],
+    });
+  if (z < 7) return new Uint8Array(0);
+  const sequences = PNX_SEQUENCES.map((id, s) => ({
+    id,
+    type: s === 0 ? 'equirectangular' : 'flat',
+    date: s === 0 ? '2025-06-01' : '2023-03-01',
+    parts: [
+      [
+        [from, PNX_LINE.lat],
+        [to, PNX_LINE.lat],
+      ],
+    ],
+  }));
+  if (z < 15) return encodePanoramaxTile(tile, { sequences });
+  const pictures = panoramaxPictures()
+    .filter((p) => p.lon >= west && p.lon < east)
+    .map((p) => ({
+      id: p.id,
+      lon: p.lon,
+      lat: p.lat,
+      sequenceId: p.sequenceId,
+      heading: 90,
+      ts: p.datetime.replace('T', ' ').replace('+00:00', '+00'),
+      type: p.isPano ? 'equirectangular' : 'flat',
+    }));
+  return encodePanoramaxTile(tile, { sequences, pictures });
+}
+
+/** A call named by host, path shape and parameter names. */
+export function describePanoramaxCall(method, url) {
+  const keys = [...url.searchParams.keys()].sort();
+  const path = url.pathname
+    .replace(/\/map\/\d+\/\d+\/\d+\.mvt$/, '/map/{z}/{x}/{y}.mvt')
+    .replace(
+      /^\/derivates\/[\w-]+\/(sd|hd|thumb)\.jpg$/,
+      '/derivates/{id}/$1.jpg',
+    );
+  return `${method} ${url.hostname}${path}${keys.length ? `?${keys.join('&')}` : ''}`;
+}
+
+const json = (body) => ({
+  status: 200,
+  contentType: 'application/geo+json',
+  headers: CORS,
+  body: JSON.stringify(body),
+  known: true,
+});
+
+/**
+ * Answer one Panoramax request; `known` is false for a call no fixture
+ * covers, so the gate fails on a new one instead of missing it.
+ */
+export function answerPanoramaxRequest({ method, url }) {
+  const address = new URL(url);
+  if (method === 'OPTIONS')
+    return { status: 204, headers: CORS, body: '', known: true };
+  const pictures = panoramaxPictures();
+  if (address.hostname === new URL(HOST).hostname) {
+    const file = address.pathname.match(
+      /^\/derivates\/([\w-]+)\/(sd|hd|thumb)\.jpg$/,
+    );
+    if (!file || !pictures.some((p) => p.id === file[1]))
+      return { status: 404, headers: CORS, body: '', known: false };
+    if (file[2] === 'hd') asked.hd++;
+    return {
+      status: 200,
+      contentType: 'image/jpeg',
+      headers: CORS,
+      body: photoJpeg(),
+      known: true,
+    };
+  }
+  if (address.hostname !== 'api.panoramax.xyz')
+    return { status: 404, headers: CORS, body: '', known: false };
+  const tile = address.pathname.match(/^\/api\/map\/(\d+)\/(\d+)\/(\d+)\.mvt$/);
+  if (tile) {
+    const bytes = panoramaxTile(
+      Number(tile[1]),
+      Number(tile[2]),
+      Number(tile[3]),
+    );
+    return bytes.length
+      ? {
+          status: 200,
+          contentType: 'application/vnd.mapbox-vector-tile',
+          headers: CORS,
+          body: Buffer.from(bytes),
+          known: true,
+        }
+      : { status: 204, headers: CORS, body: '', known: true };
+  }
+  if (address.pathname !== '/api/search')
+    return { status: 404, headers: CORS, body: '', known: false };
+  asked.search++;
+  const q = address.searchParams;
+  if (q.has('ids')) {
+    const wanted = q.get('ids').split(',');
+    return json({
+      type: 'FeatureCollection',
+      features: pictures
+        .filter((p) => wanted.includes(p.id))
+        .map((p) => item(p, pictures)),
+    });
+  }
+  const filter = q.get('filter') || '';
+  const since = q.get('datetime')?.split('/')[0];
+  const kept = pictures
+    .filter(
+      (p) => !q.get('collections') || p.sequenceId === q.get('collections'),
+    )
+    .filter((p) =>
+      filter === 'field_of_view=360'
+        ? p.isPano
+        : filter === 'field_of_view<360'
+          ? !p.isPano
+          : true,
+    )
+    .filter((p) => !since || Date.parse(p.datetime) >= Date.parse(since));
+  // A box: every picture in it, nearest its centre first, as the live API
+  // returns them (roughly: the browser ranks them again).
+  if (q.has('bbox')) {
+    const [west, south, east, north] = q.get('bbox').split(',').map(Number);
+    const centre = { lon: (west + east) / 2, lat: (south + north) / 2 };
+    return json({
+      type: 'FeatureCollection',
+      features: kept
+        .filter(
+          (p) =>
+            p.lon >= west && p.lon <= east && p.lat >= south && p.lat <= north,
+        )
+        .map((p) => ({ p, metres: metresApart(centre, p) }))
+        .sort((a, b) => a.metres - b.metres || a.p.id.localeCompare(b.p.id))
+        .slice(0, Number(q.get('limit')) || 10)
+        .map(({ p }) => item(p, pictures)),
+    });
+  }
+  const [lon, lat] = (q.get('place_position') || '').split(',').map(Number);
+  const radius = Number((q.get('place_distance') || '0-50').split('-')[1]);
+  // As the API does, even at the widest tolerance: a place behind a
+  // picture (every one looks east) is not in it.
+  const facing = (p) => lon >= p.lon - 1e-7;
+  const near = kept
+    .filter(facing)
+    .map((p) => ({ p, metres: metresApart({ lon, lat }, p) }))
+    .filter(({ metres }) => metres <= radius)
+    .sort((a, b) => a.metres - b.metres)
+    .slice(0, Number(q.get('limit')) || 10)
+    .map(({ p }) => item(p, pictures));
+  return json({ type: 'FeatureCollection', features: near });
+}

scripts/format-scope.json

@@ -2,8 +2,11 @@
   ".prettierrc.json",
   "package.json",
   "scripts/format-scope.json",
+  "src/ui/styles/form-field.css",
+  "scripts/qa-form-fields.mjs",
   "scripts/package-boundaries.json",
   "scripts/format.mjs",
+  "scripts/qa-layer-visibility.mjs",
   "scripts/next-layer-state-token.mjs",
   "scripts/check-layer-state-tokens.mjs",
   "scripts/qa-layer-token-twochar.mjs",
@@ -18,6 +21,10 @@
   "src/tooling/panelStorageDocs.test.mjs",
   "src/tooling/packageBoundaries.test.mjs",
   "src/data/infrastructure.js",
+  "src/data/aircraftEmergency.js",
+  "src/data/aircraftEmergency.test.mjs",
+  "src/data/aircraftEmergencyAnalyst.test.mjs",
+  "scripts/qa-emergency-squawk.mjs",
   "src/data/infrastructure.test.mjs",
   "src/data/localGeojsonCore.js",
   "src/data/localGeojsonLod.js",
@@ -26,6 +33,8 @@
   "src/annotations/drawMode.test.mjs",
   "src/annotations/drawTool.js",
   "src/annotations/drawTool.test.mjs",
+  "src/data/geoFileImport.test.mjs",
+  "src/ui/geoFileImport.test.mjs",
   "src/annotations/adminOutline.test.mjs",
   "src/annotations/regionRing.test.mjs",
   "src/data/adminBoundaries.test.mjs",
@@ -40,9 +49,6 @@
   "scripts/qa-voice-auth-focus.mjs",
   "src/codexOauthRealtime.test.mjs",
   "src/voice/cloudVoiceAuth.test.mjs",
-  "scripts/qa-panel-resize.mjs",
-  "scripts/qa-panelDrag.mjs",
-  "src/tooling/panelResizeQa.test.mjs",
   "scripts/qa-terrain-429.mjs",
   "src/app/application.js",
   "src/app/application.test.mjs",
@@ -90,6 +96,7 @@
   "server/providers/space/launch-library.js",
   "src/data/spaceProviderRequests.js",
   "src/tooling/spaceProviders.test.mjs",
+  "src/tooling/ll2Integration.test.mjs",
   "server/providers/terrain.js",
   "server/providers/traffic.js",
   "server/providers/firms.js",
@@ -106,10 +113,16 @@
   "server/providers/cctv/cap.js",
   "server/providers/cctv/groundHeights.js",
   "server/providers/cctv/catalog.js",
+  "server/providers/cctv/lithuania.js",
+  "src/data/cctvLithuania.test.mjs",
+  "server/providers/cctv/taiwan.js",
+  "src/data/cctvTaiwan.test.mjs",
   "server/providers/cctv/constants.js",
   "server/providers/cctv/media.js",
   "server/providers/cctv/normalize.js",
+  "src/data/cctvMissingNumbers.test.mjs",
   "server/providers/cctv/sources.js",
+  "src/data/cctvSourcePins.test.mjs",
   "server/providers/radio.js",
   "server/providers/radio/catalog.js",
   "server/providers/radio/constants.js",
@@ -172,7 +185,6 @@
   "src/ui/panelRails.js",
   "src/ui/leftPanelRail.js",
   "src/ui/rightPanelRail.js",
-  "src/ui/panelResize.test.mjs",
   "src/ui/panelMeasurement.js",
   "src/ui/panelRailGeometry.js",
   "src/ui/panelRails.test.mjs",
@@ -182,7 +194,11 @@
   "src/ui/visualInput.js",
   "src/ui/visualInput.test.mjs",
   "scripts/qa-visual-input.mjs",
+  "scripts/qa-scope-hud.mjs",
+  "scripts/qa-segmented-controls.mjs",
   "src/ui/displayControls.js",
+  "src/ui/segmentedControl.test.mjs",
+  "src/ui/styles/segmented-control.css",
   "src/ui/displayControls.test.mjs",
   "src/ui/cameraOrientationControls.js",
   "src/ui/cameraOrientationControls.test.mjs",
@@ -196,9 +212,11 @@
   "src/styles/thermal.js",
   "src/styles/anime.js",
   "src/styles/noir.js",
-  "src/styles/snow.js",
   "scripts/qa-visual-effects.mjs",
   "scripts/qa-draw-tool.mjs",
+  "scripts/qa-geo-import.mjs",
+  "scripts/qa-geo-import-regressions.mjs",
+  "scripts/qa-geo-import-large.mjs",
   "src/ui/mapSource.js",
   "src/ui/mapSourceControls.js",
   "src/ui/mapSourceControls.test.mjs",
@@ -267,11 +285,11 @@
   "src/ui/scenePresentation.js",
   "src/ui/sceneControls.test.mjs",
   "scripts/qa-scene-controls.mjs",
-  "src/ui.js",
-  "src/standalone/ui.js",
+  "scripts/qa-action-buttons.mjs",
   "src/ui/applicationShell.js",
   "src/ui/panelLayoutController.js",
   "src/ui/panelPositionControls.js",
+  "src/ui/panelPositionControls.test.mjs",
   "src/ui/recordingControls.js",
   "src/ui/shellElements.js",
   "src/ui/shellFeedback.js",
@@ -289,6 +307,8 @@
   "src/ui/styles/status.css",
   "src/ui/styles/layers.css",
   "src/ui/styles/controls.css",
+  "src/ui/styles/slider.css",
+  "src/ui/styles/action-button.css",
   "src/ui/styles/cctv.css",
   "src/ui/styles/foundation.css",
   "src/ui/styles/first-run.css",
@@ -357,6 +377,12 @@
   "src/layers/vessels/tracking.js",
   "src/layers/vessels/ownership.test.mjs",
   "src/data/earthquakes.js",
+  "src/app/layers/airQuality.js",
+  "src/layers/airQuality/index.js",
+  "src/layers/airQuality/model.js",
+  "src/layers/airQuality/model.test.mjs",
+  "src/layers/airQuality/ownership.test.mjs",
+  "src/layers/airQuality/source.js",
   "src/layers/earthquakes/index.js",
   "src/layers/earthquakes/model.js",
   "src/layers/earthquakes/source.js",
@@ -427,7 +453,9 @@
   "src/data/satellites.js",
   "src/data/rocketLaunches.js",
   "src/layers/satellites/source.test.mjs",
+  "src/layers/satellites/stale.test.mjs",
   "src/layers/launches/source.test.mjs",
+  "src/layers/launches/ingestion.test.mjs",
   "src/layers/installations/lifecycle.js",
   "src/layers/installations/viewport.js",
   "src/layers/installations/controls.js",
@@ -490,7 +518,6 @@
   "src/layers/bikeshare/selection.js",
   "src/data/traffic.js",
   "src/data/bikeshare.js",
-  "src/data/flowTiles.js",
   "src/layers/traffic/source.test.mjs",
   "src/layers/bikeshare/source.test.mjs",
   "src/layers/bikeshare/proxyRoute.test.mjs",
@@ -531,11 +558,16 @@
   "src/data/cctvEstonia.test.mjs",
   "src/data/cctvWarendorf.test.mjs",
   "src/data/cctvCalgary.test.mjs",
+  "src/data/cctvCataloniaSource.test.mjs",
+  "src/data/cctvHk.test.mjs",
   "src/data/cctvVegvesen.test.mjs",
   "src/data/cctvA22.test.mjs",
+  "src/data/cctvNyc.test.mjs",
   "src/data/cctvNswSource.test.mjs",
   "src/data/cctvTxdotSource.test.mjs",
   "src/layers/cctv/source.test.mjs",
+  "src/layers/cctv/frames.test.mjs",
+  "src/layers/cctv/rendering.test.mjs",
   "src/data/alprCameras.js",
   "src/data/alprCameras.test.mjs",
   "src/data/dataCredits.test.mjs",
@@ -616,9 +648,9 @@
   "src/voice/control.js",
   "src/voice/realtimeBackend.js",
   "src/voice/realtimeBackend.test.mjs",
+  "src/agent/worldPacket.test.mjs",
   "src/voice/layerSummary.js",
   "build/application-html.js",
-  "src/app/sourceSlot.js",
   "src/app/sources.js",
   "src/ui/composition.js",
   "src/services/application.js",
@@ -713,6 +745,7 @@
   "src/voice/session.test.mjs",
   "src/layers/alpr/records.js",
   "src/layers/earthquakes/records.js",
+  "src/layers/earthquakes/records.test.mjs",
   "src/sources/sourceSlot.js",
   "src/data/feedState.js",
   "src/app/localGeojsonServices.js",
@@ -725,6 +758,7 @@
   "src/search/nominatim.js",
   "src/search/nominatim.test.mjs",
   "src/sources/httpBody.js",
+  "src/sources/httpBody.test.mjs",
   "src/sources/overpass.js",
   "src/sources/nominatim.js",
   "server/providers/transit.js",
@@ -827,6 +861,28 @@
   "server/providers/firePerimeters.js",
   "src/data/cyclonesProxy.test.mjs",
   "src/data/firePerimetersProxy.test.mjs",
+  "server/providers/gnssIntegrity.js",
+  "src/data/gnssIntegrityProxy.test.mjs",
+  "src/app/layers/gnss.js",
+  "src/layers/gnss/index.js",
+  "src/layers/gnss/records.js",
+  "src/layers/gnss/source.js",
+  "src/layers/gnss/records.test.mjs",
+  "src/layers/gnss/source.test.mjs",
+  "src/layers/gnss/ownership.test.mjs",
+  "scripts/qa-gnss.mjs",
+  "server/providers/ghostMaps.js",
+  "server/providers/ghostMaps.test.mjs",
+  "src/app/layers/ghostMaps.js",
+  "src/layers/ghostMaps/index.js",
+  "src/layers/ghostMaps/catalog.js",
+  "src/layers/ghostMaps/kml.js",
+  "src/layers/ghostMaps/records.js",
+  "src/layers/ghostMaps/source.js",
+  "src/layers/ghostMaps/catalog.test.mjs",
+  "src/layers/ghostMaps/records.test.mjs",
+  "src/layers/ghostMaps/lifecycle.test.mjs",
+  "scripts/qa-ghostmaps.mjs",
   "src/layers/cyclones/index.js",
   "src/layers/cyclones/rendering.js",
   "src/layers/cyclones/labels.js",
@@ -843,9 +899,13 @@
   "src/layers/weather/imageryHost.test.mjs",
   "src/sdr/adsbDecoder.test.mjs",
   "src/sdr/controller.test.mjs",
+  "src/sdr/decoderDiagnostics.test.mjs",
   "src/sdr/gain.test.mjs",
+  "src/sdr/readPipeline.diag.test.mjs",
+  "src/sdr/sdrAudioWorklet.test.mjs",
   "src/sdr/spectrum.test.mjs",
   "src/sdr/usbDevices.test.mjs",
+  "src/sdr/workerAdmission.test.mjs",
   "src/sources/adsbRecords.test.mjs",
   "src/layers/localAdsb/index.test.mjs",
   "src/ui/localSdrControls.test.mjs",
@@ -871,61 +931,102 @@
   "src/ui/streetLevelPresentation.test.mjs",
   "src/app/layers/streetLevel.js",
   "src/tooling/mapillaryProvider.test.mjs",
+  "src/app/layers/streetLevel.test.mjs",
+  "src/data/idSwitches.js",
+  "src/layers/streetLevel/credits.js",
+  "src/layers/streetLevel/providers/mapillary/index.js",
+  "src/layers/streetLevel/providers/mapillary/provider.test.mjs",
+  "src/layers/streetLevel/params.js",
+  "src/layers/streetLevel/params.test.mjs",
+  "src/layers/streetLevel/pickRouter.js",
+  "src/layers/streetLevel/pickRouter.test.mjs",
+  "src/layers/streetLevel/providerSwitches.test.mjs",
+  "src/layers/streetLevel/registry.js",
+  "src/layers/streetLevel/registry.test.mjs",
+  "src/layers/streetLevel/uiState.js",
+  "src/layers/streetLevel/uiState.test.mjs",
   "src/layers/streetLevel/providers/mapillary/source.test.mjs",
   "src/streetLevelMarkup.test.mjs",
   "src/layers/streetLevel/index.js",
   "src/layers/streetLevel/policy.js",
   "src/layers/streetLevel/filter.js",
-  "src/layers/streetLevel/registry.js",
-  "src/layers/streetLevel/params.js",
-  "src/layers/streetLevel/pickRouter.js",
-  "src/layers/streetLevel/uiState.js",
-  "src/layers/streetLevel/groundCast.js",
-  "src/layers/streetLevel/meshSampler.js",
   "src/layers/streetLevel/view.js",
   "src/layers/streetLevel/marker.js",
-  "src/layers/streetLevel/cameraFollow.js",
-  "src/layers/streetLevel/credits.js",
+  "src/layers/streetLevel/cameraFraming.js",
   "src/layers/streetLevel/viewerHost.js",
-  "src/layers/streetLevel/providers/mapillary/index.js",
   "src/layers/streetLevel/state.js",
-  "src/layers/streetLevel/providers/mapillary/policy.js",
-  "src/layers/streetLevel/providers/mapillary/coverage.js",
-  "src/layers/streetLevel/providers/mapillary/sequences.js",
+  "src/layers/streetLevel/lineCoverage.js",
+  "src/layers/streetLevel/sequenceCones.js",
   "src/layers/streetLevel/glyphs.js",
   "src/layers/streetLevel/providers/mapillary/decode.js",
   "src/layers/streetLevel/tileMath.js",
   "src/layers/streetLevel/selection.js",
   "src/layers/streetLevel/providers/mapillary/viewer.js",
   "src/layers/streetLevel/providers/mapillary/source.js",
+  "src/layers/streetLevel/groundClick.js",
+  "src/layers/streetLevel/providers/google/index.js",
+  "src/layers/streetLevel/providers/google/policy.js",
+  "src/layers/streetLevel/providers/google/viewer.js",
+  "src/layers/streetLevel/providers/google/mapsLoader.js",
+  "src/layers/streetLevel/groundClick.test.mjs",
+  "src/layers/streetLevel/providers/google/provider.test.mjs",
+  "src/layers/streetLevel/providers/google/viewer.test.mjs",
+  "src/layers/streetLevel/providers/google/mapsLoader.test.mjs",
+  "src/layers/streetLevel/providers/kartaview/index.js",
+  "src/layers/streetLevel/providers/kartaview/policy.js",
+  "src/layers/streetLevel/providers/kartaview/source.js",
+  "src/layers/streetLevel/providers/kartaview/decode.js",
+  "src/layers/streetLevel/providers/kartaview/viewer.js",
+  "src/layers/streetLevel/panorama.js",
+  "src/layers/streetLevel/providers/kartaview/policy.test.mjs",
+  "src/layers/streetLevel/providers/kartaview/decode.test.mjs",
+  "src/layers/streetLevel/providers/kartaview/source.test.mjs",
+  "src/layers/streetLevel/panorama.test.mjs",
+  "src/layers/streetLevel/providers/kartaview/viewer.test.mjs",
+  "src/layers/streetLevel/providers/kartaview/provider.test.mjs",
+  "src/layers/streetLevel/providers/panoramax/index.js",
+  "src/layers/streetLevel/providers/panoramax/policy.js",
+  "src/layers/streetLevel/providers/panoramax/source.js",
+  "src/layers/streetLevel/providers/panoramax/decode.js",
+  "src/layers/streetLevel/providers/panoramax/viewer.js",
+  "src/layers/streetLevel/photoViewer.js",
+  "src/layers/streetLevel/limiter.js",
+  "src/layers/streetLevel/imageSize.js",
+  "src/layers/streetLevel/tileCache.js",
+  "src/layers/streetLevel/providers/panoramax/policy.test.mjs",
+  "src/layers/streetLevel/providers/panoramax/decode.test.mjs",
+  "src/layers/streetLevel/providers/panoramax/source.test.mjs",
+  "src/layers/streetLevel/providers/panoramax/viewer.test.mjs",
+  "src/layers/streetLevel/providers/panoramax/provider.test.mjs",
+  "src/testSupport/panoramaxFixtures.mjs",
+  "src/layers/streetLevel/photoViewer.test.mjs",
+  "src/layers/streetLevel/limiter.test.mjs",
+  "src/layers/streetLevel/imageSize.test.mjs",
+  "src/layers/streetLevel/lineCoverage.test.mjs",
+  "src/testSupport/kartaViewFakes.mjs",
+  "src/testSupport/googleStreetViewFakes.mjs",
   "server/providers/mapillary.js",
-  "server/providers/mapillary/routes.js",
-  "server/providers/mapillary/constants.js",
   "server/providers/mapillary/tiles.js",
   "server/providers/mapillary/trim.js",
   "src/layers/streetLevel/tileMath.test.mjs",
   "scripts/qa-street-level.mjs",
   "src/tooling/streetLevelQa.test.mjs",
   "scripts/qa-browserEvidence.mjs",
+  "scripts/qa-chrome.mjs",
+  "src/qaChrome.test.mjs",
   "scripts/fixtures/street-level/mapillaryGraph.mjs",
+  "scripts/fixtures/street-level/kartaView.mjs",
+  "scripts/fixtures/street-level/panoramax.mjs",
   "src/layers/streetLevel/filter.test.mjs",
-  "src/layers/streetLevel/registry.test.mjs",
-  "src/layers/streetLevel/params.test.mjs",
-  "src/layers/streetLevel/pickRouter.test.mjs",
-  "src/layers/streetLevel/uiState.test.mjs",
-  "src/layers/streetLevel/groundCast.test.mjs",
-  "src/layers/streetLevel/meshSampler.test.mjs",
   "src/layers/streetLevel/view.test.mjs",
-  "src/layers/streetLevel/providers/mapillary/provider.test.mjs",
+  "src/layers/streetLevel/providers/mapillary/mapillary.test.mjs",
   "src/layers/streetLevel/providers/mapillary/decode.test.mjs",
-  "src/layers/streetLevel/providers/mapillary/coverage.test.mjs",
   "src/layers/streetLevel/providers/mapillary/coverageFixture.mjs",
-  "src/layers/streetLevel/cameraFollow.test.mjs",
+  "src/layers/streetLevel/cameraFraming.test.mjs",
   "src/ui/streetLevelControls.test.mjs",
-  "src/ui/panelDock.test.mjs",
   "src/layers/streetLevel/marker.test.mjs",
   "src/layers/streetLevel/viewerHost.test.mjs",
-  "src/layers/streetLevel/providers/mapillary/sequences.test.mjs",
+  "src/layers/streetLevel/sequenceCones.test.mjs",
   "src/layers/streetLevel/selection.test.mjs",
   "src/layers/streetLevel/index.test.mjs",
   "scripts/qa-overpass-offload.mjs",
@@ -942,6 +1043,7 @@
   "scripts/qa-context-arrivals.mjs",
   "src/tools/catalog.test.mjs",
   "src/tools/area.test.mjs",
+  "src/tools/results.test.mjs",
   "src/tools/queries/queries.test.mjs",
   "src/tools/mcp/mcp.test.mjs",
   "src/tools/localServer.test.mjs",
@@ -969,5 +1071,52 @@
   "src/tools/views.test.mjs",
   "src/app/embed.test.mjs",
   "src/tools/globePanel.test.mjs",
-  "src/costEndpointThrottle.test.mjs"
+  "src/costEndpointThrottle.test.mjs",
+  "src/sources/gbfsStations.test.mjs",
+  "scripts/qa-gbfs-names.mjs",
+  "scripts/generate-icons.mjs",
+  "src/tooling/webAppIcons.test.mjs",
+  "src/ui/flyToDataSource.js",
+  "src/ui/flyToDataSource.test.mjs",
+  "scripts/assemble-changelog.mjs",
+  "src/tooling/changelogFragments.test.mjs",
+  "src/data/gbfsProxyRateLimit.test.mjs",
+  "src/data/routeSegment.test.mjs",
+  "src/terrainHeightsBounds.test.mjs",
+  "scripts/build-bright-stars.mjs",
+  "scripts/build-milky-way.mjs",
+  "src/sky/stars.test.mjs",
+  "src/sky/starrySky.test.mjs",
+  "src/tooling/skyAssets.test.mjs",
+  "src/tooling/skyAssets.paintOut.test.mjs",
+  "scripts/qa-anime-sky.mjs",
+  "scripts/qa-sky-model-lighting.mjs",
+  "server/providers/overpass/requestAdmission.test.mjs",
+  "src/tooling/trackArrivalObservation.test.mjs",
+  "src/ui/styles/status-badge.css",
+  "src/ui/statusBadge.test.mjs",
+  "src/ui/cctvBadges.test.mjs",
+  "scripts/qa-status-badges.mjs",
+  "src/dockerTrustedPeers.test.mjs",
+  "src/cameraGlobeRotation.test.mjs",
+  "src/voice/globeResetConfirmation.test.mjs",
+  "src/hudDms.test.mjs",
+  "src/hudSummaryGate.test.mjs",
+  "src/voice/hudPlaceLabels.test.mjs",
+  "src/voice/panel/preferences.test.mjs",
+  "src/voice/panel/host.test.mjs",
+  "src/voice/panel/manualPanel.test.mjs",
+  "src/voice/panel/nativeActivity.test.mjs",
+  "src/voice/panel/inactivity.test.mjs",
+  "src/voice/panel/actionObserver.test.mjs",
+  "src/voice/panel/testDom.mjs",
+  "src/voice/realtimeCostPanel.test.mjs",
+  "docs/SHARE-LINK-FORMAT.md",
+  "src/share/wire.test.mjs",
+  "src/share/viewCodec.test.mjs",
+  "src/share/legacyShareState.test.mjs",
+  "src/testSupport/shareViewFixtures.mjs",
+  "src/ui/shareLinks.test.mjs",
+  "src/ui/shareButton.test.mjs",
+  "src/share/shareLinkPath.test.mjs"
 ]

scripts/generate-icons.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+// Renders the home-screen and favicon rasters from `public/logo.svg`.
+//
+// Re-run after changing the logo: `node scripts/generate-icons.mjs`. The output
+// is committed, because the install icons have to exist in a plain `vite build`
+// and contributors should not need an image toolchain to ship the app.
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import sharp from 'sharp';
+
+const REPO_ROOT = path.resolve(
+  fileURLToPath(new URL('.', import.meta.url)),
+  '..',
+);
+const LOGO = path.join(REPO_ROOT, 'public', 'logo.svg');
+const OUT_DIR = path.join(REPO_ROOT, 'public', 'icons');
+
+/** `--bg-dark` from src/ui/styles/foundation.css, so the tile matches the app. */
+const BACKGROUND = '#0a0a0f';
+
+/**
+ * Fraction of the canvas the mark is allowed to occupy.
+ *
+ * A maskable icon may be cropped to a circle inscribed in the middle 80% of the
+ * square, so its mark stays well inside that circle; the other icons are shown
+ * as drawn and only need optical breathing room.
+ */
+const INSET = { normal: 0.78, maskable: 0.54 };
+
+const TARGETS = [
+  { file: 'icon-32.png', size: 32, inset: INSET.normal },
+  { file: 'icon-180.png', size: 180, inset: INSET.normal },
+  { file: 'icon-192.png', size: 192, inset: INSET.normal },
+  { file: 'icon-512.png', size: 512, inset: INSET.normal },
+  { file: 'icon-512-maskable.png', size: 512, inset: INSET.maskable },
+];
+
+/** Fit the logo inside `size * inset` and centre it on an opaque square. */
+async function render(svg, { size, inset }) {
+  const box = Math.round(size * inset);
+  // The logo's viewBox is wider than it is tall, so `contain` bounds it by
+  // width and leaves the vertical padding uneven — centring is done by the
+  // composite below rather than by the resize.
+  const mark = await sharp(svg, { density: 384 })
+    .resize(box, box, {
+      fit: 'contain',
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+    .png()
+    .toBuffer();
+  return sharp({
+    create: {
+      width: size,
+      height: size,
+      channels: 4,
+      background: BACKGROUND,
+    },
+  })
+    .composite([{ input: mark, gravity: 'centre' }])
+    .png({ compressionLevel: 9 })
+    .toBuffer();
+}
+
+const svg = await readFile(LOGO);
+await mkdir(OUT_DIR, { recursive: true });
+for (const target of TARGETS) {
+  await writeFile(path.join(OUT_DIR, target.file), await render(svg, target));
+  console.log(`icons: wrote ${target.file} (${target.size}px)`);
+}

scripts/i18n.mjs

@@ -0,0 +1,626 @@
+// Keeps the locale catalogs in step with the code.
+//
+//   npm run i18n                     check every catalog and find unmarked UI text
+//   npm run i18n -- --prune          also drop entries the code no longer uses
+//   npm run i18n -- --missing ru     print what ru lacks, as JSON to translate
+//
+// A translation left as the English fails unless src/i18n/same-as-english.json
+// lists it.
+//
+// Messages are the English literals passed to t(), tn() and msg() in src/,
+// plus the markup opted in with data-i18n* in src/ui/templates and index.html.
+// It also lists UI text that is not marked at all (see findUnmarked).
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LOCALES_DIR = path.join(ROOT, 'src/i18n/locales');
+const SAME_AS_ENGLISH = path.join(ROOT, 'src/i18n/same-as-english.json');
+
+const STRING = String.raw`'(?:\\.|[^'\\\n])*'|"(?:\\.|[^"\\\n])*"|\`(?:\\.|[^\`\\$])*\``;
+const CALL = new RegExp(
+  String.raw`\bt\(\s*(${STRING})\s*,\s*\{\s*context:\s*(${STRING})|\b(t|msg)\(\s*(${STRING})|\btn\(\s*[^,]+?,\s*(${STRING})\s*,\s*(${STRING})`,
+  'g',
+);
+
+function unquote(literal) {
+  const body = literal.slice(1, -1);
+  return body.replace(
+    /\\(u\{[0-9a-fA-F]+\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|.)/gs,
+    (_, esc) => {
+      if (esc[0] === 'u' || esc[0] === 'x') {
+        return String.fromCodePoint(parseInt(esc.replace(/[ux{}]/g, ''), 16));
+      }
+      return { n: '\n', t: '\t', r: '\r' }[esc] ?? esc;
+    },
+  );
+}
+
+const ENTITIES = {
+  amp: '&',
+  lt: '<',
+  gt: '>',
+  quot: '"',
+  apos: "'",
+  nbsp: ' ',
+};
+function decodeHtml(text) {
+  return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (all, name) => {
+    if (name[0] === '#') {
+      const hex = name[1] === 'x' || name[1] === 'X';
+      return String.fromCodePoint(
+        parseInt(name.slice(hex ? 2 : 1), hex ? 16 : 10),
+      );
+    }
+    return ENTITIES[name.toLowerCase()] ?? all;
+  });
+}
+
+const normalize = (text) => text.replace(/\s+/g, ' ').trim();
+
+function trackedFiles(...pathspecs) {
+  return (
+    execFileSync(
+      'git',
+      [
+        'ls-files',
+        '--cached',
+        '--others',
+        '--exclude-standard',
+        '--',
+        ...pathspecs,
+      ],
+      {
+        cwd: ROOT,
+        encoding: 'utf8',
+      },
+    )
+      .split('\n')
+      .filter(Boolean)
+      // The index still lists a file moved or deleted without git mv / git rm.
+      .filter((file) => existsSync(path.join(ROOT, file)))
+  );
+}
+
+/**
+ * Every message the code can ask for.
+ * @returns {Map<string, {plural: boolean, one?: string, where: string}>}
+ */
+export function extractMessages() {
+  const messages = new Map();
+  const add = (text, where, plural = null) => {
+    if (!text) return;
+    const known = messages.get(text);
+    if (known && Boolean(known.plural) !== Boolean(plural)) {
+      throw new Error(
+        `${where}: "${text}" is used both as plural and plain text (also ${known.where})`,
+      );
+    }
+    if (!known)
+      messages.set(text, { plural: Boolean(plural), one: plural?.one, where });
+  };
+
+  const sources = sourceFiles();
+  for (const file of sources) {
+    const source = readFileSync(path.join(ROOT, file), 'utf8');
+    for (const match of source.matchAll(CALL)) {
+      const line = source.slice(0, match.index).split('\n').length;
+      const where = `${file}:${line}`;
+      if (match[1]) {
+        add(`${unquote(match[2])}|${unquote(match[1])}`, where);
+      } else if (match[4]) {
+        if (match[4][0] === '`' && match[4].includes('${')) continue;
+        add(unquote(match[4]), where);
+      } else {
+        add(unquote(match[6]), where, { one: unquote(match[5]) });
+      }
+    }
+  }
+
+  const markup = trackedFiles('index.html', 'src/ui/templates/*.html');
+  const TAG = /<([a-zA-Z][\w-]*)(\s[^>]*?)\/?>([^<]*)/gs;
+  for (const file of markup) {
+    const html = readFileSync(path.join(ROOT, file), 'utf8');
+    for (const [, tag, attrs, text] of html.matchAll(TAG)) {
+      const where = `${file} <${tag}>`;
+      if (/\sdata-i18n(\s|=|$)/.test(attrs)) {
+        const context = attrs.match(/\sdata-i18n-context="([^"]*)"/);
+        const message = normalize(decodeHtml(text));
+        add(context ? `${decodeHtml(context[1])}|${message}` : message, where);
+      }
+      for (const [, name] of attrs.matchAll(
+        /\sdata-i18n-(title|aria-label|placeholder)\b/g,
+      )) {
+        const value = attrs.match(new RegExp(String.raw`\s${name}="([^"]*)"`));
+        if (value) add(decodeHtml(value[1]), where);
+        else
+          throw new Error(
+            `${where}: data-i18n-${name} without a ${name} attribute`,
+          );
+      }
+    }
+  }
+  return messages;
+}
+
+const hasWords = (text) => /[A-Za-z]{2,}/.test(text);
+const lineAt = (source, index) => source.slice(0, index).split('\n').length;
+
+const VOID_TAGS = new Set(
+  'area base br col embed hr img input link meta source track wbr'.split(' '),
+);
+const SKIP_TAGS = new Set(['script', 'style', 'svg', 'code', 'pre', 'title']);
+
+/**
+ * User-visible markup text without data-i18n*. Skipped, with everything
+ * inside: translate="no" (text that stays as is, as in HTML),
+ * data-i18n-runtime (code sets this text through t()), and icons
+ * (aria-hidden, Material Symbols).
+ */
+export function unmarkedMarkup(file, html) {
+  const found = [];
+  const source = html.replace(/<!--[\s\S]*?-->|<![^>]*>/g, (c) =>
+    c.replace(/[^\n]/g, ' '),
+  );
+  const TOKEN =
+    /<(\/?)([a-zA-Z][\w-]*)((?:"[^"]*"|'[^']*'|[^>"'])*?)(\/?)>|([^<]+)/g;
+  const stack = [];
+  const skipping = () => stack.at(-1)?.skip === true;
+  for (const match of source.matchAll(TOKEN)) {
+    const [, closing, rawTag, attrs = '', selfClosing, text] = match;
+    if (text !== undefined) {
+      const top = stack.at(-1);
+      const value = normalize(decodeHtml(text));
+      if (!skipping() && hasWords(value) && !top?.marked)
+        found.push({
+          where: `${file}:${lineAt(source, match.index)}`,
+          text: value,
+        });
+      continue;
+    }
+    const tag = rawTag.toLowerCase();
+    if (closing) {
+      const at = stack.map((entry) => entry.tag).lastIndexOf(tag);
+      if (at >= 0) stack.length = at;
+      continue;
+    }
+    const skip =
+      skipping() ||
+      SKIP_TAGS.has(tag) ||
+      /\stranslate="no"/.test(attrs) ||
+      /\sdata-i18n-runtime\b/.test(attrs) ||
+      /\saria-hidden="true"/.test(attrs) ||
+      /class="[^"]*material-symbols/.test(attrs);
+    if (!skip) {
+      for (const [, name, value] of attrs.matchAll(
+        /\s(title|aria-label|placeholder)="([^"]*)"/g,
+      )) {
+        if (
+          hasWords(value) &&
+          !new RegExp(String.raw`\sdata-i18n-${name}\b`).test(attrs)
+        )
+          found.push({
+            where: `${file}:${lineAt(source, match.index)}`,
+            text: `${name}="${decodeHtml(value)}"`,
+          });
+      }
+    }
+    if (!VOID_TAGS.has(tag) && !selfClosing)
+      stack.push({ tag, skip, marked: /\sdata-i18n(\s|=|$)/.test(attrs) });
+  }
+  return found;
+}
+
+// Where a string becomes UI text. Each pattern ends where the value starts.
+const JS_SINKS = [
+  /\.(?:textContent|innerText|innerHTML|outerHTML|title|placeholder|ariaLabel)\s*=(?!=)\s*/g,
+  /\bsetAttribute\(\s*['"](?:title|aria-label|aria-valuetext|placeholder|alt)['"]\s*,\s*/g,
+  /\b(?:createTextNode|insertAdjacentText)\(\s*(?:['"][a-z]+['"]\s*,\s*)?/g,
+  /\binsertAdjacentHTML\(\s*['"][a-z]+['"]\s*,\s*/g,
+  // Also showToast?.(…) and this._showToast(…).
+  /\b_?(?:showToast|toast|setHint|announce|say)(?:\?\.)?\(\s*/g,
+  // `status` values are often codes ('ok', 'auth-failed'); visibleText drops
+  // those, so only readable text is reported. A name right after `?` is a
+  // ternary branch (`ok ? status : 'Fallback'`), not a property.
+  /(?:^|[{,\s])(?<!\?\s*)(?:label|title|tooltip|placeholder|hint|ariaLabel|accessibilityLabel|caption|subtitle|kicker|emptyText|blurb|countLabel|status|loadingLabel|statusMessage)\s*:\s*/gm,
+];
+// Layer status set by assignment: this._error = …, stats.lastError = …,
+// error = … (a layer factory keeps its status in `let error`). Not checked:
+// the declaration itself (`const error = …`, `let status = …`) and a default
+// value in a parameter list or destructuring (see defaultValue).
+const ASSIGNMENT_SINK =
+  /(?<![\w$])(?<!\b(?:const|let|var)\s+)_?(?:error|lastError|loadingLabel|statusMessage|status)\s*(?:\?\?|\|\|)?=(?![=>])\s*/g;
+JS_SINKS.push(ASSIGNMENT_SINK);
+
+/**
+ * Whether `name = value` at `nameStart` is a default (`(status = 'idle') =>`,
+ * `const { error = '…' } = options`): it follows `(`, `[`, `{` or `,` and its
+ * value ends at `,` or a closing bracket. An assignment statement ends at `;`.
+ */
+function defaultValue(source, nameStart, valueStart) {
+  const before = source.slice(0, nameStart).trimEnd().at(-1);
+  if (!before || !'([{,'.includes(before)) return false;
+  const end = valueStart + expressionAt(source, valueStart).length;
+  const after = source.slice(end).trimStart()[0];
+  return Boolean(after) && ',)]}'.includes(after);
+}
+const MARKERS = /\b(?:t|tn|msg)\(/y;
+
+/** The expression starting at `start`, up to its end at bracket depth 0. */
+function expressionAt(source, start) {
+  let depth = 0;
+  let i = start;
+  for (; i < source.length; i++) {
+    const c = source[i];
+    if (c === "'" || c === '"' || c === '`') {
+      i = skipString(source, i);
+      continue;
+    }
+    if ('([{'.includes(c)) depth++;
+    else if (')]}'.includes(c)) {
+      if (depth === 0) break;
+      depth--;
+    } else if (depth === 0 && (c === ';' || c === ',')) break;
+    else if (depth === 0 && c === '\n') {
+      const next = source.slice(i + 1).match(/^\s*(\S\S?)/)?.[1] ?? '';
+      const before = source.slice(start, i).trimEnd().at(-1) ?? '';
+      if (!/^(\?|:|\+|\.|&&|\|\|)/.test(next) && !/[?:+=&|(,]/.test(before))
+        break;
+    }
+  }
+  return source.slice(start, i);
+}
+
+function skipString(source, i) {
+  const quote = source[i];
+  for (let j = i + 1; j < source.length; j++) {
+    if (source[j] === '\\') j++;
+    else if (quote === '`' && source[j] === '$' && source[j + 1] === '{') {
+      let depth = 1;
+      for (j += 2; j < source.length && depth; j++) {
+        if (source[j] === '{') depth++;
+        else if (source[j] === '}') depth--;
+        else if ('\'"`'.includes(source[j])) j = skipString(source, j);
+      }
+      j--;
+    } else if (source[j] === quote) return j;
+    else if (quote !== '`' && source[j] === '\n') return j;
+  }
+  return source.length;
+}
+
+/** String literals that sit in value position: not inside any call or index,
+ * not compared, and not already passed to t/tn/msg. */
+function valueLiterals(expression) {
+  const literals = [];
+  let callDepth = 0;
+  const stack = [];
+  for (let i = 0; i < expression.length; i++) {
+    const c = expression[i];
+    if (c === '(' || c === '[') {
+      const isCall = c === '[' || /[\w$\]\)]\s*$/.test(expression.slice(0, i));
+      stack.push(isCall);
+      if (isCall) callDepth++;
+      continue;
+    }
+    if (c === ')' || c === ']') {
+      if (stack.pop()) callDepth--;
+      continue;
+    }
+    MARKERS.lastIndex = i;
+    if (MARKERS.test(expression)) {
+      stack.push(true);
+      callDepth++;
+      i = MARKERS.lastIndex - 1;
+      continue;
+    }
+    if (c !== "'" && c !== '"' && c !== '`') continue;
+    const end = skipString(expression, i);
+    const literal = expression.slice(i, end + 1);
+    const before = expression.slice(0, i).trimEnd();
+    const after = expression.slice(end + 1).trimStart();
+    const compared =
+      /(===|!==|==|!=|\bcase|\bin)$/.test(before) ||
+      /^(===|!==|==|!=|in\b)/.test(after);
+    if (callDepth === 0 && !compared) literals.push(literal);
+    i = end;
+  }
+  return literals;
+}
+
+/** The text a literal shows: static template parts, HTML tags removed. */
+function visibleText(literal, html) {
+  let body = literal.slice(1, -1).replace(/\$\{(?:[^{}]|\{[^{}]*\})*\}/g, ' ');
+  if (html) {
+    const attrs = [
+      ...body.matchAll(/\s(?:title|aria-label|placeholder|alt)="([^"]*)"/g),
+    ].map((m) => m[1]);
+    body = decodeHtml([body.replace(/<[^>]*>/g, ' '), ...attrs].join(' '));
+  }
+  const text = normalize(body);
+  if (!hasWords(text)) return null;
+  if (/\{[^{}]*:[^{}]*\}|^[\w-]+\s*:\s*[^;]+;/.test(text)) return null; // CSS
+  if (/^(?:rgba?|hsla?)\(|\b\d+px\b/.test(text)) return null; // colours, fonts
+  if (/^[a-z0-9_.:/-]+$/.test(text) || /^https?:/.test(text)) return null;
+  return text;
+}
+
+/** Blank out comments, keeping strings and line numbers intact. */
+function withoutComments(source) {
+  let out = '';
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i];
+    if (c === "'" || c === '"' || c === '`') {
+      const end = skipString(source, i);
+      out += source.slice(i, end + 1);
+      i = end;
+    } else if (c === '/' && source[i + 1] === '/') {
+      const end = source.indexOf('\n', i);
+      const stop = end < 0 ? source.length : end;
+      out += ' '.repeat(stop - i);
+      i = stop - 1;
+    } else if (c === '/' && source[i + 1] === '*') {
+      const end = source.indexOf('*/', i + 2);
+      const stop = end < 0 ? source.length : end + 2;
+      out += source.slice(i, stop).replace(/[^\n]/g, ' ');
+      i = stop - 1;
+    } else out += c;
+  }
+  return out;
+}
+
+export function unmarkedScript(file, original) {
+  const found = [];
+  const lines = original.split('\n');
+  const source = withoutComments(original);
+  const ignored = (line) =>
+    /i18n-ignore/.test(lines[line - 1] ?? '') ||
+    /i18n-ignore/.test(lines[line - 2] ?? '');
+  for (const sink of JS_SINKS) {
+    sink.lastIndex = 0;
+    for (const match of source.matchAll(sink)) {
+      const start = match.index + match[0].length;
+      const line = lineAt(source, start);
+      if (ignored(line)) continue;
+      if (sink === ASSIGNMENT_SINK && defaultValue(source, match.index, start))
+        continue;
+      const html = /HTML/.test(match[0]);
+      for (const literal of valueLiterals(expressionAt(source, start))) {
+        const text = visibleText(literal, html);
+        if (text) found.push({ where: `${file}:${line}`, text });
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * UI text that is not marked for translation: markup without data-i18n* and
+ * string literals that reach the page without t(), tn() or msg().
+ * Opt-outs: see unmarkedMarkup; in code, `// i18n-ignore` on or above the line.
+ * @returns {{where: string, text: string}[]}
+ */
+export function findUnmarked() {
+  const found = [];
+  for (const file of trackedFiles('index.html', 'src/ui/templates/*.html'))
+    found.push(
+      ...unmarkedMarkup(file, readFileSync(path.join(ROOT, file), 'utf8')),
+    );
+  for (const file of sourceFiles().filter(
+    (name) => !NOT_UI.some((pattern) => pattern.test(name)),
+  ))
+    found.push(
+      ...unmarkedScript(file, readFileSync(path.join(ROOT, file), 'utf8')),
+    );
+  const seen = new Set();
+  return found.filter(({ where, text }) => {
+    const key = `${where}\0${text}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// Text that never reaches the page as UI: tool results and descriptions for
+// AI clients (MCP and the voice model).
+const NOT_UI = [/^src\/tools\//];
+
+function sourceFiles() {
+  return trackedFiles(
+    'src/*.js',
+    'src/*.mjs',
+    'src/**/*.js',
+    'src/**/*.mjs',
+  ).filter(
+    (file) =>
+      !file.startsWith('src/i18n/') &&
+      !/\.test\.mjs$|\/testSupport\//.test(file),
+  );
+}
+
+const placeholders = (text) =>
+  [...String(text).matchAll(/\{([A-Za-z0-9_]+)\}/g)]
+    .map((m) => m[1])
+    .sort()
+    .join(',');
+
+export function catalogPath(locale) {
+  return path.join(LOCALES_DIR, `${locale}.json`);
+}
+
+export function readCatalog(locale) {
+  return JSON.parse(readFileSync(catalogPath(locale), 'utf8'));
+}
+
+export function shippedLocales() {
+  return trackedFiles('src/i18n/locales/*.json').map((file) =>
+    path.basename(file, '.json'),
+  );
+}
+
+/** Messages a locale keeps exactly as in English, on purpose. */
+export function readSameAsEnglish(locale) {
+  const lists = JSON.parse(readFileSync(SAME_AS_ENGLISH, 'utf8'));
+  return new Set(lists[locale] || []);
+}
+
+/** The English a message shows: its text without the "context|" prefix. */
+const englishOf = (text) => text.slice(text.indexOf('|') + 1);
+
+/** A translation with nothing to show: t() falls back to English for it. */
+const blank = (value) => value.trim() === '';
+
+/** Words to read, beyond {placeholders}, codes and punctuation. */
+const hasLetters = (value) => /\p{L}{2}/u.test(value.replace(/\{[^}]*\}/g, ''));
+
+const STILL_ENGLISH = (text, locale) =>
+  `"${text}" is still English: translate it, or list it under "${locale}" in src/i18n/same-as-english.json`;
+
+/**
+ * Compare one catalog with the extracted messages.
+ * @param {Set<string>} [sameAsEnglish] Messages allowed to read as English.
+ * @returns {{missing: string[], stale: string[], errors: string[]}}
+ */
+export function checkCatalog(
+  locale,
+  catalog,
+  messages,
+  sameAsEnglish = readSameAsEnglish(locale),
+) {
+  const categories = new Intl.PluralRules(locale).resolvedOptions()
+    .pluralCategories;
+  const missing = [];
+  const errors = [];
+  for (const [text, info] of messages) {
+    if (!Object.hasOwn(catalog, text)) {
+      missing.push(text);
+      continue;
+    }
+    const entry = catalog[text];
+    if (info.plural) {
+      if (!entry || typeof entry !== 'object') {
+        errors.push(`"${text}" needs plural forms ${categories.join('/')}`);
+        continue;
+      }
+      const english = new Set([info.one, englishOf(text)]);
+      const stillEnglish = [];
+      for (const category of categories) {
+        const form = entry[category];
+        if (typeof form !== 'string')
+          errors.push(`"${text}" lacks the "${category}" form`);
+        else if (blank(form))
+          errors.push(`"${text}" [${category}] is empty: translate it`);
+        else if (placeholders(form) !== placeholders(text))
+          errors.push(`"${text}" [${category}] placeholders differ: ${form}`);
+        else if (english.has(form) && hasLetters(form))
+          stillEnglish.push(category);
+      }
+      if (stillEnglish.length && !sameAsEnglish.has(text))
+        errors.push(
+          `${STILL_ENGLISH(text, locale)} (forms ${stillEnglish.join('/')})`,
+        );
+    } else if (typeof entry !== 'string') {
+      errors.push(`"${text}" must be a string`);
+    } else if (blank(entry)) {
+      errors.push(`"${text}" is empty: translate it`);
+    } else if (placeholders(entry) !== placeholders(text)) {
+      errors.push(`"${text}" placeholders differ: ${entry}`);
+    } else if (
+      entry === englishOf(text) &&
+      hasLetters(entry) &&
+      !sameAsEnglish.has(text)
+    ) {
+      errors.push(STILL_ENGLISH(text, locale));
+    }
+  }
+  const stale = Object.keys(catalog).filter((text) => !messages.has(text));
+  return { missing, stale, errors };
+}
+
+/**
+ * What `--missing <locale>` prints: every missing entry, ready to translate.
+ * A template, not a translation: the check rejects a string left empty and a
+ * plural form left as the English.
+ */
+export function missingTemplate(locale, catalog, messages) {
+  const categories = new Intl.PluralRules(locale).resolvedOptions()
+    .pluralCategories;
+  const out = {};
+  for (const text of checkCatalog(locale, catalog, messages, new Set())
+    .missing) {
+    const info = messages.get(text);
+    out[text] = info.plural
+      ? Object.fromEntries(
+          categories.map((category) => [
+            category,
+            category === 'one' ? info.one : text,
+          ]),
+        )
+      : '';
+  }
+  return out;
+}
+
+function main(args) {
+  const messages = extractMessages();
+  const missingFor = args.includes('--missing')
+    ? args[args.indexOf('--missing') + 1]
+    : null;
+  if (missingFor) {
+    const out = missingTemplate(missingFor, readCatalog(missingFor), messages);
+    console.log(JSON.stringify(out, null, 2));
+    return 0;
+  }
+  let failed = false;
+  for (const locale of shippedLocales()) {
+    let catalog = readCatalog(locale);
+    const { missing, stale, errors } = checkCatalog(locale, catalog, messages);
+    if (args.includes('--prune') && stale.length) {
+      catalog = Object.fromEntries(
+        Object.entries(catalog).filter(([text]) => messages.has(text)),
+      );
+      writeFileSync(
+        catalogPath(locale),
+        `${JSON.stringify(catalog, null, 2)}\n`,
+      );
+      console.log(`${locale}: pruned ${stale.length} unused entries`);
+    } else if (stale.length) {
+      failed = true;
+      console.log(
+        `${locale}: ${stale.length} entries the code no longer uses (npm run i18n -- --prune):`,
+      );
+      for (const text of stale) console.log(`  ${JSON.stringify(text)}`);
+    }
+    if (missing.length) {
+      failed = true;
+      console.log(
+        `${locale}: ${missing.length} missing (npm run i18n -- --missing ${locale}):`,
+      );
+      for (const text of missing)
+        console.log(`  ${JSON.stringify(text)}  ${messages.get(text).where}`);
+    }
+    for (const error of errors) {
+      failed = true;
+      console.log(`${locale}: ${error}`);
+    }
+    if (!missing.length && !stale.length && !errors.length) {
+      console.log(`${locale}: ${messages.size} messages, complete`);
+    }
+  }
+  const unmarked = findUnmarked();
+  if (unmarked.length) {
+    failed = true;
+    console.log(
+      `${unmarked.length} UI strings not marked for translation (see docs/I18N.md):`,
+    );
+    for (const { where, text } of unmarked)
+      console.log(`  ${where}  ${JSON.stringify(text)}`);
+  }
+  return failed ? 1 : 0;
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  process.exitCode = main(process.argv.slice(2));
+}

scripts/pinokio-install.mjs

@@ -24,8 +24,8 @@ export function runChecked(command, args, { shell = false } = {}) {
 export function installPinokioDependencies() {
   applyPinokioEnvironment();
   rmSync(READY_FILE, { force: true });
-  const npm = npmProcessSpec();
-  runChecked(npm.command, ['ci'], { shell: npm.shell });
+  const npm = npmProcessSpec(['ci']);
+  runChecked(npm.command, npm.args, { shell: npm.shell });
 
   // Pinokio starts Vite directly and loads only its ENVIRONMENT file plus the
   // normal dotenv ladder. Unlike dev-fresh.sh, it does not import macOS

scripts/precompute-cctv-heights.mjs

@@ -1,6 +1,7 @@
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { chromeExecutablePath } from './qa-chrome.mjs';
 import {
   planeSupportPoints,
   poseHash,
@@ -325,8 +326,10 @@ async function main() {
       'src/data/local_data/cctv_ground_heights/cctv_ground_heights.json',
   );
   let sidecar = await loadSidecar(output);
+  // A cold catalog waits for its slowest pack (Tarktee gets 30 s), so allow
+  // more than that.
   const response = await fetch(`${base}/api/cctv/sources`, {
-    signal: AbortSignal.timeout(30_000),
+    signal: AbortSignal.timeout(60_000),
   });
   if (!response.ok) throw new Error(`Catalog HTTP ${response.status}`);
   const catalog = await response.json();
@@ -389,8 +392,7 @@ async function main() {
       const { default: puppeteer } = await import('puppeteer');
       browser = await puppeteer.launch({
         headless: false,
-        executablePath:
-          '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        executablePath: chromeExecutablePath(),
         protocolTimeout: 600000,
         args: [
           '--no-sandbox',

scripts/qa-action-buttons.mjs

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+/**
+ * Scenes/CCTV action-button acceptance against dev or production preview:
+ * QA_BASE_URL=http://127.0.0.1:4179 node scripts/qa-action-buttons.mjs
+ * Uses the installed CCTV controller with fixture camera/action ports to prove
+ * native dispatch/disabled/teardown without providers or world calibration writes.
+ * Real Scene authoring/playback remains covered by qa-scene-controls.mjs.
+ */
+import fs from 'node:fs';
+import puppeteer from 'puppeteer';
+
+const browser = await puppeteer.launch({
+  headless: true,
+  args: ['--use-gl=angle', '--use-angle=swiftshader'],
+});
+const page = await browser.newPage();
+const errors = [];
+page.on('pageerror', (error) => errors.push(error.message));
+let failures = 0;
+const check = (name, passed, detail) => {
+  console.log(`[${passed ? 'PASS' : 'FAIL'}] ${name}`);
+  if (!passed) {
+    failures++;
+    console.log(JSON.stringify(detail));
+  }
+};
+const shots = 'qa-shots/action-buttons';
+fs.mkdirSync(shots, { recursive: true });
+
+try {
+  await page.setViewport({ width: 1440, height: 900 });
+  await page.goto(
+    `${process.env.QA_BASE_URL || 'http://127.0.0.1:4179'}/?welcome=0`,
+    { waitUntil: 'domcontentloaded' },
+  );
+  await page.waitForFunction(
+    () =>
+      window.__godsEyeView?.styleManager?._cctvControls &&
+      document.getElementById('loading-screen')?.classList.contains('hidden'),
+    { timeout: 60000 },
+  );
+  const inventory = await page.evaluate(() => {
+    const ids = [
+      'scene-new-btn',
+      'scene-delete-btn',
+      'scene-capture-btn',
+      'scene-update-shot-btn',
+      'scene-start-btn',
+      'scene-stop-btn',
+      'scene-next-btn',
+      'scene-export-btn',
+      'scene-import-btn',
+      'scene-download-btn',
+      'cctv-nearest-btn',
+      'cctv-prev-btn',
+      'cctv-next-btn',
+      'cctv-focus-btn',
+      'cctv-calib-save-btn',
+      'cctv-calib-reset-btn',
+    ];
+    const ordinary = ids.map((id) => document.getElementById(id));
+    const generated = [
+      ...document.querySelectorAll(
+        '.scene-shot-btn, [data-director-authoring] button',
+      ),
+    ];
+    const toggles = [
+      'cctv-enable-btn',
+      'cctv-coverage-btn',
+      'cctv-auto-hop-btn',
+      'cctv-projection-btn',
+      'cctv-adjust-btn',
+    ].map((id) => document.getElementById(id));
+    return {
+      shared: [...ordinary, ...generated].every(
+        (node) =>
+          node?.type === 'button' &&
+          node.classList.contains('gev-action-button'),
+      ),
+      generated: generated.length,
+      layout: ordinary.every((node) => {
+        const style = getComputedStyle(node);
+        return style.minWidth === '72px' && style.flexGrow === '1';
+      }),
+      togglesSeparate: toggles.every(
+        (node) => node && !node.classList.contains('gev-action-button'),
+      ),
+      compactDanger: !!document.querySelector(
+        '.scene-shot-danger.gev-action-button--compact.gev-action-button--danger',
+      ),
+    };
+  });
+  check(
+    'static and generated actions share the native component',
+    inventory.shared && inventory.generated >= 4 && inventory.compactDanger,
+    inventory,
+  );
+  check(
+    'persistent CCTV toggles retain their existing controls',
+    inventory.togglesSeparate,
+  );
+  check('ordinary actions retain their panel sizing', inventory.layout);
+
+  await page.evaluate(() => {
+    const manager = window.__godsEyeView.styleManager;
+    const owner = manager._cctvControls;
+    owner._cctvUnsubscribe?.();
+    owner._cctvUnsubscribe = null;
+    window.__qaButtonCalls = [];
+    const record = (...args) => window.__qaButtonCalls.push(args);
+    owner.actions = {
+      ...owner.actions,
+      isEnabled: () => true,
+      toggleEnabled: async () => {
+        record('enable');
+        return true;
+      },
+      runExplicitFocus: (select, focus) => focus(select()),
+      setParams: (params, options) => record('params', params, options),
+      showToast: () => {},
+    };
+    owner.cctv = {
+      focusNearest: () => {
+        record('nearest');
+        return 'a';
+      },
+      cycleCamera: (direction) => {
+        record('cycle', direction);
+        return 'b';
+      },
+      focusCamera: (id, seconds) => record('focus', id, seconds),
+    };
+    window.__qaCameraState = {
+      enabled: true,
+      activeCameraId: 'a',
+      cameras: [
+        { id: 'a', city: 'Fixture', name: 'A' },
+        { id: 'b', city: 'Fixture', name: 'B' },
+      ],
+      activeCamera: { id: 'a', name: 'A', basePose: {} },
+    };
+    owner._renderCctvState(window.__qaCameraState);
+    manager.setPanelCollapsed('cctv-panel', false, {
+      persist: false,
+      syncShare: false,
+    });
+  });
+  await page.focus('#cctv-next-btn');
+  await page.keyboard.press('Space');
+  await page.waitForFunction(() => window.__qaButtonCalls.length === 3);
+  check(
+    'native Space dispatches Next and its focus once',
+    await page.evaluate(
+      () =>
+        JSON.stringify(window.__qaButtonCalls) ===
+        JSON.stringify([['enable'], ['cycle', 1], ['focus', 'b', 1.4]]),
+    ),
+  );
+  check(
+    'native keyboard activation keeps a visible focus ring',
+    await page.$eval(
+      '#cctv-next-btn',
+      (node) =>
+        document.activeElement === node &&
+        getComputedStyle(node).outlineStyle === 'solid',
+    ),
+  );
+  await page.evaluate(() => {
+    window.__qaButtonCalls = [];
+  });
+  await page.focus('#cctv-prev-btn');
+  await page.keyboard.press('Enter');
+  await page.waitForFunction(() => window.__qaButtonCalls.length === 3);
+  check(
+    'native Enter dispatches Previous once',
+    await page.evaluate(
+      () =>
+        JSON.stringify(window.__qaButtonCalls) ===
+        JSON.stringify([['enable'], ['cycle', -1], ['focus', 'b', 1.4]]),
+    ),
+  );
+
+  for (const [id, expected] of [
+    ['cctv-nearest-btn', [['enable'], ['nearest'], ['focus', 'a', 1.8]]],
+    [
+      'cctv-focus-btn',
+      [
+        ['enable'],
+        ['focus', 'a', 1.9],
+        ['params', { selectedCameraId: 'a' }, { origin: 'user' }],
+      ],
+    ],
+  ]) {
+    await page.evaluate(() => {
+      window.__qaButtonCalls = [];
+    });
+    await page.click(`#${id}`);
+    await page.waitForFunction(() => window.__qaButtonCalls.length === 3);
+    const calls = await page.evaluate(() => window.__qaButtonCalls);
+    check(
+      `${id} retains its existing action and focus timing`,
+      JSON.stringify(calls) === JSON.stringify(expected),
+      calls,
+    );
+  }
+
+  await page.evaluate(() => {
+    window.__qaButtonCalls = [];
+  });
+  await page.click('#cctv-calib-save-btn');
+  await page.click('#cctv-calib-reset-btn');
+  const calibration = await page.evaluate(() => window.__qaButtonCalls);
+  check(
+    'Save and Reset retain camera identity and user-origin dispatch',
+    JSON.stringify(calibration) ===
+      JSON.stringify([
+        [
+          'params',
+          { selectedCameraId: 'a', calibration: { cameraId: 'a', save: true } },
+          { origin: 'user' },
+        ],
+        [
+          'params',
+          {
+            selectedCameraId: 'a',
+            calibration: { cameraId: 'a', reset: true },
+          },
+          { origin: 'user' },
+        ],
+      ]),
+    calibration,
+  );
+  await page.evaluate(() => {
+    window.__qaButtonCalls = [];
+    window.__godsEyeView.styleManager._cctvControls._renderCctvState({
+      enabled: false,
+    });
+  });
+  await page.click('#cctv-next-btn');
+  await page.waitForFunction(
+    () => {
+      const node = document.getElementById('cctv-next-btn');
+      return node.disabled && Number(getComputedStyle(node).opacity) === 0.45;
+    },
+    { timeout: 3000 },
+  );
+  check(
+    'disabled actions stay inert and keep disabled presentation',
+    await page.$eval(
+      '#cctv-next-btn',
+      (node) =>
+        node.disabled &&
+        getComputedStyle(node).opacity === '0.45' &&
+        window.__qaButtonCalls.length === 0,
+    ),
+  );
+
+  for (const width of [1440, 620, 390]) {
+    await page.setViewport({ width, height: 900 });
+    for (const panel of ['scene-panel', 'cctv-panel']) {
+      await page.evaluate((panel) => {
+        window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
+          persist: false,
+          syncShare: false,
+        });
+      }, panel);
+      const fit = await page.$eval(`#${panel}`, (root) => {
+        const buttons = [...root.querySelectorAll('.gev-action-button')];
+        const rect = root.getBoundingClientRect();
+        return {
+          count: buttons.length,
+          fits:
+            buttons.length > 0 &&
+            buttons.every((button) => {
+              const box = button.getBoundingClientRect();
+              return (
+                box.width > 0 &&
+                box.left >= rect.left &&
+                box.right <= rect.right + 1 &&
+                box.left >= 0 &&
+                box.right <= innerWidth + 1 &&
+                button.scrollWidth <= button.clientWidth
+              );
+            }),
+        };
+      });
+      check(`${panel} actions fit at ${width}px`, fit.fits, fit);
+      if (width !== 620)
+        await page.screenshot({ path: `${shots}/${panel}-${width}.png` });
+    }
+  }
+  await page.evaluate(() => {
+    const owner = window.__godsEyeView.styleManager._cctvControls;
+    owner.destroy();
+    document.getElementById('cctv-next-btn').disabled = false;
+    window.__qaButtonCalls = [];
+  });
+  await page.click('#cctv-next-btn');
+  check(
+    'destroyed controllers revoke action listeners',
+    await page.evaluate(() => window.__qaButtonCalls.length === 0),
+  );
+  const localized = new URL(page.url());
+  localized.searchParams.set('lang', 'ru');
+  await page.goto(localized.href, { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(
+    () =>
+      window.__godsEyeView?.styleManager?._cctvControls &&
+      document.getElementById('loading-screen')?.classList.contains('hidden'),
+    { timeout: 60000 },
+  );
+  for (const panel of ['scene-panel', 'cctv-panel']) {
+    await page.evaluate((panel) => {
+      window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
+        persist: false,
+        syncShare: false,
+      });
+    }, panel);
+    const translated = await page.$eval(`#${panel}`, (root) => {
+      const buttons = [...root.querySelectorAll('.gev-action-button')];
+      return (
+        document.documentElement.lang === 'ru' &&
+        buttons.length > 0 &&
+        buttons.every((node) => node.scrollWidth <= node.clientWidth)
+      );
+    });
+    check(`Russian ${panel} action labels fit at 390px`, translated);
+    await page.screenshot({ path: `${shots}/${panel}-ru-390.png` });
+  }
+  check('no uncaught browser errors', errors.length === 0, errors);
+} finally {
+  await browser.close();
+}
+console.log(`RESULT: ${failures} failures`);
+process.exitCode = failures ? 1 : 0;

scripts/qa-air-quality.mjs

@@ -0,0 +1,171 @@
+/**
+ * qa-air-quality.mjs — headless proof for the Air quality layer.
+ *
+ * Checks what unit tests cannot: that the live ECCC feed answers, that readings
+ * reach the app in the provider-shaped form other networks will share, and that
+ * the Weather readout descriptor carries a legend and an in-view list.
+ *
+ * AQHI is reported by ECCC as an integer from 1 with "10+" above ten. The API
+ * returns the underlying decimal, so a reading arriving as 1.08 — or a station
+ * with no reading surfacing as a confident 1 — is a real defect this catches.
+ *
+ * Run:  node scripts/qa-air-quality.mjs --url http://localhost:4173
+ */
+
+import puppeteer from 'puppeteer';
+
+const argv = process.argv.slice(2);
+const getOpt = (name, dflt) => {
+  const i = argv.indexOf(name);
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : dflt;
+};
+const APP_URL = getOpt('--url', 'http://localhost:4173');
+
+const results = [];
+function record(name, ok, detail) {
+  results.push({ name, ok, detail });
+  const tag = ok ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m';
+  console.log(`  [${tag}] ${name}${detail ? `  — ${detail}` : ''}`);
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function main() {
+  let exitCode = 0;
+  const consoleErrors = [];
+  const browser = await puppeteer.launch({
+    headless: 'new',
+    args: [
+      '--use-gl=swiftshader',
+      '--enable-unsafe-swiftshader',
+      '--no-sandbox',
+      '--disable-dev-shm-usage',
+    ],
+    defaultViewport: { width: 1400, height: 900 },
+  });
+
+  try {
+    const page = await browser.newPage();
+    page.on('pageerror', (e) => consoleErrors.push(String(e).slice(0, 160)));
+    page.on('console', (m) => {
+      if (m.type() === 'error') consoleErrors.push(m.text().slice(0, 160));
+    });
+
+    await page.goto(APP_URL, { waitUntil: 'domcontentloaded', timeout: 90000 });
+    await page.waitForFunction(
+      () => window.__godsEyeView?.viewer && window.__godsEyeView?.dataManager,
+      { timeout: 90000 },
+    );
+    await sleep(1500);
+
+    const stats = await page.evaluate(async () => {
+      const dm = window.__godsEyeView.dataManager;
+      await dm.setEnabled('air-quality', true);
+      const mod = dm.layers.get('air-quality')?.module;
+      if (!mod) return { missing: true };
+      let s = null;
+      for (let i = 0; i < 45; i++) {
+        await new Promise((r) => setTimeout(r, 1000));
+        s = mod.getStats();
+        if (s.count > 0 || s.error) break;
+      }
+      return s;
+    });
+
+    const loaded = !stats?.missing && !stats?.error && stats?.count > 0;
+    record('stations report a current index', loaded,
+      `count=${stats?.count} error=${stats?.error}`);
+    if (!loaded) exitCode = 1;
+
+    const records = await page.evaluate(
+      () =>
+        window.__godsEyeView.dataManager
+          .layers.get('air-quality')
+          ?.module.getAnalystRecords(500) || [],
+    );
+
+    // The provider-neutral contract other networks will share.
+    const shaped = records.every(
+      (r) => r.provider && r.scale && Number.isFinite(r.value) && r.band,
+    );
+    record('every reading carries provider, scale, value and band', shaped,
+      records.length
+        ? `sample={provider:${records[0].provider}, scale:${records[0].scale}, value:${records[0].value}, band:${records[0].band}}`
+        : 'no records');
+    if (!shaped) exitCode = 1;
+
+    const published = records.every((r) => Number.isInteger(r.value) && r.value >= 1);
+    record('every AQHI value is in the published integer form, floored at 1', published,
+      `values=${[...new Set(records.map((r) => r.value))].sort((a, b) => a - b).join(',')}`);
+    if (!published) exitCode = 1;
+
+    const zones = [...new Set(records.map((r) => r.zone).filter(Boolean))].sort();
+    record('coverage spans multiple ECCC administrative zones', zones.length >= 3,
+      `zones=${zones.join(',') || 'none'} stations=${records.length}`);
+    if (zones.length < 3) exitCode = 1;
+
+    // The card's whole point is "highest readings in view", so put the camera
+    // over Canada before asserting on it — the default view is over Austin,
+    // where an empty in-view list is correct and proves nothing.
+    await page.evaluate(() => {
+      const gev = window.__godsEyeView;
+      const ellipsoid = gev.viewer.scene.globe.ellipsoid;
+      const d2r = Math.PI / 180;
+      try {
+        gev.viewer.camera.cancelFlight();
+      } catch {
+        /* no flight in progress */
+      }
+      gev.viewer.camera.setView({
+        destination: ellipsoid.cartographicToCartesian({
+          longitude: -100 * d2r,
+          latitude: 55 * d2r,
+          height: 4_000_000,
+        }),
+        orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+      });
+      gev.viewer.scene.requestRender?.();
+    });
+    await sleep(2500);
+
+    const controls = await page.evaluate(
+      () =>
+        window.__godsEyeView.dataManager
+          .layers.get('air-quality')
+          ?.module.getRowControls?.() || null,
+    );
+    const readoutOk =
+      controls?.readout === true &&
+      Array.isArray(controls?.legend?.colors) &&
+      controls.legend.colors.length === controls.legend.labels.length &&
+      Array.isArray(controls?.list?.items) &&
+      controls.list.items.length > 0 &&
+      controls.list.items.every((item) => item.id && item.label && item.value) &&
+      /Canada only/.test(controls?.summary?.coverage || '');
+    record('the Weather readout lists the worst readings in view, with a legend', readoutOk,
+      controls
+        ? `bands=${controls.legend?.labels?.join('/')} inView=${controls.list?.items?.length} coverage="${controls.summary?.coverage}"`
+        : 'no descriptor');
+    if (!readoutOk) exitCode = 1;
+
+    record('no console errors', consoleErrors.length === 0,
+      consoleErrors.length ? consoleErrors.slice(0, 2).join(' | ') : 'clean');
+    if (consoleErrors.length) exitCode = 1;
+  } catch (e) {
+    console.error('\x1b[31mHarness error:\x1b[0m', e);
+    exitCode = 3;
+  } finally {
+    await browser.close();
+  }
+
+  const pass = results.filter((r) => r.ok === true).length;
+  const fail = results.filter((r) => r.ok === false).length;
+  console.log('\n' + '─'.repeat(60));
+  console.log(`  RESULT: ${pass} passed, ${fail} failed`);
+  console.log('─'.repeat(60) + '\n');
+  process.exit(exitCode || (fail > 0 ? 1 : 0));
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(3);
+});

scripts/qa-anime-sky.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * qa-anime-sky — the anime style must leave the sky without bands.
+ *
+ * Anime's luminance bands turn the faint Milky Way into blotches, so
+ * src/ui/visualEffects.js fades the glow out with the style. Headless against
+ * a Vite dev server, both sky assets must be ready. Normal must show the
+ * Galactic Centre glow (at least 2 % of pixels at luma >= 10/255), then
+ * Anime must retain stars while at most 0.5 % reaches the first cel band.
+ * The Normal baseline measured 43 % in headless Chromium at 1000×700;
+ * the 2 % floor leaves room for GPU differences while rejecting a black sky.
+ *
+ * Usage: node scripts/qa-anime-sky.mjs [--url http://localhost:4333/]
+ * Exit: 0 pass, 1 fail, 2 the anime style was not reached.
+ */
+import puppeteer from 'puppeteer';
+
+const i = process.argv.indexOf('--url');
+const URL_ =
+  i > 0 && process.argv[i + 1] ? process.argv[i + 1] : 'http://localhost:4333/';
+
+const browser = await puppeteer.launch({
+  headless: 'new',
+  args: ['--no-sandbox', '--ignore-gpu-blocklist'],
+});
+try {
+  const page = await browser.newPage();
+  await page.setRequestInterception(true);
+  page.on('request', (request) => {
+    const host = new URL(request.url()).hostname;
+    if (host.endsWith('halfpixel.ai') || host.includes('worldfx'))
+      request.abort();
+    else request.continue();
+  });
+  page.on('pageerror', (e) => console.log('PAGEERR', String(e).slice(0, 300)));
+  await page.setViewport({ width: 1000, height: 700 });
+  await page.evaluateOnNewDocument(() =>
+    localStorage.setItem('gev:first-run-mission:v1', 'suppressed'),
+  );
+  await page.goto(URL_, { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(() => window.__godsEyeView?.viewer?.scene, {
+    timeout: 120000,
+  });
+  await page.waitForFunction(
+    () => {
+      const sky = window.__godsEyeView.viewer.scene.skyBox;
+      return (
+        sky?._milkyWayCubeMap &&
+        sky?._starCommand &&
+        document.getElementById('loading-screen')?.classList.contains('hidden')
+      );
+    },
+    { timeout: 60000 },
+  );
+  const r = await page.evaluate(async () => {
+    const entry = performance
+      .getEntriesByType('resource')
+      .map((e) => e.name)
+      .find((n) => /\.vite\/deps\/cesium\.js/.test(n));
+    if (!entry)
+      throw new Error(
+        'run against the Vite dev server (needs .vite/deps/cesium.js)',
+      );
+    const C = await import(entry),
+      g = window.__godsEyeView,
+      v = g.viewer,
+      s = v.scene;
+    g.styleManager.setStyle('normal', { userInitiated: true });
+    const t = v.clock.currentTime;
+    await C.Transforms.preloadIcrfFixed(
+      new C.TimeInterval({
+        start: C.JulianDate.addDays(t, -1, new C.JulianDate()),
+        stop: C.JulianDate.addDays(t, 1, new C.JulianDate()),
+      }),
+    );
+    const m = C.Transforms.computeIcrfToFixedMatrix(t);
+    const ra = C.Math.toRadians(266.4),
+      dec = C.Math.toRadians(-29);
+    const look = C.Matrix3.multiplyByVector(
+      m,
+      new C.Cartesian3(
+        Math.cos(dec) * Math.cos(ra),
+        Math.cos(dec) * Math.sin(ra),
+        Math.sin(dec),
+      ),
+      new C.Cartesian3(),
+    );
+    const north = C.Matrix3.multiplyByVector(
+      m,
+      C.Cartesian3.UNIT_Z,
+      new C.Cartesian3(),
+    );
+    const right = C.Cartesian3.normalize(
+      C.Cartesian3.cross(look, north, new C.Cartesian3()),
+      new C.Cartesian3(),
+    );
+    s.camera.cancelFlight();
+    s.tweens.removeAll();
+    s.camera.setView({
+      destination: C.Cartesian3.multiplyByScalar(look, 3e7, new C.Cartesian3()),
+      orientation: {
+        direction: look,
+        up: C.Cartesian3.cross(right, look, new C.Cartesian3()),
+      },
+    });
+    const gl = s.context._gl,
+      w = gl.drawingBufferWidth,
+      h = gl.drawingBufferHeight,
+      px = new Uint8Array(w * h * 4);
+    const measure = async () => {
+      await new Promise((res) => setTimeout(res, 2500));
+      s.requestRender();
+      s.render();
+      gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, px);
+      let banded = 0;
+      let visible = 0;
+      for (let i = 0; i < px.length; i += 4) {
+        const luma = 0.299 * px[i] + 0.587 * px[i + 1] + 0.114 * px[i + 2];
+        if (luma >= 51) banded++;
+        if (luma >= 10) visible++;
+      }
+      return { banded, visible };
+    };
+    const normal = await measure();
+    g.styleManager.setStyle('anime', { userInitiated: true });
+    const anime = await measure();
+    let animeOn = false;
+    for (let i = 0; i < s.postProcessStages.length; i++) {
+      const stage = s.postProcessStages.get(i);
+      if (stage.name === 'godsEyeView_anime')
+        animeOn = stage.enabled && stage.uniforms.intensity > 0.99;
+    }
+    return {
+      total: px.length / 4,
+      normal,
+      ...anime,
+      assetsReady: Boolean(s.skyBox._milkyWayCubeMap && s.skyBox._starCommand),
+      visibility: s.skyBox.milkyWayVisibility,
+      animeOn,
+    };
+  });
+  const tag =
+    !r.animeOn || !r.assetsReady
+      ? 'UNREACHED'
+      : r.normal.visible >= 0.02 * r.total &&
+          r.banded > 0 &&
+          r.banded <= 0.005 * r.total &&
+          r.visibility === 0
+        ? 'PASS'
+        : 'FAIL';
+  console.log(
+    `${tag}: ${r.banded} of ${r.total} sky pixels at or above the first cel band (luma >= 0.2)\n     ${JSON.stringify(r)}`,
+  );
+  process.exitCode = tag === 'PASS' ? 0 : tag === 'FAIL' ? 1 : 2;
+} catch (error) {
+  console.error(`UNREACHED: ${error.message}`);
+  process.exitCode = 2;
+} finally {
+  await browser.close();
+}

scripts/qa-browserEvidence.mjs

@@ -7,10 +7,10 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 
 /** Console messages and failed requests kept per page. */
-export const EVIDENCE_LIMIT = 200;
+const EVIDENCE_LIMIT = 200;
 
 /** Cesium's console line when the render loop throws (CesiumWidget). */
-export const RENDER_ERROR_PATTERN = /An error occurred while rendering/i;
+const RENDER_ERROR_PATTERN = /An error occurred while rendering/i;
 
 /** Mask tokens in a URL or message before it is printed or saved. */
 export function redact(text) {

scripts/qa-cables-shot.mjs

@@ -6,6 +6,7 @@
  */
 import puppeteer from 'puppeteer';
 import { mkdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 
 const argv = process.argv;
 const url = argv.includes('--url') ? argv[argv.indexOf('--url') + 1] : 'http://localhost:4214';
@@ -65,7 +66,9 @@ try {
       requestAnimationFrame(tick);
     }));
     await new Promise((r) => setTimeout(r, 1_000));
-    const path = new URL(`../qa-shots/cables-${tag}-${view.name}.png`, import.meta.url).pathname;
+    const path = fileURLToPath(
+      new URL(`../qa-shots/cables-${tag}-${view.name}.png`, import.meta.url),
+    );
     await page.screenshot({ path });
     console.log(`saved ${path}`);
   }

scripts/qa-camera-controls.mjs

@@ -370,6 +370,9 @@ try {
   await page.screenshot({ path: 'qa-shots/camera-controls/angle.png' });
   await page.setViewport({ width: 390, height: 844 });
   await new Promise((resolve) => setTimeout(resolve, 700));
+  // Phones present CCTV in the Cameras tab's sheet.
+  await page.click('#mobile-tab-bar [data-mobile-sheet="cameras"]');
+  await new Promise((resolve) => setTimeout(resolve, 400));
   await page.screenshot({ path: 'qa-shots/camera-controls/narrow.png' });
   check(
     'narrow camera panel remains within the viewport',

scripts/qa-cctv-v2.mjs

@@ -11,8 +11,10 @@
  *      exactly once per camera ACTIVATION (the §9.1 obstruction probe) and
  *      never again in steady state; shared mesh-floor sampling fires at most
  *      once per coarse cell during the staggered geometry-load drain, and
- *      actually COMPLETES once tiles load (>=1 real sample — the
- *      ceiling alone would pass trivially at Δ=0 if the snap never finished),
+ *      actually COMPLETES once tiles load in photoreal mode (>=1 real sample
+ *      — the ceiling alone would pass trivially at Δ=0 if the snap never
+ *      finished). Globe mode instead proves the rendered mount uses a real
+ *      terrain height with zero mesh samples. Sampling
  *      stays flat while idle, and stays flat for non-positional pose edits.
  *   2. Geometry contract: the 5-polyline frustum wireframe + far-cap plane
  *      exist for the active camera, the plane's corners coincide with the
@@ -139,6 +141,56 @@ function record(name, ok, detail) {
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
+// Each page.evaluate is bounded by puppeteer's `protocolTimeout` (default
+// 180s). Waits never come close: they poll from Node (below). The headroom is
+// for the few long evaluates, such as enabling the full ~3,700-camera catalog
+// on a real GPU, and matches the other qa-*.mjs harnesses.
+const PROTOCOL_TIMEOUT_MS = 300_000;
+
+/**
+ * Polls an in-page predicate from Node, one short page.evaluate per tick,
+ * until it holds or the budget runs out. Used instead of page.waitForFunction
+ * for two reasons: its default rAF polling stops in a minimised or hidden
+ * headful window (timers keep running, rAF does not), and its result is one
+ * CDP call that protocolTimeout cuts off, while the headful drain budget
+ * reaches ~50 minutes. A predicate that throws fails the run instead of
+ * silently spending the budget.
+ * @param {import('puppeteer').Page} page
+ * @param {Function} predicate - In-page predicate.
+ * @param {object} opts
+ * @param {number} opts.timeoutMs - Overall budget.
+ * @param {number} [opts.intervalMs=250] - Delay between checks.
+ * @param {unknown[]} [opts.args=[]] - Arguments passed to the predicate.
+ *   The predicate must return a boolean: its result crosses CDP by value.
+ * @returns {Promise<boolean>} True if the predicate held within the budget.
+ */
+async function waitForPredicate(
+  page,
+  predicate,
+  { timeoutMs, intervalMs = 250, args = [] },
+) {
+  // performance.now() is monotonic and doesn't advance while the machine
+  // sleeps, so neither a clock change nor a laptop sleep eats the budget.
+  const deadline = performance.now() + timeoutMs;
+  for (;;) {
+    try {
+      if (await page.evaluate(predicate, ...args)) return true;
+    } catch (err) {
+      // A navigation or Vite reload replaces the execution context: poll again.
+      if (
+        !/Execution context was destroyed|Cannot find context/.test(
+          err?.message ?? '',
+        )
+      ) {
+        throw err;
+      }
+    }
+    const remaining = deadline - performance.now();
+    if (remaining <= 0) return false;
+    await sleep(Math.min(intervalMs, remaining));
+  }
+}
+
 // SwiftShader can spend tens of seconds servicing the hover drillPick emitted
 // by page.mouse.move(), before the LEFT_DOWN under test even runs. Position the
 // pointer while ADJUST is disabled, then re-enable it and explicitly render a
@@ -155,29 +207,58 @@ async function positionPointerForGizmoDrag(page, point, frameCount = 3) {
     gev.dataManager.layers
       .get('cctv')
       .module.setParams({ calibrationMode: true });
-    const scene = gev.viewer.scene;
-    let rendered = 0;
-    return new Promise((resolve) => {
-      let settled = false;
-      const finish = (complete) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        remove();
-        resolve(complete);
-      };
-      const remove = scene.postRender.addEventListener(() => {
-        rendered += 1;
-        if (rendered >= count) {
-          finish(true);
-          return;
-        }
+    return (await window.__qaRenderFrames(count, 5000)) >= count;
+  }, frameCount);
+}
+
+/**
+ * Saves a screenshot for human review. These are never a gate, so a capture
+ * that fails (for example when the renderer stalls in a hidden headful window)
+ * is logged instead of ending the run.
+ * @param {import('puppeteer').Page} page
+ * @param {string} file
+ * @param {string} label
+ */
+async function saveReviewShot(page, file, label) {
+  try {
+    await page.screenshot({ path: file });
+    console.log(`  screenshot (${label}) → ${path.relative(REPO_ROOT, file)}`);
+  } catch (err) {
+    console.warn(
+      `  screenshot skipped (${label}): ${path.relative(REPO_ROOT, file)}: ${err?.message ?? err}`,
+    );
+  }
+}
+
+/**
+ * Installs window.__qaRenderFrames(count, capMs) in the page: requests renders
+ * until `count` frames have passed scene.postRender or capMs runs out, and
+ * resolves with the number of frames rendered. The cap keeps a stalled
+ * renderer (headful window asleep or hidden) from hanging the CDP call.
+ * @param {import('puppeteer').Page} page
+ */
+function installRenderFramesHelper(page) {
+  return page.evaluate(() => {
+    window.__qaRenderFrames = (count, capMs) =>
+      new Promise((resolve) => {
+        const scene = window.__godsEyeView.viewer.scene;
+        let frames = 0;
+        const finish = () => {
+          clearTimeout(timer);
+          remove();
+          resolve(frames);
+        };
+        const remove = scene.postRender.addEventListener(() => {
+          if (++frames >= count) {
+            finish();
+            return;
+          }
+          scene.requestRender();
+        });
+        const timer = setTimeout(finish, capMs);
         scene.requestRender();
       });
-      const timer = setTimeout(() => finish(false), 5000);
-      scene.requestRender();
-    });
-  }, frameCount);
+  });
 }
 
 // In-page helper (stringified and re-defined inside each evaluate that needs
@@ -280,23 +361,21 @@ const BEARING_SHIFT_SRC = `
  * @returns {Promise<boolean>} True if tilesLoaded was observed within the timeout.
  */
 function waitForTilesLoaded(page, timeoutMs = 15000) {
-  return page
-    .waitForFunction(
-      () => {
-        const scene = window.__godsEyeView.viewer.scene;
-        const prims = scene.primitives;
-        for (let i = 0; i < prims.length; i++) {
-          const p = prims.get(i);
-          if (p && p.constructor && p.constructor.name === 'Cesium3DTileset') {
-            return p.tilesLoaded === true;
-          }
+  return waitForPredicate(
+    page,
+    () => {
+      const scene = window.__godsEyeView.viewer.scene;
+      const prims = scene.primitives;
+      for (let i = 0; i < prims.length; i++) {
+        const p = prims.get(i);
+        if (p && p.constructor && p.constructor.name === 'Cesium3DTileset') {
+          return p.tilesLoaded === true;
         }
-        return true; // no tileset in the scene — nothing to wait for
-      },
-      { timeout: timeoutMs },
-    )
-    .then(() => true)
-    .catch(() => false);
+      }
+      return true; // no tileset in the scene — nothing to wait for
+    },
+    { timeoutMs },
+  );
 }
 
 /**
@@ -364,6 +443,10 @@ async function main() {
   const chromeExecutable = findChromeExecutable();
   const browser = await puppeteer.launch({
     headless: HEADFUL ? false : 'new',
+    protocolTimeout: PROTOCOL_TIMEOUT_MS,
+    // Talk CDP over a pipe, so no debugging port stays open on localhost for
+    // the length of a headful run.
+    pipe: true,
     ...(chromeExecutable ? { executablePath: chromeExecutable } : {}),
     args: [
       '--no-sandbox',
@@ -397,13 +480,18 @@ async function main() {
     });
     console.log('Loading app...');
     await page.goto(APP_URL, { waitUntil: 'domcontentloaded', timeout: 60000 });
-    await page.waitForFunction(
+    const appReady = await waitForPredicate(
+      page,
       () =>
-        window.__godsEyeView &&
-        window.__godsEyeView.viewer &&
-        window.__godsEyeView.dataManager,
-      { timeout: 60000 },
+        Boolean(
+          window.__godsEyeView &&
+          window.__godsEyeView.viewer &&
+          window.__godsEyeView.dataManager,
+        ),
+      { timeoutMs: 60000 },
     );
+    if (!appReady) throw new Error('app did not initialise within 60s');
+    await installRenderFramesHelper(page);
     // Let the initial fly-to Austin and first tiles settle.
     await sleep(4000);
 
@@ -475,18 +563,15 @@ async function main() {
     console.log(
       `Waiting for geometry-load queue to drain (N=${camCount}, budget ${Math.round(drainBudgetMs / 1000)}s)...`,
     );
-    const drained = await page
-      .waitForFunction(
-        () => {
-          const mod =
-            window.__godsEyeView.dataManager.layers.get('cctv').module;
-          const ui = mod.getUIState();
-          return ui.loading && ui.loading.active === false;
-        },
-        { timeout: drainBudgetMs },
-      )
-      .then(() => true)
-      .catch(() => false);
+    const drained = await waitForPredicate(
+      page,
+      () => {
+        const mod = window.__godsEyeView.dataManager.layers.get('cctv').module;
+        const ui = mod.getUIState();
+        return Boolean(ui.loading) && ui.loading.active === false;
+      },
+      { timeoutMs: drainBudgetMs, intervalMs: 1000 },
+    );
     record(
       `geometry-load queue drains within ${Math.round(drainBudgetMs / 1000)}s (N=${camCount})`,
       drained ? true : HEADFUL ? false : null,
@@ -575,27 +660,87 @@ async function main() {
     // (existence, not just ceiling). The wait below tolerates the update-tick
     // latency of the completion pass (update interval is 10s).
     // -----------------------------------------------------------------------
-    console.log('Waiting for tiles + the one-shot completion pass...');
-    const tilesSeenLoaded = await waitForTilesLoaded(page, 45000);
-    let sampleFloorOk = false;
-    if (tilesSeenLoaded) {
-      sampleFloorOk = await page
-        .waitForFunction(
-          (base) => window.__qaCounters.sampleHeight - base >= 1,
-          { timeout: 30000 },
-          c0.sampleHeight,
-        )
-        .then(() => true)
-        .catch(() => false);
-    }
-    const cFloor = await readCounters();
-    record(
-      '>=1 real ground sample once tilesLoaded observed (one-shot snap completed)',
-      tilesSeenLoaded ? sampleFloorOk : null,
-      tilesSeenLoaded
-        ? `total real samples since enable=${cFloor.sampleHeight - c0.sampleHeight}`
-        : 'tilesLoaded never observed within 45s — floor not assessable this run',
+    const globeMode = await page.evaluate(
+      () => window.__godsEyeView.viewer.scene.globe?.show !== false,
     );
+    if (globeMode) {
+      // Globe stacks intentionally perform no scene.sampleHeight query.
+      // Require independently fetched DEM heights and the actual rendered
+      // mount, so a catalog/geoid fallback cannot turn zero samples into a pass.
+      console.log(
+        'Checking terrain-globe completion against live DEM heights...',
+      );
+      const terrain = await page.evaluate(async () => {
+        const camera = window.__godsEyeView.dataManager.layers
+          .get('cctv')
+          .module.getUIState().activeCamera;
+        const exact = `${camera.lon.toFixed(5)},${camera.lat.toFixed(5)}`;
+        const cell = `${camera.lon.toFixed(3)},${camera.lat.toFixed(3)}`;
+        const response = await fetch(
+          `/api/terrain/heights?points=${encodeURIComponent(`${exact};${cell}`)}`,
+          { signal: AbortSignal.timeout(30000) },
+        );
+        const body = await response.json();
+        return { ok: response.ok, results: body.results };
+      });
+      const heights = terrain.results?.map((result) => result?.ellipsoid);
+      const terrainReady =
+        terrain.ok && heights?.length === 2 && heights.every(Number.isFinite);
+      const mountResolved =
+        terrainReady &&
+        (await waitForPredicate(
+          page,
+          (expected, base) => {
+            const { viewer, dataManager } = window.__godsEyeView;
+            const camera = dataManager.layers
+              .get('cctv')
+              .module.getUIState().activeCamera;
+            const ray = viewer.entities.getById(`cctv-${camera.id}-ray-tl`);
+            const mount = ray?.polyline?.positions.getValue(
+              viewer.clock.currentTime,
+            )?.[0];
+            const height =
+              mount &&
+              viewer.scene.globe.ellipsoid.cartesianToCartographic(mount)
+                .height;
+            return (
+              Number.isFinite(camera.groundPriorM) &&
+              Math.abs(camera.groundPriorM - expected[0]) < 0.01 &&
+              Number.isFinite(height) &&
+              expected.some(
+                (ground) =>
+                  Math.abs(height - ground - camera.mountHeightM) < 0.05,
+              ) &&
+              window.__qaCounters.sampleHeight === base
+            );
+          },
+          { timeoutMs: 30000, args: [heights, c0.sampleHeight] },
+        ));
+      record(
+        'terrain-globe completion uses a real DEM height at the rendered mount without mesh samples',
+        Boolean(mountResolved),
+        `terrain=${JSON.stringify(heights)}, mesh sample Δ=${(await readCounters()).sampleHeight - c0.sampleHeight}`,
+      );
+    } else {
+      console.log('Waiting for tiles + the one-shot completion pass...');
+      const tilesSeenLoaded = await waitForTilesLoaded(page, 45000);
+      let sampleFloorOk = false;
+      if (tilesSeenLoaded) {
+        sampleFloorOk = await waitForPredicate(
+          page,
+          (base) => window.__qaCounters.sampleHeight - base >= 1,
+          { timeoutMs: 30000, args: [c0.sampleHeight] },
+        );
+      }
+      const cFloor = await readCounters();
+      record(
+        '>=1 real ground sample once tilesLoaded observed (one-shot snap completed)',
+        tilesSeenLoaded ? sampleFloorOk : null,
+        tilesSeenLoaded
+          ? `total real samples since enable=${cFloor.sampleHeight - c0.sampleHeight}`
+          : 'tilesLoaded never observed within 45s — floor not assessable this run',
+      );
+    }
 
     // Let the completion pass finish before the steady-state window: require
     // the sampleHeight counter quiet for 12s (> the 10s update interval, so
@@ -1358,18 +1503,7 @@ async function main() {
         },
       });
       window.__qaCctvSiblingOwner = owner;
-      await new Promise((resolve) => {
-        let frames = 0;
-        const remove = scene.postRender.addEventListener(() => {
-          if (++frames < 3) {
-            scene.requestRender();
-            return;
-          }
-          remove();
-          resolve();
-        });
-        scene.requestRender();
-      });
+      const framesRendered = await window.__qaRenderFrames(3, 10000);
       const rect = scene.canvas.getBoundingClientRect();
       const picked = scene.pick(canvasPoint);
       const pickedId = picked?.id?.id ?? picked?.id ?? null;
@@ -1382,26 +1516,33 @@ async function main() {
           typeof pickedId === 'string' ? pickedId : (pickedId?.id ?? null),
         ownerId: owner.id,
         ownsExactObject: picked?.id === owner,
+        framesRendered,
         projectionDelta: Math.hypot(
           projected.x - canvasPoint.x,
           projected.y - canvasPoint.y,
         ),
       };
     }, emptyClickPoint);
+    const siblingOwnsPick =
+      siblingTarget?.pickedId === 'qa-cctv-sibling-owner' &&
+      siblingTarget.ownsExactObject;
+    // No frame at all within the 10s cap points at a stalled renderer rather
+    // than at picking, though the harness can't rule out both. Fail it on the
+    // real-GPU sign-off path; leave it inconclusive under headless GL. A slow
+    // SwiftShader frame (1-2 of 3) still counts as a real miss.
+    const siblingRendererStalled =
+      siblingTarget && !siblingOwnsPick && siblingTarget.framesRendered === 0;
     record(
       'sibling test object owns its canvas pick',
+      !siblingTarget
+        ? null
+        : siblingOwnsPick ||
+            (siblingRendererStalled && !HEADFUL ? null : false),
       siblingTarget
-        ? siblingTarget.pickedId === 'qa-cctv-sibling-owner' &&
-            siblingTarget.ownsExactObject
-        : null,
-      siblingTarget
-        ? `picked=${siblingTarget.pickedId} exactOwner=${siblingTarget.ownsExactObject} projectionΔ=${siblingTarget.projectionDelta}`
+        ? `${siblingRendererStalled ? 'renderer stalled: ' : ''}frames=${siblingTarget.framesRendered}/3 picked=${siblingTarget.pickedId} exactOwner=${siblingTarget.ownsExactObject} projectionΔ=${siblingTarget.projectionDelta}`
         : 'no previously verified empty canvas ray was available',
     );
-    if (
-      siblingTarget?.pickedId === 'qa-cctv-sibling-owner' &&
-      siblingTarget.ownsExactObject
-    ) {
+    if (siblingOwnsPick) {
       await page.mouse.click(siblingTarget.x, siblingTarget.y);
       await sleep(250);
     }
@@ -1426,8 +1567,7 @@ async function main() {
     });
     record(
       'sibling canvas click passes through without CCTV selection or deselection',
-      siblingTarget?.pickedId === 'qa-cctv-sibling-owner' &&
-        siblingTarget.ownsExactObject
+      siblingOwnsPick
         ? siblingClick.activeId === clickEvidenceSetup.activeId &&
             siblingClick.transitions === siblingClick.baselineTransitions &&
             siblingClick.focusEvents === 0 &&
@@ -1626,10 +1766,7 @@ async function main() {
     );
 
     const viewshedShot = path.join(SHOTS_DIR, 'cctv-v3-viewshed.png');
-    await page.screenshot({ path: viewshedShot });
-    console.log(
-      `  screenshot (visual review only) → ${path.relative(REPO_ROOT, viewshedShot)}`,
-    );
+    await saveReviewShot(page, viewshedShot, 'visual review only');
 
     // =========================================================================
     // Group 7: calibration gizmo (v3 design §3c — ADJUST mode + drag)
@@ -1963,10 +2100,7 @@ async function main() {
     // -----------------------------------------------------------------------
     await sleep(1000);
     const shot = path.join(SHOTS_DIR, 'cctv-v2-active.png');
-    await page.screenshot({ path: shot });
-    console.log(
-      `  screenshot (visual review only, not a gate) → ${path.relative(REPO_ROOT, shot)}`,
-    );
+    await saveReviewShot(page, shot, 'visual review only, not a gate');
 
     // No console errors during the whole exercise.
     record(

scripts/qa-chrome.mjs

@@ -0,0 +1,47 @@
+/**
+ * The browser for gates that drive an installed Chrome. These gates were
+ * written against macOS Google Chrome, which Windows and Linux do not have.
+ */
+import { existsSync } from 'node:fs';
+
+export const MACOS_CHROME =
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+
+/**
+ * PUPPETEER_EXECUTABLE_PATH when set, then macOS Google Chrome when it is
+ * installed. Otherwise undefined, so Puppeteer launches the browser it manages.
+ */
+export function chromeExecutablePath({
+  env = process.env,
+  exists = existsSync,
+} = {}) {
+  if (env.PUPPETEER_EXECUTABLE_PATH) return env.PUPPETEER_EXECUTABLE_PATH;
+  return exists(MACOS_CHROME) ? MACOS_CHROME : undefined;
+}
+
+/** Restore an owned test window before capture: focus emulation alone does not
+ * unminimize the native compositor, so CDP screenshots can otherwise stall. */
+export async function captureQaScreenshot(
+  page,
+  options,
+  { headful = true } = {},
+) {
+  if (headful) {
+    const session = await page.createCDPSession();
+    try {
+      const { windowId, bounds } = await session.send(
+        'Browser.getWindowForTarget',
+      );
+      if (bounds.windowState === 'minimized') {
+        await session.send('Browser.setWindowBounds', {
+          windowId,
+          bounds: { windowState: 'normal' },
+        });
+      }
+      await page.bringToFront();
+    } finally {
+      await session.detach();
+    }
+  }
+  return page.screenshot(options);
+}

scripts/qa-cockpit-plates.mjs

@@ -12,7 +12,7 @@
  * passed with the painter stubbed out — the number was right and nothing was
  * drawn. Every assertion here now comes from the RENDERED path instead:
  *
- *   ids/counts — `styleManager.getDetectionDiagnostics()` (src/ui.js), the
+ *   ids/counts — `styleManager.getDetectionDiagnostics()` (src/ui/shellFacade.js), the
  *     overlay's own published `visibleCount` / `labeledKeys`, so a contact only
  *     counts once the sweep, the arbiter and the placement solve have all run.
  *   plate scale — tapped off `CanvasRenderingContext2D` while the frame paints.

scripts/qa-cockpit-utility.mjs

@@ -1603,7 +1603,7 @@ try {
     cockpit.setVisionMode('optical');
     current.focus({ preventScroll: true });
     const states = [read()];
-    for (let index = 0; index < 7; index += 1) {
+    for (let index = 0; index < 6; index += 1) {
       current.click();
       states.push(read());
     }
@@ -1637,36 +1637,36 @@ try {
       reentered,
     };
   });
-  const cycleModes = ['optical', 'crt', 'nvg', 'thermal', 'anime', 'noir', 'snow', 'optical'];
-  const cycleLabels = ['NORMAL', 'CRT', 'NVG', 'FLIR', 'ANIME', 'NOIR', 'SNOW', 'NORMAL'];
+  const cycleModes = ['optical', 'crt', 'nvg', 'thermal', 'anime', 'noir', 'optical'];
+  const cycleLabels = ['NORMAL', 'CRT', 'NVG', 'FLIR', 'ANIME', 'NOIR', 'NORMAL'];
   check(
-    'Cockpit vision control exposes Normal, CRT, NVG, FLIR, Anime, Noir and Snow before wrapping',
+    'Cockpit vision control exposes Normal, CRT, NVG, FLIR, Anime and Noir before wrapping',
     JSON.stringify(visionCycle.states.map((state) => state.mode)) === JSON.stringify(cycleModes)
       && JSON.stringify(visionCycle.states.map((state) => state.label)) === JSON.stringify(cycleLabels)
       && visionCycle.states[5]?.aria === 'Current cockpit vision style: Noir. Activate for next style.'
-      && visionCycle.states[7]?.aria === 'Current cockpit vision style: Normal. Activate for next style.',
+      && visionCycle.states[6]?.aria === 'Current cockpit vision style: Normal. Activate for next style.',
     JSON.stringify(visionCycle.states.map(({ mode, label, aria }) => ({ mode, label, aria }))),
   );
   check(
     'user vision changes open Display for every temporary treatment and retain selector focus',
-    visionCycle.states.slice(1, 7).every((state) => state.displayOpen === 'true')
-      && visionCycle.states.slice(1, 7).every((state) => state.radioOpen === 'false')
-      && visionCycle.states.slice(1, 7).every((state) => state.parametersActive)
-      && visionCycle.states.slice(1, 7).every((state) => !state.parametersCollapsed)
-      && visionCycle.states.slice(1, 7).every((state) => state.signalCollapsed)
+    visionCycle.states.slice(1, 6).every((state) => state.displayOpen === 'true')
+      && visionCycle.states.slice(1, 6).every((state) => state.radioOpen === 'false')
+      && visionCycle.states.slice(1, 6).every((state) => state.parametersActive)
+      && visionCycle.states.slice(1, 6).every((state) => !state.parametersCollapsed)
+      && visionCycle.states.slice(1, 6).every((state) => state.signalCollapsed)
       && visionCycle.states.every((state) => state.focusRetained),
     JSON.stringify(visionCycle.states),
   );
   check(
     'each Cockpit vision mode drives only its own shader and Normal clears them all',
-    visionCycle.states.slice(1, 7).every((state) => {
+    visionCycle.states.slice(1, 6).every((state) => {
       const target = {
-        crt: 'retro', nvg: 'surveillance', thermal: 'thermal', anime: 'anime', noir: 'noir', snow: 'snow',
+        crt: 'retro', nvg: 'surveillance', thermal: 'thermal', anime: 'anime', noir: 'noir',
       }[state.mode];
       return Object.entries(state.intensities).every(([name, value]) =>
         name === target ? value > 0 : value === 0);
     })
-      && Object.values(visionCycle.states[7].intensities).every((value) => value === 0),
+      && Object.values(visionCycle.states[6].intensities).every((value) => value === 0),
     JSON.stringify(visionCycle.states.map(({ mode, intensities }) => ({ mode, intensities }))),
   );
   check(
@@ -1751,7 +1751,7 @@ try {
     return state;
   }, { variantName: variant, kind: openKind });
 
-  for (const variant of ['off', 'minimal', 'tactical', 'operator']) {
+  for (const variant of ['off', 'minimal', 'tactical']) {
     for (const kind of ['display', 'radio']) {
       const state = await desktopState(variant, kind);
       check(
@@ -2081,7 +2081,7 @@ try {
       await page.screenshot({ path: path.join(shotsDir, `cyber-resize-${height}.png`) });
     }
   }
-  await page.evaluate(() => window.__godsEyeView.styleManager._setHudVariant('operator'));
+  await page.evaluate(() => window.__godsEyeView.styleManager._setHudVariant('tactical'));
 
   const signalTransition = await page.evaluate(() => {
     const manager = window.__godsEyeView.styleManager;
@@ -2317,13 +2317,13 @@ try {
     const styleManager = window.__godsEyeView.styleManager;
     const styleBefore = styleManager.activeStyle;
     // A Cockpit-only choice that Reset must undo.
-    styleManager.cockpitView.setVisionMode('snow');
+    styleManager.cockpitView.setVisionMode('anime');
     window.__qaCockpitReset = {
       calls: 0,
       original: manager.resetToGlobeView,
       subjectId: awareness?.getContextSnapshot?.()?.subject?.id || null,
       styleBefore,
-      snowDuringCockpit: styleManager.stages?.snow?.uniforms?.intensity,
+      animeDuringCockpit: styleManager.stages?.anime?.uniforms?.intensity,
     };
     manager.resetToGlobeView = function qaCountedCockpitReset(...args) {
       window.__qaCockpitReset.calls += 1;
@@ -2360,7 +2360,7 @@ try {
       height,
       subjectPreserved: Boolean(qa.subjectId && subjectId === qa.subjectId),
       styleRestored: gev.styleManager.activeStyle === qa.styleBefore,
-      snowDuringCockpit: qa.snowDuringCockpit,
+      animeDuringCockpit: qa.animeDuringCockpit,
       // Cockpit-time intensities are Cockpit's own, so check against the map preset.
       visionRestored: Object.entries(gev.styleManager.stages || {}).every(([name, stage]) =>
         name === gev.styleManager.activeStyle
@@ -2376,7 +2376,7 @@ try {
       && resetState.resetHidden
       && Math.abs(resetState.height - 18_000_000) < 150_000
       && resetState.subjectPreserved
-      && resetState.snowDuringCockpit > 0
+      && resetState.animeDuringCockpit > 0
       && resetState.styleRestored
       && resetState.visionRestored,
     JSON.stringify(resetState),

scripts/qa-directions.mjs

@@ -10,6 +10,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import puppeteer from 'puppeteer';
+import { chromeExecutablePath } from './qa-chrome.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const args = process.argv.slice(2);
@@ -35,8 +36,7 @@ const check = (name, passed, detail = '') => {
 
 const browser = await puppeteer.launch({
   headless: false,
-  executablePath:
-    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  executablePath: chromeExecutablePath(),
   args: [
     '--no-sandbox',
     '--disable-background-timer-throttling',

scripts/qa-director-timing.mjs

@@ -88,6 +88,70 @@ try {
     };
   });
   for (const [name, passed] of Object.entries(result)) check(name, passed);
+  const visibilityRestored = await page.evaluate(async () => {
+    // QA layer registration exists only in Vite dev builds.
+    if (typeof window.__gevQaRegisterLayer !== 'function') return 'skipped';
+    const { sceneDirector: director, dataManager } = window.__godsEyeView;
+    const layerId = 'director-seek-visibility-qa';
+    window.__gevQaRegisterLayer(dataManager, {
+      id: layerId,
+      name: 'Director seek visibility QA',
+      updateInterval: -1,
+      init() {},
+      enable() {},
+      disable() {},
+      update() {},
+      destroy() {},
+      getStats: () => ({ count: 0 }),
+    });
+    const scene = {
+      id: 'visibility-qa',
+      title: 'Visibility QA',
+      shots: [
+        {
+          id: 'visibility-shot',
+          title: 'Visibility shot',
+          durationSec: 0.4,
+          holdSec: 0,
+          camera: director.styleManager.getCameraState(),
+          visual: director.styleManager.getVisualState(),
+          layers: { [layerId]: { enabled: true } },
+        },
+      ],
+    };
+    director._project.scenes.push(scene);
+    try {
+      const loaded = await director.loadShot(scene.id, scene.shots[0].id, {
+        flyDuration: 0.2,
+      });
+      const disabled =
+        (await dataManager.setEnabled(layerId, false, { origin: 'user' })) &&
+        !dataManager.layers.get(layerId).enabled;
+      const sought = await director.seekScene(scene.id, 0.5);
+      return (
+        loaded?.started &&
+        disabled &&
+        sought &&
+        dataManager.layers.get(layerId).enabled
+      );
+    } finally {
+      director.stopScene();
+      director._project.scenes = director._project.scenes.filter(
+        ({ id }) => id !== scene.id,
+      );
+      await window.__gevQaUnregisterLayer(dataManager, layerId);
+    }
+  });
+  if (visibilityRestored === 'skipped') {
+    console.log(
+      '[SKIP] same-shot seek visibility needs a Vite dev server (QA_BASE_URL)',
+    );
+  } else {
+    check(
+      'same-shot seek restores manually changed layer visibility',
+      visibilityRestored,
+    );
+  }
   const content = await page.evaluate(async () => {
     const d = window.__godsEyeView.sceneDirector;
     const scene = d._project.scenes.find(({ title }) =>

scripts/qa-draw-tool.mjs

@@ -3,6 +3,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import puppeteer from 'puppeteer';
+import { chromeExecutablePath } from './qa-chrome.mjs';
 
 const BASE_URL = process.env.QA_BASE_URL || 'http://localhost:4173';
 const SHOT_DIR = process.env.QA_SHOT_DIR || 'qa-shots/draw';
@@ -22,8 +23,7 @@ const browser = await puppeteer.launch({
   headless: !HEADFUL,
   ...(HEADFUL
     ? {
-        executablePath:
-          '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        executablePath: chromeExecutablePath(),
       }
     : {}),
   args: [

scripts/qa-emergency-squawk.mjs

@@ -0,0 +1,554 @@
+#!/usr/bin/env node
+/**
+ * qa-emergency-squawk.mjs — headless proof for transponder emergency highlighting.
+ *
+ * Drives the REAL app in headless Chromium against a dev server (keyless).
+ * `/api/flights` and `/api/military` are stubbed in the page so the codes
+ * are deterministic; everything downstream (normalizers, records, rendering,
+ * Cockpit HUD) is production code.
+ *
+ *   (i)   TINT — a civil 7600 and a military ADS-B `general` emergency are
+ *         drawn red; a normal civil flight stays white, a normal military
+ *         flight stays amber, and a military `minfuel` priority stays amber.
+ *         POLL/MODELS verify existing untracked billboards and 3D models
+ *         repaint when emergency status starts and clears.
+ *   (ii)  HUD — tracking the military emergency and entering Cockpit names
+ *         the broadcast code on the aircraft-meta line, in red.
+ *   (iii) CLEAR — the next poll drops the code: the HUD line returns to its
+ *         normal wording (the status is not sticky).
+ *   (iv)  RELEASE — the code returns and tracking stops: the restored fleet
+ *         billboard is red, not the plain military amber.
+ *
+ * Screenshots saved to qa-shots/emergency-*.png (gitignored).
+ *
+ * Run:  node scripts/qa-emergency-squawk.mjs --url http://localhost:4173
+ * Optional: --timeout-ms 180000 for a slow boot.
+ * Exits non-zero on any FAIL. Does not commit anything.
+ */
+
+import puppeteer from 'puppeteer';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, '..');
+const SHOTS_DIR = path.join(REPO_ROOT, 'qa-shots');
+
+const argv = process.argv.slice(2);
+const getOpt = (name, dflt) => {
+  const i = argv.indexOf(name);
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : dflt;
+};
+const APP_URL = getOpt('--url', 'http://localhost:4173');
+const HEADFUL = argv.includes('--headful');
+const TIMEOUT_MS = Number(getOpt('--timeout-ms', '60000'));
+const CENTER = { lon: 4.0, lat: 53.5 };
+
+const results = [];
+function record(name, ok, detail) {
+  results.push({ name, ok, detail });
+  const tag = ok ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m';
+  console.log(`  [${tag}] ${name}${detail ? `  — ${detail}` : ''}`);
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** OpenSky state vector: squawk sits at index 14. */
+const civilRow = (icao24, callsign, lon, lat, squawk) => [
+  icao24,
+  callsign,
+  'Netherlands',
+  null,
+  null,
+  lon,
+  lat,
+  10000,
+  false,
+  230,
+  90,
+  0,
+  null,
+  10050,
+  squawk,
+  false,
+  0,
+];
+
+/** readsb row as adsb.lol /v2/mil returns it. */
+const milRow = (hex, flight, lon, lat, squawk, emergency) => ({
+  hex,
+  flight,
+  lon,
+  lat,
+  alt_baro: 24000,
+  alt_geom: 24200,
+  gs: 380,
+  track: 270,
+  t: 'C17',
+  r: `QA-${hex}`,
+  squawk,
+  emergency,
+  seen: 1,
+  seen_pos: 1,
+});
+
+/** Page-side route stubs; `__squawkQaPhase` switches the military emergency off. */
+function installStubs() {
+  const realFetch = window.fetch.bind(window);
+  window.__squawkQaPhase = 'emergency';
+  const json = (body) =>
+    Promise.resolve(
+      new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      }),
+    );
+  window.fetch = (input, init) => {
+    const url = typeof input === 'string' ? input : input?.url || '';
+    const now = Date.now();
+    const { civil, mil } = window.__squawkQaFixtures;
+    if (
+      url.includes('/api/flights/track') ||
+      url.includes('/api/military/track')
+    )
+      return json({ path: [] });
+    if (url.includes('/api/flights')) {
+      const t = Math.floor(now / 1000);
+      return json({
+        time: t,
+        states: civil.map((row) => {
+          const copy = [...row];
+          copy[3] = t - 1;
+          copy[4] = t - 1;
+          return copy;
+        }),
+      });
+    }
+    if (url.includes('/api/military')) {
+      const cleared = window.__squawkQaPhase === 'cleared';
+      return json({
+        msg: 'No error',
+        now,
+        ac: mil.map((row) =>
+          cleared && row.hex === 'ae7700'
+            ? { ...row, squawk: '4521', emergency: 'none' }
+            : row,
+        ),
+      });
+    }
+    return realFetch(input, init);
+  };
+}
+
+/** Colour of every shown fleet billboard whose id is one of `ids`. */
+function billboardColors(ids) {
+  const { viewer } = window.__godsEyeView;
+  const found = {};
+  const seen = new Set();
+  const visit = (primitive) => {
+    if (!primitive || seen.has(primitive)) return;
+    seen.add(primitive);
+    if (
+      typeof primitive.length !== 'number' ||
+      typeof primitive.get !== 'function'
+    )
+      return;
+    for (let i = 0; i < primitive.length; i++) {
+      const item = primitive.get(i);
+      if (item?.color && ids.includes(item.id) && item.show !== false) {
+        found[item.id] = {
+          r: Math.round(item.color.red * 255),
+          g: Math.round(item.color.green * 255),
+          b: Math.round(item.color.blue * 255),
+        };
+      } else visit(item);
+    }
+  };
+  visit(viewer.scene.primitives);
+  return found;
+}
+
+const isRed = (c) => Boolean(c) && c.r > 200 && c.g < 110 && c.b < 110;
+const isWhite = (c) => Boolean(c) && c.r > 220 && c.g > 220 && c.b > 220;
+const isAmber = (c) =>
+  Boolean(c) && c.r > 180 && c.g > 110 && c.b < 140 && !isRed(c);
+
+async function shoot(page, name) {
+  await page
+    .waitForFunction(
+      () => window.__godsEyeView.viewer.scene.globe.tilesLoaded,
+      { timeout: 30000 },
+    )
+    .catch(() => {});
+  await sleep(600);
+  await page.screenshot({
+    path: path.join(SHOTS_DIR, `emergency-${name}.png`),
+  });
+}
+
+async function main() {
+  console.log('\nEmergency squawk proof (qa-emergency-squawk)');
+  console.log(`  App URL : ${APP_URL}\n`);
+  try {
+    const res = await fetch(APP_URL);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  } catch (e) {
+    console.error(
+      `\x1b[31mDev server not reachable at ${APP_URL} (${e.message}).\x1b[0m`,
+    );
+    process.exit(2);
+  }
+  fs.mkdirSync(SHOTS_DIR, { recursive: true });
+  const executablePath =
+    process.env.PUPPETEER_EXECUTABLE_PATH ||
+    (await puppeteer.executablePath().catch(() => null)) ||
+    undefined;
+  const browser = await puppeteer.launch({
+    headless: HEADFUL ? false : 'new',
+    protocolTimeout: 180000,
+    ...(executablePath && fs.existsSync(executablePath)
+      ? { executablePath }
+      : {}),
+    args: [
+      '--use-gl=angle',
+      '--use-angle=swiftshader',
+      '--disable-dev-shm-usage',
+      '--disable-background-timer-throttling',
+      '--disable-renderer-backgrounding',
+      '--window-size=1440,900',
+    ],
+  });
+
+  let exitCode = 0;
+  const errors = [];
+  try {
+    const page = await browser.newPage();
+    await page.setViewport({ width: 1440, height: 900 });
+    page.on('pageerror', (e) => errors.push(e.message));
+    const { lon, lat } = CENTER;
+    await page.evaluateOnNewDocument(
+      (fixtures) => {
+        window.__squawkQaFixtures = fixtures;
+      },
+      {
+        civil: [
+          civilRow('4847a1', 'KLM7600 ', lon - 0.6, lat + 0.25, '7600'),
+          civilRow('4847a2', 'KLM1234 ', lon - 0.6, lat - 0.25, '2000'),
+        ],
+        mil: [
+          milRow('ae7700', 'RCH7700', lon + 0.6, lat + 0.25, '1200', 'general'),
+          milRow('ae0f01', 'RCH0F01', lon + 0.6, lat - 0.25, '1234', 'minfuel'),
+          milRow('ae0001', 'RCH0001', lon, lat - 0.5, '4520', 'none'),
+        ],
+      },
+    );
+    // Stub in-page rather than with request interception: an intercepted page
+    // stalls Cesium's workers (see qa-gnss.mjs).
+    await page.evaluateOnNewDocument(installStubs);
+    await page.goto(`${APP_URL}/?welcome=0`, {
+      waitUntil: 'domcontentloaded',
+      timeout: TIMEOUT_MS,
+    });
+    await page.waitForFunction(
+      () => window.__godsEyeView?.viewer && window.__godsEyeView?.dataManager,
+      { timeout: TIMEOUT_MS },
+    );
+    await sleep(5000);
+    await page.keyboard.press('Escape');
+    await page.evaluate(
+      (lo, la) => {
+        const gev = window.__godsEyeView;
+        const d2r = Math.PI / 180;
+        try {
+          gev.viewer.camera.cancelFlight();
+        } catch {
+          /* no flight active */
+        }
+        gev.viewer.camera.setView({
+          destination: gev.viewer.scene.globe.ellipsoid.cartographicToCartesian(
+            {
+              longitude: lo * d2r,
+              latitude: la * d2r,
+              height: 260000,
+            },
+          ),
+          orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+        });
+        gev.viewer.scene.requestRender?.();
+      },
+      lon,
+      lat,
+    );
+
+    // ── (i) TINT ──────────────────────────────────────────────────────────
+    console.log('(i) TINT — emergency codes through the real layers...');
+    await page.evaluate(async () => {
+      const dm = window.__godsEyeView.dataManager;
+      await dm.setEnabled('flights', true, { origin: 'user' });
+      await dm.setEnabled('military', true, { origin: 'user' });
+    });
+    const ids = ['4847a1', '4847a2', 'ae7700', 'ae0f01', 'ae0001'];
+    const probe = `(${billboardColors})(${JSON.stringify(ids)})`;
+    await page
+      .waitForFunction(`Object.keys(${probe}).length === ${ids.length}`, {
+        timeout: TIMEOUT_MS,
+        polling: 500,
+      })
+      .catch(() => {});
+    await sleep(1500);
+    const colors = await page.evaluate(probe);
+    const show = (id) => JSON.stringify(colors[id] ?? null);
+    record(
+      'TINT: civil squawk 7600 is red',
+      isRed(colors['4847a1']),
+      show('4847a1'),
+    );
+    record(
+      'TINT: normal civil flight stays white',
+      isWhite(colors['4847a2']),
+      show('4847a2'),
+    );
+    record(
+      'TINT: military ADS-B general emergency is red',
+      isRed(colors.ae7700),
+      show('ae7700'),
+    );
+    record(
+      'TINT: military minimum-fuel priority stays amber',
+      isAmber(colors.ae0f01),
+      show('ae0f01'),
+    );
+    record(
+      'TINT: normal military flight stays amber',
+      isAmber(colors.ae0001),
+      show('ae0001'),
+    );
+    await shoot(page, 'globe-tint');
+
+    // Existing untracked billboards and models must repaint in both directions.
+    await page.evaluate(async () => {
+      window.__squawkQaPhase = 'cleared';
+      await window.__godsEyeView.dataManager.refreshLayer('military');
+    });
+    record(
+      'POLL: existing military billboard clears to amber',
+      isAmber((await page.evaluate(probe)).ae7700),
+    );
+    await page.evaluate(async () => {
+      window.__squawkQaPhase = 'emergency';
+      await window.__godsEyeView.dataManager.refreshLayer('military');
+    });
+    record(
+      'POLL: existing military billboard turns red again',
+      isRed((await page.evaluate(probe)).ae7700),
+    );
+    const modelProbe = () => {
+      const found = {};
+      const visit = (items) => {
+        for (let i = 0; i < items.length; i++) {
+          const item = items.get(i);
+          if (item.ready && item.color && typeof item.id === 'string')
+            found[item.id] = {
+              r: Math.round(item.color.red * 255),
+              g: Math.round(item.color.green * 255),
+              b: Math.round(item.color.blue * 255),
+            };
+          else if (item.get) visit(item);
+        }
+      };
+      visit(window.__godsEyeView.viewer.scene.primitives);
+      return found;
+    };
+    await page.waitForFunction(
+      `(${modelProbe})()['4847a1'] && (${modelProbe})().ae7700`,
+      { timeout: TIMEOUT_MS, polling: 250 },
+    );
+    const beforeModels = await page.evaluate(modelProbe);
+    record(
+      'MODELS: civil and military emergency models are red',
+      isRed(beforeModels['4847a1']) && isRed(beforeModels.ae7700),
+      JSON.stringify(beforeModels),
+    );
+    await page.evaluate(async () => {
+      window.__squawkQaFixtures.civil[0][14] = '2000';
+      window.__squawkQaFixtures.civil[1][14] = '7600';
+      window.__squawkQaPhase = 'cleared';
+      const dm = window.__godsEyeView.dataManager;
+      await dm.refreshLayer('flights');
+      await dm.refreshLayer('military');
+    });
+    await page.waitForFunction(
+      `(${modelProbe})()['4847a1']?.g > 220 && (${modelProbe})()['4847a2']?.g < 110 && (${modelProbe})().ae7700?.g > 110`,
+      { timeout: TIMEOUT_MS, polling: 250 },
+    );
+    const afterModels = await page.evaluate(modelProbe);
+    record(
+      'MODELS: existing civil models start and clear, military clears',
+      isWhite(afterModels['4847a1']) &&
+        isRed(afterModels['4847a2']) &&
+        isAmber(afterModels.ae7700),
+      JSON.stringify(afterModels),
+    );
+    await page.evaluate(async () => {
+      window.__squawkQaFixtures.civil[0][14] = '7600';
+      window.__squawkQaFixtures.civil[1][14] = '2000';
+      window.__squawkQaFixtures.mil[0].squawk = '7700';
+      window.__squawkQaPhase = 'emergency';
+      const dm = window.__godsEyeView.dataManager;
+      await dm.refreshLayer('flights');
+      await dm.refreshLayer('military');
+    });
+    // ── (ii) HUD ──────────────────────────────────────────────────────────
+    console.log('\n(ii) HUD — track the emergency and enter Cockpit...');
+    const tracked = await page.evaluate(() =>
+      Boolean(
+        window.__godsEyeView.dataManager.layers
+          .get('military')
+          .module.trackById('ae7700', { origin: 'user' }),
+      ),
+    );
+    record(
+      'HUD: emergency aircraft can be tracked',
+      tracked,
+      `tracked=${tracked}`,
+    );
+    // Cockpit entry is gated on the Contacts (flights) context mode.
+    await page.evaluate(() =>
+      window.__godsEyeView.styleManager._contextControls._selectContextMode(
+        'flights',
+      ),
+    );
+    await page
+      .waitForFunction(
+        () => {
+          const entry = document.getElementById('cockpit-entry');
+          return entry && !entry.hidden && !entry.disabled;
+        },
+        { timeout: 20000 },
+      )
+      .catch(() => {});
+    await page
+      .$eval('#cockpit-entry', (entry) => entry.click())
+      .catch(() => {});
+    const hudReady = await page
+      .waitForFunction(
+        () =>
+          document.body.classList.contains('cockpit-mode') &&
+          /SQUAWK 7700/.test(
+            document.getElementById('cockpit-aircraft-meta')?.textContent || '',
+          ),
+        { timeout: 30000 },
+      )
+      .then(
+        () => true,
+        () => false,
+      );
+    const hud = await page.evaluate(() => {
+      const meta = document.getElementById('cockpit-aircraft-meta');
+      return {
+        cockpit: document.body.classList.contains('cockpit-mode'),
+        text: meta?.textContent || '',
+        emergencyClass: meta?.classList.contains('emergency') || false,
+        color: meta ? getComputedStyle(meta).color : null,
+      };
+    });
+    record(
+      'HUD: meta line names the broadcast code',
+      hudReady && hud.text.includes('SQUAWK 7700 · GENERAL EMERGENCY'),
+      JSON.stringify(hud),
+    );
+    record(
+      'HUD: meta line is styled as an emergency',
+      hud.emergencyClass && /255,\s*68,\s*68/.test(hud.color || ''),
+      `class=${hud.emergencyClass} color=${hud.color}`,
+    );
+    const trackedBroadcast = await page.evaluate(
+      () =>
+        window.__godsEyeView.dataManager.layers
+          .get('military')
+          .module.getTrackedInfo().emergencyBroadcast,
+    );
+    record(
+      'TRACKED: voice-facing status quotes the broadcast',
+      trackedBroadcast === 'broadcasting squawk 7700 (general emergency)',
+      trackedBroadcast,
+    );
+    await shoot(page, 'cockpit-hud');
+
+    // ── (iii) CLEAR ───────────────────────────────────────────────────────
+    console.log('\n(iii) CLEAR — the next poll drops the code...');
+    await page.evaluate(async () => {
+      window.__squawkQaPhase = 'cleared';
+      await window.__godsEyeView.dataManager.refreshLayer('military');
+    });
+    const cleared = await page
+      .waitForFunction(
+        () =>
+          !document
+            .getElementById('cockpit-aircraft-meta')
+            ?.classList.contains('emergency'),
+        { timeout: 20000 },
+      )
+      .then(
+        () => true,
+        () => false,
+      );
+    const after = await page.evaluate(
+      () => document.getElementById('cockpit-aircraft-meta')?.textContent || '',
+    );
+    record(
+      'CLEAR: HUD returns to its normal wording',
+      cleared && !after.includes('SQUAWK') && after.includes('COURSE ALIGNED'),
+      JSON.stringify(after),
+    );
+    await shoot(page, 'cockpit-cleared');
+
+    // ── (iv) RELEASE ──────────────────────────────────────────────────────
+    console.log('\n(iv) RELEASE — the code returns, then tracking stops...');
+    await page.evaluate(async () => {
+      window.__squawkQaPhase = 'emergency';
+      const dm = window.__godsEyeView.dataManager;
+      await dm.refreshLayer('military');
+      dm.layers.get('military').module.stopTracking({ origin: 'user' });
+    });
+    const releaseProbe = `(${billboardColors})(["ae7700"])`;
+    const released = await page
+      .waitForFunction(`Boolean((${releaseProbe}).ae7700)`, {
+        timeout: 20000,
+        polling: 250,
+      })
+      .then(
+        () => true,
+        () => false,
+      );
+    const releasedColor = (await page.evaluate(releaseProbe)).ae7700;
+    record(
+      'RELEASE: untracked emergency billboard is red',
+      released && isRed(releasedColor),
+      JSON.stringify(releasedColor ?? null),
+    );
+    record(
+      'no uncaught browser errors',
+      errors.length === 0,
+      errors.slice(0, 3).join(' | '),
+    );
+  } catch (err) {
+    console.error('\x1b[31mHarness error:\x1b[0m', err);
+    exitCode = 3;
+  } finally {
+    await browser.close();
+  }
+
+  const pass = results.filter((r) => r.ok).length;
+  const fail = results.length - pass;
+  console.log('\n' + '─'.repeat(60));
+  console.log(`  RESULT: ${pass} passed, ${fail} failed`);
+  console.log(`  Shots : ${SHOTS_DIR}/emergency-*.png`);
+  console.log('─'.repeat(60) + '\n');
+  process.exit(exitCode || (fail > 0 ? 1 : 0));
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(3);
+});

scripts/qa-failstate-b10.mjs

@@ -34,10 +34,6 @@
 import puppeteer from 'puppeteer';
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = path.resolve(__dirname, '..');
 
 const argv = process.argv.slice(2);
 const getOpt = (name, dflt) => {

scripts/qa-final-polish-credits.mjs

@@ -52,7 +52,6 @@ try {
       id,
       value,
     );
-  const text = () => page.$eval('#cesium-credits', (e) => e.innerText);
   const shot = async (name, osm, tiles) => {
     await sleep(300);
     const state = await page.$eval('#cesium-credits', (e) => {

scripts/qa-firms.mjs

@@ -230,16 +230,20 @@ async function main() {
 
   try {
     const res = await fetch(APP_URL);
+    // Only the status matters; an unread body can hold the socket open.
+    await res.body?.cancel();
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
   } catch (e) {
     console.error(`\x1b[31mDev server not reachable at ${APP_URL} (${e.message}).\x1b[0m`);
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
 
   const status = await fetch(`${APP_URL}/api/firms/status`).then((r) => r.json()).catch(() => null);
   if (!FIXTURES && !status?.hasKey) {
     console.error('\x1b[31mServer has no FIRMS key — run against the keyed dev server (:4420).\x1b[0m');
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
 
   fs.mkdirSync(SHOTS_DIR, { recursive: true });

scripts/qa-firstrun-mutations.mjs

@@ -30,12 +30,16 @@ const TESTS = ['src/firstRunExperience.test.mjs', 'src/standalone/startupChrome.
 const FILES = {
   keyboard: path.join(ROOT, 'src', 'ui', 'surfaceKeyboard.js'),
   module: path.join(ROOT, 'src', 'firstRunExperience.js'),
-  html: path.join(ROOT, 'index.html'),
-  css: path.join(ROOT, 'style.css'),
+  html: path.join(ROOT, 'src', 'ui', 'templates', 'welcome.html'),
+  css: path.join(ROOT, 'src', 'ui', 'styles', 'first-run.css'),
   voiceInstructions: path.join(ROOT, 'server/providers/openai/instructions.js'),
-  voiceTools: path.join(ROOT, 'server/providers/openai/tools.js'),
-  main: path.join(ROOT, 'src', 'standalone', 'startupChrome.js'),
-  ui: path.join(ROOT, 'src', 'ui.js'),
+  voiceDescriptions: path.join(
+    ROOT,
+    'server/providers/openai/toolDescriptions.js',
+  ),
+  main: path.join(ROOT, 'src', 'app', 'startupChrome.js'),
+  ui: path.join(ROOT, 'src', 'ui', 'panelPositionControls.js'),
+  radio: path.join(ROOT, 'src', 'ui', 'radioBindings.js'),
   docs: path.join(ROOT, 'docs', 'CURRENT-STATE.md'),
 };
 
@@ -63,14 +67,14 @@ const MUTATIONS = [
   {
     defect: 'the session flag is never read, so it re-nags on every reload',
     file: 'module',
-    from: "if (readStored('session', sessionStorageRef, FIRST_RUN_SESSION_KEY) === 'dismissed') return false;",
-    to: '// session check removed',
+    from: "  if (\n    readStored('session', sessionStorageRef, FIRST_RUN_SESSION_KEY) ===\n    'dismissed'\n  )\n    return false;",
+    to: '  // session check removed',
   },
   {
     defect: 'the durable flag is never read, so the checkbox does nothing',
     file: 'module',
-    from: "if (readStored('local', storage, FIRST_RUN_STORAGE_KEY) === 'suppressed') return false;",
-    to: '// durable check removed',
+    from: "  if (readStored('local', storage, FIRST_RUN_STORAGE_KEY) === 'suppressed')\n    return false;",
+    to: '  // durable check removed',
   },
   {
     defect: '?welcome=1 no longer outranks suppression, so demos cannot replay it',
@@ -105,7 +109,7 @@ const MUTATIONS = [
   {
     defect: 'the guarded resolver stops catching, so a hostile getter escapes',
     file: 'module',
-    from: "  try {\n    return kind === 'session' ? globalThis.sessionStorage : globalThis.localStorage;\n  } catch {\n    // Privacy-restricted storage should not make first launch silent.\n    return null;\n  }",
+    from: "  try {\n    return kind === 'session'\n      ? globalThis.sessionStorage\n      : globalThis.localStorage;\n  } catch {\n    // Privacy-restricted storage should not make first launch silent.\n    return null;\n  }",
     to: "  return kind === 'session' ? globalThis.sessionStorage : globalThis.localStorage;",
   },
   {
@@ -131,8 +135,8 @@ const MUTATIONS = [
   {
     defect: 'nothing watches for another surface taking the screen',
     file: 'module',
-    from: "surfaceObserver?.observe(documentRef.body, { attributes: true, attributeFilter: ['class'] });",
-    to: '/* observer never attached */',
+    from: "    surfaceObserver?.observe(documentRef.body, {\n      attributes: true,\n      attributeFilter: ['class'],\n    });",
+    to: '    /* observer never attached */',
   },
   {
     defect: 'cockpit drops off the exclusive list and can stack with the launcher',
@@ -155,8 +159,8 @@ const MUTATIONS = [
   {
     defect: 'isTopmost stops hit-testing, so an unclassed overlay buries the card again',
     file: 'module',
-    from: '    && root.getClientRects().length > 0\n    && !coveredByOverlay();',
-    to: '    && root.getClientRects().length > 0;',
+    from: '    root.getClientRects().length > 0 &&\n    !coveredByOverlay();',
+    to: '    root.getClientRects().length > 0;',
   },
   {
     defect: 'an inconclusive hit test reads as COVERED, so ESC quietly stops working',
@@ -171,12 +175,12 @@ const MUTATIONS = [
     to: '    /* belt removed */',
   },
   {
-    // Anchored past the call so it cannot land on the cockpit disclosure's own
-    // stopImmediatePropagation() a few lines below and prove nothing about this.
-    defect: 'the radio disclosure returns to stopPropagation, so one ESC does two things',
-    file: 'ui',
-    from: '      event.stopImmediatePropagation();\n      const escapedFromDisclosure = event.target === this._contextRadioToggleBtn',
-    to: '      event.stopPropagation();\n      const escapedFromDisclosure = event.target === this._contextRadioToggleBtn',
+    // Anchored past the call so it lands on the Cockpit utility disclosure's
+    // Escape claim and nowhere else.
+    defect: 'a Cockpit utility disclosure returns to stopPropagation, so later document listeners also act on its ESC',
+    file: 'radio',
+    from: "      event.stopImmediatePropagation();\n      const kind = displayOpen ? 'display' : 'radio';",
+    to: "      event.stopPropagation();\n      const kind = displayOpen ? 'display' : 'radio';",
   },
   {
     defect: 'the "no timer" decision is deleted, so the next editor re-litigates it blind',
@@ -234,7 +238,7 @@ const MUTATIONS = [
   {
     defect: 'the removed INFRASTRUCTURE tile comes back as a one-click globe dump',
     file: 'module',
-    from: "  environmental: Object.freeze({",
+    from: '  environmental: Object.freeze({',
     to: "  infrastructure: Object.freeze({\n    kind: 'globe',\n    layerIds: Object.freeze(['local-datacenters', 'local-dams', 'telegeography-submarine-cables']),\n    busyText: 'Mapping global infrastructure…',\n  }),\n  environmental: Object.freeze({",
   },
   {
@@ -326,8 +330,8 @@ const MUTATIONS = [
   {
     defect: 'the Context panel is left collapsed, hiding the mode that just started',
     file: 'module',
-    from: "styleManager.setPanelCollapsed?.('global-context-panel', false, { explicit: true });",
-    to: '// panel reveal removed',
+    from: "            styleManager.setPanelCollapsed?.('global-context-panel', false, {\n              explicit: true,\n            });",
+    to: '            // panel reveal removed',
   },
   {
     defect: 'the decision table is deleted, so the next editor re-litigates it blind',
@@ -340,8 +344,8 @@ const MUTATIONS = [
   {
     defect: 'disabling the focused tile drops the keyboard to <body> mid-flight',
     file: 'module',
-    from: "for (const button of buttons) button.setAttribute('aria-disabled', String(next));",
-    to: 'for (const button of buttons) button.disabled = next;',
+    from: "    for (const button of buttons)\n      button.setAttribute('aria-disabled', String(next));",
+    to: '    for (const button of buttons) button.disabled = next;',
   },
   {
     defect: 'Tab escapes into an app the visitor has not seen yet',
@@ -370,8 +374,8 @@ const MUTATIONS = [
   {
     defect: 'the card stays clickable through its fade-out (double-launch)',
     file: 'css',
-    from: '  transition: opacity 220ms ease, transform 280ms cubic-bezier(0.2, 0.8, 0.2, 1);\n  /* Inert until revealed AND again while fading out, so a click during the\n     dismiss animation cannot launch a second mission behind the fade. */\n  pointer-events: none;',
-    to: '  transition: opacity 220ms ease, transform 280ms cubic-bezier(0.2, 0.8, 0.2, 1);',
+    from: '  transition:\n    opacity 220ms ease,\n    transform 280ms cubic-bezier(0.2, 0.8, 0.2, 1);\n  /* Inert until revealed AND again while fading out, so a click during the\n     dismiss animation cannot launch a second mission behind the fade. */\n  pointer-events: none;',
+    to: '  transition:\n    opacity 220ms ease,\n    transform 280ms cubic-bezier(0.2, 0.8, 0.2, 1);',
   },
   {
     defect: 'the launcher survives Clean-UI and recording mode',
@@ -403,8 +407,8 @@ const MUTATIONS = [
     // those instead and prove nothing about this feature.
     defect: "the launcher's reduced-motion opt-out is dropped",
     file: 'css',
-    from: '  #first-run-launcher,\n  .first-run-choices button,\n  .first-run-arrow { transition: none; }\n  /* Scrolling a tile into view must not animate either. */\n  .first-run-choices { scroll-behavior: auto; }',
-    to: '  .first-run-nothing { transition: none; }',
+    from: '  #first-run-launcher,\n  .first-run-choices button,\n  .first-run-arrow {\n    transition: none;\n  }\n  /* Scrolling a tile into view must not animate either. */\n  .first-run-choices {\n    scroll-behavior: auto;\n  }',
+    to: '  .first-run-nothing {\n    transition: none;\n  }',
   },
 
   // ── Markup and startup ordering ───────────────────────────────────────────
@@ -442,21 +446,21 @@ const MUTATIONS = [
     defect: 'the launcher is revealed before the loading cover yields',
     file: 'main',
     from: "      loadingScreen.classList.add('hidden');",
-    to: '      initFirstRunExperience({ styleManager, dataManager });\n      loadingScreen.classList.add(\'hidden\');',
+    to: "      revealFirstRun();\n      loadingScreen.classList.add('hidden');",
   },
   {
     defect: 'the globe missions lose their DataManager and cannot enable layers',
     file: 'main',
-    from: 'initFirstRunExperience({ styleManager, dataManager });',
-    to: 'initFirstRunExperience({ styleManager });',
+    from: 'firstRun = initializeWelcome?.({ styleManager, dataManager });',
+    to: 'firstRun = initializeWelcome?.({ styleManager });',
   },
 
   // ── Voice: schema must not drift ──────────────────────────────────────────
   {
     defect: 'the voice TOOL SCHEMA is edited (a Realtime prompt-cache bust)',
-    file: 'voiceTools',
-    from: "            'earthquakes',\n            'satellites',",
-    to: "            'earthquakes',\n            'infrastructure-mode',\n            'satellites',",
+    file: 'voiceDescriptions',
+    from: "'Counts, lists, superlatives and attribute filters over records loaded by ENABLED layers",
+    to: "'Counts, lists, superlatives, and attribute filters over records loaded by ENABLED layers",
   },
   {
     defect: 'the instruction mapping is dropped, so voice cannot reach the modes',

scripts/qa-firstrun.mjs

@@ -357,53 +357,6 @@ async function runArbitrationSection(page, { shots, consoleErrors }) {
       `classVisible=${afterUncoveredEsc.classVisible} session=${afterUncoveredEsc.session}`,
     );
 
-    // ── Blocker repro: a control that claims only the KEY ───────────────────
-    // The compact Radio disclosure closes on ESC from a capture listener bound
-    // long before this module exists. It called stopPropagation(), which does
-    // NOT stop later listeners on the same document — so one key closed the
-    // disclosure AND dismissed the launcher. The card is not hiding behind this
-    // one and must not yield to it: the key is simply already spoken for.
-    await open(page, { query: "?welcome=1", errorSink: consoleErrors });
-    const beforeRadio = await launcherState();
-    record('the launcher is up before the radio disclosure opens', beforeRadio.onScreen);
-    const radioOpened = await page.evaluate(() => {
-      document.getElementById('context-radio-toggle-btn')?.click();
-      return !!document.getElementById('context-radio-dock')?.classList.contains('disclosure-open');
-    });
-    await sleep(250);
-    record('the compact Radio disclosure opens', radioOpened);
-    const withRadio = await launcherState();
-    record(
-      'a small disclosure is a key contest, not a screen takeover — no yield',
-      withRadio.classVisible && withRadio.topmost,
-      `classVisible=${withRadio.classVisible} topmost=${withRadio.topmost}`,
-    );
-
-    await page.keyboard.press('Escape');
-    await sleep(400);
-    const radioAfterEsc = await page.evaluate(() => (
-      !!document.getElementById('context-radio-dock')?.classList.contains('disclosure-open')
-    ));
-    const launcherAfterRadioEsc = await launcherState();
-    record('ESC closes the disclosure', radioOpened && !radioAfterEsc,
-      `disclosure still open=${radioAfterEsc}`);
-    record(
-      'that SAME ESC does not also dismiss the launcher',
-      beforeRadio.onScreen && launcherAfterRadioEsc.classVisible
-        && launcherAfterRadioEsc.session !== 'dismissed',
-      `classVisible=${launcherAfterRadioEsc.classVisible} session=${launcherAfterRadioEsc.session} — one key, one action`,
-    );
-    // ...and the NEXT press is the launcher's, so nothing was permanently taken.
-    await page.keyboard.press('Escape');
-    await sleep(600);
-    const escAfterRadioClosed = await launcherState();
-    record(
-      'the next ESC belongs to the launcher again',
-      beforeRadio.onScreen && !escAfterRadioClosed.classVisible
-        && escAfterRadioClosed.session === 'dismissed',
-      `classVisible=${escAfterRadioClosed.classVisible} session=${escAfterRadioClosed.session}`,
-    );
-
     // ── Deferred reveal: a surface already up when the launcher would show ──
     // The class goes on as soon as the app exists, which is well before the
     // launcher's reveal (~T+1.9s), so init genuinely sees a screen it does not

scripts/qa-floorhold-mutations.mjs

@@ -26,7 +26,7 @@ const TESTS = [
 ];
 
 const FLIGHTS = 'src/layers/flights/motion.js';
-const FLOOR = 'src/data/groundFloor.js';
+const FLOOR = 'src/services/groundFloor.js';
 const ALT = 'src/data/renderAltitude.js';
 
 /** @type {Array<{defect: string, edits: Array<{file: string, from: string, to: string}>}>} */
@@ -133,8 +133,8 @@ const MUTATIONS = [
     edits: [
       {
         file: FLOOR,
-        from: '      if (lowest == null || h < lowest) lowest = h;',
-        to: '      if (lowest == null || h > lowest) lowest = h;',
+        from: '        if (lowest == null || h < lowest) lowest = h;',
+        to: '        if (lowest == null || h > lowest) lowest = h;',
       },
     ],
   },
@@ -143,8 +143,8 @@ const MUTATIONS = [
     edits: [
       {
         file: FLOOR,
-        from: '  return resolved >= NEIGHBOR_FLOOR_MIN_SAMPLES ? lowest : null;',
-        to: '  return resolved >= 1 ? lowest : null;',
+        from: '    return resolved >= NEIGHBOR_FLOOR_MIN_SAMPLES ? lowest : null;',
+        to: '    return resolved >= 1 ? lowest : null;',
       },
     ],
   },

scripts/qa-flyroute-mutations.mjs

@@ -35,17 +35,17 @@ const MUTATIONS = [
   },
   {
     defect: 'heading lerps in Cartesian space and cannot cross a U-turn',
-    from: '    const turned = Cesium.Matrix3.multiplyByVector(rotation, state.headingDir, _frameDir);',
+    from: '    const turned = Cesium.Matrix3.multiplyByVector(\n      rotation,\n      state.headingDir,\n      _frameDir,\n    );',
     to: '    const turned = Cesium.Cartesian3.lerp(state.headingDir, gaze, k, _frameDir);',
   },
   {
     defect: 'the exact-180° bank direction becomes a floating-point coin toss',
-    from: '  if (cosTurn <= -1 + ANTIPODAL_EPS && Math.abs(sinLeft) < ANTIPODAL_EPS) return Math.PI;',
+    from: '  if (cosTurn <= -1 + ANTIPODAL_EPS && Math.abs(sinLeft) < ANTIPODAL_EPS)\n    return Math.PI;',
     to: '  // branch removed',
   },
   {
     defect: 'a cold cell is read as sea level (the 1.3 km underground bug)',
-    from: '    state.floorM = Number.isFinite(state.floorM) ? state.floorM : state.coldSeedFloorM;',
+    from: '    state.floorM = Number.isFinite(state.floorM)\n      ? state.floorM\n      : state.coldSeedFloorM;',
     to: '    state.floorM = carto.height;',
   },
   {
@@ -55,12 +55,12 @@ const MUTATIONS = [
   },
   {
     defect: 'the dolly races the fire-and-forget warm instead of arming for it',
-    from: '  if (canAnswer && !state.floorKnown && !state.departed && state.armS < ROUTE_ARM_S) {',
+    from: '  if (\n    canAnswer &&\n    !state.floorKnown &&\n    !state.departed &&\n    state.armS < ROUTE_ARM_S\n  ) {',
     to: '  if (false) {',
   },
   {
     defect: 'no mesh probe, so a permanently cold DEM is flown blind',
-    from: '  if (cold.length && !state.meshProbeSpent && typeof state.probeFn === \'function\') {',
+    from: '  if (\n    cold.length &&\n    !state.meshProbeSpent &&\n    typeof state.probeFn === \'function\'\n  ) {',
     to: '  if (false) {',
   },
   {
@@ -90,8 +90,8 @@ const MUTATIONS = [
   },
   {
     defect: 'the mesh probe fires every arming frame instead of once per route',
-    from: '  if (cold.length && !state.meshProbeSpent && typeof state.probeFn === \'function\') {\n    state.meshProbeSpent = true;',
-    to: '  if (cold.length && typeof state.probeFn === \'function\') {\n    state.meshProbeSpent = true;',
+    from: '    cold.length &&\n    !state.meshProbeSpent &&\n    typeof state.probeFn === \'function\'\n  ) {\n    state.meshProbeSpent = true;',
+    to: '    cold.length &&\n    typeof state.probeFn === \'function\'\n  ) {\n    state.meshProbeSpent = true;',
   },
   {
     defect: 'one warm cell resolves a corridor whose other cells are unknown',
@@ -105,13 +105,13 @@ const MUTATIONS = [
   },
   {
     defect: 'the hard clearance clamp reads the SMOOTHED floor, not the raw sample',
-    from: '    (Number.isFinite(sampledFloor) ? sampledFloor : state.floorM) + ROUTE_MIN_CLEARANCE_M,',
+    from: '    (Number.isFinite(sampledFloor) ? sampledFloor : state.floorM) +\n      ROUTE_MIN_CLEARANCE_M,',
     to: '    state.floorM + ROUTE_MIN_CLEARANCE_M,',
   },
   {
     defect: 'levelling also RE-FRAMES the camera (destination passed with the HPR)',
-    from: '    cam.setView({ orientation: { heading: cam.heading, pitch: cam.pitch, roll: 0 } });',
-    to: '    cam.setView({ destination: Cesium.Cartesian3.fromDegrees(0, 0, 5000), orientation: { heading: cam.heading, pitch: cam.pitch, roll: 0 } });',
+    from: '    cam.setView({\n      orientation: { heading: cam.heading, pitch: cam.pitch, roll: 0 },\n    });',
+    to: '    cam.setView({\n      destination: Cesium.Cartesian3.fromDegrees(0, 0, 5000),\n      orientation: { heading: cam.heading, pitch: cam.pitch, roll: 0 },\n    });',
   },
   {
     defect: 'the OS reduced-motion preference is never consulted',

scripts/qa-form-fields.mjs

@@ -0,0 +1,465 @@
+#!/usr/bin/env node
+/** Native form-field regression gate. CCTV ports are fixtures, never live writes. */
+import fs from 'node:fs';
+import puppeteer from 'puppeteer';
+
+const browser = await puppeteer.launch({
+  headless: true,
+  args: ['--use-gl=angle', '--use-angle=swiftshader'],
+});
+const page = await browser.newPage();
+page.setDefaultNavigationTimeout(60000);
+let failures = 0;
+const errors = [];
+page.on('pageerror', (error) => errors.push(error.message));
+const check = (name, passed, detail) => {
+  console.log(`[${passed ? 'PASS' : 'FAIL'}] ${name}`);
+  if (!passed) {
+    failures++;
+    console.log(JSON.stringify(detail));
+  }
+};
+fs.mkdirSync('qa-shots/form-fields', { recursive: true });
+try {
+  await page.setViewport({ width: 1440, height: 900 });
+  await page.goto(
+    `${process.env.QA_BASE_URL || 'http://127.0.0.1:4183'}/?welcome=0`,
+    {
+      waitUntil: 'domcontentloaded',
+    },
+  );
+  await page.waitForFunction(
+    () =>
+      window.__godsEyeView?.styleManager?._cctvControls &&
+      document.getElementById('loading-screen')?.classList.contains('hidden'),
+    { timeout: 60000 },
+  );
+  const inventory = await page.evaluate(() => {
+    const selects = [
+      '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.every((node) => node.classList.contains('gev-field')),
+      native: selects.every(
+        (node) =>
+          node instanceof HTMLSelectElement && !node.hasAttribute('role'),
+      ),
+      dark: selects.every(
+        (node) => getComputedStyle(node).colorScheme === 'dark',
+      ),
+    };
+  });
+  check(
+    'all six panel dropdowns retain native select semantics and shared surface',
+    inventory.shared && inventory.native,
+    inventory,
+  );
+  check('native option menus keep the dark scheme', inventory.dark);
+  await page.evaluate(() => {
+    const manager = window.__godsEyeView.styleManager;
+    manager.setPanelCollapsed('pp-toggles', false, {
+      persist: false,
+      syncShare: false,
+    });
+    manager.setPanelCollapsed('scene-panel', false, {
+      persist: false,
+      syncShare: false,
+    });
+    manager.setPanelCollapsed('cctv-panel', false, {
+      persist: false,
+      syncShare: false,
+    });
+    window.__qaFormChanges = [];
+    document
+      .getElementById('scene-select')
+      .addEventListener('change', (event) =>
+        window.__qaFormChanges.push(event.target.value),
+      );
+  });
+  const ownerSetup = await page.evaluate(() => {
+    const owner = window.__godsEyeView.styleManager._cctvControls;
+    owner._cctvUnsubscribe?.();
+    owner._cctvUnsubscribe = null;
+    window.__qaFormCalls = [];
+    owner.actions = {
+      ...owner.actions,
+      isEnabled: () => true,
+      toggleEnabled: async () => true,
+      setParams: (...args) => window.__qaFormCalls.push(args),
+      runExplicitFocus: (select, focus) => focus(select()),
+      showToast: () => {},
+    };
+    owner.cctv = {
+      setParams() {},
+      focusCamera: (id) => window.__qaFormCalls.push(['focus', id]),
+      selectCamera: (id) => id,
+    };
+    owner._cctvState = {
+      enabled: true,
+      activeCameraId: 'a',
+      cameras: [
+        { id: 'a', name: 'A' },
+        { id: 'b', name: 'B' },
+      ],
+      activeCamera: {
+        id: 'a',
+        headingDeg: 30,
+        pitchDeg: -10,
+        fovDeg: 45,
+        rangeM: 120,
+        mountHeightM: 8,
+        calibration: {},
+        basePose: {
+          headingDeg: 20,
+          pitchDeg: -10,
+          fovDeg: 45,
+          rangeM: 120,
+          mountHeightM: 8,
+        },
+      },
+    };
+    owner._renderCctvState(owner._cctvState);
+    const input = document.getElementById('sdr-frequency-input');
+    return {
+      min: input.min,
+      max: input.max,
+      step: input.step,
+      type: input.type,
+      shared: input.classList.contains('gev-field'),
+    };
+  });
+  check(
+    'FM frequency retains native bounds, precision and shared surface',
+    ownerSetup.min === '87.5' &&
+      ownerSetup.max === '108' &&
+      ownerSetup.step === '0.1' &&
+      ownerSetup.type === 'number' &&
+      ownerSetup.shared,
+    ownerSetup,
+  );
+  const validity = await page.$eval('#sdr-frequency-input', (input) => {
+    const original = input.value;
+    input.value = '87.4';
+    const below = input.validity.rangeUnderflow;
+    input.value = '108.1';
+    const above = input.validity.rangeOverflow;
+    input.value = '98.55';
+    const step = input.validity.stepMismatch;
+    input.value = '';
+    const empty = input.validity.valid;
+    input.value = original;
+    return below && above && step && empty;
+  });
+  check(
+    'native numeric validity preserves underflow, overflow, steps and empty drafts',
+    validity,
+  );
+  await page.select('#cctv-camera-select', 'b');
+  await page.waitForFunction(() => window.__qaFormCalls.length === 2);
+  const cameraSelection = await page.evaluate(() => window.__qaFormCalls);
+  check(
+    'camera dropdown retains selection, focus and user-origin dispatch',
+    cameraSelection[0][0] === 'focus' &&
+      cameraSelection[0][1] === 'b' &&
+      cameraSelection[1][0].selectedCameraId === 'b' &&
+      cameraSelection[1][1].origin === 'user',
+    cameraSelection,
+  );
+  await page.evaluate(() => {
+    window.__qaFormCalls = [];
+    document.getElementById('cctv-camera-select').disabled = true;
+  });
+  await page.focus('#scene-select');
+  await page.focus('#cctv-camera-select');
+  check(
+    'disabled native selects cannot receive keyboard focus',
+    await page.evaluate(
+      () => document.activeElement.id !== 'cctv-camera-select',
+    ),
+  );
+  await page.evaluate(() => {
+    document.getElementById('cctv-camera-select').disabled = false;
+  });
+  const begin = async (field) => {
+    await page.evaluate((field) => {
+      const owner = window.__godsEyeView.styleManager._cctvControls;
+      owner._beginCctvCalValueEdit(
+        document.querySelector(`[data-cal-field="${field}"]`),
+      );
+    }, field);
+  };
+  for (const [field, step, value] of [
+    ['heading', '0.1', '30.0'],
+    ['pitch', '0.1', '-10.0'],
+    ['fov', '1', '45'],
+    ['range', '1', '120'],
+    ['height', '1', '8'],
+    ['north', '0.1', '0.0'],
+    ['east', '0.1', '0.0'],
+  ]) {
+    await begin(field);
+    const result = await page.$eval('.cctv-cal-input', (input) => ({
+      step: input.step,
+      value: input.value,
+      native: input.type === 'number',
+      shared: input.classList.contains('gev-field'),
+      label: input.getAttribute('aria-label'),
+      focus: document.activeElement === input,
+    }));
+    check(
+      `${field} editor retains precision, initial value and focus`,
+      result.step === step &&
+        result.value === value &&
+        result.native &&
+        result.shared &&
+        !!result.label &&
+        result.focus,
+      result,
+    );
+    await page.keyboard.press('Escape');
+  }
+  check(
+    'Escape cancels each field without a calibration write',
+    await page.evaluate(() => window.__qaFormCalls.length === 0),
+  );
+  await begin('heading');
+  await page.keyboard.press('Backspace');
+  await page.type('.cctv-cal-input', '100');
+  await page.evaluate(() => {
+    window.__godsEyeView.styleManager._cctvControls._cctvState.activeCamera.basePose.headingDeg = 60;
+  });
+  await page.keyboard.press('Enter');
+  const commit = await page.evaluate(() => window.__qaFormCalls);
+  check(
+    'Enter commits once against the frozen camera base',
+    commit.length === 1 &&
+      commit[0][0].calibration.patch.headingDeg === 80 &&
+      commit[0][0].calibration.cameraId === 'a' &&
+      commit[0][1].origin === 'user',
+    commit,
+  );
+  await begin('north');
+  await page.keyboard.press('Backspace');
+  await page.type('.cctv-cal-input', '12.5');
+  await page.$eval('.cctv-cal-input', (input) => input.blur());
+  const blur = await page.evaluate(() => window.__qaFormCalls);
+  check(
+    'blur commits a decimal offset exactly once',
+    blur.length === 2 && blur[1][0].calibration.patch.offsetNorthM === 12.5,
+    blur,
+  );
+  await begin('east');
+  await page.keyboard.press('Backspace');
+  await page.keyboard.press('Enter');
+  check(
+    'an empty numeric draft does not write calibration',
+    await page.evaluate(() => window.__qaFormCalls.length === 2),
+  );
+  await begin('heading');
+  await page.type('.cctv-cal-input', '90');
+  await page.evaluate(() => {
+    window.__godsEyeView.styleManager._cctvControls._cctvState.activeCameraId =
+      'b';
+  });
+  await page.keyboard.press('Enter');
+  check(
+    'a stale camera editor cannot commit to the next camera',
+    await page.evaluate(() => window.__qaFormCalls.length === 2),
+  );
+
+  await page.evaluate(() => {
+    for (const panel of ['pp-toggles', 'scene-panel', 'cctv-panel'])
+      window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
+        persist: false,
+        syncShare: false,
+      });
+  });
+  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 = 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,
+          };
+        });
+      });
+      check(
+        `${lang} fields fit their panels at ${width}px`,
+        layout.every((item) => item.fits),
+        layout,
+      );
+      if (width === 390)
+        await page.screenshot({
+          path: `qa-shots/form-fields/${lang}-${width}.png`,
+        });
+    }
+  }
+  await page.evaluate(() => {
+    document.documentElement.lang = 'en';
+    document.documentElement.dataset.uiTheme = 'cyber';
+  });
+  const cyber = await page.$eval(
+    '#scene-select',
+    (node) => getComputedStyle(node).backgroundColor,
+  );
+  check(
+    'Cyber keeps its native field theme',
+    cyber === 'rgba(26, 35, 39, 0.96)',
+    cyber,
+  );
+  await begin('heading');
+  await page.evaluate(() => {
+    const owner = window.__godsEyeView.styleManager._cctvControls;
+    window.__qaDetachedInput = document.querySelector('.cctv-cal-input');
+    owner.destroy();
+    window.__qaDetachedInput.dispatchEvent(new Event('blur'));
+  });
+  check(
+    'disposal removes the editor and prevents late commits',
+    await page.evaluate(
+      () =>
+        !document.querySelector('.cctv-cal-input') &&
+        window.__qaFormCalls.length === 2,
+    ),
+  );
+  // Scene selection can restore application settings. Exercise it after the
+  // fixture-owned CCTV phase so those asynchronous effects cannot replace ports.
+  page.once('dialog', (dialog) => dialog.accept('Baseline selection fixture'));
+  await page.click('#scene-new-btn');
+  await page.waitForFunction(() =>
+    [...document.querySelectorAll('#scene-select option')].some(
+      (option) => option.textContent === 'Baseline selection fixture',
+    ),
+  );
+  page.once('dialog', (dialog) => dialog.accept('QA selection fixture'));
+  await page.click('#scene-new-btn');
+  await page.waitForFunction(
+    () => document.querySelectorAll('#scene-select option').length > 1,
+  );
+  const targetSceneId = await page.$eval(
+    '#scene-select',
+    (node) =>
+      [...node.options].find(
+        (option) => option.textContent === 'QA selection fixture',
+      ).value,
+  );
+  const baselineSceneId = await page.$eval(
+    '#scene-select',
+    (node) =>
+      [...node.options].find(
+        (option) => option.textContent === 'Baseline selection fixture',
+      ).value,
+  );
+  await page.select('#scene-select', baselineSceneId);
+  await page.waitForFunction(
+    (id) => window.__godsEyeView.sceneDirector._getSelectedScene().id !== id,
+    {},
+    targetSceneId,
+  );
+  await page.evaluate(() => {
+    window.__qaFormChanges = [];
+  });
+  await page.focus('#scene-select');
+  // Typeahead is native even when headless Chrome does not drive OS popups.
+  await page.keyboard.press('q');
+  const sceneSelection = await page.evaluate(() => ({
+    id: document.getElementById('scene-select').value,
+    selected: window.__godsEyeView.sceneDirector._getSelectedScene().id,
+    changes: window.__qaFormChanges,
+    focus: document.activeElement.id,
+    outline: getComputedStyle(document.activeElement).outlineStyle,
+  }));
+  check(
+    'native typeahead reaches the Scene owner and keeps focus',
+    sceneSelection.id === targetSceneId &&
+      sceneSelection.selected === targetSceneId &&
+      sceneSelection.changes.at(-1) === targetSceneId &&
+      sceneSelection.focus === 'scene-select',
+    sceneSelection,
+  );
+  check('keyboard focus remains visible', sceneSelection.outline === 'solid');
+  const localized = new URL(page.url());
+  localized.searchParams.set('lang', 'ru');
+  await page.goto(localized.href, { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(
+    () =>
+      window.__godsEyeView?.styleManager?._cctvControls &&
+      document.getElementById('loading-screen')?.classList.contains('hidden'),
+    { timeout: 60000 },
+  );
+  await page.evaluate(() => {
+    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', 'scene-panel', 'cctv-panel'])
+      window.__godsEyeView.styleManager.setPanelCollapsed(panel, false, {
+        persist: false,
+        syncShare: false,
+      });
+  });
+  if (
+    await page.$eval(
+      '#draw-toggle',
+      (node) => node.getAttribute('aria-pressed') !== 'true',
+    )
+  )
+    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,
+      )
+    );
+  });
+  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);
+} finally {
+  await browser.close();
+}
+process.exitCode = failures ? 1 : 0;

scripts/qa-gbfs-names.mjs

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+/**
+ * Keyless station-name regression against the real globe and bike-share tool.
+ * Run with a dev or preview server: node scripts/qa-gbfs-names.mjs --url http://localhost:4173
+ * GBFS documents are synthetic; no operator feed or provider key is required.
+ */
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import puppeteer from 'puppeteer';
+
+const urlIndex = process.argv.indexOf('--url');
+const appUrl =
+  urlIndex < 0 ? 'http://localhost:4173' : process.argv[urlIndex + 1];
+const shots = path.resolve('qa-shots/gbfs-names');
+fs.mkdirSync(shots, { recursive: true });
+const information = {
+  version: '3.0',
+  data: {
+    stations: [
+      {
+        station_id: 'english',
+        name: [
+          { language: 'hu', text: 'Magyar tér' },
+          { language: 'en', text: 'QA English Square' },
+        ],
+      },
+      {
+        station_id: 'short',
+        name: [null, { language: 'en', text: ' ' }],
+        short_name: [{ language: 'en-GB', text: 'QA Short Name' }],
+      },
+      { station_id: 'unnamed', name: [null, {}, { language: 42, text: [] }] },
+      { station_id: 'legacy', name: ' QA Legacy Station ' },
+      {
+        station_id: 'fallback',
+        name: [null, { language: 'hu', text: 'QA Magyar Station' }],
+      },
+    ].map((station, index) => ({
+      ...station,
+      lat: 30.2681 + index * 0.001,
+      lon: -97.7469 + index * 0.001,
+      capacity: 13,
+    })),
+  },
+};
+const status = {
+  data: {
+    stations: information.data.stations.map(({ station_id }) => ({
+      station_id,
+      num_bikes_available: 4,
+      num_docks_available: 9,
+      is_renting: true,
+      is_returning: true,
+    })),
+  },
+};
+const browser = await puppeteer.launch({
+  headless: 'new',
+  ...(process.env.PUPPETEER_EXECUTABLE_PATH
+    ? { executablePath: process.env.PUPPETEER_EXECUTABLE_PATH }
+    : {}),
+  args:
+    process.platform === 'darwin'
+      ? ['--use-angle=metal']
+      : ['--use-gl=angle', '--use-angle=swiftshader'],
+});
+let checks = 0;
+const check = (name, actual, expected) => {
+  assert.deepEqual(actual, expected, name);
+  checks++;
+  console.log(`[PASS] ${name}`);
+};
+async function open(mode = 'normal') {
+  const page = await browser.newPage();
+  await page.bringToFront();
+  const errors = [];
+  page.on('pageerror', (error) => errors.push(error.message));
+  await page.setViewport({ width: 1440, height: 900 });
+  await page.evaluateOnNewDocument(
+    ({ information, status, mode }) => {
+      localStorage.clear();
+      localStorage.setItem('gev:first-run-mission:v1', 'suppressed');
+      window.__qaPainted = [];
+      const paint = CanvasRenderingContext2D.prototype.fillText;
+      CanvasRenderingContext2D.prototype.fillText = function (text, ...args) {
+        if (
+          String(text).startsWith('QA ') ||
+          String(text) === 'Station unnamed'
+        ) {
+          window.__qaPainted.push(String(text));
+          if (window.__qaPainted.length > 100) window.__qaPainted.shift();
+        }
+        return paint.call(this, text, ...args);
+      };
+      const original = window.fetch.bind(window);
+      window.fetch = async (input, init) => {
+        const url = String(
+          typeof input === 'string' || input instanceof URL ? input : input.url,
+        );
+        if (url.includes('/api/gbfs/')) {
+          if (mode === 'failure') return new Response('{}', { status: 503 });
+          const payload =
+            mode === 'empty'
+              ? { data: { stations: [] } }
+              : decodeURIComponent(url).includes('station_information')
+                ? information
+                : status;
+          return new Response(JSON.stringify(payload), {
+            headers: { 'Content-Type': 'application/json' },
+          });
+        }
+        if (url.includes('/api/flights')) return new Response('{"states":[]}');
+        if (url.includes('/api/military')) return new Response('{"ac":[]}');
+        if (url.includes('/api/vessels'))
+          return new Response('{"connected":false,"vessels":[]}');
+        return original(input, init);
+      };
+    },
+    { information, status, mode },
+  );
+  await page.goto(appUrl, { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(
+    () =>
+      window.__godsEyeView?.dataManager && window.__godsEyeView?.voiceCommands,
+    { timeout: 60000 },
+  );
+  await page.waitForFunction(
+    () =>
+      !document.getElementById('loading-screen') ||
+      (document.getElementById('loading-screen').classList.contains('hidden') &&
+        getComputedStyle(document.getElementById('loading-screen')).opacity ===
+          '0'),
+    { timeout: 60000 },
+  );
+  await page.evaluate(async () => {
+    const { dataManager, viewer } = window.__godsEyeView;
+    for (const [id, layer] of dataManager.layers) {
+      if (layer.enabled)
+        await dataManager.setEnabled(id, false, { origin: 'user' });
+    }
+    const Cartesian3 = viewer.camera.position.constructor;
+    viewer.camera.cancelFlight();
+    viewer.camera.setView({
+      destination: Cartesian3.fromDegrees(-97.7449, 30.2701, 3000),
+      orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+    });
+    await dataManager.setEnabled('bikeshare', true, { origin: 'user' });
+    window.__godsEyeView.requestRender('gbfs-name-qa');
+  });
+  return { page, errors };
+}
+try {
+  const { page, errors } = await open();
+  await page.waitForFunction(
+    () =>
+      window.__godsEyeView.dataManager.layers.get('bikeshare').module.getStats()
+        .count === 5,
+    { timeout: 15000 },
+  );
+  const records = await page.evaluate(() =>
+    window.__godsEyeView.dataManager.layers
+      .get('bikeshare')
+      .module.getAnalystRecords(),
+  );
+  check(
+    'the layer retains all five stations and normalized names',
+    records.map((r) => r.name),
+    [
+      'QA English Square',
+      'QA Short Name',
+      null,
+      'QA Legacy Station',
+      'QA Magyar Station',
+    ],
+  );
+  const tool = await page.evaluate(() =>
+    window.__godsEyeView.voiceCommands.runner('get_bike_share', {
+      area: { lat: 30.2701, lon: -97.7449, radius_km: 2 },
+    }),
+  );
+  check('the real bike-share tool succeeds', tool.ok, true);
+  check(
+    'the tool preserves localized, short, unnamed, legacy and non-English names',
+    tool.data.rows.map((r) => r.name).sort(),
+    [
+      null,
+      'QA English Square',
+      'QA Short Name',
+      'QA Legacy Station',
+      'QA Magyar Station',
+    ].sort(),
+  );
+  check(
+    'availability remains attached to every station',
+    tool.data.rows.every(
+      (r) => r.bikes_available === 4 && r.docks_available === 9,
+    ),
+    true,
+  );
+  const clickPoint = await page.evaluate(() => {
+    window.__qaPainted = [];
+    const { viewer } = window.__godsEyeView;
+    const Cartesian3 = viewer.camera.position.constructor;
+    const point = viewer.scene.cartesianToCanvasCoordinates(
+      Cartesian3.fromDegrees(-97.7469, 30.2681),
+    );
+    const rect = viewer.scene.canvas.getBoundingClientRect();
+    return { x: rect.left + point.x, y: rect.top + point.y };
+  });
+  await page.mouse.click(clickPoint.x, clickPoint.y);
+  await page.waitForFunction(
+    () => window.__qaPainted.includes('QA English Square'),
+    { timeout: 10000 },
+  );
+  check(
+    'a real pointer click selects the station with its localized name',
+    await page.evaluate(() => window.__qaPainted.includes('QA English Square')),
+    true,
+  );
+  await page.keyboard.press('Escape');
+  for (const [id, title] of [
+    ['english', 'QA English Square'],
+    ['short', 'QA Short Name'],
+    ['unnamed', 'Station unnamed'],
+  ]) {
+    await page.evaluate((id) => {
+      window.__qaPainted = [];
+      const app = window.__godsEyeView;
+      app.dataManager.layers
+        .get('bikeshare')
+        .module._selectBikeshareStationForTest(`austin-capmetro:${id}`);
+      app.requestRender('gbfs-name-selection-qa');
+    }, id);
+    await page.waitForFunction(
+      (title) => window.__qaPainted.includes(title),
+      { timeout: 10000 },
+      title,
+    );
+    check(
+      `the selected ${id} card paints the expected title`,
+      await page.evaluate((title) => window.__qaPainted.includes(title), title),
+      true,
+    );
+    await page.screenshot({ path: path.join(shots, `${id}.png`) });
+    await page.keyboard.press('Escape');
+    await page.waitForFunction(() =>
+      window.__godsEyeView.dataManager.layers
+        .get('bikeshare')
+        .module.getDetectableObjects()
+        .every((record) => !record.skipLabel),
+    );
+    check(
+      `Escape clears the ${id} card`,
+      await page.evaluate(
+        () =>
+          window.__godsEyeView.dataManager.layers
+            .get('bikeshare')
+            .module.getDetectableObjects()
+            .filter((record) => record.skipLabel).length,
+      ),
+      0,
+    );
+  }
+  await page.setViewport({ width: 390, height: 844 });
+  await page.evaluate(() => {
+    window.__qaPainted = [];
+    const app = window.__godsEyeView;
+    // Use the supported clean view to inspect the mobile card clear of panels.
+    app.styleManager.toggleCleanView(true);
+    const Cartesian3 = app.viewer.camera.position.constructor;
+    app.viewer.camera.cancelFlight();
+    app.viewer.camera.setView({
+      destination: Cartesian3.fromDegrees(-97.7449, 30.2701, 3000),
+      orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+    });
+    app.dataManager.layers
+      .get('bikeshare')
+      .module._selectBikeshareStationForTest('austin-capmetro:english');
+    app.requestRender('gbfs-name-mobile-qa');
+  });
+  await page.waitForFunction(
+    () => window.__qaPainted.includes('QA English Square'),
+    { timeout: 10000 },
+  );
+  check(
+    'the mobile selected card paints its normalized name',
+    await page.evaluate(() => window.__qaPainted.includes('QA English Square')),
+    true,
+  );
+  await page.screenshot({ path: path.join(shots, 'mobile.png') });
+  await page.evaluate(() =>
+    window.__godsEyeView.dataManager.setEnabled('bikeshare', false, {
+      origin: 'user',
+    }),
+  );
+  check(
+    'disabling clears selected cards and analyst records',
+    await page.evaluate(() => ({
+      count: window.__godsEyeView.dataManager.layers
+        .get('bikeshare')
+        .module.getAnalystRecords().length,
+      selected: window.__godsEyeView.dataManager.layers
+        .get('bikeshare')
+        .module.getDetectableObjects()
+        .filter((record) => record.skipLabel).length,
+    })),
+    { count: 0, selected: 0 },
+  );
+  check('normal fixtures produce no page exceptions', errors, []);
+  await page.close();
+  for (const mode of ['empty', 'failure']) {
+    const { page, errors } = await open(mode);
+    await page.waitForFunction(
+      () =>
+        !window.__godsEyeView.dataManager.layers
+          .get('bikeshare')
+          .module.getStats().loading,
+    );
+    check(
+      `${mode} leaves no rendered stations`,
+      await page.evaluate(
+        () =>
+          window.__godsEyeView.dataManager.layers
+            .get('bikeshare')
+            .module.getStats().count,
+      ),
+      0,
+    );
+    check(`${mode} produces no page exceptions`, errors, []);
+    await page.close();
+  }
+  console.log(`GBFS names: ${checks}/${checks} checks passed; ${appUrl}`);
+} finally {
+  await browser.close();
+}

scripts/qa-geo-import-large.mjs

@@ -0,0 +1,446 @@
+#!/usr/bin/env node
+/** Large KML acceptance: style equivalence, 27.6 MB import and optional real file.
+ * QA_BASE_URL defaults to http://localhost:4173. Optional --file /path/file.kml.
+ * For a USGS fixture with blocked icons, add --expect-local-pins to check paint.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import puppeteer from 'puppeteer';
+import { hookRenderErrors, readRenderErrors } from './qa-browserEvidence.mjs';
+
+const base = process.env.QA_BASE_URL || 'http://localhost:4173';
+const supplied = process.argv.includes('--file')
+  ? path.resolve(process.argv[process.argv.indexOf('--file') + 1])
+  : null;
+const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'gev-large-kml-'));
+const file = path.join(directory, 'metadata-rich-27mb.kml');
+const style =
+  '<Style><IconStyle><scale>0.6</scale><color>ff00dd66</color></IconStyle></Style>';
+const notes = 'A local observation with supporting detail. '.repeat(120);
+const placemarks = Array.from({ length: 5000 }, (_, i) => {
+  const lon = -122.6 + (i % 100) * 0.002;
+  const lat = 37.65 + Math.floor(i / 100) * 0.003;
+  return `<Placemark><name>Point ${i}</name><styleUrl>#base</styleUrl>${style}<description>${notes}</description><Point><coordinates>${lon},${lat},0</coordinates></Point></Placemark>`;
+});
+const wrap = (body) =>
+  `<kml xmlns="http://www.opengis.net/kml/2.2"><Document><Style id="base"><IconStyle><heading>25</heading><scale>1.2</scale></IconStyle><LineStyle><color>ffdd6600</color><width>7</width></LineStyle><PolyStyle><color>6600ddff</color><fill>1</fill><outline>0</outline></PolyStyle></Style>${body}</Document></kml>`;
+const large = wrap(placemarks.join(''));
+fs.writeFileSync(file, large);
+const bytes = fs.statSync(file).size;
+if (bytes < 20 * 1024 * 1024 || bytes > 30 * 1024 * 1024)
+  throw new Error(`Fixture must be 20–30 MiB, got ${bytes} bytes`);
+const small = wrap(
+  Array.from({ length: 6 }, (_, i) => {
+    const kind = i % 3;
+    const geometry =
+      kind === 0
+        ? '<Point><coordinates>-122.49,37.77,0</coordinates></Point>'
+        : kind === 1
+          ? '<LineString><coordinates>-122.50,37.77,0 -122.49,37.77,0</coordinates></LineString>'
+          : '<Polygon><outerBoundaryIs><LinearRing><coordinates>-122.50,37.77,0 -122.49,37.77,0 -122.49,37.78,0 -122.50,37.77,0</coordinates></LinearRing></outerBoundaryIs></Polygon>';
+    const override =
+      kind === 0
+        ? style
+        : kind === 1
+          ? '<Style><LineStyle><width>3</width></LineStyle></Style>'
+          : '<Style><PolyStyle><outline>1</outline></PolyStyle></Style>';
+    return `<Placemark><name>Small ${i}</name><styleUrl>#base</styleUrl>${override}${geometry}</Placemark>`;
+  }).join('') +
+    '<Style id="named-a"><IconStyle><scale>0.8</scale></IconStyle></Style>' +
+    '<Style id="named-b"><IconStyle><scale>0.8</scale></IconStyle></Style>' +
+    '<StyleMap id="paired"><Pair><key>normal</key><Style><IconStyle><scale>0.8</scale></IconStyle></Style></Pair></StyleMap>' +
+    ['named-a', 'named-b', 'paired']
+      .map(
+        (id) =>
+          `<Placemark><name>${id}</name><styleUrl>#${id}</styleUrl><Point><coordinates>-122.49,37.77,0</coordinates></Point></Placemark>`,
+      )
+      .join(''),
+);
+const browser = await puppeteer.launch({
+  headless: true,
+  args:
+    process.platform === 'darwin'
+      ? ['--use-gl=angle', '--use-angle=metal']
+      : ['--no-sandbox', '--use-gl=angle', '--use-angle=swiftshader'],
+});
+const page = await browser.newPage();
+await hookRenderErrors(page);
+const errors = [];
+const fileRequests = [];
+page.on('pageerror', (e) => errors.push(e.message));
+await page.setRequestInterception(true);
+page.on('request', (request) => {
+  if (new URL(request.url()).hostname === 'earthquake.usgs.gov') {
+    fileRequests.push(request.url());
+    void request.abort();
+  } else void request.continue();
+});
+let failures = 0;
+const check = (name, ok, detail) => {
+  console.log(`[${ok ? 'PASS' : 'FAIL'}] ${name}`, detail ?? '');
+  if (!ok) failures++;
+};
+try {
+  await page.setViewport({ width: 1440, height: 900 });
+  await page.goto(`${base}/?welcome=0`, { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(
+    () =>
+      window.__gevGeoImport &&
+      document.getElementById('loading-screen')?.classList.contains('hidden'),
+    { timeout: 60000 },
+  );
+  await page.evaluate(async () => {
+    const { viewer, dataManager } = window.__godsEyeView;
+    const C = window.__CESIUM__;
+    for (const id of dataManager.layers.keys())
+      await dataManager.setEnabled(id, false);
+    viewer.clock.shouldAnimate = false;
+    viewer.imageryLayers.removeAll();
+    viewer.terrainProvider = new C.EllipsoidTerrainProvider();
+    viewer.camera.cancelFlight();
+    viewer.camera.setView({
+      destination: C.Cartesian3.fromDegrees(-122.5, 37.72, 50000),
+      orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+    });
+    window.__qaStyleSnapshot = (source) => {
+      const now = viewer.clock.currentTime;
+      const images = new Map();
+      const imageValue = (p) => {
+        const value = p?.getValue(now);
+        if (value?.tagName !== 'CANVAS') return value;
+        if (!images.has(value)) images.set(value, value.toDataURL());
+        return images.get(value);
+      };
+      const color = (p) => p?.getValue(now)?.toCssColorString();
+      const positions = (p) => p?.getValue(now)?.map((v) => [v.x, v.y, v.z]);
+      const renderedPins = new Map();
+      const collection = source.importedBillboards;
+      if (collection)
+        for (let i = 0; i < collection.length; i++) {
+          const pin = collection.get(i);
+          renderedPins.set(pin.id, pin);
+        }
+      const actual = (e, key, fallback) => {
+        const pin = renderedPins.get(e);
+        return pin ? pin[key] : (e.billboard?.[key]?.getValue(now) ?? fallback);
+      };
+      return (source.importedEntities || source.entities.values)
+        .map((e) => ({
+          name: e.name,
+          point: renderedPins.get(e)?.position || e.position?.getValue(now),
+          scale: e.billboard ? actual(e, 'scale', 1) : undefined,
+          rotation: e.billboard ? actual(e, 'rotation', 0) : undefined,
+          image: renderedPins.get(e)?.image || imageValue(e.billboard?.image),
+          color: e.billboard
+            ? actual(e, 'color', C.Color.WHITE).toCssColorString()
+            : undefined,
+          width: e.polyline?.width?.getValue(now),
+          lineColor: color(e.polyline?.material?.color),
+          line: positions(e.polyline?.positions),
+          fill: e.polygon?.fill?.getValue(now),
+          outline: e.polygon?.outline?.getValue(now),
+          polygonColor: color(e.polygon?.material?.color),
+          polygon: e.polygon?.hierarchy
+            ?.getValue(now)
+            ?.positions?.map((v) => [v.x, v.y, v.z]),
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    };
+    window.__qaUnsharedKml = async (text) => {
+      const doc = new DOMParser().parseFromString(text, 'application/xml');
+      for (const el of [...doc.getElementsByTagName('*')])
+        if (
+          ['description', 'ExtendedData', 'BalloonStyle'].includes(el.localName)
+        )
+          el.remove();
+      const source = await C.KmlDataSource.load(doc, {
+        camera: viewer.scene.camera,
+        canvas: viewer.scene.canvas,
+        clampToGround: true,
+      });
+      for (const e of source.importedEntities || source.entities.values)
+        e.label = undefined;
+      return source;
+    };
+  });
+  const equivalent = await page.evaluate(async (text) => {
+    const { viewer } = window.__godsEyeView;
+    const control = await window.__qaUnsharedKml(text);
+    const outcomes = await window.__gevGeoImport.importFiles([
+      new File([text], 'style-equivalence.kml'),
+    ]);
+    const candidate = viewer.dataSources.get(viewer.dataSources.length - 1);
+    const result = {
+      ok: outcomes[0]?.ok,
+      same:
+        JSON.stringify(window.__qaStyleSnapshot(control)) ===
+        JSON.stringify(window.__qaStyleSnapshot(candidate)),
+      entities: (candidate.importedEntities || candidate.entities.values)
+        .length,
+    };
+    await window.__gevGeoImport.remove(outcomes[0]?.id);
+    return result;
+  }, small);
+  check(
+    'shared inline and named styles preserve point, line and polygon overrides/inheritance',
+    equivalent.ok && equivalent.same && equivalent.entities === 9,
+    JSON.stringify(equivalent),
+  );
+
+  // The control bypasses the former style-count refusal solely in this test,
+  // to compare native unshared rendering against normalized rendering.
+  await page.evaluate(async (text) => {
+    const source = await window.__qaUnsharedKml(text);
+    window.__qaUnsharedSnapshot = JSON.stringify(
+      window.__qaStyleSnapshot(source),
+    );
+    window.__qaControl = source;
+    await window.__godsEyeView.viewer.dataSources.add(source);
+  }, large);
+  const measure = async () =>
+    page.evaluate(async () => {
+      const C = window.__CESIUM__,
+        { viewer } = window.__godsEyeView;
+      const scene = viewer.scene;
+      viewer.camera.cancelFlight();
+      viewer.camera.setView({
+        destination: C.Cartesian3.fromDegrees(-122.5, 37.72, 50000),
+        orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+      });
+      const started = performance.now(),
+        samples = [];
+      let last,
+        frames = 0;
+      const remove = scene.postRender.addEventListener(() => {
+        const t = performance.now();
+        if (t - started < 2000) return;
+        frames++;
+        if (last !== undefined) samples.push(t - last);
+        last = t;
+      });
+      await new Promise((resolve) => {
+        let previous = performance.now();
+        function tick(t) {
+          viewer.camera.rotate(
+            C.Cartesian3.UNIT_Z,
+            Math.min(t - previous, 100) * 0.0000002,
+          );
+          previous = t;
+          scene.requestRender();
+          if (t - started < 7000) requestAnimationFrame(tick);
+          else resolve();
+        }
+        requestAnimationFrame(tick);
+      });
+      remove();
+      samples.sort((a, b) => a - b);
+      const gl = scene.context._gl,
+        debug = gl.getExtension('WEBGL_debug_renderer_info');
+      return {
+        fps: frames / 5,
+        p50Ms: samples[Math.floor(samples.length * 0.5)],
+        p95Ms: samples[Math.floor(samples.length * 0.95)],
+        renderer: debug ? gl.getParameter(debug.UNMASKED_RENDERER_WEBGL) : null,
+      };
+    });
+  console.log('UNSHARED CONTROL', JSON.stringify(await measure()));
+  await page.evaluate(() =>
+    window.__godsEyeView.viewer.dataSources.remove(window.__qaControl, true),
+  );
+
+  const loadPicked = async (filename, expected) => {
+    const before = await page.evaluate(
+      () => window.__godsEyeView.viewer.dataSources.length,
+    );
+    const priorIds = await page.evaluate(() =>
+      window.__gevGeoImport.list().map((f) => f.id),
+    );
+    const started = performance.now();
+    await (await page.$('#geo-import-input')).uploadFile(filename);
+    const name = path.basename(filename);
+    const loaded = await page
+      .waitForFunction(
+        ({ name, priorIds }) =>
+          window.__gevGeoImport.list().some((f) => !priorIds.includes(f.id)) ||
+          document
+            .getElementById('geo-import-hint')
+            .textContent.startsWith(`${name}:`),
+        { timeout: 120000 },
+        { name, priorIds },
+      )
+      .then(
+        () => true,
+        () => false,
+      );
+    const state = await page.evaluate(() => ({
+      files: window.__gevGeoImport.list(),
+      hint: document.getElementById('geo-import-hint').textContent,
+      sources: window.__godsEyeView.viewer.dataSources.length,
+    }));
+    const item = state.files.find((f) => !priorIds.includes(f.id));
+    check(
+      `picked ${name} loads`,
+      loaded &&
+        (expected === null
+          ? item?.entityCount > 0
+          : item?.entityCount === expected) &&
+        state.sources === before + 1,
+      JSON.stringify({
+        bytes: fs.statSync(filename).size,
+        loadMs: Math.round(performance.now() - started),
+        ...state,
+      }),
+    );
+    return item;
+  };
+  const item = await loadPicked(file, 5000);
+  if (item) {
+    const same = await page.evaluate(() => {
+      const viewer = window.__godsEyeView.viewer;
+      const source = viewer.dataSources.get(viewer.dataSources.length - 1);
+      return (
+        JSON.stringify(window.__qaStyleSnapshot(source)) ===
+        window.__qaUnsharedSnapshot
+      );
+    });
+    check('all 5,000 normalized graphics match their unshared control', same);
+    console.log('NORMALIZED CANDIDATE', JSON.stringify(await measure()));
+    await page.evaluate((id) => window.__gevGeoImport.remove(id), item.id);
+  }
+  if (supplied) {
+    const clockBefore = await page.evaluate(() => {
+      const v = window.__godsEyeView.viewer,
+        C = window.__CESIUM__;
+      return [
+        C.JulianDate.toIso8601(v.clock.startTime),
+        C.JulianDate.toIso8601(v.clock.stopTime),
+        C.JulianDate.toIso8601(v.clock.currentTime),
+        v.clock.multiplier,
+      ];
+    });
+    const suppliedItem = await loadPicked(supplied, null);
+    const clockAfter = await page.evaluate(() => {
+      const v = window.__godsEyeView.viewer,
+        C = window.__CESIUM__;
+      return [
+        C.JulianDate.toIso8601(v.clock.startTime),
+        C.JulianDate.toIso8601(v.clock.stopTime),
+        C.JulianDate.toIso8601(v.clock.currentTime),
+        v.clock.multiplier,
+      ];
+    });
+    check(
+      'real dated KML leaves the shared clock unchanged',
+      JSON.stringify(clockBefore) === JSON.stringify(clockAfter),
+    );
+    if (suppliedItem && process.argv.includes('--expect-local-pins')) {
+      const markers = await page.evaluate(() => {
+        const { viewer } = window.__godsEyeView,
+          C = window.__CESIUM__;
+        const source = viewer.dataSources.get(viewer.dataSources.length - 1);
+        const points = (
+          source.importedEntities || source.entities.values
+        ).filter((e) => e.position && e.billboard);
+        const images = points.filter((e) =>
+          e.billboard.image?.getValue(viewer.clock.currentTime),
+        );
+        if (images.length) {
+          const at = C.Cartographic.fromCartesian(
+            images[0].position.getValue(viewer.clock.currentTime),
+          );
+          viewer.camera.cancelFlight();
+          viewer.camera.setView({
+            destination: C.Cartesian3.fromRadians(
+              at.longitude,
+              at.latitude,
+              100000,
+            ),
+            orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+          });
+        }
+        return { points: points.length, images: images.length };
+      });
+      check(
+        'supplied point markers have drawable images',
+        markers.points > 0 && markers.images === markers.points,
+        JSON.stringify(markers),
+      );
+      if (markers.points) {
+        const yellowPixels = async () => {
+          const shot = await page.screenshot({
+            clip: { x: 620, y: 350, width: 200, height: 200 },
+            type: 'png',
+            encoding: 'base64',
+          });
+          return page.evaluate(async (base64) => {
+            const bitmap = await createImageBitmap(
+              await (await fetch(`data:image/png;base64,${base64}`)).blob(),
+            );
+            const canvas = new OffscreenCanvas(bitmap.width, bitmap.height),
+              context = canvas.getContext('2d');
+            context.drawImage(bitmap, 0, 0);
+            const data = context.getImageData(
+              0,
+              0,
+              bitmap.width,
+              bitmap.height,
+            ).data;
+            let count = 0;
+            for (let i = 0; i < data.length; i += 4)
+              if (data[i] > 150 && data[i + 1] > 150 && data[i + 2] < 100)
+                count++;
+            return count;
+          }, shot);
+        };
+        const setVisible = (visible) =>
+          page.evaluate(
+            ({ id, visible }) => window.__gevGeoImport.setVisible(id, visible),
+            { id: suppliedItem.id, visible },
+          );
+        await setVisible(false);
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const hidden = await yellowPixels();
+        await setVisible(true);
+        let shown = hidden;
+        const deadline = performance.now() + 10000;
+        while (performance.now() < deadline && shown <= hidden + 10) {
+          await new Promise((resolve) => setTimeout(resolve, 500));
+          shown = await yellowPixels();
+        }
+        check(
+          'real USGS markers paint when shown and disappear when hidden',
+          shown > hidden + 10,
+          JSON.stringify({ hidden, shown }),
+        );
+        await page.screenshot({
+          path: path.join(directory, 'real-kml-visible.png'),
+        });
+      }
+    }
+    if (suppliedItem)
+      await page.evaluate(
+        (id) => window.__gevGeoImport.remove(id),
+        suppliedItem.id,
+      );
+  }
+  check(
+    'file-directed USGS icon/metadata requests never leave the page',
+    fileRequests.length === 0,
+    fileRequests.length,
+  );
+  errors.push(...(await readRenderErrors(page)));
+  check(
+    'no uncaught page or render errors',
+    errors.length === 0,
+    JSON.stringify(errors),
+  );
+  check(
+    'all imported sources are removed',
+    await page.evaluate(() => window.__gevGeoImport.list().length === 0),
+  );
+  console.log('Fixture retained at', file);
+} finally {
+  await browser.close();
+}
+process.exitCode = failures ? 1 : 0;

scripts/qa-geo-import-regressions.mjs

@@ -0,0 +1,564 @@
+#!/usr/bin/env node
+/** Import regressions through the real UI controller and Cesium loaders.
+ * Run against dev and preview: QA_BASE_URL=http://localhost:4173 node scripts/qa-geo-import-regressions.mjs
+ */
+import puppeteer from 'puppeteer';
+import * as Cesium from 'cesium';
+import { hookRenderErrors, readRenderErrors } from './qa-browserEvidence.mjs';
+
+const browser = await puppeteer.launch({ headless: true });
+const page = await browser.newPage();
+const meshBytes = Buffer.alloc(60);
+[
+  -2000, 2000, -2000, 2000, 2000, -2000, -2000, 2000, 2000, 2000, 2000, 2000,
+].forEach((value, i) => meshBytes.writeFloatLE(value, i * 4));
+[0, 1, 2, 2, 1, 3].forEach((value, i) =>
+  meshBytes.writeUInt16LE(value, 48 + i * 2),
+);
+const fixture = {
+  '/__qa_import_surface/tileset.json': {
+    asset: { version: '1.1' },
+    geometricError: 0,
+    root: {
+      transform: Cesium.Matrix4.toArray(
+        Cesium.Transforms.eastNorthUpToFixedFrame(
+          Cesium.Cartesian3.fromDegrees(-122.5, 37.7),
+        ),
+      ),
+      boundingVolume: { box: [0, 0, 2000, 2000, 0, 0, 0, 2000, 0, 0, 0, 100] },
+      geometricError: 0,
+      content: { uri: 'surface.gltf' },
+    },
+  },
+  '/__qa_import_surface/surface.gltf': {
+    asset: { version: '2.0' },
+    scene: 0,
+    scenes: [{ nodes: [0] }],
+    nodes: [{ mesh: 0 }],
+    meshes: [
+      {
+        primitives: [{ attributes: { POSITION: 0 }, indices: 1, material: 0 }],
+      },
+    ],
+    materials: [{ doubleSided: true }],
+    buffers: [
+      {
+        byteLength: 60,
+        uri: `data:application/octet-stream;base64,${meshBytes.toString('base64')}`,
+      },
+    ],
+    bufferViews: [
+      { buffer: 0, byteOffset: 0, byteLength: 48, target: 34962 },
+      { buffer: 0, byteOffset: 48, byteLength: 12, target: 34963 },
+    ],
+    accessors: [
+      {
+        bufferView: 0,
+        componentType: 5126,
+        count: 4,
+        type: 'VEC3',
+        min: [-2000, 2000, -2000],
+        max: [2000, 2000, 2000],
+      },
+      { bufferView: 1, componentType: 5123, count: 6, type: 'SCALAR' },
+    ],
+  },
+};
+await page.setRequestInterception(true);
+page.on('request', (request) => {
+  const body = fixture[new URL(request.url()).pathname];
+  if (body)
+    void request.respond({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify(body),
+    });
+  else void request.continue();
+});
+const errors = [],
+  requests = [];
+page.on('pageerror', (e) => errors.push(e.message));
+page.on('console', (m) => {
+  if (/Ignoring clampToGround/.test(m.text())) errors.push(m.text());
+});
+await hookRenderErrors(page);
+let failed = 0;
+try {
+  await page.setViewport({ width: 390, height: 844 });
+  await page.goto(
+    `${process.env.QA_BASE_URL || 'http://localhost:4173'}/?welcome=0`,
+    { waitUntil: 'domcontentloaded' },
+  );
+  await page.waitForFunction(
+    () =>
+      window.__gevGeoImport &&
+      document.getElementById('loading-screen')?.classList.contains('hidden'),
+    { timeout: 90000 },
+  );
+  await page.evaluate(async () => {
+    const { viewer, dataManager } = window.__godsEyeView,
+      C = window.__CESIUM__;
+    for (const id of dataManager.layers.keys())
+      await dataManager.setEnabled(id, false);
+    viewer.imageryLayers.removeAll();
+    viewer.terrainProvider = new C.EllipsoidTerrainProvider();
+    viewer.clock.shouldAnimate = false;
+    viewer.camera.cancelFlight();
+    viewer.camera.setView({
+      destination: C.Cartesian3.fromDegrees(-122.5, 37.7, 100000),
+      orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+    });
+  });
+  page.on('request', (r) => {
+    if (!/^(data:|blob:)/.test(r.url())) requests.push(r.url());
+  });
+  const results = await page.evaluate(async () => {
+    const { viewer } = window.__godsEyeView,
+      C = window.__CESIUM__,
+      tool = window.__gevGeoImport;
+    const results = [],
+      now = C.JulianDate.clone(viewer.clock.currentTime);
+    const check = (name, pass, detail = '') =>
+      results.push({ name, pass: Boolean(pass), detail });
+    const wrap = (body, attrs = '') =>
+      `<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:gx="http://www.google.com/kml/ext/2.2" ${attrs}><Document>${body}</Document></kml>`;
+    const point = '<Point><coordinates>-122.5,37.7,0</coordinates></Point>';
+    const load = async (value, name) => {
+      const content =
+        typeof value === 'object' && !ArrayBuffer.isView(value)
+          ? JSON.stringify(value)
+          : value;
+      const [outcome] = await tool.importFiles([new File([content], name)]);
+      return {
+        outcome,
+        source: outcome.ok
+          ? viewer.dataSources.get(viewer.dataSources.length - 1)
+          : null,
+      };
+    };
+    const remove = (r) => {
+      if (r.outcome.ok) tool.remove(r.outcome.id);
+    };
+    let r = await load(
+      {
+        type: 'FeatureCollection',
+        features: [
+          {
+            type: 'Feature',
+            id: 'kartaview-owned',
+            properties: {
+              name: 'XYZ',
+              addProperty: 1,
+              'marker-symbol': 'rail',
+            },
+            geometry: { type: 'Point', coordinates: [-122.5, 37.7, 100] },
+          },
+          {
+            type: 'Feature',
+            geometry: {
+              type: 'Polygon',
+              coordinates: [
+                [
+                  [-122.5, 37.7, 10],
+                  [-122.4, 37.7, 10],
+                  [-122.4, 37.8, 10],
+                  [-122.5, 37.7, 10],
+                ],
+              ],
+            },
+          },
+        ],
+      },
+      'xyz.geojson',
+    );
+    const pin = (r.source?.importedEntities || r.source?.entities.values).find(
+        (e) => e.billboard,
+      ),
+      polygon = (r.source?.importedEntities || r.source?.entities.values).find(
+        (e) => e.polygon,
+      );
+    check(
+      'XYZ ground footprint and isolated entity IDs',
+      r.outcome.ok &&
+        pin.id !== 'kartaview-owned' &&
+        Math.abs(
+          C.Cartographic.fromCartesian(pin.position.getValue(now)).height,
+        ) < 0.01 &&
+        polygon.polygon.perPositionHeight?.getValue(now) !== true,
+    );
+    check(
+      'ground pins have no persistent clamping callbacks',
+      pin?.billboard.heightReference?.getValue(now) ===
+        C.HeightReference.NONE &&
+        pin.billboard.disableDepthTestDistance.getValue(now) === Infinity,
+    );
+    remove(r);
+    r = await load(
+      wrap(
+        '<Placemark><name>ground</name><gx:Track><gx:coord>-122.5 37.7 0</gx:coord><gx:coord>-122.4 37.8 0</gx:coord></gx:Track></Placemark>' +
+          '<Placemark><name>absolute</name><gx:Track><altitudeMode>absolute</altitudeMode><gx:coord>-122.5 37.7 10000</gx:coord><gx:coord>-122.4 37.8 10000</gx:coord></gx:Track></Placemark>' +
+          '<Placemark><name>line</name><LineString><coordinates>-122.5,37.7 -122.4,37.8</coordinates></LineString></Placemark>',
+      ),
+      'tracks.kml',
+    );
+    const find = (name) =>
+      (r.source?.importedEntities || r.source?.entities.values).find(
+        (e) => e.name === name,
+      );
+    check(
+      'ground tracks and untessellated authored lines clamp',
+      find('ground')?.polyline.clampToGround?.getValue(now) &&
+        find('line')?.polyline.clampToGround?.getValue(now),
+    );
+    check(
+      'explicit track altitude and original vertices survive',
+      find('absolute')?.polyline.positions.getValue(now).length === 2 &&
+        find('absolute')
+          .polyline.positions.getValue(now)
+          .every(
+            (p) =>
+              Math.abs(C.Cartographic.fromCartesian(p).height - 10000) < 0.01,
+          ),
+    );
+    remove(r);
+    r = await load(
+      wrap(
+        `<Style id="s"><IconStyle><scale>0.5</scale></IconStyle></Style><Placemark><styleUrl>  #s  </styleUrl>${point}</Placemark>`,
+      ),
+      'local-style.kml',
+    );
+    check('whitespace around a local style remains local', r.outcome.ok);
+    remove(r);
+    r = await load(
+      wrap(
+        `<Placemark><StyleMap><Pair><key>normal</key><styleUrl>https://gev-qa-trap.invalid/style</styleUrl></Pair></StyleMap>${point}</Placemark>`,
+      ),
+      'incomplete-style.kml',
+    );
+    check('removing external style does not hang the queue', r.outcome.ok);
+    remove(r);
+    r = await load(
+      wrap(
+        `<Folder><visibility>0</visibility><Placemark>${point}</Placemark></Folder>`,
+      ),
+      'hidden-folder.kml',
+    );
+    check(
+      'import show controls own previously hidden KML content',
+      r.outcome.ok &&
+        (r.source.importedEntities || r.source.entities.values).every(
+          (e) => e.isShowing,
+        ),
+    );
+    remove(r);
+    r = await load(
+      wrap(
+        '<GroundOverlay><color>ff00ff00</color><LatLonBox><north>37.8</north><south>37.7</south><east>-122.4</east><west>-122.5</west></LatLonBox></GroundOverlay>',
+      ),
+      'colored.kml',
+    );
+    check(
+      'a colored overlay without an icon is drawable',
+      r.outcome.ok &&
+        (r.source.importedEntities || r.source.entities.values).some(
+          (e) => e.rectangle,
+        ),
+    );
+    remove(r);
+    const xml = wrap(`<Placemark>${point}</Placemark>`);
+    const utf16 = new Uint8Array(2 + xml.length * 2);
+    utf16.set([255, 254]);
+    for (let i = 0; i < xml.length; i++) {
+      utf16[2 + i * 2] = xml.charCodeAt(i) & 255;
+      utf16[3 + i * 2] = xml.charCodeAt(i) >> 8;
+    }
+    r = await load(utf16, 'utf16.kml');
+    check('UTF-16 BOM is decoded', r.outcome.ok);
+    remove(r);
+    r = await load(
+      wrap(
+        `<Placemark>${point}</Placemark>`,
+        'xmlns:gx="http://www.google.com/kml/ext/2.2" xsi:schemaLocation="test"',
+      ),
+      'namespaces.kml',
+    );
+    check(
+      'ordinary duplicate and missing export namespaces are repaired',
+      r.outcome.ok,
+    );
+    remove(r);
+    for (const [name, value] of [
+      ['null geometry', { type: 'Feature', geometry: null }],
+      ['invalid coordinates', { type: 'Point', coordinates: ['bad', 37] }],
+      [
+        'missing feature type',
+        {
+          type: 'FeatureCollection',
+          features: [{ geometry: { type: 'Point', coordinates: [0, 0] } }],
+        },
+      ],
+      [
+        'nested unsupported geometry',
+        { type: 'Feature', geometry: { type: 'Topology', arcs: [] } },
+      ],
+    ]) {
+      r = await load(value, 'refused.geojson');
+      check(`${name} is refused without stopping rendering`, !r.outcome.ok);
+      remove(r);
+    }
+    r = await load(
+      wrap(
+        '<Placemark><Point><coordinates>NaN,37,0</coordinates></Point></Placemark>',
+      ),
+      'invalid.kml',
+    );
+    check('non-finite KML coordinates are refused', !r.outcome.ok);
+    remove(r);
+    r = await load(
+      {
+        type: 'LineString',
+        coordinates: [
+          [-122.6, 37.7],
+          [-122.4, 37.7],
+        ],
+      },
+      'portrait.geojson',
+    );
+    await new Promise((resolve) => setTimeout(resolve, 2300));
+    const positions = (r.source?.importedEntities ||
+      r.source?.entities.values)[0].polyline.positions.getValue(now);
+    const screen = positions?.map((p) =>
+      C.SceneTransforms.worldToWindowCoordinates(viewer.scene, p),
+    );
+    check(
+      'portrait flight includes both route endpoints',
+      screen?.every(
+        (p) => p && p.x > 0 && p.x < innerWidth && p.y > 0 && p.y < innerHeight,
+      ),
+      screen?.map((p) => p && [p.x, p.y]),
+    );
+    remove(r);
+    r = await load(
+      {
+        type: 'MultiPoint',
+        coordinates: [
+          [-74, 40.7],
+          [139.7, 35.7],
+        ],
+      },
+      'intercontinental.geojson',
+    );
+    await new Promise((resolve) => setTimeout(resolve, 2300));
+    const intercontinental = (
+      r.source?.importedEntities || r.source?.entities.values
+    )
+      .filter((e) => e.position)
+      .map((e) => e.position.getValue(now));
+    const occluder = new C.EllipsoidalOccluder(
+      C.Ellipsoid.WGS84,
+      viewer.camera.positionWC,
+    );
+    check(
+      'intercontinental points remain in frame and in front of the horizon',
+      intercontinental?.every((p) => {
+        const s = C.SceneTransforms.worldToWindowCoordinates(viewer.scene, p);
+        return (
+          occluder.isPointVisible(p) &&
+          s &&
+          s.x > 0 &&
+          s.x < innerWidth &&
+          s.y > 0 &&
+          s.y < innerHeight
+        );
+      }),
+    );
+    remove(r);
+    r = await load(
+      wrap(
+        '<Placemark><LineString><altitudeMode>absolute</altitudeMode><extrude>1</extrude><coordinates>4.9,52.37,3000 5.12,52.09,3000</coordinates></LineString></Placemark><Placemark><Point><coordinates>5.12,52.09</coordinates></Point></Placemark>',
+      ),
+      'wall.kml',
+    );
+    await new Promise((resolve) => setTimeout(resolve, 2300));
+    check(
+      'a wall contributes both endpoints to the flight',
+      r.outcome.ok &&
+        (r.source.importedEntities || r.source.entities.values)
+          .find((e) => e.wall)
+          ?.wall.positions.getValue(now)
+          .every((p) => {
+            const s = C.SceneTransforms.worldToWindowCoordinates(
+              viewer.scene,
+              p,
+            );
+            return (
+              s && s.x > 0 && s.x < innerWidth && s.y > 0 && s.y < innerHeight
+            );
+          }),
+    );
+    remove(r);
+    r = await load(
+      {
+        type: 'MultiPoint',
+        coordinates: [
+          [0, 0],
+          [180, 0],
+        ],
+      },
+      'antipodal.geojson',
+    );
+    await new Promise((resolve) => setTimeout(resolve, 1800));
+    check(
+      'symmetric global extents keep a finite camera',
+      r.outcome.ok &&
+        Number.isFinite(viewer.camera.positionCartographic.height),
+    );
+    remove(r);
+    viewer.camera.cancelFlight();
+    viewer.camera.setView({
+      destination: C.Cartesian3.fromDegrees(-122.5, 37.7, 100000),
+      orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+    });
+    const mesh = await C.Cesium3DTileset.fromUrl(
+      `${location.origin}/__qa_import_surface/tileset.json`,
+    );
+    viewer.scene.primitives.add(mesh);
+    // This fixture installs a mesh outside the app's map-source lifecycle.
+    // Let the new camera/tiles reach a rendered frame before testing sampling.
+    await new Promise((resolve) => {
+      let frames = 0;
+      const remove = viewer.scene.postRender.addEventListener(() => {
+        if (++frames >= 2) {
+          remove();
+          resolve();
+        } else viewer.scene.requestRender();
+      });
+      viewer.scene.requestRender();
+    });
+    const fixtureDeadline = performance.now() + 5000;
+    while (!mesh.tilesLoaded && performance.now() < fixtureDeadline) {
+      viewer.scene.requestRender();
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    const globeShown = viewer.scene.globe.show;
+    viewer.scene.globe.show = false;
+
+    r = await load(
+      { type: 'Point', coordinates: [-122.5, 37.7, 0] },
+      'mesh-point.geojson',
+    );
+    const meshPoint = (r.source?.importedEntities || r.source?.entities.values)
+      .find((e) => e.billboard)
+      ?.position.getValue(now);
+    const meshHeight =
+      meshPoint && C.Cartographic.fromCartesian(meshPoint).height;
+    check(
+      'native 3D Tiles ground sampling keeps pins on the rendered mesh',
+      r.outcome.ok && Math.abs(meshHeight - 2000) < 2,
+      {
+        meshHeight,
+        tilesLoaded: mesh.tilesLoaded,
+        globeShown: viewer.scene.globe.show,
+      },
+    );
+    tool.flyTo(r.outcome.id);
+    await new Promise((resolve) => setTimeout(resolve, 2300));
+    const meshScreen =
+      meshPoint &&
+      C.SceneTransforms.worldToWindowCoordinates(viewer.scene, meshPoint);
+    check(
+      'a high-surface arrival frames the elevated pin',
+      meshScreen &&
+        Math.abs(meshScreen.x - innerWidth / 2) < 20 &&
+        Math.abs(meshScreen.y - innerHeight / 2) < 20,
+      {
+        screen: meshScreen && [meshScreen.x, meshScreen.y],
+        camera: {
+          height: viewer.camera.positionCartographic.height,
+          pitch: viewer.camera.pitch,
+        },
+        meshHeight,
+      },
+    );
+    const groundSource = r.source;
+    const elevated = await load(
+      wrap(
+        '<Placemark><Point><altitudeMode>absolute</altitudeMode><coordinates>-122.5,37.7,5000</coordinates></Point></Placemark>',
+      ),
+      'elevated-pin.kml',
+    );
+    await new Promise((resolve) => setTimeout(resolve, 2600));
+    check(
+      'a higher imported pin never becomes the sampled ground',
+      elevated.outcome.ok &&
+        Math.abs(
+          C.Cartographic.fromCartesian(
+            groundSource.importedBillboards.get(0).position,
+          ).height - 2000,
+        ) < 2,
+    );
+    remove(elevated);
+    remove(r);
+    viewer.scene.primitives.remove(mesh);
+    viewer.scene.globe.show = globeShown;
+    const before = tool.list().length;
+    const transfer = new DataTransfer();
+    transfer.items.add(
+      new File(
+        [JSON.stringify({ type: 'Point', coordinates: [-122.5, 37.7] })],
+        'panel-drop.geojson',
+      ),
+    );
+    const event = new DragEvent('drop', {
+      bubbles: true,
+      cancelable: true,
+      dataTransfer: transfer,
+    });
+    document.getElementById('geo-import-button').dispatchEvent(event);
+    for (let i = 0; i < 100 && tool.list().length === before; i++)
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    check(
+      'a panel drop imports and prevents the browser default',
+      event.defaultPrevented && tool.list().length === before + 1,
+    );
+    for (const file of tool.list()) tool.remove(file.id);
+    check(
+      'the shared clock stays exactly unchanged',
+      C.JulianDate.equals(now, viewer.clock.currentTime),
+    );
+    check('no file sources remain', tool.list().length === 0);
+    return results;
+  });
+  for (const r of results) {
+    console.log(
+      `[${r.pass ? 'PASS' : 'FAIL'}] ${r.name}`,
+      JSON.stringify(r.detail),
+    );
+    if (!r.pass) failed++;
+  }
+  const renderErrors = await readRenderErrors(page);
+  if (errors.length || renderErrors.length) {
+    failed++;
+    console.log(
+      '[FAIL] browser/render errors',
+      JSON.stringify({ errors, renderErrors }),
+    );
+  }
+  // Terrain belongs to the base map; imported files may sample that provider.
+  const unexpected = requests.filter(
+    (url) =>
+      new URL(url).pathname !== '/logo.svg' &&
+      !new URL(url).pathname.startsWith('/__qa_import_surface/') &&
+      !/\/api\/|\.terrain(?:\?|$)|reearth|cesium|arcgis|openstreetmap|\.pbf(?:\?|$)/i.test(
+        url,
+      ),
+  );
+  console.log(
+    `[${unexpected.length ? 'FAIL' : 'PASS'}] no unexpected file-directed requests`,
+    JSON.stringify(unexpected),
+  );
+  if (unexpected.length) failed++;
+} finally {
+  await browser.close();
+}
+process.exitCode = failed ? 1 : 0;

scripts/qa-geo-import.mjs

@@ -0,0 +1,594 @@
+#!/usr/bin/env node
+/**
+ * Rendered acceptance for DISPLAY ▸ 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
+ * each become one row and one data source; the imported shape actually paints
+ * on the globe in its row's color (a GeoJSON `stroke`/`fill` does not override
+ * it) and stops painting when hidden; no import makes the page request
+ * anything named in it (network link, remote icon, remote style, palette
+ * icon, balloon or extended-data HTML, maki marker) or anything outside the
+ * page for it; no entity keeps a description, label or properties; dated KML
+ * and GPX leave the app's clock alone and still draw now; a GPX track keeps
+ * its two segments apart; keyboard focus survives hide/show; a dropped file
+ * imports like a picked one; a file that is not geodata is refused with a
+ * reason and leaves nothing behind; Remove gives every data source back; no
+ * page errors.
+ *
+ * Usage: dev server up (`npm run dev`), then `node scripts/qa-geo-import.mjs`.
+ * QA_BASE_URL (default http://localhost:4173), QA_SHOT_DIR, QA_HEADFUL=1.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import puppeteer from 'puppeteer';
+import { hookRenderErrors, readRenderErrors } from './qa-browserEvidence.mjs';
+
+const BASE_URL = process.env.QA_BASE_URL || 'http://localhost:4173';
+const SHOT_DIR = process.env.QA_SHOT_DIR || 'qa-shots/geo-import';
+const HEADFUL = process.env.QA_HEADFUL === '1';
+// Golden Gate Park: a big, flat, green rectangle the test polygon can cover.
+const VIEW = { lon: -122.4862, lat: 37.7694, height: 4200, pitch: -88 };
+const TRAP_HOST = 'gev-qa-trap.invalid';
+
+/* ── fixtures ──────────────────────────────────────────────────────────── */
+
+const ring = [
+  [-122.511, 37.7645],
+  [-122.4545, 37.7645],
+  [-122.4545, 37.7745],
+  [-122.511, 37.7745],
+  [-122.511, 37.7645],
+];
+const geojson = JSON.stringify({
+  type: 'FeatureCollection',
+  features: [
+    {
+      type: 'Feature',
+      // A file's own simplestyle and HTML must not survive the import.
+      properties: {
+        name: 'QA park',
+        stroke: '#ff0000',
+        fill: '#ff0000',
+        'fill-opacity': 1,
+        description: `<img src="https://${TRAP_HOST}/props.png">`,
+      },
+      geometry: { type: 'Polygon', coordinates: [ring.map((p) => [...p, 0])] },
+    },
+    {
+      type: 'Feature',
+      properties: { name: 'QA pin', 'marker-symbol': 'rail' },
+      geometry: { type: 'Point', coordinates: [-122.4862, 37.7694, 0] },
+    },
+  ],
+});
+const kml = (iconHref) => `<?xml version="1.0" encoding="UTF-8"?>
+<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:gx="http://www.google.com/kml/ext/2.2">
+<Document>
+  <Style id="s"><IconStyle><Icon><href>${iconHref}</href></Icon></IconStyle></Style>
+  <Style id="palette"><IconStyle><Icon><href>root://icons/palette-4.png</href><gx:x>32</gx:x><gx:y>64</gx:y></Icon></IconStyle></Style>
+  <NetworkLink><Link><href>https://${TRAP_HOST}/link.kml</href></Link></NetworkLink>
+  <Placemark><name>QA KML pin</name><styleUrl>#s</styleUrl>
+    <description><![CDATA[<img src="https://${TRAP_HOST}/balloon.png">]]></description>
+    <TimeSpan><begin>2019-01-01T00:00:00Z</begin><end>2019-01-02T00:00:00Z</end></TimeSpan>
+    <ExtendedData><Data name="note"><value><![CDATA[<iframe src="https://${TRAP_HOST}/extended.html"></iframe>]]></value></Data></ExtendedData>
+    <Point><coordinates>-122.47,37.77,0</coordinates></Point></Placemark>
+  <Placemark><name>QA palette pin</name><styleUrl>#palette</styleUrl>
+    <Point><coordinates>-122.48,37.771,0</coordinates></Point></Placemark>
+  <Placemark><name>QA moving</name>
+    <gx:Track><when>2019-01-01T00:00:00Z</when><when>2019-01-01T01:00:00Z</when>
+      <gx:coord>-122.49 37.767 0</gx:coord><gx:coord>-122.475 37.772 0</gx:coord></gx:Track></Placemark>
+  <Placemark><name>QA split tracks</name><gx:MultiTrack>
+    <gx:Track><gx:coord>-122.50 37.767 0</gx:coord><gx:coord>-122.49 37.768 0</gx:coord></gx:Track>
+    <gx:Track><gx:coord>-122.47 37.771 0</gx:coord><gx:coord>-122.46 37.772 0</gx:coord></gx:Track>
+  </gx:MultiTrack></Placemark>
+  <Placemark><name>QA remote style</name><styleUrl>https://${TRAP_HOST}/styles.kml#x</styleUrl>
+    <LineString><coordinates>-122.50,37.766 -122.46,37.772</coordinates></LineString></Placemark>
+  <GroundOverlay><Icon><href>https://${TRAP_HOST}/overlay.png</href></Icon>
+    <LatLonBox><north>37.77</north><south>37.76</south><east>-122.46</east><west>-122.47</west></LatLonBox></GroundOverlay>
+</Document>
+</kml>`;
+const gpx = `<?xml version="1.0" encoding="UTF-8"?>
+<gpx version="1.1" creator="qa" xmlns="http://www.topografix.com/GPX/1/1">
+  <wpt lat="37.769" lon="-122.49"><name>QA waypoint</name></wpt>
+  <trk><name>QA track</name><desc>&lt;img src="https://${TRAP_HOST}/gpx.png"&gt;</desc><trkseg>
+    <trkpt lat="37.766" lon="-122.505"><time>2018-06-01T10:00:00Z</time></trkpt><trkpt lat="37.768" lon="-122.49"><time>2018-06-01T10:05:00Z</time></trkpt>
+  </trkseg><trkseg>
+    <trkpt lat="37.770" lon="-122.48"><time>2018-06-01T11:00:00Z</time></trkpt><trkpt lat="37.772" lon="-122.47"><time>2018-06-01T11:05:00Z</time></trkpt>
+  </trkseg></trk>
+</gpx>`;
+// 1×1 PNG.
+const PNG = Buffer.from(
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==',
+  'base64',
+);
+/** Stored (uncompressed) zip — enough for a KMZ fixture. */
+function storedZip(files) {
+  const parts = [];
+  const central = [];
+  let offset = 0;
+  for (const [name, data] of files) {
+    const n = Buffer.from(name);
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt32LE(data.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(n.length, 26);
+    const c = Buffer.alloc(46);
+    c.writeUInt32LE(0x02014b50, 0);
+    c.writeUInt32LE(data.length, 20);
+    c.writeUInt32LE(data.length, 24);
+    c.writeUInt16LE(n.length, 28);
+    c.writeUInt32LE(offset, 42);
+    parts.push(local, n, data);
+    central.push(c, n);
+    offset += 30 + n.length + data.length;
+  }
+  const dir = Buffer.concat(central);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(files.length, 8);
+  end.writeUInt16LE(files.length, 10);
+  end.writeUInt32LE(dir.length, 12);
+  end.writeUInt32LE(offset, 16);
+  return Buffer.concat([...parts, dir, end]);
+}
+const kmzDoc = kml('files/pin.png').replace(
+  `<href>https://${TRAP_HOST}/overlay.png</href>`,
+  '<href>files/overlay.png</href>',
+);
+
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gev-qa-geo-import-'));
+const fixture = (name, data) => {
+  const file = path.join(dir, name);
+  fs.writeFileSync(file, data);
+  return file;
+};
+const FILES = [
+  fixture('park.geojson', geojson),
+  fixture('remote-bits.kml', kml(`https://${TRAP_HOST}/icon.png`)),
+  fixture(
+    'packed.kmz',
+    storedZip([
+      ['doc.kml', Buffer.from(kmzDoc)],
+      ['files/pin.png', PNG],
+      ['files/overlay.png', PNG],
+    ]),
+  ),
+  fixture('walk.gpx', gpx),
+];
+
+/* ── harness ───────────────────────────────────────────────────────────── */
+
+const browser = await puppeteer.launch({
+  headless: !HEADFUL,
+  args: [
+    '--no-sandbox',
+    '--disable-background-timer-throttling',
+    '--disable-renderer-backgrounding',
+    ...(process.platform === 'darwin'
+      ? ['--use-angle=metal', '--enable-gpu']
+      : ['--use-gl=angle', '--use-angle=swiftshader']),
+  ],
+});
+const page = await browser.newPage();
+await hookRenderErrors(page);
+const errors = [];
+const trapped = [];
+page.on('pageerror', (error) => errors.push(`pageerror: ${error.message}`));
+page.on('console', (message) => {
+  if (/Ignoring clampToGround/.test(message.text()))
+    errors.push(message.text());
+});
+// Anything a file names, and the icon assets Cesium would load on a file's
+// behalf (KML palette icons from maps.google.com, GeoJSON maki markers).
+const FILE_FETCH = [TRAP_HOST, 'maps.google.com/mapfiles', '/maki/'];
+page.on('request', (request) => {
+  if (FILE_FETCH.some((needle) => request.url().includes(needle)))
+    trapped.push(request.url());
+});
+let failures = 0;
+function check(name, passed, detail = '') {
+  console.log(
+    `[${passed ? 'PASS' : 'FAIL'}] ${name}${detail ? ` — ${detail}` : ''}`,
+  );
+  if (!passed) failures++;
+}
+fs.mkdirSync(SHOT_DIR, { recursive: true });
+const shot = (name) =>
+  page.screenshot({
+    path: path.join(SHOT_DIR, `${name}.jpg`),
+    type: 'jpeg',
+    quality: 82,
+  });
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const CLIP = { x: 380, y: 240, width: 480, height: 320 };
+
+/** Pixels in the clip close to the first import color (#39d0ff). */
+async function cyanPixels() {
+  await page.evaluate(() => window.__godsEyeView.viewer.scene.requestRender());
+  await wait(600);
+  const base64 = await page.screenshot({
+    clip: CLIP,
+    type: 'png',
+    encoding: 'base64',
+  });
+  return page.evaluate(async (b64) => {
+    const bitmap = await createImageBitmap(
+      await (await fetch(`data:image/png;base64,${b64}`)).blob(),
+    );
+    const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+    const context = canvas.getContext('2d');
+    context.drawImage(bitmap, 0, 0);
+    const { data } = context.getImageData(0, 0, bitmap.width, bitmap.height);
+    let n = 0;
+    for (let i = 0; i < data.length; i += 4) {
+      const [r, g, b] = [data[i], data[i + 1], data[i + 2]];
+      if (b > 45 && g > 30 && r < 100 && b - r > 30) n += 1;
+    }
+    return n;
+  }, base64);
+}
+const state = () =>
+  page.evaluate(() => ({
+    files: window.__gevGeoImport.list(),
+    dataSources: window.__godsEyeView.viewer.dataSources.length,
+    rows: document.querySelectorAll('#geo-import-list .geo-import-row').length,
+    hint: document.getElementById('geo-import-hint')?.textContent || '',
+  }));
+
+try {
+  await page.setViewport({ width: 1280, height: 860 });
+  await page.goto(`${BASE_URL}/?welcome=0`, { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(
+    () =>
+      window.__gevGeoImport &&
+      window.__godsEyeView?.viewer &&
+      document.getElementById('loading-screen')?.classList.contains('hidden'),
+    { timeout: 90_000 },
+  );
+  await page.evaluate(async (view) => {
+    const viewer = window.__godsEyeView.viewer;
+    for (const id of window.__godsEyeView.dataManager.layers.keys())
+      await window.__godsEyeView.dataManager.setEnabled(id, false);
+    viewer.imageryLayers.removeAll();
+    viewer.terrainProvider = new window.__CESIUM__.EllipsoidTerrainProvider();
+    viewer.scene.globe.baseColor = window.__CESIUM__.Color.BLACK;
+    viewer.scene.globe.enableLighting = false;
+    viewer.camera.cancelFlight?.();
+    viewer.camera.setView({
+      destination: window.__CESIUM__.Cartesian3.fromDegrees(
+        view.lon,
+        view.lat,
+        view.height,
+      ),
+      orientation: { heading: 0, pitch: (view.pitch * Math.PI) / 180, roll: 0 },
+    });
+    viewer.scene.requestRender();
+  }, VIEW);
+  await wait(4000);
+  await page.evaluate(() => {
+    const rail = document.getElementById('pp-toggles');
+    if (rail?.classList.contains('collapsed'))
+      document
+        .querySelector('.panel-collapse-btn[data-collapse-target="pp-toggles"]')
+        ?.click();
+  });
+  await page.waitForFunction(
+    () =>
+      document.getElementById('geo-import-button')?.getBoundingClientRect()
+        .width > 0,
+    { timeout: 10_000 },
+  );
+  const before = await state();
+  check(
+    'Import is on the DISPLAY rail with an empty, hidden list',
+    before.rows === 0 &&
+      !(await page.evaluate(() =>
+        document
+          .getElementById('geo-import-list')
+          .classList.contains('visible'),
+      )),
+  );
+  const cyanBefore = await cyanPixels();
+  await page.evaluate(() => {
+    window.__godsEyeView.viewer.clock.shouldAnimate = false;
+  });
+  const clock = () =>
+    page.evaluate(() => {
+      const c = window.__godsEyeView.viewer.clock;
+      const iso = (t) => window.__CESIUM__.JulianDate.toIso8601(t, 0);
+      return {
+        start: iso(c.startTime),
+        stop: iso(c.stopTime),
+        range: c.clockRange,
+        step: c.clockStep,
+        multiplier: c.multiplier,
+        animate: c.shouldAnimate,
+        // Wall-clock drift aside, the current time must not jump to 2018/2019.
+        currentTime: window.__CESIUM__.JulianDate.toIso8601(c.currentTime),
+      };
+    });
+  const clockBefore = await clock();
+  const sourcesBefore = before.dataSources;
+
+  // Picked through the real <input type=file>.
+  const input = await page.$('#geo-import-input');
+  await input.uploadFile(...FILES);
+  const imported = await page
+    .waitForFunction(() => window.__gevGeoImport.list().length === 4, {
+      timeout: 60_000,
+    })
+    .then(
+      () => true,
+      () => false,
+    );
+  const after = await state();
+  check(
+    'four picked files become four rows and four data sources',
+    imported &&
+      after.rows === 4 &&
+      after.dataSources === before.dataSources + 4,
+    JSON.stringify(
+      after.files.map((f) => `${f.name}:${f.format}:${f.entityCount}`),
+    ),
+  );
+  check(
+    'formats are recognized',
+    after.files.map((f) => f.format).join() === 'geojson,kml,kmz,gpx',
+  );
+  check(
+    'the KML and KMZ had their outside references removed',
+    after.files[1].removed > 0 && after.files[2].removed > 0,
+    `removed ${after.files[1].removed}/${after.files[2].removed}`,
+  );
+  check(
+    'the hint says so',
+    /Added 4 files\..*left out/.test(after.hint),
+    after.hint,
+  );
+  const clockAfter = await clock();
+  check(
+    "dated KML and GPX leave the app's clock alone",
+    JSON.stringify(clockAfter) === JSON.stringify(clockBefore) &&
+      (await page.evaluate(
+        () =>
+          window.__godsEyeView.viewer.clockTrackedDataSource?.clock ===
+          undefined,
+      )),
+    `${JSON.stringify(clockBefore)} → ${JSON.stringify(clockAfter)}`,
+  );
+  const inside = await page.evaluate((from) => {
+    const viewer = window.__godsEyeView.viewer;
+    const now = viewer.clock.currentTime;
+    const sources = [];
+    for (let i = from; i < viewer.dataSources.length; i++)
+      sources.push(viewer.dataSources.get(i));
+    const entities = sources.flatMap(
+      (ds) => ds.importedEntities || ds.entities.values,
+    );
+    const named = (name) => entities.find((e) => e.name === name);
+    const gpx = sources[3].importedEntities || sources[3].entities.values;
+    const kmz = sources[2].importedEntities || sources[2].entities.values;
+    return {
+      sources: sources.length,
+      clocks: sources.filter((ds) => ds.clock !== undefined).length,
+      described: entities.filter((e) => e.description !== undefined).length,
+      labelled: entities.filter((e) => e.label !== undefined).length,
+      withProperties: entities.filter((e) => e.properties !== undefined).length,
+      withKml: entities.filter((e) => e.kml !== undefined).length,
+      hidden: entities.filter((e) => !e.isAvailable(now)).length,
+      datedPinNow: Boolean(named('QA KML pin')?.isAvailable(now)),
+      fallbackPins: ['QA KML pin', 'QA palette pin'].filter((name) =>
+        named(name)?.billboard?.image?.getValue(now),
+      ).length,
+      movingIsLine: Boolean(
+        named('QA moving')?.polyline && !named('QA moving')?.position,
+      ),
+      movingVertices:
+        named('QA moving')?.polyline?.positions?.getValue(now)?.length,
+      splitTracks: (sources[1].importedEntities || sources[1].entities.values)
+        .filter((e) => e.parent?.name === 'QA split tracks' && e.polyline)
+        .map((e) => e.polyline.positions.getValue(now).length),
+      gpxLines: gpx.filter((e) => e.polyline).length,
+      gpxPoints: gpx.filter((e) => e.billboard || e.point).length,
+      kmzLocalImage: kmz.some((e) =>
+        String(e.billboard?.image?.getValue(now) || '').startsWith('blob:'),
+      ),
+      kmzOverlay: kmz.some((e) => e.rectangle),
+      groundedLines: sources
+        .slice(1, 3)
+        .every((ds) =>
+          (ds.importedEntities || ds.entities.values)
+            .filter((e) => e.polyline)
+            .every((e) => e.polyline.clampToGround?.getValue(now)),
+        ),
+      xyzPolygon:
+        (sources[0].importedEntities || sources[0].entities.values)
+          .find((e) => e.polygon)
+          ?.polygon.perPositionHeight?.getValue(now) !== true,
+    };
+  }, sourcesBefore);
+  check(
+    'no imported entity keeps a description, label, properties or KML data',
+    inside.sources === 4 &&
+      inside.described +
+        inside.labelled +
+        inside.withProperties +
+        inside.withKml ===
+        0,
+    JSON.stringify(inside),
+  );
+  check(
+    'no imported source has a clock, and dated features draw now',
+    inside.clocks === 0 &&
+      inside.hidden === 0 &&
+      inside.datedPinNow &&
+      inside.movingIsLine &&
+      inside.movingVertices === 2,
+    JSON.stringify(inside),
+  );
+  check(
+    'blocked KML icon sources use drawable local fallback pins',
+    inside.fallbackPins === 2,
+    JSON.stringify({ fallbackPins: inside.fallbackPins }),
+  );
+  check(
+    'KML MultiTrack keeps its segments and original vertex count',
+    inside.splitTracks.join() === '2,2',
+    JSON.stringify(inside.splitTracks),
+  );
+  check(
+    'the GPX track keeps its two segments apart',
+    inside.gpxLines === 2 && inside.gpxPoints === 1,
+    JSON.stringify(inside),
+  );
+  check(
+    'KMZ retains its own packed image and overlay',
+    inside.kmzLocalImage && inside.kmzOverlay,
+  );
+  check(
+    'XYZ polygons and KML/KMZ lines use ground geometry',
+    inside.xyzPolygon && inside.groundedLines,
+  );
+  await page.evaluate((from) => {
+    for (const entity of window.__godsEyeView.viewer.dataSources.get(from)
+      .entities.values)
+      if (entity.billboard) entity.show = false;
+  }, sourcesBefore);
+  await page.evaluate((view) => {
+    const viewer = window.__godsEyeView.viewer;
+    viewer.camera.cancelFlight?.();
+    viewer.camera.setView({
+      destination: window.__CESIUM__.Cartesian3.fromDegrees(
+        view.lon,
+        view.lat,
+        view.height,
+      ),
+      orientation: { heading: 0, pitch: (view.pitch * Math.PI) / 180, roll: 0 },
+    });
+  }, VIEW);
+  await wait(2500);
+  const cyanShown = await cyanPixels();
+  await shot('imported');
+  check(
+    'the imported polygon paints on the globe',
+    cyanShown > cyanBefore * 4 && cyanShown > cyanBefore + 5000,
+    `${cyanBefore} → ${cyanShown}`,
+  );
+
+  const parkId = after.files[0].id;
+  await page.click(
+    `#geo-import-list [data-import-id="${parkId}"] button[data-action="toggle"]`,
+  );
+  const cyanHidden = await cyanPixels();
+  check(
+    'hiding it stops it painting',
+    cyanHidden < cyanShown / 3,
+    `${cyanShown} → ${cyanHidden}`,
+  );
+  await page.click(
+    `#geo-import-list [data-import-id="${parkId}"] button[data-action="toggle"]`,
+  );
+  check(
+    'showing it again paints it again',
+    (await cyanPixels()) > cyanHidden * 4,
+  );
+
+  // Keyboard: focus stays on the same control when the list is rebuilt.
+  const toggleSelector = `#geo-import-list [data-import-id="${parkId}"] button[data-action="toggle"]`;
+  await page.focus(toggleSelector);
+  await page.keyboard.press('Enter');
+  const focusAfterHide = await page.evaluate(
+    (sel) => document.activeElement === document.querySelector(sel),
+    toggleSelector,
+  );
+  await page.keyboard.press('Enter');
+  const focusAfterShow = await page.evaluate(
+    (sel) =>
+      document.activeElement === document.querySelector(sel) &&
+      document.activeElement.getAttribute('aria-pressed') === 'true',
+    toggleSelector,
+  );
+  check(
+    'keyboard focus stays on the toggle through hide and show',
+    focusAfterHide && focusAfterShow,
+  );
+
+  // Dropped onto the globe, as a person drags from their file manager.
+  await page.evaluate((text) => {
+    const container = window.__godsEyeView.viewer.container;
+    const transfer = new DataTransfer();
+    transfer.items.add(
+      new File([text], 'dropped.geojson', { type: 'application/geo+json' }),
+    );
+    for (const type of ['dragenter', 'dragover', 'drop'])
+      container.dispatchEvent(
+        new DragEvent(type, {
+          dataTransfer: transfer,
+          bubbles: true,
+          cancelable: true,
+        }),
+      );
+  }, geojson);
+  const dropped = await page
+    .waitForFunction(() => window.__gevGeoImport.list().length === 5, {
+      timeout: 20_000,
+    })
+    .then(
+      () => true,
+      () => false,
+    );
+  check('a file dropped on the globe imports', dropped);
+
+  // Not geodata: refused with a reason, nothing added.
+  await page.evaluate(() => {
+    const transfer = new DataTransfer();
+    transfer.items.add(
+      new File(['just some notes'], 'notes.txt', { type: 'text/plain' }),
+    );
+    window.__godsEyeView.viewer.container.dispatchEvent(
+      new DragEvent('drop', {
+        dataTransfer: transfer,
+        bubbles: true,
+        cancelable: true,
+      }),
+    );
+  });
+  await wait(800);
+  const refused = await state();
+  check(
+    'a file that is not geodata is refused with a reason',
+    refused.files.length === 5 &&
+      /notes\.txt: Only GeoJSON, KML, KMZ and GPX/.test(refused.hint),
+    refused.hint,
+  );
+
+  // Remove every file through its row button.
+  for (const { id } of refused.files)
+    await page.click(
+      `#geo-import-list [data-import-id="${id}"] button[data-action="remove"]`,
+    );
+  const cleared = await state();
+  check(
+    'Remove gives every data source back',
+    cleared.rows === 0 && cleared.dataSources === before.dataSources,
+    `${cleared.dataSources} vs ${before.dataSources}`,
+  );
+  await wait(1500);
+  check(
+    'nothing named inside a file, and no icon asset for one, was ever requested',
+    trapped.length === 0,
+    trapped.join(' '),
+  );
+  errors.push(...(await readRenderErrors(page)));
+  check('no page or rendering errors', errors.length === 0, errors.join(' | '));
+} catch (error) {
+  check('harness ran to completion', false, error?.stack || String(error));
+} finally {
+  await browser.close();
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+console.log(failures ? `\n${failures} check(s) failed` : '\nall checks passed');
+process.exit(failures ? 1 : 0);

scripts/qa-ghostmaps.mjs

@@ -0,0 +1,645 @@
+#!/usr/bin/env node
+/**
+ * qa-ghostmaps.mjs — headless proof for the S2 Underground GhostMaps layer
+ * (id `s2-ghostmaps`): S2's public KMZ intel products, kept current from
+ * github.com/s2underground/GhostMaps.
+ *
+ * Drives the REAL app in headless Chromium against a dev server (keyless).
+ *
+ *   (i)   LIVE — enabling the layer loads the default products (Common
+ *         Intelligence Picture and the 30-day kinetic pull) from the live
+ *         repository through /api/ghostmaps, one data source per product,
+ *         matching the proxy's catalog commit; the row shows one chip per
+ *         catalog product with the defaults active, and the page holds an
+ *         open event stream to /api/ghostmaps/events.
+ *   (ii)  PICK — a Common Intelligence Picture marker at the screen centre
+ *         picks as this layer's entity; clicking it paints its report card
+ *         and clicking empty ground clears it.
+ *   (iii) PUSH (synthetic) — the event stream is replaced in the page and a
+ *         catalog naming a new edition of one product is pushed: only that
+ *         product reloads (a new data source replaces the old one, no
+ *         duplicates), the other keeps its data source. A catalog without a
+ *         product removes it.
+ *   (iv)  CHIPS — clicking an active product chip removes that product,
+ *         clicking it again restores it; the choice survives a reload.
+ *   (v)   DISABLE — every GhostMaps data source leaves the viewer.
+ *   (vi)  VIEWPORT — at a 390x844 phone viewport the open row and its chips
+ *         fit the panel width with no horizontal overflow.
+ *   (vii) FAR SIDE — pins skip the depth test, so they are horizon-culled:
+ *         seen from over the Indian Ocean no pin clearly behind the planet is
+ *         shown; back over North America the near-side pins show again.
+ *
+ * Screenshots go to qa-shots/ghostmaps-*.png (gitignored).
+ *
+ * Run:  node scripts/qa-ghostmaps.mjs --url http://localhost:4173
+ * Optional: --timeout-ms 180000 for a slow boot, --shots <dir>.
+ * Exits non-zero on any FAIL. Does not commit anything.
+ */
+
+import puppeteer from 'puppeteer';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const argv = process.argv.slice(2);
+const getOpt = (name, dflt) => {
+  const i = argv.indexOf(name);
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : dflt;
+};
+const APP_URL = getOpt('--url', 'http://localhost:4173');
+const HEADFUL = argv.includes('--headful');
+const TIMEOUT_MS = Number(getOpt('--timeout-ms', '90000'));
+const SHOTS_DIR = path.resolve(
+  getOpt('--shots', path.join(__dirname, '..', 'qa-shots')),
+);
+const LAYER_ID = 's2-ghostmaps';
+
+const results = [];
+function record(name, ok, detail) {
+  results.push({ name, ok, detail });
+  const tag = ok ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m';
+  console.log(`  [${tag}] ${name}${detail ? `  — ${detail}` : ''}`);
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function boot(page) {
+  await page.goto(`${APP_URL}/?welcome=0`, {
+    waitUntil: 'domcontentloaded',
+    timeout: TIMEOUT_MS,
+  });
+  await page.waitForFunction(
+    () => window.__godsEyeView?.viewer && window.__godsEyeView?.dataManager,
+    { timeout: TIMEOUT_MS },
+  );
+  await sleep(5000);
+  await page.keyboard.press('Escape');
+}
+
+/** GhostMaps data sources on the viewer: name → entity count. */
+function ghostSources(prefix) {
+  const { dataSources } = window.__godsEyeView.viewer;
+  const out = [];
+  for (let i = 0; i < dataSources.length; i++) {
+    const ds = dataSources.get(i);
+    if (ds.name?.startsWith(prefix))
+      out.push({ name: ds.name, count: ds.entities.values.length });
+  }
+  return out;
+}
+
+function paintedOverlayPixels() {
+  const canvas = document.getElementById('world-overlay-canvas');
+  if (!canvas) return -1;
+  const pixels = canvas
+    .getContext('2d')
+    .getImageData(0, 0, canvas.width, canvas.height).data;
+  let count = 0;
+  for (let i = 3; i < pixels.length; i += 4) if (pixels[i] > 0) count++;
+  return count;
+}
+
+async function enableAndSettle(page) {
+  await page.evaluate((id) => {
+    const panel = document.getElementById('data-panel');
+    if (panel?.classList.contains('collapsed'))
+      panel.querySelector('[data-collapse-target="data-panel"]')?.click();
+    return window.__godsEyeView.dataManager.setEnabled(id, true);
+  }, LAYER_ID);
+  await page.waitForFunction(
+    (id) => {
+      const stats = window.__godsEyeView.dataManager.layers
+        .get(id)
+        .module.getStats();
+      return !stats.loading && stats.count > 0;
+    },
+    { timeout: TIMEOUT_MS, polling: 500 },
+    LAYER_ID,
+  );
+}
+
+const stats = (page) =>
+  page.evaluate(
+    (id) => window.__godsEyeView.dataManager.layers.get(id).module.getStats(),
+    LAYER_ID,
+  );
+const sources = (page) =>
+  page.evaluate(`(${ghostSources})(${JSON.stringify(`${LAYER_ID}:`)})`);
+
+async function showRow(page) {
+  await page.evaluate((id) => {
+    document
+      .querySelector(`[data-layer-id="${id}"]`)
+      ?.scrollIntoView({ block: 'center' });
+  }, LAYER_ID);
+  await sleep(400);
+}
+
+async function main() {
+  fs.mkdirSync(SHOTS_DIR, { recursive: true });
+  const browser = await puppeteer.launch({
+    headless: !HEADFUL,
+    args: ['--use-angle=swiftshader', '--enable-unsafe-swiftshader'],
+    defaultViewport: { width: 1440, height: 900 },
+  });
+  try {
+    // ---- (i) LIVE ---------------------------------------------------------
+    const page = await browser.newPage();
+    // Start clean once; a reload must keep what the page stored.
+    await page.evaluateOnNewDocument(() => {
+      try {
+        if (sessionStorage.getItem('qa-ghostmaps-clean')) return;
+        localStorage.clear();
+        sessionStorage.setItem('qa-ghostmaps-clean', '1');
+      } catch {
+        /* sandboxed frames have no storage */
+      }
+    });
+    page.on('pageerror', (error) =>
+      console.log(`  [page error] ${error.message}`),
+    );
+    await boot(page);
+    const catalog = await page.evaluate(() =>
+      fetch('/api/ghostmaps/catalog').then((r) => r.json()),
+    );
+    record(
+      'LIVE: proxy catalog names a commit and the default products',
+      /^[0-9a-f]{40}$/.test(catalog.commit || '') &&
+        ['cip', 'kinetic-30d'].every((id) =>
+          catalog.products.some((p) => p.id === id && p.defaultOn),
+        ),
+      `${catalog.commit?.slice(0, 7)} "${catalog.message}", ${catalog.products.length} products`,
+    );
+    const t0 = Date.now();
+    await enableAndSettle(page);
+    const live = await stats(page);
+    const liveSources = await sources(page);
+    record(
+      'LIVE: default products load as one data source each',
+      liveSources.length === 2 &&
+        liveSources.every((s) => s.count > 0) &&
+        live.products.sort().join() === 'cip,kinetic-30d',
+      `${liveSources.map((s) => `${s.name}=${s.count}`).join(', ')} in ${Date.now() - t0} ms`,
+    );
+    record(
+      'LIVE: layer reports the proxy commit and no error',
+      live.commit === catalog.commit && !live.error,
+      `commit ${live.commit?.slice(0, 7)}, error ${live.error}`,
+    );
+    await showRow(page);
+    const chips = await page.evaluate(
+      (id) =>
+        [
+          ...document.querySelectorAll(
+            `[data-layer-id="${id}"] .data-toggle-chip`,
+          ),
+        ].map((chip) => ({
+          id: chip.dataset.chipId,
+          active: chip.getAttribute('aria-pressed') === 'true',
+        })),
+      LAYER_ID,
+    );
+    record(
+      'LIVE: one chip per product, defaults pressed',
+      chips.length === catalog.products.length &&
+        chips.every(
+          (chip) =>
+            chip.active ===
+            catalog.products.find((p) => p.id === chip.id)?.defaultOn,
+        ),
+      chips.map((c) => `${c.id}${c.active ? '*' : ''}`).join(' '),
+    );
+    const stream = await page
+      .waitForFunction(
+        (id) =>
+          window.__godsEyeView.dataManager.layers.get(id).module.getStats()
+            .stream === 'open',
+        { timeout: 15000, polling: 250 },
+        LAYER_ID,
+      )
+      .then(
+        () => true,
+        () => false,
+      );
+    record('LIVE: the /api/ghostmaps/events stream is open', stream);
+    await page.screenshot({ path: path.join(SHOTS_DIR, 'ghostmaps-live.png') });
+
+    // ---- (ii) PICK ----------------------------------------------------------
+    const target = await page.evaluate((id) => {
+      const gev = window.__godsEyeView;
+      const ds = [...Array(gev.viewer.dataSources.length).keys()]
+        .map((i) => gev.viewer.dataSources.get(i))
+        .find((item) => item.name === `${id}:cip`);
+      const entity = ds.entities.values.find((e) => e.billboard);
+      const carto = gev.viewer.scene.globe.ellipsoid.cartesianToCartographic(
+        entity.position.getValue(gev.viewer.clock.currentTime),
+      );
+      try {
+        gev.viewer.camera.cancelFlight();
+      } catch {
+        /* no flight */
+      }
+      gev.viewer.camera.setView({
+        destination: gev.viewer.scene.globe.ellipsoid.cartographicToCartesian({
+          longitude: carto.longitude,
+          latitude: carto.latitude,
+          height: 40000,
+        }),
+        orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+      });
+      gev.viewer.scene.requestRender?.();
+      return entity.id;
+    }, LAYER_ID);
+    await page
+      .waitForFunction(
+        () => window.__godsEyeView.viewer.scene.globe.tilesLoaded,
+        { timeout: 30000 },
+      )
+      .catch(() => {});
+    // The horizon cull reveals the pin on the frame after the camera moves.
+    await page
+      .waitForFunction(
+        () => {
+          const v = window.__godsEyeView.viewer;
+          v.scene.requestRender?.();
+          const c = v.scene.canvas;
+          return v.scene
+            .drillPick({ x: c.clientWidth / 2, y: c.clientHeight / 2 }, 8)
+            .some((p) =>
+              String(p?.id?.id ?? p?.id ?? '').startsWith('ghostmaps:cip:'),
+            );
+        },
+        { timeout: 15000, polling: 500 },
+      )
+      .catch(() => {});
+    const probe = await page.evaluate(() => {
+      const v = window.__godsEyeView.viewer;
+      const c = v.scene.canvas;
+      const box = c.getBoundingClientRect();
+      const centre = { x: c.clientWidth / 2, y: c.clientHeight / 2 };
+      const picked = v.scene.drillPick(centre, 8);
+      // Empty ground: the first point below the marker (the card is drawn
+      // above it) that picks nothing at all; markers can be dense in a city.
+      let empty = null;
+      for (let r = 120; r < 420 && !empty; r += 60)
+        for (const a of [2, 1, 3, 0, 4]) {
+          const p = {
+            x: centre.x + r * Math.cos((a * Math.PI) / 4),
+            y: centre.y + r * Math.sin((a * Math.PI) / 4),
+          };
+          if (!v.scene.pick(p)) {
+            empty = p;
+            break;
+          }
+        }
+      empty ||= { x: centre.x + 400, y: centre.y + 300 };
+      return {
+        ids: picked.map((p) => String(p?.id?.id ?? p?.id ?? '')),
+        centre: { x: centre.x + box.left, y: centre.y + box.top },
+        empty: { x: empty.x + box.left, y: empty.y + box.top },
+      };
+    });
+    record(
+      'PICK: the centred marker picks as a GhostMaps entity',
+      probe.ids.some((id) => id.startsWith('ghostmaps:cip:')),
+      `${target} → [${probe.ids.slice(0, 3).join(', ')}]`,
+    );
+    const before = await page.evaluate(paintedOverlayPixels);
+    await page.mouse.click(probe.centre.x, probe.centre.y);
+    const painted = await page
+      .waitForFunction(`(${paintedOverlayPixels})() > ${before + 100}`, {
+        timeout: 10000,
+        polling: 250,
+      })
+      .then(
+        () => true,
+        () => false,
+      );
+    const after = await page.evaluate(paintedOverlayPixels);
+    record(
+      'PICK: clicking the marker paints its report card',
+      painted,
+      `${before} → ${after} pixels`,
+    );
+    await page.screenshot({ path: path.join(SHOTS_DIR, 'ghostmaps-card.png') });
+    const cardState = () =>
+      page.evaluate((id) => {
+        const d = window.__gevWorldOverlay?.getDiagnostics?.();
+        return {
+          entries: d?.entriesBySource?.[id] ?? null,
+          painted: d?.paintedBySource?.[id] ?? null,
+        };
+      }, LAYER_ID);
+    const selectedState = await cardState();
+    record(
+      'PICK: the overlay host holds and paints exactly one card',
+      selectedState.entries === 1 && selectedState.painted === 1,
+      JSON.stringify(selectedState),
+    );
+    await page.mouse.click(probe.empty.x, probe.empty.y);
+    // The overlay canvas is `desynchronized`, so headless read-back can
+    // return a stale buffer; the host's own model is the authority here.
+    const cleared = await page
+      .waitForFunction(
+        (id) => {
+          const d = window.__gevWorldOverlay.getDiagnostics();
+          return (
+            d.entriesBySource?.[id] === 0 && !(d.paintedBySource?.[id] > 0)
+          );
+        },
+        { timeout: 10000, polling: 250 },
+        LAYER_ID,
+      )
+      .then(
+        () => true,
+        () => false,
+      );
+    record(
+      'PICK: clicking empty ground clears the card',
+      cleared,
+      JSON.stringify(await cardState()),
+    );
+
+    // ---- (vii) FAR SIDE ---------------------------------------------------
+    // Pins skip the depth test; with Google 3D tiles nothing else hides the
+    // far side. A pin clearly behind the planet (sphere test with margin) must
+    // be hidden, and pins facing the camera must still show.
+    const horizonCounts = (lon, lat) =>
+      page.evaluate(
+        async (id, lo, la) => {
+          const gev = window.__godsEyeView;
+          const d2r = Math.PI / 180;
+          try {
+            gev.viewer.camera.cancelFlight();
+          } catch {
+            /* no flight */
+          }
+          gev.viewer.camera.setView({
+            destination:
+              gev.viewer.scene.globe.ellipsoid.cartographicToCartesian({
+                longitude: lo * d2r,
+                latitude: la * d2r,
+                height: 18_000_000,
+              }),
+            orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+          });
+          gev.viewer.scene.requestRender?.();
+          await new Promise((r) => setTimeout(r, 1200));
+          const c = gev.viewer.camera.positionWC;
+          const norm = (v) => Math.hypot(v.x, v.y, v.z);
+          let far = 0;
+          let nearShown = 0;
+          for (let i = 0; i < gev.viewer.dataSources.length; i++) {
+            const ds = gev.viewer.dataSources.get(i);
+            if (!ds.name?.startsWith(`${id}:`)) continue;
+            for (const e of ds.entities.values) {
+              if (!e.billboard) continue;
+              const p = e.position.getValue(gev.viewer.clock.currentTime);
+              // Angle from the camera's nadir to the pin, against the
+              // geometric horizon angle; the cull's 1 km margin shows pins up
+              // to about 1° past it, so "clearly behind" is beyond 2°.
+              const angle = Math.acos(
+                (p.x * c.x + p.y * c.y + p.z * c.z) / (norm(p) * norm(c)),
+              );
+              const horizon = Math.acos(norm(p) / norm(c));
+              const margin = (2 * Math.PI) / 180;
+              if (e.show && angle > horizon + margin) far++;
+              if (e.show && angle < horizon - margin) nearShown++;
+            }
+          }
+          return { far, nearShown };
+        },
+        LAYER_ID,
+        lon,
+        lat,
+      );
+    const fromIndianOcean = await horizonCounts(80, -30);
+    record(
+      'FAR SIDE: pins behind the planet are hidden',
+      fromIndianOcean.far === 0,
+      JSON.stringify(fromIndianOcean),
+    );
+    await page.screenshot({
+      path: path.join(SHOTS_DIR, 'ghostmaps-far-side.png'),
+    });
+    const fromAmerica = await horizonCounts(-98, 39);
+    record(
+      'FAR SIDE: pins facing the camera show again',
+      fromAmerica.far === 0 && fromAmerica.nearShown > 100,
+      JSON.stringify(fromAmerica),
+    );
+
+    // ---- (iv) CHIPS -------------------------------------------------------
+    const clickChip = async (id) => {
+      // Row controls render on the next frame after the layer settles.
+      await page.waitForSelector(
+        `[data-layer-id="${LAYER_ID}"] .data-toggle-chip[data-chip-id="${id}"]`,
+        { timeout: 15000 },
+      );
+      return page.evaluate(
+        (layer, chip) =>
+          document
+            .querySelector(
+              `[data-layer-id="${layer}"] .data-toggle-chip[data-chip-id="${chip}"]`,
+            )
+            ?.click(),
+        LAYER_ID,
+        id,
+      );
+    };
+    await clickChip('kinetic-30d');
+    await page.waitForFunction(
+      (id) =>
+        !window.__godsEyeView.dataManager.layers
+          .get(id)
+          .module.getStats()
+          .products.includes('kinetic-30d'),
+      { timeout: 15000 },
+      LAYER_ID,
+    );
+    const without = await sources(page);
+    record(
+      'CHIPS: turning a product off removes only its data source',
+      without.length === 1 && without[0].name === `${LAYER_ID}:cip`,
+      without.map((s) => s.name).join(', '),
+    );
+    await page.reload({ waitUntil: 'domcontentloaded' });
+    await page.waitForFunction(() => window.__godsEyeView?.dataManager, {
+      timeout: TIMEOUT_MS,
+    });
+    await sleep(3000);
+    await enableAndSettle(page);
+    const kept = await stats(page);
+    record(
+      'CHIPS: the product choice survives a reload',
+      kept.products.join() === 'cip',
+      kept.products.join(', '),
+    );
+    await showRow(page);
+    await clickChip('kinetic-30d');
+    await page.waitForFunction(
+      (id) =>
+        window.__godsEyeView.dataManager.layers
+          .get(id)
+          .module.getStats()
+          .products.includes('kinetic-30d'),
+      { timeout: 30000 },
+      LAYER_ID,
+    );
+    record(
+      'CHIPS: turning it back on restores it',
+      (await sources(page)).length === 2,
+    );
+
+    // ---- (v) DISABLE ------------------------------------------------------
+    await page.evaluate(
+      (id) => window.__godsEyeView.dataManager.setEnabled(id, false),
+      LAYER_ID,
+    );
+    await sleep(500);
+    record(
+      'DISABLE: every GhostMaps data source leaves the viewer',
+      (await sources(page)).length === 0,
+    );
+    await page.close();
+
+    // ---- (iii) PUSH (synthetic) ----------------------------------------------
+    const push = await browser.newPage();
+    await push.evaluateOnNewDocument(() => {
+      localStorage.clear();
+      // A controllable stand-in for the real stream.
+      class QaEventSource {
+        constructor(url) {
+          this.url = url;
+          this.listeners = new Set();
+          (window.__qaStreams ||= []).push(this);
+        }
+        addEventListener(type, listener) {
+          if (type === 'catalog') this.listeners.add(listener);
+        }
+        removeEventListener(type, listener) {
+          this.listeners.delete(listener);
+        }
+        close() {
+          this.closed = true;
+        }
+        emit(catalog) {
+          for (const listener of this.listeners)
+            listener({ data: JSON.stringify(catalog) });
+        }
+      }
+      window.EventSource = QaEventSource;
+    });
+    await boot(push);
+    await enableAndSettle(push);
+    const identity = () =>
+      push.evaluate((id) => {
+        const { dataSources } = window.__godsEyeView.viewer;
+        window.__qaIds ||= new WeakMap();
+        window.__qaNext ||= 1;
+        const out = {};
+        for (let i = 0; i < dataSources.length; i++) {
+          const ds = dataSources.get(i);
+          if (!ds.name?.startsWith(`${id}:`)) continue;
+          if (!window.__qaIds.has(ds))
+            window.__qaIds.set(ds, window.__qaNext++);
+          out[ds.name] = window.__qaIds.get(ds);
+        }
+        return out;
+      }, LAYER_ID);
+    const first = await identity();
+    const pushed = Date.now();
+    await push.evaluate(async (id) => {
+      const catalog = await fetch('/api/ghostmaps/catalog').then((r) =>
+        r.json(),
+      );
+      const kinetic = catalog.products.find((p) => p.id === 'kinetic-30d');
+      kinetic.version = 'f'.repeat(40);
+      catalog.message = 'QA push';
+      window.__qaStreams
+        .filter((s) => !s.closed)
+        .forEach((s) => s.emit(catalog));
+    }, LAYER_ID);
+    await push.waitForFunction(
+      (id) => {
+        const layer = window.__godsEyeView.dataManager.layers.get(id).module;
+        return (
+          !layer.getStats().loading &&
+          layer.getRowControls().info.includes('QA push')
+        );
+      },
+      { timeout: 20000, polling: 100 },
+      LAYER_ID,
+    );
+    await sleep(500);
+    const second = await identity();
+    record(
+      'PUSH: a new edition reloads only that product',
+      Object.keys(second).length === 2 &&
+        second[`${LAYER_ID}:kinetic-30d`] !==
+          first[`${LAYER_ID}:kinetic-30d`] &&
+        second[`${LAYER_ID}:cip`] === first[`${LAYER_ID}:cip`],
+      `${JSON.stringify(first)} → ${JSON.stringify(second)} in ${Date.now() - pushed} ms`,
+    );
+    await push.evaluate(async () => {
+      const catalog = await fetch('/api/ghostmaps/catalog').then((r) =>
+        r.json(),
+      );
+      catalog.products = catalog.products.filter((p) => p.id !== 'kinetic-30d');
+      window.__qaStreams
+        .filter((s) => !s.closed)
+        .forEach((s) => s.emit(catalog));
+    });
+    await sleep(1000);
+    const third = await identity();
+    record(
+      'PUSH: a product leaving the catalog leaves the globe',
+      Object.keys(third).join() === `${LAYER_ID}:cip`,
+      Object.keys(third).join(', '),
+    );
+    await push.close();
+
+    // ---- (vi) VIEWPORT ----------------------------------------------------
+    const phone = await browser.newPage();
+    await phone.setViewport({ width: 390, height: 844, isMobile: true });
+    await phone.evaluateOnNewDocument(() => localStorage.clear());
+    await boot(phone);
+    await enableAndSettle(phone);
+    await showRow(phone);
+    const fit = await phone.evaluate((id) => {
+      const row = document.querySelector(`[data-layer-id="${id}"]`);
+      const panel = document.getElementById('data-panel');
+      const controls = row?.querySelector('.data-toggle-controls');
+      return {
+        row: Boolean(row),
+        overflow: controls ? controls.scrollWidth - controls.clientWidth : -1,
+        pageOverflow:
+          document.documentElement.scrollWidth -
+          document.documentElement.clientWidth,
+        panelRight: panel?.getBoundingClientRect().right,
+        width: window.innerWidth,
+      };
+    }, LAYER_ID);
+    record(
+      'VIEWPORT: chips fit the phone-width panel',
+      fit.row && fit.overflow <= 1 && fit.pageOverflow <= 0,
+      JSON.stringify(fit),
+    );
+    await phone.screenshot({
+      path: path.join(SHOTS_DIR, 'ghostmaps-phone.png'),
+    });
+    await phone.close();
+  } finally {
+    await browser.close();
+  }
+  const failed = results.filter((r) => !r.ok);
+  console.log(
+    `\n${results.length - failed.length}/${results.length} passed. Screenshots: ${SHOTS_DIR}`,
+  );
+  process.exit(failed.length ? 1 : 0);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

scripts/qa-gnss.mjs

@@ -0,0 +1,988 @@
+#!/usr/bin/env node
+/**
+ * qa-gnss.mjs — headless proof for the GNSS Integrity layer
+ * (id `gnss-integrity`): low navigation accuracy reported by ADS-B.
+ *
+ * Drives the REAL app in headless Chromium against a dev server (keyless).
+ * The live section reads adsb.lol through `/api/gnss-integrity` (60 s server
+ * cache, one upstream read per whole-degree anchor); the other sections
+ * stub that route in the page so they are deterministic.
+ *
+ *   (i)   LIVE — over Poland and the southern Baltic the layer settles with no error,
+ *         one geometry per cell and legend band counts that sum to the cell
+ *         count; cells are required only when the returned rows, binned
+ *         with the layer's own rules, reach the per-cell minimum (live
+ *         traffic varies by hour). Requires a non-stale response no older than 60 s.
+ *   (ii)  BANDS (synthetic) — a 10-aircraft cell with 5 degraded is high,
+ *         a 30-aircraft cell with 2 degraded is medium, a 3-aircraft cell
+ *         with 1 degraded is low (first bad discounted), a clean cell at sea
+ *         is low, a 2-aircraft cell is withheld; `stale: true` reaches
+ *         getStats. Every band is drawn and low is shown over land and sea.
+ *         The row reads as low navigation accuracy, and stats carry the
+ *         machine-readable provenance (GEV classifier, gpsjam bands, window).
+ *         PICK verifies actual perimeter and empty-ground clicks under GNSS.
+ *         CAMERA/GLOBE verify automatic sampling and the screen-centre anchor.
+ *   (iii) FAILURE — the route stubbed to 502: stats.error is set and the
+ *         cells already on the globe are kept.
+ *   (iv)  DISABLE — owned ground primitives are hidden.
+ *   (v)   KEYBOARD — the row's toggle button, focused, turns the layer on
+ *         with Enter and off with Space, keeps focus and names its state.
+ *   (vi)  VIEWPORT — at a 390x844 phone viewport the open row and its legend
+ *         fit the panel width with no horizontal overflow.
+ *   (vii) AGE (synthetic) — a fresh page whose stubbed proxy replays the same
+ *         stale snapshot observed 31 minutes ago draws nothing and reports no
+ *         error; observed 29 minutes ago it draws its cells. The replay keeps
+ *         its observation time instead of restarting the 30-minute window.
+ *
+ * Screenshots wait until every cell's ground geometry is built and show the
+ * open Data Layers row with its legend. Visual proof saved to
+ * qa-shots/gnss-*.png (gitignored).
+ *
+ * Run:  node scripts/qa-gnss.mjs --url http://localhost:4173
+ *       (also against a built preview: npm run build && npm run preview,
+ *       then pass the preview URL)
+ * Optional: --timeout-ms 180000 for a slow boot.
+ * Exits non-zero on any FAIL. Does not commit anything.
+ */
+
+import puppeteer from 'puppeteer';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  accumulateGnssObservations,
+  binGnssCells,
+} from '../src/layers/gnss/records.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, '..');
+const SHOTS_DIR = path.join(REPO_ROOT, 'qa-shots');
+
+const argv = process.argv.slice(2);
+const getOpt = (name, dflt) => {
+  const i = argv.indexOf(name);
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : dflt;
+};
+const APP_URL = getOpt('--url', 'http://localhost:4173');
+const HEADFUL = argv.includes('--headful');
+const TIMEOUT_MS = Number(getOpt('--timeout-ms', '60000'));
+const LAYER_ID = 'gnss-integrity';
+
+const results = [];
+function record(name, ok, detail) {
+  results.push({ name, ok, detail });
+  const tag = ok ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m';
+  console.log(`  [${tag}] ${name}${detail ? `  — ${detail}` : ''}`);
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** Boot the app, dismiss the intro and place the camera straight down. */
+async function boot(page, { lon, lat, height }) {
+  await page.goto(`${APP_URL}/?welcome=0`, {
+    waitUntil: 'domcontentloaded',
+    timeout: TIMEOUT_MS,
+  });
+  await page.waitForFunction(
+    () => window.__godsEyeView?.viewer && window.__godsEyeView?.dataManager,
+    { timeout: TIMEOUT_MS },
+  );
+  await sleep(5000);
+  await page.keyboard.press('Escape');
+  await page.evaluate(
+    (lo, la, h) => {
+      const gev = window.__godsEyeView;
+      const d2r = Math.PI / 180;
+      // The app's intro flyTo animation clobbers a setView issued mid-flight.
+      try {
+        gev.viewer.camera.cancelFlight();
+      } catch {
+        /* no flight active */
+      }
+      gev.viewer.camera.setView({
+        destination: gev.viewer.scene.globe.ellipsoid.cartographicToCartesian({
+          longitude: lo * d2r,
+          latitude: la * d2r,
+          height: h,
+        }),
+        orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+      });
+      gev.viewer.scene.requestRender?.();
+    },
+    lon,
+    lat,
+    height,
+  );
+}
+
+/** Enable (or refresh) the layer and poll until it settles. */
+async function enableAndSettle(page, { refresh = false } = {}) {
+  return page.evaluate(
+    async (id, again) => {
+      const dm = window.__godsEyeView.dataManager;
+      const layer = dm.layers.get(id).module;
+      if (again) await dm.refreshLayer(id);
+      else await dm.setEnabled(id, true);
+      const stats = layer.getStats();
+      const rowControls = layer.getRowControls().legend;
+      const legend = rowControls.map(({ label, count }) => ({ label, count }));
+      const blurb = rowControls[0]?.blurb ?? '';
+      const rowName =
+        document.querySelector(`[data-layer-id="${id}"] .data-name`)
+          ?.textContent ?? '';
+      const all = window.__godsEyeView.viewer.scene.groundPrimitives;
+      const ds = Array.from({ length: all.length }, (_, i) => all.get(i)).find(
+        (item) => item.id === id,
+      );
+      return {
+        stats,
+        legend,
+        blurb,
+        rowName,
+        name: layer.name,
+        entities: ds?.get(0)?.geometryInstances.length ?? 0,
+        shown: ds?.show ?? null,
+      };
+    },
+    LAYER_ID,
+    refresh,
+  );
+}
+
+/** Open the Data Layers panel and bring the GNSS row into view. */
+async function showLayerRow(page) {
+  await page.evaluate((id) => {
+    const panel = document.getElementById('data-panel');
+    if (panel.classList.contains('collapsed'))
+      panel.querySelector('[data-collapse-target="data-panel"]').click();
+    document
+      .querySelector(`[data-layer-id="${id}"]`)
+      ?.scrollIntoView({ block: 'center' });
+  }, LAYER_ID);
+  await sleep(800);
+}
+
+/** Actual card pixels on the shared canvas, available in dev and production. */
+function paintedOverlayPixels() {
+  const canvas = document.getElementById('world-overlay-canvas');
+  if (!canvas) return -1;
+  const pixels = canvas
+    .getContext('2d')
+    .getImageData(0, 0, canvas.width, canvas.height).data;
+  let count = 0;
+  for (let i = 3; i < pixels.length; i += 4) if (pixels[i] > 0) count++;
+  return count;
+}
+
+async function shoot(page, name) {
+  await page
+    .waitForFunction(
+      () => window.__godsEyeView.viewer.scene.globe.tilesLoaded,
+      { timeout: TIMEOUT_MS },
+    )
+    .catch(() => {});
+  await showLayerRow(page);
+  await page.screenshot({ path: path.join(SHOTS_DIR, `gnss-${name}.png`) });
+}
+
+/** Bounding-sphere state of every GNSS cell: DONE = 0, PENDING = 1, FAILED = 2. */
+function cellStates(id) {
+  const { viewer } = window.__godsEyeView;
+  const all = viewer.scene.groundPrimitives;
+  const ds = Array.from({ length: all.length }, (_, i) => all.get(i)).find(
+    (item) => item.id === id,
+  );
+  if (!ds?.length) return [];
+  return [ds.get(0).ready ? 0 : 1];
+}
+
+/** Wait until every GNSS cell's ground rectangle has finished building. */
+async function waitForBuiltCells(page, timeoutMs = 60000) {
+  const built = await page
+    .waitForFunction(
+      `(${cellStates})(${JSON.stringify(LAYER_ID)}).every((state) => state === 0)`,
+      { timeout: timeoutMs, polling: 250 },
+    )
+    .then(
+      () => true,
+      () => false,
+    );
+  const states = await page.evaluate(
+    `(${cellStates})(${JSON.stringify(LAYER_ID)})`,
+  );
+  return { built, detail: `states=${JSON.stringify(states)}` };
+}
+
+const fixtureRow = (hex, lat, lon, degraded) => ({
+  hex,
+  lat,
+  lon,
+  nic: degraded ? 0 : 8,
+  nacp: degraded ? 0 : 10,
+  gpsLost: false,
+  degraded,
+});
+
+/**
+ * Synthetic 0.5° cells: high at sea (5/10 bad), medium on land (2/30 bad),
+ * low on land (1/3 bad), low at sea (0/4 bad), withheld (2 aircraft).
+ */
+function fixturePayload() {
+  const rows = [];
+  const hex = (prefix, i) => `${prefix}${i.toString(16).padStart(2, '0')}`;
+  for (let i = 0; i < 10; i++)
+    rows.push(fixtureRow(hex('a000', i), 55.1 + i * 0.01, 19.1, i < 5));
+  for (let i = 0; i < 30; i++)
+    rows.push(fixtureRow(hex('d000', i), 54.1 + i * 0.01, 19.6, i < 2));
+  for (let i = 0; i < 3; i++)
+    rows.push(fixtureRow(hex('b000', i), 54.1 + i * 0.01, 18.1, i === 0));
+  for (let i = 0; i < 4; i++)
+    rows.push(fixtureRow(hex('e000', i), 55.1 + i * 0.01, 18.1, false));
+  for (let i = 0; i < 2; i++)
+    rows.push(fixtureRow(hex('c000', i), 53.1 + i * 0.01, 17.1, true));
+  return {
+    fetchedAt: Date.now(),
+    anchor: { lat: 55, lon: 19 },
+    radiusNm: 250,
+    rows,
+    stale: true,
+  };
+}
+
+/** Answer /api/gnss-integrity in-page from `fixturePayload()`. */
+async function stubRoute(page, { ageMs = 0, initialFailures = 0, stale } = {}) {
+  await page.evaluateOnNewDocument(
+    (payload, age, failures, staleOverride) => {
+      window.__gnssQaAgeMs = age;
+      window.__gnssQaRequests = [];
+      window.__gnssQaFailures = failures;
+      const realFetch = window.fetch.bind(window);
+      window.__gnssQaMode = 'fixture';
+      window.fetch = (input, init) => {
+        const url = typeof input === 'string' ? input : input?.url || '';
+        if (!url.includes('/api/gnss-integrity')) return realFetch(input, init);
+        window.__gnssQaRequests.push(url);
+        if (window.__gnssQaFailures > 0) {
+          window.__gnssQaFailures--;
+          return Promise.resolve(
+            Response.json(
+              { error: 'rate_limited' },
+              {
+                status: 429,
+                headers: { 'Retry-After': '5' },
+              },
+            ),
+          );
+        }
+        const ok = window.__gnssQaMode === 'fixture';
+        const body = ok
+          ? {
+              ...payload,
+              fetchedAt: Date.now() - (window.__gnssQaAgeMs || 0),
+              ageMs: window.__gnssQaAgeMs || 0,
+              stale: staleOverride ?? payload.stale,
+            }
+          : { error: 'gnss_integrity_unavailable' };
+        return Promise.resolve(
+          new Response(JSON.stringify(body), {
+            status: ok ? 200 : 502,
+            headers: { 'Content-Type': 'application/json' },
+          }),
+        );
+      };
+    },
+    fixturePayload(),
+    ageMs,
+    initialFailures,
+    stale,
+  );
+}
+
+/** Toggle button of the GNSS row, as the panel draws it. */
+function toggleState(id) {
+  const button = document.querySelector(
+    `[data-layer-id="${id}"] .data-toggle-btn`,
+  );
+  const layer = window.__godsEyeView.dataManager.layers.get(id);
+  return {
+    focused: document.activeElement === button,
+    label: button?.getAttribute('aria-label') ?? '',
+    enabled: Boolean(layer?.enabled),
+    count: layer?.module.getStats().count ?? -1,
+  };
+}
+
+/** Press a key on the focused GNSS toggle and wait for the lifecycle to settle. */
+async function pressToggle(page, key, wantEnabled) {
+  await page.evaluate((id) => {
+    document.querySelector(`[data-layer-id="${id}"] .data-toggle-btn`)?.focus();
+  }, LAYER_ID);
+  await page.keyboard.press(key);
+  await page
+    .waitForFunction(
+      (id, want) => {
+        const layer = window.__godsEyeView.dataManager.layers.get(id);
+        return (
+          Boolean(layer?.enabled) === want &&
+          (!want || layer.module.getStats().count > 0)
+        );
+      },
+      { timeout: 30000, polling: 250 },
+      LAYER_ID,
+      wantEnabled,
+    )
+    .catch(() => {});
+  return page.evaluate(`(${toggleState})(${JSON.stringify(LAYER_ID)})`);
+}
+
+async function main() {
+  console.log('\nGNSS Integrity proof (qa-gnss)');
+  console.log(`  App URL : ${APP_URL}\n`);
+  try {
+    const res = await fetch(APP_URL);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  } catch (e) {
+    console.error(
+      `\x1b[31mDev server not reachable at ${APP_URL} (${e.message}).\x1b[0m`,
+    );
+    process.exit(2);
+  }
+  fs.mkdirSync(SHOTS_DIR, { recursive: true });
+  const executablePath =
+    process.env.PUPPETEER_EXECUTABLE_PATH ||
+    (await puppeteer.executablePath().catch(() => null)) ||
+    undefined;
+  const browser = await puppeteer.launch({
+    headless: HEADFUL ? false : 'new',
+    ...(executablePath && fs.existsSync(executablePath)
+      ? { executablePath }
+      : {}),
+    args: [
+      '--use-gl=angle',
+      '--use-angle=swiftshader',
+      '--disable-dev-shm-usage',
+      '--disable-background-timer-throttling',
+      '--disable-renderer-backgrounding',
+      '--window-size=1440,900',
+    ],
+  });
+
+  let exitCode = 0;
+  const errors = [];
+  try {
+    // ── (i) LIVE ──────────────────────────────────────────────────────────
+    console.log(
+      '(i) LIVE — adsb.lol integrity snapshot over Poland and the southern Baltic...',
+    );
+    const live = await browser.newPage();
+    await live.setViewport({ width: 1440, height: 900 });
+    live.on('pageerror', (e) => errors.push(e.message));
+    const liveBodies = [];
+    live.on('response', (res) => {
+      if (res.url().includes('/api/gnss-integrity') && res.ok())
+        liveBodies.push(res.json());
+    });
+    await boot(live, { lon: 19.6, lat: 52.6, height: 1_100_000 });
+    const l = await enableAndSettle(live);
+    const legendTotal = l.legend.reduce((sum, { count }) => sum + count, 0);
+    // Bin what adsb.lol actually returned with the layer's own rules: live
+    // traffic varies by hour, so cells are required only when some cell
+    // really reached the minimum aircraft count.
+    const liveSnapshots = (await Promise.allSettled(liveBodies))
+      .filter((r) => r.status === 'fulfilled')
+      .map((r) => r.value);
+    record(
+      'LIVE: a successful, dated integrity response was received',
+      liveSnapshots.length > 0 &&
+        liveSnapshots.every(
+          (body) =>
+            Array.isArray(body.rows) &&
+            Number.isFinite(body.ageMs) &&
+            body.ageMs >= 0 &&
+            body.ageMs <= 60000 &&
+            body.stale !== true &&
+            body.classifier === 'gev-nic-nacp-v2',
+        ),
+      `successful responses=${liveSnapshots.length}`,
+    );
+    const liveRows = liveSnapshots.reduce(
+      (sum, body) => sum + (body.rows?.length || 0),
+      0,
+    );
+    const expectedStore = new Map();
+    for (const body of liveSnapshots) {
+      const at = Date.now();
+      accumulateGnssObservations(expectedStore, body.rows, at, {
+        observedAt: at - body.ageMs,
+      });
+    }
+    const expectedCells = binGnssCells(expectedStore).length;
+    record(
+      'LIVE: no error, one geometry per cell',
+      !l.stats.error && l.entities === l.stats.count,
+      `cells=${l.stats.count} entities=${l.entities} error=${JSON.stringify(l.stats.error)}`,
+    );
+    if (expectedCells > 0) {
+      record(
+        'LIVE: a snapshot with a qualifying cell yields cells',
+        l.stats.count > 0,
+        `rows=${liveRows} expected=${expectedCells} cells=${l.stats.count}`,
+      );
+    } else {
+      console.log(
+        `  [info] ${liveRows} live rows, no cell reaches the minimum — cell count not asserted`,
+      );
+    }
+    record(
+      'LIVE: legend band counts sum to the cell count',
+      legendTotal === l.stats.count,
+      JSON.stringify(l.legend),
+    );
+    const liveBuilt = await waitForBuiltCells(live);
+    record(
+      'LIVE: every cell rectangle is built on a parked camera',
+      liveBuilt.built,
+      liveBuilt.detail,
+    );
+    await shoot(live, 'live-poland-baltic');
+    await live.close();
+
+    // ── (ii) BANDS ────────────────────────────────────────────────────────
+    console.log(
+      '\n(ii) BANDS — synthetic integrity rows through the real layer...',
+    );
+    const page = await browser.newPage();
+    await page.setViewport({ width: 1440, height: 900 });
+    page.on('pageerror', (e) => errors.push(e.message));
+    // Stub the route in-page rather than with request interception: an
+    // intercepted page stalls Cesium's geometry workers, so ground rectangles
+    // never finish building and the screenshot would not show real behaviour.
+    await stubRoute(page);
+    await boot(page, { lon: 18.6, lat: 54.6, height: 450_000 });
+    const f = await enableAndSettle(page);
+    const band = (prefix) =>
+      f.legend.find(({ label }) => label.startsWith(prefix))?.count;
+    record(
+      'BANDS: 4 cells shown, the 2-aircraft cell withheld',
+      f.stats.count === 4 && f.entities === 4,
+      `cells=${f.stats.count} entities=${f.entities}`,
+    );
+    record(
+      'BANDS: 5/10 is high, 2/30 is medium, 1/3 and 0/4 are low',
+      band('Low-accuracy score >') === 1 &&
+        band('Low-accuracy score 2') === 1 &&
+        band('Low-accuracy score <') === 2,
+      JSON.stringify(f.legend),
+    );
+    const prov = f.stats.provenance;
+    record(
+      'PROVENANCE: GEV classifier, gpsjam bands and visited-view window are machine-readable',
+      prov?.classifier?.id === 'gev-nic-nacp-v2' &&
+        prov.classifier.definedBy === 'GEV' &&
+        prov.classifier.validated === false &&
+        prov.aggregation?.source === 'https://gpsjam.org/faq' &&
+        JSON.stringify(prov.aggregation.bands) === '[2,10]' &&
+        prov.window?.minutes === 30 &&
+        prov.window.scope === 'visited-view' &&
+        prov.interpretation?.validated === false,
+      JSON.stringify(prov?.classifier),
+    );
+    record(
+      'WORDING: the row leads with low navigation accuracy, interference only as the hedged reading',
+      f.name === 'GNSS Integrity' &&
+        f.rowName.includes('GNSS Integrity') &&
+        !/interference/i.test(f.rowName) &&
+        f.legend.every(({ label }) => label.startsWith('Low-accuracy score')) &&
+        /one aircraft is discounted/.test(f.blurb) &&
+        /not a detection/.test(f.blurb),
+      `name=${JSON.stringify(f.name)}`,
+    );
+    record(
+      'BANDS: stale snapshot is reported',
+      f.stats.stale === true,
+      `stale=${f.stats.stale}`,
+    );
+    const bandsBuilt = await waitForBuiltCells(page);
+    record(
+      'BANDS: every cell rectangle is built on a parked camera',
+      bandsBuilt.built,
+      bandsBuilt.detail,
+    );
+    await shoot(page, 'synthetic-bands');
+
+    // GNSS fills must not own map input, including over a real perimeter.
+    await page.evaluate(async () => {
+      const original = window.fetch.bind(window);
+      window.fetch = (input, init) => {
+        const url = typeof input === 'string' ? input : input.url;
+        if (url.includes('/api/fire-perimeters/inciweb'))
+          return Promise.resolve(Response.json({ rows: [] }));
+        if (url.includes('/api/fire-perimeters'))
+          return Promise.resolve(
+            Response.json({
+              rows: [
+                {
+                  stableId: 'gnss-pick-qa',
+                  name: 'GNSS PICK QA FIRE',
+                  containedPct: 0,
+                  acres: 100,
+                  polygons: [
+                    [
+                      [
+                        [18.247, 54.247],
+                        [18.253, 54.247],
+                        [18.253, 54.253],
+                        [18.247, 54.253],
+                        [18.247, 54.247],
+                      ],
+                    ],
+                  ],
+                },
+              ],
+            }),
+          );
+        return original(input, init);
+      };
+      const { viewer, dataManager } = window.__godsEyeView;
+      viewer.camera.cancelFlight();
+      viewer.camera.setView({
+        destination: viewer.scene.globe.ellipsoid.cartographicToCartesian({
+          longitude: (18.25 * Math.PI) / 180,
+          latitude: (54.25 * Math.PI) / 180,
+          height: 2500,
+        }),
+        orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+      });
+      await dataManager.setEnabled('fire-perimeters', true);
+      viewer.scene.requestRender();
+    });
+    await page.waitForFunction(
+      () => {
+        const v = window.__godsEyeView.viewer,
+          p = v.scene.pick({
+            x: v.scene.canvas.clientWidth / 2,
+            y: v.scene.canvas.clientHeight / 2,
+          });
+        return String(p?.id?.id ?? p?.id ?? '').startsWith(
+          'fire-perimeter:gnss-pick-qa:',
+        );
+      },
+      { timeout: TIMEOUT_MS, polling: 250 },
+    );
+    const pickProbe = await page.evaluate(() => {
+      const v = window.__godsEyeView.viewer,
+        c = v.scene.canvas;
+      const centre = { x: c.clientWidth / 2, y: c.clientHeight / 2 };
+      const empty = { x: centre.x + 300, y: centre.y };
+      const picked = v.scene.pick(empty),
+        box = c.getBoundingClientRect();
+      return {
+        centre: { x: centre.x + box.left, y: centre.y + box.top },
+        empty: { x: empty.x + box.left, y: empty.y + box.top },
+        surface: !picked || picked.id === undefined,
+        height: v.camera.positionCartographic.height,
+      };
+    });
+    record('PICK: a perimeter remains selectable under GNSS', true);
+    record(
+      'PICK: street ground remains a surface pick under GNSS',
+      pickProbe.surface,
+    );
+    const beforeCardPixels = await page.evaluate(paintedOverlayPixels);
+    await page.mouse.click(pickProbe.centre.x, pickProbe.centre.y);
+    await page.waitForFunction(
+      `(${paintedOverlayPixels})() > ${beforeCardPixels + 100}`,
+      { timeout: 10000, polling: 250 },
+    );
+    const selectedCardPixels = await page.evaluate(paintedOverlayPixels);
+    record(
+      'PICK: actual perimeter click paints its incident card',
+      selectedCardPixels > beforeCardPixels + 100,
+      `${beforeCardPixels} → ${selectedCardPixels} pixels`,
+    );
+    await page.screenshot({
+      path: path.join(SHOTS_DIR, 'gnss-perimeter-selected.png'),
+    });
+    await page.mouse.click(pickProbe.empty.x, pickProbe.empty.y);
+    await page.waitForFunction(
+      `(${paintedOverlayPixels})() <= ${beforeCardPixels}`,
+      { timeout: 10000, polling: 250 },
+    );
+    const clearedCardPixels = await page.evaluate(paintedOverlayPixels);
+    record(
+      'PICK: empty ground clears the perimeter card',
+      clearedCardPixels <= beforeCardPixels,
+      `${selectedCardPixels} → ${clearedCardPixels} pixels`,
+    );
+    await page.mouse.click(pickProbe.empty.x, pickProbe.empty.y, {
+      clickCount: 2,
+    });
+    await sleep(1000);
+    record(
+      'PICK: empty double-click does not zoom to a GNSS cell',
+      await page.evaluate(
+        (height) =>
+          Math.abs(
+            window.__godsEyeView.viewer.camera.positionCartographic.height -
+              height,
+          ) < 200,
+        pickProbe.height,
+      ),
+    );
+    await page.evaluate(async () => {
+      await window.__godsEyeView.dataManager.setEnabled(
+        'fire-perimeters',
+        false,
+      );
+    });
+    console.log('\nCAMERA — automatic regional refresh without toggling...');
+    const beforeMove = await page.evaluate(
+      () => window.__gnssQaRequests.length,
+    );
+    await page.evaluate(() => {
+      const { viewer } = window.__godsEyeView;
+      viewer.camera.setView({
+        destination: viewer.scene.globe.ellipsoid.cartographicToCartesian({
+          longitude: (139.7 * Math.PI) / 180,
+          latitude: (35.7 * Math.PI) / 180,
+          height: 1_100_000,
+        }),
+        orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+      });
+      viewer.scene.requestRender();
+    });
+    await page.waitForFunction(
+      () => {
+        const url = window.__gnssQaRequests.at(-1);
+        return (
+          url &&
+          Math.abs(
+            Number(new URL(url, location.origin).searchParams.get('lon')) -
+              139.7,
+          ) < 1
+        );
+      },
+      { timeout: 15000 },
+    );
+    await sleep(3500);
+    const moved = await page.evaluate(
+      (id) => ({
+        requests: window.__gnssQaRequests.length,
+        enabled: window.__godsEyeView.dataManager.isEnabled(id),
+        coverage: window.__godsEyeView.dataManager.layers
+          .get(id)
+          .module.getStats().coverage,
+        info: document.querySelector(
+          `[data-layer-id="${id}"] .data-toggle-controls-info`,
+        )?.textContent,
+      }),
+      LAYER_ID,
+    );
+    record(
+      'CAMERA: moving to Tokyo automatically refreshes the new region and updates the row',
+      moved.enabled &&
+        moved.requests > beforeMove &&
+        moved.requests <= beforeMove + 2 &&
+        moved.coverage?.longitude === 140 &&
+        /Regional sample.*250 nm radius/.test(moved.info),
+      JSON.stringify(moved),
+    );
+    await shoot(page, 'camera-refresh');
+    await page.evaluate(() => {
+      const { viewer } = window.__godsEyeView;
+      viewer.camera.setView({
+        destination: viewer.scene.globe.ellipsoid.cartographicToCartesian({
+          longitude: (12.4 * Math.PI) / 180,
+          latitude: (41.9 * Math.PI) / 180,
+          height: 16_000_000,
+        }),
+        orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+      });
+      viewer.scene.requestRender();
+    });
+    await page.waitForFunction(
+      () => {
+        const url = window.__gnssQaRequests.at(-1);
+        const params = url && new URL(url, location.origin).searchParams;
+        return (
+          params &&
+          Math.abs(Number(params.get('lon')) - 12.4) < 1 &&
+          Math.abs(Number(params.get('lat')) - 41.9) < 1
+        );
+      },
+      { timeout: 15000 },
+    );
+    const world = await page.evaluate((id) => {
+      const { viewer, dataManager } = window.__godsEyeView;
+      const bounds = viewer.camera.computeViewRectangle(
+        viewer.scene.globe.ellipsoid,
+      );
+      return {
+        enabled: dataManager.isEnabled(id),
+        height: viewer.camera.positionCartographic.height,
+        boundsMidLongitude:
+          bounds && ((bounds.west + bounds.east) * 90) / Math.PI,
+        coverage: dataManager.layers.get(id).module.getStats().coverage,
+      };
+    }, LAYER_ID);
+    record(
+      'GLOBE: zoomed-out sampling stays centred on Rome and exposes its regional radius',
+      world.enabled &&
+        world.height > 15_000_000 &&
+        world.coverage?.longitude === 12 &&
+        world.coverage?.latitude === 42 &&
+        world.coverage?.radiusNm === 250,
+      JSON.stringify(world),
+    );
+    await shoot(page, 'globe-regional');
+    await page.evaluate(() => {
+      const { viewer } = window.__godsEyeView;
+      viewer.camera.setView({
+        destination: viewer.scene.globe.ellipsoid.cartographicToCartesian({
+          longitude: (18.6 * Math.PI) / 180,
+          latitude: (54.6 * Math.PI) / 180,
+          height: 450_000,
+        }),
+        orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
+      });
+      viewer.scene.requestRender();
+    });
+    await page.waitForFunction(
+      () => {
+        const url = window.__gnssQaRequests.at(-1);
+        return (
+          url &&
+          Math.abs(
+            Number(new URL(url, location.origin).searchParams.get('lon')) -
+              18.6,
+          ) < 1
+        );
+      },
+      { timeout: 15000 },
+    );
+    await sleep(3500);
+
+    // ── (iii) FAILURE ─────────────────────────────────────────────────────
+    console.log('\n(iii) FAILURE — /api/gnss-integrity stubbed to 502...');
+    await page.evaluate(() => {
+      window.__gnssQaMode = 'error';
+    });
+    const e = await enableAndSettle(page, { refresh: true });
+    record(
+      'FAILURE: error surfaced, cells kept',
+      Boolean(e.stats.error) && e.stats.count === 4 && e.entities === 4,
+      `error=${JSON.stringify(e.stats.error)} cells=${e.stats.count}`,
+    );
+    await shoot(page, 'failure');
+
+    // ── (iv) DISABLE ──────────────────────────────────────────────────────
+    console.log('\n(iv) DISABLE...');
+    const shown = await page.evaluate(async (id) => {
+      await window.__godsEyeView.dataManager.setEnabled(id, false);
+      const all = window.__godsEyeView.viewer.scene.groundPrimitives;
+      return Array.from({ length: all.length }, (_, i) => all.get(i)).find(
+        (item) => item.id === id,
+      )?.show;
+    }, LAYER_ID);
+    record('DISABLE: data source hidden', shown === false, `show=${shown}`);
+    await shoot(page, 'disabled');
+
+    // ── (v) KEYBOARD ──────────────────────────────────────────────────────
+    console.log('\n(v) KEYBOARD — the row toggle, from the keyboard...');
+    await page.evaluate(() => {
+      window.__gnssQaMode = 'fixture';
+    });
+    await showLayerRow(page);
+    const on = await pressToggle(page, 'Enter', true);
+    record(
+      'KEYBOARD: Enter on the focused toggle enables the layer and keeps focus',
+      on.enabled &&
+        on.focused &&
+        on.count === 4 &&
+        /^GNSS Integrity: /.test(on.label) &&
+        !/OFF$/.test(on.label),
+      JSON.stringify(on),
+    );
+    const off = await pressToggle(page, ' ', false);
+    record(
+      'KEYBOARD: Space on the focused toggle disables it and the label says OFF',
+      !off.enabled && off.focused && /^GNSS Integrity: OFF$/.test(off.label),
+      JSON.stringify(off),
+    );
+
+    // ── (vi) VIEWPORT ─────────────────────────────────────────────────────
+    console.log(
+      '\n(vi) VIEWPORT — the open row on a 390x844 phone viewport...',
+    );
+    await page.close();
+    // A fresh page: switching an open page to isMobile reloads it, which
+    // would measure a half-booted app instead of the open row.
+    const phone = await browser.newPage();
+    await phone.setViewport({ width: 390, height: 844, isMobile: true });
+    phone.on('pageerror', (e) => errors.push(e.message));
+    await stubRoute(phone);
+    await boot(phone, { lon: 18.6, lat: 54.6, height: 450_000 });
+    await showLayerRow(phone);
+    await pressToggle(phone, 'Enter', true);
+    await showLayerRow(phone);
+    const fit = await phone.evaluate((id) => {
+      const row = document.querySelector(`[data-layer-id="${id}"]`);
+      const legend = [...row.querySelectorAll('.data-toggle-legend-item')];
+      const rect = row.getBoundingClientRect();
+      return {
+        width: window.innerWidth,
+        rowLeft: Math.round(rect.left),
+        rowRight: Math.round(rect.right),
+        overflow: row.scrollWidth - row.clientWidth,
+        legendItems: legend.length,
+        coverageInfo: row.querySelector('.data-toggle-controls-info')
+          ?.textContent,
+        legendInside: legend.every((item) => {
+          const r = item.getBoundingClientRect();
+          return (
+            r.width > 0 && r.left >= rect.left - 1 && r.right <= rect.right + 1
+          );
+        }),
+      };
+    }, LAYER_ID);
+    record(
+      'VIEWPORT: row and legend fit a 390 px viewport without horizontal overflow',
+      fit.rowLeft >= 0 &&
+        fit.rowRight <= fit.width &&
+        fit.overflow <= 0 &&
+        fit.legendItems === 3 &&
+        /Regional sample.*250 nm radius/.test(fit.coverageInfo) &&
+        fit.legendInside,
+      JSON.stringify(fit),
+    );
+    await phone.screenshot({ path: path.join(SHOTS_DIR, 'gnss-phone.png') });
+    await phone.close();
+
+    console.log(
+      '\nSTARTUP — initial rate limit stays enabled and recovers automatically...',
+    );
+    const retry = await browser.newPage();
+    await retry.setViewport({ width: 1440, height: 900 });
+    retry.on('pageerror', (e) => errors.push(e.message));
+    // Pages share the disposable test context's storage. Start this one cold,
+    // so a previous fixture cannot auto-enable GNSS before the START test.
+    await retry.evaluateOnNewDocument(() => localStorage.clear());
+    await stubRoute(retry, { initialFailures: 1, stale: false });
+    await boot(retry, { lon: 18.6, lat: 54.6, height: 450_000 });
+    await showLayerRow(retry);
+    await retry.evaluate((id) => {
+      window.__gnssQaFailedStarts = 0;
+      window.__godsEyeView.dataManager.subscribe((change) => {
+        if (change.layerId === id && change.type === 'visibility-failed')
+          window.__gnssQaFailedStarts++;
+      });
+    }, LAYER_ID);
+    const initial = await enableAndSettle(retry);
+    const limited = await retry.evaluate((id) => {
+      const dm = window.__godsEyeView.dataManager;
+      const row = document.querySelector(`[data-layer-id="${id}"]`);
+      return {
+        enabled: dm.isEnabled(id),
+        failedStarts: window.__gnssQaFailedStarts,
+        label: row.querySelector('.data-toggle-btn').textContent,
+        info: row.querySelector('.data-toggle-controls-info').textContent,
+      };
+    }, LAYER_ID);
+    record(
+      'STARTUP: first 429 keeps the layer enabled and shows automatic retry timing',
+      limited.enabled &&
+        limited.failedStarts === 0 &&
+        limited.label === 'UNAVAILABLE' &&
+        initial.stats.count === 0 &&
+        initial.stats.retryInSec > 0 &&
+        /rate limited.*Retrying automatically at/.test(limited.info),
+      JSON.stringify(limited),
+    );
+    await retry.screenshot({
+      path: path.join(SHOTS_DIR, 'gnss-startup-retrying.png'),
+    });
+    await retry.waitForFunction(
+      (id) => {
+        const layer = window.__godsEyeView.dataManager.layers.get(id);
+        return (
+          layer.enabled &&
+          layer.module.getStats().error === null &&
+          layer.module.getStats().count === 4
+        );
+      },
+      { timeout: 20000 },
+      LAYER_ID,
+    );
+    const recovered = await retry.evaluate(
+      (id) => ({
+        requests: window.__gnssQaRequests.length,
+        enabled: window.__godsEyeView.dataManager.isEnabled(id),
+        label: document.querySelector(
+          `[data-layer-id="${id}"] .data-toggle-btn`,
+        ).textContent,
+        info: document.querySelector(
+          `[data-layer-id="${id}"] .data-toggle-controls-info`,
+        ).textContent,
+      }),
+      LAYER_ID,
+    );
+    record(
+      'STARTUP: one automatic retry recovers to ON without toggling and clears the warning',
+      recovered.enabled &&
+        recovered.requests === 2 &&
+        recovered.label === 'ON' &&
+        !/Retrying/.test(recovered.info),
+      JSON.stringify(recovered),
+    );
+    await shoot(retry, 'startup-recovered');
+    await retry.close();
+
+    // ── (vii) AGE ─────────────────────────────────────────────────────────
+    console.log(
+      '\n(vii) AGE — a replayed stale snapshot keeps its observation time...',
+    );
+    const aged = await browser.newPage();
+    await aged.setViewport({ width: 1440, height: 900 });
+    aged.on('pageerror', (e) => errors.push(e.message));
+    await stubRoute(aged, { ageMs: 31 * 60_000 });
+    await boot(aged, { lon: 18.6, lat: 54.6, height: 450_000 });
+    const old = await enableAndSettle(aged, {});
+    record(
+      'AGE: a snapshot observed 31 min ago adds no cells and is not an error',
+      old.stats.count === 0 && old.entities === 0 && !old.stats.error,
+      `cells=${old.stats.count} entities=${old.entities} error=${JSON.stringify(old.stats.error)}`,
+    );
+    await aged.evaluate(() => {
+      window.__gnssQaAgeMs = 29 * 60_000;
+    });
+    const recent = await enableAndSettle(aged, { refresh: true });
+    record(
+      'AGE: the same snapshot observed 29 min ago is still inside the window',
+      recent.stats.count === 4 && recent.entities === 4,
+      `cells=${recent.stats.count} entities=${recent.entities}`,
+    );
+    await aged.close();
+    record(
+      'no uncaught browser errors',
+      errors.length === 0,
+      errors.slice(0, 3).join(' | '),
+    );
+  } catch (err) {
+    console.error('\x1b[31mHarness error:\x1b[0m', err);
+    exitCode = 3;
+  } finally {
+    await browser.close();
+  }
+
+  const pass = results.filter((r) => r.ok).length;
+  const fail = results.length - pass;
+  console.log('\n' + '─'.repeat(60));
+  console.log(`  RESULT: ${pass} passed, ${fail} failed`);
+  console.log(`  Shots : ${SHOTS_DIR}/gnss-*.png`);
+  console.log('─'.repeat(60) + '\n');
+  process.exit(exitCode || (fail > 0 ? 1 : 0));
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(3);
+});

scripts/qa-l9-matrix.mjs

@@ -1884,7 +1884,7 @@ async function runBrowserGroup(record) {
 
   await step('C15', async () => {
     // CRT/NVG/FLIR are DISPLAY LABELS; the real style ids are retro /
-    // surveillance / thermal (src/ui.js STYLE_STATUS_LABELS). Passing the
+    // surveillance / thermal (src/ui/visualPresets.js STYLE_STATUS_LABELS). Passing the
     // labels made every call a silent no-op that still "passed" — so assert
     // the returned visual state actually changed to the requested style.
     const wanted = [['retro', 'CRT'], ['surveillance', 'NVG'], ['thermal', 'FLIR'], ['normal', 'Normal']];
@@ -2006,8 +2006,9 @@ async function runBrowserGroup(record) {
       for (let i = 0; i < 20; i += 1) {
         // eslint-disable-next-line no-await-in-loop
         await new Promise((r) => setTimeout(r, 500));
-        const status = document.getElementById('gev-voice-status')?.textContent?.trim() || '';
-        if (status && status !== 'CONNECTING') break;
+        // The label is translated; the machine state is on the control.
+        const status = document.getElementById('gev-voice-control')?.dataset.status || '';
+        if (status && status !== 'connecting') break;
       }
       let diag = null;
       try { diag = vc.getDiagnostics?.(); } catch { /* not started */ }

scripts/qa-labels.mjs

@@ -86,14 +86,6 @@ function percentile(values, pct) {
   return sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * pct) - 1)];
 }
 
-function parseJson(value, fallback) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
-
 function analyzeMembership(samples) {
   let replacements = 0;
   let exposure = 0;

scripts/qa-layer-visibility.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+/**
+ * Real-browser proof for manager-owned periodic work and document visibility.
+ * Uses the app's development-only layer registration seam; no provider keys.
+ * Run: node scripts/qa-layer-visibility.mjs --url http://localhost:4173
+ * Hiding uses a real background tab, never a patched document.hidden getter.
+ */
+import assert from 'node:assert/strict';
+import puppeteer from 'puppeteer';
+import { chromeExecutablePath } from './qa-chrome.mjs';
+
+const args = process.argv.slice(2);
+const urlIndex = args.indexOf('--url');
+const url = new URL(
+  (urlIndex >= 0 ? args[urlIndex + 1] : undefined) ||
+    process.env.QA_BASE_URL ||
+    'http://localhost:4173',
+);
+url.searchParams.set('welcome', '0');
+const browser = await puppeteer.launch({
+  executablePath: chromeExecutablePath(),
+  headless: true,
+  args: [
+    '--no-sandbox',
+    '--disable-background-timer-throttling',
+    '--disable-renderer-backgrounding',
+  ],
+});
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const check = (name, actual, expected) => {
+  assert.equal(actual, expected, name);
+  console.log(`PASS ${name}: ${actual}`);
+};
+try {
+  const page = await browser.newPage();
+  const focus = await page.createCDPSession();
+  await focus.send('Emulation.setFocusEmulationEnabled', { enabled: true });
+  await page.goto(url.href, { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(
+    () => window.__gevQaRegisterLayer && window.__godsEyeView?.dataManager,
+  );
+  await page.evaluate(async () => {
+    const manager = window.__godsEyeView.dataManager;
+    window.__qaVisibilityUpdates = 0;
+    window.__gevQaRegisterLayer(manager, {
+      id: 'qa-document-visibility',
+      name: 'Visibility QA',
+      updateInterval: 750,
+      init() {},
+      enable() {},
+      disable() {},
+      destroy() {},
+      async update() {
+        window.__qaVisibilityUpdates++;
+        return true;
+      },
+      getStats() {
+        return { count: window.__qaVisibilityUpdates };
+      },
+    });
+    await manager.setEnabled('qa-document-visibility', true, { origin: 'qa' });
+  });
+  const count = () => page.evaluate(() => window.__qaVisibilityUpdates);
+  await page.waitForFunction(() => window.__qaVisibilityUpdates >= 3);
+  check('periodic updates run while visible', (await count()) >= 3, true);
+  await focus.send('Emulation.setFocusEmulationEnabled', { enabled: false });
+  const cover = await browser.newPage();
+  await cover.bringToFront();
+  await page.waitForFunction(() => document.visibilityState === 'hidden');
+  const hiddenCount = await count();
+  await pause(2200);
+  check('hidden tab makes no periodic updates', await count(), hiddenCount);
+  check(
+    'explicit refresh remains available while hidden',
+    await page.evaluate(() =>
+      window.__godsEyeView.dataManager.refreshLayer('qa-document-visibility'),
+    ),
+    true,
+  );
+  check('explicit hidden refresh runs once', await count(), hiddenCount + 1);
+  await focus.send('Emulation.setFocusEmulationEnabled', { enabled: true });
+  await page.waitForFunction(
+    () =>
+      document.visibilityState === 'visible' &&
+      window.__qaVisibilityUpdates > 0,
+  );
+  await pause(200);
+  check(
+    'resume performs one overdue refresh without a catch-up burst',
+    await count(),
+    hiddenCount + 2,
+  );
+  await page.evaluate(() =>
+    window.__godsEyeView.dataManager.setEnabled(
+      'qa-document-visibility',
+      false,
+      { origin: 'qa' },
+    ),
+  );
+  const stopped = await count();
+  await focus.send('Emulation.setFocusEmulationEnabled', { enabled: false });
+  await cover.bringToFront();
+  await page.waitForFunction(() => document.visibilityState === 'hidden');
+  await focus.send('Emulation.setFocusEmulationEnabled', { enabled: true });
+  await pause(1100);
+  check(
+    'disabled layer does not resume on visibility change',
+    await count(),
+    stopped,
+  );
+  check(
+    'QA layer destroys cleanly',
+    await page.evaluate(() =>
+      window.__gevQaUnregisterLayer(
+        window.__godsEyeView.dataManager,
+        'qa-document-visibility',
+      ),
+    ),
+    true,
+  );
+  console.log('RESULT: 7 passed');
+} finally {
+  await browser.close();
+}

scripts/qa-location-controls.mjs

@@ -84,6 +84,63 @@ try {
       () => window.__godsEyeView.styleManager._activePoiIndex === 1,
     ),
   );
+  const geocoderRequests = [];
+  const recordGeocoderRequest = (request) => {
+    const url = new URL(request.url());
+    if (
+      url.pathname === '/api/geocode' ||
+      url.pathname === '/api/google/geocode' ||
+      (url.hostname === 'photon.komoot.io' && url.pathname === '/api/')
+    )
+      geocoderRequests.push(request.url());
+  };
+  page.on('request', recordGeocoderRequest);
+  await page.$eval('#location-search', (input) => {
+    input.value = 'geo:39.7392,-104.9903';
+    input.focus();
+  });
+  await page.keyboard.press('Enter');
+  await page.waitForFunction(
+    () => {
+      const state =
+        window.__godsEyeView.styleManager._locationLookup.getState();
+      return (
+        state.query === 'geo:39.7392,-104.9903' && state.status === 'found'
+      );
+    },
+    { timeout: 30000 },
+  );
+  await page.waitForFunction(
+    () => !window.__godsEyeView.viewer.camera._currentFlight,
+    { timeout: 10000 },
+  );
+  check(
+    'native geo URI search shows the decimal coordinate readout',
+    await page.evaluate(() => {
+      const ui = window.__godsEyeView.styleManager;
+      return (
+        ui._searchedLocationLabel === '39.7392° N, 104.9903° W' &&
+        ui._locationMiniCity.textContent.includes('39.7392° N') &&
+        ui._locationMiniPoi.textContent === '104.9903° W'
+      );
+    }),
+  );
+  check(
+    'geo URI navigation settles near the requested coordinate',
+    await page.evaluate(() => {
+      const position = window.__godsEyeView.viewer.camera.positionCartographic;
+      const degrees = 180 / Math.PI;
+      return (
+        Math.abs(position.latitude * degrees - 39.7392) < 0.05 &&
+        Math.abs(position.longitude * degrees + 104.9903) < 0.05
+      );
+    }),
+  );
+  check(
+    'geo URI search makes no geocoder request',
+    geocoderRequests.length === 0,
+  );
+  page.off('request', recordGeocoderRequest);
   await page.evaluate(() => {
     const lookup = window.__godsEyeView.styleManager._locationLookup;
     window.__qaSearchRequests = [];
@@ -96,6 +153,7 @@ try {
         window.__qaSearchRequests.push({ query, options, resolve }),
       );
     document.getElementById('location-search').value = 'First';
+    document.getElementById('location-search').focus();
   });
   await page.keyboard.press('Enter');
   await page.waitForFunction(() => window.__qaSearchRequests.length === 1);

scripts/qa-map-source-tray.mjs

@@ -156,16 +156,52 @@ const pressTabs = async (count, backwards = false) => {
   // The row scrolls smoothly when native Tab brings an edge button into view.
   await new Promise((resolve) => setTimeout(resolve, 250));
 };
+// Phones (≤720px) present the dock's Presets inline in the More tab's sheet.
+// It opens from the keyboard, as a keyboard user would, so the focus it moves
+// into the sheet shows a ring.
+const openPhoneMoreSheet = async () => {
+  const tab = '#mobile-tab-bar [data-mobile-sheet="more"]';
+  if (await page.evaluate(() => document.body.dataset.mobileSheet === 'more')) {
+    await page.focus(tab);
+    await page.keyboard.press('Enter');
+  }
+  await page.focus(tab);
+  await page.keyboard.press('Enter');
+  await page.evaluate(() => new Promise((resolve) => {
+    requestAnimationFrame(() => requestAnimationFrame(resolve));
+  }));
+};
+
+// Media-query changes reach the page on a rendering step; wait until the
+// phone shell agrees with the viewport before measuring.
+const waitForShellSettled = () => page.waitForFunction(() => (
+  document.body.classList.contains('mobile-shell')
+    === matchMedia('(max-width: 720px)').matches
+), { timeout: 10_000, polling: 100 });
+
+// The dock slides back into place when the layout leaves the phone shell.
+const waitForDockSettled = () => page.waitForFunction(() => (
+  !document.getElementById('command-dock').getAnimations({ subtree: true })
+    .some((animation) => animation.playState === 'running')
+), { timeout: 5_000 });
+
 const checkResponsiveStyleFocus = async (width) => {
   // The disclosure is only the starting boundary. Every style target below is
   // reached by actual Tab events, never by focusing the style under test.
   const selectedMapBefore = await page.evaluate(() => (
     window.__godsEyeView.styleManager.mapStackController.getActiveId()
   ));
-  await page.focus('#control-panel-toggle');
-  await pressTabs(2); // disclosure -> pin -> Normal
-  for (const [index, style] of ['normal', 'thermal', 'snow'].entries()) {
-    if (index) await pressTabs(3);
+  if (width <= 720) {
+    // Phones show Presets in the More tab's sheet, which focuses its first
+    // visible control (Normal) when it opens; the tray toggle and pin are
+    // desktop chrome there.
+    await openPhoneMoreSheet();
+  } else {
+    await page.focus('#control-panel-toggle');
+    await pressTabs(2); // disclosure -> pin -> Normal
+  }
+  for (const [tabs, style] of [[0, 'normal'], [3, 'thermal'], [2, 'noir']]) {
+    if (tabs) await pressTabs(tabs);
     const state = await styleFocusMetrics();
     check(`${width} px ${style} keyboard ring is visible and unclipped`,
       hasVisibleStyleFocus(state, style) && state.selectedStyle === 'normal'
@@ -215,7 +251,16 @@ const layerFocusState = async (id) => ({
   ...await page.evaluate((layerId) => {
     const manager = window.__godsEyeView.dataManager;
     const button = document.querySelector(`[data-layer-id="${layerId}"] .data-toggle-btn`);
-    const list = document.getElementById('data-toggles');
+    // The list scrolls on its own on desktop; in a phone sheet the sheet
+    // scrolls instead. Measure whichever container actually scrolls.
+    let list = document.getElementById('data-toggles');
+    for (let node = list; node; node = node.parentElement) {
+      const overflow = getComputedStyle(node).overflowY;
+      if ((overflow === 'auto' || overflow === 'scroll') && node.scrollHeight > node.clientHeight) {
+        list = node;
+        break;
+      }
+    }
     return {
       lifecycle: manager.getLayerLifecycleState(layerId),
       feedState: button?.dataset.feedState, label: button?.textContent.trim(),
@@ -522,13 +567,13 @@ try {
   // Visual Styles precede the five Map Source tiles. Keep the existing opening
   // handoff to selected OSM, then use the user's real Shift+Tab path into styles.
   await pressTabs(5, true);
-  const snowFocus = await styleFocusMetrics();
-  check('Shift+Tab reaches Snow with a visible ring while Normal and OSM stay selected',
-    hasVisibleStyleFocus(snowFocus, 'snow') && !snowFocus.selected
-      && snowFocus.selectedStyle === 'normal' && snowFocus.selectedMap === 'osm',
-    JSON.stringify(snowFocus));
+  const noirFocus = await styleFocusMetrics();
+  check('Shift+Tab reaches Noir with a visible ring while Normal and OSM stay selected',
+    hasVisibleStyleFocus(noirFocus, 'noir') && !noirFocus.selected
+      && noirFocus.selectedStyle === 'normal' && noirFocus.selectedMap === 'osm',
+    JSON.stringify(noirFocus));
   await page.screenshot({ path: path.join(shotsDir, 'keyboard-style-focus.png') });
-  await pressTabs(3, true);
+  await pressTabs(2, true);
   const middleFocus = await styleFocusMetrics();
   check('Shift+Tab traverses the middle FLIR style without activating it',
     hasVisibleStyleFocus(middleFocus, 'thermal') && !middleFocus.selected
@@ -1146,6 +1191,8 @@ try {
 
   await page.setViewport({ width: 620, height: 900, deviceScaleFactor: 1 });
   await new Promise((resolve) => setTimeout(resolve, 180));
+  await waitForShellSettled();
+  await openPhoneMoreSheet();
   const at620 = await trayMetrics();
   check(
     '620 px tray uses two rows without clipping',
@@ -1179,7 +1226,13 @@ try {
   await page.screenshot({ path: path.join(shotsDir, '480-open.png') });
   await checkResponsiveStyleFocus(480);
 
+  // Pinning and the compact wing are the narrow desktop dock (721–900 px);
+  // phones use the tab bar instead.
+  await page.setViewport({ width: 800, height: 900, deviceScaleFactor: 1 });
+  await waitForShellSettled();
+  await waitForDockSettled();
   await page.click('.dock-pin-btn[data-pin-target="control-panel"]');
+  await waitForDockSettled();
   await page.click('#control-panel-toggle');
   const cdp = await page.createCDPSession();
   await cdp.send('Emulation.setTouchEmulationEnabled', { enabled: true, maxTouchPoints: 1 });
@@ -1374,6 +1427,27 @@ try {
 
     for (const width of [1000, 620, 480]) {
       await page.setViewport({ width, height: 900, deviceScaleFactor: 1 });
+      await waitForShellSettled();
+      if (width <= 720) {
+        // Phones present Location as the Search tab's sheet: the keyboard opens
+        // it onto the field, and Escape returns focus to the tab.
+        const searchTab = '#mobile-tab-bar [data-mobile-sheet="search"]';
+        await page.focus(searchTab);
+        await page.keyboard.press('Enter');
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        const field = await focusMetrics('#location-search');
+        check(`Search: ${width} px keyboard opens the sheet on the location field`,
+          field.focusedId === 'location-search' && field.visible && field.insideViewport,
+          JSON.stringify(field));
+        await page.screenshot({ path: path.join(shotsDir, `${width}-search-open.png`) });
+        await page.keyboard.press('Escape');
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        const tab = await focusMetrics(searchTab);
+        const closedSheet = await page.evaluate(() => !document.body.dataset.mobileSheet);
+        check(`Search: ${width} px Escape closes the sheet with a visible ring on its tab`,
+          closedSheet && hasVisibleControlFocus(tab), JSON.stringify({ closedSheet, tab }));
+        continue;
+      }
       await page.evaluate(() => {
         const manager = window.__godsEyeView.styleManager;
         manager.setPanelCollapsed('control-panel', true, { persist: false, syncShare: false });
@@ -1489,6 +1563,12 @@ try {
     if (dataSetup.ready) {
       for (const width of [1000, 620, 480]) {
         await page.setViewport({ width, height: 900, deviceScaleFactor: 1 });
+        await waitForShellSettled();
+        if (width <= 720 && !(await page.evaluate(() => document.body.dataset.mobileSheet === 'layers'))) {
+          // Phones present Data Layers in the Layers tab's sheet.
+          await page.focus('#mobile-tab-bar [data-mobile-sheet="layers"]');
+          await page.keyboard.press('Enter');
+        }
         await page.evaluate(() => window.__godsEyeView.styleManager.setPanelCollapsed('data-panel', false, { persist: false, syncShare: false }));
         // Resizing schedules rail placement on animation frames. Wait for that
         // pass and its CSS transitions before comparing a focus rectangle with
@@ -1549,6 +1629,7 @@ try {
       )));
 
       await page.setViewport({ width: 1000, height: 900, deviceScaleFactor: 1 });
+      await waitForShellSettled();
       await page.evaluate(() => window.__godsEyeView.styleManager.setPanelCollapsed('data-panel', false, { persist: false, syncShare: false }));
       await page.focus('#data-panel .panel-collapse-btn');
       const transitionTab = await tabTo(`[data-layer-id="${dataSetup.transitionId}"] .data-toggle-btn`);

scripts/qa-overpass-offload.mjs

@@ -306,7 +306,16 @@ try {
   await observeNetwork(page);
   page.on('pageerror', (error) => result.errors.push(error.message));
   page.on('console', (message) => {
-    if (message.type() === 'error' && result.consoleErrors.length < 30)
+    if (message.type() !== 'error') return;
+    // A keyless server does not offer optional Google tokens. Keep every other
+    // HTTP or JavaScript error visible, including failures of this route other
+    // than its expected capability-miss 404.
+    const optionalTokenMiss =
+      message.location().url === new URL('/api/google/tiles-token', url).href &&
+      /^Failed to load resource: the server responded with a status of 404\b/.test(
+        message.text(),
+      );
+    if (!optionalTokenMiss && result.consoleErrors.length < 30)
       result.consoleErrors.push(message.text());
   });
   page.on('requestfailed', (request) => {

scripts/qa-panel-resize.mjs

@@ -1,456 +0,0 @@
-#!/usr/bin/env node
-/**
- * Browser QA for the floating CCTV panel: lift, resize from every handle,
- * minimum size, reload, and dock again. `--fail-on-retry` (or
- * QA_FAIL_ON_RETRY=1) fails on any header-press retry.
- */
-import assert from 'node:assert/strict';
-import { pathToFileURL } from 'node:url';
-import { RESIZE_DIRECTIONS, resizeBox } from '../src/ui/panelResize.js';
-import {
-  describePress,
-  dockPanelByDoubleClick,
-  dragPointer,
-  liftPanelByHeader,
-  nextFrames,
-} from './qa-panelDrag.mjs';
-import {
-  hookRenderErrors,
-  readRenderErrors,
-  saveFailureArtifacts,
-  watchPage,
-} from './qa-browserEvidence.mjs';
-
-export const PANEL_ID = 'cctv-panel';
-export const STORAGE_KEY = `godsEyeView.v8.panelPos.${PANEL_ID}`;
-export const MIN_SIZE = { width: 300, height: 160 };
-export const ARTIFACT_DIR = 'qa-artifacts/panel-resize';
-const VIEWPORT = { width: 1400, height: 900 };
-const EDGE_BY_SIDE = { n: 'top', s: 'bottom', e: 'right', w: 'left' };
-
-/** Box edges a resize in `dir` must leave exactly where they were. */
-export function pinnedEdges(dir) {
-  return Object.entries(EDGE_BY_SIDE)
-    .filter(([side]) => !dir.includes(side))
-    .map(([, edge]) => edge);
-}
-
-/** Pointer travel that grows a panel by `amount` on every edge named in `dir`. */
-export function growthDelta(dir, amount) {
-  return {
-    dx: dir.includes('e') ? amount : dir.includes('w') ? -amount : 0,
-    dy: dir.includes('s') ? amount : dir.includes('n') ? -amount : 0,
-  };
-}
-
-/**
- * Viewport point inside the handle for `dir`, given the panel's client rect.
- * Edge strips straddle the border by 3px; corners and the grip sit inside.
- */
-export function handlePoint(rect, dir) {
-  const inset = dir.length === 2 ? 4 : 1;
-  const x = dir.includes('w')
-    ? rect.left + inset
-    : dir.includes('e')
-      ? rect.right - inset
-      : rect.left + rect.width / 2;
-  const y = dir.includes('n')
-    ? rect.top + inset
-    : dir.includes('s')
-      ? rect.bottom - inset
-      : rect.top + rect.height / 2;
-  return { x, y };
-}
-
-/** Pinned edges that moved during a resize in `dir`. */
-export function driftedEdges(before, after, dir, tolerance = 1.5) {
-  const edges = (box) => ({
-    left: box.left,
-    top: box.top,
-    right: box.left + box.width,
-    bottom: box.top + box.height,
-  });
-  const a = edges(before);
-  const b = edges(after);
-  return pinnedEdges(dir).filter(
-    (edge) => Math.abs(a[edge] - b[edge]) > tolerance,
-  );
-}
-
-function near(actual, expected, tolerance, label) {
-  assert.ok(
-    Math.abs(actual - expected) <= tolerance,
-    `${label}: expected ${expected} ± ${tolerance}, got ${actual}`,
-  );
-}
-
-async function main() {
-  const { default: puppeteer } = await import('puppeteer');
-  const args = process.argv.slice(2);
-  const urlIndex = args.indexOf('--url');
-  const url = urlIndex >= 0 ? args[urlIndex + 1] : 'http://localhost:4173';
-  if (args.includes('--fail-on-retry')) process.env.QA_FAIL_ON_RETRY = '1';
-  const browser = await puppeteer.launch({
-    headless: true,
-    executablePath:
-      process.env.PUPPETEER_EXECUTABLE_PATH ||
-      (await puppeteer.executablePath()),
-    args: ['--no-sandbox', '--use-gl=angle', '--use-angle=swiftshader'],
-  });
-  const monitors = [];
-  try {
-    const page = await browser.newPage();
-    await page.setViewport(VIEWPORT);
-    const errors = [];
-    monitors.push(watchPage(page, { name: 'panel', errors }));
-    await hookRenderErrors(page);
-
-    const boot = async () => {
-      await page.goto(`${url}/`, { waitUntil: 'domcontentloaded' });
-      await page.waitForFunction(() => window.__godsEyeView?.viewer, {
-        timeout: 90_000,
-      });
-      await page.waitForSelector(`#${PANEL_ID} .panel-header`);
-      await page.evaluate(() => {
-        document.querySelector('.first-run-explore')?.click();
-      });
-      await page.keyboard.press('Escape');
-      await page.evaluate(() => {
-        document.getElementById('first-run-launcher')?.remove();
-        for (const node of document.querySelectorAll('[class*=first-run]'))
-          node.remove();
-      });
-      await page.mouse.click(VIEWPORT.width / 2, VIEWPORT.height / 2);
-      await nextFrames(page);
-    };
-    const readPanel = () =>
-      page.evaluate((id) => {
-        const panel = document.getElementById(id);
-        const rect = panel.getBoundingClientRect();
-        return {
-          left: rect.left,
-          top: rect.top,
-          width: rect.width,
-          height: rect.height,
-          // handlePoint() reads the far edges for s/e handles.
-          right: rect.right,
-          bottom: rect.bottom,
-          floating: panel.classList.contains('panel-floating'),
-          collapsed: panel.classList.contains('collapsed'),
-          inRail: panel.parentElement?.id === 'right-context-rail',
-          allocated: panel.style.getPropertyValue(
-            '--right-panel-allocated-height',
-          ),
-          inlineWidth: panel.style.width,
-          inlineHeight: panel.style.height,
-          stored: localStorage.getItem(`godsEyeView.v8.panelPos.${id}`),
-        };
-      }, PANEL_ID);
-    /**
-     * Best effort: wait for the box to hold still for half a second. The lift
-     * is checked against the box at pointerdown, so a timeout only costs time.
-     */
-    const settle = async () => {
-      try {
-        await page.waitForFunction(
-          (id) => {
-            const r = document.getElementById(id).getBoundingClientRect();
-            const box = [r.left, r.top, r.width, r.height]
-              .map(Math.round)
-              .join(',');
-            const now = performance.now();
-            if (window.__qaLastBox !== box) {
-              window.__qaLastBox = box;
-              window.__qaSince = now;
-            }
-            return now - window.__qaSince >= 500;
-          },
-          { polling: 100, timeout: 20_000 },
-          PANEL_ID,
-        );
-      } catch (error) {
-        if (error?.name !== 'TimeoutError') throw error;
-        console.log('note: the CCTV panel was still moving; lifting anyway');
-      }
-    };
-    const headerPoint = async () => {
-      const rect = await page.evaluate((id) => {
-        const title = document.querySelector(
-          `#${id} .panel-header .panel-title`,
-        );
-        const r = title.getBoundingClientRect();
-        return { x: r.left + r.width / 2, y: r.top + r.height / 2 };
-      }, PANEL_ID);
-      return rect;
-    };
-    const drag = (from, dx, dy) => dragPointer(page, from, dx, dy);
-
-    await page.goto(`${url}/`, { waitUntil: 'domcontentloaded' });
-    await page.evaluate((key) => {
-      localStorage.removeItem(key);
-      localStorage.removeItem('godsEyeView.v8.panelFloatHintShown');
-    }, STORAGE_KEY);
-    await boot();
-
-    await page.evaluate((id) => {
-      const panel = document.getElementById(id);
-      if (panel.classList.contains('collapsed'))
-        document
-          .querySelector(`.panel-collapse-btn[data-collapse-target="${id}"]`)
-          .click();
-    }, PANEL_ID);
-    await page.waitForFunction(
-      (id) => !document.getElementById(id).classList.contains('collapsed'),
-      {},
-      PANEL_ID,
-    );
-    // The rail animates panel heights, and on a slow software renderer the
-    // panels above CCTV can still be moving after a fixed sleep.
-    await settle();
-    const docked = await readPanel();
-    assert.equal(docked.floating, false);
-    assert.equal(docked.inRail, true);
-
-    // Names whatever above CCTV in the rail shifted it, for a retry note.
-    const railAbove = () =>
-      page.evaluate((id) => {
-        const out = [];
-        for (const node of document.getElementById('right-context-rail')
-          ?.children || []) {
-          if (node.id === id) break;
-          out.push(
-            `${node.id || node.className}:${Math.round(node.offsetHeight)}`,
-          );
-        }
-        return out.join(' ');
-      }, PANEL_ID);
-    const aboveAtDock = await railAbove();
-    // On CI a panel above CCTV grows after load and can shift the header out
-    // from under the press; the helper retries only such a provable miss.
-    const attempt = await liftPanelByHeader(page, PANEL_ID, {
-      dx: -200,
-      dy: -100,
-      note: async () =>
-        `rail above CCTV ${aboveAtDock} -> ${await railAbove()}`,
-    });
-    const { pressed } = attempt;
-    const lifted = await readPanel();
-    assert.equal(
-      lifted.floating,
-      true,
-      `a header drag lifts the panel out (${describePress(attempt)}; panel docked at ${docked.top}, at press ${pressed?.top})`,
-    );
-    assert.equal(
-      lifted.collapsed,
-      false,
-      'the drag-ending click must not collapse',
-    );
-    const moved = `docked at ${docked.left},${docked.top}; pressed at ${pressed.left},${pressed.top}`;
-    near(
-      lifted.left,
-      Math.max(6, pressed.left - 200),
-      2,
-      `lifted left (${moved})`,
-    );
-    near(
-      lifted.top,
-      Math.max(6, pressed.top - 100),
-      2,
-      `lifted top (${moved})`,
-    );
-    near(lifted.width, pressed.width, 2, 'lifted width');
-    // The rail lets go of the lifted panel on its next layout pass.
-    await page
-      .waitForFunction(
-        (id) =>
-          document
-            .getElementById(id)
-            .style.getPropertyValue('--right-panel-allocated-height') === '',
-        { timeout: 5_000 },
-        PANEL_ID,
-      )
-      .catch(() => {});
-    const afterLayout = await readPanel();
-    assert.equal(afterLayout.allocated, '', 'the rail no longer allocates it');
-    const railExcludes = await page.evaluate((id) => {
-      const rail = document.getElementById('right-context-rail');
-      // Same rule as the rail: hidden panels take no room.
-      const counted = [...rail.children].filter((panel) =>
-        panel.matches(
-          '[data-panel-id]:not(.panel-floating):not(.collapsed):not([hidden])',
-        ),
-      );
-      return {
-        expandedCount: rail.dataset.expandedCount,
-        counted: counted.length,
-        includesPanel: counted.some((panel) => panel.id === id),
-      };
-    }, PANEL_ID);
-    assert.equal(railExcludes.includesPanel, false);
-    if (railExcludes.expandedCount !== undefined)
-      assert.equal(Number(railExcludes.expandedCount), railExcludes.counted);
-    const storedAfterLift = JSON.parse(afterLayout.stored);
-    assert.equal(storedAfterLift.floating, true);
-    assert.equal(
-      'height' in storedAfterLift,
-      false,
-      'a drag alone must not freeze the measured height',
-    );
-    console.log('PASS: header drag lifts CCTV out of the rail');
-
-    // Park near the top: the voice dock would cover the south corners once
-    // the loop below has grown the window.
-    {
-      const header = await headerPoint();
-      await drag(header, 0, 120 - header.y);
-    }
-
-    const limits = {
-      minWidth: MIN_SIZE.width,
-      minHeight: MIN_SIZE.height,
-      viewportWidth: VIEWPORT.width,
-      viewportHeight: VIEWPORT.height,
-    };
-    for (const dir of RESIZE_DIRECTIONS) {
-      const before = await readPanel();
-      const { dx, dy } = growthDelta(dir, 40);
-      const point = handlePoint(before, dir);
-      const hit = await page.evaluate(({ x, y }) => {
-        const node = document.elementFromPoint(x, y);
-        if (!node) return 'nothing';
-        const dirAttr = node.dataset?.dir
-          ? `[data-dir=${node.dataset.dir}]`
-          : '';
-        return `${node.tagName.toLowerCase()}${node.id ? `#${node.id}` : ''}.${[...node.classList].join('.')}${dirAttr}`;
-      }, point);
-      await drag(point, dx, dy);
-      const after = await readPanel();
-      const expected = resizeBox(before, dir, dx, dy, limits);
-      for (const key of ['left', 'top', 'width', 'height'])
-        near(after[key], expected[key], 2, `${dir} ${key} (pointer on ${hit})`);
-      assert.deepEqual(driftedEdges(before, after, dir, 2), [], `${dir} pins`);
-    }
-    console.log('PASS: eight resize handles keep the opposite edge pinned');
-
-    let before = await readPanel();
-    await drag(handlePoint(before, 'se'), -2000, -2000);
-    let after = await readPanel();
-    near(after.width, MIN_SIZE.width, 2, 'min width (se)');
-    near(after.height, MIN_SIZE.height, 2, 'min height (se)');
-    assert.deepEqual(driftedEdges(before, after, 'se', 2), []);
-    before = after;
-    await drag(handlePoint(before, 'nw'), 2000, 2000);
-    after = await readPanel();
-    near(after.width, MIN_SIZE.width, 2, 'min width (nw)');
-    near(after.height, MIN_SIZE.height, 2, 'min height (nw)');
-    assert.deepEqual(driftedEdges(before, after, 'nw', 2), []);
-    console.log('PASS: minimum size holds from both corners');
-
-    const saved = await readPanel();
-    const record = JSON.parse(saved.stored);
-    assert.equal(record.floating, true);
-    await boot();
-    const restored = await readPanel();
-    assert.equal(restored.floating, true, 'floating survives a reload');
-    for (const key of ['left', 'top', 'width', 'height'])
-      near(restored[key], record[key], 2, `restored ${key}`);
-    console.log('PASS: reload restores position and size');
-
-    // A collapsed window keeps the height chosen for it, through a drag of
-    // its header strip and a reload.
-    const setCollapsed = async (collapsed) => {
-      await page.evaluate(
-        (id, want) => {
-          const panel = document.getElementById(id);
-          if (panel.classList.contains('collapsed') !== want)
-            document
-              .querySelector(
-                `.panel-collapse-btn[data-collapse-target="${id}"]`,
-              )
-              .click();
-        },
-        PANEL_ID,
-        collapsed,
-      );
-      await page.waitForFunction(
-        (id, want) =>
-          document.getElementById(id).classList.contains('collapsed') === want,
-        {},
-        PANEL_ID,
-        collapsed,
-      );
-      await nextFrames(page);
-    };
-    await drag(handlePoint(await readPanel(), 'se'), 0, 200);
-    const chosen = await readPanel();
-    assert.ok(
-      chosen.height > MIN_SIZE.height + 150,
-      `the window grew to ${chosen.height}px`,
-    );
-    await setCollapsed(true);
-    const strip = await readPanel();
-    assert.ok(strip.height < chosen.height - 100, 'collapsed to its header');
-    await drag(await headerPoint(), 40, 30);
-    const movedStrip = await readPanel();
-    assert.equal(movedStrip.floating, true, 'the strip stays a window');
-    near(
-      JSON.parse(movedStrip.stored).height,
-      chosen.height,
-      2,
-      'stored height while collapsed',
-    );
-    await boot();
-    await setCollapsed(false);
-    near(
-      (await readPanel()).height,
-      chosen.height,
-      2,
-      'height after expanding',
-    );
-    console.log(
-      'PASS: a collapsed window keeps its height through a drag and a reload',
-    );
-
-    const dock = await dockPanelByDoubleClick(page, PANEL_ID);
-    const snapped = await readPanel();
-    assert.equal(
-      snapped.floating,
-      false,
-      `double-click snaps back (${describePress(dock)})`,
-    );
-    assert.equal(snapped.inRail, true);
-    assert.equal(snapped.inlineWidth, '');
-    assert.equal(snapped.inlineHeight, '');
-    assert.equal(snapped.stored, null, 'the storage key is gone');
-    console.log('PASS: header double-click returns the panel to the rail');
-
-    const renderErrors = await readRenderErrors(page);
-    assert.deepEqual(
-      [...errors, ...renderErrors.map((text) => `scene.renderError: ${text}`)],
-      [],
-      'no page errors and no Cesium render-loop errors',
-    );
-    console.log('PASS: no page errors and no render-loop errors');
-  } catch (error) {
-    const dir = await saveFailureArtifacts({
-      dir: ARTIFACT_DIR,
-      browser,
-      monitors,
-      error,
-    }).catch(() => null);
-    if (dir) console.error(`failure evidence saved in ${dir}/`);
-    throw error;
-  } finally {
-    await browser.close();
-  }
-}
-
-if (
-  process.argv[1] &&
-  import.meta.url === pathToFileURL(process.argv[1]).href
-) {
-  main().catch((error) => {
-    console.error(error.stack || error.message);
-    process.exit(1);
-  });
-}

scripts/qa-panelDrag.mjs

@@ -1,319 +0,0 @@
-/**
- * Header press-and-verify for the QA gates that lift a rail panel into a
- * floating window and dock it again. The rail animates panel heights, so a
- * point read once can be under another panel by the time the pointer goes
- * down. Only a provable miss (a recorded press outside the header) is
- * retried, with a GitHub `::warning::`. With QA_FAIL_ON_RETRY=1 a miss the
- * panel's own movement cannot explain fails the run instead.
- */
-
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-/** Retries after the first attempt, and the pause before each. */
-export const PRESS_RETRIES = 2;
-const RETRY_PAUSE_MS = 1000;
-
-/** Whether a retry fails the run (QA_FAIL_ON_RETRY=1 or --fail-on-retry). */
-export function failOnRetryDefault(
-  env = process.env,
-  argv = process.argv.slice(2),
-) {
-  return env.QA_FAIL_ON_RETRY === '1' || argv.includes('--fail-on-retry');
-}
-
-/**
- * A failed attempt whose press landed outside the header. No recorded press
- * is a failure, not a miss: a retry would only hide it.
- * @param {{done: boolean, pressed: {inHeader: boolean}|null}} attempt
- */
-export function pressMissed(attempt) {
-  return !attempt.done && attempt.pressed?.inHeader === false;
-}
-
-/** Whether the panel's box changed by more than 2 px between two reads. */
-export function panelMoved(before, after) {
-  if (!before || !after) return false;
-  return ['left', 'top', 'width', 'height'].some(
-    (key) => Math.abs((after[key] ?? NaN) - (before[key] ?? NaN)) > 2,
-  );
-}
-
-/** The panel's box, rounded, as `left,top widthxheight`. */
-export function formatBox(box) {
-  if (!box) return 'unknown';
-  const r = (value) => Math.round(value ?? NaN);
-  return `${r(box.left)},${r(box.top)} ${r(box.width)}x${r(box.height)}`;
-}
-
-function panelBox(page, panelId) {
-  return page.evaluate((id) => {
-    const r = document.getElementById(id).getBoundingClientRect();
-    return { left: r.left, top: r.top, width: r.width, height: r.height };
-  }, panelId);
-}
-
-export function headerPoint(page, panelId) {
-  return page.evaluate((id) => {
-    const title = document.querySelector(`#${id} .panel-header .panel-title`);
-    const r = title.getBoundingClientRect();
-    return { x: r.left + r.width / 2, y: r.top + r.height / 2 };
-  }, panelId);
-}
-
-/** Name the element at a point, and whether it is the panel's header. */
-export function hitAt(page, point, panelId) {
-  return page.evaluate(
-    ({ x, y, id }) => {
-      const node = document.elementFromPoint(x, y);
-      if (!node) return { target: 'nothing', inHeader: false };
-      return {
-        target: `${node.tagName.toLowerCase()}${node.id ? `#${node.id}` : ''}.${[...node.classList].join('.')}`,
-        inHeader: Boolean(node.closest(`#${id} .panel-header`)),
-      };
-    },
-    { ...point, id: panelId },
-  );
-}
-
-/**
- * Re-resolve the header point until it hits the header or the wait runs out
- * (the press then records the miss).
- */
-export async function headerTarget(
-  page,
-  panelId,
-  { tries = 20, intervalMs = 500 } = {},
-) {
-  let point = await headerPoint(page, panelId);
-  let hit = await hitAt(page, point, panelId);
-  for (let i = 0; i < tries && !hit.inHeader; i++) {
-    await delay(intervalMs);
-    point = await headerPoint(page, panelId);
-    hit = await hitAt(page, point, panelId);
-  }
-  const box = await panelBox(page, panelId);
-  return { point, hit, timedOut: !hit.inHeader, box };
-}
-
-/**
- * Best effort: wait until the panel's box has held still for `stillMs`, so
- * the header does not move between the hit check and the press.
- */
-export async function waitForStill(
-  page,
-  panelId,
-  { stillMs = 300, timeout = 5000 } = {},
-) {
-  try {
-    await page.waitForFunction(
-      (id, ms) => {
-        const r = document.getElementById(id).getBoundingClientRect();
-        const box = [r.left, r.top, r.width, r.height].map(Math.round).join();
-        const now = performance.now();
-        if (window.__qaStillBox !== box) {
-          window.__qaStillBox = box;
-          window.__qaStillSince = now;
-        }
-        return now - window.__qaStillSince >= ms;
-      },
-      { polling: 100, timeout },
-      panelId,
-      stillMs,
-    );
-    return true;
-  } catch (error) {
-    if (error?.name !== 'TimeoutError') throw error;
-    return false;
-  }
-}
-
-/** Record the next pointerdown's target and the panel's box at that moment. */
-export function recordNextPress(page, panelId) {
-  return page.evaluate((id) => {
-    window.__qaPressBox = null;
-    window.addEventListener(
-      'pointerdown',
-      (event) => {
-        const r = document.getElementById(id).getBoundingClientRect();
-        const target = event.target;
-        window.__qaPressBox = {
-          left: r.left,
-          top: r.top,
-          width: r.width,
-          height: r.height,
-          target: `${target.tagName?.toLowerCase()}${target.id ? `#${target.id}` : ''}.${[...(target.classList || [])].join('.')}`,
-          inHeader: Boolean(target.closest?.(`#${id} .panel-header`)),
-        };
-      },
-      { capture: true, once: true },
-    );
-  }, panelId);
-}
-
-function readPress(page) {
-  return page.evaluate(() => window.__qaPressBox ?? null);
-}
-
-export async function waitForFloating(
-  page,
-  panelId,
-  floating,
-  { timeout = 3000 } = {},
-) {
-  try {
-    await page.waitForFunction(
-      (id, want) =>
-        document.getElementById(id).classList.contains('panel-floating') ===
-        want,
-      { polling: 50, timeout },
-      panelId,
-      floating,
-    );
-    return true;
-  } catch (error) {
-    if (error?.name !== 'TimeoutError') throw error;
-    return false;
-  }
-}
-
-/** Two paints: by then every layout change an input caused is on screen. */
-export function nextFrames(page) {
-  return page.evaluate(
-    () =>
-      new Promise((resolve) =>
-        requestAnimationFrame(() => requestAnimationFrame(() => resolve())),
-      ),
-  );
-}
-
-export async function dragPointer(page, from, dx, dy, { steps = 6 } = {}) {
-  await page.mouse.move(from.x, from.y);
-  await page.mouse.down();
-  await page.mouse.move(from.x + dx / 2, from.y + dy / 2, { steps });
-  await page.mouse.move(from.x + dx, from.y + dy, { steps });
-  await page.mouse.up();
-  await nextFrames(page);
-}
-
-export function describeRetry(
-  panelId,
-  attempt,
-  { round, retries, extra = '' },
-) {
-  const { hit, pressed, timedOut, still, box } = attempt;
-  return [
-    `retry ${round + 1}/${retries}: the press missed the ${panelId} header (on ${pressed?.target ?? hit.target})`,
-    `pre-press hit check ${timedOut ? `timed out (on ${hit.target})` : 'passed'}`,
-    `stillness ${still === false ? 'timed out' : 'held'}`,
-    `panel box at hit check ${formatBox(box)} -> at press ${formatBox(pressed)}`,
-  ]
-    .concat(extra ? [extra] : [])
-    .join('; ');
-}
-
-/** Retry `press` only while it provably misses the header. */
-async function pressUntilDecided(
-  page,
-  panelId,
-  press,
-  {
-    retries,
-    log,
-    note,
-    pauseMs = RETRY_PAUSE_MS,
-    failOnRetry = failOnRetryDefault(),
-  },
-) {
-  for (let round = 0; ; round++) {
-    const still = await waitForStill(page, panelId);
-    await recordNextPress(page, panelId);
-    const { point, hit, timedOut, box } = await headerTarget(page, panelId);
-    const done = await press(point);
-    const attempt = {
-      point,
-      hit,
-      timedOut,
-      still,
-      box,
-      done,
-      pressed: await readPress(page),
-      retries: round,
-    };
-    if (round >= retries || !pressMissed(attempt)) return attempt;
-    const why = describeRetry(panelId, attempt, {
-      round,
-      retries,
-      extra: note ? await note() : '',
-    });
-    if (failOnRetry && !panelMoved(box, attempt.pressed))
-      throw new Error(
-        `QA_FAIL_ON_RETRY=1 turns this retry into a failure: ${why}`,
-      );
-    log(`note: ${why}; retrying`);
-    log(`::warning title=Panel press retried::${why}`);
-    await delay(pauseMs);
-  }
-}
-
-/**
- * Lift a docked panel into a floating window with a header drag.
- * @returns {Promise<{point: {x: number, y: number}, hit: {target: string, inHeader: boolean}, done: boolean, pressed: object|null}>}
- */
-export function liftPanelByHeader(
-  page,
-  panelId,
-  {
-    dx,
-    dy,
-    retries = PRESS_RETRIES,
-    log = console.log,
-    note,
-    pauseMs,
-    failOnRetry,
-  } = {},
-) {
-  return pressUntilDecided(
-    page,
-    panelId,
-    async (point) => {
-      await dragPointer(page, point, dx, dy);
-      return waitForFloating(page, panelId, true);
-    },
-    { retries, log, note, pauseMs, failOnRetry },
-  );
-}
-
-/** Dock a floating panel with a header double-click; same result as lifting. */
-export function dockPanelByDoubleClick(
-  page,
-  panelId,
-  {
-    retries = PRESS_RETRIES,
-    log = console.log,
-    note,
-    pauseMs,
-    failOnRetry,
-  } = {},
-) {
-  return pressUntilDecided(
-    page,
-    panelId,
-    async (point) => {
-      await page.mouse.click(point.x, point.y, { clickCount: 1 });
-      await page.mouse.click(point.x, point.y, { clickCount: 2 });
-      return waitForFloating(page, panelId, false);
-    },
-    { retries, log, note, pauseMs, failOnRetry },
-  );
-}
-
-/** Where an attempt pressed, for an assertion message. */
-export function describePress(attempt) {
-  const { point, hit, pressed } = attempt;
-  const where = `pressed ${Math.round(point.x)},${Math.round(point.y)}`;
-  if (!pressed)
-    return `${where}: no pointerdown reached the page (hit check on ${hit.target}, in header: ${hit.inHeader})`;
-  const n = attempt.retries || 0;
-  const retried = n ? `, after ${n} ${n === 1 ? 'retry' : 'retries'}` : '';
-  return `${where} on ${pressed.target}, in header: ${pressed.inHeader}${retried}`;
-}

scripts/qa-radio.mjs

@@ -81,6 +81,32 @@ function check(name, ok, detail = '') {
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+// Radio lives only inside Context; a user reaches its controls by expanding
+// Context and then Radio. Returns the prior collapse state so a step can put
+// the panels back for the scenarios that follow.
+async function revealRadioControls(page, targetId) {
+  const prior = await page.evaluate(async (id) => {
+    const manager = window.__godsEyeView.styleManager;
+    const collapsed = (panelId) => document.getElementById(panelId).classList.contains('collapsed');
+    const state = { context: collapsed('global-context-panel'), radio: collapsed('radio-panel') };
+    manager.setPanelCollapsed('global-context-panel', false, { explicit: true });
+    manager.setPanelCollapsed('radio-panel', false, { explicit: true });
+    await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+    document.getElementById(id).scrollIntoView({ block: 'nearest' });
+    return state;
+  }, targetId);
+  await page.waitForSelector(`#${targetId}`, { visible: true });
+  return prior;
+}
+
+async function restoreRadioPanels(page, prior) {
+  await page.evaluate(({ context, radio }) => {
+    const manager = window.__godsEyeView.styleManager;
+    manager.setPanelCollapsed('radio-panel', radio);
+    manager.setPanelCollapsed('global-context-panel', context);
+  }, prior);
+}
+
 // Native pick buffers and clustered overlay entries settle on rendered frames,
 // not on wall-clock sleeps, particularly with software rendering.
 async function settleRadioFrames(page) {
@@ -167,6 +193,13 @@ async function main() {
     page.on('request', (request) => {
       const url = new URL(request.url());
 
+      // Radio QA uses keyless maps; an optional Google token is not offered.
+      if (request.method() === 'GET' && url.origin === APP_ORIGIN
+        && url.pathname === '/api/google/tiles-token') {
+        request.respond({ status: 200, contentType: 'application/json', body: '{}' });
+        return;
+      }
+
     // These scenarios exercise Context lifecycle and keyboard ownership, not
     // live orbit accuracy. Reuse the tracking suite's fixed element sets so
     // CelesTrak outages cannot invalidate an otherwise clean UI run.
@@ -278,31 +311,16 @@ async function main() {
       window.__godsEyeView.styleManager.setPanelCollapsed('global-context-panel', true);
     });
 
+    const enablePanels = await revealRadioControls(page, 'radio-enable-btn');
     const enableStartedAt = Date.now();
-    const initialDisclosure = await page.evaluate(() => {
-      const button = document.getElementById('context-radio-toggle-btn');
-      const mini = document.getElementById('context-radio-mini');
-      const enabledBefore = window.__godsEyeView.dataManager.isEnabled('radio');
-      button.click();
-      return {
-        enabledBefore,
-        enabledAfterDisclosure: window.__godsEyeView.dataManager.isEnabled('radio'),
-        expanded: button.getAttribute('aria-expanded'),
-        miniHidden: mini.hidden,
-      };
-    });
-    check(
-      'Radio launcher discloses compact controls without changing power',
-      !initialDisclosure.enabledBefore && !initialDisclosure.enabledAfterDisclosure
-        && initialDisclosure.expanded === 'true' && !initialDisclosure.miniHidden,
-      JSON.stringify(initialDisclosure),
-    );
-    await page.$eval('#context-radio-mini-enable-btn', (button) => button.click());
+    await page.click('#radio-enable-btn');
     await page.waitForFunction(() => {
       const state = window.__godsEyeView.dataManager.layers.get('radio').module.getUIState();
       return state.enabled && !state.loading && state.stationCount === 750;
     });
     const enableElapsedMs = Date.now() - enableStartedAt;
+    // Later scenarios start from the collapsed rail this step began with.
+    await restoreRadioPanels(page, enablePanels);
     const initial = await page.evaluate(() => {
       const module = window.__godsEyeView.dataManager.layers.get('radio').module;
       const state = module.getUIState();
@@ -321,9 +339,6 @@ async function main() {
           color: entry.dataset.radioColor,
         })),
         enablePressed: document.getElementById('radio-enable-btn').getAttribute('aria-pressed'),
-        launcherExpanded: document.getElementById('context-radio-toggle-btn').getAttribute('aria-expanded'),
-        launcherActive: document.getElementById('context-radio-toggle-btn').classList.contains('active'),
-        compactEnablePressed: document.getElementById('context-radio-mini-enable-btn').getAttribute('aria-pressed'),
         fullPlayEnabled: !document.getElementById('radio-play-btn').disabled,
         fullPlayLabel: document.getElementById('radio-play-btn').getAttribute('aria-label'),
         tunerVisible: !document.getElementById('radio-tuner').hidden,
@@ -334,9 +349,8 @@ async function main() {
     check('750-station catalog renders within the browser budget', initial.state.stationCount === 750 && enableElapsedMs < 5000, `${enableElapsedMs}ms`);
     check('enable does not autoplay', initial.plays === 0 && initial.state.audioState === 'stopped');
     check(
-      'compact and detailed Radio power controls reflect the layer manager independently of disclosure',
-      initial.enablePressed === 'true' && initial.compactEnablePressed === 'true'
-        && initial.launcherExpanded === 'true' && initial.launcherActive,
+      'Radio power control reflects the layer manager after the panels collapse again',
+      initial.enablePressed === 'true',
     );
     check('dynamic canonical and genre categories reach the UI', initial.filterOptions >= 10, `${initial.filterOptions} options`);
     const musicOption = initial.filterPalette.find((entry) => entry.id === 'music');
@@ -412,14 +426,10 @@ async function main() {
         prevDisabled: document.getElementById('radio-prev-btn').disabled,
         playDisabled: document.getElementById('radio-play-btn').disabled,
         volumeDisabled: document.getElementById('radio-volume').disabled,
-        disclosureLabel: document.getElementById('context-radio-toggle-btn').getAttribute('aria-label'),
-        compactPowerLabel: document.getElementById('context-radio-mini-enable-btn').getAttribute('aria-label'),
-        compactPowerText: document.getElementById('context-radio-mini-enable-btn').textContent,
         fullLabel: document.getElementById('radio-enable-btn').getAttribute('aria-label'),
         fullText: document.getElementById('radio-enable-btn').textContent,
         layerState: document.getElementById('radio-layer-state').textContent,
         playbackMessage: document.getElementById('radio-playback-state').textContent,
-        miniStation: document.getElementById('context-radio-mini-station').textContent,
         dataRailText: document.querySelector('[data-layer-id="radio"] .data-toggle-btn')?.textContent,
         dataRailState: document.querySelector('[data-layer-id="radio"] .data-toggle-btn')?.dataset.feedState,
         dataRailLabel: document.querySelector('[data-layer-id="radio"] .data-toggle-btn')?.getAttribute('aria-label'),
@@ -461,14 +471,10 @@ async function main() {
         && uncertainPresentation.prevDisabled
         && uncertainPresentation.playDisabled
         && uncertainPresentation.volumeDisabled
-        && /compact Radio controls/i.test(uncertainPresentation.disclosureLabel)
-        && /uncertain/i.test(uncertainPresentation.compactPowerLabel)
-        && uncertainPresentation.compactPowerText === 'RECONCILE'
         && /uncertain/i.test(uncertainPresentation.fullLabel)
         && uncertainPresentation.fullText === 'RECONCILE'
         && uncertainPresentation.layerState === 'UNCERTAIN'
         && /uncertain/i.test(uncertainPresentation.playbackMessage)
-        && uncertainPresentation.miniStation === 'RADIO STATE UNCERTAIN'
         && uncertainPresentation.dataRailText === 'UNCERTAIN'
         && uncertainPresentation.dataRailState === 'uncertain'
         && /uncertain/i.test(uncertainPresentation.dataRailLabel)
@@ -510,10 +516,6 @@ async function main() {
       presentationActive: window.__godsEyeView.dataManager.layers.get('radio').module.getUIState().presentationActive,
       markerSourceVisible: window.__godsEyeView.viewer.dataSources.getByName('Radio stations')[0]?.show,
       full: document.getElementById('radio-enable-btn').textContent,
-      disclosure: document.getElementById('context-radio-toggle-btn').getAttribute('aria-label'),
-      disclosureControls: document.getElementById('context-radio-toggle-btn').getAttribute('aria-controls'),
-      disclosureExpanded: document.getElementById('context-radio-toggle-btn').getAttribute('aria-expanded'),
-      compactPower: document.getElementById('context-radio-mini-enable-btn').textContent,
       layerState: document.getElementById('radio-layer-state').textContent,
       message: document.getElementById('radio-playback-state').textContent,
       stopDisabled: document.getElementById('radio-stop-btn').disabled,
@@ -527,8 +529,6 @@ async function main() {
         && disablingPresentation.presentationActive === false
         && disablingPresentation.markerSourceVisible === false
         && disablingPresentation.full === 'DISABLING'
-        && /compact Radio controls/i.test(disablingPresentation.disclosure)
-        && disablingPresentation.compactPower === 'DISABLING'
         && disablingPresentation.layerState === 'DISABLING'
         && /disabling/i.test(disablingPresentation.message)
         && disablingPresentation.stopDisabled
@@ -585,10 +585,6 @@ async function main() {
       presentationActive: window.__godsEyeView.dataManager.layers.get('radio').module.getUIState().presentationActive,
       markerSourceVisible: window.__godsEyeView.viewer.dataSources.getByName('Radio stations')[0]?.show,
       full: document.getElementById('radio-enable-btn').textContent,
-      disclosure: document.getElementById('context-radio-toggle-btn').getAttribute('aria-label'),
-      disclosureControls: document.getElementById('context-radio-toggle-btn').getAttribute('aria-controls'),
-      disclosureExpanded: document.getElementById('context-radio-toggle-btn').getAttribute('aria-expanded'),
-      compactPower: document.getElementById('context-radio-mini-enable-btn').textContent,
       layerState: document.getElementById('radio-layer-state').textContent,
       message: document.getElementById('radio-playback-state').textContent,
       tunerHidden: document.getElementById('radio-tuner').hidden,
@@ -603,10 +599,6 @@ async function main() {
         && enablingPresentation.presentationActive === false
         && enablingPresentation.markerSourceVisible === false
         && enablingPresentation.full === 'ENABLING'
-        && enablingPresentation.disclosure === 'Go to expanded Radio section'
-        && enablingPresentation.disclosureControls === 'radio-panel'
-        && enablingPresentation.disclosureExpanded === 'true'
-        && enablingPresentation.compactPower === 'ENABLING'
         && enablingPresentation.layerState === 'ENABLING'
         && /enabling/i.test(enablingPresentation.message)
         && enablingPresentation.tunerHidden
@@ -1284,8 +1276,6 @@ async function main() {
     const clusterBadge = await page.evaluate(async () => {
       const viewer = window.__godsEyeView.viewer;
       const { getOverlayPaintRect, getWorldOverlayDiagnostics } = await import('/src/overlays/worldOverlay.js');
-      const { distanceFade } = await import('/src/overlays/worldOverlayDraw.js');
-      const { radioStationIdFromPick } = await import('/src/data/radio.js');
       const baselineSolveRevision = getWorldOverlayDiagnostics().solveRevision;
       const source = Array.from({ length: viewer.dataSources.length }, (_, index) => viewer.dataSources.get(index))
         .find((item) => item.name === 'Radio stations');
@@ -1576,112 +1566,9 @@ async function main() {
       JSON.stringify(directoryRefreshContinuity),
     );
     await page.select('#radio-filter', 'news');
-    check('launcher enables Radio without forcing Context open', !initial.panelExpanded && !initial.contextExpanded && initial.nestedInContext);
+    check('enabled Radio stays nested in Context and leaves both panels collapsed', !initial.panelExpanded && !initial.contextExpanded && initial.nestedInContext);
     check('full Play is available before a station is selected', !initial.state.selected && initial.fullPlayEnabled && initial.fullPlayLabel === 'Play nearest radio station');
 
-    const hoverOnlyDisclosure = await page.evaluate(() => {
-      const button = document.getElementById('context-radio-toggle-btn');
-      if (button.getAttribute('aria-expanded') === 'true') button.click();
-      return {
-        expanded: button.getAttribute('aria-expanded'),
-        hidden: document.getElementById('context-radio-mini').hidden,
-      };
-    });
-    await page.hover('#context-radio-toggle-btn');
-    await sleep(100);
-    const hoverOnlyVisible = await page.$eval('#context-radio-mini', (mini) => (
-      !mini.hidden && getComputedStyle(mini).display !== 'none'
-    ));
-    check(
-      'hover alone does not disclose compact Radio controls',
-      hoverOnlyDisclosure.expanded === 'false' && hoverOnlyDisclosure.hidden && !hoverOnlyVisible,
-      JSON.stringify({ hoverOnlyDisclosure, hoverOnlyVisible }),
-    );
-    await page.click('#context-radio-toggle-btn');
-    await page.waitForFunction(() => {
-      const button = document.getElementById('context-radio-toggle-btn');
-      const mini = document.getElementById('context-radio-mini');
-      return button.getAttribute('aria-expanded') === 'true'
-        && !mini.hidden && getComputedStyle(mini).display !== 'none';
-    });
-    const compact = await page.evaluate(() => {
-      const mini = document.getElementById('context-radio-mini');
-      const toggle = document.getElementById('context-radio-toggle-btn');
-      const dock = document.getElementById('context-radio-dock');
-      const miniRect = mini.getBoundingClientRect();
-      const toggleRect = toggle.getBoundingClientRect();
-      const miniStyle = getComputedStyle(mini);
-      return {
-        visible: miniStyle.display !== 'none' && miniRect.width > 0 && miniRect.height > 0,
-        display: miniStyle.display,
-        visibility: miniStyle.visibility,
-        opacity: miniStyle.opacity,
-        miniRect: { top: miniRect.top, left: miniRect.left, width: miniRect.width, height: miniRect.height },
-        toggleRect: { top: toggleRect.top, left: toggleRect.left, width: toggleRect.width, height: toggleRect.height },
-        dockRect: (() => {
-          const rect = dock.getBoundingClientRect();
-          return { top: rect.top, left: rect.left, width: rect.width, height: rect.height };
-        })(),
-        offsetParent: mini.offsetParent?.id || mini.offsetParent?.className || null,
-        prevEnabled: !document.getElementById('context-radio-mini-prev-btn').disabled,
-        playEnabled: !document.getElementById('context-radio-mini-play-btn').disabled,
-        playLabel: document.getElementById('context-radio-mini-play-btn').getAttribute('aria-label'),
-        nextEnabled: !document.getElementById('context-radio-mini-next-btn').disabled,
-        volumeEnabled: !document.getElementById('context-radio-mini-volume').disabled,
-        offsetBelowToggle: Math.round(miniRect.top - toggleRect.bottom),
-      };
-    });
-    check(
-      'explicit launcher disclosure reveals enabled compact Radio controls',
-      compact.visible && compact.prevEnabled && compact.playEnabled && compact.nextEnabled && compact.volumeEnabled,
-      JSON.stringify(compact),
-    );
-    check('compact Play is available before a station is selected', compact.playLabel === 'Play nearest radio station');
-    check('compact Radio controls sit 20px below the launcher', compact.offsetBelowToggle === 20, `${compact.offsetBelowToggle}px`);
-    const compactCloseDisclosure = await page.evaluate(() => {
-      const launcher = document.getElementById('context-radio-toggle-btn');
-      const close = document.getElementById('context-radio-mini-close-btn');
-      close.focus();
-      close.click();
-      const result = {
-        launcherExpanded: launcher.getAttribute('aria-expanded'),
-        compactHidden: document.getElementById('context-radio-mini').hidden,
-        focusRestored: document.activeElement === launcher,
-        radioCollapsed: document.getElementById('radio-panel').classList.contains('collapsed'),
-      };
-      launcher.click();
-      return result;
-    });
-    check(
-      'dedicated compact close hides only the compact Radio disclosure and restores launcher focus',
-      compactCloseDisclosure.launcherExpanded === 'false'
-        && compactCloseDisclosure.compactHidden
-        && compactCloseDisclosure.focusRestored
-        && compactCloseDisclosure.radioCollapsed,
-      JSON.stringify(compactCloseDisclosure),
-    );
-    const compactTouchDisclosure = await page.evaluate(() => {
-      const button = document.getElementById('context-radio-toggle-btn');
-      button.click();
-      const closed = button.getAttribute('aria-expanded') === 'false'
-        && document.getElementById('context-radio-mini').hidden;
-      button.dispatchEvent(new PointerEvent('pointerdown', {
-        bubbles: true,
-        pointerType: 'touch',
-        isPrimary: true,
-      }));
-      button.click();
-      return {
-        closed,
-        reopened: button.getAttribute('aria-expanded') === 'true'
-          && !document.getElementById('context-radio-mini').hidden,
-      };
-    });
-    check(
-      'touch/coarse-pointer activation can close and reopen compact Radio controls',
-      compactTouchDisclosure.closed && compactTouchDisclosure.reopened,
-      JSON.stringify(compactTouchDisclosure),
-    );
     const multiExpandedPanelLayout = await page.evaluate(async () => {
       const manager = window.__godsEyeView.styleManager;
       const ids = ['data-panel', 'scene-panel', 'pp-toggles', 'cctv-panel', 'global-context-panel'];
@@ -2057,7 +1944,6 @@ async function main() {
         hudVariant: manager.hud.getVariant(),
         displayExpanded: display.getAttribute('aria-expanded') === 'true',
         radioExpanded: radio.getAttribute('aria-expanded') === 'true',
-        contextRadioExpanded: document.getElementById('context-radio-toggle-btn')?.getAttribute('aria-expanded') === 'true',
         focusId: document.activeElement?.id || null,
         detectionMode: manager.getDetectionState().detectionMode,
         models3dEnabled: manager._models3dEnabled,
@@ -2153,11 +2039,13 @@ async function main() {
       for (let index = 0; index < 5; index += 1) {
         recordLayoutStep();
         if (index < 4) {
-          if (index < 2) {
-            hudLayout.value = index === 0 ? 'operator' : 'minimal';
-            hudLayout.dispatchEvent(new Event('change', { bubbles: true }));
-          } else {
+          // Off and back on in Minimal, so the toggle must restore a
+          // non-default layout before the cycle returns to Tactical.
+          if (index === 1 || index === 2) {
             hudToggle.click();
+          } else {
+            hudLayout.value = index === 0 ? 'minimal' : 'tactical';
+            hudLayout.dispatchEvent(new Event('change', { bubbles: true }));
           }
           await waitForHudSettle();
         }
@@ -2282,8 +2170,7 @@ async function main() {
         document.getElementById('cockpit-radio-next-btn'),
       ].every((button) => button?.isConnected && !button.disabled);
       const detailsExcluded = !document.querySelector(
-        '#cockpit-radio-panel #context-radio-details-btn, '
-        + '#cockpit-radio-panel #radio-filter, #cockpit-radio-panel #radio-tuner',
+        '#cockpit-radio-panel #radio-filter, #cockpit-radio-panel #radio-tuner',
       );
       const scenesHidden = getComputedStyle(scene).display === 'none';
       radio.click();
@@ -2326,7 +2213,7 @@ async function main() {
         scenesHidden,
         mapProviderUtilityStable,
         hudInteractionsExact: layoutSteps.map((step) => step.hud).join('>')
-          === 'TACTICAL>OPERATOR>MINIMAL>OFF>MINIMAL',
+          === 'TACTICAL>MINIMAL>OFF>MINIMAL>TACTICAL',
         // The accordion clears the topline, Cockpit cards, and Cesium credits
         // across every HUD layout. Its list owns any overflow internally.
         leftLaneClearAcrossHudCycle: layoutSteps.every((step) => (
@@ -2376,7 +2263,6 @@ async function main() {
         manager.setPanelCollapsed('global-context-panel', prior.contextCollapsed);
         if (display.getAttribute('aria-expanded') !== String(prior.displayExpanded)) display.click();
         if (radio.getAttribute('aria-expanded') !== String(prior.radioExpanded)) radio.click();
-        manager._setRadioDisclosure(prior.contextRadioExpanded);
         hud.hidden = prior.hudHidden;
         signal.hidden = prior.signalHidden;
         if (prior.utilityTop) hud.style.setProperty('--cockpit-utility-top', prior.utilityTop);
@@ -2411,7 +2297,6 @@ async function main() {
           && document.getElementById('global-context-panel').classList.contains('collapsed') === prior.contextCollapsed
           && display.getAttribute('aria-expanded') === String(prior.displayExpanded)
           && radio.getAttribute('aria-expanded') === String(prior.radioExpanded)
-          && document.getElementById('context-radio-toggle-btn')?.getAttribute('aria-expanded') === String(prior.contextRadioExpanded)
           && hud.hidden === prior.hudHidden
           && signal.hidden === prior.signalHidden
           && intelHud.style.getPropertyValue('transition') === priorHudTransition
@@ -2467,21 +2352,20 @@ async function main() {
     check('first Play scenario starts without a leaked Radio selection', firstPlayPrecondition === null,
       `selected=${firstPlayPrecondition}`);
     await page.select('#radio-filter', 'all');
-    await page.$eval('#context-radio-toggle-btn', (button) => {
-      if (button.getAttribute('aria-expanded') !== 'true') button.click();
-    });
     await page.evaluate(() => {
       const camera = window.__godsEyeView.viewer.camera;
       window.__qaFirstPlayFlyToCalls = [];
       window.__qaFirstPlayOriginalFlyTo = camera.flyTo;
       camera.flyTo = (options) => window.__qaFirstPlayFlyToCalls.push(options);
-      document.getElementById('context-radio-toggle-btn').focus();
     });
-    await page.$eval('#context-radio-mini-play-btn', (button) => button.click());
+    const firstPlayPanels = await revealRadioControls(page, 'radio-play-btn');
+    await page.focus('#radio-play-btn');
+    await page.click('#radio-play-btn');
     await page.waitForFunction(() => {
       const state = window.__godsEyeView.dataManager.layers.get('radio').module.getUIState();
       return state.audioState === 'playing' || state.audioState === 'error';
     });
+    await restoreRadioPanels(page, firstPlayPanels);
     const postMicroDragPlayback = await page.evaluate(async () => {
       const mod = window.__godsEyeView.dataManager.layers.get('radio').module;
       let state = mod.getUIState();
@@ -2588,59 +2472,19 @@ async function main() {
     );
     await page.select('#radio-filter', 'news');
 
-    await page.$eval('#context-radio-mini-volume', (input) => {
+    await page.$eval('#radio-volume', (input) => {
       input.value = '35';
       input.dispatchEvent(new Event('input', { bubbles: true }));
     });
-    const compactVolume = await page.evaluate(() => ({
+    const radioVolume = await page.evaluate(() => ({
       volume: window.__godsEyeView.dataManager.layers.get('radio').module.getUIState().volume,
       full: document.getElementById('radio-volume').value,
-      mini: document.getElementById('context-radio-mini-volume').value,
+      label: document.getElementById('radio-volume-value').textContent,
     }));
-    check('compact volume shares the full Radio player state', Math.abs(compactVolume.volume - 0.35) < 0.001 && compactVolume.full === '35' && compactVolume.mini === '35');
-
-    const compactDisclosureContinuity = await page.evaluate(async () => {
-      const radio = window.__godsEyeView.dataManager.layers.get('radio').module;
-      const manager = window.__godsEyeView.styleManager;
-      manager.setPanelCollapsed('global-context-panel', true);
-      manager._setRadioDisclosure(true);
-      await radio.play({ origin: 'user' });
-      const before = radio.getUIState();
-      const disclosure = document.getElementById('context-radio-toggle-btn');
-      if (disclosure.getAttribute('aria-expanded') !== 'true') disclosure.click();
-      disclosure.click();
-      const closed = {
-        expanded: disclosure.getAttribute('aria-expanded'),
-        hidden: document.getElementById('context-radio-mini').hidden,
-        state: radio.getUIState(),
-      };
-      disclosure.click();
-      return {
-        before,
-        closed,
-        reopened: disclosure.getAttribute('aria-expanded'),
-        miniHidden: document.getElementById('context-radio-mini').hidden,
-        after: radio.getUIState(),
-      };
-    });
     check(
-      'compact disclosure preserves playback, station, filter, and volume continuity',
-      compactDisclosureContinuity.closed.expanded === 'false'
-        && compactDisclosureContinuity.closed.hidden
-        && compactDisclosureContinuity.reopened === 'true'
-        && !compactDisclosureContinuity.miniHidden
-        && compactDisclosureContinuity.before.audioState === 'playing'
-        && compactDisclosureContinuity.closed.state.audioState === 'playing'
-        && compactDisclosureContinuity.after.audioState === 'playing'
-        && compactDisclosureContinuity.after.selected?.id === compactDisclosureContinuity.before.selected?.id
-        && compactDisclosureContinuity.after.filter === compactDisclosureContinuity.before.filter
-        && compactDisclosureContinuity.after.volume === compactDisclosureContinuity.before.volume,
-      JSON.stringify({
-        before: compactDisclosureContinuity.before,
-        closed: compactDisclosureContinuity.closed,
-        reopened: compactDisclosureContinuity.reopened,
-        after: compactDisclosureContinuity.after,
-      }),
+      'full Radio volume drives the Radio player state',
+      Math.abs(radioVolume.volume - 0.35) < 0.001 && radioVolume.full === '35' && radioVolume.label === '35%',
+      JSON.stringify(radioVolume),
     );
 
     const voicePause = await page.evaluate(async () => {
@@ -2704,11 +2548,13 @@ async function main() {
       idleVoice.audioState === 'paused',
       idleVoice.audioState,
     );
-    const manualPlayTarget = await page.evaluate(() => {
+    const manualPlayTarget = await page.evaluate(async () => {
       const manager = window.__godsEyeView.styleManager;
-      manager.setPanelCollapsed('global-context-panel', true);
-      manager._setRadioDisclosure(true);
-      const button = document.getElementById('context-radio-mini-play-btn');
+      manager.setPanelCollapsed('global-context-panel', false);
+      manager.setPanelCollapsed('radio-panel', false);
+      await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+      const button = document.getElementById('radio-play-btn');
+      button.scrollIntoView({ block: 'nearest' });
       const rect = button.getBoundingClientRect();
       const style = getComputedStyle(button);
       return {
@@ -2723,12 +2569,12 @@ async function main() {
       };
     });
     check(
-      'manual voice takeover targets the visible compact Radio Play control',
+      'manual voice takeover targets the visible full Radio Play control',
       manualPlayTarget.visible && manualPlayTarget.enabled,
       JSON.stringify(manualPlayTarget),
     );
     if (manualPlayTarget.visible && manualPlayTarget.enabled) {
-      await page.click('#context-radio-mini-play-btn');
+      await page.click('#radio-play-btn');
       await page.waitForFunction(() => (
         window.__godsEyeView.dataManager.layers.get('radio').module.getUIState().audioState === 'playing'
         && window.__godsEyeView.voiceCommands.status === 'idle'
@@ -2754,13 +2600,16 @@ async function main() {
       const beforeSpace = radio.getUIState().audioState;
       // Simulate an already-started hold-Space session; click-started open mic
       // deliberately ignores Space takeover, and short taps never claim voice.
-      const priorPushToTalkMode = voice.pushToTalkMode;
-      voice.pushToTalkMode = true;
+      // The provider facade forwards reads, not writes. Set the mounted
+      // controller's input owner; assigning on the facade only shadows it.
+      const controller = voice.session.adapter.controller;
+      const priorPushToTalkMode = controller.pushToTalkMode;
+      controller.pushToTalkMode = true;
       document.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, cancelable: true, code: 'Space', key: ' ' }));
       await new Promise((resolve) => setTimeout(resolve, 700));
       const afterSpace = radio.getUIState().audioState;
       document.dispatchEvent(new KeyboardEvent('keyup', { bubbles: true, cancelable: true, code: 'Space', key: ' ' }));
-      voice.pushToTalkMode = priorPushToTalkMode;
+      controller.pushToTalkMode = priorPushToTalkMode;
       await radio.play();
       voice.setVoiceSpeaker('ai');
       return { beforeSpace, afterSpace, afterAi: radio.getUIState().audioState };
@@ -2773,7 +2622,6 @@ async function main() {
     await page.evaluate(() => window.__godsEyeView.voiceCommands.setStatus('idle', 'QA complete'));
     await page.evaluate(async () => {
       const manager = window.__godsEyeView.styleManager;
-      manager._setRadioDisclosure(false);
       manager.setPanelCollapsed('global-context-panel', false);
       manager.setPanelCollapsed('radio-panel', false);
       await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
@@ -3827,22 +3675,22 @@ async function main() {
       gev.dataManager.layers.get('flights').enabled = true;
     });
     await sleep(500);
-    await page.evaluate(() => window.__godsEyeView.styleManager.setPanelCollapsed('global-context-panel', true));
     await page.evaluate(() => {
-      const button = document.getElementById('context-radio-toggle-btn');
-      if (button.getAttribute('aria-expanded') !== 'true') button.click();
+      const manager = window.__godsEyeView.styleManager;
+      manager.setPanelCollapsed('global-context-panel', false);
+      manager.setPanelCollapsed('radio-panel', false);
     });
-    await page.waitForSelector('#context-radio-mini', { visible: true });
+    await page.waitForSelector('#radio-next-btn', { visible: true });
     await page.evaluate(() => {
       window.__qaRadioCameraHeight = window.__godsEyeView.viewer.camera.positionCartographic.height;
     });
     const radioOnlyNextDispatched = await page.evaluate(() => {
-      const button = document.getElementById('context-radio-mini-next-btn');
+      const button = document.getElementById('radio-next-btn');
       if (!button) return false;
       button.click();
       return true;
     });
-    if (!radioOnlyNextDispatched) throw new Error('Radio compact next button unavailable');
+    if (!radioOnlyNextDispatched) throw new Error('Radio next button unavailable');
     await page.waitForFunction(() => typeof window.__qaRejectRadioPlay === 'function');
     await page.evaluate(() => {
       const viewer = window.__godsEyeView.viewer;
@@ -3877,7 +3725,7 @@ async function main() {
       flyToCalls: window.__qaRadioFlyToCalls.length,
       flightTargets,
       cameraHeight: window.__qaRadioCameraHeight,
-      compactPlayLabel: document.getElementById('context-radio-mini-play-btn').getAttribute('aria-label'),
+      playLabel: document.getElementById('radio-play-btn').getAttribute('aria-label'),
       regularMarkerSize: Array.from({ length: window.__godsEyeView.viewer.dataSources.length }, (_, index) => window.__godsEyeView.viewer.dataSources.get(index))
         .find((item) => item.name === 'Radio stations')?.entities.values[0]?.point?.pixelSize?.getValue(),
       selectedMarkerSize: selectedEntity?.point?.pixelSize?.getValue(),
@@ -3890,7 +3738,7 @@ async function main() {
     };
     });
     check(
-      'compact Next follows stable directory order and retries its next available station',
+      'Radio Next follows stable directory order and retries its next available station',
       playing.state.selected?.id === playing.expectedFallback?.id
         && playing.calls[0] === playing.expectedPrimary?.streamUrl
         && playing.calls[1] === playing.expectedFallback?.streamUrl,
@@ -3901,9 +3749,9 @@ async function main() {
         fallback: playing.expectedFallback?.id,
       }),
     );
-    check('compact next is explicit playback and updates play/pause state', playing.calls.length === 2 && playing.compactPlayLabel.startsWith('Pause'));
+    check('Radio next is explicit playback and updates play/pause state', playing.calls.length === 2 && playing.playLabel.startsWith('Pause'));
     check(
-      'compact next rotates toward its station without changing zoom, including fallback',
+      'Radio next rotates toward its station without changing zoom, including fallback',
       playing.flyToCalls === 2
         && Math.abs(playing.flightTargets[0]?.lat - playing.expectedPrimary?.lat) < 0.001
         && Math.abs(playing.flightTargets[0]?.lon - playing.expectedPrimary?.lon) < 0.001
@@ -3942,11 +3790,11 @@ async function main() {
       };
       return [
         await run('flights', 'radio-next-btn'),
-        await run('military', 'context-radio-mini-prev-btn'),
+        await run('military', 'radio-prev-btn'),
       ];
     });
     check(
-      'full and compact Radio navigation preserve Flights/Military camera ownership',
+      'full Radio Next and Prev navigation preserve Flights/Military camera ownership',
       trackedRadioControls.every((sample) => sample.afterStationId
         && sample.afterStationId !== sample.beforeStationId
         && sample.flyToDelta === 0
@@ -3960,7 +3808,7 @@ async function main() {
       viewer.trackedEntity = undefined;
       window.__qaRadioDelayNextFailure = true;
       const beforeFlyToCalls = window.__qaRadioFlyToCalls.length;
-      document.getElementById('context-radio-mini-next-btn')?.click();
+      document.getElementById('radio-next-btn')?.click();
       return { beforeFlyToCalls };
     });
     await page.waitForFunction(() => typeof window.__qaRejectRadioPlay === 'function');
@@ -4236,7 +4084,7 @@ async function main() {
       window.__godsEyeView.dataManager.layers.get('flights').enabled = false;
     });
     const radioOnlyNextClicked = await page.evaluate(() => {
-      const button = document.getElementById('context-radio-mini-next-btn');
+      const button = document.getElementById('radio-next-btn');
       if (!(button instanceof HTMLButtonElement)) return false;
       button.click();
       return true;
@@ -4500,106 +4348,12 @@ async function main() {
         && companion.radioCollapsed && !companion.contextCollapsed && companion.nested,
     );
 
-    const expandedContextRadioBefore = await page.evaluate(() => {
-      const gev = window.__godsEyeView;
-      const scroller = document.querySelector('#global-context-panel .global-context-panel-inner');
-      scroller.scrollTop = 0;
-      const camera = gev.viewer.camera.positionWC;
-      return {
-        scrollTop: scroller.scrollTop,
-        pageY: window.scrollY,
-        camera: { x: camera.x, y: camera.y, z: camera.z },
-        plays: window.__qaRadioPlayCalls.length,
-      };
-    });
-    await page.click('#context-radio-toggle-btn');
-    await page.waitForFunction(() => !document.getElementById('radio-panel').classList.contains('collapsed'));
-    await page.waitForFunction((priorScroll) => (
-      document.activeElement?.getAttribute('data-collapse-target') === 'radio-panel'
-      && document.querySelector('#global-context-panel .global-context-panel-inner').scrollTop > priorScroll
-    ), { timeout: 10_000 }, expandedContextRadioBefore.scrollTop);
-    const expandedContextRadioAfter = await page.evaluate(() => {
-      const gev = window.__godsEyeView;
-      gev.styleManager._renderRadioState(gev.dataManager.layers.get('radio').module.getUIState());
-      const launcher = document.getElementById('context-radio-toggle-btn');
-      const radio = document.getElementById('radio-panel');
-      const scroller = document.querySelector('#global-context-panel .global-context-panel-inner');
-      const camera = gev.viewer.camera.positionWC;
-      return {
-        ariaControls: launcher.getAttribute('aria-controls'),
-        expanded: launcher.getAttribute('aria-expanded'),
-        label: launcher.getAttribute('aria-label'),
-        radioCollapsed: radio.classList.contains('collapsed'),
-        compactHidden: document.getElementById('context-radio-mini').hidden,
-        scrollTop: scroller.scrollTop,
-        focusTarget: document.activeElement?.getAttribute('data-collapse-target'),
-        pageY: window.scrollY,
-        camera: { x: camera.x, y: camera.y, z: camera.z },
-        plays: window.__qaRadioPlayCalls.length,
-        state: gev.dataManager.layers.get('radio').module.getUIState().audioState,
-      };
-    });
-    const expandedContextRadioCameraDelta = Math.hypot(
-      expandedContextRadioAfter.camera.x - expandedContextRadioBefore.camera.x,
-      expandedContextRadioAfter.camera.y - expandedContextRadioBefore.camera.y,
-      expandedContextRadioAfter.camera.z - expandedContextRadioBefore.camera.z,
-    );
-    check(
-      'expanded Context Radio icon reveals and scrolls to embedded Radio without an overlay or playback/camera theft',
-      expandedContextRadioAfter.ariaControls === 'radio-panel'
-        && expandedContextRadioAfter.expanded === 'true'
-        && expandedContextRadioAfter.label === 'Go to expanded Radio section'
-        && !expandedContextRadioAfter.radioCollapsed
-        && expandedContextRadioAfter.compactHidden
-        && expandedContextRadioAfter.scrollTop > expandedContextRadioBefore.scrollTop
-        && expandedContextRadioAfter.focusTarget === 'radio-panel'
-        && expandedContextRadioAfter.pageY === expandedContextRadioBefore.pageY
-        && expandedContextRadioCameraDelta < 0.01
-        && expandedContextRadioAfter.plays === expandedContextRadioBefore.plays
-        && expandedContextRadioAfter.state === 'playing',
-      JSON.stringify({
-        before: expandedContextRadioBefore,
-        after: expandedContextRadioAfter,
-        cameraDelta: expandedContextRadioCameraDelta,
-      }),
-    );
-
     await page.evaluate(() => {
       const manager = window.__godsEyeView.styleManager;
-      manager.setPanelCollapsed('global-context-panel', true);
-      manager._setRadioDisclosure(true);
+      manager.setPanelCollapsed('global-context-panel', false);
+      manager.setPanelCollapsed('radio-panel', false);
     });
-    await page.waitForFunction(() => {
-      const close = document.getElementById('context-radio-mini-close-btn');
-      const rect = close.getBoundingClientRect();
-      return !document.getElementById('context-radio-mini').hidden && rect.width > 0 && rect.height > 0;
-    });
-    await page.click('#context-radio-mini-close-btn');
-    const closedCompact = await page.evaluate(() => {
-      const launcher = document.getElementById('context-radio-toggle-btn');
-      return {
-        radioCollapsed: document.getElementById('radio-panel').classList.contains('collapsed'),
-        compactHidden: document.getElementById('context-radio-mini').hidden,
-        focusRestored: document.activeElement === launcher,
-      };
-    });
-    await page.click('#context-radio-toggle-btn');
-    await page.waitForFunction(() => !document.getElementById('context-radio-mini').hidden);
-    await page.click('#context-radio-details-btn');
-    const repeatedOpen = await page.evaluate(() => ({
-      radioCollapsed: document.getElementById('radio-panel').classList.contains('collapsed'),
-      compactHidden: document.getElementById('context-radio-mini').hidden,
-    }));
-    const splitDetailActions = { closedCompact, repeatedOpen };
-    check(
-      'collapsed Context keeps compact close and full-panel open as separate stable actions',
-      !splitDetailActions.closedCompact.radioCollapsed
-        && splitDetailActions.closedCompact.compactHidden
-        && splitDetailActions.closedCompact.focusRestored
-        && !splitDetailActions.repeatedOpen.radioCollapsed
-        && splitDetailActions.repeatedOpen.compactHidden,
-      JSON.stringify(splitDetailActions),
-    );
+    await page.waitForFunction(() => !document.getElementById('radio-panel').classList.contains('collapsed'));
 
     await page.click('#global-context-flights-btn');
     await page.waitForFunction(() => !document.getElementById('context-flights-view').hidden);

scripts/qa-recent-imagery.mjs

@@ -12,16 +12,22 @@
  * Run: start the app (`./scripts/dev-fresh.sh`) and
  *   node scripts/qa-recent-imagery.mjs
  * Env: QA_BASE_URL (default http://localhost:4173), QA_SHOT_DIR (default
- * qa-shots/recent-imagery), QA_HEADFUL=1. Every wait is bounded. Without
- * network access to NASA the run skips with exit code 0.
+ * qa-shots/recent-imagery), QA_HEADFUL=1.
+ * QA_RECENT_IMAGERY_SLOW_RENDER=1 permits loaded SwiftShader CI to use a
+ * 4 s ZOOM IN wait and 0.8 s height-stability tail (defaults: 2 s / 1.2 s).
+ * Every wait is bounded. Without NASA access the run skips with code 0.
  */
 import fs from 'node:fs';
 import path from 'node:path';
 import puppeteer from 'puppeteer';
+import { chromeExecutablePath } from './qa-chrome.mjs';
 
 const BASE_URL = process.env.QA_BASE_URL || 'http://localhost:4173';
 const SHOT_DIR = process.env.QA_SHOT_DIR || 'qa-shots/recent-imagery';
 const HEADFUL = process.env.QA_HEADFUL === '1';
+const SLOW_RENDER = process.env.QA_RECENT_IMAGERY_SLOW_RENDER === '1';
+const ZOOM_TIMEOUT_MS = SLOW_RENDER ? 4_000 : 2_000;
+const HEIGHT_TAIL_SAMPLES = SLOW_RENDER ? 8 : 12;
 const STEP_TIMEOUT = 20_000;
 const AUSTIN = { lon: -97.74, lat: 30.27, height: 12_000 };
 const PANEL = '#recent-imagery-panel';
@@ -49,8 +55,7 @@ const browser = await puppeteer.launch({
   headless: !HEADFUL,
   ...(HEADFUL
     ? {
-        executablePath:
-          '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        executablePath: chromeExecutablePath(),
       }
     : {}),
   args: [
@@ -308,15 +313,21 @@ const CONTROLS = {
 };
 const measure = () =>
   page.evaluate((controls) => {
+    const panel = document.getElementById('recent-imagery-panel');
     const body = document.getElementById('recent-imagery-panel-body');
+    const panelRect = panel?.getBoundingClientRect();
     const out = { bodyScroll: body?.scrollTop ?? null, rects: {} };
     for (const [name, selector] of Object.entries(controls)) {
       const rect = document.querySelector(selector)?.getBoundingClientRect();
-      out.rects[name] = rect
-        ? [rect.left, rect.top, rect.width, rect.height].map(
-            (v) => Math.round(v * 10) / 10,
-          )
-        : null;
+      out.rects[name] =
+        rect && panelRect
+          ? [
+              rect.left - panelRect.left,
+              rect.top - panelRect.top,
+              rect.width,
+              rect.height,
+            ].map((v) => Math.round(v * 10) / 10)
+          : null;
     }
     return out;
   }, CONTROLS);
@@ -372,6 +383,9 @@ try {
   const initialStack = await page.evaluate(() => window.__riQa.activeStack());
   const photoreal = initialStack === 'photoreal';
   console.log(`initial map stack: ${initialStack}`);
+  console.log(
+    `stability: ${SLOW_RENDER ? 'slow-render' : 'default'} (zoom ${ZOOM_TIMEOUT_MS} ms, last ${HEIGHT_TAIL_SAMPLES} samples)`,
+  );
   const onPhotorealOnly = (name, passed, detail) =>
     photoreal
       ? check(name, passed, detail)
@@ -1042,13 +1056,13 @@ try {
       ) <=
       target * 0.01,
     fitHeight,
-    2_000,
+    ZOOM_TIMEOUT_MS,
   );
   const zoomedHeight = await page.evaluate(
     () => window.__godsEyeView.viewer.camera.positionCartographic.height,
   );
   check(
-    `ZOOM IN flies to ${Math.round(fitHeight / 1000)} km within 2 s`,
+    `ZOOM IN reaches target within ${ZOOM_TIMEOUT_MS / 1_000} s`,
     zoomed,
     `height=${Math.round(zoomedHeight)} target=${Math.round(fitHeight)}`,
   );
@@ -1258,7 +1272,8 @@ try {
       );
       await wait(100);
     }
-    const tail = (key) => new Set(samples.slice(8).map((s) => s[key]));
+    const tail = (key) =>
+      new Set(samples.slice(-HEIGHT_TAIL_SAMPLES).map((s) => s[key]));
     return {
       settled: tail('imagery').size === 1 && tail('cctv').size === 1,
       detail: `imagery=${samples.map((s) => s.imagery).join(',')} cctv=${samples.map((s) => s.cctv).join(',')}`,

scripts/qa-scene-controls.mjs

@@ -66,7 +66,8 @@ try {
       );
     }),
   );
-  await page.click('#scene-capture-btn');
+  await page.focus('#scene-capture-btn');
+  await page.keyboard.press('Space');
   await page.waitForFunction(
     () => document.querySelectorAll('.scene-shot-row').length === 1,
   );
@@ -328,6 +329,9 @@ try {
   await page.keyboard.press('Escape');
   await page.screenshot({ path: path.join(shots, 'desktop.png') });
   await page.setViewport({ width: 390, height: 844 });
+  // Phones present Scenes in the Layers tab's sheet.
+  await page.click('#mobile-tab-bar [data-mobile-sheet="layers"]');
+  await new Promise((resolve) => setTimeout(resolve, 400));
   await page.screenshot({ path: path.join(shots, 'narrow.png') });
   check(
     'Scene controls stay inside the narrow viewport',

scripts/qa-scene-dialog-file-drop.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * qa-scene-dialog-file-drop — the SHARE SCENE dialog's file control accepts a
+ * file dropped from the desktop, proved in a real browser.
+ *
+ * The dialog draws a translated row over the native file input
+ * (src/ui/sceneSharing.js, fileChooser). The input must still cover the row,
+ * or drops miss it. Drops a file on the row's centre via CDP and expects
+ * `input.files` to hold it.
+ *
+ * Usage:
+ *   node scripts/qa-scene-dialog-file-drop.mjs
+ *
+ * Needs the repository's puppeteer (devDependencies). Exit status 0 when the
+ * drop selects the file, 1 otherwise.
+ */
+import http from 'node:http';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import puppeteer from 'puppeteer';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const TYPES = {
+  '.js': 'text/javascript',
+  '.mjs': 'text/javascript',
+  '.json': 'application/json',
+  '.html': 'text/html',
+};
+
+const PAGE = `<!doctype html><html lang="en"><body>
+<script type="module">
+  import { createSceneDialog } from '/src/ui/sceneSharing.js';
+  window.openDialog = () => {
+    const dialog = createSceneDialog('Share selected scene', () => {});
+    const files = dialog.input('Choose data-pack files', '', { type: 'file' });
+    files.multiple = true;
+    window.filesInput = files;
+    // Centre of the visible row (the wrapper's last child).
+    const row = files.parentElement.lastElementChild;
+    const r = row.getBoundingClientRect();
+    return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+  };
+  window.ready = true;
+</script></body></html>`;
+
+async function dropOn(client, x, y, file) {
+  const data = { items: [], files: [file], dragOperationsMask: 1 };
+  for (const type of ['dragEnter', 'dragOver', 'drop']) {
+    await client.send('Input.dispatchDragEvent', { type, x, y, data });
+  }
+}
+
+async function main() {
+  const dir = await mkdtemp(path.join(tmpdir(), 'qa-scene-dialog-drop-'));
+  const pack = path.join(dir, 'pack.json');
+  await writeFile(pack, '{}');
+  const server = http.createServer(async (req, res) => {
+    if (req.url === '/') {
+      res.writeHead(200, { 'content-type': 'text/html' });
+      res.end(PAGE);
+      return;
+    }
+    try {
+      const body = await readFile(path.join(ROOT, req.url));
+      res.writeHead(200, {
+        'content-type': TYPES[path.extname(req.url)] || 'text/plain',
+      });
+      res.end(body);
+    } catch {
+      res.writeHead(404).end();
+    }
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const url = `http://127.0.0.1:${server.address().port}/`;
+  const browser = await puppeteer.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    await page.setViewport({ width: 1000, height: 800 });
+    const errors = [];
+    page.on('pageerror', (error) => errors.push(String(error)));
+    await page.goto(url);
+    await page.waitForFunction(() => window.ready === true);
+    const point = await page.evaluate(() => window.openDialog());
+    const client = await page.createCDPSession();
+    await dropOn(client, point.x, point.y, pack);
+    const names = await page.evaluate(() =>
+      [...window.filesInput.files].map((file) => file.name),
+    );
+    console.log(JSON.stringify({ names, errors }));
+    if (errors.length) throw new Error(`page errors: ${errors.join('; ')}`);
+    if (names.length !== 1 || names[0] !== 'pack.json') {
+      throw new Error(
+        `expected the dropped pack.json to be selected, got ${JSON.stringify(names)}`,
+      );
+    }
+    console.log('OK: a file dropped on the visible control is selected');
+  } finally {
+    await browser.close();
+    server.close();
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

scripts/qa-scope-hud.mjs

@@ -0,0 +1,674 @@
+#!/usr/bin/env node
+/**
+ * Scope and HUD browser acceptance. Requires the development server.
+ * Run: node scripts/qa-scope-hud.mjs
+ * Optional: QA_BASE_URL, QA_SCREENSHOT_DIR (screenshots stay outside the repo).
+ * Proves a fresh boot defaults to Scope ON at 100%, native checkbox click/Space,
+ * feather 0/11/100/200, layout independence,
+ * share/scene restore, and visible text backing including rotated metadata.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import puppeteer from 'puppeteer';
+
+const browser = await puppeteer.launch({
+  headless: true,
+  args: [
+    '--no-sandbox',
+    ...(process.platform === 'darwin'
+      ? ['--use-angle=metal', '--enable-gpu']
+      : ['--use-gl=angle', '--use-angle=swiftshader']),
+  ],
+});
+const page = await browser.newPage();
+const errors = [];
+page.on('pageerror', (error) => errors.push(error.message));
+let failures = 0;
+const check = (name, passed, detail) => {
+  console.log(`[${passed ? 'PASS' : 'FAIL'}] ${name}`);
+  if (!passed) {
+    failures += 1;
+    if (detail) console.log(JSON.stringify(detail));
+  }
+};
+const readScope = () =>
+  page.evaluate(() => {
+    const scope = window.__godsEyeView.styleManager.getVisualState().scope;
+    const canvas = document.getElementById('scope-mask');
+    const context = canvas.getContext('2d');
+    const radialX = Math.round(
+      canvas.width / 2 + Math.min(canvas.width, canvas.height) * 0.35,
+    );
+    return {
+      enabled: scope.enabled,
+      feather: scope.featherPct / 100,
+      cornerAlpha: context.getImageData(1, 1, 1, 1).data[3],
+      radialAlpha: context.getImageData(
+        radialX,
+        Math.round(canvas.height / 2),
+        1,
+        1,
+      ).data[3],
+      checked: document.getElementById('scope-toggle').checked,
+      disabled: document.getElementById('scope-feather-slider').disabled,
+      value: Number(document.getElementById('scope-feather-slider').value),
+      readout: document.getElementById('scope-feather-value').textContent,
+    };
+  });
+
+const readHudGlyphs = () =>
+  page.evaluate(() => {
+    const hud = document.getElementById('intel-hud');
+    const probe = document.createElement('span');
+    probe.style.display = 'none';
+    hud.appendChild(probe);
+    const baseline = {
+      color: getComputedStyle(probe).color,
+      shadow: getComputedStyle(probe).textShadow,
+    };
+    probe.remove();
+    const glyphs = [
+      '.hud-mode',
+      '.hud-system',
+      '.hud-summary-label',
+      '.hud-summary',
+      '.hud-orbital',
+      '#hud-mgrs',
+      '#hud-coll',
+    ].map((selector) => {
+      const el = hud.querySelector(selector);
+      const style = getComputedStyle(el);
+      let opacity = 1;
+      for (
+        let current = el;
+        current && current !== hud;
+        current = current.parentElement
+      )
+        opacity *= Number(getComputedStyle(current).opacity);
+      return {
+        selector,
+        color: style.color,
+        shadow: style.textShadow,
+        opacity,
+      };
+    });
+    return { baseline, glyphs };
+  });
+
+async function settleTextBackings(enabled) {
+  // The pre-existing active-style value transitions all properties for 300ms.
+  // Wait for its backing to finish changing before inspecting or capturing it.
+  await page
+    .waitForFunction(
+      (scopeEnabled) => {
+        const expected = scopeEnabled
+          ? 'rgba(0, 0, 0, 0)'
+          : 'rgba(0, 0, 0, 0.7)';
+        return [
+          ...document.querySelectorAll(
+            '#intel-hud .hud-readout, .scene-text-holdout',
+          ),
+        ].every(
+          (el) =>
+            getComputedStyle(el).backgroundColor === expected &&
+            getComputedStyle(el).boxShadow === 'none',
+        );
+      },
+      { timeout: 2_000 },
+      enabled,
+    )
+    .catch(() => null);
+}
+
+const readSceneChrome = () =>
+  page.evaluate(() => {
+    const title = document.querySelector('#title-bar h1');
+    const eye = title.querySelector('.title-logo');
+    const subtitle = document.querySelector('#title-bar .subtitle');
+    const label = document.querySelector('#style-indicator .indicator-label');
+    const rect = (el, text = false) => {
+      if (!el.getClientRects().length) return null;
+      const range = document.createRange();
+      range.selectNodeContents(el);
+      const box = text
+        ? range.getBoundingClientRect()
+        : el.getBoundingClientRect();
+      return {
+        left: box.left,
+        top: box.top,
+        right: box.right,
+        bottom: box.bottom,
+      };
+    };
+    const titleBox = rect(title);
+    const eyeBox = rect(eye);
+    const backing = getComputedStyle(title, '::before');
+    const plate = {
+      left: titleBox.left + parseFloat(backing.left),
+      top: titleBox.top + parseFloat(backing.top),
+      right: titleBox.right - parseFloat(backing.right),
+      bottom: titleBox.bottom - parseFloat(backing.bottom),
+    };
+    const contains = (box) =>
+      Object.entries(box).every(([side, value]) =>
+        ['left', 'top'].includes(side)
+          ? plate[side] <= value + 0.5
+          : plate[side] >= value - 0.5,
+      );
+    const probe = document.createElement('span');
+    document.body.appendChild(probe);
+    probe.style.color = 'var(--text-dim)';
+    const dim = getComputedStyle(probe).color;
+    probe.style.color = 'var(--text-secondary)';
+    const secondary = getComputedStyle(probe).color;
+    probe.remove();
+    return {
+      positions: {
+        title: titleBox,
+        eye: eyeBox,
+        text: rect(title.querySelector('[translate="no"]'), true),
+        subtitle: rect(subtitle, true),
+      },
+      titleUnbacked: backing.backgroundColor === 'rgba(0, 0, 0, 0)',
+      titleCovered:
+        backing.position === 'absolute' &&
+        backing.backgroundColor === 'rgba(0, 0, 0, 0.7)' &&
+        contains(titleBox) &&
+        contains(eyeBox),
+      leftAligned:
+        !rect(subtitle) || Math.abs(plate.left - rect(subtitle).left) <= 0.5,
+      colors: [getComputedStyle(subtitle).color, getComputedStyle(label).color],
+      dim,
+      secondary,
+    };
+  });
+
+function checkSceneChrome(name, before, after) {
+  const stable = Object.keys(before.positions).every((key) => {
+    const a = before.positions[key];
+    const b = after.positions[key];
+    return a && b
+      ? Object.keys(a).every((side) => Math.abs(a[side] - b[side]) <= 0.5)
+      : a === b;
+  });
+  check(`${name}: title, eye and subtitle stay in place across Scope`, stable, {
+    before,
+    after,
+  });
+  check(
+    `${name}: OFF title plate covers the eye and aligns with the subtitle`,
+    before.titleUnbacked && after.titleCovered && after.leftAligned,
+    after,
+  );
+  check(
+    `${name}: secondary labels brighten only with Scope OFF`,
+    before.colors.every((color) => color === before.dim) &&
+      after.colors.every((color) => color === after.secondary),
+    { before: before.colors, after: after.colors },
+  );
+}
+
+async function openApplication(url) {
+  await page.goto(url.href, { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(
+    () => window.__godsEyeView?.styleManager?._applicationShortcuts,
+    { timeout: 60_000 },
+  );
+  await page.waitForFunction(
+    () => {
+      const cover = document.getElementById('loading-screen');
+      return (
+        cover?.classList.contains('hidden') &&
+        Number(getComputedStyle(cover).opacity) === 0
+      );
+    },
+    { timeout: 60_000 },
+  );
+}
+
+try {
+  await page.setViewport({ width: 1440, height: 900 });
+  const url = new URL(process.env.QA_BASE_URL || 'http://127.0.0.1:4173');
+  url.searchParams.set('welcome', '0');
+  // This browser has a fresh profile. Start without authored state so the
+  // first assertion exercises the defaults rather than a share-link restore.
+  url.hash = '';
+  await openApplication(url);
+  const fresh = await readScope();
+  check(
+    'bare-URL fresh boot opens Scope ON with 100% feather',
+    fresh.enabled &&
+      fresh.checked &&
+      !fresh.disabled &&
+      fresh.feather === 1 &&
+      fresh.value === 100 &&
+      fresh.readout === '100%' &&
+      fresh.cornerAlpha > 0,
+    fresh,
+  );
+
+  // Use a known city view for canvas and readability checks below.
+  url.hash =
+    'v=2&lat=30.2672&lon=-97.7431&alt=2500&heading=0&pitch=-45&roll=0&map=esri&sc=1&scf=100&l=';
+  // Changing only the hash does not rerun startup restoration. Leave the app
+  // document first so this fixture is applied by a new application boot.
+  await page.goto('about:blank');
+  await openApplication(url);
+  await page.evaluate(() => {
+    const manager = window.__godsEyeView.styleManager;
+    manager.setPanelCollapsed('pp-toggles', false, {
+      persist: false,
+      syncShare: false,
+    });
+    manager.hud.setMode('on');
+    manager.setStyle('normal');
+  });
+  const initial = await readScope();
+  check(
+    'Austin fixture restores Scope ON and 100% feather',
+    initial.enabled &&
+      initial.checked &&
+      !initial.disabled &&
+      initial.feather === 1 &&
+      initial.value === 100 &&
+      initial.readout === '100%' &&
+      initial.cornerAlpha > 0,
+    initial,
+  );
+  const name = await page.$eval('#scope-toggle', (el) => ({
+    type: el.type,
+    label: el.labels?.[0]?.textContent.trim(),
+  }));
+  check(
+    'Scope uses a native checkbox with a visible label',
+    name.type === 'checkbox' && name.label?.includes('Scope'),
+    name,
+  );
+  await page.click('#scope-toggle');
+  const off = await readScope();
+  check(
+    'click disables Scope and its feather slider',
+    !off.enabled &&
+      !off.checked &&
+      off.disabled &&
+      off.feather === 1 &&
+      off.cornerAlpha === 0,
+    off,
+  );
+  await page.focus('#scope-toggle');
+  await page.keyboard.press('Space');
+  const on = await readScope();
+  check(
+    'Space re-enables the native checkbox without losing feather',
+    on.enabled &&
+      on.checked &&
+      !on.disabled &&
+      on.feather === 1 &&
+      on.cornerAlpha > 0,
+    on,
+  );
+
+  const paintedAlpha = [];
+  for (const pct of [0, 11, 100, 200]) {
+    await page.$eval(
+      '#scope-feather-slider',
+      (el, value) => {
+        el.value = String(value);
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+      },
+      pct,
+    );
+    const state = await readScope();
+    paintedAlpha.push(state.radialAlpha);
+    check(
+      `feather ${pct}% reaches the mask and readout`,
+      state.value === pct &&
+        state.feather === pct / 100 &&
+        state.readout === `${pct}%`,
+      state,
+    );
+  }
+  check(
+    'painted gradient widens beyond the old 100% ceiling',
+    paintedAlpha[0] === 0 &&
+      paintedAlpha[1] === 0 &&
+      paintedAlpha[2] > 0 &&
+      paintedAlpha[3] > paintedAlpha[2],
+    paintedAlpha,
+  );
+  await page.focus('#scope-feather-slider');
+  await page.keyboard.press('Home');
+  check('native Home reaches the hard edge', (await readScope()).feather === 0);
+  await page.keyboard.press('End');
+  check(
+    'native End reaches the expanded 200% maximum',
+    (await readScope()).feather === 2,
+  );
+  await page.click('#scope-toggle');
+  for (const layout of ['minimal', 'cyber', 'tactical']) {
+    await page.select('#hud-layout-select', layout);
+    const state = await readScope();
+    check(
+      `Scope OFF and 200% survive ${layout}`,
+      !state.enabled &&
+        !state.checked &&
+        state.disabled &&
+        state.feather === 2 &&
+        state.value === 200 &&
+        state.cornerAlpha === 0,
+      state,
+    );
+  }
+
+  const restored = await page.evaluate(async () => {
+    const manager = window.__godsEyeView.styleManager;
+    const links = manager.shareLinkManager;
+    manager._syncShareState();
+    const params = links._buildHashParams();
+    const encoded = { enabled: params.get('sc'), feather: params.get('scf') };
+    await manager.applyVisualState({ scope: { enabled: true, featherPct: 0 } });
+    await manager._visualSettings.restoreShareState({
+      scopeEnabled: encoded.enabled === '1',
+      scopeFeatherPct: Number(encoded.feather),
+    });
+    const shared = manager.getVisualState().scope;
+    await manager.applyVisualState({
+      scope: { enabled: true, featherPct: 200 },
+    });
+    const scene = manager.getVisualState().scope;
+    await manager.applyVisualState({
+      scope: { enabled: false, featherPct: 200 },
+    });
+    return { encoded, shared, scene };
+  });
+  check(
+    'share state serializes and restores Scope OFF with 200%',
+    restored.encoded.enabled === '0' &&
+      restored.encoded.feather === '200' &&
+      restored.shared.enabled === false &&
+      restored.shared.featherPct === 200,
+    restored,
+  );
+  check(
+    'scene state restores Scope ON with 200%',
+    restored.scene.enabled === true && restored.scene.featherPct === 200,
+    restored,
+  );
+
+  for (const layout of ['minimal', 'tactical']) {
+    await page.select('#hud-layout-select', layout);
+    await page.evaluate(() =>
+      window.__godsEyeView.styleManager.applyVisualState({
+        scope: { enabled: true, featherPct: 100 },
+      }),
+    );
+    await settleTextBackings(true);
+    const originalGlyphs = await readHudGlyphs();
+    const originalChrome = await readSceneChrome();
+    const original = await page.evaluate(() => {
+      const hud = document.getElementById('intel-hud');
+      const wrappers = [...hud.querySelectorAll('.hud-readout')];
+      const scene = [...document.querySelectorAll('.scene-text-holdout')];
+      const unexpectedBackings = [...wrappers, ...scene]
+        .map((el) => {
+          const style = getComputedStyle(el);
+          return {
+            selector: el.id || el.className,
+            background: style.backgroundColor,
+            shadow: style.boxShadow,
+          };
+        })
+        .filter(
+          (style) =>
+            style.background !== 'rgba(0, 0, 0, 0)' || style.shadow !== 'none',
+        );
+      return {
+        markerAbsent: !document.documentElement.hasAttribute('data-scope-mask'),
+        unbacked: unexpectedBackings.length === 0,
+        unexpectedBackings,
+        wrappersTransparent: wrappers.every(
+          (el) => getComputedStyle(el).display === 'contents',
+        ),
+      };
+    });
+    check(
+      `${layout}: Scope ON retains the original presentation without new backplates`,
+      original.markerAbsent &&
+        original.unbacked &&
+        original.wrappersTransparent,
+      original,
+    );
+    check(
+      `${layout}: original HUD color, glow and metadata alpha remain intact`,
+      originalGlyphs.glyphs.every(
+        (glyph) =>
+          glyph.color === originalGlyphs.baseline.color &&
+          glyph.shadow === originalGlyphs.baseline.shadow,
+      ) &&
+        originalGlyphs.glyphs.find(
+          (glyph) => glyph.selector === '.hud-summary-label',
+        ).opacity === 0.55 &&
+        originalGlyphs.glyphs.find((glyph) => glyph.selector === '.hud-orbital')
+          .opacity === 0.7 &&
+        originalGlyphs.glyphs.find((glyph) => glyph.selector === '#hud-coll')
+          .opacity === 0.5,
+      originalGlyphs,
+    );
+    if (process.env.QA_SCREENSHOT_DIR) {
+      fs.mkdirSync(process.env.QA_SCREENSHOT_DIR, { recursive: true });
+      await page.screenshot({
+        path: path.join(
+          process.env.QA_SCREENSHOT_DIR,
+          `scope-on-${layout}.png`,
+        ),
+      });
+    }
+    await page.evaluate(() =>
+      window.__godsEyeView.styleManager.applyVisualState({
+        scope: { enabled: false },
+      }),
+    );
+    await settleTextBackings(false);
+    const backedGlyphs = await readHudGlyphs();
+    checkSceneChrome(layout, originalChrome, await readSceneChrome());
+    check(
+      `${layout}: Scope OFF adds backing without changing glyph styles`,
+      JSON.stringify(backedGlyphs) === JSON.stringify(originalGlyphs),
+      backedGlyphs,
+    );
+    const coverage = await page.evaluate(() => {
+      const hud = document.getElementById('intel-hud');
+      const walker = document.createTreeWalker(hud, NodeFilter.SHOW_TEXT);
+      const missing = [];
+      let visible = 0;
+      let node;
+      while ((node = walker.nextNode())) {
+        if (
+          !node.textContent.trim() ||
+          node.parentElement.closest('.hud-bracket')
+        )
+          continue;
+        const range = document.createRange();
+        range.selectNodeContents(node);
+        if (
+          ![...range.getClientRects()].some(
+            (rect) => rect.width > 0 && rect.height > 0,
+          )
+        )
+          continue;
+        visible += 1;
+        const backing = node.parentElement.closest('.hud-readout');
+        const color = backing && getComputedStyle(backing).backgroundColor;
+        if (
+          !backing ||
+          color !== 'rgba(0, 0, 0, 0.7)' ||
+          getComputedStyle(backing).boxShadow !== 'none' ||
+          backing.parentElement.closest('.hud-readout')
+        )
+          missing.push(node.textContent.trim());
+      }
+      const wrapped = [...hud.querySelectorAll('.hud-readout')].filter(
+        (el) => el.offsetWidth > 0 && el.offsetHeight > 0,
+      );
+      const empty = wrapped.filter((el) => !el.innerText.trim()).length;
+      const overlaps = [];
+      for (const parent of new Set(wrapped.map((el) => el.parentElement))) {
+        const siblings = wrapped.filter((el) => el.parentElement === parent);
+        for (let i = 1; i < siblings.length; i += 1) {
+          const previous = siblings[i - 1].getBoundingClientRect();
+          const current = siblings[i].getBoundingClientRect();
+          const horizontal =
+            Math.min(previous.right, current.right) -
+            Math.max(previous.left, current.left);
+          const vertical =
+            Math.min(previous.bottom, current.bottom) -
+            Math.max(previous.top, current.top);
+          // Horizontal bars share a vertical band. Only intersecting text boxes
+          // can stack their backing alpha; allow subpixel layout rounding.
+          if (horizontal > 0.5 && vertical > 0.5) {
+            overlaps.push({
+              parent: parent.className,
+              previous: siblings[i - 1].innerText,
+              current: siblings[i].innerText,
+              vertical,
+            });
+          }
+        }
+      }
+      const lineIds = [
+        'hud-mgrs',
+        'hud-latlon',
+        'hud-gsd',
+        'hud-alt',
+        'hud-timestamp',
+        'hud-bottom-line',
+      ];
+      const multiline = lineIds.filter((id) => {
+        const el = document.getElementById(id);
+        if (!el.getClientRects().length) return false;
+        const range = document.createRange();
+        range.selectNodeContents(el);
+        return (
+          range.getBoundingClientRect().height >
+          parseFloat(getComputedStyle(el).lineHeight) * 1.5
+        );
+      });
+      const edges = [...hud.querySelectorAll('.hud-edge')]
+        .filter((el) => getComputedStyle(el).display !== 'none')
+        .map((el) => {
+          const box = el.querySelector('.hud-readout').getBoundingClientRect();
+          return (
+            getComputedStyle(el).transform !== 'none' &&
+            box.height > box.width &&
+            Number(getComputedStyle(el).opacity) === 1
+          );
+        });
+      const broadBackings = [
+        ...hud.querySelectorAll('.hud-corner, .hud-bottom-bar'),
+      ].filter(
+        (el) =>
+          el.offsetWidth > 0 &&
+          getComputedStyle(el).backgroundColor !== 'rgba(0, 0, 0, 0)',
+      );
+      return {
+        scopeOff: document.documentElement.dataset.scopeMask === 'off',
+        visible,
+        missing,
+        empty,
+        overlaps,
+        multiline,
+        edges,
+        broadBackings: broadBackings.length,
+      };
+    });
+    check(
+      `${layout}: all visible HUD text has one backing`,
+      coverage.scopeOff &&
+        coverage.visible > 0 &&
+        coverage.missing.length === 0 &&
+        coverage.empty === 0 &&
+        coverage.broadBackings === 0,
+      coverage,
+    );
+    check(
+      `${layout}: adjacent readout backings do not overlap`,
+      coverage.overlaps.length === 0,
+      coverage,
+    );
+    check(
+      `${layout}: desktop telemetry remains single line; rotated backing follows the labels`,
+      coverage.multiline.length === 0 && coverage.edges.every(Boolean),
+      coverage,
+    );
+    if (process.env.QA_SCREENSHOT_DIR) {
+      fs.mkdirSync(process.env.QA_SCREENSHOT_DIR, { recursive: true });
+      await page.screenshot({
+        path: path.join(
+          process.env.QA_SCREENSHOT_DIR,
+          `scope-off-${layout}.png`,
+        ),
+      });
+    }
+  }
+  const details = await page.evaluate(() => {
+    const summary = document.getElementById('hud-summary');
+    summary.textContent = 'LONG TELEMETRY SUMMARY '.repeat(30);
+    const ais = document.getElementById('hud-ais-vessel');
+    ais.textContent = 'AIS: 4 VESSELS\nLATEST OBSERVATION';
+    return {
+      summaryClipped:
+        summary.scrollWidth > summary.clientWidth &&
+        getComputedStyle(summary).textOverflow === 'ellipsis',
+      aisMultiline:
+        getComputedStyle(ais).whiteSpace === 'pre-line' &&
+        ais.textContent.split('\n').length === 2 &&
+        ais.getBoundingClientRect().height + 0.5 >=
+          parseFloat(getComputedStyle(ais).lineHeight) * 2,
+      recColor: getComputedStyle(document.getElementById('hud-rec-dot')).color,
+    };
+  });
+  check(
+    'summary clipping, multiline AIS and red REC dot retain their behavior',
+    details.summaryClipped &&
+      details.aisMultiline &&
+      details.recColor === 'rgb(255, 51, 51)',
+    details,
+  );
+  await page.setViewport({ width: 390, height: 844 });
+  await page.select('#hud-layout-select', 'minimal');
+  const narrow = await page.evaluate(() =>
+    [...document.querySelectorAll('#intel-hud .hud-readout')]
+      .filter(
+        (el) =>
+          el.getClientRects().length &&
+          getComputedStyle(el).display !== 'contents',
+      )
+      .every((el) => {
+        const box = el.getBoundingClientRect();
+        return box.left >= 0 && box.right <= innerWidth;
+      }),
+  );
+  check('narrow HUD text backings stay within the viewport', narrow);
+  for (const layout of ['minimal', 'tactical']) {
+    await page.select('#hud-layout-select', layout);
+    await page.evaluate(() =>
+      window.__godsEyeView.styleManager.applyVisualState({
+        scope: { enabled: true },
+      }),
+    );
+    await settleTextBackings(true);
+    const before = await readSceneChrome();
+    await page.evaluate(() =>
+      window.__godsEyeView.styleManager.applyVisualState({
+        scope: { enabled: false },
+      }),
+    );
+    await settleTextBackings(false);
+    checkSceneChrome(`narrow ${layout}`, before, await readSceneChrome());
+  }
+  check('runtime has no uncaught browser errors', errors.length === 0, errors);
+} finally {
+  await browser.close();
+}
+console.log(`RESULT: ${failures} failures`);
+process.exitCode = failures ? 1 : 0;

scripts/qa-segmented-controls.mjs

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+/** Run against a dev server or built preview with QA_BASE_URL (default :4179). */
+import fs from 'node:fs';
+import puppeteer from 'puppeteer';
+
+const browser = await puppeteer.launch({
+  executablePath:
+    process.env.PUPPETEER_EXECUTABLE_PATH || (await puppeteer.executablePath()),
+  headless: true,
+  args: ['--use-gl=angle', '--use-angle=swiftshader'],
+});
+const page = await browser.newPage();
+const errors = [];
+const failures = [];
+page.on('pageerror', (error) => errors.push(error.message));
+const check = (name, passed, detail = '') => {
+  console.log(
+    `[${passed ? 'PASS' : 'FAIL'}] ${name}${detail ? ` — ${detail}` : ''}`,
+  );
+  if (!passed) failures.push(name);
+};
+const base = process.env.QA_BASE_URL || 'http://localhost:4179';
+const shots = process.env.QA_SHOTS_DIR || 'qa-shots/segmented-controls';
+fs.mkdirSync(shots, { recursive: true });
+
+try {
+  await page.setViewport({ width: 1440, height: 900 });
+  await page.goto(`${base}/?welcome=0`, { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(
+    () => window.__godsEyeView?.styleManager?._applicationShortcuts,
+    { timeout: 60000 },
+  );
+  await page.waitForFunction(
+    () =>
+      document.getElementById('loading-screen')?.classList.contains('hidden'),
+    { timeout: 60000 },
+  );
+  await page.evaluate(() =>
+    window.__godsEyeView.styleManager.setPanelCollapsed('pp-toggles', false, {
+      persist: false,
+      syncShare: false,
+    }),
+  );
+
+  const surface = await page.evaluate(() => {
+    const groups = [...document.querySelectorAll('[role="radiogroup"]')];
+    const buttons = groups.flatMap((group) => [
+      ...group.querySelectorAll('[role="radio"]'),
+    ]);
+    return {
+      groups: groups.length,
+      buttons: buttons.length,
+      shared:
+        groups.every((g) => g.classList.contains('gev-segmented')) &&
+        buttons.every((b) => {
+          const style = getComputedStyle(b);
+          return (
+            b.classList.contains('gev-segment') &&
+            style.fontSize === '9px' &&
+            style.minHeight === '24px' &&
+            style.borderRadius === '0px'
+          );
+        }),
+    };
+  });
+  check(
+    'all six one-of-many groups use the shared surface',
+    surface.groups === 6 && surface.buttons === 15 && surface.shared,
+    JSON.stringify(surface),
+  );
+
+  await page.evaluate(() =>
+    document.getElementById('models3d-mode-all').click(),
+  );
+  check(
+    'model selection reaches both aircraft layers',
+    await page.evaluate(() => {
+      const dm = window.__godsEyeView.dataManager;
+      return (
+        ['flights', 'military'].every(
+          (id) => dm.layers.get(id).module.getParams().models3dMode === 'all',
+        ) &&
+        document
+          .getElementById('models3d-mode-all')
+          .getAttribute('aria-checked') === 'true'
+      );
+    }),
+  );
+  await page.focus('#models3d-mode-all');
+  await page.keyboard.press('ArrowLeft');
+  check(
+    'Display retains its click-only arrow policy',
+    await page.evaluate(
+      () =>
+        document
+          .getElementById('models3d-mode-all')
+          .getAttribute('aria-checked') === 'true',
+    ),
+  );
+  await page.focus('#models3d-mode-proximity');
+  await page.keyboard.press('Space');
+  check(
+    'native Space selects model coverage',
+    await page.evaluate(
+      () =>
+        document
+          .getElementById('models3d-mode-proximity')
+          .getAttribute('aria-checked') === 'true',
+    ),
+  );
+  await page.evaluate(() =>
+    document.getElementById('detection-allocation-weighted').click(),
+  );
+  check(
+    'allocation selection still updates application tuning',
+    await page.evaluate(
+      () =>
+        window.__godsEyeView.styleManager._detectionAllocationPreference ===
+          'WEIGHTED' &&
+        document
+          .getElementById('detection-allocation-weighted')
+          .getAttribute('aria-checked') === 'true',
+    ),
+  );
+
+  await page.evaluate(() =>
+    document.querySelector('[data-shape="pin"]').click(),
+  );
+  check(
+    'drawing shape still uses its existing feature action',
+    await page.evaluate(
+      () =>
+        window.__gevDrawTool?.shape === 'pin' &&
+        document
+          .querySelector('[data-shape="pin"]')
+          .getAttribute('aria-checked') === 'true',
+    ),
+  );
+
+  // Off-layer controls still own params; no catalog/provider request is needed.
+  await page.evaluate(() =>
+    document.querySelector('[data-sl-pano="flat"]').click(),
+  );
+  check(
+    'panorama choice reaches the Street Level layer',
+    await page.evaluate(
+      () =>
+        window.__godsEyeView.dataManager.layers
+          .get('street-level')
+          .module.getParams().pano === 'flat',
+    ),
+  );
+  await page.evaluate(() =>
+    document.querySelector('[data-sl-pano="flat"]').dispatchEvent(
+      new KeyboardEvent('keydown', {
+        key: 'Home',
+        bubbles: true,
+        cancelable: true,
+      }),
+    ),
+  );
+  check(
+    'Street Level Home retains selection and roving tab state',
+    await page.evaluate(
+      () =>
+        window.__godsEyeView.dataManager.layers
+          .get('street-level')
+          .module.getParams().pano === 'all' &&
+        document
+          .querySelector('[data-sl-pano="all"]')
+          .getAttribute('tabindex') === '0',
+    ),
+  );
+  await page.evaluate(() =>
+    document.querySelector('[data-sl-render="fill"]').click(),
+  );
+  check(
+    'fit/fill keeps its stored render preference',
+    await page.evaluate(
+      () =>
+        localStorage.getItem('gev:street-level:render-mode') === 'fill' &&
+        document
+          .querySelector('[data-sl-render="fill"]')
+          .getAttribute('aria-checked') === 'true',
+    ),
+  );
+
+  await page.evaluate(() =>
+    document.querySelector('.ri-mode-btn[data-mode="ab"]').click(),
+  );
+  check(
+    'imagery mode reaches its controlled layer state',
+    await page.evaluate(
+      () =>
+        window.__godsEyeView.dataManager.layers
+          .get('recent-imagery')
+          .module.getSnapshot().mode === 'ab',
+    ),
+  );
+  await page.evaluate(() =>
+    document.getElementById('ri-mode').dispatchEvent(
+      new KeyboardEvent('keydown', {
+        key: 'ArrowRight',
+        bubbles: true,
+        cancelable: true,
+      }),
+    ),
+  );
+  check(
+    'imagery arrows wrap from the current selected value',
+    await page.evaluate(
+      () =>
+        window.__godsEyeView.dataManager.layers
+          .get('recent-imagery')
+          .module.getSnapshot().mode === 'image' &&
+        document
+          .querySelector('.ri-mode-btn[data-mode="image"]')
+          .getAttribute('aria-checked') === 'true',
+    ),
+  );
+
+  await page.evaluate(() => {
+    const manager = window.__godsEyeView.styleManager;
+    manager._setDetectionAllocation('ELASTIC', {
+      syncShare: false,
+      persist: false,
+    });
+    document
+      .getElementById('models3d-mode-proximity')
+      .scrollIntoView({ block: 'center' });
+  });
+  await page.screenshot({ path: `${shots}/desktop.png` });
+  await page.setViewport({ width: 620, height: 900 });
+  await page.evaluate(() =>
+    document
+      .getElementById('models3d-mode-proximity')
+      .scrollIntoView({ block: 'center' }),
+  );
+  await page.screenshot({ path: `${shots}/narrow.png` });
+  check(
+    'narrow selectors stay within their panel',
+    await page.evaluate(() =>
+      [...document.querySelectorAll('.pp-mode-seg')]
+        .filter((g) => g.getClientRects().length)
+        .every((group) => group.scrollWidth <= group.clientWidth + 1),
+    ),
+  );
+  const cyber = await page.evaluate(() => {
+    const root = document.documentElement;
+    const previous = root.getAttribute('data-ui-theme');
+    root.setAttribute('data-ui-theme', 'cyber');
+    const selected = [
+      ...document.querySelectorAll('.gev-segment[aria-checked="true"]'),
+    ];
+    // Check the final theme colors, independent of software-GL frame cadence.
+    for (const button of selected)
+      for (const animation of button.getAnimations()) animation.finish();
+    const backgrounds = selected.map(
+      (button) => getComputedStyle(button).backgroundColor,
+    );
+    const radii = [...document.querySelectorAll('.gev-segmented')].map(
+      (group) => getComputedStyle(group).borderRadius,
+    );
+    const consistent =
+      selected.length === 6 &&
+      backgrounds.every((color) => color === backgrounds[0]) &&
+      radii.every((radius) => radius === '1px');
+    if (previous === null) root.removeAttribute('data-ui-theme');
+    else root.setAttribute('data-ui-theme', previous);
+    return { consistent, count: selected.length, backgrounds, radii };
+  });
+  check(
+    'Cyber theme styles every selected segment consistently',
+    cyber.consistent,
+    JSON.stringify(cyber),
+  );
+  await page.evaluate(async () => {
+    const { dataManager, styleManager } = window.__godsEyeView;
+    await dataManager.setEnabled('recent-imagery', true);
+    styleManager.setPanelCollapsed('recent-imagery-panel', false, {
+      persist: false,
+      syncShare: false,
+    });
+  });
+  for (const width of [1440, 620, 390]) {
+    await page.setViewport({ width, height: 900 });
+    await page.focus('.ri-mode-btn[aria-checked="true"]');
+    const modeLayout = await page.evaluate(() => {
+      const group = document.getElementById('ri-mode');
+      const bounds = group.getBoundingClientRect();
+      const style = getComputedStyle(group);
+      const top = bounds.top + parseFloat(style.borderTopWidth);
+      const bottom = bounds.bottom - parseFloat(style.borderBottomWidth);
+      const buttons = [...group.querySelectorAll('[role="radio"]')];
+      return {
+        visible: bounds.width > 0 && bounds.height > 0,
+        contained: buttons.every((button) => {
+          const rect = button.getBoundingClientRect();
+          return rect.top >= top - 0.5 && rect.bottom <= bottom + 0.5;
+        }),
+        groupHeight: bounds.height,
+        buttonHeights: buttons.map(
+          (button) => button.getBoundingClientRect().height,
+        ),
+      };
+    });
+    check(
+      `imagery mode buttons and focus outline fit their row at ${width}px`,
+      modeLayout.visible && modeLayout.contained,
+      JSON.stringify(modeLayout),
+    );
+  }
+  check('no uncaught browser errors', errors.length === 0, errors.join(' | '));
+} catch (error) {
+  console.error('Browser errors:', errors);
+  await page.screenshot({ path: `${shots}/failure.png` }).catch(() => {});
+  throw error;
+} finally {
+  await browser.close();
+}
+console.log(`RESULT: ${failures.length} failures`);
+process.exitCode = failures.length ? 1 : 0;

scripts/qa-sky-model-lighting.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+/**
+ * Lit airplane regression: StarrySky must match a black environment baseline.
+ * A white environment is a positive control: it must visibly brighten the
+ * same model. Each case uses a fresh scene and dynamic environment map.
+ * Usage: node scripts/qa-sky-model-lighting.mjs [--url http://localhost:4333/]
+ */
+import assert from 'node:assert/strict';
+import puppeteer from 'puppeteer';
+
+const i = process.argv.indexOf('--url');
+const base = i > 0 ? process.argv[i + 1] : 'http://localhost:4333/';
+const url = new URL('/__qa_sky_model__', base);
+const browser = await puppeteer.launch({
+  headless: true,
+  args: ['--no-sandbox', '--ignore-gpu-blocklist'],
+});
+try {
+  const page = await browser.newPage();
+  page.on('pageerror', (error) => console.log('PAGEERR', error.message));
+  await page.setRequestInterception(true);
+  page.on('request', (request) => {
+    if (request.url() === url.href)
+      request.respond({
+        contentType: 'text/html',
+        body: '<!doctype html><html><body></body></html>',
+      });
+    else if (new URL(request.url()).origin !== url.origin) request.abort();
+    else request.continue();
+  });
+  await page.goto(url.href);
+  const results = await page.evaluate(async () => {
+    window.CESIUM_BASE_URL = '/cesium/';
+    // Use StarrySky's exact Vite dependency URL, including its version query.
+    const source = await fetch('/src/sky/starrySky.js').then((r) => r.text());
+    const cesiumUrl = source.match(
+      /from ["']([^"']*\/cesium\.js[^"']*)["']/,
+    )?.[1];
+    if (!cesiumUrl) throw new Error('run against the Vite dev server');
+    const C = await import(cesiumUrl);
+    const { StarrySky } = await import('/src/sky/starrySky.js');
+    const time = C.JulianDate.fromIso8601('2026-10-19T00:00:00Z');
+    const results = {};
+    for (const kind of ['black', 'starry', 'white']) {
+      const canvas = document.createElement('canvas');
+      canvas.width = 400;
+      canvas.height = 300;
+      document.body.append(canvas);
+      const scene = new C.Scene({ canvas });
+      scene.rethrowRenderErrors = true;
+      let cubeMap;
+      try {
+        scene.backgroundColor = C.Color.BLACK;
+        scene.light = new C.DirectionalLight({
+          direction: new C.Cartesian3(1, 0, 0),
+          intensity: 0.2,
+        });
+        if (kind === 'starry') {
+          scene.skyBox = new StarrySky({ requestRender() {} });
+          scene.skyBox._loading = true; // visible sky is outside this probe
+        } else {
+          const value = kind === 'white' ? 255 : 0;
+          const face = {
+            width: 1,
+            height: 1,
+            arrayBufferView: new Uint8Array([value, value, value, 255]),
+          };
+          cubeMap = new C.CubeMap({
+            context: scene.context,
+            source: Object.fromEntries(
+              [...C.CubeMap.faceNames()].map((name) => [name, face]),
+            ),
+          });
+          scene.skyBox = { _cubeMap: cubeMap, update() {}, destroy() {} };
+        }
+        const position = C.Cartesian3.fromDegrees(0, 0, 10000);
+        const model = await C.Model.fromGltfAsync({
+          url: '/models/airplane.glb',
+          modelMatrix: C.Transforms.eastNorthUpToFixedFrame(position),
+        });
+        scene.primitives.add(model);
+        scene.camera.lookAt(position, new C.HeadingPitchRange(0.4, -0.5, 45));
+        let framed = false;
+        for (let frame = 0; frame < 240; frame++) {
+          scene.initializeFrame();
+          scene.render(time);
+          if (model.ready && !framed) {
+            scene.camera.viewBoundingSphere(
+              model.boundingSphere,
+              new C.HeadingPitchRange(
+                0.4,
+                -0.5,
+                model.boundingSphere.radius * 3,
+              ),
+            );
+            framed = true;
+          }
+          await new Promise(requestAnimationFrame);
+        }
+        if (!model.ready || !model.environmentMapManager.radianceCubeMap)
+          throw new Error(`${kind}: model or dynamic lighting did not load`);
+        scene.initializeFrame();
+        scene.render(time);
+        const gl = scene.context._gl;
+        const px = new Uint8Array(canvas.width * canvas.height * 4);
+        gl.readPixels(
+          0,
+          0,
+          canvas.width,
+          canvas.height,
+          gl.RGBA,
+          gl.UNSIGNED_BYTE,
+          px,
+        );
+        let total = 0;
+        let visible = 0;
+        for (let p = 0; p < px.length; p += 4) {
+          const luma = 0.299 * px[p] + 0.587 * px[p + 1] + 0.114 * px[p + 2];
+          total += luma;
+          if (luma > 1) visible++;
+        }
+        results[kind] = { total, visible };
+      } finally {
+        scene.destroy();
+        cubeMap?.destroy();
+        canvas.remove();
+      }
+    }
+    return results;
+  });
+  console.log(JSON.stringify(results));
+  assert.ok(results.black.visible > 100, 'the lit model must be visible');
+  assert.ok(
+    Math.abs(results.starry.total - results.black.total) <=
+      results.black.total * 0.01,
+    'StarrySky must match black environment lighting within 1%',
+  );
+  assert.ok(
+    results.white.total > results.black.total * 1.03,
+    'white environment control must brighten the model by at least 3%',
+  );
+  console.log(
+    'PASS: lit airplane matches black sky; white control is brighter',
+  );
+} finally {
+  await browser.close();
+}

scripts/qa-status-badges.mjs

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+/** Badge acceptance on dev/preview. Camera state is a disposable controller fixture. */
+import fs from 'node:fs';
+import puppeteer from 'puppeteer';
+
+const browser = await puppeteer.launch({
+  headless: true,
+  args: ['--use-gl=angle', '--use-angle=swiftshader'],
+});
+const page = await browser.newPage();
+page.setDefaultNavigationTimeout(60000);
+const errors = [];
+page.on('pageerror', (error) => errors.push(error.message));
+let checks = 0;
+let failures = 0;
+const check = (name, passed, detail) => {
+  checks++;
+  console.log(`[${passed ? 'PASS' : 'FAIL'}] ${name}`);
+  if (!passed) {
+    failures++;
+    console.log(JSON.stringify(detail));
+  }
+};
+const out = 'qa-shots/status-badges';
+fs.mkdirSync(out, { recursive: true });
+try {
+  for (const lang of ['en', 'ru']) {
+    await page.setViewport({ width: 1440, height: 900 });
+    await page.goto(
+      `${process.env.QA_BASE_URL || 'http://127.0.0.1:4189'}/?welcome=0&lang=${lang}`,
+      { waitUntil: 'domcontentloaded' },
+    );
+    await page.waitForFunction(
+      () =>
+        window.__godsEyeView?.styleManager?._cctvControls &&
+        document.getElementById('loading-screen')?.classList.contains('hidden'),
+      { timeout: 60000 },
+    );
+    await page.evaluate(async () => {
+      const { dataManager, styleManager: manager } = window.__godsEyeView;
+      await dataManager.setEnabled('wind', true);
+      manager.setPanelCollapsed('weather-panel', false, {
+        persist: false,
+        syncShare: false,
+      });
+      manager.setPanelCollapsed('cctv-panel', false, {
+        persist: false,
+        syncShare: false,
+      });
+      const owner = manager._cctvControls;
+      owner._cctvUnsubscribe?.();
+      owner._cctvUnsubscribe = null;
+      owner.actions = { ...owner.actions, isEnabled: () => true };
+      owner._renderCctvState({
+        enabled: true,
+        activeCameraId: 'badge-fixture',
+        cameras: [{ id: 'badge-fixture', city: 'QA', name: 'Badge fixture' }],
+        activeCamera: {
+          id: 'badge-fixture',
+          city: 'QA',
+          headingDeg: 30,
+          pitchDeg: -10,
+          fovDeg: 45,
+          rangeM: 120,
+          mountHeightM: 8,
+          sourceKind: 'snapshot',
+          sourceStatus: 'degraded',
+          calBadge: 'curated',
+          calDirty: false,
+        },
+      });
+      window.__qaBadgeText =
+        document.getElementById('cctv-source-badge').textContent;
+    });
+    await page.waitForSelector('.weather-coverage.gev-status-badge');
+    const inventory = await page.evaluate(() => {
+      const source = document.getElementById('cctv-source-badge');
+      const quality = document.getElementById('cctv-quality-chip');
+      const coverage = [...document.querySelectorAll('.weather-coverage')];
+      return {
+        shared: [source, quality, ...coverage].every((node) =>
+          node.classList.contains('gev-status-badge'),
+        ),
+        live:
+          source.getAttribute('role') === 'status' &&
+          source.getAttribute('aria-live') === 'polite',
+        silent: [quality, ...coverage].every(
+          (node) =>
+            !node.hasAttribute('aria-live') &&
+            !node.hasAttribute('role') &&
+            !node.hasAttribute('tabindex'),
+        ),
+        coverage:
+          coverage.length > 0 &&
+          coverage.every(
+            (node) =>
+              node.textContent &&
+              !node.hidden &&
+              node.classList.contains('gev-status-badge--plain'),
+          ),
+        source: source.textContent,
+      };
+    });
+    check(
+      `${lang}: CCTV and populated Weather badges share the view`,
+      inventory.shared && inventory.coverage,
+      inventory,
+    );
+    check(
+      `${lang}: existing announcement and read-only semantics remain intact`,
+      inventory.live && inventory.silent,
+      inventory,
+    );
+    check(
+      `${lang}: source wording uses the active locale`,
+      lang === 'en'
+        ? inventory.source === 'SNAPSHOT · DEGRADED'
+        : inventory.source !== 'SNAPSHOT · DEGRADED',
+      inventory,
+    );
+
+    for (const state of ['loading', 'error', 'retained', 'ready', 'idle']) {
+      const result = await page.evaluate((state) => {
+        const owner = window.__godsEyeView.styleManager._cctvControls;
+        owner._cctvFrame.dataset.loading = state === 'loading' ? 'true' : '';
+        owner._cctvFrame.dataset.error = ['error', 'retained'].includes(state)
+          ? 'true'
+          : '';
+        owner._cctvFrameWrap.classList.toggle(
+          'has-frame',
+          state === 'retained',
+        );
+        owner._syncCctvSourceBadge(
+          owner._cctvState.activeCamera,
+          state !== 'idle',
+        );
+        const badge = document.getElementById('cctv-source-badge');
+        return {
+          state: badge.dataset.frameState,
+          text: badge.textContent,
+          color: getComputedStyle(badge).color,
+        };
+      }, state);
+      const expected = {
+        loading: ['loading', 'rgb(255, 229, 155)'],
+        error: ['error', 'rgb(255, 176, 176)'],
+        retained: ['ready', 'rgb(157, 239, 255)'],
+        ready: ['ready', 'rgb(157, 239, 255)'],
+        idle: ['idle', 'rgb(157, 239, 255)'],
+      }[state];
+      check(
+        `${lang}: ${state} keeps its frame state and palette`,
+        result.state === expected[0] &&
+          result.color === expected[1] &&
+          (!['ready', 'retained'].includes(state) ||
+            result.text === inventory.source),
+        result,
+      );
+    }
+    for (const [calBadge, dirty, color] of [
+      ['raw-prior', false, 'rgb(143, 231, 255)'],
+      ['curated', false, 'rgb(255, 230, 162)'],
+      ['calibrated', false, 'rgb(173, 255, 191)'],
+      ['curated', true, 'rgb(255, 208, 138)'],
+    ]) {
+      const result = await page.evaluate(
+        ({ calBadge, dirty }) => {
+          const owner = window.__godsEyeView.styleManager._cctvControls;
+          document.getElementById('cctv-next-btn').focus();
+          owner._renderCctvState({
+            ...owner._cctvState,
+            activeCamera: {
+              ...owner._cctvState.activeCamera,
+              calBadge,
+              calDirty: dirty,
+            },
+          });
+          const badge = document.getElementById('cctv-quality-chip');
+          return {
+            state: badge.dataset.calBadge,
+            color: getComputedStyle(badge).color,
+            focus: document.activeElement.id,
+          };
+        },
+        { calBadge, dirty },
+      );
+      check(
+        `${lang}: ${dirty ? 'edited' : calBadge} keeps provenance color and control focus`,
+        result.state === (dirty ? 'edited' : calBadge) &&
+          result.color === color &&
+          result.focus === 'cctv-next-btn',
+        result,
+      );
+    }
+    for (const theme of ['tactical', 'cyber']) {
+      await page.evaluate(
+        (theme) => window.__godsEyeView.styleManager._setHudVariant(theme),
+        theme,
+      );
+      for (const width of [1440, 620, 390]) {
+        await page.setViewport({ width, height: 900 });
+        for (const panelId of ['cctv-panel', 'weather-panel']) {
+          await page.evaluate(async (panelId) => {
+            const manager = window.__godsEyeView.styleManager;
+            for (const other of ['cctv-panel', 'weather-panel']) {
+              if (other !== panelId)
+                manager.setPanelCollapsed(other, true, {
+                  persist: false,
+                  syncShare: false,
+                });
+            }
+            manager.setPanelCollapsed(panelId, false, {
+              persist: false,
+              syncShare: false,
+            });
+            await new Promise((resolve) =>
+              requestAnimationFrame(() => requestAnimationFrame(resolve)),
+            );
+          }, panelId);
+          const layout = await page.evaluate((panelId) => {
+            const selector =
+              panelId === 'cctv-panel'
+                ? '#cctv-source-badge, #cctv-quality-chip'
+                : '.weather-coverage';
+            return [...document.querySelectorAll(selector)].map((node) => {
+              const rect = node.getBoundingClientRect();
+              const panel = node.closest(`#${panelId}`).getBoundingClientRect();
+              return {
+                id: node.id || 'weather-coverage',
+                text: node.textContent,
+                width: rect.width,
+                height: rect.height,
+                scroll: node.scrollWidth,
+                client: node.clientWidth,
+                left: rect.left,
+                right: rect.right,
+                panelLeft: panel.left,
+                panelRight: panel.right,
+                fits:
+                  rect.width > 0 &&
+                  rect.height > 0 &&
+                  rect.left >= panel.left - 1 &&
+                  rect.right <= panel.right + 1 &&
+                  node.scrollWidth <= node.clientWidth + 1,
+              };
+            });
+          }, panelId);
+          check(
+            `${lang}/${theme}: ${panelId} badges fit at ${width}px`,
+            layout.length >= (panelId === 'cctv-panel' ? 2 : 1) &&
+              layout.every((node) => node.fits),
+            layout,
+          );
+          if (width === 390)
+            await page.screenshot({
+              path: `${out}/${lang}-${theme}-${panelId}-${width}.png`,
+            });
+        }
+      }
+    }
+    const disposed = await page.evaluate(() => {
+      const owner = window.__godsEyeView.styleManager._cctvControls;
+      const badge = document.getElementById('cctv-quality-chip');
+      const text = badge.textContent;
+      owner.destroy();
+      owner._renderCctvState(null);
+      return badge.textContent === text;
+    });
+    check(`${lang}: disposal prevents late state painting`, disposed);
+  }
+  check('no uncaught browser errors', errors.length === 0, errors);
+} finally {
+  await browser.close();
+}
+console.log(`${checks} checks; ${failures} failures`);
+process.exitCode = failures ? 1 : 0;

scripts/qa-traffic-jamviz-ab.mjs

@@ -139,15 +139,19 @@ async function main() {
 
   try {
     const res = await fetch(APP_URL);
+    // Only the status matters; an unread body can hold the socket open.
+    await res.body?.cancel();
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
   } catch (e) {
     console.error(`Dev server not reachable at ${APP_URL} (${e.message}).`);
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
   const status = await fetch(`${APP_URL}/api/tomtom/status`).then((r) => r.json()).catch(() => null);
   if (!status?.hasKey) {
     console.error('Server has no TomTom key — the A/B needs live flow.');
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
 
   fs.mkdirSync(OUT_DIR, { recursive: true });

scripts/qa-traffic-oblique.mjs

@@ -80,9 +80,7 @@ try {
       page.evaluate(() => {
         const { viewer, dataManager } = window.__godsEyeView;
         let upper = 0,
-          lower = 0,
-          near = 0;
-        const camera = viewer.camera.positionWC;
+          lower = 0;
         dataManager.layers
           .get('traffic')
           .module.visitMotionDots((id, key, p) => {

scripts/qa-traffic-preset-ab.mjs

@@ -145,15 +145,19 @@ async function main() {
 
   try {
     const res = await fetch(APP_URL);
+    // Only the status matters; an unread body can hold the socket open.
+    await res.body?.cancel();
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
   } catch (e) {
     console.error(`Dev server not reachable at ${APP_URL} (${e.message}).`);
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
   const status = await fetch(`${APP_URL}/api/tomtom/status`).then((r) => r.json()).catch(() => null);
   if (!status?.hasKey) {
     console.error('Server has no TomTom key — the A/B needs live flow.');
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
 
   fs.mkdirSync(OUT_DIR, { recursive: true });

scripts/qa-traffic.mjs

@@ -25,12 +25,13 @@
  * Visual proof saved to qa-shots/ (gitignored).
  *
  * Run:  node scripts/qa-traffic.mjs --url http://localhost:4410
- * Add --fixtures for synthetic roads and the recorded flow tile without a key;
- * that mode does not qualify live source access or quota accounting.
+ * Add --fixtures for synthetic road/flow tiles and a flat terrain surface without a key;
+ * that mode does not qualify geographic terrain, live source access or quota accounting.
  * Exits non-zero on any FAIL. Does not commit anything.
  */
 
 import puppeteer from 'puppeteer';
+import { captureQaScreenshot } from './qa-chrome.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -44,10 +45,12 @@ const getOpt = (name, dflt) => {
   const i = argv.indexOf(name);
   return i >= 0 && argv[i + 1] ? argv[i + 1] : dflt;
 };
-const APP_URL = getOpt('--url', 'http://localhost:4410');
+const appUrl = new URL(getOpt('--url', 'http://localhost:4410'));
+appUrl.searchParams.set('welcome', '0');
+const APP_URL = appUrl.href;
 const HEADFUL = argv.includes('--headful');
 const FIXTURES = argv.includes('--fixtures');
-const fixtureResponse = FIXTURES ? (await import('./traffic-fixtures.mjs')).trafficFixtureResponse : () => null;
+const { installTrafficRoutes } = await import('./traffic-fixtures.mjs');
 
 const CHROME_EXECUTABLE_CANDIDATES = [
   process.env.PUPPETEER_EXECUTABLE_PATH,
@@ -80,6 +83,10 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
 /** Enable traffic + teleport, then poll the layer until settled. */
 async function settleTraffic(page, view, { minCount = 1, timeoutS = 30 } = {}) {
+  // The app deliberately stops rendering hidden pages. Programmatic camera
+  // changes do not activate a headful window the way a real UI click does.
+  await page.bringToFront();
+  await page.waitForFunction(() => document.visibilityState === 'visible');
   return page.evaluate(async (v, minC, tS) => {
     const gev = window.__godsEyeView;
     const dm = gev.dataManager;
@@ -97,6 +104,7 @@ async function settleTraffic(page, view, { minCount = 1, timeoutS = 30 } = {}) {
     });
     let s = null;
     for (let i = 0; i < tS; i++) {
+      if (document.visibilityState !== 'visible') throw new Error('Traffic QA page became hidden; rendering is intentionally paused');
       await new Promise((r) => setTimeout(r, 1000));
       s = mod.getStats();
       // Retained roads from the previous city can satisfy count/loading before
@@ -113,17 +121,21 @@ async function main() {
 
   try {
     const res = await fetch(APP_URL);
+    // Only the status matters; an unread body can hold the socket open.
+    await res.body?.cancel();
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
   } catch (e) {
     console.error(`\x1b[31mDev server not reachable at ${APP_URL} (${e.message}).\x1b[0m`);
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
 
-  const statusBefore = FIXTURES ? {hasKey:true,dailyCount:0} : await fetch(`${APP_URL}/api/tomtom/status`).then((r) => r.json()).catch(() => null);
-  if (FIXTURES) console.log('Source mode: synthetic roads and recorded flow tiles; live quota is not qualified.');
+  const statusBefore = FIXTURES ? {hasKey:true,dailyCount:0} : await fetch(`${appUrl.origin}/api/tomtom/status`).then((r) => r.json()).catch(() => null);
+  if (FIXTURES) console.log('Source mode: synthetic road/flow tiles and a flat terrain surface; live quota is not qualified.');
   if (!statusBefore?.hasKey) {
     console.error('\x1b[31mServer has no TomTom key — run against the keyed dev server (:4410).\x1b[0m');
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
 
   fs.mkdirSync(SHOTS_DIR, { recursive: true });
@@ -131,8 +143,10 @@ async function main() {
     headless: HEADFUL ? false : 'new',
     ...(findChromeExecutable() ? { executablePath: findChromeExecutable() } : {}),
     args: [
-      '--no-sandbox', '--disable-setuid-sandbox', '--use-gl=angle', '--use-angle=swiftshader',
-      '--disable-dev-shm-usage', '--disable-web-security',
+      '--no-sandbox', '--disable-setuid-sandbox',
+      ...(!HEADFUL ? ['--use-gl=angle', '--use-angle=swiftshader'] : []),
+      '--disable-backgrounding-occluded-windows',
+      '--disable-dev-shm-usage',
       '--disable-background-timer-throttling', '--disable-renderer-backgrounding',
       '--window-size=1440,900',
     ],
@@ -140,24 +154,22 @@ async function main() {
 
   let exitCode = 0;
   try {
-    const page = await browser.newPage();
-    const onFixture = (request) => {
-      const response = fixtureResponse(request);
-      if (response) void request.respond(response); else void request.continue();
-    };
-    if (FIXTURES) { await page.setRequestInterception(true); page.on('request', onFixture); }
+    let page = await browser.newPage();
+    // Keep this visible-page regression deterministic even if the OS starts
+    // Chrome minimized. Use browser focus emulation, not patched DOM getters.
+    const focusSession = await page.createCDPSession();
+    await focusSession.send('Emulation.setFocusEmulationEnabled', { enabled: true });
     await page.setViewport({ width: 1440, height: 900 });
 
-    // Track flow-tile requests + traffic console lines for (ii)/(iii)/(v).
+    // Track flow-tile requests for the (iii) budget check.
     const flowRequests = [];
     page.on('request', (req) => {
       if (req.url().includes('/api/tomtom/flow/')) flowRequests.push(req.url());
     });
-    const trafficLogs = [];
-    page.on('console', (msg) => {
-      const t = msg.text();
-      if (t.includes('[Data:Traffic]')) trafficLogs.push(t);
-    });
+    const pageErrors = [];
+    if (FIXTURES) await installTrafficRoutes(page, { origin: appUrl.origin, fixtures: true, onError: error => pageErrors.push(error.message) });
+    page.on('pageerror', error => { pageErrors.push(error.message); console.error('PAGE ERROR:', error.message); });
+    page.on('console', message => { if (message.type() === 'error') console.error('BROWSER ERROR:', message.text()); });
 
     console.log('Loading app...');
     await page.goto(APP_URL, { waitUntil: 'domcontentloaded', timeout: 60000 });
@@ -190,7 +202,7 @@ async function main() {
         `coverage=${mumbai.flowCoveragePct}% tiles=${mumbai.tilesFetched}`);
       if (mumbai.mode !== 'live' || !(mumbai.count > 0) || !(colored > 0)) exitCode = 1;
       await sleep(1200);
-      await page.screenshot({ path: path.join(SHOTS_DIR, 'traffic-live-flow.png') });
+      await captureQaScreenshot(page, { path: path.join(SHOTS_DIR, 'traffic-live-flow.png') }, { headful: HEADFUL });
     }
 
     // ── (iv) uncovered-roads param — hide vs sim ─────────────────────────────
@@ -223,7 +235,7 @@ async function main() {
         (hid.flowBuckets?.sim || 0) === 0 && hid.count > 0,
         `count=${hid.count} sim=${hid.flowBuckets?.sim}`);
       if ((hid.flowBuckets?.sim || 0) !== 0) exitCode = 1;
-      await page.screenshot({ path: path.join(SHOTS_DIR, 'traffic-live-hide-mode.png') });
+      await captureQaScreenshot(page, { path: path.join(SHOTS_DIR, 'traffic-live-hide-mode.png') }, { headful: HEADFUL });
     } else {
       record('PARAM: hide mode renders zero sim (white) dots', null,
         'view had 100% coverage (no sim dots to hide) — inconclusive here, covered by unit tests');
@@ -231,30 +243,26 @@ async function main() {
 
     // ── (ii) C4 oblique bounds ───────────────────────────────────────────────
     console.log('\n(ii) C4 — oblique fetch bounds land at the look-at point...');
-    trafficLogs.length = 0;
-    await settleTraffic(page, { lon: -97.72, lat: 30.245, height: 2500, heading: 315, pitch: -20 }, { minCount: 100 });
+    const oblique = await settleTraffic(page, { lon: -97.72, lat: 30.245, height: 2500, heading: 315, pitch: -20 }, { minCount: 100 });
     {
-      const fetchLine = trafficLogs.find((t) => t.includes('fetch') && t.includes('['));
-      let ok = false; let detail = 'no fetch log captured';
-      if (fetchLine) {
-        const m = fetchLine.match(/\[(-?[\d.]+),(-?[\d.]+),(-?[\d.]+),(-?[\d.]+)\]/);
-        if (m) {
-          const [s, w, n, e] = m.slice(1).map(Number);
-          const cLat = (s + n) / 2; const cLon = (w + e) / 2;
-          const dKm = Math.sqrt(((cLat - 30.245) * 111) ** 2 + ((cLon - (-97.72)) * 111 * Math.cos(30.27 * Math.PI / 180)) ** 2);
-          ok = dKm > 1 && dKm <= 13; // look-at ~6.9 km ahead; clamp allows ≤12 (+margin)
-          detail = `box center (${cLat.toFixed(4)},${cLon.toFixed(4)}) is ${dKm.toFixed(1)} km from camera (want 1–13 km; pre-fix bug: 25+ km)`;
-        }
+      const bounds = oblique?.roadBounds;
+      let ok = false; let detail = 'no road bounds published';
+      if (bounds) {
+        const cLat = (bounds.south + bounds.north) / 2;
+        const cLon = (bounds.west + bounds.east) / 2;
+        const dKm = Math.hypot((cLat - 30.245) * 111, (cLon + 97.72) * 111 * Math.cos(30.27 * Math.PI / 180));
+        ok = dKm > 1 && dKm <= 13;
+        detail = `road box center is ${dKm.toFixed(1)} km from camera (want 1–13 km)`;
       }
       record('C4: oblique fetch box centers on the look-at point', ok, detail);
       if (!ok) exitCode = 1;
-      await page.screenshot({ path: path.join(SHOTS_DIR, 'traffic-c4-oblique.png') });
+      await captureQaScreenshot(page, { path: path.join(SHOTS_DIR, 'traffic-c4-oblique.png') }, { headful: HEADFUL });
     }
 
     // ── (iii) budget honesty ─────────────────────────────────────────────────
     console.log('\n(iii) Budget — dailyCount grew by ≤ requests this run...');
     {
-      const statusAfter = FIXTURES ? statusBefore : await fetch(`${APP_URL}/api/tomtom/status`).then((r) => r.json());
+      const statusAfter = FIXTURES ? statusBefore : await fetch(`${appUrl.origin}/api/tomtom/status`).then((r) => r.json());
       const grew = statusAfter.dailyCount - statusBefore.dailyCount;
       const ok = grew >= 0 && grew <= flowRequests.length;
       record('BUDGET: /api/tomtom/status growth ≤ page tile requests', FIXTURES ? null : ok,
@@ -264,25 +272,22 @@ async function main() {
 
     // ── (v) KEYLESS fallback (intercepted — server key untouched) ────────────
     console.log('\n(v) KEYLESS — intercepted status, expect pure simulation...');
-    if (FIXTURES) page.off('request', onFixture);
-    await page.setRequestInterception(true);
+    // Keyless is an independent fresh-session contract. Close the keyed page
+    // so its workers, terrain work and intercepted cache cannot leak into it.
+    await page.close();
+    page = await browser.newPage();
+    await page.setViewport({ width: 1440, height: 900 });
+    const keylessFocus = await page.createCDPSession();
+    await keylessFocus.send('Emulation.setFocusEmulationEnabled', { enabled: true });
+    page.on('pageerror', error => { pageErrors.push(error.message); console.error('PAGE ERROR:', error.message); });
+    page.on('console', message => { if (message.type() === 'error') console.error('BROWSER ERROR:', message.text()); });
     const keylessFlowReqs = [];
-    page.on('request', (req) => {
-      const url = req.url();
-      if (url.includes('/api/tomtom/status')) {
-        req.respond({ status: 200, contentType: 'application/json', body: JSON.stringify({ hasKey: false }) });
-        return;
-      }
-      if (url.includes('/api/tomtom/flow/')) {
-        keylessFlowReqs.push(url);
-        req.respond({ status: 503, contentType: 'application/json', body: JSON.stringify({ error: 'no_key' }) });
-        return;
-      }
-      const response = fixtureResponse(req);
-      if (response) { void req.respond(response); return; }
-      try { req.continue(); } catch { /* already handled */ }
+    await installTrafficRoutes(page, {
+      origin: appUrl.origin, fixtures: FIXTURES, keyless: true,
+      onFlow: url => keylessFlowReqs.push(url),
+      onError: error => pageErrors.push(error.message),
     });
-    await page.reload({ waitUntil: 'domcontentloaded', timeout: 60000 });
+    await page.goto(APP_URL, { waitUntil: 'domcontentloaded', timeout: 60000 });
     await page.waitForFunction(
       () => window.__godsEyeView?.viewer && window.__godsEyeView?.dataManager,
       { timeout: 60000 },
@@ -312,8 +317,9 @@ async function main() {
         exitCode = 1;
       }
       await sleep(1000);
-      await page.screenshot({ path: path.join(SHOTS_DIR, 'traffic-sim-keyless.png') });
+      await captureQaScreenshot(page, { path: path.join(SHOTS_DIR, 'traffic-sim-keyless.png') }, { headful: HEADFUL });
     }
+    record('BROWSER: no uncaught page exceptions', pageErrors.length === 0, pageErrors.join('; '));
   } catch (e) {
     console.error('\x1b[31mHarness error:\x1b[0m', e);
     exitCode = 3;

scripts/qa-transit-browser.mjs

@@ -47,6 +47,7 @@ export async function reportTransitVisibility(page, label) {
     const layer = app.dataManager.layers.get('transit').module;
     const state = layer._transitStateForTest();
     return {
+      pageVisibility: document.visibilityState,
       total: state._vehicles.size,
       visible: state._visible.size,
       moving: state._moving.size,
@@ -59,6 +60,10 @@ export async function reportTransitVisibility(page, label) {
     };
   });
   console.log(`  ${label}: ${JSON.stringify(result)}`);
+  if (result.pageVisibility !== 'visible')
+    throw new Error(
+      `${label}: Transit QA requires a visible page; hidden pages deliberately pause polling`,
+    );
   if (result.renderLoop === false || result.renderErrors.length)
     throw new Error(
       `${label}: Cesium render loop stopped or raised an error: ${JSON.stringify(result.renderErrors)}`,

scripts/qa-transit-controls.mjs

@@ -1,6 +1,7 @@
 const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 export const BOSTON = {
   id: 'boston',
+  feedId: 'mbta',
   label: 'Boston (MBTA)',
   lat: 42.3554,
   lon: -71.0605,
@@ -11,6 +12,7 @@ const LIVE_CITIES = [
   BOSTON,
   {
     id: 'austin',
+    feedId: 'capmetro-austin',
     label: 'Austin (CapMetro)',
     lat: 30.2672,
     lon: -97.7431,
@@ -19,6 +21,7 @@ const LIVE_CITIES = [
   },
   {
     id: 'minneapolis',
+    feedId: 'metrotransit-msp',
     label: 'Minneapolis (Metro Transit)',
     lat: 44.9778,
     lon: -93.265,
@@ -27,6 +30,7 @@ const LIVE_CITIES = [
   },
   {
     id: 'helsinki',
+    feedId: 'hsl-helsinki',
     label: 'Helsinki (HSL)',
     lat: 60.1699,
     lon: 24.9384,
@@ -35,6 +39,7 @@ const LIVE_CITIES = [
   },
   {
     id: 'oslo',
+    feedId: 'entur-norway',
     label: 'Oslo (Entur)',
     lat: 59.9139,
     lon: 10.7522,

scripts/qa-transit-heading.mjs

@@ -1,11 +1,11 @@
 import puppeteer from 'puppeteer';
+import { chromeExecutablePath } from './qa-chrome.mjs';
 
 /** Prove parked and moving headings in the real scene, without live feeds. */
 export async function runTransitHeadingRegression(base, check) {
   const browser = await puppeteer.launch({
     headless: true,
-    executablePath:
-      '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    executablePath: chromeExecutablePath(),
     args: ['--no-sandbox', '--disable-background-timer-throttling'],
   });
   try {

scripts/qa-transit-recovery.mjs

@@ -1,5 +1,6 @@
 /** Camera-jump regression against an existing server; never starts a server. */
 import puppeteer from 'puppeteer';
+import { chromeExecutablePath, captureQaScreenshot } from './qa-chrome.mjs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { reduceTrailPixels } from '../src/layers/transit/qaMetrics.js';
 
@@ -8,8 +9,7 @@ const shots = process.env.QA_SHOTS || 'qa-shots/transit-recovery';
 await mkdir(shots, { recursive: true });
 const browser = await puppeteer.launch({
   headless: false,
-  executablePath:
-    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  executablePath: chromeExecutablePath(),
   args: [
     '--disable-background-timer-throttling',
     '--disable-renderer-backgrounding',
@@ -307,7 +307,7 @@ try {
   result.pixelPass = pixels.pass;
   result.pixelDetails = pixels;
   result.errors = errors;
-  await page.screenshot({ path: `${shots}/recovery.png` });
+  await captureQaScreenshot(page, { path: `${shots}/recovery.png` });
   await writeFile(`${shots}/recovery.json`, JSON.stringify(result, null, 2));
   for (const key of ['on', 'off', 'onAgain', 'offAgain']) delete result[key];
   const pass =

scripts/qa-transit-scenes.mjs

@@ -1,3 +1,4 @@
+import { captureQaScreenshot } from './qa-chrome.mjs';
 import { getRegisteredTransitFeed } from '../src/data/transitFeeds.js';
 
 // Not registered or active: camera discovery and live polls never own this feed.
@@ -219,7 +220,7 @@ export async function runFleetBudgets({
         allocations.layerFrameBytes / allocationTrace.rows.length <= 8192,
       `${allocations.layerFrameBytes / allocationTrace.rows.length} transit-authored bytes/frame; whole frame ${allocations.frameBytes / allocationTrace.rows.length}; top three ${JSON.stringify(details.topAllocatorsPerFrame)}; collected objects included. Full profile saved.`,
     );
-    await page.screenshot({
+    await captureQaScreenshot(page, {
       path: `${shots}/${tag}-fleet-${count}.jpg`,
       type: 'jpeg',
       quality: 85,
@@ -392,7 +393,7 @@ export async function runBostonMatrix({
         JSON.stringify({ pixels, contrast }),
         { unexercised: pixels.length < 6 },
       );
-      await page.screenshot({
+      await captureQaScreenshot(page, {
         path: `${shots}/${tag}-matrix-${background.name}-${look.name}-fleet.jpg`,
         type: 'jpeg',
         quality: 90,
@@ -407,7 +408,7 @@ export async function runBostonMatrix({
           target.key,
         );
         await wait(500);
-        await page.screenshot({
+        await captureQaScreenshot(page, {
           path: `${shots}/${tag}-matrix-${background.name}-${look.name}-${target.route}-selected.jpg`,
           type: 'jpeg',
           quality: 90,
@@ -431,7 +432,7 @@ export async function runBostonMatrix({
         );
       }
       await wait(300);
-      await page.screenshot({
+      await captureQaScreenshot(page, {
         path: `${shots}/${tag}-matrix-${background.name}-${look.name}-restored.jpg`,
         type: 'jpeg',
         quality: 90,
@@ -579,7 +580,7 @@ export async function runBostonLive({
       JSON.stringify(selection),
       { unexercised: !target },
     );
-    await page.screenshot({
+    await captureQaScreenshot(page, {
       path: `${shots}/${tag}-boston-live-${view.name}.jpg`,
       type: 'jpeg',
       quality: 90,
@@ -1010,7 +1011,7 @@ export async function runTrailVisibility({
     stable: pixels.stable[i],
     eligible: pixels.eligible[i],
   }));
-  await page.screenshot({
+  await captureQaScreenshot(page, {
     path: `${shots}/${tag}-${altitude}m-trail-visible.jpg`,
     type: 'jpeg',
     quality: 95,

scripts/qa-transit.mjs

@@ -36,9 +36,11 @@ import {
  */
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import puppeteer from 'puppeteer';
+import { chromeExecutablePath, captureQaScreenshot } from './qa-chrome.mjs';
 import { createTransitHistory } from '../server/providers/transitHistory.js';
 import { DETECTION_THEME_MAP } from '../src/overlays/worldOverlayTokens.js';
 import { transitModeTier } from '../src/data/transitPresetStyle.js';
+import { TRANSIT_POLL_MS } from '../src/layers/transit/policy.js';
 
 import {
   reduceAnchor,
@@ -46,8 +48,6 @@ import {
   reduceScenario,
   reduceSensorContrast,
   reduceScriptedMotion,
-  reduceMotion,
-  reduceFleet,
 } from '../src/layers/transit/qaMetrics.js';
 
 const BASE = process.env.QA_BASE_URL || 'http://localhost:4173';
@@ -262,10 +262,10 @@ await mkdir(SHOTS, { recursive: true });
 const browser = await puppeteer.launch({
   headless: false,
   protocolTimeout: 150000,
-  executablePath:
-    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  executablePath: chromeExecutablePath(),
   args: [
     '--no-sandbox',
+    '--disable-backgrounding-occluded-windows',
     '--disable-background-timer-throttling',
     '--disable-renderer-backgrounding',
     '--window-size=1920,1080',
@@ -273,6 +273,10 @@ const browser = await puppeteer.launch({
   ],
 });
 const page = await browser.newPage();
+// This gate measures visible-page motion. OS minimization must not silently
+// switch it into the app's intentional hidden-tab polling pause.
+const focus = await page.createCDPSession();
+await focus.send('Emulation.setFocusEmulationEnabled', { enabled: true });
 boundPageEvaluations(page);
 await page.setViewport({ width: 1920, height: 1080 });
 const pageErrors = [];
@@ -288,11 +292,13 @@ page.on('request', (request) => {
 });
 
 const shot = (name, caption) =>
-  page
-    .screenshot({ path: `${SHOTS}/${name}`, type: 'jpeg', quality: 82 })
-    .then(() => {
-      console.log(`  shot ${name} — ${caption}`);
-    });
+  captureQaScreenshot(page, {
+    path: `${SHOTS}/${name}`,
+    type: 'jpeg',
+    quality: 82,
+  }).then(() => {
+    console.log(`  shot ${name} — ${caption}`);
+  });
 
 const view = (city) =>
   `${BASE}/?welcome=0#lat=${city.lat}&lon=${city.lon}&alt=600&heading=${city.heading}&pitch=-45`;
@@ -391,22 +397,42 @@ try {
         orientation: { heading: 0, pitch: (-40 * Math.PI) / 180, roll: 0 },
       });
     }, city);
-    await page.waitForFunction(
-      () =>
-        (window.__godsEyeView.dataManager.layers
-          .get('transit')
-          .module.getStats().count || 0) > 0,
-      { timeout: 90_000 },
-    );
+    const arrived = await page
+      .waitForFunction(
+        (feedId) =>
+          [
+            ...window.__godsEyeView.dataManager.layers
+              .get('transit')
+              .module._transitStateForTest()
+              ._vehicles.keys(),
+          ].some((key) => key.startsWith(`${feedId}:`)),
+        { timeout: 90_000 },
+        city.feedId,
+      )
+      .then(
+        () => true,
+        () => false,
+      );
+    if (!arrived) {
+      check(
+        `${city.label}: live feed arrived`,
+        false,
+        `No vehicles from ${city.feedId}; retained vehicles from other cities cannot qualify this view`,
+        { unexercised: true },
+      );
+      continue;
+    }
     await wait(9_000);
-    const fleet = await page.evaluate(() => {
+    const fleet = await page.evaluate((feedId) => {
       const layer =
         window.__godsEyeView.dataManager.layers.get('transit').module;
       return {
-        count: layer._transitStateForTest()._vehicles.size,
+        count: [...layer._transitStateForTest()._vehicles.keys()].filter(
+          (key) => key.startsWith(`${feedId}:`),
+        ).length,
         stats: layer.getStats(),
       };
-    });
+    }, city.feedId);
     check(
       `${city.label}: vehicles are rendered`,
       fleet.count >= 20,
@@ -428,6 +454,7 @@ try {
         .module._transitStateForTest();
       let best = null;
       for (const entry of state._vehicles.values()) {
+        if (!entry.key.startsWith(`${c.feedId}:`)) continue;
         const d = Math.hypot(entry.to.lat - c.lat, entry.to.lon - c.lon);
         if (!best || d < best.d)
           best = { d, lat: entry.to.lat, lon: entry.to.lon, key: entry.key };
@@ -1609,6 +1636,7 @@ try {
             m[3] * v[0] + m[7] * v[1] + m[11] * v[2] + m[15] * v[3],
           ];
           const frames = [];
+          const observedPolls = new Set();
           const publicationsBefore = state._cardPublications || 0;
           let headSamples = 0,
             headErrorPx = 0,
@@ -1625,6 +1653,13 @@ try {
                 const proj = scene.camera.frustum.projectionMatrix;
                 const p = entry.marker.position;
                 const clip = mul(proj, mul(view, [p.x, p.y, p.z, 1]));
+                if (
+                  entry.marker.show !== false &&
+                  rect &&
+                  Number.isFinite(entry.pollSeq)
+                ) {
+                  observedPolls.add(entry.pollSeq);
+                }
                 frames.push({
                   t: performance.now() - t0,
                   mx: ((clip[0] / clip[3]) * 0.5 + 0.5) * canvas.clientWidth,
@@ -1670,7 +1705,15 @@ try {
                   headSamples++;
                 }
               }
-              if (performance.now() - t0 >= durationMs) finish();
+              const elapsed = performance.now() - t0;
+              // Keep at least 20 seconds of motion and require an observed poll
+              // transition. A fixed 20s wall-clock window can miss a 15s poll
+              // when an earlier refresh is still settling.
+              if (
+                (elapsed >= 20_000 && observedPolls.size >= 2) ||
+                elapsed >= durationMs
+              )
+                finish();
             };
             let remove;
             const finish = () => {
@@ -1678,6 +1721,7 @@ try {
               remove?.();
               resolve({
                 selected: true,
+                elapsedMs: performance.now() - t0,
                 frames,
                 textPublishes:
                   (state._cardPublications || 0) - publicationsBefore,
@@ -1692,7 +1736,7 @@ try {
           });
         },
         target.key,
-        20_000,
+        3 * TRANSIT_POLL_MS,
       );
     }
     check(
@@ -1713,8 +1757,9 @@ try {
       );
       check(
         'card text publication stays throttled while the anchor runs at frame rate',
-        anchor.textPublishes > 0 && anchor.textPublishes <= 20_000 / 250 + 3,
-        `${anchor.textPublishes} text publications in 20 s`,
+        anchor.textPublishes > 0 &&
+          anchor.textPublishes <= anchor.elapsedMs / 250 + 3,
+        `${anchor.textPublishes} text publications in ${(anchor.elapsedMs / 1000).toFixed(1)} s`,
       );
     } else {
       check(

scripts/qa-ui-disposal.mjs

@@ -43,11 +43,7 @@ try {
     const fpsReadout = document.querySelector('.frame-rate-readout');
     const fpsWasVisible = fpsReadout && !fpsReadout.hidden;
     const watchObserver = (name) => {
-      const owner =
-        name === '_draggableResizeObserver'
-          ? ui._panelPosition
-          : ui._panelLayout;
-      const observer = owner[name];
+      const observer = ui._panelLayout[name];
       if (!observer) return false;
       const disconnect = observer.disconnect.bind(observer);
       counts[name] = 0;
@@ -59,7 +55,6 @@ try {
     };
     const observed = [
       '_commandDockTrayObserver',
-      '_draggableResizeObserver',
       '_leftStackResizeObserver',
       '_rightStackResizeObserver',
       '_leftStackMutationObserver',
@@ -139,7 +134,6 @@ try {
       const focusBefore = document.activeElement;
       const stoppedBeforeRestoration =
         ui._panelLayout.destroyed &&
-        ui._panelPosition.destroyed &&
         ui._feedback.destroyed &&
         ui._recording.destroyed &&
         cockpit.destroyed &&
@@ -194,11 +188,7 @@ try {
               counts[field] === 1 && ui._contextControls[field] === null,
           ),
         observersReleased: observed.every(
-          (name) =>
-            counts[name] === 1 &&
-            (name === '_draggableResizeObserver'
-              ? ui._panelPosition
-              : ui._panelLayout)[name] === null,
+          (name) => counts[name] === 1 && ui._panelLayout[name] === null,
         ),
         subscriptionReleased:
           counts.cctv === 1 && ui._cctvControls._cctvUnsubscribe === null,

scripts/qa-vessel-cards.mjs

@@ -295,7 +295,7 @@ async function main() {
       );
 
       // Wait for the photoreal tileset and at least one vessel refresh.
-      const settled = await page
+      await page
         .waitForFunction(() => {
           const gev = window.__godsEyeView;
           const t = gev.tileset;

scripts/qa-visual-effects.mjs

@@ -80,7 +80,6 @@ try {
     'thermal',
     'anime',
     'noir',
-    'snow',
     'normal',
   ]) {
     await page.evaluate(

scripts/qa-visual-input.mjs

@@ -183,6 +183,38 @@ try {
       return manager.bloomEnabled !== before;
     }),
   );
+  const sliders = await page.evaluate(() => {
+    const ordinary = [
+      ...document.querySelectorAll('input[type="range"]'),
+    ].filter(
+      (input) => !input.matches('#radio-tuner-slider, .bhote-event-range'),
+    );
+    return {
+      count: ordinary.length,
+      shared: ordinary.every((input) =>
+        input.classList.contains('gev-quantitative-slider'),
+      ),
+      surface: ordinary.every((input) => {
+        const style = getComputedStyle(input);
+        return (
+          style.height === '18px' &&
+          style.appearance === 'none' &&
+          style.padding === '0px' &&
+          style.borderWidth === '0px' &&
+          (!input.disabled ||
+            (style.opacity === '0.42' && style.cursor === 'not-allowed'))
+        );
+      }),
+      tunerSeparate: !document
+        .getElementById('radio-tuner-slider')
+        .classList.contains('gev-quantitative-slider'),
+    };
+  });
+  check(
+    'ordinary sliders share one native surface',
+    sliders.count > 10 && sliders.shared && sliders.surface,
+  );
+  check('radio tuning keeps its specialized control', sliders.tunerSeparate);
   fs.mkdirSync('qa-shots/visual-input', { recursive: true });
   await page.screenshot({ path: 'qa-shots/visual-input/desktop.png' });
   await page.setViewport({ width: 620, height: 900 });

scripts/qa-voice-routing.mjs

@@ -1745,8 +1745,9 @@ async function runBehaviorLayer() {
       'behavior: analyst follow-up re-filters the remembered set',
       `count=${r?.count} followUp=${r?.coverage?.followUp}`,
     );
-    // A marine region resolves from the bundled Natural Earth pack in the page,
-    // without the slower geocode fallback.
+    // Require the bundled boundary source and the existing whole-query limit.
+    // This elapsed time includes record acquisition and filtering; the region
+    // resolver has its own separate fallback budget.
     const gulfStarted = Date.now();
     r = await run('analyst_query', {
       layers: ['flights'],
@@ -1757,9 +1758,10 @@ async function runBehaviorLayer() {
     report(
       r?.ok === true &&
         String(r?.coverage?.scope || '').includes('Gulf of Mexico') &&
+        r?.coverage?.scopeSource === 'natural-earth' &&
         gulfMs < 3000,
       'behavior: analyst resolves the Gulf of Mexico from the bundled pack',
-      `scope=${r?.coverage?.scope} ms=${gulfMs} err=${r?.error || ''}`,
+      `scope=${r?.coverage?.scope} source=${r?.coverage?.scopeSource} ms=${gulfMs} err=${r?.error || ''}`,
     );
 
     // (5) zoom_to_globe is ABSOLUTE full-earth (>12,000 km band)

scripts/qa-weather-swap.mjs

@@ -8,13 +8,7 @@
  *   node scripts/qa-weather-swap.mjs --url http://localhost:4173 --label google
  *     [--layer weather-satellite] [--product clouds] [--headless]
  */
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  writeFileSync,
-} from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import puppeteer from 'puppeteer';
 

scripts/qa-weather-teardown.mjs

@@ -61,6 +61,10 @@ const browser = await puppeteer.launch({
 
 const boot = async () => {
   const page = await browser.newPage();
+  // This probe measures active rendering; an OS-minimized window must not
+  // silently exercise the application's intentional hidden-page pause.
+  const focus = await page.createCDPSession();
+  await focus.send('Emulation.setFocusEmulationEnabled', { enabled: true });
   await page.setViewport({ width: 1400, height: 920, deviceScaleFactor: 1 });
   const errors = [];
   page.on('pageerror', (e) =>
@@ -141,7 +145,7 @@ const snapshot = (page) =>
         ),
       },
       weather,
-      windCells: wind.gpu?.pathCount ?? wind.paths ?? null,
+      windCells: wind.gpu?.pathCount ?? wind.paths ?? 0,
       enabled: [...dm.layers].filter(([, e]) => e.enabled).map(([id]) => id),
     };
   });
@@ -220,7 +224,7 @@ try {
   const baseline = await snapshot(a.page);
   console.log('baseline', JSON.stringify(baseline));
   for (const id of WEATHER) await setLayer(a.page, id, true);
-  await a.page
+  const weatherReady = await a.page
     .waitForFunction(
       () =>
         ['weather-radar', 'weather-satellite', 'weather-lightning'].every(
@@ -233,7 +237,13 @@ try {
         ),
       { timeout: 120_000 },
     )
-    .catch(() => console.log('  !! weather not ready'));
+    .then(
+      () => true,
+      () => false,
+    );
+  results.weatherReady = weatherReady;
+  if (!weatherReady)
+    console.log('  !! weather not ready — feature coverage incomplete');
   await sleep(2000);
   // exercise: history playback, wind reading, storm selection, product switch
   await a.page.evaluate(() => {
@@ -331,11 +341,25 @@ try {
     'errors (control run):',
     results.errorsB.length ? results.errorsB : 'none',
   );
+  // Resource ownership is an acceptance check; provider availability remains
+  // separately reported diagnostic evidence in both runs.
+  if (
+    !weatherReady ||
+    Object.keys(leak).length ||
+    [...a.errors, ...b.errors].some((e) => e.startsWith('pageerror:'))
+  ) {
+    process.exitCode = 1;
+  }
+} catch (error) {
+  results.failure = { name: error.name, message: error.message };
+  throw error;
+} finally {
+  // Preserve completed resource evidence even if a later provider or browser
+  // phase aborts. A partial run still exits nonzero.
   writeFileSync(
     path.join(outDir, 'results.json'),
     JSON.stringify(results, null, 2),
   );
   console.log(`wrote ${path.join(outDir, 'results.json')}`);
-} finally {
   await browser.close();
 }

scripts/run-unit-tests.mjs

@@ -1,7 +1,7 @@
 import { readdirSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { pathToFileURL } from 'node:url';
 
 export const ALLOCATION_TEST_FILES = Object.freeze([
   'src/data/focusAllocations.test.mjs',
@@ -21,9 +21,20 @@ export function assertNode24AllocationRuntime(version = process.versions.node) {
   return version;
 }
 
+/**
+ * Directories this runner searches for `*.test.mjs`, in stable order.
+ *
+ * `server/` belongs here because provider modules own tests of their own: a
+ * suite placed beside the module it covers must run, and CI's unit-test job runs
+ * `npm test`, so a directory missing from this list is a suite that never runs
+ * there. `unitTestRunner.test.mjs` asserts the list covers every `*.test.mjs`
+ * outside dependencies, build output and dot-directories, so adding a tree
+ * without adding it here fails.
+ */
+export const UNIT_TEST_ROOTS = Object.freeze(['src', 'server']);
+
 /** Discover repository unit tests in stable path order. */
 export function discoverUnitTestFiles(root = process.cwd()) {
-  const sourceRoot = path.join(root, 'src');
   const files = [];
   const visit = (directory) => {
     for (const entry of readdirSync(directory, { withFileTypes: true })) {
@@ -34,7 +45,7 @@ export function discoverUnitTestFiles(root = process.cwd()) {
       }
     }
   };
-  visit(sourceRoot);
+  for (const testRoot of UNIT_TEST_ROOTS) visit(path.join(root, testRoot));
   return files.sort();
 }
 

scripts/setup-doctor.mjs

@@ -76,10 +76,15 @@ export function hasRequiredDependencies(rootDir = ROOT) {
   }
 }
 
-/** Return the npm command and spawn mode required by the target platform. */
-export function npmProcessSpec(platform = process.platform) {
-  const windows = platform === 'win32';
-  return { command: windows ? 'npm.cmd' : 'npm', shell: windows };
+/**
+ * Return the npm command, arguments and spawn mode for the target platform.
+ * Windows must run npm.cmd through a shell, and Node 24 deprecates passing an
+ * argument array with `shell: true` (DEP0190), so there the arguments, which
+ * are fixed npm subcommands, join the command string.
+ */
+export function npmProcessSpec(args, platform = process.platform) {
+  if (platform !== 'win32') return { command: 'npm', args, shell: false };
+  return { command: ['npm.cmd', ...args].join(' '), args: [], shell: true };
 }
 
 /** Read one key from Vite's dotenv file ladder without depending on Vite. */
@@ -119,6 +124,19 @@ export function resolveOpenSkyAuthMode({
   return OPENSKY_AUTH_MODES.has(mode) ? mode : OPENSKY_AUTH_MODE_DEFAULT;
 }
 
+/** Whether OPENSKY_CREDENTIALS_FILE is set, with the same precedence as the auth mode. The server reads that file when the client id and secret are empty. */
+export function resolveOpenSkyCredentialsFile({
+  authoritativeEnvironment = false,
+  environment = process.env,
+  rootDir = ROOT,
+} = {}) {
+  const environmentDefines = Object.prototype.hasOwnProperty.call(environment, 'OPENSKY_CREDENTIALS_FILE');
+  const value = authoritativeEnvironment && environmentDefines
+    ? String(environment.OPENSKY_CREDENTIALS_FILE || '')
+    : String(environment.OPENSKY_CREDENTIALS_FILE || '') || readDoctorDotenvValue('OPENSKY_CREDENTIALS_FILE', rootDir);
+  return isConfiguredValue(value.trim());
+}
+
 function hasKeychainItem(service, account) {
   if (process.platform !== 'darwin') return false;
   const result = spawnSync('security', [
@@ -148,10 +166,11 @@ export function resolveCredential(spec, {
 
 export function buildCapabilitySummary(
   credentials,
-  { openSkyAuthMode = OPENSKY_AUTH_MODE_DEFAULT } = {},
+  { openSkyAuthMode = OPENSKY_AUTH_MODE_DEFAULT, openSkyCredentialsFile = false } = {},
 ) {
   const configured = (name) => credentials[name]?.configured === true;
-  const hasOAuthCredentials = configured('OPENSKY_CLIENT_ID') && configured('OPENSKY_CLIENT_SECRET');
+  const hasClientPair = configured('OPENSKY_CLIENT_ID') && configured('OPENSKY_CLIENT_SECRET');
+  const hasOAuthCredentials = hasClientPair || openSkyCredentialsFile === true;
   const requestedOpenSkyMode = String(openSkyAuthMode || '').trim().toLowerCase();
   const openSkyMode = OPENSKY_AUTH_MODES.has(requestedOpenSkyMode)
     ? requestedOpenSkyMode
@@ -159,11 +178,13 @@ export function buildCapabilitySummary(
   const flights = openSkyMode === 'anon'
     ? 'OpenSky keyless anonymous access (rate-limited)'
     : openSkyMode === 'basic'
-      ? 'OpenSky Basic mode selected (credential presence and validity not verified)'
+      ? 'OpenSky Basic mode selected: OpenSky retired username/password sign-in, so flights load anonymously (rate-limited)'
       : openSkyMode === 'auto'
         ? 'OpenSky auto mode selected (runtime credential choice and validity not verified)'
-        : hasOAuthCredentials
+        : hasClientPair
           ? 'OpenSky OAuth credentials present (runtime mode and validity not verified)'
+          : hasOAuthCredentials
+            ? 'OpenSky OAuth credentials file set (OPENSKY_CREDENTIALS_FILE; file contents and validity not verified)'
           : 'OpenSky keyless anonymous access (rate-limited)';
   const route = selectMapStartupRoute({
     googleApiKey: configured('GOOGLE_MAPS_API_KEY') ? 'configured' : '',
@@ -190,8 +211,8 @@ export function buildCapabilitySummary(
 
 export function inspectSetup({ includeKeychain = true, authoritativeEnvironment = false, rootDir = ROOT } = {}) {
   const node = classifyNodeVersion();
-  const npm = npmProcessSpec();
-  const npmResult = spawnSync(npm.command, ['--version'], {
+  const npm = npmProcessSpec(['--version']);
+  const npmResult = spawnSync(npm.command, npm.args, {
     encoding: 'utf8',
     shell: npm.shell,
   });
@@ -210,6 +231,7 @@ export function inspectSetup({ includeKeychain = true, authoritativeEnvironment
     credentials,
     capabilities: buildCapabilitySummary(credentials, {
       openSkyAuthMode: resolveOpenSkyAuthMode({ authoritativeEnvironment, rootDir }),
+      openSkyCredentialsFile: resolveOpenSkyCredentialsFile({ authoritativeEnvironment, rootDir }),
     }),
   };
 }

scripts/shot-sink.mjs

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-// Minimal screenshot sink: the browser POSTs a data:image/... URL (grabbed from
-// the real-GPU Cesium canvas) and this writes it to qa-shots/height-datum/<name>.
-// Keeps large image payloads OUT of the agent's context — browser → sink → disk.
-// Usage: node scripts/shot-sink.mjs   (listens on :4399)
-import http from 'node:http';
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import path from 'node:path';
-
-const OUT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'qa-shots', 'height-datum');
-mkdirSync(OUT, { recursive: true });
-const PORT = 4399;
-
-const cors = (res) => {
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-};
-
-http.createServer((req, res) => {
-  cors(res);
-  if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
-  const url = new URL(req.url, 'http://localhost');
-  if (req.method === 'POST' && url.pathname === '/save') {
-    const name = (url.searchParams.get('name') || 'shot').replace(/[^a-zA-Z0-9._-]/g, '_');
-    let body = '';
-    req.on('data', (c) => { body += c; });
-    req.on('end', () => {
-      try {
-        const m = /^data:image\/(png|jpeg);base64,(.+)$/s.exec(body.trim());
-        if (!m) { res.writeHead(400); res.end('bad dataurl'); return; }
-        const ext = m[1] === 'jpeg' ? 'jpg' : 'png';
-        const file = path.join(OUT, `${name}.${ext}`);
-        writeFileSync(file, Buffer.from(m[2], 'base64'));
-        res.writeHead(200); res.end(file);
-        console.log(`saved ${file} (${Math.round(m[2].length / 1024)} KB b64)`);
-      } catch (e) { res.writeHead(500); res.end(String(e)); }
-    });
-    return;
-  }
-  res.writeHead(404); res.end('nope');
-}).listen(PORT, () => console.log(`shot-sink on http://localhost:${PORT} → ${OUT}`));

scripts/track-regression.mjs

@@ -94,6 +94,7 @@
 
 import fs from 'node:fs';
 import puppeteer from 'puppeteer';
+import { arrivalRotationPassed } from '../src/tooling/trackArrivalObservation.mjs';
 import { classifyAircraft, CLASS_SCALE_3D, CLASS_MODEL_REAL } from '../src/data/aircraftClass.js';
 import { ensureGeoidReady, geoidHeight } from '../src/data/geoid.js';
 
@@ -443,7 +444,10 @@ async function main() {
         // for nearby names. Answer both with empty results: the entity-context
         // assertions are about the SELECTED contact, and a live lookup would
         // make the run non-hermetic (and bill the owner's Google quota).
-        if (url.hostname === 'maps.googleapis.com' && url.pathname.startsWith('/maps/api/geocode')) {
+        if (
+          isAppRequest &&
+          (url.pathname === '/api/google/reverse-geocode' || url.pathname === '/api/google/geocode')
+        ) {
           return Promise.resolve(jsonResponse({ status: 'ZERO_RESULTS', results: [] }));
         }
         if (isAppRequest && url.pathname === '/api/google/nearby-places') {
@@ -2692,16 +2696,17 @@ async function main() {
     //       reappear wearing its stale/creation-north nose for up to 1 s).
     // Staged deterministically: park the camera nadir over the synthetic
     // cluster, let rotations settle, TAMPER a billboard's rotation, then
-    // trigger each path with the camera idle. The idle-drift catch-up
-    // (ROTATION_REFRESH_MS = 1 s) can coincidentally mask a regression in a
-    // ~300 ms SwiftShader frame window, so a regression shows as an
-    // intermittent (not guaranteed) failure — never a false failure.
+    // trigger each path with the camera idle. The fleet runs every 80 ms,
+    // independently of rendered FPS. Observe the first completed settle and
+    // reveal frames within 500 ms of forcing moveEnd, before the 1 s idle
+    // rotation refresh can repair an incorrect first reveal.
     // ============================================================
     console.log('\nChange 4 — arrival rotation: moveEnd settle pass + horizon-reveal pass');
     const arrival = await evalPage(async () => {
       const v = window.__godsEyeView.viewer;
       const dm = window.__godsEyeView.dataManager;
       const { screenProjectedRotation } = await import(`${window.__gevQaSourceBase || '/src'}/data/iconOrientation.js`);
+      const { observeArrivalRotation } = await import(`${window.__gevQaSourceBase || '/src'}/tooling/trackArrivalObservation.mjs`);
       // 3D models OFF for this phase: a model-handed-off billboard is hidden
       // and skips rotation updates entirely — the probes need live billboards
       // (this is also the app's default state the field report came from).
@@ -2763,39 +2768,29 @@ async function main() {
         const bb = findBB(id);
         if (!bb || !bb.show) return { error: `${id} missing/hidden` };
         const r0 = bb.rotation; // settled tamper origin; correctness uses a fresh projection below
-        // (a) settle pass: tamper, then raise moveEnd with the camera IDLE —
-        // the pose signature is unchanged, so only the moveEnd hook can fix
-        // this before the 1 s catch-up.
-        bb.rotation = r0 + 1.5;
-        v.camera.moveEnd.raiseEvent();
-        await nextFrames(2);
-        const afterMoveEnd = bb.rotation;
-        // A real-GPU fleet tick can land near the edge of the frame budget and
-        // advance the contact before the probe reads it. Compare with the
-        // production projection at the CURRENT position, not the now-stale r0.
-        const expectedMoveEnd = screenProjectedRotation(v.scene, bb.position, course, null);
-        // (b) reveal pass: tamper + hide — the next fleet tick must flip it
-        // visible AND correct the nose in that same tick (camera still idle,
-        // no moveEnd raised). Diagnostic fields (round 5): record WHICH frame
-        // the flip landed on (flipFrame; -1 = never within the extended
-        // window) and whether a 3D model owns this id — distinguishes "tick
-        // slow under load" from "occluder says hidden" from "model handoff".
-        bb.rotation = r0 + 1.5;
-        bb.show = false;
-        let flipFrame = -1;
-        for (let f = 1; f <= 6; f++) {
-          await nextFrames(1);
-          if (bb.show && flipFrame === -1) flipFrame = f;
-          if (f >= 2 && flipFrame !== -1) break;
-        }
-        const expectedReveal = screenProjectedRotation(v.scene, bb.position, course, null);
+        const observed = await observeArrivalRotation({
+          scene: v.scene,
+          startMoveEnd() {
+            // Only moveEnd can repair the tampered angle at the idle pose.
+            bb.rotation = r0 + 1.5;
+            v.camera.moveEnd.raiseEvent();
+          },
+          startReveal() {
+            // Hide immediately after the confirmed settle frame. The next
+            // eligible fleet tick must reveal AND re-aim in that same tick.
+            bb.rotation = r0 + 1.5;
+            bb.show = false;
+          },
+          read() {
+            return {
+              shown: bb.show,
+              rotationError: angDiff(bb.rotation,
+                screenProjectedRotation(v.scene, bb.position, course, null)),
+            };
+          },
+        });
         const hasModel = !!(window.__g3dFindModel && window.__g3dFindModel(id));
-        return {
-          r0,
-          dMoveEnd: angDiff(afterMoveEnd, expectedMoveEnd),
-          dReveal: angDiff(bb.rotation, expectedReveal),
-          shown: bb.show, flipFrame, hasModel,
-        };
+        return { r0, ...observed, hasModel };
       };
       const flightCourse = window.__SYNTH.flights.find((f) => f.icao === 'aaa002')?.track ?? 0;
       const militaryCourse = window.__SYNTH.military.find((m) => m.hex === 'bbb101')?.track ?? 0;
@@ -2804,22 +2799,13 @@ async function main() {
         military: await probe('bbb101', militaryCourse),
       };
     });
-    const fmtArr = (a) => (!a ? `no result (${arrival?.error || 'phase error'})` : a.error ? a.error
-      : `settle-err=${(a.dMoveEnd * 180 / Math.PI).toFixed(1)}° reveal-err=${(a.dReveal * 180 / Math.PI).toFixed(1)}° shown=${a.shown} flipFrame=${a.flipFrame} hasModel=${a.hasModel}`);
+    const fmtArr = (a) => (!a ? `no result (${arrival?.error || 'phase error'})` : a.error ? `${a.error}; elapsed=${Number(a.elapsedMs).toFixed(1)} ms`
+      : `settle-err=${(a.dMoveEnd * 180 / Math.PI).toFixed(1)}° reveal-err=${(a.dReveal * 180 / Math.PI).toFixed(1)}° shown=${a.shown} flipFrame=${a.flipFrame} settle=${a.moveEndMs.toFixed(1)} ms reveal=${a.revealMs.toFixed(1)} ms total=${a.elapsedMs.toFixed(1)} ms hasModel=${a.hasModel}`);
     const TAMPER_DEG = 1.5 * 180 / Math.PI; // ≈ 86° — an uncorrected nose stays this far off
-    // Reveal budget re-pinned 2 → 4 frames (round 5): the diagnostic probe
-    // shows the military flip consistently lands on frame 2 — the exact edge
-    // of the old budget — so any load hiccup flaked it (flights lands frame
-    // 1). The regression this protects against is a reveal that waits for
-    // the 1 s idle catch-up (~30-60 frames) or never re-aims; 4 frames still
-    // catches that with a wide margin, with zero-headroom flakes gone.
-    const arrOk = (a) => !!a && !a.error && a.shown
-      && (a.flipFrame === -1 ? false : a.flipFrame <= 4)
-      && a.dMoveEnd * 180 / Math.PI < 10 && a.dReveal * 180 / Math.PI < 10;
-    record(`arrival: moveEnd + reveal both re-aim within 4 frames, flights (tamper was ${TAMPER_DEG.toFixed(0)}°)`,
-      arrOk(arrival.flights), fmtArr(arrival.flights));
-    record(`arrival: moveEnd + reveal both re-aim within 4 frames, military (tamper was ${TAMPER_DEG.toFixed(0)}°)`,
-      arrOk(arrival.military), fmtArr(arrival.military));
+    record(`arrival: moveEnd + first reveal both re-aim before idle refresh, flights (tamper was ${TAMPER_DEG.toFixed(0)}°)`,
+      arrivalRotationPassed(arrival.flights), fmtArr(arrival.flights));
+    record(`arrival: moveEnd + first reveal both re-aim before idle refresh, military (tamper was ${TAMPER_DEG.toFixed(0)}°)`,
+      arrivalRotationPassed(arrival.military), fmtArr(arrival.military));
 
     // ============================================================
     // DISPLAY FLOOR (2026-08-19): a grounded contact must never render below

scripts/traffic-fixtures.mjs

@@ -1,56 +1,175 @@
-import { readFileSync } from 'node:fs';
-import { decodeFlowTile } from '../src/layers/traffic/flowDecode.js';
-import { tilesForBounds } from '../src/data/tomtomTiles.js';
+import { PbfWriter } from 'pbf';
 
-const tile = readFileSync(
-  new URL(
-    '../src/data/fixtures/tomtom-flow-austin-12-935-1686.pbf',
-    import.meta.url,
-  ),
-);
+const corsHeaders = { 'access-control-allow-origin': '*' };
 const json = (body) => ({
   status: 200,
+  headers: corsHeaders,
   contentType: 'application/json',
   body: JSON.stringify(body),
 });
 
-/** Reuse the recorded flow tile for an explicitly synthetic browser exercise. */
+// Cesium heightmap-1.0: 65x65 little-endian uint16 heights, scale .2,
+// offset -1000, followed by child availability and a uniform land mask.
+const flatTerrain = Buffer.alloc(65 * 65 * 2 + 2);
+for (let i = 0; i < 65 * 65; i++) flatTerrain.writeUInt16LE(5000, i * 2);
+
+/** Synthetic, geographically aligned motor roads at both source zooms. */
+export function trafficFixtureTile(zoom, flow = false) {
+  const writer = new PbfWriter();
+  writer.writeMessage(
+    3,
+    (_, layer) => {
+      layer.writeVarintField(15, 2);
+      layer.writeStringField(1, flow ? 'Traffic flow' : 'transportation');
+      layer.writeVarintField(5, 4096);
+      layer.writeStringField(3, flow ? 'traffic_level' : 'class');
+      layer.writeMessage(
+        4,
+        (_, value) => {
+          if (flow) value.writeDoubleField(3, 0.6);
+          else value.writeStringField(1, 'primary');
+        },
+        null,
+      );
+      if (flow) {
+        layer.writeStringField(3, 'road_type');
+        layer.writeMessage(
+          4,
+          (_, value) => value.writeStringField(1, 'Major road'),
+          null,
+        );
+      }
+      // z12 has four times the span of z14. Keep the same world spacing,
+      // and cover only alternate roads with flow to exercise hide/sim controls.
+      const step = 256 * 2 ** (zoom - 14);
+      for (let y = step; y < 4096; y += step) {
+        if (flow && (y / step) % 2) continue;
+        layer.writeMessage(
+          2,
+          (_, feature) => {
+            feature.writeVarintField(3, 2);
+            feature.writePackedVarint(2, flow ? [0, 0, 1, 1] : [0, 0]);
+            feature.writePackedVarint(4, [9, 0, y * 2, 10, 8192, 0]);
+          },
+          null,
+        );
+      }
+    },
+    null,
+  );
+  return Buffer.from(writer.finish());
+}
+
+/** Intercept the current vector sources; never fall through to live roads. */
 export function trafficFixtureResponse(request) {
   const url = new URL(request.url());
+  if (url.hostname === 'terrain.reearth.land') {
+    if (url.pathname.endsWith('/layer.json'))
+      return json({
+        tilejson: '2.1.0',
+        format: 'heightmap-1.0',
+        version: 'qa-flat',
+        scheme: 'tms',
+        projection: 'EPSG:4326',
+        minzoom: 0,
+        maxzoom: 0,
+        tiles: ['{z}/{x}/{y}.terrain?v={version}'],
+        available: [[{ startX: 0, startY: 0, endX: 1, endY: 0 }]],
+        attribution:
+          'Synthetic flat terrain for Traffic QA; not live elevation data',
+      });
+    if (/\/0\/[01]\/0\.terrain$/.test(url.pathname))
+      return {
+        status: 200,
+        contentType: 'application/octet-stream',
+        headers: corsHeaders,
+        body: flatTerrain,
+      };
+    throw new Error(`Unexpected terrain fixture request: ${url.pathname}`);
+  }
   if (url.pathname === '/api/tomtom/status')
     return json({ hasKey: true, dailyCount: 0 });
-  if (/^\/api\/tomtom\/flow\/\d+\/\d+\/\d+\.pbf$/.test(url.pathname))
-    return { status: 200, contentType: 'application/x-protobuf', body: tile };
-  if (url.pathname !== '/api/overpass') return null;
-  const query = new URLSearchParams(request.postData()).get('data') || '';
-  if (!query.includes('highway')) return null;
-  const match = query.match(/\((-?[\d.]+),(-?[\d.]+),(-?[\d.]+),(-?[\d.]+)\)/);
-  if (!match) throw new Error('Missing road fixture viewport');
-  const [south, west, north, east] = match.slice(1).map(Number);
-  const inside = ([lon, lat]) =>
-    lat >= south && lat <= north && lon >= west && lon <= east;
-  const segments = tilesForBounds({ south, west, north, east }, 12).flatMap(
-    ({ z, x, y }) => decodeFlowTile(tile, z, x, y),
+  const flow = url.pathname.match(
+    /^\/api\/tomtom\/flow\/(\d+)\/\d+\/\d+\.pbf$/,
   );
-  const elements = segments
-    .filter((segment) => segment.coords.some(inside))
-    .slice(0, 240)
-    .map((segment, index) => ({
-      type: 'way',
-      id: index + 1,
-      tags: { highway: 'primary', oneway: 'yes' },
-      geometry: segment.coords.map(([lon, lat]) => ({ lon, lat })),
-    }));
-  const latitude = (south + north) / 2,
-    longitude = (west + east) / 2;
-  elements.push({
-    type: 'way',
-    id: 99999,
-    tags: { highway: 'residential' },
-    geometry: [
-      { lat: latitude, lon: longitude },
-      { lat: latitude + 0.003, lon: longitude + 0.003 },
-    ],
+  if (flow)
+    return {
+      status: 200,
+      contentType: 'application/x-protobuf',
+      headers: corsHeaders,
+      body: trafficFixtureTile(Number(flow[1]), true),
+    };
+  if (url.hostname !== 'tiles.openfreemap.org') return null;
+  if (url.pathname === '/planet')
+    return json({
+      tilejson: '3.0.0',
+      minzoom: 0,
+      maxzoom: 14,
+      tiles: ['https://tiles.openfreemap.org/qa-traffic/{z}/{x}/{y}.pbf'],
+    });
+  const road = url.pathname.match(/^\/qa-traffic\/(\d+)\/\d+\/\d+\.pbf$/);
+  if (!road)
+    throw new Error(`Unrecognized road fixture request: ${url.pathname}`);
+  return {
+    status: 200,
+    contentType: 'application/x-protobuf',
+    headers: corsHeaders,
+    body: trafficFixtureTile(Number(road[1])),
+  };
+}
+
+/** Intercept provider URLs only; Cesium worker/module loading stays untouched. */
+export async function installTrafficRoutes(
+  page,
+  {
+    origin,
+    fixtures = false,
+    keyless = false,
+    onFlow = () => {},
+    onError = () => {},
+  },
+) {
+  const session = await page.createCDPSession();
+  const patterns = [
+    `${origin}/api/tomtom/status*`,
+    `${origin}/api/tomtom/flow/*`,
+    ...(fixtures
+      ? ['https://tiles.openfreemap.org/*', 'https://terrain.reearth.land/*']
+      : []),
+  ].map((urlPattern) => ({ urlPattern, requestStage: 'Request' }));
+  session.on('Fetch.requestPaused', async ({ requestId, request }) => {
+    try {
+      const url = new URL(request.url);
+      let response;
+      if (keyless && url.pathname === '/api/tomtom/status') {
+        response = json({ hasKey: false });
+      } else if (keyless && url.pathname.startsWith('/api/tomtom/flow/')) {
+        onFlow(request.url);
+        response = { ...json({ error: 'no_key' }), status: 503 };
+      } else if (fixtures) {
+        response = trafficFixtureResponse({ url: () => request.url });
+      }
+      if (!response) {
+        await session.send('Fetch.continueRequest', { requestId });
+        return;
+      }
+      await session.send('Fetch.fulfillRequest', {
+        requestId,
+        responseCode: response.status,
+        responseHeaders: Object.entries({
+          'content-type': response.contentType,
+          ...response.headers,
+        }).map(([name, value]) => ({ name, value })),
+        body: Buffer.from(response.body).toString('base64'),
+      });
+    } catch (error) {
+      if (page.isClosed()) return;
+      onError(error);
+      await session
+        .send('Fetch.failRequest', { requestId, errorReason: 'Failed' })
+        .catch(() => {});
+    }
   });
-  return json({ elements });
+  await session.send('Fetch.enable', { patterns });
+  return session;
 }

scripts/voice-bench/phrases.mjs

@@ -116,6 +116,9 @@ export const CORE_PHRASES = Object.freeze([
   // — camera verbs (tools #23/#24) —
   { phrase: 'Orbit around this area slowly', expect: 'move_camera', typedArgs: [where('move_camera', (a) => a.motion === 'orbit' && a.speed === 'slow')] },
   { phrase: 'Pan left a bit', expect: 'move_camera', typedArgs: [where('move_camera', (a) => a.motion === 'pan' && a.direction === 'left')] },
+  { phrase: 'Rotate the globe to the right', expect: 'move_camera', typedArgs: [where('move_camera', (a) => a.motion === 'rotate_globe' && (a.direction === undefined || a.direction === 'right'))] },
+  { phrase: 'Keep spinning the Earth slowly to the left', expect: 'move_camera', typedArgs: [where('move_camera', (a) => a.motion === 'rotate_globe' && a.direction === 'left' && a.speed === 'slow' && (a.mode === undefined || a.mode === 'continuous'))] },
+  { phrase: 'Turn the camera to look right', expect: 'move_camera', typedArgs: [where('move_camera', (a) => a.motion === 'rotate' && a.direction === 'right')] },
   { phrase: 'Stop moving the camera', expect: 'move_camera', typedArgs: [where('move_camera', (a) => a.motion === 'stop')] },
   { phrase: 'Fly the route we just drew', expect: 'fly_route' },