Skip to content

A spy satellite simulator in your browser, except the data is real. Live open source spatial intelligence on a photorealistic 3D globe.

222 KB
Raw Blame
#!/usr/bin/env node
/**
 * track-regression.mjs
 *
 * DETERMINISTIC regression harness for 3D flight TRACKING.
 *
 * Background: tracked-plane 3D has regressed FOUR times (flicker → freeze →
 * jitter → pull-out → cross-layer orphan), each fix sometimes revealing the
 * next. This script locks the invariants so they can't silently break again.
 *
 * It drives the REAL app (http://localhost:4173) in headless Chromium with the
 * same WebGL launch flags the existing Cesium render harness uses
 * (tools/cesium-render.mjs): --use-gl=angle / --use-angle=swiftshader.
 *
 * DETERMINISM: it does NOT depend on live OpenSky / adsb.lol / AISStream
 * (all optional or rate-limited in local QA). Instead it installs a persistent
 * `fetch` shim in the page that intercepts the poll endpoints and returns
 * SYNTHETIC aircraft positioned near the camera, in the EXACT upstream payload
 * shapes the layers parse:
 *   - flights  → GET /api/flights      → { states: [ <state-vector[]> ] }
 *   - military → GET /api/military  → { ac: [ <adsblol-aircraft{}> ] }
 *   - vessels  → GET /api/vessels     → connected, zero-row snapshot
 * The shim stays installed so the layers' setInterval pollers keep the
 * synthetic planes alive (under MISSING_POLL_LIMIT=3 so they're never pruned).
 *
 * The four invariants, each one assertion block:
 *   1. NO JITTER          — the tracked plane's 3D MODEL position and its
 *                           getDetectableObjects() (HUD/detection) position use
 *                           the SAME per-frame value. We sample both over ~30
 *                           frames and assert max|visual-centre−detectable| ≈ 0.
 *   2. NO PULL-OUT        — tracking plane B while tracking A must not fly the
 *                           camera to a high overview (deselect/switch never
 *                           moves the camera — it stays in the follow band).
 *   3. NO CROSS-LAYER     — tracking military then commercial (and vice versa)
 *      ORPHAN               clears the FIRST layer (its getTrackedInfo()===null),
 *                           via the per-layer viewer.trackedEntityChanged listener.
 *   4. INIT CLEAN         — app loads, all 12 layers present, no console errors,
 *                           [Detection] Initialized + [TrackedReadout] Initialized.
 *
 * Plus two pre-ship-audit (2026-07-01) regressions appended at the end:
 *   H1. CLICK-OWN-PLANE   — the tracked standalone model exposes its pick id,
 *                           and a real mouse click on the tracked plane is a
 *                           NO-OP (no deselect, no camera spike).
 *   M3. AGE-OUT RELEASE   — when the tracked plane's fixes stop arriving
 *                           (3 missed polls via the shim), tracking clears and
 *                           the camera is RELEASED IN PLACE: viewer.trackedEntity
 *                           undefined, NO jump (owner decision 2026-07-02 —
 *                           the old ~80 km overview flyTo is gone).
 *
 * And the landing-ghost polish (2026-07-02): a LOW+SLOW (landed) plane that
 * vanishes from the feed is removed after ONE missed poll, while a cruise
 * plane keeps the full 3-poll grace (it absorbs real feed gaps); the tracked
 * readout carries a "· STALE" cue while a tracked plane coasts through its
 * missed-poll grace, and drops it when the plane reappears.
 *
 * And the ground-traffic feature (2026-07-03, owner reversal): present-but-
 * grounded planes render FULL-STRENGTH in the airborne tint pipeline
 * (white / amber-military; the day-1 gray mute was killed the same day) at
 * ×0.8 scale and stay detectable; the on_ground flip restyles the SAME
 * billboard in place (landing/takeoff transition — never a removal); a
 * grounded plane that then vanishes from the feed still fast-culls after one
 * missed poll (both layers; military keys off adsb.lol's alt_baro === "ground").
 * Ground billboards render depth-test-free (disableDepthTestDistance = ∞) so
 * the photoreal tile skin can't bury them up close; takeoff restores the test.
 *
 * And GROUND 3D (2026-07-03, owner decision LOCKED: "when I have 3D mode —
 * proximity or all — I want that respected regardless of whether a plane is
 * on the ground or in the air. No distinction."): a synthetic on_ground plane
 * is model-ELIGIBLE and gets a model under the existing cap (both layers); its
 * model matrix height reads the ONE-SHOT cached ground snap — a stubbed
 * scene.sampleHeight (qa-cctv-drift-b9b style) + the per-layer belly offset —
 * never the buried/floating feed altitude, and never re-samples per frame;
 * the TRACKED grounded plane gets the standalone tracked model too (the
 * owner's "tracked SWA143 at 0 kts showed a 2D billboard" case).
 *
 * And arrival-rotation freshness (2026-07-03 ground-polish): camera.moveEnd
 * forces a full rotation pass on the next frame (fly-to settles the
 * pose-signature gate can eat), and a billboard flipping INTO view while the
 * camera idles re-aims the same tick instead of wearing a stale nose for up
 * to ROTATION_REFRESH_MS. Both layers.
 *
 * Run:  npm run test:track       (assumes dev server already up on :4173)
 *       node scripts/track-regression.mjs
 *
 * Exits non-zero if ANY invariant fails. DOES NOT COMMIT anything.
 *
 * Flags:
 *   --source-base <path>  Browser module prefix (default /src)
 *   --url <url>        App URL (default http://localhost:4173)
 *   --headful          Show the browser (debugging)
 *   --offline-imagery  Use bundled texture for known Esri/OSM tile images only
 *   --keep-open        Leave the browser open after the run (debugging)
 */

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';

// ---------------------------------------------------------------------------
// Args
// ---------------------------------------------------------------------------
const argv = process.argv.slice(2);
const getFlag = (name) => argv.includes(name);
const getOpt = (name, dflt) => {
  const i = argv.indexOf(name);
  return i >= 0 && argv[i + 1] ? argv[i + 1] : dflt;
};

const SOURCE_BASE = getOpt('--source-base', '/src').replace(/\/$/, '');
const APP_URL = getOpt('--url', 'http://localhost:4173');
const APP_ORIGIN = new URL(APP_URL).origin;
const HEADFUL = getFlag('--headful');
const OFFLINE_IMAGERY = getFlag('--offline-imagery');
const KEEP_OPEN = getFlag('--keep-open');

const CHROME_EXECUTABLE_CANDIDATES = [
  process.env.PUPPETEER_EXECUTABLE_PATH,
  // Prefer puppeteer's version-pinned Chrome-for-Testing over the system
  // Chrome: /Applications auto-updates underneath the harnesses, and its
  // software-GL behavior shifts across majors (system Chrome 150 blew the
  // tile-gated drain budget under SwiftShader on 2026-07-30 — six
  // false-negative qa-cctv-v2 runs against a healthy build). A deterministic
  // pinned browser beats the newest one for regression harnesses.
  await puppeteer.executablePath().catch(() => null),
  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
  '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
  '/Applications/Chromium.app/Contents/MacOS/Chromium',
].filter(Boolean);

function findChromeExecutable() {
  for (const candidate of CHROME_EXECUTABLE_CANDIDATES) {
    try {
      if (fs.existsSync(candidate)) return candidate;
    } catch {
      // Ignore inaccessible candidates and let Puppeteer fall back to its cache.
    }
  }
  return null;
}

// ---------------------------------------------------------------------------
// Pretty PASS/FAIL reporting
// ---------------------------------------------------------------------------
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}` : ''}`);
}
function skip(name, why) {
  results.push({ name, ok: null, detail: why });
  console.log(`  [\x1b[33mSKIP\x1b[0m] ${name}  — ${why}`);
}

