fix(import): address review on metadata, bounds, navigation, clock and GPX

- Imported metadata stays inert: descriptions, native labels, properties and
  KML extended data are dropped from every entity; names are kept as short
  plain text. GeoJSON loads with a describe that builds no HTML, and
  simplestyle (including marker-symbol) is dropped, so no icon asset is
  fetched for a file and GeoJSON draws in its row's color.
- Bound geometry before loading: features and vertices are counted in the
  parsed GeoJSON, the KML document and while reading GPX, and a file over
  20,000 features or 250,000 vertices is refused before Cesium builds it.
- Imports run one batch at a time, so concurrent picks or drops cannot pass
  the 12-file cap.
- Fly-to framing walks long tracks by index instead of spreading them into a
  call.
- Fly-to is an immediate navigation through the application shell; the fly
  after an import is a deferred navigation stamped when the batch starts and
  re-asserted just before flying.
- Dated imports never change the shared clock: imported sources expose no
  clock, entities are available for all time, and a KML gx:Track is drawn as
  its line.
- GPX is read into GeoJSON with one line per track segment, without times.
- KML/KMZ rows show a hatched swatch (they keep their own styles); keyboard
  focus is kept on the same control after hide/show and moves to the next
  row after remove.
- Unit regressions for each, and the rendered QA now imports hostile
  metadata, dated KML/GPX and a two-segment track, and fails on any request
  for a file's contents or icon assets, a clock change, or surviving
  metadata.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

src/ui/flyToDataSource.js

@@ -12,27 +12,47 @@ import { guardCameraAboveGround } from '../cameraGroundGuard.js';
 
 const MAX_POINTS = 5000;
 
-/** Longitude/latitude pairs of every entity's position, line and polygon. */
+/**
+ * Longitude/latitude pairs of every entity's position, line and polygon,
+ * thinned to at most `MAX_POINTS`. 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.
+ */
 export function dataSourcePoints(dataSource, time = Cesium.JulianDate.now()) {
-  const cartesians = [];
+  const parts = [];
+  let total = 0;
   for (const entity of dataSource?.entities?.values ?? []) {
     const at = entity.position?.getValue?.(time);
-    if (at) cartesians.push(at);
+    if (at) {
+      parts.push([at]);
+      total += 1;
+    }
     const line = entity.polyline?.positions?.getValue?.(time);
-    if (Array.isArray(line)) cartesians.push(...line);
-    const hierarchy = entity.polygon?.hierarchy?.getValue?.(time);
-    if (Array.isArray(hierarchy?.positions))
-      cartesians.push(...hierarchy.positions);
+    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(cartesians.length / MAX_POINTS));
+  const stride = Math.max(1, Math.ceil(total / MAX_POINTS));
   const points = [];
-  for (let i = 0; i < cartesians.length; i += stride) {
-    const carto = Cesium.Cartographic.fromCartesian(cartesians[i]);
-    if (!carto) continue;
-    points.push([
-      Cesium.Math.toDegrees(carto.longitude),
-      Cesium.Math.toDegrees(carto.latitude),
-    ]);
+  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;
+      points.push([
+        Cesium.Math.toDegrees(carto.longitude),
+        Cesium.Math.toDegrees(carto.latitude),
+      ]);
+    }
   }
   return points;
 }