tileserver-gl 5.7.0-pre.0 → 5.7.0

package/public/templates/data.tmpl

@@ -7,11 +7,9 @@
   {{#use_maplibre}}
   <link rel="stylesheet" type="text/css" href="{{public_url}}maplibre-gl.css{{&key_query}}" />
   <link rel="stylesheet" type="text/css" href="{{public_url}}maplibre-gl-inspect.css{{&key_query}}" />
-  <script src="{{public_url}}maplibre-gl.js{{&key_query}}"></script>
-  <script src="{{public_url}}maplibre-gl-inspect.js{{&key_query}}"></script>
-  {{^is_light}}
-  <script src="{{public_url}}elevation-control.js{{&key_query}}"></script>
-  {{/is_light}}
+  <script type="importmap">
+    { "imports": { "maplibre-gl": "{{public_url}}maplibre-gl.mjs{{&key_query}}" } }
+  </script>
   <style>
     body {background:#fff;color:#333;font-family:Arial, sans-serif;}
     {{^is_terrain}}
@@ -58,7 +56,15 @@
   <div id="layerList"></div>
   <pre id="propertyList"></pre>
   {{/is_terrain}}
-  <script>
+  <script type="module">
+    import * as maplibregl from 'maplibre-gl';
+    {{^is_terrain}}
+    import MaplibreInspect from '{{public_url}}maplibre-gl-inspect.mjs{{&key_query}}';
+    {{/is_terrain}}
+    {{^is_light}}
+    import ElevationInfoControl from '{{public_url}}elevation-control.js{{&key_query}}';
+    {{/is_light}}
+
     var keyMatch = location.search.match(/[\?\&]key=([^&]+)/i);
     var keyParam = keyMatch ? '?key=' + keyMatch[1] : '';
 

package/public/templates/viewer.tmpl

@@ -7,8 +7,9 @@
   <link rel="stylesheet" type="text/css" href="{{public_url}}maplibre-gl.css{{&key_query}}" />
   <link rel="stylesheet" type="text/css" href="{{public_url}}maplibre-gl-inspect.css{{&key_query}}" />
   <link rel="stylesheet" type="text/css" href="{{public_url}}leaflet.css{{&key_query}}" />
-  <script src="{{public_url}}maplibre-gl.js{{&key_query}}"></script>
-  <script src="{{public_url}}maplibre-gl-inspect.js{{&key_query}}"></script>
+  <script type="importmap">
+    { "imports": { "maplibre-gl": "{{public_url}}maplibre-gl.mjs{{&key_query}}" } }
+  </script>
   <script src="{{public_url}}leaflet.js{{&key_query}}"></script>
   <script src="{{public_url}}leaflet-hash.js{{&key_query}}"></script>
   <style>
@@ -31,12 +32,15 @@
 <body>
   <h1 style="display:none;">{{name}}</h1>
   <div id='map'></div>
-  <script>
+  <script type="module">
+    import * as maplibregl from 'maplibre-gl';
+    import MaplibreInspect from '{{public_url}}maplibre-gl-inspect.mjs{{&key_query}}';
+
     function isWebglSupported() {
-        if (window.WebGLRenderingContext) {
+        if (window.WebGL2RenderingContext) {
             const canvas = document.createElement('canvas');
             try {
-                const context = canvas.getContext('webgl2') || canvas.getContext('webgl');
+                const context = canvas.getContext('webgl2');
                 if (context && typeof context.getParameter == 'function') {
                     return true;
                 }
@@ -45,7 +49,7 @@
             }
             return false;
         }
-        // WebGL not supported
+        // WebGL2 not supported (required by maplibre-gl v6+)
         return false;
     }
     var q = (location.search || '').substr(1).split('&');
@@ -107,7 +111,7 @@
         req.open('GET', url, true);
         req.onload = function() {
             var jsonResponse = JSON.parse(req.responseText);
-            for (key in jsonResponse) {
+            for (var key in jsonResponse) {
               var keyl = key.toLowerCase();
                 switch(keyl) {
                   case "tiles":
@@ -125,7 +129,7 @@
                 }
             }
 
-            for (tile_url in tile_urls) {
+            for (var tile_url in tile_urls) {
                 var leafletUrl = tile_urls[tile_url];
                 {{#leaflet_retina}}
                 // Inject {r} for Leaflet retina support without modifying TileJSON directly.

package/src/main.js

@@ -2,6 +2,7 @@
 
 'use strict';
 import os from 'os';
+import { inspect } from 'node:util';
 
 const envSize = parseInt(process.env.UV_THREADPOOL_SIZE, 10);
 process.env.UV_THREADPOOL_SIZE = Math.ceil(
@@ -25,18 +26,63 @@ import { openMbTilesWrapper } from './mbtiles_wrapper.js';
 // Global Error Handlers - Prevent server crashes from unhandled errors
 // ============================================================================
 
+// Keeping the process alive hides the failure unless the log says what broke,
+// so report the stack, any cause chain, and how often this has happened. A
+// repeating count is the signal that something is looping, not misfiring once.
+const survivedErrorCounts = new Map();
+const SURVIVED_ERROR_KEYS_MAX = 500;
+
+/**
+ * Renders a thrown value as text, following up to `depth` levels of `cause`.
+ * @param {unknown} err - The thrown value or rejection reason.
+ * @param {number} [depth] - Remaining cause levels to follow.
+ * @returns {string} A printable description of the error.
+ */
+function describeError(err, depth = 3) {
+  if (!(err instanceof Error)) {
+    return `Non-Error value: ${inspect(err, { depth: 3 })}`;
+  }
+  let text = err.stack || `${err.name}: ${err.message}`;
+  if (err.cause !== undefined && depth > 0) {
+    text += `\nCaused by: ${describeError(err.cause, depth - 1)}`;
+  }
+  return text;
+}
+
+/**
+ * Reports an error the process deliberately survived.
+ * @param {string} kind - The handler that fired.
+ * @param {unknown} err - The thrown value or rejection reason.
+ * @returns {void}
+ */
+function reportSurvivedError(kind, err) {
+  const detail = describeError(err);
+  const key = `${kind} :: ${err instanceof Error ? err.message : detail}`;
+
+  let occurrence = '';
+  if (survivedErrorCounts.has(key)) {
+    const count = survivedErrorCounts.get(key) + 1;
+    survivedErrorCounts.set(key, count);
+    occurrence = ` (occurrence ${count})`;
+  } else if (survivedErrorCounts.size < SURVIVED_ERROR_KEYS_MAX) {
+    // Bounded: distinct messages can carry tile coordinates or URLs, and an
+    // unbounded tally of them would be a leak of its own.
+    survivedErrorCounts.set(key, 1);
+    occurrence = ' (occurrence 1)';
+  }
+
+  console.error(`[${kind}] server continuing after error${occurrence}:`);
+  console.error(detail);
+}
+
 // Prevent unhandled promise rejections from crashing the server
-process.on('unhandledRejection', (reason, promise) => {
-  console.error('Unhandled Promise Rejection at:', promise);
-  console.error('Reason:', reason);
-  // Don't exit - keep server running
+process.on('unhandledRejection', (reason) => {
+  reportSurvivedError('unhandledRejection', reason);
 });
 
 // Prevent uncaught exceptions from crashing the server
 process.on('uncaughtException', (error) => {
-  console.error('Uncaught Exception:', error);
-  console.error('Stack:', error.stack);
-  // Don't exit - keep server running
+  reportSurvivedError('uncaughtException', error);
 });
 
 // ============================================================================

package/src/render_mode.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Converts a TileServer zoom level to the zoom expected by MapLibre Native.
+ * @param {number} zoom TileServer zoom level.
+ * @param {number} logicalWidth Unscaled request width in pixels.
+ * @param {'tile'|'static'} mode Rendering mode.
+ * @returns {number} MapLibre Native zoom level.
+ */
+export function getMapLibreRenderZoom(zoom, logicalWidth, mode) {
+  if (mode === 'static') {
+    return Math.max(0, zoom - 1);
+  }
+
+  if (mode === 'tile') {
+    return Math.max(0, logicalWidth === 512 ? zoom : zoom - 1);
+  }
+
+  throw new Error(`Unsupported render mode: ${mode}`);
+}
+
+/**
+ * Calculates the TileServer zoom MapLibre Native effectively uses for a
+ * static-map overlay. Horizontal world copies can wrap, but the world must
+ * fill the viewport vertically. The 256px zoom-zero render has a dedicated
+ * resize path in serve_rendered.
+ * @param {number} zoom Requested TileServer zoom level.
+ * @param {number} logicalWidth Unscaled request width in pixels.
+ * @param {number} logicalHeight Unscaled request height in pixels.
+ * @returns {number} Effective TileServer zoom level.
+ */
+export function getStaticOverlayZoom(zoom, logicalWidth, logicalHeight) {
+  const minimumViewportZoom = Math.log2(logicalHeight / 256);
+  if (zoom === 0 && logicalWidth === 256) {
+    return Math.max(0, minimumViewportZoom);
+  }
+  return Math.max(1, zoom, minimumViewportZoom);
+}

package/src/serve_data.js

@@ -15,6 +15,8 @@ import {
   isValidRemoteUrl,
   fetchTileData,
   lonLatToTilePixel,
+  parseOptionalBoolean,
+  resolveSparse,
 } from './utils.js';
 import { getPMtilesInfo, openPMtiles } from './pmtiles_adapter.js';
 import { gunzipP, gzipP } from './promises.js';
@@ -131,15 +133,19 @@ export const serve_data = {
 
       let data = fetchTile.data;
       let headers = fetchTile.headers;
-      let isGzipped = data.slice(0, 2).indexOf(Buffer.from([0x1f, 0x8b])) === 0;
 
-      if (isGzipped) {
+      const isGzipped =
+        data.slice(0, 2).indexOf(Buffer.from([0x1f, 0x8b])) === 0;
+      const serveGzipped =
+        isGzipped && format === 'pbf' && !options.dataDecoratorFunc;
+
+      if (isGzipped && !serveGzipped) {
         data = await gunzipP(data);
       }
 
       if (tileJSONFormat === 'pbf') {
         if (options.dataDecoratorFunc) {
-          data = options.dataDecoratorFunc(
+          data = await options.dataDecoratorFunc(
             req.params.id,
             'data',
             data,
@@ -177,7 +183,9 @@ export const serve_data = {
       headers['Content-Encoding'] = 'gzip';
       res.set(headers);
 
-      data = await gzipP(data);
+      if (!serveGzipped) {
+        data = await gzipP(data);
+      }
 
       if (metricsModule) {
         metricsModule.tilesServedTotal.inc({
@@ -619,19 +627,29 @@ export const serve_data = {
     delete tileJSON['scheme'];
     tileJSON['tilejson'] = '3.0.0';
 
+    // MBTiles metadata is a table of strings, so a `sparse` row arrives as
+    // "false" - truthy at face value. Take it as a boolean here and drop the
+    // raw key, so nothing downstream (the data decorator, the served TileJSON)
+    // ever sees the unparsed form. The resolved value is put back below.
+    const metadataSparse = parseOptionalBoolean(tileJSON.sparse);
+    delete tileJSON['sparse'];
+
     Object.assign(tileJSON, params.tilejson || {});
     fixTileJSONCenter(tileJSON);
 
     if (options.dataDecoratorFunc) {
-      tileJSON = options.dataDecoratorFunc(id, 'tilejson', tileJSON);
+      tileJSON = await options.dataDecoratorFunc(id, 'tilejson', tileJSON);
     }
 
-    // Determine sparse: per-source overrides global, then format-based default
-    // sparse=true -> 404 (allows overzoom)
-    // sparse=false -> 204 (empty tile, no overzoom)
-    // Default: vector tiles (pbf) -> false, raster tiles -> true
-    const isVector = tileJSON.format === 'pbf';
-    const sparse = params.sparse ?? options.sparse ?? !isVector;
+    // sparse=true -> 404 (allows overzoom), sparse=false -> 204 (empty tile)
+    const sparse = resolveSparse({
+      perSource: params.sparse,
+      globalOption: options.sparse,
+      metadata: metadataSparse,
+      isVector: tileJSON.format === 'pbf',
+    });
+    // Advertise what the server will actually do, not what the archive claimed.
+    tileJSON.sparse = sparse;
 
     // eslint-disable-next-line security/detect-object-injection -- id is from config file data source names
     repo[id] = {