// ---------------------------------------------------------------------------
// Synthetic aircraft (positioned near Austin, the app's load view).
// Commercial ICAOs deliberately NOT in any known-military set so the flights
// layer doesn't suppress them; military hexes are whatever adsb.lol returns and
// the military layer registers them itself on parse.
// ---------------------------------------------------------------------------
const SYNTH = {
  // Austin load view is (-97.7431, 30.2672). Spread a few planes a few km apart.
  flights: [
    // [icao24, callsign, country, time_position, last_contact, lon, lat, baro_alt, on_ground, velocity, true_track]
    { icao: 'aaa001', callsign: 'SYN001', lon: -97.7431, lat: 30.2672, alt: 9000, vel: 230, track: 90 },
    { icao: 'aaa002', callsign: 'SYN002', lon: -97.7600, lat: 30.2800, alt: 9500, vel: 210, track: 45 },
    { icao: 'aaa003', callsign: 'SYN003', lon: -97.7300, lat: 30.2550, alt: 8700, vel: 250, track: 135 },
  ],
  // Two real, well-formed TLEs (ISS + Hubble). SGP4 needs a valid element set;
  // these are static public catalog entries, so the propagated positions are
  // reproducible run to run.
  tle: [
    'ISS (ZARYA)',
    '1 25544U 98067A   24001.50000000  .00016717  00000-0  10270-3 0  9004',
    '2 25544  51.6416 247.4627 0006703 130.5360 325.0288 15.49814310 12345',
    'HST',
    '1 20580U 90037B   24001.50000000  .00001250  00000-0  67000-4 0  9992',
    '2 20580  28.4700 288.8102 0002613 321.7208 133.2117 15.09299130 12345',
    '',
  ].join('\n'),
  // One dense (Starlink-shell) element set, so dense mode has a real subject
  // to track. Same orbital elements as the ISS entry with a distinct satnum,
  // which keeps SGP4 valid and the propagation reproducible.
  denseTle: [
    'STARLINK-1007',
    '1 44713U 19074A   24001.50000000  .00016717  00000-0  10270-3 0  9004',
    '2 44713  53.0000 247.4627 0006703 130.5360 325.0288 15.06000000 12345',
    '',
  ].join('\n'),
  military: [
    // adsb.lol record fields: hex, flight, lon, lat, alt_baro (ft), track, gs (kt), t, r, ownOp, seen_pos
    { hex: 'bbb101', flight: 'MIL101', lon: -97.7500, lat: 30.2700, altFt: 28000, track: 270, gsKt: 420, t: 'F16', r: 'AF-101' },
    { hex: 'bbb102', flight: 'MIL102', lon: -97.7350, lat: 30.2600, altFt: 26000, track: 315, gsKt: 400, t: 'F18', r: 'AF-102' },
  ],
};

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------
async function main() {
  console.log(`\n3D Tracking Regression Harness`);
  console.log(`  App URL : ${APP_URL}`);
  console.log(`  Mode    : ${HEADFUL ? 'headful' : 'headless'}\n`);

  // Tracking does not assert imagery geography. This optional fixture leaves
  // provider metadata, terrain, models and every tracking assertion untouched.
  // Read before launching so a missing bundled asset fails explicitly.
  const offlineImageryTile = OFFLINE_IMAGERY
    ? fs.readFileSync(new URL('../node_modules/cesium/Build/Cesium/Assets/Textures/NaturalEarthII/0/0/0.jpg', import.meta.url))
    : null;
  let offlineImageryRequests = 0;
  if (OFFLINE_IMAGERY) console.log('  Imagery : bundled NaturalEarthII fixture (tile images only)');

  // Verify the dev server is up before launching a browser.
  try {
    const res = await fetch(APP_URL, { method: 'GET' });
    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`);
    console.error(`Start it first:  ./scripts/dev-fresh.sh   (or:  npm run dev)`);
    process.exit(2);
  }

  const chromeExecutable = findChromeExecutable();
  if (chromeExecutable) {
    console.log(`  Browser : ${chromeExecutable}\n`);
  }

  const browser = await puppeteer.launch({
    headless: HEADFUL ? false : 'new',
    // This machine intermittently stalls single CDP calls past the 180 s
    // default under SwiftShader load (same hardening as qa-focus-evidence).
    protocolTimeout: 300_000,
    ...(chromeExecutable ? { executablePath: chromeExecutable } : {}),
    args: [
      '--no-sandbox',
      '--disable-setuid-sandbox',
      // SwiftShader only in headless: forcing it in headful defeats the whole
      // point of --headful (real GPU). Diagnosed 2026-08-03: under this
      // machine's Chrome 145 SwiftShader, loading the tracked military GLB
      // kills frame production entirely (rAF stops while timers/evals stay
      // alive), wedging any rAF-awaiting evaluation. Same policy as
      // qa-focus-evidence: headful = real GPU.
      ...(HEADFUL ? [] : ['--use-gl=angle', '--use-angle=swiftshader']),
      '--disable-dev-shm-usage',
      '--disable-web-security',
      '--disable-background-timer-throttling',
      '--disable-renderer-backgrounding',
      // macOS stops frame production for fully-occluded windows, which kills
      // rAF (and thus every rAF-awaiting evaluation) in headful runs whose
      // window opens behind others — the qa-focus-evidence bringToFront
      // lesson, enforced belt-and-braces here.
      '--disable-backgrounding-occluded-windows',
      '--window-size=1280,800',
    ],
  });

  const consoleErrors = [];
  const failedResponses = [];
  const sawLog = { detection: false, readout: false };

  try {
    const page = await browser.newPage();
  await page.evaluateOnNewDocument((base) => { window.__gevQaSourceBase = base; }, SOURCE_BASE);
    await page.setViewport({ width: 1280, height: 800 });
    await page.setRequestInterception(true);
    page.on('request', (request) => {
      const url = new URL(request.url());
      // Reuse the one existing interceptor; do not install competing handlers.
      // Exact HTTPS origins and image paths only: metadata, feature queries,
      // other providers, terrain and local/model resources continue normally.
      const knownImageryTile = request.method() === 'GET' && (
        (url.origin === 'https://services.arcgisonline.com'
          && /^\/ArcGIS\/rest\/services\/World_Imagery\/MapServer\/tile\/\d+\/\d+\/\d+$/.test(url.pathname))
        || (url.origin === 'https://tile.openstreetmap.org'
          && /^\/\d+\/\d+\/\d+\.png$/.test(url.pathname))
      );
      if (OFFLINE_IMAGERY && knownImageryTile) {
        offlineImageryRequests++;
        request.respond({
          status: 200,
          contentType: 'image/jpeg',
          headers: { 'Access-Control-Allow-Origin': '*' },
          body: offlineImageryTile,
        });
        return;
      }
      if (url.origin === APP_ORIGIN && url.pathname === '/api/openai/hud-summary') {
        request.respond({
          status: 200,
          contentType: 'application/json',
          body: JSON.stringify({ summary: 'QA globe ready' }),
        });
        return;
      }
      request.continue();
    });

    page.on('console', (msg) => {
      const text = msg.text();
      const type = msg.type();
      if (text.includes('[Detection] Initialized')) sawLog.detection = true;
      if (text.includes('[TrackedReadout] Initialized')) sawLog.readout = true;
      if (type === 'error') {
        // Ignore benign network resource 404s (e.g. an un-shimmed upstream
        // endpoint with no live data, a missing tile/favicon). Those are
        // environmental noise, not a tracking-invariant regression. Real JS
        // errors (TypeError, unhandled rejection, etc.) are still captured.
        const isBenign404 = /Failed to load resource.*404/i.test(text);
        const sourceUrl = msg.location()?.url || '';
        if (!isBenign404) consoleErrors.push(sourceUrl ? `${text} [${sourceUrl}]` : text);
      }
      // Surface a trace for debugging, but keep it quiet.
      if (process.env.GEV_TEST_VERBOSE) console.log(`    [page:${type}] ${text}`);
    });
    page.on('pageerror', (err) => consoleErrors.push(`pageerror: ${err.message}`));
    page.on('response', (response) => {
      if (response.status() >= 500) {
        failedResponses.push(`HTTP ${response.status()} ${response.url()}`);
      }
    });

    // ---- Install the synthetic-fetch shim BEFORE any app code runs ----------
    // Must be in place before the layers' first update() fires fetch(API_URL).
    await page.evaluateOnNewDocument((synth, appOrigin) => {
      // Stash the planes so the page can mutate them later (e.g. to advance
      // positions), and so we can confirm the shim is live.
      window.__SYNTH = synth;
      window.__SYNTH_HITS = { opensky: 0, mil: 0 };

      const realFetch = window.fetch.bind(window);
      const jsonResponse = (obj) =>
        new Response(JSON.stringify(obj), {
          status: 200,
          headers: { 'Content-Type': 'application/json' },
        });

      window.fetch = (input, init) => {
        const requestUrl = typeof input === 'string' || input instanceof URL
          ? String(input)
          : input?.url;
        const url = new URL(requestUrl, window.location.href);
        const isAppRequest = url.origin === appOrigin;
        // OpenSky (commercial flights): { states: [ state-vector[] ] }
        if (isAppRequest && url.pathname === '/api/flights') {
          window.__SYNTH_HITS.opensky++;
          // A withheld contact models the ordinary case where the recipient's
          // first authoritative refresh does not yet carry the shared aircraft.
          const withheld = (() => {
            try { return window.sessionStorage.getItem('__gevWithhold') || ''; } catch { return ''; }
          })();
          const states = window.__SYNTH.flights
            .filter((f) => f.icao !== withheld)
            .map((f) => ([
            f.icao,            // 0 icao24
            f.callsign,        // 1 callsign
            'Synthetica',      // 2 origin_country
            Math.floor(Date.now() / 1000), // 3 time_position
            Math.floor(Date.now() / 1000), // 4 last_contact
            f.lon,             // 5 longitude
            f.lat,             // 6 latitude
            f.alt,             // 7 baro_altitude (m)
            f.onGround === true, // 8 on_ground (ground-traffic phase flips this live)
            f.vel,             // 9 velocity (m/s)
            f.track,           // 10 true_track (deg)
            0, null, null, null, false, 0, // padding to match state-vector length
          ]));
          return Promise.resolve(jsonResponse({ time: Math.floor(Date.now() / 1000), states }));
        }
        // Trail backfill (fires on trackById). Stub with valid-but-empty
        // payloads so the deterministic run never 404s against the dev proxy.
        // flights: { path: [ [time, lat, lon, baroAlt, true_track, on_ground] ] }
        if (isAppRequest && url.pathname === '/api/flights/track') {
          return Promise.resolve(jsonResponse({ path: [] }));
        }
        // military: { timestamp: <epochSec>, trace: [ [secAfter, lat, lon, ...] ] }
        if (isAppRequest && url.pathname === '/api/military/track') {
          return Promise.resolve(jsonResponse({ timestamp: Math.floor(Date.now() / 1000), trace: [] }));
        }
        // adsbdb enrichment (fires for tracked/model-eligible planes): empty
        // object → typeCode stays null → the synthetic planes' class (and so
        // their 3D scale + ground-snap belly offset) is DETERMINISTIC, never a
        // live-proxy lookup of a fake hex.
        if (isAppRequest && /^\/api\/adsbdb\/(?:type|route)\/[^/]+$/.test(url.pathname)) {
          return Promise.resolve(jsonResponse({}));
        }
        // Contacts enables the optional AIS source alongside aircraft. Keep
        // this tracking harness independent of local AIS credentials while
        // preserving the truthful "awaiting first message" lifecycle.
        if (isAppRequest && url.pathname === '/api/vessels') {
          return Promise.resolve(jsonResponse({
            status: 'connected',
            rows: [],
            lastMessageAt: null,
          }));
        }
        // Contacts also enables mapped installations. This tracking harness
        // does not test installation acquisition; a valid empty viewport keeps
        // public Overpass outages out of aircraft/satellite tracking results.
        // Preserve the real response shape and all console-error assertions.
        if (isAppRequest && url.pathname === '/api/military-installations') {
          return Promise.resolve(jsonResponse({
            elements: [],
            saturated: false,
            elementCap: 700,
            retrievedAt: new Date().toISOString(),
            status: 'ready',
          }));
        }
        // CelesTrak TLE groups. Served from a fixed two-satellite catalog so
        // the satellite assertions are deterministic and the run never depends
        // on an upstream that rate-limits (it was answering 403 the night this
        // was written).
        if (isAppRequest && url.pathname.startsWith('/api/celestrak/')) {
          const group = url.pathname.slice('/api/celestrak/'.length);
          // One named group fails on demand. Failing a group the subject is
          // NOT in is the reclassification case: CelesTrak moves satellites
          // between groups, so a subject missing from its old group may have
          // moved into the one that just failed.
          if (window.__SYNTH.failGroup && group === window.__SYNTH.failGroup) {
            return Promise.resolve(new Response('upstream unavailable', { status: 503 }));
          }
          if (group === 'starlink') {
            // A dense load that FAILS is the case that erases the dense
            // request: settling a failure reverts the catalog mode to core.
            if (window.__SYNTH.failDense) {
              return Promise.resolve(new Response('upstream unavailable', { status: 503 }));
            }
            return Promise.resolve(new Response(window.__SYNTH.denseTle, {
              status: 200, headers: { 'Content-Type': 'text/plain' },
            }));
          }
          // EVERY core group serves the same catalog. Dedupe keeps the first
          // (stations) tag, so the catalog is unchanged — but no group is
          // EMPTY, and an empty group counts as failed, which would make an
          // `accepted` refresh (and therefore any release) unreachable here.
          return Promise.resolve(new Response(window.__SYNTH.tle, {
            status: 200, headers: { 'Content-Type': 'text/plain' },
          }));
        }
        // Voice scene context reverse-geocodes the view target and asks Places
        // 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 (
          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') {
          return Promise.resolve(jsonResponse({ places: [] }));
        }
        // adsb.lol military: { ac: [ aircraft{} ] }  (must come AFTER /trace check)
        if (isAppRequest && url.pathname === '/api/military') {
          window.__SYNTH_HITS.mil++;
          const ac = window.__SYNTH.military.map((m) => ({
            hex: m.hex,
            flight: m.flight,
            lon: m.lon,
            lat: m.lat,
            alt_baro: m.altFt,
            track: m.track,
            gs: m.gsKt,
            t: m.t,
            r: m.r,
            ownOp: 'SYNTH AF',
            seen_pos: 0,
          }));
          return Promise.resolve(jsonResponse({ msg: 'No error', now: Date.now(), ac }));
        }
        return realFetch(input, init);
      };
    }, SYNTH, APP_ORIGIN);

    console.log('Loading app...');
    await page.goto(APP_URL, { waitUntil: 'domcontentloaded', timeout: 60000 });
    if (HEADFUL) await page.bringToFront();

    // Wait for the app to expose its globals (Cesium viewer + dataManager).
    await page.waitForFunction(
      () => window.__godsEyeView && window.__godsEyeView.viewer && window.__godsEyeView.dataManager,
      { timeout: 60000, polling: 200 }
    );
    console.log('  App globals ready.\n');

    // Small helper: run an expression in the page after the next render frame,
    // so reads happen on a settled frame.
    const evalPage = (fn, ...args) => page.evaluate(fn, ...args);

    // ============================================================
    // INVARIANT 4: INIT CLEAN  (run first — establishes baseline)
    // ============================================================
    console.log('Invariant 4 — init clean');
    // Give the app a moment to finish first-frame init (detection/readout log).
    await page.waitForFunction(
      () => {
        const dm = window.__godsEyeView.dataManager;
        return dm && dm.layers && dm.layers.size >= 12;
      },
      { timeout: 30000, polling: 200 }
    ).catch(() => {});

    const layerInfo = await evalPage(() => {
      const dm = window.__godsEyeView.dataManager;
      return {
        count: dm.layers.size,
        ids: [...dm.layers.keys()],
        hasFlights: dm.layers.has('flights'),
        hasMilitary: dm.layers.has('military'),
      };
    });
    record('init: >=12 layers registered', layerInfo.count >= 12,
      `${layerInfo.count} layers [${layerInfo.ids.join(', ')}]`);
    record('init: flights + military layers present',
      layerInfo.hasFlights && layerInfo.hasMilitary,
      `flights=${layerInfo.hasFlights} military=${layerInfo.hasMilitary}`);

    // Detection + TrackedReadout init logs are emitted during app boot.
    // Give them a beat in case they fire just after globals appear.
    await waitFor(() => sawLog.detection && sawLog.readout, 8000).catch(() => {});
    record('init: [Detection] Initialized logged', sawLog.detection);
    record('init: [TrackedReadout] Initialized logged', sawLog.readout);

    record('init: no console errors during boot', consoleErrors.length === 0,
      consoleErrors.length ? `${consoleErrors.length} error(s): ${consoleErrors.slice(0, 3).join(' | ')}` : 'clean');

    // Independent GLB capability control. Product model absence cannot prove
    // that the browser backend is incapable: that is the condition this
    // harness is meant to catch. Load the already-approved airplane asset
    // directly through Cesium, outside the Flights/Military model pipelines,
    // then remove the control before exercising product behavior.
    const glbControlStarted = await evalPage(async () => {
      window.__qaGlbControl = null;
      window.__qaGlbControlError = null;
      const asset = await fetch('/models/airplane.glb');
      const assetBytes = asset.ok ? (await asset.arrayBuffer()).byteLength : 0;
      if (!asset.ok || assetBytes === 0) {
        throw new Error(`GLB control asset unavailable: HTTP ${asset.status}`);
      }
      const Cesium = await import('/node_modules/cesium/Build/Cesium/index.js');
      const viewer = window.__godsEyeView.viewer;
      const modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(-97.7431, 30.2672, 9000),
      );
      void Cesium.Model.fromGltfAsync({
        url: '/models/airplane.glb',
        modelMatrix,
        scale: 1,
      }).then((model) => {
        model.id = 'qa:independent-glb-control';
        window.__qaGlbControl = viewer.scene.primitives.add(model);
        viewer.scene.requestRender();
      }).catch((error) => {
        window.__qaGlbControlError = String(error?.message || error);
      });
      return true;
    }).catch((error) => {
      throw new Error(`Independent GLB capability control could not start: ${error.message}`);
    });
    const glbBackendCapable = glbControlStarted && await page.waitForFunction(() => {
      const control = window.__qaGlbControl;
      window.__godsEyeView.viewer.scene.requestRender();
      return Boolean(control?.ready);
    }, { timeout: 40000, polling: 250 }).then(() => true).catch(() => false);
    const glbControlDetail = await evalPage((capable) => {
      const viewer = window.__godsEyeView.viewer;
      const control = window.__qaGlbControl;
      const error = window.__qaGlbControlError;
      if (control) viewer.scene.primitives.remove(control);
      delete window.__qaGlbControl;
      delete window.__qaGlbControlError;
      return capable ? 'ready' : (error || 'did not become ready');
    }, glbBackendCapable);
    console.log(`  GLB capability control: ${glbBackendCapable ? 'ready' : 'unavailable'} (${glbControlDetail})`);

    // Hermeticity (round 5, 2026-07-06): the mesh-floor sampler probes the
    // REAL scene once per cell per poll. Under headless GL, Google tiles
    // sometimes stream at the synthetic-plane coords and sometimes don't, so
    // billboard datums varied run-to-run and flaked the ground/arrival
    // groups. Stub sampleHeight to "no tiles anywhere" for the whole run; the
    // ground-3d group REPLACES this with its counting 187.5 stub, restoring
    // the deterministic pre-round-5 datums everywhere else.
    await evalPage(() => {
      window.__godsEyeView.viewer.scene.sampleHeight = () => undefined;
    });

    // ============================================================
    // Enable flights + military layers and feed synthetic data.
    // ============================================================
    console.log('\nEnabling flights + military layers (synthetic feed)...');
    const enabled = await evalPage(async () => {
      const dm = window.__godsEyeView.dataManager;
      // setEnabled→toggle→init→enable→update(immediate fetch, shimmed).
      await dm.setEnabled('flights', true);
      await dm.setEnabled('military', true);
      // Drive 3D through the actual DISPLAY-rail control. This preserves the
      // user-facing ownership seam and proves that one toggle drives both
      // commercial and military layers before model-capacity assertions run.
      //
      // Since 2026-08-22 the toggle DEFAULTS ON, so the former "click it if it
      // is dark" arming step would have become a no-op and this check would
      // have quietly degraded into a restatement of the default. Drive a full
      // round trip instead — OFF, then back ON — so both directions are proven
      // through the real control no matter which way the default points.
      const fl = dm.layers.get('flights').module;
      const mil = dm.layers.get('military').module;
      const models3dButton = document.getElementById('models3d-toggle');
      const models3dOff = { button: null, fl: null, mil: null };
      if (models3dButton) {
        if (!models3dButton.classList.contains('active')) models3dButton.click();
        models3dButton.click(); // → OFF: both layers must follow the one control
        models3dOff.button = models3dButton.classList.contains('active');
        models3dOff.fl = fl.getParams().models3d;
        models3dOff.mil = mil.getParams().models3d;
        models3dButton.click(); // → ON: the state the rest of the run needs
      }
      // Force one more update each so freshly-shimmed data is ingested.
      await fl.update(window.__godsEyeView.viewer);
      await mil.update(window.__godsEyeView.viewer);
      return {
        flEnabled: dm.isEnabled('flights'),
        milEnabled: dm.isEnabled('military'),
        flStats: fl.getStats(),
        milStats: mil.getStats(),
        models3dButtonActive: models3dButton?.classList.contains('active') === true,
        flModels3d: fl.getParams().models3d,
        milModels3d: mil.getParams().models3d,
        models3dOff,
        hits: window.__SYNTH_HITS,
      };
    });
    console.log(`  flights enabled=${enabled.flEnabled} count=${enabled.flStats.count} | military enabled=${enabled.milEnabled} count=${enabled.milStats.count}`);
    console.log(`  shim hits: opensky=${enabled.hits.opensky} mil=${enabled.hits.mil}`);

    const injectionWorked = enabled.flStats.count > 0 && enabled.milStats.count > 0;
    record('inject: synthetic flights ingested (count>0)', enabled.flStats.count > 0,
      `flights count=${enabled.flStats.count}`);
    record('inject: synthetic military ingested (count>0)', enabled.milStats.count > 0,
      `military count=${enabled.milStats.count}`);
    record('DISPLAY-rail 3D toggle drives both aircraft layers, both directions',
      enabled.models3dButtonActive && enabled.flModels3d && enabled.milModels3d
      && enabled.models3dOff.button === false
      && enabled.models3dOff.fl === false && enabled.models3dOff.mil === false,
      `on: button=${enabled.models3dButtonActive} flights=${enabled.flModels3d} military=${enabled.milModels3d}`
      + ` | off: button=${enabled.models3dOff.button} flights=${enabled.models3dOff.fl} military=${enabled.models3dOff.mil}`);

    if (!injectionWorked) {
      skip('jitter / pull-out / orphan (need synthetic planes)',
        'synthetic injection produced 0 planes — see inject failures above');
      finishAndExit();
      return;
    }

    // ============================================================
    // SHARE LINK V2 — real reload restores the same logical plane.
    // ============================================================
    console.log('\nShare Link v2 — tracked aircraft survives a full reload');
    const shareTracked = await evalPage(() => (
      window.__godsEyeView.dataManager.layers
        .get('flights').module.trackById('aaa001', { origin: 'user' })
    ));
    await page.waitForFunction(
      () => {
        const flights = window.__godsEyeView?.dataManager?.layers?.get('flights')?.module;
        // `lo=` alone is NOT discriminating — the 3D-models option already
        // put an `lo` field in the hash before any aircraft was selected.
        // Wait for the tracking assignment itself.
        return location.hash.includes('v=2')
          && /[?&#]lo=[^&]*f\.t\.aaa001/.test(location.hash)
          && flights?.getParams?.().selectedFlightsTrackingId === 'aaa001';
      },
      // Share serialization is driven by the rendered state transition. On a
      // saturated headless GPU, ten seconds can expire before that frame even
      // though tracking is already accepted; keep the assertion identical but
      // give the callback the same 30 s budget as other reload/latch checks.
      { timeout: 30000, polling: 100 },
    );
    const trackedShareUrl = page.url();
    record(
      'share-v2: explicit aircraft selection reaches the generated URL',
      // Pin the ACTUAL tracking assignment (`f.t.<icao>`), not the mere
      // presence of an `lo` field that the 3D-models option already supplies.
      shareTracked
        && /[?&#]lo=[^&]*f\.t\.aaa001/.test(trackedShareUrl)
        && !trackedShareUrl.includes('f.t.aaa002'),
      trackedShareUrl,
    );

    await page.reload({ waitUntil: 'domcontentloaded', timeout: 60000 });
    await page.waitForFunction(
      () => window.__godsEyeView?.dataManager?.layers?.size >= 12,
      { timeout: 60000, polling: 200 },
    );
    await page.waitForFunction(
      () => {
        const manager = window.__godsEyeView?.dataManager;
        const tracked = manager?.layers?.get('flights')?.module?.getTrackedInfo?.();
        return manager?.isEnabled?.('flights')
          && tracked?.icao24 === 'aaa001'
          && window.__godsEyeView.viewer.trackedEntity?.gevTrackedId === 'flights:aaa001';
      },
      { timeout: 30000, polling: 100 },
    );
    const shareReload = await evalPage(() => {
      const manager = window.__godsEyeView.dataManager;
      const flights = manager.layers.get('flights').module;
      return {
        flightsEnabled: manager.isEnabled('flights'),
        trackedId: flights.getTrackedInfo()?.icao24 || null,
        durableId: flights.getParams()?.selectedFlightsTrackingId || null,
        viewerTrackedId: window.__godsEyeView.viewer.trackedEntity?.gevTrackedId || null,
      };
    });
    record(
      'share-v2: full reload restores the selected logical aircraft',
      shareReload.flightsEnabled
        && shareReload.trackedId === 'aaa001'
        && shareReload.durableId === 'aaa001',
      JSON.stringify(shareReload),
    );
    record(
      'share-v2: restored aircraft owns the Cesium follow camera',
      shareReload.viewerTrackedId === 'flights:aaa001',
      `viewerTrackedId=${shareReload.viewerTrackedId}`,
    );

    // Prove the URL itself owns the result. Remove the same-origin saved
    // preference, then open the captured link as a clean recipient would.
    await evalPage(() => localStorage.removeItem('gev:layer-state:v2'));
    await page.goto(trackedShareUrl, { waitUntil: 'domcontentloaded', timeout: 60000 });
    await page.waitForFunction(
      () => window.__godsEyeView?.dataManager?.layers?.size >= 12,
      { timeout: 60000, polling: 200 },
    );
    await page.waitForFunction(
      () => {
        const manager = window.__godsEyeView?.dataManager;
        const tracked = manager?.layers?.get('flights')?.module?.getTrackedInfo?.();
        return manager?.isEnabled?.('flights')
          && tracked?.icao24 === 'aaa001'
          && window.__godsEyeView.viewer.trackedEntity?.gevTrackedId === 'flights:aaa001';
      },
      { timeout: 30000, polling: 100 },
    );
    const cleanRecipient = await evalPage(() => {
      const manager = window.__godsEyeView.dataManager;
      const flights = manager.layers.get('flights').module;
      return {
        flightsEnabled: manager.isEnabled('flights'),
        trackedId: flights.getTrackedInfo()?.icao24 || null,
        durableId: flights.getParams()?.selectedFlightsTrackingId || null,
        viewerTrackedId: window.__godsEyeView.viewer.trackedEntity?.gevTrackedId || null,
      };
    });
    record(
      'share-v2: clean recipient magic link restores the selected aircraft',
      cleanRecipient.flightsEnabled
        && cleanRecipient.trackedId === 'aaa001'
        && cleanRecipient.durableId === 'aaa001'
        && cleanRecipient.viewerTrackedId === 'flights:aaa001',
      JSON.stringify(cleanRecipient),
    );
    // ---- Not-yet-arrived shared subject: PENDING, silent, then latches ----
    // Reload-from-local always survived a slow first refresh via the layer's
    // deferred-restore latch. The shared path used to decide on ONE refresh,
    // clear the subject, and post a failure notice seconds into startup.
    await evalPage(() => window.sessionStorage.setItem('__gevWithhold', 'aaa001'));
    // A goto whose URL differs only by hash is a SAME-DOCUMENT navigation: the
    // page would never reload and the app would keep its existing tracking.
    // Leave the document first so this is a real cold boot of the shared link.
    await page.goto('about:blank', { waitUntil: 'domcontentloaded', timeout: 30000 });
    await page.goto(trackedShareUrl, { waitUntil: 'domcontentloaded', timeout: 60000 });
    await page.waitForFunction(
      () => window.__godsEyeView?.dataManager?.layers?.size >= 12,
      { timeout: 60000, polling: 200 },
    );
    await page.waitForFunction(
      () => document.getElementById('loading-screen')?.classList.contains('hidden'),
      { timeout: 60000, polling: 200 },
    );
    await new Promise((resolve) => setTimeout(resolve, 6000));
    const pendingShare = await evalPage(() => ({
      tracked: window.__godsEyeView.dataManager.layers
        .get('flights').module.getTrackedInfo()?.icao24 || null,
      notice: (document.getElementById('global-loading-label')?.textContent || '').trim(),
      noticeShown: !document.getElementById('global-loading-status')?.hidden,
    }));
    record(
      'share-v2: a not-yet-arrived subject is held pending, with no failure notice',
      pendingShare.tracked === null
        && !/unavailable|expired|could not be restored/i.test(
          pendingShare.noticeShown ? pendingShare.notice : '',
        ),
      JSON.stringify(pendingShare),
    );

    // The aircraft now arrives on a later poll; the latch must take it.
    await evalPage(() => window.sessionStorage.removeItem('__gevWithhold'));
    await evalPage(async () => {
      const flights = window.__godsEyeView.dataManager.layers.get('flights').module;
      for (let i = 0; i < 3; i += 1) {
        await flights.update(window.__godsEyeView.viewer);
        await new Promise((resolve) => setTimeout(resolve, 600));
      }
    });
    await page.waitForFunction(
      () => window.__godsEyeView?.dataManager?.layers?.get('flights')?.module
        ?.getTrackedInfo?.()?.icao24 === 'aaa001',
      { timeout: 30000, polling: 200 },
    ).catch(() => {});
    const latchedShare = await evalPage(() => ({
      tracked: window.__godsEyeView.dataManager.layers
        .get('flights').module.getTrackedInfo()?.icao24 || null,
      viewerTrackedId: window.__godsEyeView.viewer.trackedEntity?.gevTrackedId || null,
    }));
    record(
      'share-v2: the pending subject latches on when it arrives on a later poll',
      latchedShare.tracked === 'aaa001'
        && latchedShare.viewerTrackedId === 'flights:aaa001',
      JSON.stringify(latchedShare),
    );

    // The captured link intentionally contains only the explicitly owned
    // Flights layer. Restore the harness-only Military companion before the
    // legacy cross-layer invariants continue.
    await evalPage(async () => {
      const manager = window.__godsEyeView.dataManager;
      await manager.setEnabled('military', true);
      await manager.layers.get('military').module.update(window.__godsEyeView.viewer);
    });
    await evalPage(() => {
      window.__godsEyeView.viewer.scene.sampleHeight = () => undefined;
    });

    // ============================================================
    // VOICE ENTITY CONTEXT — a click-selected contact IS "the selected
    // entity". The aircraft layers publish selection on their own awareness
    // lane (the readout card + Contacts subject), and for the whole life of
    // the voice tools they never wrote the SHARED context slot that
    // `get_entity_context` reads. So with a plane plainly selected on screen,
    // `{scope:'selected'}` silently downgraded to `'in_view'` and the model
    // answered "there isn't a plane currently selected" (owner field session,
    // 2026-08-21). Drives the real tool runner; costs no model turns.
    // ============================================================
    console.log('\nVoice entity context — a click-selected contact answers scope:selected');
    const runnerReady = await evalPage(() => typeof window.__gevVoiceCommands?.runner === 'function');
    if (!runnerReady) {
      skip('voice-context: click-selected aircraft answers scope:selected',
        'voice command runner not exposed on this build');
    } else {
      const flightSelected = await evalPage(async () => {
        const flights = window.__godsEyeView.dataManager.layers.get('flights').module;
        // The exact call the canvas click handler makes on a billboard pick.
        flights.trackById('aaa001', { origin: 'user' });
        const result = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        return {
          scope: result?.scope || null,
          layerId: result?.selected?.layerId || null,
          id: result?.selected?.id || null,
          name: result?.selected?.name || null,
          latitude: result?.selected?.latitude ?? null,
          callsign: result?.selected?.properties?.callsign || null,
        };
      });
      record(
        'voice-context: click-selected aircraft answers scope:selected',
        flightSelected.scope === 'selected'
          && flightSelected.layerId === 'flights'
          && flightSelected.id === 'aaa001',
        JSON.stringify(flightSelected),
      );
      record(
        'voice-context: the selected contact carries its identity and position',
        flightSelected.name === 'SYN001'
          && flightSelected.callsign === 'SYN001'
          && Number.isFinite(flightSelected.latitude),
        JSON.stringify(flightSelected),
      );

      // Selecting a different contact must MOVE the subject, not stack a
      // second one: a frozen record left behind would be narrated later at a
      // position its aircraft has long since left.
      const switchedSubject = await evalPage(async () => {
        const manager = window.__godsEyeView.dataManager;
        manager.layers.get('flights').module.trackById('aaa002', { origin: 'user' });
        const result = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        const store = window.__gevContextStore;
        const flightRecords = [...store.entities.values()].filter((r) => r.layerId === 'flights');
        return {
          scope: result?.scope || null,
          id: result?.selected?.id || null,
          flightRecordIds: flightRecords.map((r) => r.id),
        };
      });
      record(
        'voice-context: switching contacts moves the subject and leaves no stale record',
        switchedSubject.scope === 'selected'
          && switchedSubject.id === 'aaa002'
          && switchedSubject.flightRecordIds.length === 1
          && switchedSubject.flightRecordIds[0] === 'aaa002',
        JSON.stringify(switchedSubject),
      );

      // A military contact is the same click, on the sibling layer.
      const militarySelected = await evalPage(async () => {
        const manager = window.__godsEyeView.dataManager;
        manager.layers.get('flights').module.stopTracking();
        manager.layers.get('military').module.trackById('bbb101', { origin: 'user' });
        const result = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        return {
          scope: result?.scope || null,
          layerId: result?.selected?.layerId || null,
          id: result?.selected?.id || null,
          name: result?.selected?.name || null,
        };
      });
      record(
        'voice-context: click-selected military contact answers scope:selected',
        militarySelected.scope === 'selected'
          && militarySelected.layerId === 'military'
          && militarySelected.id === 'bbb101'
          && militarySelected.name === 'MIL101',
        JSON.stringify(militarySelected),
      );

      // Deselecting must give the slot back — a subject that outlives its
      // selection is the same bug pointed the other way.
      const deselected = await evalPage(async () => {
        const manager = window.__godsEyeView.dataManager;
        manager.layers.get('military').module.stopTracking();
        const result = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        return { scope: result?.scope || null, selected: result?.selected ?? null };
      });
      record(
        'voice-context: deselecting releases the subject back to in_view',
        deselected.scope === 'in_view' && deselected.selected === null,
        JSON.stringify(deselected),
      );

      // ============================================================
      // SATELLITES — same PRD gap as the aircraft layers: a tracked satellite
      // published only its awareness event, so voice could not see it either.
      // ============================================================
      console.log('\nVoice entity context — a tracked satellite is a selected subject');
      const satelliteContext = await evalPage(async () => {
        const manager = window.__godsEyeView.dataManager;
        await manager.setEnabled('satellites', true);
        const satellites = manager.layers.get('satellites').module;
        // Wait for the shimmed stations catalog to build its satrecs.
        for (let i = 0; i < 80; i += 1) {
          if (satellites.getStats?.().count > 0) break;
          await new Promise((resolve) => setTimeout(resolve, 250));
        }
        const tracked = satellites.trackById(25544, { origin: 'user' });
        await new Promise((resolve) => setTimeout(resolve, 500));
        const selected = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        // Switching subjects must move the slot, not stack a second orbit.
        satellites.trackById(20580, { origin: 'user' });
        await new Promise((resolve) => setTimeout(resolve, 500));
        const switched = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        const satelliteRecordIds = [...window.__gevContextStore.entities.values()]
          .filter((record) => record.layerId === 'satellites')
          .map((record) => record.id);
        // CATALOG REBUILD. The tracked satellite's catalog entry is replaced
        // wholesale by a TLE refresh, so a surviving subject must re-resolve
        // against the new satrec — and a subject that did NOT survive must
        // release the slot rather than linger frozen at its last position.
        satellites.trackById(25544, { origin: 'user' });
        await new Promise((resolve) => setTimeout(resolve, 500));
        await satellites.update(window.__godsEyeView.viewer);
        await new Promise((resolve) => setTimeout(resolve, 600));
        const afterRebuild = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });

        // RECLASSIFICATION: the subject vanishes from the catalog while a
        // DIFFERENT group — one it could have been moved into — failed to
        // load. Its own group loaded fine, so a group-scoped proof would call
        // this a disappearance. It is not: absence is only proven when every
        // potential carrier loaded.
        const fullTle = window.__SYNTH.tle;
        const truncatedTle = fullTle.split('\n').slice(3).join('\n');
        window.__SYNTH.tle = truncatedTle;
        window.__SYNTH.failGroup = 'geo';
        await satellites.update(window.__godsEyeView.viewer);
        await new Promise((resolve) => setTimeout(resolve, 800));
        const afterPartial = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        window.__SYNTH.failGroup = null;
        window.__SYNTH.tle = fullTle;
        // Recover, so the release case below starts from a healthy subject.
        await satellites.update(window.__godsEyeView.viewer);
        await new Promise((resolve) => setTimeout(resolve, 800));

        // Now the subject vanishes from a COMPLETE catalog — proven absence.
        window.__SYNTH.tle = fullTle.split('\n').slice(3).join('\n');
        await satellites.update(window.__godsEyeView.viewer);
        await new Promise((resolve) => setTimeout(resolve, 800));
        const afterSubjectGone = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        window.__SYNTH.tle = fullTle;

        // DENSE CARRIER FAILURE. Track a dense-shell satellite, then let the
        // dense load fail on the next rebuild. Settling that failure reverts
        // the catalog mode to 'core', so anything reading the mode AFTER the
        // await no longer sees that dense was ever a potential carrier — and
        // would delete a subject the dense catalog might have carried.
        satellites.setParams({ catalog: 'dense' });
        for (let i = 0; i < 80; i += 1) {
          if (satellites.getStats?.().count > 2) break;
          await new Promise((resolve) => setTimeout(resolve, 250));
        }
        const denseTracked = satellites.trackById(44713, { origin: 'user' });
        await new Promise((resolve) => setTimeout(resolve, 600));
        const denseSelected = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        window.__SYNTH.failDense = true;
        await satellites.update(window.__godsEyeView.viewer);
        await new Promise((resolve) => setTimeout(resolve, 1200));
        const afterDenseFailure = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        const catalogModeAfterFailure = satellites.getParams?.().catalog ?? null;
        window.__SYNTH.failDense = false;
        satellites.setParams({ catalog: 'core' });
        satellites.stopTracking?.();
        await new Promise((resolve) => setTimeout(resolve, 400));

        satellites.trackById(25544, { origin: 'user' });
        await new Promise((resolve) => setTimeout(resolve, 400));
        satellites.stopTracking?.();
        await new Promise((resolve) => setTimeout(resolve, 400));
        const released = await window.__gevVoiceCommands.runner('get_entity_context', { scope: 'selected' });
        await manager.setEnabled('satellites', false);
        // Following a satellite left the camera in orbit. Hand it back to the
        // synthetic fleet so later groups see the view they were written for.
        manager.layers.get('flights').module.trackById('aaa001', { origin: 'user' });
        await new Promise((resolve) => setTimeout(resolve, 600));
        return {
          tracked,
          scope: selected?.scope ?? null,
          layerId: selected?.selected?.layerId ?? null,
          id: selected?.selected?.id ?? null,
          name: selected?.selected?.name ?? null,
          latitude: selected?.selected?.latitude ?? null,
          switchedId: switched?.selected?.id ?? null,
          satelliteRecordIds,
          releasedScope: released?.scope ?? null,
          releasedSelected: released?.selected ?? null,
          rebuiltScope: afterRebuild?.scope ?? null,
          rebuiltId: afterRebuild?.selected?.id ?? null,
          rebuiltLatitude: afterRebuild?.selected?.latitude ?? null,
          goneScope: afterSubjectGone?.scope ?? null,
          goneSelected: afterSubjectGone?.selected ?? null,
          partialScope: afterPartial?.scope ?? null,
          partialId: afterPartial?.selected?.id ?? null,
          denseTracked,
          denseSelectedId: denseSelected?.selected?.id ?? null,
          denseFailureScope: afterDenseFailure?.scope ?? null,
          denseFailureId: afterDenseFailure?.selected?.id ?? null,
          catalogModeAfterFailure,
        };
      });
      record(
        'voice-context: a tracked satellite answers scope:selected with its identity',
        satelliteContext.tracked === true
          && satelliteContext.scope === 'selected'
          && satelliteContext.layerId === 'satellites'
          && satelliteContext.id === '25544'
          && /ISS/.test(satelliteContext.name || '')
          && Number.isFinite(satelliteContext.latitude),
        JSON.stringify(satelliteContext),
      );
      record(
        'voice-context: switching satellites moves the subject and leaves no stale orbit',
        satelliteContext.switchedId === '20580'
          && satelliteContext.satelliteRecordIds.length === 1
          && satelliteContext.satelliteRecordIds[0] === '20580',
        JSON.stringify(satelliteContext),
      );
      record(
        'voice-context: the subject survives a catalog rebuild under the same id',
        satelliteContext.rebuiltScope === 'selected'
          && satelliteContext.rebuiltId === '25544'
          && Number.isFinite(satelliteContext.rebuiltLatitude),
        JSON.stringify(satelliteContext),
      );
      record(
        'voice-context: a subject missing while ANOTHER potential carrier failed is preserved',
        satelliteContext.partialScope === 'selected' && satelliteContext.partialId === '25544',
        JSON.stringify(satelliteContext),
      );
      record(
        'voice-context: a subject that does not survive the rebuild releases the slot',
        satelliteContext.goneScope === 'in_view' && satelliteContext.goneSelected === null,
        JSON.stringify(satelliteContext),
      );
      record(
        'voice-context: a failed DENSE load preserves its subject, even though the mode reverts',
        satelliteContext.denseTracked === true
          && satelliteContext.denseSelectedId === '44713'
          && satelliteContext.catalogModeAfterFailure === 'core'
          && satelliteContext.denseFailureScope === 'selected'
          && satelliteContext.denseFailureId === '44713',
        JSON.stringify(satelliteContext),
      );
      record(
        'voice-context: deselecting a satellite releases the subject',
        satelliteContext.releasedScope === 'in_view' && satelliteContext.releasedSelected === null,
        JSON.stringify(satelliteContext),
      );

      // ============================================================
      // PANEL === SPOKEN. Not the shared helper as a stand-in: the REAL
      // Contacts pipeline (awareness selects a subject, evaluateSubject fills
      // the snapshot, the panel renders it) against the REAL voice tool. A
      // divergence introduced at the call site itself — not in the helper —
      // has to go red here.
      // ============================================================
      console.log('\nPanel === spoken — one number, through both real call sites');
      const panelVsSpoken = await evalPage(async () => {
        const manager = window.__godsEyeView.dataManager;
        if (!manager.isEnabled('flights')) await manager.setEnabled('flights', true);
        if (!manager.isEnabled('military')) await manager.setEnabled('military', true);
        // Enter Contacts the way the operator does, then select a contact so
        // awareness has a real subject.
        const button = document.getElementById('global-context-flights-btn');
        if (button && !window.__godsEyeView.styleManager.getContextModeState?.().mode) button.click();
        for (let i = 0; i < 80; i += 1) {
          if (window.__godsEyeView.styleManager.getContextModeState?.().mode) break;
          await new Promise((resolve) => setTimeout(resolve, 100));
        }
        manager.layers.get('flights').module.trackById('aaa001', { origin: 'user' });
        // Awareness recomputes on its own cadence; wait for a real snapshot.
        const awareness = manager.layers.get('military-awareness')?.module;
        let snapshot = null;
        for (let i = 0; i < 80; i += 1) {
          snapshot = awareness?.getContextSnapshot?.() || null;
          if (snapshot?.cohorts?.length) break;
          await new Promise((resolve) => setTimeout(resolve, 150));
        }
        if (!snapshot?.subject) return { error: 'awareness produced no subject' };
        const countFor = (id) => {
          const cohort = snapshot.cohorts.find((entry) => entry?.id === id);
          return Number.isFinite(cohort?.count) ? cohort.count : null;
        };
        // What the PANEL shows, read from the snapshot it renders.
        const panelAircraft = (countFor('flights') ?? 0) + (countFor('military') ?? 0);
        // What VOICE says, through the real tool runner.
        const spoken = await window.__gevVoiceCommands.runner('analyst_query', {
          layers: ['flights', 'military'],
          scope: { kind: 'radius', km: Math.round((snapshot.radiusM || 250000) / 1000) },
        });
        return {
          subject: snapshot.subject.label || snapshot.subject.id || null,
          panelAircraft,
          spokenCount: spoken?.count ?? null,
          spokenEngine: spoken?.window?.engine ?? null,
          spokenCenteredOn: spoken?.window?.centeredOn ?? null,
        };
      });
      record(
        'panel===spoken: the Contacts panel and the voice count are one number',
        !panelVsSpoken.error
          && panelVsSpoken.spokenEngine === 'contacts-window'
          && panelVsSpoken.spokenCount === panelVsSpoken.panelAircraft,
        JSON.stringify(panelVsSpoken),
      );
      record(
        'panel===spoken: the spoken answer names the subject whose window it read',
        !panelVsSpoken.error && panelVsSpoken.spokenCenteredOn === panelVsSpoken.subject,
        JSON.stringify(panelVsSpoken),
      );
      // Leave Contacts as the vocabulary group expects to find it.
      await evalPage(async () => {
        try { await window.__gevVoiceCommands.runner('set_context_mode', { mode: 'off' }); } catch {}
      });

      // ============================================================
      // CONTEXT VOCABULARY — state output must speak the words the tools
      // accept. The Contacts mode's internal id is 'flights' while
      // `set_context_mode` takes 'contacts', and state surfaces reported the
      // internal id: the model read `mode:'flights'`, concluded Contacts was
      // off, and refused to answer from the Contacts window counts carried in
      // the same payload (owner field session, 2026-08-21).
      // ============================================================
      console.log('\nContext vocabulary — state output speaks the tools\' own words');
      const manualContacts = await evalPage(async () => {
        const button = document.getElementById('global-context-flights-btn');
        if (!button) return { error: 'Contacts control not found' };
        // The MANUAL path is the one that broke silently — voice never set it.
        button.click();
        for (let i = 0; i < 60; i += 1) {
          if (window.__godsEyeView.styleManager.getContextModeState?.().mode) break;
          await new Promise((resolve) => setTimeout(resolve, 100));
        }
        const state = await window.__gevVoiceCommands.runner('get_current_view_state');
        return {
          internalMode: window.__godsEyeView.styleManager.getContextModeState?.().mode || null,
          reportedMode: state?.context?.mode ?? null,
          reportedInternal: state?.context?.modeInternal ?? null,
          active: state?.context?.active ?? null,
        };
      });
      record(
        'context-vocab: a manually activated Contacts reports as "contacts", not its internal id',
        manualContacts.internalMode === 'flights'
          && manualContacts.reportedMode === 'contacts'
          && manualContacts.reportedInternal === 'flights'
          && manualContacts.active === true,
        JSON.stringify(manualContacts),
      );

      // Round-trip: whatever state output reports must be a word the tool
      // accepts. Feeding the reported mode straight back must not be rejected.
      const roundTrip = await evalPage(async (reported) => {
        const result = await window.__gevVoiceCommands.runner('set_context_mode', { mode: reported });
        const state = await window.__gevVoiceCommands.runner('get_current_view_state');
        return {
          ok: result?.ok ?? null,
          error: result?.error || null,
          resultMode: result?.mode ?? null,
          resultInternal: result?.modeInternal ?? null,
          stateMode: state?.context?.mode ?? null,
        };
      }, manualContacts.reportedMode);
      record(
        'context-vocab: the reported mode round-trips back through set_context_mode',
        roundTrip.ok === true
          && !roundTrip.error
          && roundTrip.resultMode === 'contacts'
          && roundTrip.resultInternal === 'flights'
          && roundTrip.stateMode === 'contacts',
        JSON.stringify(roundTrip),
      );

      const contextOff = await evalPage(async () => {
        const result = await window.__gevVoiceCommands.runner('set_context_mode', { mode: 'off' });
        const state = await window.__gevVoiceCommands.runner('get_current_view_state');
        return {
          resultMode: result?.mode ?? null,
          stateMode: state?.context?.mode ?? null,
          stateInternal: state?.context?.modeInternal ?? null,
        };
      });
      record(
        'context-vocab: no context reports as "off", never a bare null',
        contextOff.resultMode === 'off'
          && contextOff.stateMode === 'off'
          && contextOff.stateInternal === null,
        JSON.stringify(contextOff),
      );

      // ============================================================
      // ANALYST -> TRACK HANDOFF — the tool instructions tell the model to
      // look a contact up with analyst_query and hand that identity to
      // track_entity. The analyst's `id` is a DISPLAY label (callsign, else
      // registration, else hex) and the lookup matched callsigns and hex
      // only, so a callsign-less contact came back as its tail number and
      // "Nothing matched" — the model then burned the turn on retries (owner
      // field session 2026-08-21, 23:48: three failed track_entity calls
      // before a fallback stuck).
      // ============================================================
      console.log('\nAnalyst handoff — a looked-up contact can actually be tracked');
      const handoff = await evalPage(async () => {
        const manager = window.__godsEyeView.dataManager;
        // This group owns its precondition: earlier groups toggle Contacts,
        // which snapshots and restores layer state around itself.
        if (!manager.isEnabled('military')) await manager.setEnabled('military', true);
        const mil = manager.layers.get('military').module;
        const priorFixture = window.__SYNTH.military.slice();
        window.__SYNTH.military = [...priorFixture, {
          hex: 'bbb777', flight: '', lon: -97.7440, lat: 30.2680,
          altFt: 1800, track: 210, gsKt: 130, t: 'UH60', r: '6606',
        }];
        try {
          await mil.update(window.__godsEyeView.viewer);
          // Scope is deliberately 'anywhere': what is under test is the
          // identity handoff, not spatial filtering, and an earlier group may
          // have left the camera somewhere else entirely.
          const analyst = await window.__gevVoiceCommands.runner('analyst_query', {
            layers: ['military'], scope: { kind: 'anywhere' }, limit: 10,
          });
          const item = (analyst?.items || []).find((entry) => entry.id === '6606') || null;
          const tracked = item
            ? await window.__gevVoiceCommands.runner('track_entity', { query: item.id, layerId: 'military' })
            : null;
          return {
            militaryEnabled: manager.isEnabled('military'),
            militaryCount: mil.getStats?.().count ?? null,
            itemCount: (analyst?.items || []).length,
            itemFound: Boolean(item),
            itemId: item?.id ?? null,
            itemIcao: item?.icao24 ?? null,
            trackOk: tracked?.ok ?? null,
            trackError: tracked?.error ?? null,
            trackedIcao: mil.getTrackedInfo()?.icao24 ?? null,
          };
        } finally {
          window.__SYNTH.military = priorFixture;
          mil.stopTracking();
          await mil.update(window.__godsEyeView.viewer);
        }
      });
      record(
        'analyst-handoff: a callsign-less contact is named by the tail number the app shows',
        handoff.itemFound && handoff.itemId === '6606',
        JSON.stringify(handoff),
      );
      record(
        'analyst-handoff: the identity the analyst returned is trackable, first try',
        handoff.trackOk === true
          && !handoff.trackError
          && handoff.trackedIcao === 'bbb777',
        JSON.stringify(handoff),
      );
      record(
        'analyst-handoff: the result carries the hex key the tracker keys on',
        handoff.itemIcao === 'bbb777',
        JSON.stringify(handoff),
      );

      // Restore the state the downstream invariants were written against:
      // flights following aaa001, military idle.
      await evalPage(() => {
        window.__godsEyeView.dataManager.layers.get('flights').module.trackById('aaa001', { origin: 'user' });
      });
      await page.waitForFunction(
        () => window.__godsEyeView?.dataManager?.layers?.get('flights')?.module
          ?.getTrackedInfo?.()?.icao24 === 'aaa001',
        { timeout: 15000, polling: 100 },
      );
    }

    // NOTE: we do NOT manually reposition the camera. Tracking sets
    // viewer.trackedEntity + a calibrated viewFrom, so the follow camera lands
    // in the few-km band (altitude*1.1+2500, clamped 3–30 km) — far below the
    // MODEL_ALT_CEIL_M = 800 km ceiling, so _modelRegimeActive() is true and the
    // standalone tracked model renders. That's the exact path the invariants
    // protect, so we exercise it rather than a synthetic setView.

    // ============================================================
    // INVARIANT 1: NO JITTER
    //   model visual centre === getDetectableObjects() position, per frame.
    // ============================================================
    console.log('\nInvariant 1 — no jitter (model visual centre === detectable pos)');

    // Install a scene-graph model finder in the page FIRST (used by the wait
    // below). The tracked model is a standalone Cesium.Model added to a
    // PrimitiveCollection under scene.primitives. We locate the shown Model whose
    // matrix translation is nearest the tracked display position.
    await evalPage(() => {
      window.__findTrackedModel = function () {
        const v = window.__godsEyeView.viewer;
        const prims = v.scene.primitives;
        const out = [];
        const walk = (coll) => {
          const n = coll.length;
          for (let i = 0; i < n; i++) {
            const p = coll.get(i);
            if (!p) continue;
            // PrimitiveCollection has .length + .get
            if (typeof p.length === 'number' && typeof p.get === 'function') { walk(p); continue; }
            // A Cesium.Model has a modelMatrix (Matrix4: column-major Float64Array-like)
            if (p.modelMatrix && typeof p.ready !== 'undefined') out.push(p);
          }
        };
        walk(prims);
        // Prefer shown+ready models.
        const shown = out.filter((m) => m.show && m.ready);
        const pool = shown.length ? shown : out;
        if (!pool.length) return null;
        // If tracking, pick the model nearest the tracked display position.
        const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
        // Prefer the tracked model's explicit H1 pick id. A neighboring fleet
        // model can temporarily be nearer while the follow camera/model matrix
        // settles after the cross-layer switch sequence, causing this probe to
        // report the neighbor's id even though the correct tracked model is up.
        const trackedInfo = fl.getTrackedInfo();
        const exactPickModel = trackedInfo
          ? pool.find((model) => String(model.id) === trackedInfo.icao24)
          : null;
        if (exactPickModel) return exactPickModel;
        const ent = window.__godsEyeView.viewer.trackedEntity;
        let tracked = null;
        if (ent && typeof ent.gevDisplayPosition === 'function') tracked = ent.gevDisplayPosition();
        if (!tracked) return pool[0];
        let best = null, bestD = Infinity;
        for (const m of pool) {
          const mm = m.modelMatrix;
          const dx = mm[12] - tracked.x, dy = mm[13] - tracked.y, dz = mm[14] - tracked.z;
          const d = dx * dx + dy * dy + dz * dz;
          if (d < bestD) { bestD = d; best = m; }
        }
        // The tracked model rides AT the display position. While the tracked
        // GLB is still loading, the nearest ready model is some OTHER plane's
        // fleet model km away — returning it made the model-up waits resolve
        // spuriously and H1 read a neighbor's pick id. Anything beyond 1 km
        // is "tracked model not up yet", not a match.
        return bestD < 1000 * 1000 ? best : null;
      };
    });

    // Track a synthetic commercial plane. Tracking sets viewer.trackedEntity +
    // viewFrom, so the follow camera lands in the few-km band and the standalone
    // 3D model renders (model regime active below the 800 km ceiling).
    const trackedIcao = SYNTH.flights[0].icao;
    await evalPage((icao) => {
      window.__godsEyeView.dataManager.layers.get('flights').module.trackById(icao);
    }, trackedIcao);
    await sleep(1500); // let the follow camera settle + the GLB load kick off

    // Wait until the tracked Cesium.Model primitive exists, is ready & shown.
    const modelUp = await page.waitForFunction((icao) => {
      const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
      const ti = fl.getTrackedInfo();
      if (!ti || ti.icao24 !== icao) return false;
      const found = window.__findTrackedModel ? window.__findTrackedModel() : null;
      return !!(found && found.ready && found.show && String(found.id) === icao);
    }, { timeout: 60000, polling: 250 }, trackedIcao).then(() => true).catch(() => false);
    record('3D: tracked commercial model becomes ready through the DISPLAY toggle', modelUp,
      modelUp ? `ready+shown id=${trackedIcao}` : 'tracked product model never became ready+shown');

    let jitterResult;
    if (!modelUp) {
      // Model didn't come up — still test the underlying invariant: the tracked
      // entity's exposed display position (what the model uses) must equal the
      // getDetectableObjects() position. This is the exact shared-source contract.
      jitterResult = await sampleFrames(page, 30, (icao) => {
        const dm = window.__godsEyeView.dataManager;
        const fl = dm.layers.get('flights').module;
        const ent = window.__godsEyeView.viewer.trackedEntity;
        const disp = ent && typeof ent.gevDisplayPosition === 'function' ? ent.gevDisplayPosition() : null;
        const dets = fl.getDetectableObjects({ maxCount: 1000 });
        const me = dets.find((d) => d.id === icao || d.id === (fl.getTrackedInfo() && fl.getTrackedInfo().callsign));
        if (!disp || !me || !me.position) return null;
        const dx = disp.x - me.position.x, dy = disp.y - me.position.y, dz = disp.z - me.position.z;
        return Math.sqrt(dx * dx + dy * dy + dz * dz);
      }, trackedIcao);
      console.log('  (3D model did not render under SwiftShader; testing the shared display-position contract directly)');
    } else {
      // Full check: independently transform airplane.glb's measured AABB centre
      // through the actual 3D model matrix, then compare it with detection.
      // glTF [x,y,z] → Cesium-local [x,-z,y]. The effective rendered
      // computedScale is separate from modelMatrix and includes any
      // minimumPixelSize enlargement, so include it just as the renderer does.
      jitterResult = await sampleFrames(page, 30, (icao) => {
        const dm = window.__godsEyeView.dataManager;
        const fl = dm.layers.get('flights').module;
        const ti = fl.getTrackedInfo();
        const model = window.__findTrackedModel();
        if (!model) return null;
        const mm = model.modelMatrix;
        const scale = Number.isFinite(model.computedScale)
          ? model.computedScale
          : (Number.isFinite(model.scale) ? model.scale : 1);
        // airplane.glb is now bounding-box centred with transforms applied.
        const x = 0 * scale;
        const y = 0 * scale;
        const z = 0 * scale;
        const visual = {
          x: mm[0] * x + mm[4] * y + mm[8] * z + mm[12],
          y: mm[1] * x + mm[5] * y + mm[9] * z + mm[13],
          z: mm[2] * x + mm[6] * y + mm[10] * z + mm[14],
        };
        const dets = fl.getDetectableObjects({ maxCount: 1000 });
        const me = dets.find((d) => d.skipLabel) // tracked entry is skipLabel:true
          || dets.find((d) => d.id === (ti && ti.callsign))
          || dets.find((d) => d.id === icao);
        if (!me || !me.position) return null;
        const dx = visual.x - me.position.x;
        const dy = visual.y - me.position.y;
        const dz = visual.z - me.position.z;
        return Math.sqrt(dx * dx + dy * dy + dz * dz);
      }, trackedIcao);
    }

    // Tolerance: the model and detectable both read _cachedDRPosition, so the
    // delta should be ~0. A regression (model recomputing dead-reckon on a later
    // frameNumber) produced a visible front-back jitter = tens to hundreds of m.
    // Allow 5 m for float noise / partial-frame sampling.
    const JITTER_TOL_M = 5;
    const samples = jitterResult.values.filter((v) => v != null);
    if (samples.length < 5) {
      skip('jitter: model visual centre === detectable pos', `only ${samples.length} usable samples (positions unavailable)`);
    } else {
      const maxDelta = Math.max(...samples);
      record('jitter: max|visual centre − detectable| ≈ 0 over frames', maxDelta <= JITTER_TOL_M,
        `max=${maxDelta.toFixed(3)} m over ${samples.length} frames (tol ${JITTER_TOL_M} m, mode=${modelUp ? 'model-matrix' : 'display-contract'})`);
    }

    // ============================================================
    // INVARIANT 2: NO PULL-OUT on a track switch
    //   tracking B while tracking A must not fly to ~80 km overview.
    // ============================================================
    console.log('\nInvariant 2 — no pull-out on track switch');
    // We're currently tracking SYN001. Record camera height, then switch to
    // SYN002 and watch the camera height across frames. A pull-out = the
    // deselect flyTo to an ~80 km overview; it should be skipped on a switch.
    const planeA = SYNTH.flights[0].icao;
    const planeB = SYNTH.flights[1].icao;

    // Ensure we are tracking A and have a settled (low) follow height first.
    await evalPage((icao) => {
      window.__godsEyeView.dataManager.layers.get('flights').module.trackById(icao);
    }, planeA);
    await sleep(1500);

    const heightBefore = await evalPage(() => window.__godsEyeView.viewer.camera.positionCartographic.height);

    // Switch to B and immediately start sampling camera height every frame.
    const switchSamples = await page.evaluate(async (icao, frames) => {
      const v = window.__godsEyeView.viewer;
      const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
      const heights = [];
      const onTick = () => { heights.push(v.camera.positionCartographic.height); };
      const remove = v.scene.postRender.addEventListener(onTick);
      fl.trackById(icao); // the SWITCH — must NOT trigger the deselect pull-out flyTo
      await new Promise((res) => {
        let n = 0;
        let settled = false;
        const finish = () => {
          if (settled) return;
          settled = true;
          clearTimeout(timer);
          stop();
          res();
        };
        const stop = v.scene.postRender.addEventListener(() => {
          if (++n >= frames) {
            finish();
            return;
          }
          v.scene.requestRender();
        });
        const timer = setTimeout(finish, Math.max(15000, frames * 1500));
        v.scene.requestRender();
      });
      remove();
      return heights;
    }, planeB, 45);

    const maxHeight = Math.max(heightBefore, ...switchSamples);
    // The follow camera for these planes sits a few km up (altitude*1.1+2500,
    // clamped 3-30 km). The "pull-out" bug flew to ~80 km. Fail if the camera
    // ever climbs past 50 km — comfortably above the legit follow band, well
    // below the 80 km overview.
    const PULLOUT_CEIL_M = 50000;
    record('pull-out: camera stays in follow band on switch (no ~80 km spike)',
      maxHeight < PULLOUT_CEIL_M,
      `maxHeight=${(maxHeight / 1000).toFixed(1)} km (before=${(heightBefore / 1000).toFixed(1)} km, ceil ${PULLOUT_CEIL_M / 1000} km)`);

    // Confirm the switch actually took effect (we are now tracking B).
    const nowTrackingB = await evalPage((icao) => {
      const ti = window.__godsEyeView.dataManager.layers.get('flights').module.getTrackedInfo();
      return !!(ti && ti.icao24 === icao);
    }, planeB);
    record('pull-out: track switch actually landed on plane B', nowTrackingB,
      nowTrackingB ? 'tracking B' : 'switch did not land');

    // ============================================================
    // INVARIANT 3: NO CROSS-LAYER ORPHAN
    //   track military, then commercial → military.getTrackedInfo()===null,
    //   and the reverse.
    // ============================================================
    console.log('\nInvariant 3 — no cross-layer orphan');
    const milHex = SYNTH.military[0].hex;
    const comIcao = SYNTH.flights[2].icao;

    // (a) military first, then commercial → military must clear.
    const cross1 = await evalPage(async (hex, icao) => {
      const dm = window.__godsEyeView.dataManager;
      const mil = dm.layers.get('military').module;
      const fl = dm.layers.get('flights').module;
      mil.trackById(hex);
      await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
      const milTrackedBefore = !!mil.getTrackedInfo();
      fl.trackById(icao); // tracking commercial flips viewer.trackedEntity → military listener fires
      await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
      return {
        milTrackedBefore,
        milTrackedAfter: !!mil.getTrackedInfo(),
        flTrackedAfter: !!fl.getTrackedInfo(),
      };
    }, milHex, comIcao);
    record('orphan: military clears when commercial is tracked',
      cross1.milTrackedBefore && cross1.milTrackedAfter === false && cross1.flTrackedAfter === true,
      `mil before=${cross1.milTrackedBefore} mil after=${cross1.milTrackedAfter} fl after=${cross1.flTrackedAfter}`);

    // (b) commercial first, then military → commercial must clear.
    const cross2 = await evalPage(async (hex, icao) => {
      const dm = window.__godsEyeView.dataManager;
      const mil = dm.layers.get('military').module;
      const fl = dm.layers.get('flights').module;
      fl.trackById(icao);
      await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
      const flTrackedBefore = !!fl.getTrackedInfo();
      mil.trackById(hex);
      await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
      return {
        flTrackedBefore,
        flTrackedAfter: !!fl.getTrackedInfo(),
        milTrackedAfter: !!mil.getTrackedInfo(),
      };
    }, milHex, comIcao);
    record('orphan: commercial clears when military is tracked',
      cross2.flTrackedBefore && cross2.flTrackedAfter === false && cross2.milTrackedAfter === true,
      `fl before=${cross2.flTrackedBefore} fl after=${cross2.flTrackedAfter} mil after=${cross2.milTrackedAfter}`);

    // No console errors should have accumulated during the tracking exercises.
    record('no console errors during tracking exercises', consoleErrors.length === 0,
      consoleErrors.length ? `${consoleErrors.length}: ${consoleErrors.slice(0, 3).join(' | ')}` : 'clean');

    // ============================================================
    // REGRESSION H1 (pre-ship audit 2026-07-01): clicking the very plane
    // you're tracking (3D on) must be a NO-OP — no deselect, no 80 km
    // pull-out. The tracked standalone model previously carried NO pick id,
    // so scene.pick read the click as empty space → the deselect flyTo.
    // ============================================================
    console.log('\nRegression H1 — click on the tracked plane is a no-op');
    const h1Icao = SYNTH.flights[0].icao;
    await evalPage((icao) => {
      window.__godsEyeView.dataManager.layers.get('flights').module.trackById(icao);
    }, h1Icao);
    await sleep(1500); // follow camera settles; tracked GLB load kicks off

    // (i) The tracked standalone model must expose its pick id (= the icao).
    const h1ModelUp = await page.waitForFunction((icao) => {
      const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
      const ti = fl.getTrackedInfo();
      if (!ti || ti.icao24 !== icao) return false;
      const found = window.__findTrackedModel ? window.__findTrackedModel() : null;
      return !!(found && found.ready && found.show && String(found.id) === icao);
    }, { timeout: 60000, polling: 250 }, h1Icao).then(() => true).catch(() => false);

    if (h1ModelUp) {
      const modelPickId = await evalPage(() => {
        const m = window.__findTrackedModel();
        return m && m.id !== undefined && m.id !== null ? String(m.id) : null;
      });
      record('H1: tracked standalone model exposes its pick id', modelPickId === h1Icao,
        `model.id=${JSON.stringify(modelPickId)} (want "${h1Icao}")`);
    } else if (!glbBackendCapable) {
      skip('H1: tracked standalone model exposes its pick id',
        `independent GLB control unavailable (${glbControlDetail})`);
    } else {
      record('H1: tracked standalone model exposes its pick id', false,
        'independent GLB control rendered, but the product tracked model did not');
    }

    // (ii) Synthetic click at the tracked plane's screen position. Search a
    // small grid around the projected display position for a point where
    // scene.pick actually returns the tracked plane (its model's icao pick id
    // or the tracked entity) so the click is deterministic — a miss would be
    // a LEGIT empty-space deselect, not the H1 signature.
    const h1ClickPoint = await evalPage(() => {
      const v = window.__godsEyeView.viewer;
      const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
      const ti = fl.getTrackedInfo();
      if (!ti) return null;
      const ent = v.trackedEntity;
      const disp = ent && typeof ent.gevDisplayPosition === 'function' ? ent.gevDisplayPosition() : null;
      const pos = disp || ti.position;
      if (!pos) return null;
      const center = v.scene.cartesianToCanvasCoordinates(pos);
      if (!center) return null;
      const isTrackedPick = (picked) => {
        if (!picked) return null;
        if (picked.id === ent) return 'entity';
        const raw = typeof picked.id === 'string' ? picked.id : (picked.primitive && picked.primitive.id);
        return raw === ti.icao24 ? 'icao-pick' : null;
      };
      const offsets = [[0, 0]];
      for (const r of [3, 6, 10, 16, 24]) {
        for (const [dx, dy] of [[r, 0], [-r, 0], [0, r], [0, -r], [r, r], [-r, -r], [r, -r], [-r, r]]) {
          offsets.push([dx, dy]);
        }
      }
      for (const [dx, dy] of offsets) {
        const pt = { x: center.x + dx, y: center.y + dy };
        let picked = null;
        try { picked = v.scene.pick(pt); } catch { picked = null; }
        const via = isTrackedPick(picked);
        if (via) return { x: pt.x, y: pt.y, via };
      }
      return { x: center.x, y: center.y, via: null };
    });

    if (!h1ClickPoint || !h1ClickPoint.via) {
      skip('H1: click on tracked plane keeps tracking (no deselect)',
        'scene.pick could not resolve the tracked plane at its screen position (GL backend picking)');
      skip('H1: click on tracked plane does not pull the camera out',
        'scene.pick could not resolve the tracked plane at its screen position (GL backend picking)');
    } else {
      const h1HeightBefore = await evalPage(() => window.__godsEyeView.viewer.camera.positionCartographic.height);
      // Trusted mouse click through the browser event pipeline → the layer's
      // ScreenSpaceEventHandler LEFT_CLICK path (the exact H1 code path).
      await page.mouse.click(h1ClickPoint.x, h1ClickPoint.y);
      const h1Heights = await page.evaluate(async (frames) => {
        const v = window.__godsEyeView.viewer;
        const heights = [];
        await new Promise((res) => {
          let n = 0;
          let settled = false;
          const finish = () => {
            if (settled) return;
            settled = true;
            clearTimeout(timer);
            stop();
            res();
          };
          const stop = v.scene.postRender.addEventListener(() => {
            heights.push(v.camera.positionCartographic.height);
            if (++n >= frames) {
              finish();
              return;
            }
            v.scene.requestRender();
          });
          const timer = setTimeout(finish, Math.max(15000, frames * 1500));
          v.scene.requestRender();
        });
        return heights;
      }, 45);
      const h1StillTracking = await evalPage((icao) => {
        const ti = window.__godsEyeView.dataManager.layers.get('flights').module.getTrackedInfo();
        return !!(ti && ti.icao24 === icao) && !!window.__godsEyeView.viewer.trackedEntity;
      }, h1Icao);
      record('H1: click on tracked plane keeps tracking (no deselect)', h1StillTracking,
        `picked via ${h1ClickPoint.via}; still tracking=${h1StillTracking}`);
      const h1MaxHeight = Math.max(h1HeightBefore, ...h1Heights);
      record('H1: click on tracked plane does not pull the camera out', h1MaxHeight < PULLOUT_CEIL_M,
        `maxHeight=${(h1MaxHeight / 1000).toFixed(1)} km (before=${(h1HeightBefore / 1000).toFixed(1)} km, ceil ${PULLOUT_CEIL_M / 1000} km)`);
    }

    // ============================================================
    // REGRESSION M3 (rewritten 2026-07-02 — deliberate behavior change):
    // when the TRACKED plane ages out (3 missed polls), tracking must clear
    // and the camera must be RELEASED IN PLACE — viewer.trackedEntity
    // undefined and NO jump (the old contract flew an ~80 km overview; the
    // owner field-ruled that wrong: "it randomly zooms way up and loses my
    // context"). The M3 ordering fix stays: tracking is cleared BEFORE the
    // removal loop deletes the plane's state, so we never sit mid-follow
    // with stale tracking state.
    // ============================================================
    console.log('\nRegression M3 — tracked plane age-out releases the camera in place');
    const m3Icao = SYNTH.flights[0].icao;
    await evalPage((icao) => {
      window.__godsEyeView.dataManager.layers.get('flights').module.trackById(icao);
    }, m3Icao);
    await sleep(1200); // settle in the low follow band

    const m3 = await evalPage(async (icao) => {
      const v = window.__godsEyeView.viewer;
      const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
      const beforeTracking = !!fl.getTrackedInfo();
      // Simulate the age-out via the shim: the plane stops arriving.
      window.__SYNTH.flights = window.__SYNTH.flights.filter((f) => f.icao !== icao);
      // MISSING_POLL_LIMIT = 3 consecutive absent polls → removal + clear.
      // Capture the camera pose right BEFORE the removing poll — the follow
      // camera drifts with the coasting plane until the instant of release,
      // so this is the "where the user was looking" reference.
      await fl.update(v);
      await fl.update(v);
      const c0 = v.camera.positionCartographic;
      const atAgeOut = {
        lonDeg: (c0.longitude * 180) / Math.PI,
        latDeg: (c0.latitude * 180) / Math.PI,
        height: c0.height,
      };
      await fl.update(v); // third miss → removal + clear + in-place release
      return {
        beforeTracking,
        atAgeOut,
        stillTrackedAfter: !!fl.getTrackedInfo(),
        viewerStillTracking: !!v.trackedEntity,
      };
    }, m3Icao);

    record('M3: tracking cleared after the tracked plane ages out (getTrackedInfo null)',
      m3.beforeTracking && !m3.stillTrackedAfter,
      `before=${m3.beforeTracking} trackedAfter=${m3.stillTrackedAfter}`);
    record('M3: camera released after age-out (viewer.trackedEntity undefined)',
      !m3.viewerStillTracking,
      `viewerTracked=${m3.viewerStillTracking}`);

    // The camera must NOT move after the release: no overview flyTo, no
    // snap — it stays where the follow left it. Sample heights across frames
    // (any transient flyTo would show up here), then read the settled pose.
    const m3Heights = await page.evaluate(async (frames) => {
      const v = window.__godsEyeView.viewer;
      const heights = [];
      await new Promise((res) => {
        let n = 0;
        let settled = false;
        const finish = () => {
          if (settled) return;
          settled = true;
          clearTimeout(timer);
          stop();
          res();
        };
        const stop = v.scene.postRender.addEventListener(() => {
          heights.push(v.camera.positionCartographic.height);
          if (++n >= frames) {
            finish();
            return;
          }
          v.scene.requestRender();
        });
        const timer = setTimeout(finish, Math.max(15000, frames * 1500));
        v.scene.requestRender();
      });
      return heights;
    }, 90);
    await sleep(800); // any (regressed) 0.6 s flyTo would have finished by now
    const m3Final = await evalPage(() => {
      const c = window.__godsEyeView.viewer.camera.positionCartographic;
      return {
        lonDeg: (c.longitude * 180) / Math.PI,
        latDeg: (c.latitude * 180) / Math.PI,
        height: c.height,
      };
    });
    // Tolerances: the release must hold the camera within ~2 km of where it
    // was at age-out time (the follow band sits a few km up; the old overview
    // flyTo climbed +80 km, orders of magnitude outside this budget).
    const M3_STAY_TOL_M = 2000;
    const m3AltDeltaM = Math.max(
      Math.abs(m3Final.height - m3.atAgeOut.height),
      ...m3Heights.map((h) => Math.abs(h - m3.atAgeOut.height)),
    );
    const m3HorizDeltaM = haversineMeters(
      m3.atAgeOut.latDeg, m3.atAgeOut.lonDeg, m3Final.latDeg, m3Final.lonDeg,
    );
    record('M3: camera stayed in place after age-out — altitude Δ < 2 km',
      m3AltDeltaM < M3_STAY_TOL_M,
      `Δalt=${(m3AltDeltaM / 1000).toFixed(2)} km (tol ${M3_STAY_TOL_M / 1000} km; ageOut=${(m3.atAgeOut.height / 1000).toFixed(1)} km, final=${(m3Final.height / 1000).toFixed(1)} km)`);
    record('M3: camera stayed in place after age-out — horizontal Δ < 2 km',
      m3HorizDeltaM < M3_STAY_TOL_M,
      `Δhoriz=${(m3HorizDeltaM / 1000).toFixed(2)} km (tol ${M3_STAY_TOL_M / 1000} km)`);

    // ============================================================
    // CHANGE 2a (2026-07-02): landing-ghost fast cull. A plane whose last
    // fix is LOW + SLOW (landed — the feed's ground flag lags the actual
    // landing) is removed after ONE missed poll, not the 3-poll grace; a
    // cruise plane that misses a poll keeps the full grace (it absorbs real
    // feed gaps — owner-confirmed important). Both layers.
    // ============================================================
    console.log('\nChange 2a — landing-ghost fast cull (1 missed poll; cruise grace intact)');
    const fastCull = await evalPage(async () => {
      const v = window.__godsEyeView.viewer;
      const dm = window.__godsEyeView.dataManager;
      const fl = dm.layers.get('flights').module;
      const mil = dm.layers.get('military').module;
      const has = (mod, id) => mod.getAllPositions(2000).some((p) => p.id === id);

      // Landed commercial plane: 120 m baro, 18 m/s (~35 kt) — under both
      // fast-cull gates (LANDED_ALT_MAX_M=150 m, LANDED_SPEED_MAX_MPS=23).
      window.__SYNTH.flights.push({ icao: 'aaa044', callsign: 'SYN044', lon: -97.7420, lat: 30.2660, alt: 120, vel: 18, track: 180 });
      // Landed military plane: 300 ft (~91 m) baro, 20 kt (~10 m/s).
      window.__SYNTH.military.push({ hex: 'bbb103', flight: 'MIL103', lon: -97.7480, lat: 30.2680, altFt: 300, track: 90, gsKt: 20, t: 'C130', r: 'AF-103' });
      await fl.update(v);
      await mil.update(v);
      const ingested = { fl: has(fl, 'aaa044'), mil: has(mil, 'bbb103') };

      // Both landed planes AND the cruise control (aaa002: 9500 m, 210 m/s)
      // vanish from the feed in the SAME poll.
      const cruise = window.__SYNTH.flights.find((f) => f.icao === 'aaa002');
      window.__SYNTH.flights = window.__SYNTH.flights.filter((f) => f.icao !== 'aaa044' && f.icao !== 'aaa002');
      window.__SYNTH.military = window.__SYNTH.military.filter((m) => m.hex !== 'bbb103');
      await fl.update(v);  // missed poll #1
      await mil.update(v); // missed poll #1
      const afterOneMiss = {
        landedGone: !has(fl, 'aaa044'),
        milLandedGone: !has(mil, 'bbb103'),
        cruiseStillThere: has(fl, 'aaa002'),
      };
      // Put the cruise plane back so any later polls aren't disturbed.
      if (cruise) window.__SYNTH.flights.push(cruise);
      await fl.update(v);
      return { ingested, afterOneMiss };
    });
    record('fast-cull: landed low+slow synthetics ingested (both layers)',
      fastCull.ingested.fl && fastCull.ingested.mil,
      `flights=${fastCull.ingested.fl} military=${fastCull.ingested.mil}`);
    record('fast-cull: landed plane removed after ONE missed poll (flights)',
      fastCull.afterOneMiss.landedGone,
      `gone=${fastCull.afterOneMiss.landedGone} (grace skipped, was 3 polls)`);
    record('fast-cull: landed plane removed after ONE missed poll (military)',
      fastCull.afterOneMiss.milLandedGone,
      `gone=${fastCull.afterOneMiss.milLandedGone} (grace skipped, was 3 polls)`);
    record('fast-cull: cruise plane keeps the 3-poll grace (present after 1 miss)',
      fastCull.afterOneMiss.cruiseStillThere,
      `present=${fastCull.afterOneMiss.cruiseStillThere}`);

    // ============================================================
    // CHANGE 2b (2026-07-02): honest readout. While the TRACKED plane is in
    // its missed-poll grace (rendered but absent from the latest poll), the
    // tracked label/readout must carry the "· STALE" cue — and drop it the
    // moment the plane reappears in the feed.
    // ============================================================
    console.log('\nChange 2b — tracked readout STALE cue during missed-poll grace');
    const staleCheck = await evalPage(async () => {
      const v = window.__godsEyeView.viewer;
      const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
      const labelText = () => {
        const ent = v.trackedEntity;
        if (!ent) return null;
        // Post overlay-unification the tracked text lives in the host
        // presentation model (entities are asserted native-label-free);
        // the native read stays as a fallback so this probe still fails
        // loudly if BOTH surfaces are ever absent.
        const model = ent.gevLabelModel;
        if (model) return [model.title, ...(model.details || [])].filter(Boolean).join('\n');
        if (!ent.label || !ent.label.text) return null;
        const t = ent.label.text;
        return typeof t === 'string' ? t : (t.getValue ? String(t.getValue(v.clock.currentTime)) : null);
      };
      // Track a cruise plane that IS in the feed (aaa003: 8700 m, 250 m/s —
      // normal grace, so one missed poll leaves it rendered-but-stale).
      fl.trackById('aaa003');
      await fl.update(v); // plane present → fresh label
      const freshLabel = labelText();
      const syn3 = window.__SYNTH.flights.find((f) => f.icao === 'aaa003');
      window.__SYNTH.flights = window.__SYNTH.flights.filter((f) => f.icao !== 'aaa003');
      await fl.update(v); // missed poll #1 → grace → label refreshed with cue
      const staleLabel = labelText();
      if (syn3) window.__SYNTH.flights.push(syn3);
      await fl.update(v); // plane back → label rebuilt without the cue
      const recoveredLabel = labelText();
      fl.stopTracking(); // leave nothing tracked
      return { freshLabel, staleLabel, recoveredLabel };
    });
    record('stale-readout: tracked label carries STALE cue during grace',
      !!staleCheck.staleLabel && staleCheck.staleLabel.includes('STALE')
        && !!staleCheck.freshLabel && !staleCheck.freshLabel.includes('STALE'),
      `fresh="${staleCheck.freshLabel && staleCheck.freshLabel.split('\n')[0]}" stale="${staleCheck.staleLabel && staleCheck.staleLabel.split('\n')[0]}"`);
    record('stale-readout: STALE cue clears when the plane reappears',
      !!staleCheck.recoveredLabel && !staleCheck.recoveredLabel.includes('STALE'),
      `recovered="${staleCheck.recoveredLabel && staleCheck.recoveredLabel.split('\n')[0]}"`);

    // ============================================================
    // CHANGE 3 (2026-07-03): ground traffic is a FEATURE. Present-but-
    // grounded planes render FULL-STRENGTH in the airborne tint pipeline
    // (white / amber-military — owner verdict, same-day reversal of the
    // day-1 gray 50%-alpha muted style: "just leave them as white … in NYC
    // I can barely see them") at ×0.8 scale; "on the ground" reads from
    // scale + no trail, never from a fade, so the 45%-alpha stale fade
    // stays unambiguous. The on_ground flip restyles the SAME billboard in
    // place (landing/takeoff transition, never a removal); a grounded plane
    // that then VANISHES from the feed still fast-culls after ONE missed
    // poll. Military mirror keys off adsb.lol's alt_baro === "ground".
    // ============================================================
    console.log('\nChange 3 — ground traffic: full-alpha style, in-place transitions, fast cull');
    const ground = await evalPage(async () => {
      const v = window.__godsEyeView.viewer;
      const dm = window.__godsEyeView.dataManager;
      const fl = dm.layers.get('flights').module;
      const mil = dm.layers.get('military').module;
      const findBB = (id) => {
        let found = null;
        const walk = (coll) => {
          const n = coll.length;
          for (let i = 0; i < n; i++) {
            let p;
            try { p = coll.get(i); } catch { continue; }
            if (!p) continue;
            if (typeof p.length === 'number' && typeof p.get === 'function') { walk(p); continue; }
            if (p.image !== undefined && p.alignedAxis !== undefined && p.id === id) found = p;
          }
        };
        walk(v.scene.primitives);
        return found;
      };
      const snap = (id) => {
        const bb = findBB(id);
        if (!bb) return null;
        const c = bb.color;
        return {
          show: bb.show, scale: bb.scale, alpha: c.alpha, red: c.red, green: c.green, blue: c.blue,
          // Infinity doesn't survive puppeteer's JSON transport — encode it.
          ddtd: bb.disableDepthTestDistance === Number.POSITIVE_INFINITY ? 'inf' : bb.disableDepthTestDistance,
        };
      };

      // 1. On-ground planes ingest + render full-strength (both layers).
      window.__SYNTH.flights.push({ icao: 'aaa066', callsign: 'GND066', lon: -97.7425, lat: 30.2665, alt: 150, vel: 7, track: 45, onGround: true });
      window.__SYNTH.military.push({ hex: 'bbb166', flight: 'MILGND1', lon: -97.7490, lat: 30.2690, altFt: 'ground', track: 120, gsKt: 12, t: 'C130', r: 'AF-166' });
      await fl.update(v);
      await mil.update(v);
      const groundSnap = snap('aaa066');
      const milGroundSnap = snap('bbb166');
      const detectable = fl.getDetectableObjects({ maxCount: 1000 }).some((d) => d.id === 'GND066');

      // 2. Takeoff: the flag flips false — same billboard, airborne style.
      const gnd = window.__SYNTH.flights.find((f) => f.icao === 'aaa066');
      gnd.onGround = false; gnd.alt = 900; gnd.vel = 75;
      await fl.update(v);
      const airSnap = snap('aaa066');

      // 3. Landing: the flag flips back true — ground scale again, still in place.
      gnd.onGround = true; gnd.alt = 150; gnd.vel = 9;
      await fl.update(v);
      const groundAgainSnap = snap('aaa066');

      // 4. Feed-dropped grounded planes (re-pinned round 7, owner field data
      //    "parked planes churn/never heal"): the fast cull now requires
      //    AIRBORNE history this session. aaa066 flew (step 2) then landed
      //    then dropped → the landing-ghost fast-cull still fires after ONE
      //    missed poll. bbb166 was BORN grounded (parked class) → it rides
      //    the normal MISSING_POLL_LIMIT grace and must SURVIVE the first
      //    missed poll, keeping its identity/floor state across feed flaps.
      window.__SYNTH.flights = window.__SYNTH.flights.filter((f) => f.icao !== 'aaa066');
      window.__SYNTH.military = window.__SYNTH.military.filter((m) => m.hex !== 'bbb166');
      await fl.update(v);
      await mil.update(v);
      return {
        groundSnap, milGroundSnap, detectable, airSnap, groundAgainSnap,
        droppedGone: !snap('aaa066'),
        milDroppedGone: !snap('bbb166'),
      };
    });
    const fmtSnap = (s) => (s ? `show=${s.show} scale=${s.scale.toFixed(3)} rgba=(${s.red.toFixed(2)},${s.green.toFixed(2)},${s.blue.toFixed(2)},${s.alpha.toFixed(2)})` : 'missing');
    // Ground style (owner verdict 2026-07-03): FULL-ALPHA airborne tint —
    // white in the flights layer, amber (#FFB800) in the military layer —
    // never the 45%-alpha stale fade, never the retired gray mute. The
    // ground cue is the ×0.8 scale (klass default ⇒ base 1.0).
    const isFullWhite = (s) => !!s && s.show && s.alpha === 1 && s.red === 1 && s.green === 1 && s.blue === 1;
    const isFullAmber = (s) => !!s && s.show && s.alpha === 1 && s.red === 1 && s.blue === 0 && Math.abs(s.green - 0xB8 / 255) < 0.02;
    record('ground: on-ground plane renders full-alpha white at ground scale + detectable (flights)',
      isFullWhite(ground.groundSnap) && Math.abs(ground.groundSnap.scale - 0.8) < 1e-6 && ground.detectable,
      `${fmtSnap(ground.groundSnap)} detectable=${ground.detectable}`);
    record('ground: military mirror — alt_baro "ground" renders full-alpha amber',
      isFullAmber(ground.milGroundSnap),
      fmtSnap(ground.milGroundSnap));
    record('ground: takeoff flip restyles in place (white, full alpha, full scale)',
      isFullWhite(ground.airSnap) && Math.abs(ground.airSnap.scale - 1) < 1e-6,
      fmtSnap(ground.airSnap));
    record('ground: landing flip returns to ground scale in place (no removal, still full alpha)',
      isFullWhite(ground.groundAgainSnap) && Math.abs(ground.groundAgainSnap.scale - 0.8) < 1e-6,
      fmtSnap(ground.groundAgainSnap));
    record('ground: landing ghost fast-culls after ONE missed poll; born-parked contact survives the flap (round 7)',
      ground.droppedGone && !ground.milDroppedGone,
      `flights(landed ghost) gone=${ground.droppedGone} military(born parked) gone=${ground.milDroppedGone} (want true/false)`);
    // Fix 2 (2026-07-03 field test): ground planes VANISHED when zooming into
    // airports — grounded altitudes sit at/below the photoreal tile skin, so the
    // depth test buried the billboard up close (log-depth imprecision let it win
    // from orbit). RE-PINNED for round 5 (owner directive 2026-07-06: "I just
    // want the planes and their lines to ALWAYS be visible... evenly
    // applied"): EVERY billboard — grounded, airborne, before and after a
    // ground flip — renders with disableDepthTestDistance = +Infinity. The
    // old grounded-only rule kept leaving classes of contacts buried (Austin
    // QNH-below-field traffic not yet flagged on_ground). Far-side contacts
    // are removed by the fleet tick's horizon occluder, which never depended
    // on the depth test. A real-machine eyeball should confirm: zooming from
    // orbit to street level, NO aircraft icon ever vanishes into the mesh.
    record('ground: depth test disabled for EVERY contact (always visible), incl. across ground flips',
      ground.groundSnap?.ddtd === 'inf' && ground.milGroundSnap?.ddtd === 'inf'
        && ground.airSnap?.ddtd === 'inf' && ground.groundAgainSnap?.ddtd === 'inf',
      `flights=${ground.groundSnap?.ddtd} mil=${ground.milGroundSnap?.ddtd} takeoff=${ground.airSnap?.ddtd} landing=${ground.groundAgainSnap?.ddtd}`);

    // ============================================================
    // GROUND 3D (2026-07-03, owner decision LOCKED): "when I have 3D mode —
    // proximity or all — I want that respected regardless of whether a plane
    // is on the ground or in the air. No distinction."
    //  (a) a synthetic on_ground plane is model-ELIGIBLE (not skipped),
    //  (b) it gets a model under the existing cap (both layers),
    //  (c) the model matrix height = stubbed scene.sampleHeight + the layer's
    //      belly offset — the one-shot cached ground snap — NOT the buried/
    //      floating feed altitude (flights alt 150 m / military "ground" → 0 m),
    //  (d) the TRACKED grounded plane gets the standalone tracked model,
    //  (e) the snap is ONE-SHOT cached: sample count stays flat across frames.
    // Height probe: |modelMatrix translation| − |billboard position| — at one
    // lat/lon a geodetic height change moves the point along the ellipsoid
    // normal, whose angle to the radial at Austin's latitude costs < 0.001%.
    //
    // RETARGETED 2026-08-03 (weld). (c) still pins exactly what it always did —
    // the MODEL rides the sampled skin while the BILLBOARD stays at the reported
    // altitude — and that split is by design and unchanged. What changed is the
    // CONSUMER anchor: detection brackets/labels and the tracked card used to
    // follow the billboard, so on a grounded plane they sat ~100 m below the
    // aircraft you can see and rose only as the coarse ground-floor cell warmed
    // ("the buoy"), sometimes never converging. They now follow whatever owns the
    // visual. So do NOT read the non-zero Δ below as "the anchor is the
    // billboard" — it is the model-vs-billboard split, and the weld group that
    // follows pins the anchor itself.
    // ============================================================
    console.log('\nGround 3D — grounded planes are model-eligible + snapped to the sampled skin');
    const GROUND3D_STUB_H = 187.5; // stubbed tile-skin height (m, ellipsoid)
    // Expected belly offsets (m): native origin-above-lowest-vertex × MODEL_SCALE
    // × CLASS_SCALE_3D[klass] — constants match the layers' MODEL_BELLY_OFFSET_NATIVE
    // / MODEL_SCALE pairs, which modelScale.test.mjs locks against the GLBs.
    // Class is computed with the REAL classifier on the synthetic feed fields.
    const g3dFlKlass = classifyAircraft({ typeCode: null, category: null });
    const g3dMilKlass = classifyAircraft({ typeCode: 'C130', category: undefined });
    const g3dFlOffset = 6.719 * 1 * (CLASS_SCALE_3D[g3dFlKlass] || 1); // airplane.glb, flights
    // Hangar fleet (2026-08-16): military C130 → turboprop → the real atr72.glb,
    // whose belly offset is the registry's measured bellyM (meters, scale 1) —
    // NOT the jet.glb 5.631 × class formula. Pinned by modelScale.test.mjs.
    const g3dMilOffset = CLASS_MODEL_REAL[g3dMilKlass]?.bellyM
      ?? 5.631 * 1 * (CLASS_SCALE_3D[g3dMilKlass] || 1); // jet.glb fallback classes
    // Height-datum fix (Task 6): the flights-layer billboard for a grounded synthetic
    // (no geo_altitude in this stub feed, no warm terrain-height cache in a headless
    // run) now renders at baroM + geoidHeight(lat, lon) rather than the raw baro
    // value verbatim — pickRenderAltitudeM's documented visual-fallback branch.
    // Height-datum fix (Task 7): militaryFlights.js now runs the pickRenderAltitudeM
    // chain too, but DELIBERATELY passes surfaceM=null for the on-ground billboard
    // (brief item 3, "don't double-correct"): a grounded plane's MODEL already rides
    // groundSnap.js's one-shot tileset sample, and its billboard is depth-test-free,
    // so re-correcting the billboard to the ellipsoidal surface would (a) double-
    // correct the same grounded plane and (b) — because military ground rows carry
    // NO baro ("alt_baro":"ground") — jump the billboard 0 -> ~surface between polls,
    // dragging the model's ground-snap input past groundSnap's 50 m move threshold
    // and forcing a re-sample (breaks the ONE-SHOT invariant asserted below).
    // So bbb177 (on-ground, no alt_geom in the stub feed, no numeric alt_baro,
    // surfaceM forced null) makes pickRenderAltitudeM return its null sentinel and
    // the military layer falls through to its SAME pre-Task-7 default (`altitudeM` —
    // 0 m for an on-ground record with no sticky prior). Expected value unchanged
    // (0 m), but now the documented Task-7 code path rather than "untouched by Task 7".
    await ensureGeoidReady();
    const g3dFlGeoidN = geoidHeight(30.2668, -97.7445); // aaa077's lat/lon (Austin)

    let g3dSetup = null;
    let g3dPrimaryFailure = null;
    let g3dCleanupFailure = null;
    try {
      g3dSetup = await evalPage(() => {
        const gev = window.__godsEyeView;
        const scene = gev.viewer.scene;
        const dm = gev.dataManager;
        const flights = dm.layers.get('flights').module;
        const military = dm.layers.get('military').module;
        const priorModels3d = {
          flights: flights.getParams().models3d,
          military: military.getParams().models3d,
        };
        const priorSampleHeight = scene.sampleHeight;
        // Keep the previous run-wide no-height seam in the page. Functions cannot
        // cross the Puppeteer serialization boundary, so cleanup restores it from
        // this private slot instead of deleting the scene's own property.
        window.__g3dPriorSampleHeight = priorSampleHeight;
        window.__g3dPriorTilesLoadedDescriptor = gev.tileset
          ? Object.getOwnPropertyDescriptor(gev.tileset, 'tilesLoaded')
          : null;
        try {
          // 3D models on (QA param) — the owner decision under test.
          flights.setParams({ models3d: true });
          military.setParams({ models3d: true });
          // Force the ground snap's tiles-ready gate open (b9b pattern): headless the
          // Google tileset never finishes streaming, so tilesLoaded stays false.
          let tilesForced = false;
          try {
            if (gev.tileset) {
              Object.defineProperty(gev.tileset, 'tilesLoaded', { value: true, configurable: true });
              tilesForced = gev.tileset.tilesLoaded === true;
            } else {
              tilesForced = true; // no tileset → groundSnap treats tiles as ready
            }
          } catch { tilesForced = false; }
          // Deterministic sampleHeight stub + call counter (headless has no real skin).
          window.__g3dSampleCalls = 0;
          window.__g3dSampleHits = { flights: 0, military: 0 };
          const fixturePoints = {
            flights: { lat: 30.2668, lon: -97.7445 },
            military: { lat: 30.2685, lon: -97.7470 },
          };
          scene.sampleHeight = function (cartographic) {
            window.__g3dSampleCalls += 1;
            // Attribute each sample to the fixture's distinct ~111 m mesh cell.
            // This prevents one successfully sampled contact from satisfying the
            // two-contact integrity assertion below.
            const lat = Number(cartographic?.latitude) * 180 / Math.PI;
            const lon = Number(cartographic?.longitude) * 180 / Math.PI;
            if (Number.isFinite(lat) && Number.isFinite(lon)) {
              for (const [layer, target] of Object.entries(fixturePoints)) {
                const dLat = lat - target.lat;
                const dLon = (lon - target.lon) * Math.cos(target.lat * Math.PI / 180);
                // 0.0008° encloses the fixture's rounded 0.001° mesh-cell
                // sample but cannot overlap the other fixture ~300 m away.
                if (Math.hypot(dLat, dLon) <= 0.0008) {
                  window.__g3dSampleHits[layer] += 1;
                }
              }
            }
            return 187.5;
          };
          return { tilesForced, priorModels3d };
        } catch (error) {
          // Setup is transactional: once the first fixture mutation lands, every
          // later setup failure restores each owned seam independently. Return
          // both outcomes across the page boundary so rollback cannot hide or
          // replace the primary setup error.
          const rollbackFailures = [];
          const attemptRollback = (label, operation) => {
            try { operation(); } catch (rollbackError) {
              rollbackFailures.push(`${label}: ${rollbackError?.message || rollbackError}`);
            }
          };
          attemptRollback('restore sampleHeight seam', () => {
            scene.sampleHeight = priorSampleHeight;
          });
          attemptRollback('restore tilesLoaded seam', () => {
            if (!gev.tileset) return;
            const prior = window.__g3dPriorTilesLoadedDescriptor;
            if (prior) Object.defineProperty(gev.tileset, 'tilesLoaded', prior);
            else delete gev.tileset.tilesLoaded;
          });
          attemptRollback('restore flights models3d', () => {
            flights.setParams({ models3d: priorModels3d.flights });
          });
          attemptRollback('restore military models3d', () => {
            military.setParams({ models3d: priorModels3d.military });
          });
          attemptRollback('delete fixture globals', () => {
            delete window.__g3dPriorSampleHeight;
            delete window.__g3dPriorTilesLoadedDescriptor;
            delete window.__g3dSampleCalls;
            delete window.__g3dSampleHits;
          });
          return {
            setupFailure: error?.message || String(error),
            rollbackFailures,
            priorModels3d,
          };
        }
      });
      if (g3dSetup.setupFailure) {
        g3dPrimaryFailure = new Error(`ground-3d setup failed: ${g3dSetup.setupFailure}`);
        if (g3dSetup.rollbackFailures.length > 0) {
          g3dCleanupFailure = new Error(
            `ground-3d setup rollback failed: ${g3dSetup.rollbackFailures.join(' | ')}`,
          );
        }
        // Setup rollback already attempted every owned seam. Prevent the
        // post-setup cleanup from running against deleted fixture globals.
        g3dSetup = null;
        throw g3dPrimaryFailure;
      }
      record('ground-3d: sampleHeight stub installed + tiles-ready forced', g3dSetup.tilesForced,
        JSON.stringify(g3dSetup));

      // Ingest one grounded plane per layer, then park the camera 8 km above them
      // (inside the model regime + add radius; on-screen so they win cap slots).
      const g3dIngest = await evalPage(async () => {
      const v = window.__godsEyeView.viewer;
      const dm = window.__godsEyeView.dataManager;
      const fl = dm.layers.get('flights').module;
      const mil = dm.layers.get('military').module;
      window.__SYNTH.flights.push({ icao: 'aaa077', callsign: 'GND077', lon: -97.7445, lat: 30.2668, alt: 150, vel: 0, track: 45, onGround: true });
      window.__SYNTH.military.push({ hex: 'bbb177', flight: 'MILGND7', lon: -97.7470, lat: 30.2685, altFt: 'ground', track: 120, gsKt: 0, t: 'C130', r: 'AF-177' });
      await fl.update(v);
      await mil.update(v);
      const findBB = (id) => {
        let found = null;
        const walk = (coll) => {
          const n = coll.length;
          for (let i = 0; i < n; i++) {
            let p;
            try { p = coll.get(i); } catch { continue; }
            if (!p) continue;
            if (typeof p.length === 'number' && typeof p.get === 'function') { walk(p); continue; }
            if (p.image !== undefined && p.alignedAxis !== undefined && p.id === id) found = p;
          }
        };
        walk(v.scene.primitives);
        return found;
      };
      const flBB = findBB('aaa077');
      const milBB = findBB('bbb177');
      if (!flBB || !milBB) return { error: `ground billboards missing (fl=${!!flBB} mil=${!!milBB})` };
      const radius = (pos) => Math.hypot(pos.x, pos.y, pos.z);
      // Park the camera 8 km radially above the flights plane (both in view nadir-ish).
      const p = flBB.position;
      const r = Math.hypot(p.x, p.y, p.z);
      const k = (r + 8000) / r;
      v.camera.cancelFlight();
      v.camera.setView({
        destination: { x: p.x * k, y: p.y * k, z: p.z * k },
        orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
      });
      return { flBBRadius: radius(flBB.position), milBBRadius: radius(milBB.position) };
      });
      if (g3dIngest.error) {
        record('ground-3d: grounded synthetics ingested', false, g3dIngest.error);
      } else {
      record('ground-3d: grounded synthetics ingested', true,
        `bb radii fl=${g3dIngest.flBBRadius.toFixed(1)} mil=${g3dIngest.milBBRadius.toFixed(1)}`);

      // In-page model finder by pick id (fleet AND tracked standalone models carry it).
      await evalPage(() => {
        window.__g3dFindModel = function (id) {
          const v = window.__godsEyeView.viewer;
          let found = null;
          const walk = (coll) => {
            const n = coll.length;
            for (let i = 0; i < n; i++) {
              let p;
              try { p = coll.get(i); } catch { continue; }
              if (!p) continue;
              if (typeof p.length === 'number' && typeof p.get === 'function') { walk(p); continue; }
              if (p.modelMatrix && typeof p.ready !== 'undefined' && p.id === id) found = p;
            }
          };
          walk(v.scene.primitives);
          return found;
        };
      });

      // (a)+(b): both grounded planes become models under the cap (the old code
      // `continue`d past them in the eligibility pre-pass — no model would EVER
      // appear). Wait for ready+shown so the handoff assert below is meaningful.
      const g3dModelsUp = await page.waitForFunction(() => {
        const fm = window.__g3dFindModel('aaa077');
        const mm = window.__g3dFindModel('bbb177');
        return !!(fm && fm.ready && fm.show && mm && mm.ready && mm.show);
      }, { timeout: 40000, polling: 250 }).then(() => true).catch(() => false);
      if (!glbBackendCapable && !g3dModelsUp) {
        skip('ground-3d: grounded planes are model-eligible and modeled (both layers)',
          `independent GLB control unavailable (${glbControlDetail}); grounded GLB readiness is not observable`);
      } else {
        record('ground-3d: grounded planes are model-eligible and modeled (both layers)', g3dModelsUp,
          g3dModelsUp ? 'fleet models up (ready+shown)' : 'models never became ready+shown');
      }

      if (g3dModelsUp) {
        // (c) + handoff + (e): heights snapped, billboards handed off, snap one-shot.
        const g3dState = await evalPage(() => {
          const v = window.__godsEyeView.viewer;
          const findBB = (id) => {
            let found = null;
            const walk = (coll) => {
              const n = coll.length;
              for (let i = 0; i < n; i++) {
                let p;
                try { p = coll.get(i); } catch { continue; }
                if (!p) continue;
                if (typeof p.length === 'number' && typeof p.get === 'function') { walk(p); continue; }
                if (p.image !== undefined && p.alignedAxis !== undefined && p.id === id) found = p;
              }
            };
            walk(v.scene.primitives);
            return found;
          };
          const modelRadius = (id) => {
            const m = window.__g3dFindModel(id);
            return m ? Math.hypot(m.modelMatrix[12], m.modelMatrix[13], m.modelMatrix[14]) : null;
          };
          return {
            flModelRadius: modelRadius('aaa077'),
            milModelRadius: modelRadius('bbb177'),
            flBBShown: findBB('aaa077')?.show ?? null,
            milBBShown: findBB('bbb177')?.show ?? null,
            sampleCalls: window.__g3dSampleCalls,
            sampleHits: { ...window.__g3dSampleHits },
          };
        });
        // Expected radial delta = (stub + offset) − billboard's rendered altitude.
        // Flights billboard altitude is baroM + geoidN (height-datum fix, Task 6 —
        // no geo_altitude/warm terrain-cache in this synthetic run, so the
        // baro-fallback branch of pickRenderAltitudeM applies). Military (Task 7)
        // runs pickRenderAltitudeM too but forces surfaceM=null for on-ground
        // billboards (don't double-correct the grounded model's tileset snap — see
        // the block above), and this synthetic has no alt_geom/alt_baro, so its
        // billboard stays at the pre-Task-7 "ground" -> 0 m default.
        const flWantDelta = (GROUND3D_STUB_H + g3dFlOffset) - (150 + g3dFlGeoidN);
        const milWantDelta = (GROUND3D_STUB_H + g3dMilOffset) - 0; // "ground" (no alt_geom/alt_baro, surfaceM forced null) → 0 m default
        const flDelta = g3dState.flModelRadius - g3dIngest.flBBRadius;
        const milDelta = g3dState.milModelRadius - g3dIngest.milBBRadius;
        const HEIGHT_TOL_M = 1.0;
        record(`ground-3d: flights model height = sampled skin + belly offset (${g3dFlKlass})`,
          Math.abs(flDelta - flWantDelta) <= HEIGHT_TOL_M,
          `Δradial=${flDelta.toFixed(2)} m want=${flWantDelta.toFixed(2)} m (stub ${GROUND3D_STUB_H} + offset ${g3dFlOffset.toFixed(2)} − alt ${(150 + g3dFlGeoidN).toFixed(2)} [150 baro + ${g3dFlGeoidN.toFixed(2)} geoidN])`);
        record(`ground-3d: military model height = sampled skin + belly offset (${g3dMilKlass})`,
          Math.abs(milDelta - milWantDelta) <= HEIGHT_TOL_M,
          `Δradial=${milDelta.toFixed(2)} m want=${milWantDelta.toFixed(2)} m (stub ${GROUND3D_STUB_H} + offset ${g3dMilOffset.toFixed(2)} − alt 0)`);
        record('ground-3d: billboard→model handoff holds on the ground (icons hidden once models render)',
          g3dState.flBBShown === false && g3dState.milBBShown === false,
          `fl bb.show=${g3dState.flBBShown} mil bb.show=${g3dState.milBBShown}`);
        const bothGroundContactsSampled = g3dState.sampleHits?.flights > 0
          && g3dState.sampleHits?.military > 0;
        record('ground-3d: both grounded synthetic contacts reached the sampling seam',
          bothGroundContactsSampled,
          `sample hits near distinct fixture cells: flights=${g3dState.sampleHits?.flights ?? 0}, military=${g3dState.sampleHits?.military ?? 0}`);

        // ============================================================
        // WELD (2026-08-03): the detection anchor follows the RENDERED aircraft.
        // With a model owning the visual, getDetectableObjects must return the
        // model's actual rendered translation, not the billboard position — the
        // two are ~100 m apart on a grounded plane. Sampled every frame for 20
        // frames because the failure this replaces was TEMPORAL: the bracket used
        // to converge slowly (or never) as the coarse floor cell warmed, so a
        // single-frame probe could pass while the live behaviour still drifted.
        // ============================================================
        const WELD_TOL_M = 2.0;
        // This guard proves the display and visual accessors have not collapsed
        // into the same position. Do not reuse WELD_TOL_M here: the measured
        // split includes wall-clock dead reckoning and can validly be only the
        // 1.51 m airliner belly offset on a faster runtime.
        const ACCESSOR_SEPARATION_EPSILON_M = 0.25;
        const weld = await page.evaluate(async (frames) => {
          const gev = window.__godsEyeView;
          const v = gev.viewer;
          const dm = gev.dataManager;
          const targets = [
            { layer: 'flights', id: 'aaa077', center: [0, 0, 0] },
            { layer: 'military', id: 'bbb177', center: [0, 0, 0] },
          ];
          const out = {};
          for (const t of targets) out[t.layer] = { maxDelta: 0, samples: 0, missing: 0 };
          await new Promise((res) => {
            let n = 0;
            let settled = false;
            const finish = () => {
              if (settled) return;
              settled = true;
              clearTimeout(timer);
              stop();
              res();
            };
            const stop = v.scene.postRender.addEventListener(() => {
              for (const t of targets) {
                const rec = out[t.layer];
                const mod = dm.layers.get(t.layer)?.module;
                const model = window.__g3dFindModel(t.id);
                const objects = mod?.getDetectableObjects?.({
                  mode: 'DENSE', maxCount: 5000, seed: 0,
                }) || [];
                const object = objects.find((o) => o && o.sourceId === t.id);
                if (!object || !object.position || !model || !model.show) {
                  rec.missing++;
                  continue;
                }
                const matrix = model.modelMatrix;
                const scale = Number.isFinite(model.computedScale)
                  ? model.computedScale
                  : (Number.isFinite(model.scale) ? model.scale : 1);
                const x = t.center[0] * scale;
                const y = t.center[1] * scale;
                const z = t.center[2] * scale;
                const visual = {
                  x: matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12],
                  y: matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13],
                  z: matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14],
                };
                const d = Math.hypot(
                  object.position.x - visual.x,
                  object.position.y - visual.y,
                  object.position.z - visual.z,
                );
                if (d > rec.maxDelta) rec.maxDelta = d;
                rec.samples++;
              }
              if (++n >= frames) {
                finish();
                return;
              }
              v.scene.requestRender();
            });
            const timer = setTimeout(finish, Math.max(15000, frames * 1500));
            v.scene.requestRender();
          });
          return out;
        }, 20);
        for (const layer of ['flights', 'military']) {
          const w = weld[layer] || { samples: 0, missing: -1, maxDelta: Infinity };
          record(`weld: ${layer} grounded detection anchor === rendered model visual centre (20 frames)`,
            w.samples >= 15 && w.missing === 0 && w.maxDelta <= WELD_TOL_M,
            `samples=${w.samples} missing=${w.missing} maxΔ=${w.maxDelta.toFixed(3)} m (tol ${WELD_TOL_M} m)`);
        }

        // (e) one-shot: drive 60 verified render frames. Correct placement above
        // proves the deterministic sample landed; the exact initial call total is
        // NOT a contract. A successful ground snap publishes the validated height
        // into the shared mesh-floor cell, so the later poll-time sampler may
        // legitimately skip that cell. The load-bearing invariant is bounded
        // growth across frames, with an explicit guard against a timed-out driver
        // falsely looking flat.
        const callsBefore = g3dState.sampleCalls;
        const fleetSampleWindow = await sampleFrames(
          page, 60, () => window.__g3dSampleCalls,
        );
        const callsAfter = await evalPage(() => window.__g3dSampleCalls);
        const fleetFramesComplete = !fleetSampleWindow.timedOut
          && fleetSampleWindow.values.length === 60;
        record('ground-3d: fleet sampling window completed all 60 requested frames',
          fleetFramesComplete,
          `frames=${fleetSampleWindow.values.length}/60 timedOut=${fleetSampleWindow.timedOut}`);
        record('ground-3d: fleet ground sampling is one-shot/per-poll bounded (no per-frame sampling)',
          fleetFramesComplete && bothGroundContactsSampled && (callsAfter - callsBefore) <= 8,
          `sampleHeight calls: before=${callsBefore}, growth over 60 verified frames=${callsAfter - callsBefore} (per-frame would be ~60+)`);

        // (d) TRACKED grounded plane → the standalone tracked model (the owner's
        // "tracked SWA143 at 0 kts stayed a 2D cyan billboard" case).
        // Start the counter BEFORE ownership changes. The previous guard began
        // only after ready+shown and could miss a regression that sampled every
        // render frame while the standalone model was loading.
        const trackedTransitionCallsBefore = callsAfter;
        await evalPage(() => {
          window.__godsEyeView.dataManager.layers.get('flights').module.trackById('aaa077');
        });
        const trackedTransitionWindow = await sampleFrames(
          page, 30, () => window.__g3dSampleCalls,
        );
        const trackedTransitionCallsAfter = await evalPage(() => window.__g3dSampleCalls);
        const trackedTransitionFramesComplete = !trackedTransitionWindow.timedOut
          && trackedTransitionWindow.values.length === 30;
        record('ground-3d: tracked loading/ownership sampling window completed all 30 requested frames',
          trackedTransitionFramesComplete,
          `frames=${trackedTransitionWindow.values.length}/30 timedOut=${trackedTransitionWindow.timedOut}`);
        record('ground-3d: tracked loading/ownership ground sampling is bounded (no per-frame sampling)',
          trackedTransitionFramesComplete
            && (trackedTransitionCallsAfter - trackedTransitionCallsBefore) <= 8,
          `sampleHeight growth from before trackById across 30 verified frames=${trackedTransitionCallsAfter - trackedTransitionCallsBefore} (per-frame would be ~30+)`);
        const g3dTrackedUp = await page.waitForFunction(() => {
          const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
          const ti = fl.getTrackedInfo();
          if (!ti || ti.icao24 !== 'aaa077') return false;
          const m = window.__g3dFindModel('aaa077');
          return !!(m && m.ready && m.show);
        }, { timeout: 25000, polling: 250 }).then(() => true).catch(() => false);
        let trackedDetail = 'tracked model never became ready+shown';
        let trackedHeightOk = false;
        if (g3dTrackedUp) {
          const trackedRadius = await evalPage(() => {
            const m = window.__g3dFindModel('aaa077');
            return m ? Math.hypot(m.modelMatrix[12], m.modelMatrix[13], m.modelMatrix[14]) : null;
          });
          const tDelta = trackedRadius - g3dIngest.flBBRadius;
          trackedHeightOk = Math.abs(tDelta - flWantDelta) <= HEIGHT_TOL_M;
          trackedDetail = `tracked model up; Δradial=${tDelta.toFixed(2)} m want=${flWantDelta.toFixed(2)} m`;
        }
        record('ground-3d: TRACKED grounded plane gets the standalone tracked model, ground-snapped',
          g3dTrackedUp && trackedHeightOk, trackedDetail);

        if (g3dTrackedUp) {
          const trackedReadyCallsBefore = await evalPage(() => window.__g3dSampleCalls);
          const trackedReadyWindow = await sampleFrames(
            page, 30, () => window.__g3dSampleCalls,
          );
          const trackedReadyCallsAfter = await evalPage(() => window.__g3dSampleCalls);
          const trackedReadyFramesComplete = !trackedReadyWindow.timedOut
            && trackedReadyWindow.values.length === 30;
          record('ground-3d: tracked ready-state sampling window completed all 30 requested frames',
            trackedReadyFramesComplete,
            `frames=${trackedReadyWindow.values.length}/30 timedOut=${trackedReadyWindow.timedOut}`);
          record('ground-3d: tracked ready-state ground sampling is bounded (no per-frame sampling)',
            trackedReadyFramesComplete
              && (trackedReadyCallsAfter - trackedReadyCallsBefore) <= 8,
            `sampleHeight growth over 30 verified ready-state frames=${trackedReadyCallsAfter - trackedReadyCallsBefore} (per-frame would be ~30+)`);
        } else {
          record('ground-3d: tracked ready-state sampling window completed all 30 requested frames',
            false, 'tracked model never became ready+shown');
          record('ground-3d: tracked ready-state ground sampling is bounded (no per-frame sampling)',
            false, 'tracked model never became ready+shown');
        }

        // WELD (tracked): the tracked CARD anchors to the model you can see.
        // `gevVisualPosition` is a SEPARATE accessor from `gevDisplayPosition` on
        // purpose — the latter carries the follow-camera anti-jitter contract and
        // must keep returning the cached dead-reckoned value the camera settled
        // on. So this asserts both halves: the visual accessor is welded to the
        // rendered model, AND the display accessor still reports the (different)
        // dead-reckoned position rather than having been quietly repurposed.
        if (g3dTrackedUp) {
          const trackedWeld = await evalPage(() => {
            const ent = window.__godsEyeView.viewer.trackedEntity;
            const m = window.__g3dFindModel('aaa077');
            if (!m) return { error: 'no tracked model' };
            const matrix = m.modelMatrix;
            const scale = Number.isFinite(m.computedScale)
              ? m.computedScale
              : (Number.isFinite(m.scale) ? m.scale : 1);
            // airplane.glb is now bounding-box centred with transforms applied.
            const x = 0 * scale;
            const y = 0 * scale;
            const z = 0 * scale;
            const anchor = {
              x: matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12],
              y: matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13],
              z: matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14],
            };
            const at = (p) => (p ? Math.hypot(
              p.x - anchor.x, p.y - anchor.y, p.z - anchor.z,
            ) : null);
            const visual = typeof ent?.gevVisualPosition === 'function' ? ent.gevVisualPosition() : null;
            const display = typeof ent?.gevDisplayPosition === 'function' ? ent.gevDisplayPosition() : null;
            return {
              hasVisualAccessor: typeof ent?.gevVisualPosition === 'function',
              visualDelta: at(visual),
              displayDelta: at(display),
            };
          });
          const visualOk = trackedWeld.hasVisualAccessor
            && Number.isFinite(trackedWeld.visualDelta)
            && trackedWeld.visualDelta <= WELD_TOL_M;
          record('weld: TRACKED card anchor === rendered tracked model visual centre',
            visualOk,
            trackedWeld.error
              || `visualΔ=${Number(trackedWeld.visualDelta).toFixed(3)} m (tol ${WELD_TOL_M} m), accessor=${trackedWeld.hasVisualAccessor}`);
          // Separation guard: if displayDelta ever collapses to visualDelta, the
          // anti-jitter accessor has been repurposed and the follow camera is at
          // risk. Skipped (not failed) when the DR cache is momentarily invalid.
          const displayDelta = trackedWeld.displayDelta;
          record('weld: gevDisplayPosition still reports the dead-reckoned position (anti-jitter intact)',
            !Number.isFinite(displayDelta) || displayDelta > ACCESSOR_SEPARATION_EPSILON_M,
            Number.isFinite(displayDelta)
              ? `displayΔ=${displayDelta.toFixed(3)} m (must stay > ${ACCESSOR_SEPARATION_EPSILON_M} m — the ground-snap split)`
              : 'display accessor returned null this frame (DR cache invalid) — separation not evaluated');
        }
      }
      }
    } catch (error) {
      // Contain the scenario so a primary fixture failure survives cleanup and
      // later groups plus the run-wide report still execute.
      g3dPrimaryFailure = error;
    } finally {
      // This group temporarily owns the sampling seam, model toggle, synthetics,
      // tracking state, and page globals. Release every one on error/timeout as
      // well as on the happy path so later height-datum scenarios cannot inherit
      // a deterministic skin or a tracked model from this fixture.
      if (g3dSetup) {
        try {
          const cleanupFailures = await evalPage(async (priorModels3d) => {
        const gev = window.__godsEyeView;
        const v = gev.viewer;
        const dm = gev.dataManager;
        const fl = dm.layers.get('flights').module;
        const mil = dm.layers.get('military').module;
        const failures = [];
        const attempt = async (label, operation) => {
          try { await operation(); } catch (error) {
            failures.push(`${label}: ${error?.message || error}`);
          }
        };
        await attempt('stop tracking', () => fl.stopTracking());
        await attempt('remove flights synthetic', () => {
          window.__SYNTH.flights = window.__SYNTH.flights.filter((f) => f.icao !== 'aaa077');
        });
        await attempt('remove military synthetic', () => {
          window.__SYNTH.military = window.__SYNTH.military.filter((m) => m.hex !== 'bbb177');
        });
        await attempt('refresh flights', () => fl.update(v));
        await attempt('refresh military', () => mil.update(v));
        await attempt('restore sampleHeight seam', () => {
          v.scene.sampleHeight = window.__g3dPriorSampleHeight;
        });
        await attempt('restore tilesLoaded seam', () => {
          if (!gev.tileset) return;
          const prior = window.__g3dPriorTilesLoadedDescriptor;
          if (prior) Object.defineProperty(gev.tileset, 'tilesLoaded', prior);
          else delete gev.tileset.tilesLoaded;
        });
        await attempt('restore flights models3d', () => {
          fl.setParams({ models3d: priorModels3d.flights });
        });
        await attempt('restore military models3d', () => {
          mil.setParams({ models3d: priorModels3d.military });
        });
        await attempt('delete fixture globals', () => {
          delete window.__g3dPriorSampleHeight;
          delete window.__g3dPriorTilesLoadedDescriptor;
          delete window.__g3dFindModel;
          delete window.__g3dSampleCalls;
          delete window.__g3dSampleHits;
        });
        return failures;
          }, g3dSetup.priorModels3d);
          if (cleanupFailures.length > 0) {
            g3dCleanupFailure = new Error(`ground-3d cleanup failed: ${cleanupFailures.join(' | ')}`);
          }
        } catch (error) {
          // A page-evaluation failure is itself cleanup evidence, but it must
          // not replace the primary error or abort the remaining harness.
          g3dCleanupFailure = error;
        }
      }
    }
    record('ground-3d: scenario completed without an unhandled fixture error',
      g3dPrimaryFailure === null,
      g3dPrimaryFailure
        ? `primary failure: ${g3dPrimaryFailure?.message || g3dPrimaryFailure}`
        : 'primary path completed');
    record('ground-3d: fixture cleanup completed without errors',
      g3dCleanupFailure === null,
      g3dCleanupFailure
        ? `cleanup failure: ${g3dCleanupFailure?.message || g3dCleanupFailure}`
        : (g3dSetup ? 'all owned fixture state released' : 'post-setup cleanup not required'));

    // ============================================================
    // CHANGE 4 (2026-07-03): arrival rotation freshness. Field test: "planes
    // look weird when you first come to them — rotations are weird". Two
    // repaired holes, both layers:
    //   (a) SETTLE PASS — camera.moveEnd forces a full rotation pass on the
    //       next frame (the pose-signature gate can eat a fly-to's settle:
    //       the final easing frames land inside one 10 m/0.06° quantization
    //       bucket, leaving mid-flight noses for up to ROTATION_REFRESH_MS).
    //   (b) REVEAL PASS — a billboard flipping INTO view while the camera
    //       idles gets its rotation refreshed the same tick (it used to
    //       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 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).
      dm.layers.get('flights').module.setParams({ models3d: false });
      dm.layers.get('military').module.setParams({ models3d: false });
      const findBB = (id) => {
        let found = null;
        const walk = (coll) => {
          const n = coll.length;
          for (let i = 0; i < n; i++) {
            let p;
            try { p = coll.get(i); } catch { continue; }
            if (!p) continue;
            if (typeof p.length === 'number' && typeof p.get === 'function') { walk(p); continue; }
            if (p.image !== undefined && p.alignedAxis !== undefined && p.id === id) found = p;
          }
        };
        walk(v.scene.primitives);
        return found;
      };
      const nextFrames = (n) => new Promise((res) => {
        let count = 0;
        let settled = false;
        const finish = () => {
          if (settled) return;
          settled = true;
          clearTimeout(timer);
          rm();
          res();
        };
        const rm = v.scene.postRender.addEventListener(() => {
          if (++count >= n) {
            finish();
            return;
          }
          v.scene.requestRender();
        });
        const timer = setTimeout(finish, Math.max(10000, n * 1500));
        v.scene.requestRender();
      });
      // Park the camera straight above the flights cluster (lift a live
      // billboard's position radially — no Cesium global needed in-page) so
      // every probe plane projects on-screen, then let rotations settle at
      // the new pose (the setView pose change forces a pass on the next tick).
      // aaa002 — aaa001 was evicted for good by the M3 age-out phase.
      const anchor = findBB('aaa002');
      if (!anchor) return { error: 'anchor aaa002 missing' };
      const p = anchor.position;
      const r = Math.hypot(p.x, p.y, p.z);
      const k = (r + 25000) / r;
      v.camera.cancelFlight();
      v.camera.setView({
        destination: { x: p.x * k, y: p.y * k, z: p.z * k },
        orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
      });
      await nextFrames(3);
      const angDiff = (a, b) => Math.abs(Math.atan2(Math.sin(a - b), Math.cos(a - b)));
      const probe = async (id, course) => {
        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
        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, ...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;
      return {
        flights: await probe('aaa002', flightCourse),
        military: await probe('bbb101', militaryCourse),
      };
    });
    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
    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
    // the floor of the cell it is DISPLAYED over.
    //
    // `renderAltitudeM` is picked once per poll from the floor of the FIX's
    // coarse cell, but what renders is the dead-reckoned position — which
    // drifts across cells for the whole 30 s segment and, while a ground
    // contact coasts on a stale feed, for hundreds of metres more. On a graded
    // apron (KAUS spans ~119–140 m ellipsoidal) the sprite ends up under the
    // mesh it taxied over; qa-floor-verify measured −15.5 m and reported
    // VERDICT: FAIL on main.
    //
    // Staged so ONLY the display path can produce the lift: the contact's own
    // fix cell is left COLD and the seeded floor is planted on the cells the
    // display has drifted onto. A poll-path fix would read the fix cell and
    // find nothing there, so a pass here cannot come from anywhere else.
    // ============================================================
    console.log('\nDisplay floor — grounded contacts never render below the cell they drifted onto');
    const DISPLAY_FLOOR_LIFT_M = 1.5; // GROUND_FLOOR_LIFT_M
    const DF_LAT = 30.2600, DF_LON = -97.7500;
    const DF_SEED_M = 400; // identity-probe floor for the fix cell

    const dfSetup = await evalPage(async () => {
      const Cesium = await import('/node_modules/cesium/Build/Cesium/index.js');
      const gev = window.__godsEyeView;
      const v = gev.viewer;
      const fl = gev.dataManager.layers.get('flights').module;
      // Hermetic: the ground-3d group's cleanup restored the REAL sampleHeight,
      // which would let the mesh sampler latch whatever headless GL streams.
      //
      // `__dfSkinM` is the switch, and it is load-bearing rather than tidy. A
      // permanently-missing stub means groundSnap can never resolve, and a
      // grounded MODEL cannot be placed without a ground height — so every
      // grounded-model assertion in this group becomes unreachable and reports
      // as a skip about GLB backends instead of as the contract it is. null is
      // the group default (the honest "no tiles here" the earlier scenarios
      // need, and the COLD case in its own right); a number opens a
      // DETERMINISTIC skin for the scenarios that need a model to draw.
      window.__dfSkinM = null;
      window.__dfSkinSamples = [];
      window.__dfPriorTilesLoadedDescriptor = gev.tileset
        ? Object.getOwnPropertyDescriptor(gev.tileset, 'tilesLoaded')
        : null;
      if (gev.tileset) {
        Object.defineProperty(gev.tileset, 'tilesLoaded', { value: true, configurable: true });
      }
      v.scene.sampleHeight = (cartographic) => {
        if (window.__dfSkinM == null) return undefined;
        const lat = Cesium.Math.toDegrees(Number(cartographic?.latitude));
        const lon = Cesium.Math.toDegrees(Number(cartographic?.longitude));
        if (Number.isFinite(lat) && Number.isFinite(lon)) {
          window.__dfSkinSamples.push({ lat, lon, h: window.__dfSkinM });
          if (window.__dfSkinSamples.length > 512) window.__dfSkinSamples.shift();
        }
        return window.__dfSkinM;
      };
      fl.setParams({ models3d: false }); // billboards own the visual (T7 gate open)
      window.__dfFindBB = (id) => {
        let found = null;
        const walk = (coll) => {
          const n = coll.length;
          for (let i = 0; i < n; i++) {
            let p; try { p = coll.get(i); } catch { continue; }
            if (!p) continue;
            if (typeof p.length === 'number' && typeof p.get === 'function') { walk(p); continue; }
            if (p.image !== undefined && p.alignedAxis !== undefined && p.id === id) found = p;
          }
        };
        walk(v.scene.primitives);
        return found;
      };
      window.__dfCarto = (pos) => {
        const c = Cesium.Cartographic.fromCartesian(pos, Cesium.Ellipsoid.WGS84);
        return { lat: Cesium.Math.toDegrees(c.latitude), lon: Cesium.Math.toDegrees(c.longitude), h: c.height };
      };
      // The fleet pass is rate-limited, so counting raw frames under-waits.
      window.__dfSettle = (ms) => new Promise((res) => {
        let done = false;
        const tick = () => { if (done) return; v.scene.requestRender(); setTimeout(tick, 30); };
        tick();
        setTimeout(() => { done = true; res(); }, ms);
      });
      // A timer can expire while the camera is new but the model/cache still
      // belongs to the old frame. Observe the first completed exit frame,
      // including a wrong result; never wait for visibility or height to pass.
      window.__dfObserveTrackedExit = async ({ scene, trackedEntity, trackedModel,
        getTrackedModel, getTrackedEntity, getTrackedId, getCameraHeight,
        exitHeight, read, now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout }) => {
        const deadline = now() + 5000;
        let removePre, removePost, removeError, timer;
        let preFrame = null;
        try {
          return await new Promise((resolve) => {
            let finished = false;
            const finish = (result) => { if (!finished) { finished = true; resolve(result); } };
            const valid = () => {
              try {
                if (now() > deadline) return 'tracked exit observation exceeded its 5000 ms deadline';
                if (getTrackedEntity() !== trackedEntity || getTrackedId() !== 'aaa097') return 'tracked exit fixture identity changed';
                if (!trackedModel || getTrackedModel() !== trackedModel) return 'tracked exit model identity changed';
                if (!(getCameraHeight() > exitHeight)) return 'tracked exit camera left the exit regime';
                return null;
              } catch { return 'tracked exit fixture validation failed'; }
            };
            removePre = scene.preUpdate.addEventListener(() => {
              if (finished) return;
              const error = valid();
              if (error) { finish({ error }); return; }
              if (preFrame == null) preFrame = scene.frameState.frameNumber;
            });
            removePost = scene.postRender.addEventListener(() => {
              if (finished || preFrame == null) return;
              const error = valid();
              if (error) { finish({ error }); return; }
              if (scene.frameState.frameNumber === preFrame) {
                finish({ error: 'tracked exit observation has no new rendered frame' }); return;
              }
              try {
                const snapshot = read();
                finish(snapshot ? { ...snapshot, observationFrame: scene.frameState.frameNumber }
                  : { error: 'tracked exit snapshot missing' });
              } catch { finish({ error: 'tracked exit snapshot failed' }); }
            });
            removeError = scene.renderError.addEventListener(() => finish({ error: 'tracked exit render failed' }));
            timer = setTimer(() => finish({ error: 'tracked exit update did not complete within 5000 ms' }), 5000);
            scene.requestRender();
          });
        } finally {
          clearTimer(timer); removePre?.(); removePost?.(); removeError?.();
        }
      };
      // Cesium Models in the scene, split by visibility (duck-typed the same
      // way the harness excludes them from height probes).
      //
      // Pass an `icao` to count ONLY that contact's model. Both the fleet loader
      // and the standalone tracked loader stamp `model.id` with the icao (the
      // pick identity click-to-track depends on), and the fleet pass never
      // models the tracked contact — so an id match for the tracked icao is
      // unambiguously ITS model. Counting every model in the scene instead let
      // an unrelated fleet, military, or control model satisfy "the model owns
      // the visual" while the contact under test never rendered at all.
      // `rendering` is the pair the production handoff consults (`ready &&
      // show`): a model registered with Cesium's default `show === true` the
      // instant its glTF resolves is NOT yet the visual.
      window.__dfCountModels = (icao) => {
        let shown = 0;
        let hidden = 0;
        let rendering = 0;
        const walk = (coll) => {
          const n = coll.length;
          for (let i = 0; i < n; i++) {
            let p; try { p = coll.get(i); } catch { continue; }
            if (!p) continue;
            if (typeof p.length === 'number' && typeof p.get === 'function') { walk(p); continue; }
            if (p.activeAnimations !== undefined && p.minimumPixelSize !== undefined) {
              if (icao !== undefined && p.id !== icao) continue;
              if (p.show) {
                shown += 1;
                if (p.ready === true) rendering += 1;
              } else hidden += 1;
            }
          }
        };
        walk(v.scene.primitives);
        return { shown, hidden, rendering };
      };
      // Ellipsoid height of the point a contact's MODEL is actually drawn at.
      // The counters above answer "is a model the visual"; this answers "and is
      // it standing on the ground", which is the half a rendering count cannot
      // see — a model placed at the raw feed altitude renders exactly as
      // enthusiastically as one placed on the tile skin, ~240 m underground.
      window.__dfModelHeight = (icao) => {
        let h = null;
        const walk = (coll) => {
          const n = coll.length;
          for (let i = 0; i < n; i++) {
            let p; try { p = coll.get(i); } catch { continue; }
            if (!p) continue;
            if (typeof p.length === 'number' && typeof p.get === 'function') { walk(p); continue; }
            if (p.activeAnimations !== undefined && p.minimumPixelSize !== undefined
              && p.id === icao && p.modelMatrix) {
              const m = p.modelMatrix;
              // Cesium's default is the IDENTITY matrix — translation (0,0,0),
              // the Earth's centre, which `Cartographic.fromCartesian` refuses.
              // An admitted-but-never-placed model reads as "no height", which
              // is the truth about it.
              if (m[12] || m[13] || m[14]) {
                const c = Cesium.Cartographic.fromCartesian(
                  new Cesium.Cartesian3(m[12], m[13], m[14]), Cesium.Ellipsoid.WGS84,
                );
                h = c ? c.height : null;
              }
            }
          }
        };
        walk(v.scene.primitives);
        return h;
      };
      // Tracked-contact model regime (2026-08-20). The tracked contact's model
      // is NOT governed by the DISPLAY-rail 3D toggle — that toggle owns the
      // FLEET's draw-call budget. The tracked model is default-on and driven by
      // camera distance, entering below TRACKED_MODEL_ENTER_ALT_M and handing
      // back to the billboard only above TRACKED_MODEL_EXIT_ALT_M (the
      // anti-flap band). The CAMERA is therefore what decides whether a model
      // or a billboard is the visual for a tracked contact, which is exactly
      // what the display floor stands aside for — so these pins drive the
      // camera explicitly instead of the toggle.
      //
      // Read the thresholds from the app's own policy module so a later retune
      // of the swap distance moves these pins with it rather than stranding
      // them on stale numbers.
      const reg = await import(`${window.__gevQaSourceBase || '/src'}/data/trackedModelRegime.js`);
      window.__dfRegime = {
        enter: reg.TRACKED_MODEL_ENTER_ALT_M,
        exit: reg.TRACKED_MODEL_EXIT_ALT_M,
      };
      // Zooming while following is safe: the tracked-camera framer positions
      // the camera ONCE per selection and is deliberately read-only on normal
      // frames (EntityView is the sole continuous writer, and the only
      // correction is a minimum-range clamp that guards zooming IN, not out),
      // so a programmatic zoom persists instead of being fought every frame.
      window.__dfCamH = () => v.camera.positionCartographic.height;
      // Both walkers bail on a STALLED step as well as on reaching the target:
      // the controller enforces a minimum range when following, so a zoom-in
      // that has bottomed out would otherwise spin the full iteration budget.
      window.__dfZoomAbove = async (targetH) => {
        let last = window.__dfCamH();
        for (let i = 0; i < 80 && window.__dfCamH() <= targetH; i++) {
          v.camera.zoomOut(Math.max(15000, (targetH - window.__dfCamH()) * 0.9));
          await window.__dfSettle(100);
          const now = window.__dfCamH();
          if (i > 0 && Math.abs(now - last) < 1) break;
          last = now;
        }
        return window.__dfCamH();
      };
      window.__dfZoomBelow = async (targetH) => {
        let last = window.__dfCamH();
        for (let i = 0; i < 80 && window.__dfCamH() >= targetH; i++) {
          v.camera.zoomIn(Math.max(250, (window.__dfCamH() - targetH) * 0.5));
          await window.__dfSettle(100);
          const now = window.__dfCamH();
          if (i > 0 && Math.abs(now - last) < 1) break;
          last = now;
        }
        return window.__dfCamH();
      };
      // Wait for THIS contact's tracked model to actually RENDER (loaded AND
      // shown) — ownership means drawing, not existing, and it means the model
      // that carries this icao's pick id, not whichever model happened to be up.
      window.__dfAwaitTrackedModel = async (icao, ms) => {
        const deadline = Date.now() + ms;
        while (Date.now() < deadline && window.__dfCountModels(icao).rendering === 0) {
          await window.__dfSettle(500);
        }
        return window.__dfCountModels(icao);
      };
      // Read the application's surface owner, then prove it is the one
      // used by the actual poll/render path with the unchanged floor seed.
      window.__dfCandidates = window.__godsEyeView.surfaceServices?.groundFloor ? ['application surface'] : [];
      return { candidates: window.__dfCandidates.length };
    });
    record('display-floor: ground-floor service owner found', dfSetup.candidates > 0,
      JSON.stringify(dfSetup));

    // Identity probe. Seed a contact's FIX cell BEFORE its first fix arrives,
    // then poll: the grounded surfaceM chain reads cachedGroundFloor, so the
    // sprite renders at the seeded floor if and only if the app shares this
    // module instance. (It must be the FIRST fix — the display runs `now − 30 s`,
    // which for a new contact extrapolates history[0].) This exercises the POLL
    // path only; the clamp under test reads the DISPLAY cell, which stays cold
    // here, so a broken fix cannot fake a pass.
    const dfIdentity = await evalPage(async (lat, lon, seedM) => {
      const v = window.__godsEyeView.viewer;
      const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
      const tried = [];
      for (let i = 0; i < window.__dfCandidates.length; i++) {
        const url = window.__dfCandidates[i];
        const gf = window.__godsEyeView.surfaceServices.groundFloor;
        if (typeof gf.reportMeshFloorCell !== 'function') { tried.push({ url, h: null }); continue; }
        gf.setMeshFloorPreferred(true);
        gf._clearMeshFloorCellsForTest();
        gf.reportMeshFloorCell(lat, lon, seedM);
        // A fresh icao per attempt: a contact that already exists keeps the
        // history[0] the warm-up dead-reckon renders, so it could never show a
        // floor seeded afterwards.
        const icao = `aaa09${i}`;
        window.__SYNTH.flights.push({ icao, callsign: `TAXI9${i}`, lon, lat, alt: 150, vel: 12, track: 90, onGround: true });
        await fl.update(v);
        await window.__dfSettle(400);
        const bb = window.__dfFindBB(icao);
        const h = bb ? window.__dfCarto(bb.position).h : null;
        tried.push({ url, h });
        gf._clearMeshFloorCellsForTest();
        if (Number.isFinite(h) && Math.abs(h - seedM) < 5) {
          window.__dfGf = gf; window.__dfIcao = icao;
          return { picked: { url, h }, tried };
        }
        window.__SYNTH.flights = window.__SYNTH.flights.filter((f) => f.icao !== icao);
      }
      return { picked: null, tried };
    }, DF_LAT, DF_LON, DF_SEED_M);
    const identityOk = !!dfIdentity.picked;
    record('display-floor: harness reached the app\'s own groundFloor module instance',
      identityOk,
      identityOk
        ? `a ${DF_SEED_M} m fix-cell seed put the sprite at ${Number(dfIdentity.picked.h).toFixed(1)} m (${dfIdentity.picked.url})`
        : `no candidate module was the app's: ${JSON.stringify(dfIdentity.tried)}`);

    if (!identityOk) {
      skip('display-floor: drift clamp (harness could not seed the shared floor cache)',
        'the identity probe above failed — assertions would be meaningless');
    } else {
      const dfDrift = await evalPage(async (lat, lon) => {
        const v = window.__godsEyeView.viewer;
        const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
        const gf = window.__dfGf;
        const icao = window.__dfIcao;
        const cell = (x) => Number(x.toFixed(3));
        // Fix cell COLD from here on. The contact keeps the seeded render
        // altitude in its history, and its DISPLAYED position sits one render
        // delay of taxi behind the fix — several cells away.
        gf._clearMeshFloorCellsForTest();
        // Airborne control at the same coordinates, ingested while every cell
        // is cold so its own fix-time clamp finds nothing: it drifts over the
        // same cells and must NOT be lifted.
        const airIcao = 'aaa095';
        window.__SYNTH.flights.push({ icao: airIcao, callsign: 'AIR95', lon, lat, alt: 150, vel: 12, track: 90 });
        await new Promise((r) => setTimeout(r, 1200)); // fix epochs are second-resolution
        await fl.update(v);
        await window.__dfSettle(400);

        const bb = window.__dfFindBB(icao);
        if (!bb) return { error: `${icao} billboard missing` };
        const d0 = window.__dfCarto(bb.position);
        const driftedCells = cell(d0.lat) !== cell(lat) || cell(d0.lon) !== cell(lon);
        const driftM = Math.hypot((d0.lat - lat) * 111320,
          (d0.lon - lon) * 111320 * Math.cos(lat * Math.PI / 180));
        // Plant a floor 30 m above where the sprite is DISPLAYED, across the
        // 3×3 cell block it can move within during the assertion window.
        const seeded = d0.h + 30;
        for (let dy = -1; dy <= 1; dy++) {
          for (let dx = -1; dx <= 1; dx++) {
            gf.reportMeshFloorCell(cell(d0.lat) + dy * 0.001, cell(d0.lon) + dx * 0.001, seeded);
          }
        }
        // The fleet clamp runs on its throttled render pass. Under a loaded QA
        // machine a fixed 1.2 s sleep can sample just before that pass, so wait
        // for the observable clamp with a hard deadline instead of weakening
        // the assertion or assuming one scheduler cadence.
        const clampDeadline = Date.now() + 5000;
        let bb2 = null;
        let d1 = null;
        do {
          await window.__dfSettle(250);
          bb2 = window.__dfFindBB(icao);
          d1 = bb2 ? window.__dfCarto(bb2.position) : null;
        } while (Date.now() < clampDeadline && (!d1 || d1.h < seeded + 1));
        const air = window.__dfFindBB(airIcao);
        const a1 = air ? window.__dfCarto(air.position) : null;
        return {
          driftedCells, driftM, seeded,
          beforeH: d0.h,
          afterH: d1 ? d1.h : null,
          floorUnderSprite: d1 ? gf.cachedGroundFloor(d1.lat, d1.lon) : null,
          fixCellMesh: gf.cachedMeshFloor(lat, lon),
          fixCellFloor: gf.cachedGroundFloor(lat, lon),
          airborneH: a1 ? a1.h : null,
          airborneFound: !!air,
        };
      }, DF_LAT, DF_LON);

      record('display-floor: the displayed position really has drifted off the fix cell',
        dfDrift.driftedCells === true,
        dfDrift.error || `displayed ${Number(dfDrift.driftM).toFixed(0)} m from the fix (render delay × taxi speed)`);

      const clampOk = Number.isFinite(dfDrift.afterH) && Number.isFinite(dfDrift.floorUnderSprite)
        && dfDrift.afterH >= dfDrift.floorUnderSprite + DISPLAY_FLOOR_LIFT_M - 0.5;
      record('display-floor: a grounded sprite never renders below the cell it drifted onto',
        clampOk,
        dfDrift.error || `${Number(dfDrift.beforeH).toFixed(1)} m → ${Number(dfDrift.afterH).toFixed(1)} m against a ${Number(dfDrift.floorUnderSprite).toFixed(1)} m floor (needs >= floor + ${DISPLAY_FLOOR_LIFT_M} m)`);

      // Discriminator: the poll path had nothing to read, so the lift can only
      // have come from the display path.
      const fixCellCold = dfDrift.fixCellMesh == null
        && (dfDrift.fixCellFloor == null || dfDrift.fixCellFloor < dfDrift.seeded - 10);
      record('display-floor: the lift came from the display path (fix cell still cold)',
        fixCellCold,
        `fix cell mesh=${dfDrift.fixCellMesh} floor=${dfDrift.fixCellFloor} vs seeded ${Number(dfDrift.seeded).toFixed(1)} m`);

      // Grounded-only: an AIRBORNE contact drifting over the same seeded cells
      // keeps its reported altitude — the fix-time clamp owns airborne heights.
      record('display-floor: an AIRBORNE contact over the same cells is not lifted',
        dfDrift.airborneFound === true && Number.isFinite(dfDrift.airborneH)
          && dfDrift.airborneH < dfDrift.seeded - 10,
        `airborne renders at ${Number(dfDrift.airborneH).toFixed(1)} m (seeded floor ${Number(dfDrift.seeded).toFixed(1)} m)`);

      // ---- Corridor wiring, WITHOUT pre-seeding ----------------------------
      // The scenario above plants the floor by hand, so it still passes if the
      // corridor collection is deleted, aimed at the wrong end, or starved.
      // This one seeds NOTHING: the contact's DISPLAY cell can only get a floor
      // if the poll actually collects the ground it is rendering over and warms
      // it through the real DEM resolve. A control cell the same distance away,
      // which no corridor covers, must stay cold.
      const dfCorridor = await evalPage(async (lat, lon) => {
        const v = window.__godsEyeView.viewer;
        const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
        const gf = window.__dfGf;
        const cell = (x) => Number(x.toFixed(3));
        gf._clearMeshFloorCellsForTest(); // DEM only — sampleHeight is stubbed off
        const key = (c) => `${c.lat},${c.lon}`;
        // Control: the same distance from the fix, perpendicular to the track,
        // so it is equally "near the airport" but on no contact's path.
        const controlCell = { lat: cell(lat + 0.02), lon: cell(lon) };
        // ~250 m PAST the fix along the track (090). The display sits behind the
        // fix and is extrapolating toward it, so this ground is only reachable
        // if the corridor follows the direction of travel instead of stopping
        // at the fix — the coasting-away defect, observable without waiting for
        // a real coast.
        const aheadCell = {
          lat: cell(lat),
          lon: cell(lon + 250 / (111320 * Math.cos(lat * Math.PI / 180))),
        };
        // Snapshot the whole neighbourhood BEFORE this contact exists. The
        // display cell's identity is only knowable after a second fix has aged
        // the display head off the fix — and by then the corridor has already
        // run and (correctly) warmed it, so a read at that point can never show
        // it cold. `_clearMeshFloorCellsForTest()` does not help: the DEM half
        // of `cachedGroundFloor` lives in terrainHeights' own cache. So the
        // cold state is captured up front and looked up afterwards. A display
        // cell outside this grid reports `out-of-snapshot`, which fails the
        // assertion rather than passing it quietly.
        const coldBefore = new Map();
        for (let dy = -3; dy <= 3; dy++) {
          for (let dx = -8; dx <= 8; dx++) {
            const c = { lat: cell(lat + dy * 0.001), lon: cell(lon + dx * 0.001) };
            coldBefore.set(key(c), gf.cachedGroundFloor(c.lat, c.lon));
          }
        }
        const startCold = {
          control: gf.cachedGroundFloor(controlCell.lat, controlCell.lon),
        };
        // Baro 0 puts it at the geoid (~-27 m here), ~150 m under the real
        // Austin surface, so any lift is unambiguous.
        window.__SYNTH.flights.push({ icao: 'aaa097', callsign: 'COAST97', lon, lat, alt: 0, vel: 12, track: 90, onGround: true });
        await fl.update(v);
        await window.__dfSettle(600);
        // AGE A SECOND FIX before sampling. With a single fix the display has
        // no path to run and renders AT the fix, which would make the whole
        // scenario vacuous — ordinary fix-cell warming could then satisfy the
        // display-cell assertion below. The second fix (epochs are
        // second-resolution) gives the `now − 30 s` display head a segment to
        // extrapolate back along, putting it ~360 m of taxi behind the fix.
        await new Promise((r) => setTimeout(r, 1200));
        await fl.update(v);
        await window.__dfSettle(600);
        const bb0 = window.__dfFindBB('aaa097');
        if (!bb0) return { error: 'aaa097 billboard missing' };
        const d0 = window.__dfCarto(bb0.position);
        const displayCell = { lat: cell(d0.lat), lon: cell(d0.lon) };
        const fixCell = { lat: cell(lat), lon: cell(lon) };
        startCold.display = coldBefore.has(key(displayCell))
          ? coldBefore.get(key(displayCell))
          : 'out-of-snapshot';
        // Give the fire-and-forget DEM resolve time to land, then let a couple
        // more polls run the corridor again.
        for (let i = 0; i < 3; i++) {
          await new Promise((r) => setTimeout(r, 1400));
          await fl.update(v);
          await window.__dfSettle(600);
        }
        // The floor owner intentionally retains the previous cell near an
        // edge. Sample inside a cell, beyond that hysteresis band, so the raw
        // coordinate's floor is unambiguously the floor the sprite must use.
        // Wait for geometry, not a passing height; a missing clamp still fails.
        const interiorLimit = 0.0005 - gf.CELL_HYSTERESIS_DEG - 0.00002;
        const sampleDeadline = Date.now() + 8000;
        let d1 = null;
        let sampleInterior = false;
        do {
          await window.__dfSettle(250);
          const bb1 = window.__dfFindBB('aaa097');
          d1 = bb1 ? window.__dfCarto(bb1.position) : null;
          sampleInterior = !!d1
            && Math.abs(d1.lat - cell(d1.lat)) < interiorLimit
            && Math.abs(d1.lon - cell(d1.lon)) < interiorLimit;
        } while (!sampleInterior && Date.now() < sampleDeadline);
        return {
          startCold,
          sampleInterior,
          displayCell,
          fixCell,
          sameCellAsFix: displayCell.lat === fixCell.lat && displayCell.lon === fixCell.lon,
          displayFloor: gf.cachedGroundFloor(displayCell.lat, displayCell.lon),
          controlFloor: gf.cachedGroundFloor(controlCell.lat, controlCell.lon),
          aheadCell,
          aheadFloor: gf.cachedGroundFloor(aheadCell.lat, aheadCell.lon),
          spriteH: d1 ? d1.h : null,
          spriteFloor: d1 ? gf.cachedGroundFloor(d1.lat, d1.lon) : null,
          beforeH: d0.h,
        };
      }, 30.3000, -97.8000);

      // The whole scenario is only meaningful if the cell being warmed is one
      // the ordinary fix-cell batch could NOT have produced. Two conditions
      // make that true, and both are asserted here rather than assumed: the
      // display head really left the fix cell (the second fix aged it there),
      // and that cell was COLD when the measurement started.
      record('display-floor/corridor: the display cell is not the fix cell, and started cold',
        dfCorridor.sameCellAsFix === false && dfCorridor.startCold?.display == null,
        dfCorridor.error
          || `display ${JSON.stringify(dfCorridor.displayCell)} vs fix ${JSON.stringify(dfCorridor.fixCell)}, started at ${dfCorridor.startCold?.display} — the fix-cell collection cannot reach the display cell`);

      record('display-floor/corridor: polling warms the ground the contact is DISPLAYED over',
        Number.isFinite(dfCorridor.displayFloor),
        dfCorridor.error
          || `display-cell floor = ${dfCorridor.displayFloor} (nothing was pre-seeded — only corridor collection can produce this)`);

      // The beyond-fix probe carries its own arithmetic precondition: a cell
      // that collapsed onto the fix cell would be warmed by the fix batch and
      // prove nothing about the direction of travel.
      const distinctAheadCell = dfCorridor.aheadCell?.lat !== dfCorridor.fixCell?.lat
        || dfCorridor.aheadCell?.lon !== dfCorridor.fixCell?.lon;
      record('display-floor/corridor: the corridor reaches PAST the fix, along the direction of travel',
        distinctAheadCell && Number.isFinite(dfCorridor.aheadFloor),
        dfCorridor.error
          || `cell ~250 m beyond the fix (${JSON.stringify(dfCorridor.aheadCell)}, distinct from fix ${JSON.stringify(dfCorridor.fixCell)}: ${distinctAheadCell}) floor = ${dfCorridor.aheadFloor} — a fix-aimed corridor never offers it`);

      record('display-floor/corridor: an off-path control cell stays cold (not ambient warming)',
        dfCorridor.controlFloor == null,
        `control cell floor = ${dfCorridor.controlFloor}`);

      record('display-floor/corridor: the height sample clears cell-boundary hysteresis',
        dfCorridor.sampleInterior === true,
        'the sampled coordinate lies inside one unambiguous floor cell');

      record('display-floor/corridor: the sprite rides the corridor-warmed floor',
        Number.isFinite(dfCorridor.spriteH) && Number.isFinite(dfCorridor.spriteFloor)
          && dfCorridor.spriteH >= dfCorridor.spriteFloor + DISPLAY_FLOOR_LIFT_M - 0.5,
        dfCorridor.error
          || `${Number(dfCorridor.beforeH).toFixed(1)} m → ${Number(dfCorridor.spriteH).toFixed(1)} m on a ${Number(dfCorridor.spriteFloor).toFixed(1)} m floor`);

      // ---- Tracked contact gets the same floor ----------------------------
      // The fleet pass skips the tracked icao and the tracked entity draws from
      // _trackedDisplayPosition, so selecting a correctly floored grounded
      // billboard used to swap it for an unfloored cyan target under the mesh.
      const dfTracked = await evalPage(async () => {
        const v = window.__godsEyeView.viewer;
        const Cesium = await import('/node_modules/cesium/Build/Cesium/index.js');
        const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
        const gf = window.__dfGf;
        const cell = (x) => Number(x.toFixed(3));
        const bbBefore = window.__dfFindBB('aaa097');
        if (!bbBefore) return { error: 'aaa097 billboard missing' };
        const d0 = window.__dfCarto(bbBefore.position);
        // Plant above both the current billboard and this group's 400 m
        // identity-probe floor. A poll can refresh the raw render altitude
        // after d0 was read; a lower seed makes the negative model-ownership
        // assertion impossible even when the clamp correctly stands aside.
        const seeded = Math.max(d0.h, 400) + 40;
        for (let dy = -1; dy <= 1; dy++) {
          for (let dx = -1; dx <= 1; dx++) {
            gf.reportMeshFloorCell(cell(d0.lat) + dy * 0.001, cell(d0.lon) + dx * 0.001, seeded);
          }
        }
        const fleetClampDeadline = Date.now() + 5000;
        let bbLifted = null;
        let fleetH = null;
        do {
          await window.__dfSettle(250);
          bbLifted = window.__dfFindBB('aaa097');
          fleetH = bbLifted ? window.__dfCarto(bbLifted.position).h : null;
        } while (Date.now() < fleetClampDeadline
          && (!Number.isFinite(fleetH) || fleetH < seeded + 1));
        if (!fl.trackById('aaa097')) return { error: 'trackById(aaa097) failed' };
        await window.__dfSettle(1500);
        // Read the tracked entity's rendered height plus the floor under it and
        // the sensor value the data APIs report, at whatever regime the camera
        // is currently in.
        const readTracked = () => {
          const pos = v.trackedEntity?.position?.getValue(Cesium.JulianDate.now());
          if (!pos) return null;
          const c = window.__dfCarto(pos);
          const info = fl.getTrackedInfo();
          const subject = fl.getTrackedSubject();
          return {
            h: c.h,
            floor: gf.cachedGroundFloor(c.lat, c.lon),
            reportedAltM: info?.altitudeM,
            subjectH: subject?.position ? window.__dfCarto(subject.position).h : null,
            camH: window.__dfCamH(),
            // THIS contact's model, not any model in the scene: the ownership
            // side of the assertion has to be about aaa097 or it proves nothing
            // about who drew aaa097.
            models: window.__dfCountModels('aaa097'),
          };
        };

        // --- Regime IN, COLD ground: the model is WITHHELD ------------------
        // trackById re-frames the camera to the close follow range, so the
        // tracked model regime is already active. `__dfSkinM` is still null, so
        // groundSnap has never resolved for this contact: there is no evidence
        // of where the ground is, and a depth-tested glTF placed at the feed
        // altitude (baro 0 → ~-27 m at Austin) renders ~240 m INSIDE the mesh.
        // The only honest answer is not to draw it — which also means the
        // billboard is still the visual and must still be FLOORED.
        await window.__dfSettle(2500);
        const coldModels = window.__dfCountModels('aaa097');
        // `shown` as well as `rendering`: a model parked at scale 0 with
        // show=true would satisfy "nothing renders" while still being a shown
        // primitive claiming the visual, which is the shape this rejects.

        const coldTracked = readTracked();
        const coldModelH = window.__dfModelHeight('aaa097');

        // --- Regime IN, WARM ground: the model takes over, ON the floor ------
        // Open a deterministic tile skin AT the planted floor. groundSnap
        // resolves, the model is placed on it (plus the class belly offset) and
        // takes the visual; the display clamp must then STAND ASIDE (T7),
        // leaving the ENTITY at its raw dead-reckon while the MODEL carries the
        // ground truth. Both halves are asserted — a rendering count alone
        // cannot tell a model standing on the apron from one buried under it.
        //
        // The open skin is HANDED to the retained-model scenario below, which
        // closes it once its own model is up. Every other way out of this block
        // — an early error return, a throw — has to close it here instead: a
        // skin left open lets a live sample latch into the floor cells the
        // planted seeds below are about to own, and the damage would then
        // surface as a failure in an unrelated scenario.
        window.__dfSkinM = seeded;
        let handOffSkin = false;
        try {
        const modelsIn = await window.__dfAwaitTrackedModel('aaa097', 20000);
        const warmModelH = window.__dfModelHeight('aaa097');
        // Scene-wide count, used only to tell two very different states apart:
        // NO model rendered at all (this browser has no usable GLB backend — a
        // legitimate skip) versus models rendered but none of them carried
        // aaa097's pick id (a real defect, and the case the old scene-wide
        // probe reported as a pass).
        const anyModelsIn = window.__dfCountModels();
        await window.__dfSettle(600);
        const zoomedIn = readTracked();
        if (!zoomedIn) return { error: 'tracked entity has no position (zoomed in)' };

        // --- Regime OUT: camera above the exit ceiling ----------------------
        // Climb past the anti-flap band and the model hands the visual back to
        // the billboard — which MUST be floored, or a tracked grounded contact
        // renders buried at any distance the operator pulls out to. This is the
        // coverage the toggle used to reach; the zoom regime reaches it now.
        const findOwnModel = () => {
          let found = null;
          const walk = (collection) => {
            for (let i = 0; i < collection.length; i++) {
              const item = collection.get(i);
              if (typeof item?.get === 'function' && typeof item.length === 'number') walk(item);
              else if (item?.id === 'aaa097' && item.activeAnimations !== undefined
                && item.minimumPixelSize !== undefined) found = item;
            }
          };
          walk(v.scene.primitives);
          return found;
        };
        const trackedEntity = v.trackedEntity;
        const trackedModel = findOwnModel();
        const achievedOut = await window.__dfZoomAbove(window.__dfRegime.exit + 5000);
        const zoomedOut = await window.__dfObserveTrackedExit({
          scene: v.scene, trackedEntity, trackedModel, getTrackedModel: findOwnModel,
          getTrackedEntity: () => v.trackedEntity,
          getTrackedId: () => fl.getTrackedInfo()?.icao24,
          getCameraHeight: window.__dfCamH, exitHeight: window.__dfRegime.exit,
          read: readTracked,
        });
        if (zoomedOut.error) return { error: zoomedOut.error };

        const out = {
          rawH: d0.h,
          seeded,
          fleetH,
          enter: window.__dfRegime.enter,
          exit: window.__dfRegime.exit,
          modelsRenderingIn: modelsIn.rendering,
          anyModelsRenderingIn: anyModelsIn.rendering,
          achievedOut,
          coldModelsRendering: coldModels.rendering,
          coldModelsShown: coldModels.shown,
          coldModelH,
          coldEntityH: coldTracked ? coldTracked.h : null,
          coldFloor: coldTracked ? coldTracked.floor : null,
          warmModelH,
          zoomedIn,
          zoomedOut,
        };
        fl.stopTracking();
        await window.__dfSettle(400);
        handOffSkin = true;
        return out;
        } finally {
          if (!handOffSkin) window.__dfSkinM = null;
        }
      });

      record('display-floor: the fleet billboard lifts onto the planted floor (control for the tracked check)',
        !dfTracked.error && Number.isFinite(dfTracked.fleetH)
          && dfTracked.fleetH >= dfTracked.seeded + DISPLAY_FLOOR_LIFT_M - 0.5,
        dfTracked.error
          || `billboard ${Number(dfTracked.rawH).toFixed(1)} m → ${Number(dfTracked.fleetH).toFixed(1)} m (floor ${Number(dfTracked.seeded).toFixed(1)} m)`);

      // The tracked contact is floored exactly when the BILLBOARD is what the
      // operator sees, and stands aside exactly when the MODEL is. "Exactly
      // when" needs BOTH halves, so both are asserted: floored on the way out,
      // NOT floored on the way in. Since the tracked model became zoom-driven
      // (2026-08-20), the camera is what picks between the two, so this pin
      // drives both sides of the hysteresis band in one scenario.
      //
      // The negative half is what a height read alone cannot establish —
      // groundSnap can land at the same number as the clamp — so it is paired
      // with an OWNERSHIP probe rather than inferred from height. The probe is
      // aaa097's OWN model (exact pick id) in the `ready && show` state
      // `_modelOwnsVisual` consults: rendering while zoomed in, not rendering
      // while zoomed out. That distinguishes the two sources by WHO DREW IT,
      // which is the actual contract:
      //  - IN: aaa097's model renders ⇒ `_floorGroundedDisplayPosition` returns
      //    early, so the tracked ENTITY sits at its raw dead-reckon (baro 0,
      //    ~150 m under the planted floor) while groundSnap positions the model.
      //  - OUT: no model of aaa097 renders ⇒ the billboard is the visual and
      //    MUST be lifted, or a tracked grounded contact renders buried at
      //    whatever distance the operator has pulled out to.
      const dfIn = dfTracked.zoomedIn || {};
      const dfOut = dfTracked.zoomedOut || {};
      const dfOutFloored = Number.isFinite(dfOut.h) && Number.isFinite(dfOut.floor)
        && dfOut.h >= dfOut.floor + DISPLAY_FLOOR_LIFT_M - 0.5;
      const dfInStandsAside = Number.isFinite(dfIn.h) && Number.isFinite(dfIn.floor)
        && dfIn.h < dfIn.floor + DISPLAY_FLOOR_LIFT_M - 0.5;
      const dfInModelOwns = dfIn.models?.rendering > 0;
      const dfOutBillboardOwns = dfOut.models?.rendering === 0;
      const dfRegimeName = 'display-floor/regime: the TRACKED grounded contact is floored exactly when the billboard is the visual';

      // COLD ground, camera IN: the gate. A grounded model with no resolved
      // ground is not drawn at all, and the billboard it did not replace is
      // still floored. Before this pin the same run reported "1 aaa097 model(s)
      // rendering, entity left at -26.8 m under a 215.1 m floor" as a PASS —
      // the model was rendering 242 m under the apron and nothing said so.
      const dfColdFloored = Number.isFinite(dfTracked.coldEntityH)
        && Number.isFinite(dfTracked.coldFloor)
        && dfTracked.coldEntityH >= dfTracked.coldFloor + DISPLAY_FLOOR_LIFT_M - 0.5;
      record('display-floor/gate: with NO resolved ground the grounded model is withheld and the billboard is floored',
        !dfTracked.error && dfTracked.coldModelsRendering === 0
          && dfTracked.coldModelsShown === 0 && dfColdFloored,
        dfTracked.error
          || `cold skin: ${dfTracked.coldModelsRendering} aaa097 model(s) rendering / ${dfTracked.coldModelsShown} shown (placed height ${dfTracked.coldModelH == null ? 'none — never placed' : Number(dfTracked.coldModelH).toFixed(1) + ' m'}), billboard at ${Number(dfTracked.coldEntityH).toFixed(1)} m on a ${Number(dfTracked.coldFloor).toFixed(1)} m floor`);

      // WARM ground, camera IN: the placement. The model is not merely visible,
      // it is standing ON the floor — within one class belly offset above it,
      // never under it. MAX_BELLY_M clears the largest offset any class adds
      // (widebody b789, 7.81 m in CLASS_MODEL_REAL); the floor itself is the
      // hard lower bound, and a model placed at the raw feed altitude is ~240 m
      // under it.
      const MAX_BELLY_M = 12;
      const dfWarmOnFloor = Number.isFinite(dfTracked.warmModelH)
        && dfTracked.warmModelH >= dfTracked.seeded
        && dfTracked.warmModelH <= dfTracked.seeded + MAX_BELLY_M;
      record('display-floor/placement: a resolved grounded model stands ON the floor, not under it and not hidden',
        !dfTracked.error && dfTracked.modelsRenderingIn > 0 && dfWarmOnFloor,
        dfTracked.error
          || `warm skin: ${dfTracked.modelsRenderingIn} aaa097 model(s) rendering at ${Number(dfTracked.warmModelH).toFixed(1)} m on a ${Number(dfTracked.seeded).toFixed(1)} m floor (belly headroom ${MAX_BELLY_M} m; raw feed altitude was ${Number(dfTracked.rawH).toFixed(1)} m)`);

      // Skip only when NO model rendered anywhere — that is a browser without a
      // usable GLB backend. Models rendering while none of them is aaa097's is
      // a defect, and falls through to the record below so it reports RED.
      if (!dfTracked.error && !dfTracked.modelsRenderingIn && !dfTracked.anyModelsRenderingIn) {
        skip(dfRegimeName,
          'no tracked model rendered in this browser — the zoomed-in half has no model to own the visual');
      } else {
        record(dfRegimeName,
          !dfTracked.error
            && dfInModelOwns && dfInStandsAside
            && dfOutBillboardOwns && dfOutFloored
            && Number.isFinite(dfIn.camH) && dfIn.camH < dfTracked.enter
            && Number.isFinite(dfOut.camH) && dfOut.camH > dfTracked.exit,
          dfTracked.error
            || `IN @ ${(dfIn.camH / 1000).toFixed(0)} km (< ${(dfTracked.enter / 1000).toFixed(0)} km enter): ${dfIn.models?.rendering} aaa097 model(s) rendering, entity left at ${Number(dfIn.h).toFixed(1)} m under a ${Number(dfIn.floor).toFixed(1)} m floor (groundSnap owns it); `
              + `OUT @ ${(dfOut.camH / 1000).toFixed(0)} km (> ${(dfTracked.exit / 1000).toFixed(1)} km exit): ${dfOut.models?.rendering} aaa097 model(s) rendering, billboard owns it again, ${Number(dfIn.h).toFixed(1)} m → ${Number(dfOut.h).toFixed(1)} m on a ${Number(dfOut.floor).toFixed(1)} m floor`);
      }

      // The visual/data split is INTENTIONAL: pixels are floored, measurements
      // are not. Pinned so a later "floor everything" pass has to argue with it.
      // Asserted in BOTH regimes — who owns the visual must never change what a
      // query, the cockpit altimeter, or a proximity count reports.
      record('display-floor/regime: data APIs report sensor truth in BOTH regimes, floored or not',
        !dfTracked.error
          && Number.isFinite(dfIn.reportedAltM) && Math.abs(dfIn.reportedAltM) < 1
          && Number.isFinite(dfOut.reportedAltM) && Math.abs(dfOut.reportedAltM) < 1
          && Math.abs(dfOut.reportedAltM - dfOut.h) > 100,
        dfTracked.error
          || `getTrackedInfo().altitudeM = ${dfIn.reportedAltM} zoomed in / ${dfOut.reportedAltM} zoomed out (feed baro), while the floored visual reads ${Number(dfOut.h).toFixed(1)} m — the split is deliberate`);

      // ---- F4: a RETAINED-but-hidden tracked model must not suppress the floor
      // Climbing past the tracked model's EXIT ceiling leaves `_trackedModel`
      // alive with show=false (the driver hides it, it is not destroyed), and
      // the tracked billboard becomes the visual again. Gating the clamp on
      // model EXISTENCE put the burial straight back in exactly that state.
      //
      // This scenario also pins the toggle contract itself. The DISPLAY-rail
      // "3D" toggle stays OFF for the whole block on purpose: it governs the
      // FLEET's draw-call budget only, and the tracked contact must still take
      // its model on zoom without the operator arming anything.
      const dfRetained = await evalPage(async () => {
        const v = window.__godsEyeView.viewer;
        const Cesium = await import('/node_modules/cesium/Build/Cesium/index.js');
        const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
        const gf = window.__dfGf;
        const cell = (x) => Number(x.toFixed(3));
        // This scenario INHERITS the open deterministic skin from the block
        // above and closes it partway through, once its own model is up. The
        // close is repeated in a finally because the skip return between here
        // and there would otherwise hand an open skin to the seeded scenarios
        // that follow; closing an already-closed skin is inert.
        try {
        // Toggle OFF throughout — the tracked model must not need it.
        fl.setParams({ models3d: false });
        const toggleOff = fl.getParams().models3d === false;
        if (!fl.trackById('aaa097')) return { error: 'trackById(aaa097) failed' };
        await window.__dfSettle(600);
        // Below the ENTER ceiling (trackById re-frames to the close follow
        // range): the tracked model arrives on zoom alone, toggle still off.
        const belowH = await window.__dfZoomBelow(window.__dfRegime.enter - 20000);
        const withModel = await window.__dfAwaitTrackedModel('aaa097', 20000);
        // Same split as the regime scenario: a browser with no usable GLB
        // backend skips; models rendering under someone else's pick id must
        // reach the assertions and fail there.
        if (!withModel.rendering && !window.__dfCountModels().rendering) {
          fl.stopTracking();
          return { skipped: 'no tracked model rendered in this browser' };
        }
        // While the model IS the visual the clamp must stand aside (T7).
        const entWith = v.trackedEntity?.position?.getValue(Cesium.JulianDate.now());
        const withModelH = entWith ? window.__dfCarto(entWith).h : null;
        // Close the deterministic skin again for the rest of the group. The
        // model is up on a snap that is already cached, so it stays up until the
        // regime hides it; what this prevents is a live sample latching into the
        // floor cells that the planted seeds below are about to own.
        window.__dfSkinM = null;
        // Now climb past the EXIT ceiling: the model object is RETAINED but
        // hidden, and the billboard is the visual again.
        const aboveH = await window.__dfZoomAbove(window.__dfRegime.exit + 5000);
        await window.__dfSettle(1500);
        // aaa097's own model only: "retained but hidden" is a claim about THIS
        // contact's primitive, and an unrelated model in the scene must not be
        // able to answer it either way.
        const afterOut = window.__dfCountModels('aaa097');
        const ent = v.trackedEntity?.position?.getValue(Cesium.JulianDate.now());
        const c = ent ? window.__dfCarto(ent) : null;
        // Plant a floor above wherever it now renders so "floored" is decisive.
        // Mesh cells latch ONE-SHOT, so the earlier scenario's seed would win
        // this block silently — clear first, then plant.
        gf._clearMeshFloorCellsForTest();
        const seeded = (c ? c.h : 0) + 35;
        if (c) {
          for (let dy = -1; dy <= 1; dy++) {
            for (let dx = -1; dx <= 1; dx++) {
              gf.reportMeshFloorCell(cell(c.lat) + dy * 0.001, cell(c.lon) + dx * 0.001, seeded);
            }
          }
        }
        // The viewer is request-render driven. Directly seeding the test seam
        // does not itself schedule a frame, so explicitly request one before
        // reading the CallbackProperty again. Production floor warming already
        // runs inside the app's render/update lifecycle; this keeps the harness
        // from mistaking a cached same-frame position for a failed clamp.
        v.scene.requestRender();
        await window.__dfSettle(900);
        const ent2 = v.trackedEntity?.position?.getValue(Cesium.JulianDate.now());
        const c2 = ent2 ? window.__dfCarto(ent2) : null;
        const out = {
          toggleOff,
          enter: window.__dfRegime.enter,
          exit: window.__dfRegime.exit,
          belowH,
          aboveH,
          modelsRenderingBelow: withModel.rendering,
          withModelH,
          hiddenModelsAbove: afterOut.hidden,
          shownModelsAbove: afterOut.shown,
          beforeSeedH: c ? c.h : null,
          seeded,
          afterSeedH: c2 ? c2.h : null,
        };
        // Hand the camera back to the CLOSE follow range before releasing. The
        // LOADING scenario below needs BOTH an active tracked regime and a
        // fleet model for this contact, and the fleet only admits models within
        // MODEL_PROX_ADD_M of the camera — parking just inside the enter
        // ceiling satisfies the regime but sits outside that add radius, which
        // silently starved the fleet half into a skip.
        await window.__dfZoomBelow(belowH + 500);
        fl.stopTracking();
        await window.__dfSettle(300);
        return out;
        } finally {
          window.__dfSkinM = null;
        }
      });

      if (dfRetained.skipped) {
        skip('display-floor: retained-but-hidden tracked model still floors the billboard',
          dfRetained.skipped);
      } else {
        record('display-floor/T7: while the tracked MODEL is the visual, the clamp stands aside',
          !dfRetained.error && dfRetained.modelsRenderingBelow > 0,
          dfRetained.error
            || `${dfRetained.modelsRenderingBelow} aaa097 model(s) rendering at ${(dfRetained.belowH / 1000).toFixed(0)} km with the 3D toggle OFF; entity at ${Number(dfRetained.withModelH).toFixed(1)} m (ground-snap owns it)`);

        // The toggle contract after auto-3D (2026-08-20): the DISPLAY-rail "3D"
        // switch owns the FLEET only. The tracked contact's model is default-on
        // and decided purely by camera distance, so with the toggle OFF it is
        // SHOWN below the enter ceiling and handed back above the exit ceiling —
        // and handed back by HIDING, not destroying, which is the retained state
        // the floor pin below depends on.
        record('display-floor/regime: the 3D toggle governs the FLEET only — the tracked model follows the zoom',
          !dfRetained.error && dfRetained.toggleOff === true
            && dfRetained.modelsRenderingBelow > 0
            && dfRetained.belowH < dfRetained.enter
            && dfRetained.shownModelsAbove === 0
            && dfRetained.hiddenModelsAbove > 0
            && dfRetained.aboveH > dfRetained.exit,
          dfRetained.error
            || `toggle OFF throughout: at ${(dfRetained.belowH / 1000).toFixed(0)} km (< ${(dfRetained.enter / 1000).toFixed(0)} km enter) ${dfRetained.modelsRenderingBelow} aaa097 model(s) rendering; at ${(dfRetained.aboveH / 1000).toFixed(0)} km (> ${(dfRetained.exit / 1000).toFixed(1)} km exit) ${dfRetained.shownModelsAbove} shown / ${dfRetained.hiddenModelsAbove} retained-hidden`);

        record('display-floor: a retained-but-hidden tracked model does NOT suppress the floor',
          Number.isFinite(dfRetained.afterSeedH)
            && dfRetained.afterSeedH >= dfRetained.seeded + DISPLAY_FLOOR_LIFT_M - 0.5,
          `${Number(dfRetained.beforeSeedH).toFixed(1)} m → ${Number(dfRetained.afterSeedH).toFixed(1)} m on a ${Number(dfRetained.seeded).toFixed(1)} m floor (${dfRetained.hiddenModelsAbove} model object(s) still retained, hidden by the zoom regime)`);
      }

      // ---- F3: the LOADING window is billboard-owned, not model-owned ------
      // Stress the fleet ownership predicate with synthetic show=true/ready=false
      // flags. Production admission keeps the model hidden; these shadows do
      // not simulate Cesium's internal loading/draw state. The tracked check
      // below separately samples the no-rendering-model window.
      const dfLoading = await evalPage(async () => {
        const v = window.__godsEyeView.viewer;
        const Cesium = await import('/node_modules/cesium/Build/Cesium/index.js');
        const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
        const gf = window.__dfGf;
        const cell = (x) => Number(x.toFixed(3));
        const floorAround = (c, seeded) => {
          for (let dy = -1; dy <= 1; dy++) {
            for (let dx = -1; dx <= 1; dx++) {
              gf.reportMeshFloorCell(cell(c.lat) + dy * 0.001, cell(c.lon) + dx * 0.001, seeded);
            }
          }
        };
        const out = {};

        // (a) FLEET: retain the adversarial flags until this contact has passed
        // through its installed fleet update and that frame has completed.
        const findFleetModel = (id) => {
          let found = null;
          const walk = (coll) => {
            const len = coll.length;
            for (let i = 0; i < len; i++) {
              let p; try { p = coll.get(i); } catch { continue; }
              if (!p) continue;
              if (typeof p.length === 'number' && typeof p.get === 'function') { walk(p); continue; }
              if (p.activeAnimations !== undefined && p.minimumPixelSize !== undefined && p.id === id) found = p;
            }
          };
          walk(v.scene.primitives);
          return found;
        };
        fl.setParams({ models3d: true });
        const fleetDeadline = Date.now() + 20000;
        let fleetModel = null;
        while (Date.now() < fleetDeadline && !(fleetModel = findFleetModel('aaa097'))) {
          await window.__dfSettle(500);
        }
        if (!fleetModel) {
          fl.setParams({ models3d: false });
          return { skipped: 'no fleet model for aaa097 in this browser' };
        }
        // Accessors with SWALLOWING setters, not data properties: the fleet tick
        // assigns `model.show = false` for a not-ready model, and assigning to a
        // non-writable own property throws in strict mode — which lands inside
        // Cesium's render loop and stops rendering for the rest of the run.
        const priorReady = Object.getOwnPropertyDescriptor(fleetModel, 'ready');
        const priorShow = Object.getOwnPropertyDescriptor(fleetModel, 'show');
        let armed = false;
        let processedFrame = null;
        let sample = null;
        let removePostRender = null;
        try {
        Object.defineProperty(fleetModel, 'ready', { get: () => false, set: () => {}, configurable: true });
        Object.defineProperty(fleetModel, 'show', {
          get: () => true,
          set: (value) => {
            // Both the not-ready handoff and horizon cull clear show AFTER
            // computing this contact's display floor. Neither a timer nor an
            // unrelated rendered frame proves that this aircraft was processed.
            if (armed && value === false && processedFrame == null) {
              processedFrame = v.scene.frameState.frameNumber;
            }
          },
          configurable: true,
        });
        const bb = window.__dfFindBB('aaa097');
        if (!bb) return { error: 'aaa097 billboard missing' };
        bb.show = true; // the handoff would not have hidden it: the model is not ready
        const d0 = window.__dfCarto(bb.position);
        gf._clearMeshFloorCellsForTest();
        // Earlier display-floor scenarios deliberately leave this contact's
        // sticky-cell/rebuild cache populated. Reset that test-owned cache
        // before planting a different artificial floor in the same area, so
        // this case measures loading ownership instead of prior-scenario
        // hysteresis.
        fl._clearDisplayFloorStateForTest();
        const seededFleet = d0.h + 45;
        floorAround(d0, seededFleet);
        const tickDeadline = Date.now() + 5000;
        removePostRender = v.scene.postRender.addEventListener(() => {
          if (sample || processedFrame == null || v.scene.frameState.frameNumber < processedFrame) return;
          if (Date.now() > tickDeadline) {
            sample = { error: 'fleet loading fixture completed after its 5000 ms deadline' };
            return;
          }
          const currentBb = window.__dfFindBB('aaa097');
          const currentModel = findFleetModel('aaa097');
          sample = {
            fleetTickCompleted: true,
            fleetFrame: v.scene.frameState.frameNumber,
            fleetModelReady: fleetModel.ready,
            fleetModelShow: fleetModel.show,
            fleetBillboardVisible: !!currentBb?.show,
            fleetSeeded: seededFleet,
            fleetH: currentBb ? window.__dfCarto(currentBb.position).h : null,
          };
          if (currentBb !== bb || currentModel !== fleetModel || fleetModel.isDestroyed()
            || fl.getTrackedInfo()) sample.error = 'fleet loading fixture changed before its completed frame';
        });
        armed = true;
        // This is a setup-completion deadline, not a visual latency budget.
        // Take the FIRST completed fleet result, even when its height is wrong;
        // never poll the height until the assertion happens to pass.
        do {
          await window.__dfSettle(50);
        } while (!sample && Date.now() < tickDeadline);
        if (!sample) return { error: 'fleet loading fixture did not complete an aircraft update within 5000 ms' };
        Object.assign(out, sample);
        } finally {
          armed = false;
          removePostRender?.();
          if (priorReady) Object.defineProperty(fleetModel, 'ready', priorReady);
          else delete fleetModel.ready;
          if (priorShow) Object.defineProperty(fleetModel, 'show', priorShow);
          else delete fleetModel.show;
          fl.setParams({ models3d: false });
        }
        await window.__dfSettle(400);

        // (b) TRACKED, regime ACTIVE but no model yet. Turning 3D on while
        // tracking makes `_trackedModelRegimeActive()` true immediately; the
        // GLB load takes frames, and the tracked billboard is the visual until
        // it finishes. Sample within that window.
        if (!fl.trackById('aaa097')) return { ...out, error: 'trackById(aaa097) failed' };
        await window.__dfSettle(500);
        const entBefore = v.trackedEntity?.position?.getValue(Cesium.JulianDate.now());
        const cBefore = entBefore ? window.__dfCarto(entBefore) : null;
        gf._clearMeshFloorCellsForTest();
        fl._clearDisplayFloorStateForTest();
        const seededTracked = (cBefore ? cBefore.h : 0) + 45;
        if (cBefore) floorAround(cBefore, seededTracked);
        // Release the tracked model so the next regime activation must load
        // from scratch, then flip the regime on and sample IMMEDIATELY.
        fl.setParams({ models3d: false });
        await window.__dfSettle(400);
        fl.stopTracking();
        await window.__dfSettle(300);
        fl.trackById('aaa097');
        fl.setParams({ models3d: true });
        v.scene.requestRender();
        await new Promise((r) => setTimeout(r, 120)); // inside the load window
        // Count only the contact under test. A headful run can legitimately
        // render unrelated live fleet or military models at the same time;
        // those say nothing about whether aaa097's loading handoff is still
        // billboard-owned. The shared helper keys models by their pick id and
        // uses the production ownership pair (`show && ready`).
        out.renderingModelsDuringLoad = window.__dfCountModels('aaa097').rendering;
        const entLoad = v.trackedEntity?.position?.getValue(Cesium.JulianDate.now());
        out.trackedSeeded = seededTracked;
        out.trackedLoadH = entLoad ? window.__dfCarto(entLoad).h : null;
        fl.setParams({ models3d: false });
        fl.stopTracking();
        await window.__dfSettle(300);
        return out;
      });

      if (dfLoading.skipped) {
        skip('display-floor/loading: fleet model loading window', dfLoading.skipped);
      } else {
        record('display-floor/loading: a fleet model that is shown-but-not-ready does not own the visual',
          !dfLoading.error && dfLoading.fleetTickCompleted === true
            && dfLoading.fleetModelShow === true && dfLoading.fleetModelReady === false
            && dfLoading.fleetBillboardVisible === true
            && Number.isFinite(dfLoading.fleetH)
            && dfLoading.fleetH >= dfLoading.fleetSeeded + DISPLAY_FLOOR_LIFT_M - 0.5,
          dfLoading.error
            || `model show=${dfLoading.fleetModelShow} ready=${dfLoading.fleetModelReady}, billboard visible=${dfLoading.fleetBillboardVisible} at ${Number(dfLoading.fleetH).toFixed(1)} m on a ${Number(dfLoading.fleetSeeded).toFixed(1)} m floor`);
      }

      record('display-floor/loading: tracked regime active with no rendering model stays floored',
        !dfLoading.error && dfLoading.renderingModelsDuringLoad === 0
          && Number.isFinite(dfLoading.trackedLoadH)
          && dfLoading.trackedLoadH >= dfLoading.trackedSeeded + DISPLAY_FLOOR_LIFT_M - 0.5,
        dfLoading.error
          || `rendering models during load=${dfLoading.renderingModelsDuringLoad}, entity at ${Number(dfLoading.trackedLoadH).toFixed(1)} m on a ${Number(dfLoading.trackedSeeded).toFixed(1)} m floor`);

      // ---- F5: a taxi-invalidated snap HOLDS, bounded by drift -------------
      // The gate above ("no evidence ⇒ no model") is right for a contact that
      // has NEVER resolved. Applied to one that HAS, it produces a new defect:
      // taxiing past groundSnap's 50 m resample threshold drops the cache, and
      // if the resample misses — tiles streaming, OSM fallback — the backoff is
      // 2–30 s, so the aircraft pops from 3D back to 2D and back again while it
      // rolls. The last MEASUREMENT is held through that instead, bounded by how
      // far the contact can have moved from where it was taken. Same answer the
      // billboard chain gives (`_heldDisplayFloorM`), a quarter of the distance,
      // because a held floor only ever RAISES a sprite while a held snap IS the
      // model's placement.
      //
      // Driven through the app's OWN handoff and its OWN groundSnap instance —
      // real Cesium primitive, real cache, real backoff. Only the position is
      // supplied by the harness rather than by the poll, which is exactly what a
      // taxi is; waiting out the 30 s render delay for the feed to move the
      // display would measure the same thing half a minute later.
      const dfHold = await evalPage(async () => {
        const Cesium = await import('/node_modules/cesium/Build/Cesium/index.js');
        const v = window.__godsEyeView.viewer;
        const fl = window.__godsEyeView.dataManager.layers.get('flights').module;
        // Test the registered instance directly, including catalogs constructed
        // with their own sources. Never import a second compatibility instance.
        const ns = fl.testing;
        if (typeof ns?._driveFleetModelHandoffForTest !== 'function')
          return { error: "the registered flights instance has no handoff test seam" };
        // Use a scenario-owned contact so its groundSnap entry is provably cold;
        // earlier display-floor cases intentionally exercise aaa097's cache.
        const holdIcao = 'aaa098';
        const sourceBb = window.__dfFindBB('aaa097');
        if (!sourceBb) return { error: 'aaa097 source billboard missing' };
        const source = window.__dfCarto(sourceBb.position);
        window.__SYNTH.flights = window.__SYNTH.flights.filter((f) => f.icao !== holdIcao);
        window.__SYNTH.flights.push({
          icao: holdIcao,
          callsign: 'HOLD98',
          lon: source.lon,
          lat: source.lat,
          alt: 0,
          vel: 0,
          track: 90,
          onGround: true,
        });
        fl.setParams({ models3d: false });
        await fl.update(v);
        await window.__dfSettle(600);
        const bb = window.__dfFindBB(holdIcao);
        if (!bb) return { error: `${holdIcao} billboard missing` };
        const base = window.__dfCarto(bb.position);
        const basePos = Cesium.Cartesian3.fromDegrees(base.lon, base.lat, base.h);
        // Offered skin: unmistakably not the feed altitude, for the case where
        // this contact's cache is cold and a real sample has to fire.
        const skin = base.h + 60;

        // 1. Open a deterministic skin and let the REAL fleet tick admit, place
        //    and show the model — the arrival path this scenario then interrupts.
        const baseSampleCount = () => window.__dfSkinSamples.filter((sample) => {
          const dLat = sample.lat - base.lat;
          const dLon = (sample.lon - base.lon) * Math.cos(base.lat * Math.PI / 180);
          return Math.hypot(dLat, dLon) <= 0.0002;
        }).length;
        const baseSamplesBefore = baseSampleCount();
        window.__dfSkinM = skin;
        fl.setParams({ models3d: true });
        const up = await window.__dfAwaitTrackedModel(holdIcao, 20000);
        if (!up.rendering) {
          window.__dfSkinM = null;
          fl.setParams({ models3d: false });
          return { skipped: `no fleet model rendered for ${holdIcao} in this browser` };
        }
        const freshOwns = ns._driveFleetModelHandoffForTest({
          icao24: holdIcao, position: basePos, course: 90,
        });
        const baseSampleHits = baseSampleCount() - baseSamplesBefore;
        const freshH = window.__dfModelHeight(holdIcao);

        // 2. The tiles go away and the contact taxis ~96 m — past the 50 m
        //    resample threshold, inside the hold bound. Every resample from here
        //    misses, so this is the whole backoff window in one call.
        window.__dfSkinM = null;
        const taxiPos = Cesium.Cartesian3.fromDegrees(base.lon + 0.001, base.lat, base.h);
        // What independent evidence says about each spot. A held snap now loses
        // to a MEASURED floor at the contact's current cell that disagrees with
        // it (groundSnap.HELD_SNAP_CONTRADICTION_M), so if this group has
        // planted a floor at the taxi cell, that is what decides the outcome —
        // and the numbers have to be visible or the failure is unreadable.
        const gfns = window.__dfGf;
        const baseCarto = window.__dfCarto(basePos);
        const taxiCarto = window.__dfCarto(taxiPos);
        const baseMeshM = gfns?.cachedMeshFloor?.(baseCarto.lat, baseCarto.lon) ?? null;
        const taxiMeshM = gfns?.cachedMeshFloor?.(taxiCarto.lat, taxiCarto.lon) ?? null;
        const heldOwns = ns._driveFleetModelHandoffForTest({ icao24: holdIcao, position: taxiPos, course: 90 });
        const heldH = window.__dfModelHeight(holdIcao);
        const heldBb = !!window.__dfFindBB(holdIcao)?.show;

        // 3. ~385 m out the memory stops describing anywhere this contact has
        //    been. It is released rather than stretched, and the gate takes over.
        const farPos = Cesium.Cartesian3.fromDegrees(base.lon + 0.004, base.lat, base.h);
        const releasedOwns = ns._driveFleetModelHandoffForTest({ icao24: holdIcao, position: farPos, course: 90 });
        const releasedBb = !!window.__dfFindBB(holdIcao)?.show;

        fl.setParams({ models3d: false });
        await window.__dfSettle(300);
        return {
          freshOwns,
          freshH,
          baseSampleHits,
          heldOwns,
          heldH,
          heldBb,
          baseMeshM,
          taxiMeshM,
          releasedOwns,
          releasedBb,
          taxiM: Cesium.Cartesian3.distance(
            Cesium.Ellipsoid.WGS84.scaleToGeodeticSurface(basePos, new Cesium.Cartesian3()),
            Cesium.Ellipsoid.WGS84.scaleToGeodeticSurface(taxiPos, new Cesium.Cartesian3()),
          ),
          farM: Cesium.Cartesian3.distance(
            Cesium.Ellipsoid.WGS84.scaleToGeodeticSurface(basePos, new Cesium.Cartesian3()),
            Cesium.Ellipsoid.WGS84.scaleToGeodeticSurface(farPos, new Cesium.Cartesian3()),
          ),
        };
      });

      if (dfHold.skipped) {
        skip('display-floor/hold: a taxi-invalidated ground snap holds the model through the resample backoff',
          dfHold.skipped);
      } else {
        // The taxi has to actually cross the threshold, or the rest proves
        // nothing: > 50 m invalidates, < 250 m is still inside the bound.
        record('display-floor/hold: the taxi really does invalidate, and the far step really does exceed the bound',
          !dfHold.error && dfHold.taxiM > 50 && dfHold.taxiM < 250 && dfHold.farM > 250,
          dfHold.error || `taxi ${Number(dfHold.taxiM).toFixed(1)} m (> 50 m invalidate, < 250 m bound), far step ${Number(dfHold.farM).toFixed(1)} m (> 250 m bound)`);

        record('display-floor/hold: a taxi-invalidated ground snap holds the model through the resample backoff',
          !dfHold.error && dfHold.baseSampleHits > 0
            && dfHold.freshOwns === true && dfHold.heldOwns === true
            && dfHold.heldBb === false
            && Number.isFinite(dfHold.heldH) && Number.isFinite(dfHold.freshH)
            && Math.abs(dfHold.heldH - dfHold.freshH) < 0.5,
          dfHold.error || `fresh owns=${dfHold.freshOwns} after ${dfHold.baseSampleHits} positive base sample(s), on a MEASURED floor at ${Number(dfHold.freshH).toFixed(1)} m; tiles gone + ${Number(dfHold.taxiM).toFixed(1)} m taxi → owns=${dfHold.heldOwns} at ${Number(dfHold.heldH).toFixed(1)} m, billboard shown=${dfHold.heldBb} (want owns=true, bb=false: no 3D→2D pop). Independent mesh floor: base=${dfHold.baseMeshM == null ? 'cold' : Number(dfHold.baseMeshM).toFixed(1)} m, taxi=${dfHold.taxiMeshM == null ? 'cold' : Number(dfHold.taxiMeshM).toFixed(1)} m`);

        record('display-floor/hold: past the drift bound the hold is released and the model is withheld',
          !dfHold.error && dfHold.releasedOwns === false && dfHold.releasedBb === true,
          dfHold.error || `${Number(dfHold.farM).toFixed(1)} m from the sample: model owns=${dfHold.releasedOwns}, billboard back at shown=${dfHold.releasedBb}`);
      }


    }

    // Cleanup: drop the synthetics and the seeded cells so nothing leaks into
    // the run-wide console/HTTP checks below.
    await evalPage(async () => {
      const gev = window.__godsEyeView;
      const v = gev.viewer;
      const fl = gev.dataManager.layers.get('flights').module;
      window.__SYNTH.flights = window.__SYNTH.flights.filter((f) => !/^aaa09/.test(f.icao));
      fl.stopTracking();
      window.__dfGf?._clearMeshFloorCellsForTest();
      delete v.scene.sampleHeight;
      if (gev.tileset) {
        const prior = window.__dfPriorTilesLoadedDescriptor;
        if (prior) Object.defineProperty(gev.tileset, 'tilesLoaded', prior);
        else delete gev.tileset.tilesLoaded;
      }
      delete window.__dfPriorTilesLoadedDescriptor;
      delete window.__dfSkinSamples;
      delete window.__dfSkinM;
      delete window.__dfObserveTrackedExit;
      await fl.update(v);
    });



    // Harness hardening (2026-07-06): the two earlier console-error checks run
    // BEFORE the ground/ground-3d/arrival groups — an exception thrown in
    // those later scenarios (e.g. inside a fleet tick) was invisible and
    // surfaced only as inexplicable downstream assertion failures. Catch-all.
    record('no console errors across the FULL run (late groups included)', consoleErrors.length === 0,
      consoleErrors.length
        ? `${consoleErrors.length}: ${consoleErrors.slice(-3).join(' | ')}`
        : 'clean');
    record('no HTTP 5xx responses across the FULL run', failedResponses.length === 0,
      failedResponses.length
        ? `${failedResponses.length}: ${failedResponses.slice(-3).join(' | ')}`
        : 'clean');

    finishAndExit();
  } finally {
    if (OFFLINE_IMAGERY) console.log(`  Bundled imagery tiles served: ${offlineImageryRequests}`);
    if (!KEEP_OPEN) {
      await browser.close();
    } else {
      console.log('\n--keep-open set; leaving browser running. Ctrl-C to exit.');
    }
  }

  function finishAndExit() {
    const failed = results.filter((r) => r.ok === false);
    const passed = results.filter((r) => r.ok === true);
    const skipped = results.filter((r) => r.ok === null);
    console.log(`\n${'─'.repeat(60)}`);
    console.log(`  RESULT: ${passed.length} passed, ${failed.length} failed, ${skipped.length} skipped`);
    console.log(`${'─'.repeat(60)}\n`);
    process.exitCode = failed.length > 0 ? 1 : 0;
  }
}

