Move scene effects and imported geometry behind the globe contract

Move Cesium viewer, map, sky, projection, trail and sonar internals into
its engine. Drive styles, bloom, sharpening and contact sonar through
engine.render. Count camera-input suspensions across all three engines
and migrate the feature callers. Preserve Cesium's effects and input
behaviour; fix transit lens clicks on Cesium and make zero sharpening on
Navara disable sharpening, as it does on Cesium.

Parse imported files into plain records and draw them through movers,
lines, ground and imagery on both engines. Follow Cesium's KML style
precedence, preserve local KMZ images and frame the drawable records.
Open overlays use imagery when the engine has no native map-overlay API.
Run every imported-display case on fake and headless Cesium engines.

The shared import path retains these known differences from Cesium's old
DataSources: wall fills, extruded prisms and gx:LatLonQuad are undrawn;
raised polygon fills drape while outlines retain altitude; GroundOverlay
rotation, altitude and RGB tint are not applied; rhumb lines become great
circles. Ground heights use the loaded surface synchronously instead of
waiting for most-detailed sampling. Supported KMZ ground overlays now
draw on Navara too. Document the limits rather than claiming full parity.

Combine batches B and C because their disjoint path manifests cannot
place the shared boundary and format files in a later commit while
keeping B independently valid. This combined commit owns the shared
docs, package boundaries, format scope, locale catalogs and coupling
baseline. Remove five obsolete import strings from all eleven catalogs.
Make the load-time source scan include new files and skip deleted paths
so the same checks work before and after recording the moves.

Coupling: Navara renderer lines fall from 1695 to 1294, Cesium import
files from 25 to 9, viewer lines from 1177 to 1026, SDK loads from 4 to 3
and engine-name lines from 62 to 42. No count grows.

The full unit suite and the boundary, format and coupling checks pass.
Browser validation remains to be run.

Browser checks to run
GOOGLE_MAPS_API_KEY= CESIUM_ION_TOKEN= npm run dev -- --port 4291
node scripts/qa-contract-suite.mjs http://localhost:4291
node scripts/qa-navara-visual-styles.mjs http://localhost:4291
node scripts/qa-navara-bloom.mjs http://localhost:4291
node scripts/qa-navara-sonar.mjs http://localhost:4291
QA_BASE_URL=http://localhost:4291 node scripts/qa-visual-effects.mjs
QA_BASE_URL=http://localhost:4291 node scripts/qa-zoom-out-guard.mjs
node scripts/qa-sky-model-lighting.mjs --url http://localhost:4291
node scripts/qa-geo-import.mjs http://localhost:4291
node scripts/qa-geo-import-regressions.mjs http://localhost:4291
node scripts/qa-geo-import-large.mjs http://localhost:4291
node scripts/qa-navara-geo-import.mjs http://localhost:4291

Use the keyless server for every check. Photoreal-only cases remain
unverified; do not enable paid tiles to run them.

