fix(import): correct clamping and bound local-file rendering

Normalize GeoJSON ground footprints, preserve explicit KML track heights,
and tessellate ground paths before native loading. Validate coordinates,
geometry types and decoded image budgets before allocating native resources;
strip loader-sensitive metadata and settle deferred failures and cancellation.

Render static pins in owned billboard collections instead of walking tens
of thousands of point entities each frame. Refine nearby ground heights in
batches, isolate imported pins from height picks, and release owned resources
and point selections on removal. Use safe ray origins above a hidden coarse
globe and retain valid mesh heights outside the current footprint.

Frame complete geometry with viewport-aware nadir arrivals, including walls
and rotated overlays; respect camera gestures and accept document file drops.
Strengthen real-loader, native 3D Tiles, paint, clock and lifecycle coverage.
Addresses both P1 and all 25 P2 findings in the follow-up review of #1122.

src/ui/flyToDataSource.js

@@ -1,92 +1,122 @@
-/**
- * Fly to everything in an imported file without
- * trusting Cesium's own framing of ground-clamped points: before the
- * destination's terrain has streamed in, a clamped billboard reports a
- * bounding sphere kilometers below the surface, and `viewer.flyTo` follows it
- * underground. Instead the footprint is framed from the features' longitudes
- * and latitudes, and the camera ground guard lifts the eye once the real
- * surface can be measured.
- */
+/** Frame the complete finite footprint of a session-local file. */
 import * as Cesium from 'cesium';
 import { guardCameraAboveGround } from '../cameraGroundGuard.js';
+import { rangeForBoundingSphere } from '../data/cameraFraming.js';
+import { cancelCameraArrival } from '../data/cameraArrival.js';
 
