Merge branch 'main' into german/street-level-slim

scripts/format-scope.json

@@ -443,6 +443,7 @@
   "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",
@@ -1059,5 +1060,6 @@
   "scripts/assemble-changelog.mjs",
   "src/tooling/changelogFragments.test.mjs",
   "src/data/gbfsProxyRateLimit.test.mjs",
+  "src/data/routeSegment.test.mjs",
   "src/terrainHeightsBounds.test.mjs"
 ]

scripts/precompute-cctv-heights.mjs

@@ -326,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();

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(