scripts/qa-geo-import.mjs

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
 /**
  * Rendered acceptance for UTILITIES ▸ Import: real files through the real file
- * input and a real drop, parsed by Cesium in the page.
+ * input and a real drop, drawn through the globe contract.
  *
  * Proves: GeoJSON, KML, KMZ (with a packed icon and ground overlay) and GPX
- * each become one row and one data source; the imported shape actually paints
+ * each become one row and owned drawing sets; the imported shape actually paints
  * on the globe in its row's color (a GeoJSON `stroke`/`fill` does not override
  * it) and stops painting when hidden; no import makes the page request
  * anything named in it (network link, remote icon, remote style, palette
  * icon, balloon or extended-data HTML, maki marker) or anything outside the
- * page for it; no entity keeps a description, label or properties; dated KML
+ * page for it; no drawing keeps a description, label or properties; dated KML
  * and GPX leave the app's clock alone and still draw now; a GPX track keeps
  * its two segments apart; keyboard focus survives hide/show; a dropped file
  * imports like a picked one; a file that is not geodata is refused with a
- * reason and leaves nothing behind; Remove gives every data source back; no
+ * reason and leaves nothing behind; Remove releases every drawing set; no
  * page errors.
  *
  * Usage: dev server up (`npm run dev`), then `node scripts/qa-geo-import.mjs`.
@@ -23,9 +23,13 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import puppeteer from 'puppeteer';
+import { installImportProbe } from './qa-geo-import-probe.mjs';
 import { hookRenderErrors, readRenderErrors } from './qa-browserEvidence.mjs';
 
-const BASE_URL = process.env.QA_BASE_URL || 'http://localhost:4173';
+const BASE_URL =
+  process.argv.find((arg) => /^https?:/.test(arg)) ||
+  process.env.QA_BASE_URL ||
+  'http://localhost:4173';
 const SHOT_DIR = process.env.QA_SHOT_DIR || 'qa-shots/geo-import';
 const HEADFUL = process.env.QA_HEADFUL === '1';
 // Golden Gate Park: a big, flat, green rectangle the test polygon can cover.
@@ -233,7 +237,8 @@ async function cyanPixels() {
 const state = () =>
   page.evaluate(() => ({
     files: window.__gevGeoImport.list(),
-    dataSources: window.__godsEyeView.viewer.dataSources.length,
+    drawing: window.__qaImports.list(),
+    groups: window.__qaImports.groups().length,
     rows: document.querySelectorAll('#geo-import-list .geo-import-row').length,
     hint: document.getElementById('geo-import-hint')?.textContent || '',
   }));
@@ -283,6 +288,7 @@ try {
         .width > 0,
     { timeout: 10_000 },
   );
+  await installImportProbe(page);
   const before = await state();
   check(
     'Import is in the UTILITIES panel with an empty, hidden list',
@@ -313,7 +319,6 @@ try {
       };
     });
   const clockBefore = await clock();
-  const sourcesBefore = before.dataSources;
 
   // Picked through the real <input type=file>.
   const input = await page.$('#geo-import-input');
@@ -328,10 +333,8 @@ try {
     );
   const after = await state();
   check(
-    'four picked files become four rows and four data sources',
-    imported &&
-      after.rows === 4 &&
-      after.dataSources === before.dataSources + 4,
+    'four picked files become four rows and four groups of drawing sets',
+    imported && after.rows === 4 && after.groups === before.groups + 4,
     JSON.stringify(
       after.files.map((f) => `${f.name}:${f.format}:${f.entityCount}`),
     ),
@@ -361,85 +364,70 @@ try {
       )),
     `${JSON.stringify(clockBefore)} → ${JSON.stringify(clockAfter)}`,
   );
-  const inside = await page.evaluate((from) => {
-    const viewer = window.__godsEyeView.viewer;
-    const now = viewer.clock.currentTime;
-    const sources = [];
-    for (let i = from; i < viewer.dataSources.length; i++)
-      sources.push(viewer.dataSources.get(i));
-    const entities = sources.flatMap(
-      (ds) => ds.importedEntities || ds.entities.values,
-    );
-    const named = (name) => entities.find((e) => e.name === name);
-    const gpx = sources[3].importedEntities || sources[3].entities.values;
-    const kmz = sources[2].importedEntities || sources[2].entities.values;
+  const inside = await page.evaluate(() => {
+    const groups = window.__qaImports.groups();
+    const pins = (group) =>
+      group.filter((r) => r.kind === 'movers').flatMap((r) => r.items);
+    const paths = (group) =>
+      group
+        .filter((r) => r.kind === 'ground' && r.options.kind === 'corridor')
+        .flatMap((r) => r.items);
+    const kml = groups[1],
+      kmz = groups[2],
+      gpx = groups[3];
+    const drawings = groups.flat().flatMap((r) => [r.options, ...r.items]);
     return {
-      sources: sources.length,
-      clocks: sources.filter((ds) => ds.clock !== undefined).length,
-      described: entities.filter((e) => e.description !== undefined).length,
-      labelled: entities.filter((e) => e.label !== undefined).length,
-      withProperties: entities.filter((e) => e.properties !== undefined).length,
-      withKml: entities.filter((e) => e.kml !== undefined).length,
-      hidden: entities.filter((e) => !e.isAvailable(now)).length,
-      datedPinNow: Boolean(named('QA KML pin')?.isAvailable(now)),
-      fallbackPins: ['QA KML pin', 'QA palette pin'].filter((name) =>
-        named(name)?.billboard?.image?.getValue(now),
-      ).length,
-      movingIsLine: Boolean(
-        named('QA moving')?.polyline && !named('QA moving')?.position,
+      groups: groups.length,
+      metadata: drawings.some((r) =>
+        [
+          'description',
+          'label',
+          'properties',
+          'kml',
+          'availability',
+          'clock',
+        ].some((key) => key in r),
       ),
-      movingVertices:
-        named('QA moving')?.polyline?.positions?.getValue(now)?.length,
-      splitTracks: (sources[1].importedEntities || sources[1].entities.values)
-        .filter((e) => e.parent?.name === 'QA split tracks' && e.polyline)
-        .map((e) => e.polyline.positions.getValue(now).length),
-      gpxLines: gpx.filter((e) => e.polyline).length,
-      gpxPoints: gpx.filter((e) => e.billboard || e.point).length,
-      kmzLocalImage: kmz.some((e) =>
-        String(e.billboard?.image?.getValue(now) || '').startsWith('blob:'),
+      fallbackPins: pins(kml).length,
+      datedPinsShown: pins(kml).every((pin) => pin.show),
+      kmlVertices: paths(kml).map((line) => line.positions.length),
+      gpxLines: paths(gpx).length,
+      gpxPoints: pins(gpx).length,
+      kmzPins: pins(kmz).length,
+      kmzOverlay: kmz.some(
+        (r) => r.kind === 'imagery' && r.options.source.url.startsWith('blob:'),
+      ),
+      groundedLines: [kml, kmz].every(
+        (group) =>
+          paths(group).length === 4 && !group.some((r) => r.kind === 'lines'),
+      ),
+      xyzPolygon: groups[0].some(
+        (r) =>
+          r.kind === 'ground' &&
+          r.options.kind === 'polygon' &&
+          r.items[0].rings.flat().every((p) => p.length === 2),
       ),
-      kmzOverlay: kmz.some((e) => e.rectangle),
-      groundedLines: sources
-        .slice(1, 3)
-        .every((ds) =>
-          (ds.importedEntities || ds.entities.values)
-            .filter((e) => e.polyline)
-            .every((e) => e.polyline.clampToGround?.getValue(now)),
-        ),
-      xyzPolygon:
-        (sources[0].importedEntities || sources[0].entities.values)
-          .find((e) => e.polygon)
-          ?.polygon.perPositionHeight?.getValue(now) !== true,
     };
-  }, sourcesBefore);
+  });
   check(
-    'no imported entity keeps a description, label, properties or KML data',
-    inside.sources === 4 &&
-      inside.described +
-        inside.labelled +
-        inside.withProperties +
-        inside.withKml ===
-        0,
+    'import drawing contains no descriptions, labels, properties or time data',
+    inside.groups === 4 && !inside.metadata,
     JSON.stringify(inside),
   );
   check(
-    'no imported source has a clock, and dated features draw now',
-    inside.clocks === 0 &&
-      inside.hidden === 0 &&
-      inside.datedPinNow &&
-      inside.movingIsLine &&
-      inside.movingVertices === 2,
+    'dated KML pins draw now and its moving track is a two-vertex line',
+    inside.datedPinsShown && inside.kmlVertices[0] === 2,
     JSON.stringify(inside),
   );
   check(
-    'blocked KML icon sources use drawable local fallback pins',
+    'blocked KML icons use drawable local fallback pins',
     inside.fallbackPins === 2,
-    JSON.stringify({ fallbackPins: inside.fallbackPins }),
+    JSON.stringify(inside),
   );
   check(
     'KML MultiTrack keeps its segments and original vertex count',
-    inside.splitTracks.join() === '2,2',
-    JSON.stringify(inside.splitTracks),
+    inside.kmlVertices.slice(1, 3).join() === '2,2',
+    JSON.stringify(inside),
   );
   check(
     'the GPX track keeps its two segments apart',
@@ -447,18 +435,13 @@ try {
     JSON.stringify(inside),
   );
   check(
-    'KMZ retains its own packed image and overlay',
-    inside.kmzLocalImage && inside.kmzOverlay,
+    'KMZ retains its packed pin and imagery overlay',
+    inside.kmzPins === 2 && inside.kmzOverlay && after.files[2].undrawn === 0,
   );
   check(
     'XYZ polygons and KML/KMZ lines use ground geometry',
     inside.xyzPolygon && inside.groundedLines,
   );
-  await page.evaluate((from) => {
-    for (const entity of window.__godsEyeView.viewer.dataSources.get(from)
-      .entities.values)
-      if (entity.billboard) entity.show = false;
-  }, sourcesBefore);
   await page.evaluate((view) => {
     const viewer = window.__godsEyeView.viewer;
     viewer.camera.cancelFlight?.();
@@ -574,9 +557,10 @@ try {
     );
   const cleared = await state();
   check(
-    'Remove gives every data source back',
-    cleared.rows === 0 && cleared.dataSources === before.dataSources,
-    `${cleared.dataSources} vs ${before.dataSources}`,
+    'Remove releases every import drawing set',
+    cleared.rows === 0 &&
+      Object.values(cleared.drawing).every((list) => list.length === 0),
+    JSON.stringify(cleared.drawing),
   );
   await wait(1500);
   check(