-const SAMPLE_TARGET_POINTS = 5000;
-
-/**
- * Longitude/latitude pairs of every entity's position, line and polygon,
- * sampling long paths toward `SAMPLE_TARGET_POINTS` while retaining each
- * geometry's endpoints. Separate point features stay in the footprint so
- * distant outliers are not lost. Long tracks are walked by index, never
- * spread into a call, so a file with hundreds of thousands of vertices cannot
- * overflow the stack; only the kept points are converted.
- */
+/** All visible positions, path vertices, polygon rings, walls and overlay bounds. */
 export function dataSourcePoints(dataSource, time = Cesium.JulianDate.now()) {
-  const parts = [];
-  let total = 0;
-  for (const entity of dataSource?.entities?.values ?? []) {
-    const at = entity.position?.getValue?.(time);
-    if (at) {
-      parts.push([at]);
-      total += 1;
-    }
-    const line = entity.polyline?.positions?.getValue?.(time);
-    if (Array.isArray(line) && line.length) {
-      parts.push(line);
-      total += line.length;
-    }
-    const ring = entity.polygon?.hierarchy?.getValue?.(time)?.positions;
-    if (Array.isArray(ring) && ring.length) {
-      parts.push(ring);
-      total += ring.length;
-    }
-  }
-  const stride = Math.max(1, Math.ceil(total / SAMPLE_TARGET_POINTS));
   const points = [];
-  let index = 0;
-  for (const part of parts) {
-    // Keep every stride-th vertex across all parts, plus each part's ends so
-    // a short line is never skipped entirely.
-    for (let i = 0; i < part.length; i++, index++) {
-      if (index % stride !== 0 && i !== 0 && i !== part.length - 1) continue;
-      const carto = Cesium.Cartographic.fromCartesian(part[i]);
-      if (!carto) continue;
+  const add = (position, grounded = false) => {
+    if (
+      !position ||
+      ![position.x, position.y, position.z].every(Number.isFinite)
+    )
+      return;
+    const c = Cesium.Cartographic.fromCartesian(position);
+    if (c && Number.isFinite(c.longitude) && Number.isFinite(c.latitude))
       points.push([
-        Cesium.Math.toDegrees(carto.longitude),
-        Cesium.Math.toDegrees(carto.latitude),
+        Cesium.Math.toDegrees(c.longitude),
+        Cesium.Math.toDegrees(c.latitude),
+        grounded ? 0 : c.height,
       ]);
+  };
+  if (dataSource?.show === false) return points;
+  for (const entity of dataSource?.importedEntities ??
+    dataSource?.entities?.values ??
+    []) {
+    if (entity.isShowing === false) continue;
+    add(
+      entity.position?.getValue?.(time),
+      entity.billboard?.heightReference?.getValue?.(time) ===
+        Cesium.HeightReference.CLAMP_TO_GROUND,
+    );
+    for (const graphic of [entity.polyline, entity.wall])
+      for (const position of graphic?.positions?.getValue?.(time) || [])
+        add(position, graphic.clampToGround?.getValue?.(time) === true);
+    const rings = [entity.polygon?.hierarchy?.getValue?.(time)];
+    while (rings.length) {
+      const ring = rings.pop();
+      for (const position of ring?.positions || [])
+        add(
+          position,
+          entity.polygon?.perPositionHeight?.getValue?.(time) !== true,
+        );
+      for (const hole of ring?.holes || []) rings.push(hole);
+    }
+    const rectangle = entity.rectangle?.coordinates?.getValue?.(time);
+    if (rectangle) {
+      const bounds = Cesium.RectangleGeometry.computeRectangle({
+        rectangle,
+        rotation: entity.rectangle.rotation?.getValue?.(time) || 0,
+      });
+      for (const corner of [
+        'southwest',
+        'southeast',
+        'northwest',
+        'northeast',
+      ]) {
+        const c = Cesium.Rectangle[corner](bounds);
+        if (Number.isFinite(c.longitude) && Number.isFinite(c.latitude))
+          points.push([
+            Cesium.Math.toDegrees(c.longitude),
+            Cesium.Math.toDegrees(c.latitude),
+            entity.rectangle.height?.getValue?.(time) || 0,
+          ]);
+      }
     }
   }
   return points;
 }
 
-/**
- * @param {Cesium.Viewer} viewer
- * @param {Cesium.DataSource} dataSource
- * @param {{duration?: number}} [options]
- * @returns {boolean} Whether there was anything to fly to.
- */
-export function flyToDataSource(viewer, dataSource, { duration = 1.5 } = {}) {
+/** Fly synchronously to the footprint; later navigation always owns its camera. */
+export function flyToDataSource(
+  viewer,
+  dataSource,
+  { duration = 1.5, ground = null } = {},
+) {
   const points = dataSourcePoints(dataSource);
-  if (!points.length) {
-    viewer.flyTo?.(dataSource, { duration });
-    return false;
-  }
-  const sphere = Cesium.BoundingSphere.fromPoints(
-    points.map(([lon, lat]) => Cesium.Cartesian3.fromDegrees(lon, lat, 0)),
+  if (!points.length) return false;
+  cancelCameraArrival(viewer);
+  const positions = points.map(([lon, lat, height]) =>
+    Cesium.Cartesian3.fromDegrees(lon, lat, height),
   );
-  const center = Cesium.Cartographic.fromCartesian(sphere.center);
+  const sphere = Cesium.BoundingSphere.fromPoints(positions);
+  const center =
+    Cesium.Cartographic.fromCartesian(sphere.center) ||
+    Cesium.Cartographic.fromDegrees(points[0][0], points[0][1]);
+  const lat = Cesium.Math.toDegrees(center.latitude),
+    lon = Cesium.Math.toDegrees(center.longitude);
+  const terrain = viewer.scene?.globe?.getHeight?.(center);
+  const cached = ground?.cachedGroundFloor?.(lat, lon);
+  const height =
+    Number.isFinite(terrain) && terrain > 0
+      ? terrain
+      : Number.isFinite(cached)
+        ? cached
+        : Number.isFinite(terrain)
+          ? terrain
+          : 0;
+  ground?.warmGroundFloor?.([{ lat, lon }]);
+  sphere.center = Cesium.Cartesian3.fromRadians(
+    center.longitude,
+    center.latitude,
+    Math.max(0, height, center.height),
+  );
+  sphere.radius = 0;
+  for (const position of positions)
+    sphere.radius = Math.max(
+      sphere.radius,
+      Cesium.Cartesian3.distance(sphere.center, position),
+    );
   viewer.camera?.flyToBoundingSphere?.(sphere, {
     offset: new Cesium.HeadingPitchRange(
       viewer.camera.heading || 0,
-      Cesium.Math.toRadians(-45),
-      Math.max(800, sphere.radius * 2.8),
+      -Math.PI / 2,
+      Math.max(800, rangeForBoundingSphere(viewer, sphere.radius)),
     ),
     duration,
-    complete: () =>
-      guardCameraAboveGround(viewer, {
-        lat: Cesium.Math.toDegrees(center.latitude),
-        lon: Cesium.Math.toDegrees(center.longitude),
-      }),
+    complete: () => guardCameraAboveGround(viewer, { lat, lon }),
   });
   return true;
 }

src/ui/flyToDataSource.test.mjs

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import * as Cesium from 'cesium';
+import { cancelCameraArrival } from '../data/cameraArrival.js';
 import { dataSourcePoints, flyToDataSource } from './flyToDataSource.js';
 
 function source() {
@@ -55,7 +56,11 @@ test('the camera frames the footprint at the surface, never a buried center', ()
     flyToDataSource(viewer, new Cesium.CustomDataSource('empty')),
     false,
   );
-  assert.equal(calls.at(-1), 'viewer.flyTo');
+  assert.equal(
+    calls.length,
+    1,
+    'empty sources never start deferred navigation',
+  );
 });
 
 test('a very long track is framed without spreading it into a call', () => {
@@ -69,8 +74,90 @@ test('a very long track is framed without spreading it into a call', () => {
   ds.entities.add({ polyline: { positions: line } });
   ds.entities.add({ position: Cesium.Cartesian3.fromDegrees(-110, 41) });
   const points = dataSourcePoints(ds);
-  assert.ok(points.length <= 5002, `${points.length} points kept`);
+  assert.equal(points.length, n + 1, 'every vertex contributes to framing');
   const lons = points.map(([lon]) => lon);
-  assert.ok(Math.min(...lons) < -119.99 && Math.max(...lons) > -110.01);
+  assert.ok(
+    lons.reduce((a, b) => Math.min(a, b), Infinity) < -119.99 &&
+      lons.reduce((a, b) => Math.max(a, b), -Infinity) > -110.01,
+  );
   assert.ok(lons.some((lon) => Math.abs(lon - -118.000005) < 0.01));
 });
+
+test('framing includes a sparse interior outlier, walls and rotated overlays', () => {
+  const ds = new Cesium.CustomDataSource('bounds');
+  const line = Array.from({ length: 200031 }, () =>
+    Cesium.Cartesian3.fromDegrees(0, 0),
+  );
+  line[12345] = Cesium.Cartesian3.fromDegrees(20, 10);
+  ds.entities.add({ polyline: { positions: line } });
+  ds.entities.add({
+    wall: { positions: Cesium.Cartesian3.fromDegreesArray([30, 10, 31, 11]) },
+  });
+  ds.entities.add({
+    rectangle: {
+      coordinates: Cesium.Rectangle.fromDegrees(40, 0, 41, 1),
+      rotation: Math.PI / 4,
+    },
+  });
+  const points = dataSourcePoints(ds);
+  assert.ok(points.some(([lon]) => Math.abs(lon - 20) < 1e-6));
+  assert.ok(points.some(([lon]) => Math.abs(lon - 31) < 1e-6));
+  assert.ok(points.some(([lon]) => lon > 41));
+});
+
+test('portrait framing accounts for FOV, high ground and symmetric extents', () => {
+  const ds = new Cesium.CustomDataSource('view');
+  ds.entities.add({
+    polyline: {
+      positions: Cesium.Cartesian3.fromDegreesArray([-105, 39, -104.9, 39]),
+    },
+  });
+  const calls = [];
+  const viewer = {
+    scene: { globe: { getHeight: () => 2600 } },
+    camera: {
+      frustum: { fov: Math.PI / 3, aspectRatio: 390 / 844 },
+      flyToBoundingSphere: (sphere, options) => calls.push({ sphere, options }),
+    },
+  };
+  flyToDataSource(viewer, ds);
+  assert.ok(
+    Math.abs(
+      Cesium.Cartographic.fromCartesian(calls[0].sphere.center).height - 2600,
+    ) < 1e-6,
+  );
+  assert.equal(calls[0].options.offset.pitch, -Math.PI / 2);
+  viewer.camera.frustum.aspectRatio = 16 / 9;
+  flyToDataSource(viewer, ds);
+  assert.ok(calls[0].options.offset.range > calls[1].options.offset.range);
+  const symmetric = {
+    entities: {
+      values: [
+        { position: { getValue: () => new Cesium.Cartesian3(6378137, 0, 0) } },
+        { position: { getValue: () => new Cesium.Cartesian3(-6378137, 0, 0) } },
+      ],
+    },
+  };
+  assert.doesNotThrow(() => flyToDataSource(viewer, symmetric));
+  assert.ok(Number.isFinite(calls.at(-1).options.offset.range));
+  assert.doesNotThrow(() => calls.at(-1).options.complete());
+  cancelCameraArrival(viewer);
+});
+
+test('non-finite positions and hidden features never enter the camera footprint', () => {
+  const position = (p) => ({ position: { getValue: () => p } });
+  const points = dataSourcePoints({
+    entities: {
+      values: [
+        position(new Cesium.Cartesian3(NaN, 1, 2)),
+        {
+          ...position(Cesium.Cartesian3.fromDegrees(10, 10)),
+          isShowing: false,
+        },
+        position(Cesium.Cartesian3.fromDegrees(20, 20)),
+      ],
+    },
+  });
+  assert.equal(points.length, 1);
+  assert.ok(Math.abs(points[0][0] - 20) < 1e-6);
+});

src/ui/geoFileImport.js

@@ -1,24 +1,4 @@
-/**
- * DISPLAY ▸ Import: put your own GeoJSON, KML, KMZ or GPX files on the globe.
- *
- * Files come in through the Import button or by dropping them onto the globe.
- * Each one becomes its own Cesium data source, clamped to the ground, with a
- * row in the panel to show or hide it, fly to it, or remove it. Files are read
- * in the browser and never uploaded; see `src/data/geoFileImport.js` for what
- * is accepted and what is stripped from KML before Cesium reads it.
- *
- * Imported files last for the page session: a reload starts empty.
- *
- * Imports run one batch at a time (a second pick or drop waits for the
- * first), so the file cap is checked against what is really on the globe.
- * Fly-to goes through the app's navigation policy (`navigation`, the
- * application shell): the button is an immediate navigation, and the fly
- * after an import is a deferred one, stamped when the import starts and
- * re-asserted just before flying, so a camera move, Cockpit or any newer
- * navigation in between wins over a slow file.
- * `destroy()` removes every imported data source, revokes every blob URL and
- * gives back every listener and the `window.__gevGeoImport` handle.
- */
+/** Session-local file controls, serial loading and application-owned navigation. */
 import {
   GEO_FILE_ACCEPT,
   GeoImportError,
@@ -44,6 +24,8 @@ export function initGeoFileImport({
   document: doc = globalThis.document,
   flyToSource = flyToDataSource,
   navigation = null,
+  ground = null,
+  subscribeMapSource = null,
 }) {
   const button = doc?.getElementById('geo-import-button');
   const input = doc?.getElementById('geo-import-input');
@@ -58,6 +40,9 @@ export function initGeoFileImport({
   let colorAt = 0;
   let destroyed = false;
   let dragDepth = 0;
+  let cameraIntent = 0;
+  const lifetime = new AbortController();
+  let removeMapSource;
 
   const listen = (target, type, listener, options) => {
     if (!target?.addEventListener) return;
@@ -68,6 +53,52 @@ export function initGeoFileImport({
     if (hint) hint.textContent = text || '';
   };
   const render = () => viewer.scene?.requestRender?.();
+  let groundTimer,
+    groundQueued = false,
+    groundAgain = false;
+  const groundRemovers = [];
+  const scheduleGround = () => {
+    if (destroyed || !imports.length) return;
+    if (groundQueued) {
+      groundAgain = true;
+      return;
+    }
+    clearTimeout(groundTimer);
+    groundTimer = setTimeout(() => {
+      groundQueued = true;
+      queue = queue
+        .catch(() => {})
+        .then(async () => {
+          try {
+            for (const item of imports) {
+              if (destroyed) return;
+              if (item.visible) await item.refreshGround?.(lifetime.signal);
+            }
+            render();
+          } catch {
+            if (!destroyed)
+              setHint(
+                'Ground heights could not be refreshed. Try the file again when the map has loaded.',
+              );
+          } finally {
+            groundQueued = false;
+            if (groundAgain) {
+              groundAgain = false;
+              scheduleGround();
+            }
+          }
+        });
+    }, 200);
+  };
+  removeMapSource = subscribeMapSource?.(scheduleGround);
+  const ownEvent = (event, listener) => {
+    const remove = event?.addEventListener?.(listener);
+    if (remove) groundRemovers.push(remove);
+  };
+  ownEvent(viewer.camera?.moveEnd, scheduleGround);
+  ownEvent(viewer.scene?.globe?.tileLoadProgressEvent, (pending) => {
+    if (!pending) scheduleGround();
+  });
 
   /** Which row button has focus, so a re-render can give it back. */
   function focusedAction() {
@@ -108,7 +139,7 @@ export function initGeoFileImport({
         name.className = 'geo-import-name';
         // textContent, never markup: the name comes from the file system.
         name.textContent = item.name;
-        name.title = `${item.name} — ${item.format.toUpperCase()}, ${item.entityCount.toLocaleString()} feature${item.entityCount === 1 ? '' : 's'}${item.ownStyles ? ', drawn with its own styles' : ''}`;
+        name.title = `${item.name} — ${item.format.toUpperCase()}, ${item.entityCount.toLocaleString()} map object${item.entityCount === 1 ? '' : 's'}${item.ownStyles ? ', drawn with its own styles' : ''}`;
         const actions = [
           [
             item.visible ? 'visibility' : 'visibility_off',
@@ -149,6 +180,7 @@ export function initGeoFileImport({
     if (!item) return false;
     item.visible = Boolean(visible);
     item.dataSource.show = item.visible;
+    if (item.visible) scheduleGround();
     renderList();
     render();
     return true;
@@ -158,7 +190,7 @@ export function initGeoFileImport({
   // destination's terrain has loaded (see ./flyToDataSource.js).
   const fly = (item) => {
     if (!item.visible) setVisible(item.id, true);
-    flyToSource(viewer, item.dataSource);
+    flyToSource(viewer, item.dataSource, { ground });
     return true;
   };
 
@@ -216,12 +248,13 @@ export function initGeoFileImport({
     // Capture the user's intent when the files are chosen, including time
     // spent waiting for an earlier batch. Later navigation must still win.
     const generation = beginAutoFly();
-    const run = queue.then(() => importBatch(list, generation));
+    const intent = ++cameraIntent;
+    const run = queue.then(() => importBatch(list, generation, intent));
     queue = run.catch(() => {});
     return run;
   }
 
-  async function importBatch(list, generation) {
+  async function importBatch(list, generation, intent) {
     const outcomes = [];
     if (destroyed || !list.length) return outcomes;
     for (const file of list) {
@@ -239,7 +272,7 @@ export function initGeoFileImport({
       const color = COLORS[colorAt % COLORS.length];
       let loaded;
       try {
-        loaded = await load(file, { viewer, color });
+        loaded = await load(file, { viewer, color, signal: lifetime.signal });
       } catch (error) {
         outcomes.push({
           name: fileName,
@@ -247,7 +280,7 @@ export function initGeoFileImport({
           error:
             error instanceof GeoImportError || error?.name === 'GeoImportError'
               ? error.message
-              : `That file could not be read${error?.message ? `: ${error.message}` : '.'}`,
+              : 'That file could not be read.',
         });
         continue;
       }
@@ -268,6 +301,7 @@ export function initGeoFileImport({
         visible: true,
         dataSource: loaded.dataSource,
         revoke: loaded.revoke,
+        refreshGround: loaded.refreshGround,
       };
       await viewer.dataSources.add(item.dataSource);
       if (destroyed) {
@@ -275,6 +309,7 @@ export function initGeoFileImport({
         item.revoke?.();
         break;
       }
+      loaded.mount?.();
       imports.push(item);
       renderList();
       render();
@@ -288,6 +323,7 @@ export function initGeoFileImport({
       // result, unless something else took the camera meanwhile.
       if (
         outcomes.filter((o) => o.ok).length === 1 &&
+        intent === cameraIntent &&
         autoFlyStillOwns(generation)
       )
         fly(item);
@@ -317,6 +353,15 @@ export function initGeoFileImport({
 
   // ---- drop onto the globe ----------------------------------------------
   const container = viewer.container;
+  const gesture = () => {
+    cameraIntent += 1;
+  };
+  listen(viewer.scene?.canvas || container, 'pointerdown', gesture, {
+    passive: true,
+  });
+  listen(viewer.scene?.canvas || container, 'wheel', gesture, {
+    passive: true,
+  });
   const hasFiles = (event) =>
     [...(event.dataTransfer?.types || [])].includes('Files');
   const setDragging = (on) =>
@@ -327,7 +372,7 @@ export function initGeoFileImport({
     dragDepth += 1;
     setDragging(true);
   });
-  listen(container, 'dragover', (event) => {
+  listen(doc, 'dragover', (event) => {
     if (!hasFiles(event)) return;
     event.preventDefault();
     if (event.dataTransfer) event.dataTransfer.dropEffect = 'copy';
@@ -337,7 +382,7 @@ export function initGeoFileImport({
     dragDepth = Math.max(0, dragDepth - 1);
     if (!dragDepth) setDragging(false);
   });
-  listen(container, 'drop', (event) => {
+  listen(doc, 'drop', (event) => {
     if (!hasFiles(event)) return;
     event.preventDefault();
     dragDepth = 0;
@@ -371,6 +416,10 @@ export function initGeoFileImport({
     destroy() {
       if (destroyed) return;
       destroyed = true;
+      lifetime.abort();
+      removeMapSource?.();
+      clearTimeout(groundTimer);
+      for (const remove of groundRemovers) remove();
       for (const item of imports.splice(0)) {
         viewer.dataSources?.remove?.(item.dataSource, true);
         item.revoke?.();
@@ -408,7 +457,6 @@ export function summarize(outcomes) {
     (n, o) => n + (o.ok ? o.removed || 0 : 0),
     0,
   );
-  if (added && stripped)
-    parts.push('KML descriptions and external references were left out.');
+  if (added && stripped) parts.push('Some KML content was left out.');
   return parts.join(' ');
 }

src/ui/geoFileImport.test.mjs

@@ -134,7 +134,7 @@ class FakeElement {
   }
 }
 
-function setup({ load, navigation, flyToSource } = {}) {
+function setup({ load, navigation, flyToSource, subscribeMapSource } = {}) {
   focus.active = null;
   const els = {
     'geo-import-button': new FakeElement('button', 'geo-import-button'),
@@ -150,6 +150,7 @@ function setup({ load, navigation, flyToSource } = {}) {
       return focus.active;
     },
   };
+  Object.setPrototypeOf(document, new FakeElement('document'));
   const added = [];
   const removed = [];
   const flights = [];
@@ -189,7 +190,8 @@ function setup({ load, navigation, flyToSource } = {}) {
     load: load || defaultLoad,
     document,
     ...(navigation ? { navigation } : {}),
-    ...(flyToSource ? { flyToSource } : {}),
+    ...(subscribeMapSource ? { subscribeMapSource } : {}),
+    flyToSource: flyToSource || ((_viewer, ds) => flights.push(ds)),
   });
   return {
     tool,
@@ -301,7 +303,7 @@ test('a refused file says why and does not stop the rest of the batch', async ()
     [false, false, true],
   );
   assert.equal(out[0].error, 'That KML file is not valid XML.');
-  assert.match(out[1].error, /could not be read: boom/);
+  assert.match(out[1].error, /could not be read\./);
   assert.match(
     t.els['geo-import-hint'].textContent,
     /^Added 1 file\. 2 files could not be added \(bad\.kml: That KML file is not valid XML\.\)/,
@@ -329,13 +331,13 @@ test('dropping files on the globe imports them; other drags are left alone', asy
   const c = t.viewer.container;
   const files = { types: ['Files'], files: [file('drop.kmz')] };
   let ev = { dataTransfer: { types: ['text/plain'] } };
-  c.emit('dragover', ev);
+  t.document.emit('dragover', ev);
   c.emit('dragenter', { dataTransfer: files });
   assert.ok(t.document.body.classList.contains('gev-geo-import-drag'));
   c.emit('dragleave', { dataTransfer: files });
   assert.ok(!t.document.body.classList.contains('gev-geo-import-drag'));
   c.emit('dragenter', { dataTransfer: files });
-  c.emit('drop', { dataTransfer: files });
+  t.document.emit('drop', { dataTransfer: files });
   assert.ok(!t.document.body.classList.contains('gev-geo-import-drag'));
   await new Promise((r) => setImmediate(r));
   assert.deepEqual(
@@ -347,7 +349,7 @@ test('dropping files on the globe imports them; other drags are left alone', asy
 test('stripped KML content is mentioned once, for the batch that had it', () => {
   assert.equal(
     summarize([{ name: 'a.kml', ok: true, removed: 3 }]),
-    'Added 1 file. KML descriptions and external references were left out.',
+    'Added 1 file. Some KML content was left out.',
   );
   assert.equal(
     summarize([{ name: 'b.geojson', ok: true, removed: 0 }]),
@@ -478,6 +480,79 @@ function navigationDouble({ immediate = true, reassert = true } = {}) {
   };
 }
 
+test('a direct camera gesture cancels the fly-to of a file still being read', async () => {
+  for (const gesture of ['pointerdown', 'wheel']) {
+    let release;
+    const t = setup({
+      load: async () => {
+        await new Promise((r) => (release = r));
+        return {
+          name: 'slow.geojson',
+          format: 'geojson',
+          entityCount: 1,
+          dataSource: {},
+        };
+      },
+    });
+    const result = t.tool.importFiles([file('slow.geojson')]);
+    await new Promise((r) => setImmediate(r));
+    t.viewer.container.emit(gesture);
+    release();
+    await result;
+    assert.equal(t.added.length, 1);
+    assert.equal(t.flights.length, 0);
+    t.tool.destroy();
+    assert.equal(t.document.listeners.length, 0);
+  }
+});
+
+test('dropping on panel controls is accepted and file drags prevent browser navigation', async () => {
+  const t = setup();
+  let prevented = 0;
+  const event = {
+    target: t.els['geo-import-button'],
+    dataTransfer: { types: ['Files'], files: [file('panel.kml')] },
+    preventDefault: () => prevented++,
+  };
+  t.document.emit('dragover', event);
+  t.document.emit('drop', event);
+  await new Promise((r) => setImmediate(r));
+  assert.equal(prevented, 2);
+  assert.equal(t.tool.list()[0].name, 'panel.kml');
+  t.tool.destroy();
+  assert.equal(t.document.listeners.length, 0);
+});
+
+test('ground refresh coalesces map changes and releases its subscription on teardown', async () => {
+  let changed,
+    unsubscribed = 0,
+    refreshed = 0;
+  const t = setup({
+    subscribeMapSource: (listener) => {
+      changed = listener;
+      return () => unsubscribed++;
+    },
+    load: async () => ({
+      name: 'point.geojson',
+      format: 'geojson',
+      entityCount: 1,
+      dataSource: {},
+      refreshGround: async () => refreshed++,
+    }),
+  });
+  await t.tool.importFiles([file('point.geojson')]);
+  changed();
+  changed();
+  changed();
+  await new Promise((resolve) => setTimeout(resolve, 300));
+  assert.equal(refreshed, 1);
+  t.tool.destroy();
+  changed();
+  await new Promise((resolve) => setTimeout(resolve, 250));
+  assert.equal(refreshed, 1);
+  assert.equal(unsubscribed, 1);
+});
+
 test('Fly to is an immediate navigation that Cockpit can refuse', async () => {
   const flown = [];
   const nav = navigationDouble({ immediate: false });

src/ui/templates/display-controls.html

@@ -148,7 +148,7 @@
       </div>
     </div>
     <div class="pp-toggle-group" id="geo-import-group">
-      <button class="pp-toggle-btn" id="geo-import-button" type="button" title="Show your own GeoJSON, KML, KMZ or GPX files on the globe (or drop them onto it). Files stay in this browser.">
+      <button class="pp-toggle-btn" id="geo-import-button" type="button" title="Show your own GeoJSON, KML, KMZ or GPX files on the globe (or drop them onto it). File bytes stay on this device; overlays can appear in map screenshots shared with voice.">
         <span class="pp-icon material-symbols-outlined" aria-hidden="true">upload_file</span>
         <span class="pp-label">Import</span>
       </button>