Keep the physical map foundation continuous at every zoom

.github/workflows/validate-continuous-zoom.yml

@@ -115,12 +115,16 @@ jobs:
           OCCUMED_PREVIEW_OUTPUT=continuous-motion/results \
             node scripts/validate-continuous-zoom.mjs
 
+          OCCUMED_PREVIEW_OUTPUT=continuous-motion/all-zoom-levels \
+            node scripts/validate-all-zoom-levels.mjs
+
       - uses: actions/upload-artifact@v4
         if: always()
         with:
           name: continuous-zoom-${{ github.sha }}
           path: |
             continuous-motion/results
+            continuous-motion/all-zoom-levels
             continuous-motion/server.log
             dist/virtual-assets/occumed-world-overview.pmtiles
           if-no-files-found: error

scripts/apply-schema-parity.mjs

@@ -174,6 +174,7 @@ water.metadata = {
 
 const landcover = runtime.layers.find((layer) => layer.id === 'landcover');
 if (!landcover) throw new Error('The exported landcover layer is missing from the runtime style.');
+landcover.minzoom = 0;
 landcover.paint ||= {};
 landcover.paint['fill-opacity'] = [
   'interpolate',
@@ -190,7 +191,7 @@ landcover.paint['fill-opacity'] = [
 ];
 landcover.metadata = {
   ...(landcover.metadata || {}),
-  'occumed:purpose': 'strong exported vegetation hierarchy over open landcover data'
+  'occumed:purpose': 'continuous worldwide vegetation foundation with regional detail added above it'
 };
 
 runtime.metadata = {

scripts/capture-polygon-regression.mjs

@@ -53,13 +53,28 @@ try {
     { timeout: 90_000 }
   );
 
+  const continuityZooms = [1.65, 2.43, 3.5, 5.5, 6.5];
   const views = [
-    { name: 'north-america-z2', center: [-102, 36], zoom: 2.43 },
-    { name: 'central-pacific-z2', center: [175, 7], zoom: 2.43 },
-    { name: 'australia-z2', center: [135, -25], zoom: 2.43 },
-    { name: 'asia-pacific-z2', center: [118, 22], zoom: 2.43 },
-    { name: 'africa-europe-z2', center: [20, 20], zoom: 2.43 },
-    { name: 'world-north-america-z1', center: [-100, 25], zoom: 1.65 }
+    { name: 'north-america-z2', center: [-102, 36], zoom: 2.43, requiresAtmosphereBloom: true },
+    { name: 'central-pacific-z2', center: [175, 7], zoom: 2.43, requiresAtmosphereBloom: true },
+    { name: 'australia-z2', center: [135, -25], zoom: 2.43, requiresAtmosphereBloom: true },
+    { name: 'asia-pacific-z2', center: [118, 22], zoom: 2.43, requiresAtmosphereBloom: true },
+    { name: 'africa-europe-z2', center: [20, 20], zoom: 2.43, requiresAtmosphereBloom: true },
+    { name: 'world-north-america-z1', center: [-100, 25], zoom: 1.65, requiresAtmosphereBloom: true },
+    ...continuityZooms.map((zoom) => ({
+      name: `amazon-z${String(zoom).replace('.', '-')}`,
+      center: [-60, -8],
+      zoom,
+      requiredSourceLayers: ['land', 'landcover'],
+      requiredRenderedLayers: ['land', 'landcover']
+    })),
+    ...continuityZooms.map((zoom) => ({
+      name: `pacific-depth-z${String(zoom).replace('.', '-')}`,
+      center: [-140, 0],
+      zoom,
+      requiredSourceLayers: ['depth'],
+      requiredRenderedLayers: ['depth']
+    }))
   ];
   const results = {};
 
@@ -87,23 +102,42 @@ try {
       const features = map
         .queryRenderedFeatures()
         .filter((feature) => feature.source === 'occumed-open');
-      const sourceLayerCounts = {};
+      const renderedSourceLayerCounts = {};
       const styleLayerCounts = {};
       for (const feature of features) {
         const sourceLayer = feature.sourceLayer || 'unknown';
         const styleLayer = feature.layer?.id || 'unknown';
-        sourceLayerCounts[sourceLayer] = (sourceLayerCounts[sourceLayer] || 0) + 1;
+        renderedSourceLayerCounts[sourceLayer] = (renderedSourceLayerCounts[sourceLayer] || 0) + 1;
         styleLayerCounts[styleLayer] = (styleLayerCounts[styleLayer] || 0) + 1;
       }
+      const sourceFeatureCounts = Object.fromEntries(
+        ['land', 'landcover', 'depth'].map((sourceLayer) => [
+          sourceLayer,
+          map.querySourceFeatures('occumed-open', { sourceLayer }).length
+        ])
+      );
+      const bloom = document.querySelector('.occumed-atmosphere-bloom');
+      const bloomStyle = bloom ? getComputedStyle(bloom) : null;
+      const bloomRect = bloom?.getBoundingClientRect() || null;
       return {
         center: map.getCenter().toArray(),
         zoom: map.getZoom(),
         source,
         sourceIsPermanent:
           !source?.url && JSON.stringify(source?.tiles || []) === JSON.stringify([expectedTemplate]),
         renderedFeatureCount: features.length,
-        sourceLayerCounts,
-        styleLayerCounts
+        renderedSourceLayerCounts,
+        sourceFeatureCounts,
+        styleLayerCounts,
+        atmosphereBloom: {
+          exists: Boolean(bloom),
+          hidden: Boolean(bloom?.hidden),
+          opacity: Number(bloomStyle?.opacity || 0),
+          filter: bloomStyle?.filter || 'none',
+          mixBlendMode: bloomStyle?.mixBlendMode || 'normal',
+          width: bloomRect?.width || 0,
+          height: bloomRect?.height || 0
+        }
       };
     }, expectedTemplate);
 
@@ -113,6 +147,28 @@ try {
     if (diagnostics.renderedFeatureCount <= 0) {
       throw new Error(`${view.name} rendered no worldwide vector features.`);
     }
+    for (const sourceLayer of view.requiredSourceLayers || []) {
+      if ((diagnostics.sourceFeatureCounts[sourceLayer] || 0) <= 0) {
+        throw new Error(`${view.name} lost the ${sourceLayer} source layer at zoom ${view.zoom}.`);
+      }
+    }
+    for (const sourceLayer of view.requiredRenderedLayers || []) {
+      if ((diagnostics.renderedSourceLayerCounts[sourceLayer] || 0) <= 0) {
+        throw new Error(`${view.name} stopped rendering the ${sourceLayer} foundation at zoom ${view.zoom}.`);
+      }
+    }
+    if (view.requiresAtmosphereBloom) {
+      const bloom = diagnostics.atmosphereBloom;
+      if (!bloom.exists || bloom.hidden || bloom.opacity < 0.95) {
+        throw new Error(`${view.name} does not show the full-strength globe atmosphere bloom.`);
+      }
+      if (bloom.filter === 'none' || bloom.mixBlendMode !== 'screen') {
+        throw new Error(`${view.name} has a hard rim instead of the luminous white-blue bloom.`);
+      }
+      if (bloom.width < 150 || Math.abs(bloom.width - bloom.height) > 1) {
+        throw new Error(`${view.name} atmosphere bloom does not track the rendered globe.`);
+      }
+    }
 
     const screenshot = await page.screenshot({
       path: path.join(outputDir, `${view.name}.png`),
@@ -127,8 +183,9 @@ try {
   const report = {
     generatedAt: new Date().toISOString(),
     origin,
-    mode: 'rebuilt-overview-polygon-regression',
+    mode: 'rebuilt-overview-polygon-layer-continuity-and-atmosphere-regression',
     expectedTemplate,
+    continuityZooms,
     results,
     pageErrors,
     networkFailures,
@@ -145,14 +202,16 @@ try {
   );
 
   if (!report.passed) {
-    throw new Error(`Polygon regression validation failed: ${JSON.stringify({
+    throw new Error(`Polygon, layer continuity, and atmosphere validation failed: ${JSON.stringify({
       pageErrors,
       networkFailures,
       externalVectorRequests: report.externalVectorRequests
     })}`);
   }
 
-  console.log(`Rendered ${views.length} rebuilt-overview globe views without browser or network errors.`);
+  console.log(
+    `Rendered ${views.length} rebuilt-overview views with continuous physical layers and a tracked exterior atmosphere bloom.`
+  );
 } finally {
   await browser.close();
 }

scripts/check-cartography-parity.mjs

@@ -82,6 +82,9 @@ const landcover = layer('landcover');
 if (!Array.isArray(landcover?.paint?.['fill-opacity'])) {
   fail('The landcover layer must preserve the strong green low-zoom hierarchy.');
 }
+if (Number(landcover?.minzoom || 0) !== 0) {
+  fail('The foundational landcover layer must remain visible from globe zoom instead of switching on later.');
+}
 
 const roadLayers = runtime.layers.filter(
   (candidate) =>
@@ -125,5 +128,5 @@ if (failures.length) {
 }
 
 console.log(
-  `Cartography parity validated: ${roadLayers.length} road layers, ${symbolLayers.length} symbol layers, normalized landuse, place hierarchy, and overlay isolation.`
+  `Cartography parity validated: ${roadLayers.length} road layers, ${symbolLayers.length} symbol layers, continuous globe landcover, normalized landuse, place hierarchy, and overlay isolation.`
 );

scripts/check-photo-reference.mjs

@@ -4,7 +4,11 @@ import { fileURLToPath } from 'node:url';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const runtimePath = path.join(root, 'public/style/occumed-open.json');
-const runtime = JSON.parse(await fs.readFile(runtimePath, 'utf8'));
+const [runtime, mapHelper, appCss] = await Promise.all([
+  fs.readFile(runtimePath, 'utf8').then(JSON.parse),
+  fs.readFile(path.join(root, 'src/occumed-map.js'), 'utf8'),
+  fs.readFile(path.join(root, 'src/styles.css'), 'utf8')
+]);
 
 function assert(condition, message) {
   if (!condition) throw new Error(message);
@@ -47,13 +51,19 @@ assert(
 );
 assert(
   runtime.sky?.['fog-color'] === 'rgba(184, 230, 255, 0.14)',
-  'The cool-blue outer atmosphere bloom is missing.'
+  'The cool-blue edge atmosphere is missing.'
 );
 assert(runtime.sky?.['fog-ground-blend'] === 0, 'Ground fog must remain disabled.');
-assert(runtime.sky?.['horizon-fog-blend'] === 0.08, 'The narrow edge bloom strength changed.');
+assert(runtime.sky?.['horizon-fog-blend'] === 0.08, 'The narrow edge atmosphere strength changed.');
 assert(!runtime.light, 'Directional light must not be reintroduced.');
 assert(!runtime.fog, 'Mapbox fog must not be copied into the MapLibre runtime.');
 assert(runtime.metadata?.['occumed:atmosphere-edge-only'] === true, 'The edge-only atmosphere protection marker is missing.');
+assert(mapHelper.includes('installOccumedAtmosphereBloom(map)'), 'The tracked exterior globe bloom is not installed.');
+assert(mapHelper.includes('resolveGlobeRadius'), 'The atmosphere bloom no longer follows the rendered globe radius.');
+assert(mapHelper.includes('BLOOM_FADE_END_ZOOM'), 'The atmosphere bloom does not fade before regional detail.');
+assert(appCss.includes('.occumed-atmosphere-bloom'), 'The exterior atmosphere bloom styling is missing.');
+assert(appCss.includes('drop-shadow(0 0 30px'), 'The atmosphere is only a hard rim and no longer has a visible outer bloom.');
+assert(appCss.includes('mix-blend-mode: screen'), 'The white-blue atmosphere bloom no longer composites luminously.');
 
 assert(layer('land')?.paint?.['background-color'] === '#79BCEC', 'The supplied Studio ocean blue changed.');
 assert(layer('occumed-land-surface')?.paint?.['fill-color'] === '#E0E0D1', 'The supplied Studio land base changed.');
@@ -139,4 +149,4 @@ assert(!/mapbox:\/\//i.test(runtime.sprite || ''), 'Runtime sprite must not use
 assert(!/api\.mapbox\.com/i.test(runtime.glyphs || ''), 'Runtime glyphs must not use Mapbox.');
 assert(runtime.metadata?.['occumed:mapbox-runtime-dependency'] === false, 'No-Mapbox dependency marker is missing.');
 
-console.log(`Reference guard passed: supplied Studio land and water, narrow edge-only atmosphere, high-DPI vector clarity, and ${allColors.size} distinct colors.`);
+console.log(`Reference guard passed: supplied Studio land and water, narrow rim plus tracked outward atmosphere bloom, high-DPI vector clarity, and ${allColors.size} distinct colors.`);

scripts/check-world-tile-gateway.mjs

@@ -134,32 +134,44 @@ const surface = tile({
     ]
   }
 });
-const overscaled = inspectVectorTile(overscaleVectorLayer(surface, {
-  layerName: 'land',
-  sourceZoom: 10,
-  targetZoom: 16,
-  targetX: 32768,
-  targetY: 32768
-}));
-expect(overscaled.land?.featureCount === 1, 'The worldwide land surface cannot overscale through max zoom.');
-for (const bounds of overscaled.land?.bounds || []) {
+const continuousSurfaceLayers = ['land', 'landcover', 'depth'];
+const overscaledSurface = inspectVectorTile(
+  mergeVectorTiles(
+    continuousSurfaceLayers.map((layerName) =>
+      overscaleVectorLayer(surface, {
+        layerName,
+        sourceZoom: 10,
+        targetZoom: 16,
+        targetX: 32768,
+        targetY: 32768
+      })
+    )
+  )
+);
+for (const layerName of continuousSurfaceLayers) {
   expect(
-    bounds && bounds.minX >= 0 && bounds.minY >= 0 && bounds.maxX <= 4096 && bounds.maxY <= 4096,
-    'Overscaled land geometry escaped the requested child tile.'
+    overscaledSurface[layerName]?.featureCount === 1,
+    `The worldwide ${layerName} surface cannot overscale through max zoom.`
   );
+  for (const bounds of overscaledSurface[layerName]?.bounds || []) {
+    expect(
+      bounds && bounds.minX >= 0 && bounds.minY >= 0 && bounds.maxX <= 4096 && bounds.maxY <= 4096,
+      `Overscaled ${layerName} geometry escaped the requested child tile.`
+    );
+  }
 }
-const physicalLandMask = inspectVectorTile(
-  mergeVectorTiles([surface], { includeLayers: ['land'] })
+const physicalSurface = inspectVectorTile(
+  mergeVectorTiles([surface], { includeLayers: continuousSurfaceLayers })
 );
-expect(physicalLandMask.land?.featureCount === 1, 'The physical surface lost its land layer.');
-expect(!physicalLandMask.landcover, 'The physical surface still overlays generalized landcover on regional detail.');
-expect(!physicalLandMask.depth, 'The physical surface still overlays generalized bathymetry on regional detail.');
-const cartographyWithoutLand = inspectVectorTile(
-  mergeVectorTiles([surface], { excludeLayers: ['land'] })
+expect(physicalSurface.land?.featureCount === 1, 'The physical surface lost its land layer.');
+expect(physicalSurface.landcover?.featureCount === 1, 'The physical surface lost continuous landcover.');
+expect(physicalSurface.depth?.featureCount === 1, 'The physical surface lost continuous bathymetry.');
+const cartographyWithoutSurface = inspectVectorTile(
+  mergeVectorTiles([surface], { excludeLayers: continuousSurfaceLayers })
 );
-expect(!cartographyWithoutLand.land, 'The duplicate basemap land layer was not excluded.');
-expect(cartographyWithoutLand.landcover?.featureCount === 1, 'Excluding land removed unrelated cartography.');
-expect(cartographyWithoutLand.depth?.featureCount === 1, 'Excluding land removed bathymetry.');
+expect(!cartographyWithoutSurface.land, 'The duplicate basemap land layer was not excluded.');
+expect(!cartographyWithoutSurface.landcover, 'The duplicate basemap landcover layer was not excluded.');
+expect(!cartographyWithoutSurface.depth, 'The duplicate basemap bathymetry layer was not excluded.');
 
 const normalizedProperties = normalizeMvtProperties({
   safeRank: 4,
@@ -256,16 +268,20 @@ expect(
   'A missing overview enrichment can still reject the complete worldwide tile.'
 );
 expect(
-  gateway.includes("includeLayers: ['land']"),
-  'The gateway does not isolate the continuous physical surface to the land mask.'
+  gateway.includes("const CONTINUOUS_SURFACE_LAYERS = Object.freeze(['land', 'landcover', 'depth'])"),
+  'The gateway does not define one authoritative set of foundational surface layers.'
+);
+expect(
+  gateway.includes('includeLayers: CONTINUOUS_SURFACE_LAYERS'),
+  'The gateway does not retain land, landcover, and bathymetry from the physical surface.'
 );
 expect(
-  gateway.includes("excludeLayers: ['land']"),
-  'The gateway can still merge duplicate land masks from the surface and basemap.'
+  gateway.includes('excludeLayers: CONTINUOUS_SURFACE_LAYERS'),
+  'The overview or regional archives can still replace the foundational surface layers.'
 );
 expect(
-  !gateway.includes("includeLayers: ['land', 'landcover', 'depth']"),
-  'The gateway still overlays generalized landcover and bathymetry on regional detail.'
+  gateway.includes('CONTINUOUS_SURFACE_LAYERS.map'),
+  'All foundational surface layers are not overscaled continuously through maximum zoom.'
 );
 expect(manifestBuilder.includes('version: 2'), 'The server-only routing manifest is not version 2.');
 expect(
@@ -287,4 +303,4 @@ if (failures.length) {
   process.exit(1);
 }
 
-console.log('Virtual worldwide tileset validated: one permanent source, safe polygon merging, clipped surface overscaling, one land mask, antimeridian routing, parent-tile retention, caching, and no browser-visible shards.');
+console.log('Virtual worldwide tileset validated: one permanent source, one continuous land/landcover/depth foundation at every zoom, safe polygon merging, clipped overscaling, antimeridian routing, parent-tile retention, caching, and no browser-visible shards.');