Draw and inspect the same wind forecast when switching globes

scripts/package-boundaries.json

@@ -3677,6 +3677,8 @@
       "src/layers/infrastructure/render/navaraStems.js",
       "src/layers/weather/render/navara.js",
       "src/layers/weather/render/navaraSurface.js",
+      "src/layers/wind/render/navara.js",
+      "src/layers/wind/render/flowMesh.js",
       "src/layers/ghostMaps/render/navara.js",
       "src/layers/shared/render/navaraGroundPicks.js",
       "src/layers/cyclones/render/navara.js",

scripts/qa-wind-engine-switch.mjs

@@ -0,0 +1,170 @@
+import puppeteer from 'puppeteer';
+import sharp from 'sharp';
+import assert from 'node:assert/strict';
+import { blockPaidQaMaps } from './qa-map-policy.mjs';
+
+const base = new URL(process.argv[2]);
+if (
+  !['localhost', '127.0.0.1'].includes(base.hostname) ||
+  ['', '4173', '4185', '4186', '4187', '4188', '4189', '4194'].includes(
+    base.port,
+  )
+)
+  throw new Error('Supply an unreserved local keyless preview URL');
+base.search = '?engine=navara&welcome=0&look=cinematic';
+base.hash =
+  'v=2&lat=43.6500&lon=-79.3800&alt=2000000&heading=0&pitch=-90&roll=0&map=sentinel2&l=';
+const b = await puppeteer.launch({
+  headless: true,
+  args: ['--use-angle=metal', '--enable-gpu'],
+});
+try {
+  const p = await b.newPage();
+  await blockPaidQaMaps(p);
+  await p.setViewport({ width: 1024, height: 768 });
+  const errors = [];
+  p.on('pageerror', (e) => {
+    errors.push(e.message);
+    console.log('error', e.message.split('?')[0]);
+  });
+  const reads = [];
+  await p.setRequestInterception(true);
+  p.on('request', (req) => {
+    const u = new URL(req.url());
+    if (!u.pathname.startsWith('/api/wind/')) return req.continue();
+    reads.push(u.pathname + u.search);
+    const model = u.searchParams.get('model'),
+      kind = u.searchParams.get('overlay');
+    const count = 36 * 19;
+    if (u.pathname.endsWith('/manifest'))
+      return req.respond({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({
+          model,
+          overlay: kind ?? 'none',
+          grid: { nx: 36, ny: 19, lo1: 0, la1: 90, dx: 10, dy: 10 },
+          gridUrl: '/api/wind/grid/' + model + '-qa.bin' + u.search,
+          cycle: {
+            validIso: '2026-11-02T12:00:00Z',
+            runIso: '2026-11-02T06:00:00Z',
+          },
+          ...(kind
+            ? {
+                scalar: {
+                  kind,
+                  units: kind === 'temperature' ? '°C' : 'hPa',
+                  level:
+                    kind === 'temperature'
+                      ? '2 m above ground'
+                      : 'mean sea level',
+                },
+              }
+            : {}),
+        }),
+      });
+    const values = new Float32Array(count * (kind ? 3 : 2));
+    values.fill(8, 0, count);
+    values.fill(6, count, count * 2);
+    if (kind) values.fill(kind === 'temperature' ? 40 : 1020, count * 2);
+    return req.respond({
+      status: 200,
+      contentType: 'application/octet-stream',
+      body: Buffer.from(values.buffer),
+    });
+  });
+  p.on('console', (msg) => {
+    if (msg.type() === 'error' && /Shader|WebGLProgram/i.test(msg.text())) {
+      errors.push(msg.text());
+      console.log('GPU', msg.text().slice(0, 2500));
+    }
+  });
+  await p.goto(base.href);
+  const ready = async (kind) => {
+    await p.waitForFunction(
+      (k) =>
+        window.__godsEyeView?.engine.kind === k &&
+        !document.querySelector('#globe-engine')?.disabled &&
+        !document.querySelector('.engine-switch-frame') &&
+        document.querySelector('#loading-screen.hidden'),
+      { timeout: 90000 },
+      kind,
+    );
+    await p.evaluate(
+      () => window.__godsEyeView.styleManager.initialRestorePromise,
+    );
+  };
+  await ready('navara');
+  await p.evaluate(async () => {
+    const { dataManager, tileset } = window.__godsEyeView;
+    if (tileset || window.__GOOGLE_MAPS_API_KEY__)
+      throw Error('Keyless preview required');
+    const mod = dataManager.layers.get('wind').module;
+    window.qaWind = mod;
+    mod.setParams({ overlay: 'temperature', paused: true, units: 'm/s' });
+    await dataManager.setEnabled('wind', true, { origin: 'user' });
+  });
+  await p.waitForFunction(
+    () =>
+      window.qaWind.getDiagnostics().surface?.ready &&
+      window.qaWind.getDiagnostics().gpu?.ready,
+  );
+  await p.evaluate(() => window.qaWind.setParams({ inspect: true }));
+  const baseline = reads.length;
+  for (const kind of ['navara', 'cesium', 'navara']) {
+    if ((await p.evaluate(() => window.__godsEyeView.engine.kind)) !== kind) {
+      await p.select('#globe-engine', kind);
+      await ready(kind);
+    }
+    await p.waitForFunction(
+      () =>
+        window.qaWind.getDiagnostics().gpu?.ready &&
+        window.qaWind.getRowControls().summary.reading?.speed === 10,
+      { timeout: 90000 },
+    );
+    await new Promise((resolve) => setTimeout(resolve, 800));
+    const check = await p.evaluate(() => {
+      const { dataManager } = window.__godsEyeView;
+      const mod = dataManager.layers.get('wind').module;
+      return {
+        same: mod === window.qaWind,
+        params: mod.getParams(),
+        gpu: mod.getDiagnostics().gpu.pathCount,
+        reading: mod.getRowControls().summary.reading,
+      };
+    });
+    assert.equal(check.same, true);
+    assert.equal(check.params.paused, true);
+    assert.ok(check.gpu > 1000);
+    assert.equal(check.reading.scalarValue, '40.0 °C');
+    assert.equal(check.reading.from, 'SW');
+    const sample = await sharp(await p.screenshot())
+      .extract({ left: 530, top: 390, width: 24, height: 24 })
+      .removeAlpha()
+      .raw()
+      .toBuffer();
+    const [r, g, b] = [0, 1, 2].map((k) => {
+      let sum = 0;
+      for (let i = k; i < sample.length; i += 3) sum += sample[i];
+      return sum / (sample.length / 3);
+    });
+    console.log(kind, check.gpu, check.reading.wind, [r, g, b]);
+    assert.ok(
+      r > g * 1.35 && r > b * 1.35,
+      kind + ' temperature field visible',
+    );
+    assert.equal(reads.length, baseline);
+  }
+  await p.evaluate(() => window.qaWind.setParams({ paused: false }));
+  await p.waitForFunction(() => window.qaWind.getDiagnostics().gpu.phaseSeconds > 0.2);
+  await p.evaluate(() => window.qaWind.setParams({ paused: true }));
+  const frozen = await p.evaluate(() => window.qaWind.getDiagnostics().gpu.phaseSeconds);
+  await new Promise((resolve) => setTimeout(resolve, 250));
+  assert.equal(await p.evaluate(() => window.qaWind.getDiagnostics().gpu.phaseSeconds), frozen);
+  assert.deepEqual(errors, []);
+  console.log(
+    'PASS retained forecast grid, pause, temperature field and sampled wind on both engines',
+  );
+} finally {
+  await b.close();
+}