// ---------------------------------------------------------------------------
// Frame sampler: run `sampleFn` once per render frame for `count` frames,
// in the page, collecting its numeric return (or null).
// ---------------------------------------------------------------------------
async function sampleFrames(page, count, sampleFn, ...args) {
  const { values, timedOut } = await page.evaluate(async (fnStr, n, extra) => {
    const fn = new Function('return (' + fnStr + ')')();
    const v = window.__godsEyeView.viewer;
    const out = [];
    let timedOut = false;
    await new Promise((resolve) => {
      let i = 0;
      let settled = false;
      const finish = () => {
        if (settled) return;
        settled = true;
        clearTimeout(timer);
        remove();
        resolve();
      };
      const remove = v.scene.postRender.addEventListener(() => {
        try { out.push(fn(...extra)); } catch (e) { out.push(null); }
        if (++i >= n) {
          finish();
          return;
        }
        // Cesium runs with requestRenderMode enabled, so one request produces
        // one postRender callback. Drive every sample explicitly instead of
        // waiting forever after the first frame.
        v.scene.requestRender();
      });
      const timer = setTimeout(() => {
        timedOut = true;
        finish();
      }, Math.max(15000, n * 1500));
      v.scene.requestRender();
    });
    return { values: out, timedOut };
  }, sampleFn.toString(), count, args);
  return { values, timedOut };
}

function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }

/** Great-circle surface distance (m) between two lat/lon points (small-angle safe). */
function haversineMeters(lat1, lon1, lat2, lon2) {
  const R = 6371000;
  const toRad = (d) => (d * Math.PI) / 180;
  const dLat = toRad(lat2 - lat1);
  const dLon = toRad(lon2 - lon1);
  const a = Math.sin(dLat / 2) ** 2
    + Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLon / 2) ** 2;
  return 2 * R * Math.asin(Math.sqrt(a));
}

// Poll a node-side predicate.
function waitFor(pred, timeoutMs) {
  return new Promise((resolve, reject) => {
    const start = Date.now();
    const tick = () => {
      if (pred()) return resolve();
      if (Date.now() - start > timeoutMs) return reject(new Error('waitFor timeout'));
      setTimeout(tick, 100);
    };
    tick();
  });
}

main().catch((err) => {
  console.error('\n\x1b[31mHarness error:\x1b[0m', err && err.stack ? err.stack : err);
  process.exit(2);
});