@signalk/charts-plugin 3.3.0 → 3.5.0

package/plugin/index.js

@@ -15,18 +15,26 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const bluebird = __importStar(require("bluebird"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const _ = __importStar(require("lodash"));
@@ -36,9 +44,19 @@ const chartDownloader_1 = require("./chartDownloader");
 const MIN_ZOOM = 1;
 const MAX_ZOOM = 24;
 const chartTilesPath = '/signalk/chart-tiles';
-module.exports = (app) => {
+// Debounce window used to collapse FSWatcher bursts during rename / atomic-save
+// sequences into one reload. Overridable via env var so tests don't have to
+// wait the full 5s on every watcher assertion.
+const RELOAD_DEBOUNCE_MS = Number(process.env.SK_CHARTS_RELOAD_DEBOUNCE_MS) || 5000;
+const createPlugin = (app) => {
     let chartProviders = {};
+    // Pre-computed per-version views of chartProviders, rebuilt on every reload.
+    // The HTTP handlers serve directly from here so tile-list requests don't pay
+    // a deep clone per provider on the hot path.
+    let sanitizedV1 = {};
+    let sanitizedV2 = {};
     let pluginStarted = false;
+    let providerRegistered = false;
     let props = {
         chartPaths: [],
         cachePath: '',
@@ -48,15 +66,32 @@ module.exports = (app) => {
     const configBasePath = app.config.configPath;
     const defaultChartsPath = path_1.default.join(configBasePath, '/charts');
     const serverMajorVersion = app.config.version
-        ? parseInt(app.config.version.split('.')[0])
-        : '1';
-    ensureDirectoryExists(defaultChartsPath);
+        ? parseInt(app.config.version.split('.')[0] ?? '0')
+        : 1;
     let cachePath = defaultChartsPath;
+    // Chart-folder watcher state, plugin-scoped so stop()/start() cycles reset cleanly.
+    // activeChartPaths / activeOnlineProviders hold the last-known config so a
+    // watcher-triggered reload can reuse it without re-running doStartup.
+    const watchers = [];
+    let reloadTimer;
+    let activeChartPaths = [];
+    let activeOnlineProviders = {};
+    // Check Node version for schema
+    const nodeVersion = process.versions.node;
+    const nodeMajorVersion = parseInt(nodeVersion.split('.')[0] ?? '0');
     // ******** REQUIRED PLUGIN DEFINITION *******
     const CONFIG_SCHEMA = {
         title: 'Signal K Charts',
         type: 'object',
         properties: {
+            ...(nodeMajorVersion < 22 && {
+                versionWarning: {
+                    type: 'string',
+                    title: 'REQUIRES NODE VERSION >=22',
+                    description: 'Starting with version 4 this plugin will not work with Node versions older than 22. You can install an older plugin version from the App store.',
+                    default: ''
+                }
+            }),
             chartPaths: {
                 type: 'array',
                 title: 'Chart paths',
@@ -175,52 +210,220 @@ module.exports = (app) => {
             return doStartup(settings); // return required for tests
         },
         stop: () => {
+            stopWatchers();
+            // Cancel any running seeding jobs so a disabled plugin doesn't keep
+            // pulling tiles from remote providers in the background.
+            chartDownloader_1.ChartSeedingManager.cancelAll();
+            // Close open SQLite connections so the user can move or delete chart
+            // files while the plugin is stopped (Windows blocks deletion on open
+            // handles). Restart re-opens fresh via findCharts.
+            for (const p of Object.values(chartProviders)) {
+                if (p?._mbtilesHandle)
+                    closeMbtilesHandle(p._mbtilesHandle);
+            }
+            chartProviders = {};
+            sanitizedV1 = {};
+            sanitizedV2 = {};
             app.setPluginStatus('stopped');
         }
     };
-    const doStartup = (config) => {
+    const doStartup = async (config) => {
+        // Check Node version
+        const nodeVersion = process.versions.node;
+        const majorVersion = parseInt(nodeVersion.split('.')[0] ?? '0');
+        if (majorVersion < 22) {
+            const errorMsg = `Node version ${nodeVersion} is not supported. This plugin requires Node version 22 or higher. Please upgrade Node or install an older plugin version.`;
+            app.setPluginError(errorMsg);
+            app.debug(errorMsg);
+            return Promise.reject(new Error(errorMsg));
+        }
         app.debug(`** loaded config: ${config}`);
         props = { ...config };
         urlBase = `${app.config.ssl ? 'https' : 'http'}://localhost:${'getExternalPort' in app.config ? app.config.getExternalPort() : 3000}`;
         app.debug(`**urlBase** ${urlBase}`);
-        const chartPaths = _.isEmpty(props.chartPaths)
+        activeChartPaths = !props.chartPaths?.length
             ? [defaultChartsPath]
             : resolveUniqueChartPaths(props.chartPaths, configBasePath);
         cachePath = props.cachePath || defaultChartsPath;
-        ensureDirectoryExists(cachePath);
-        const onlineProviders = _.reduce(props.onlineChartProviders, (result, data) => {
+        // Both paths commonly coincide on a fresh install; ensure they exist once
+        // here rather than at plugin construction time, which kept us off the
+        // sync-fs path at module load.
+        await ensureDirectoryExists(defaultChartsPath);
+        if (cachePath !== defaultChartsPath) {
+            await ensureDirectoryExists(cachePath);
+        }
+        activeOnlineProviders = {};
+        for (const data of props.onlineChartProviders ?? []) {
             const provider = convertOnlineProviderConfig(data);
-            result[provider.identifier] = provider;
-            return result;
-        }, {});
-        app.debug(`Start charts plugin. Chart paths: ${chartPaths.join(', ')}, online charts: ${Object.keys(onlineProviders).length}`);
-        // Do not register routes if plugin has been started once already
-        pluginStarted === false && registerRoutes();
+            if (activeOnlineProviders[provider.identifier]) {
+                app.debug(`Duplicate online provider identifier "${provider.identifier}" ` +
+                    `(from name "${data.name}"); the later entry wins. ` +
+                    `Rename one of the providers to avoid the collision.`);
+            }
+            activeOnlineProviders[provider.identifier] = provider;
+        }
+        app.debug(`Start charts plugin. Chart paths: ${activeChartPaths.join(', ')}, online charts: ${Object.keys(activeOnlineProviders).length}`);
+        // Routes and the v2 provider registration are idempotent — Signal K can
+        // call start() again after a config change, but re-registering would
+        // either throw or duplicate the handler.
+        if (!pluginStarted)
+            registerRoutes();
         pluginStarted = true;
-        // v2 routes - register as Resource Provider, this needs to be always on startup
-        if (serverMajorVersion === 2) {
+        if (serverMajorVersion === 2 && !providerRegistered) {
             app.debug('** Registering v2 API paths **');
             registerAsProvider();
+            providerRegistered = true;
         }
         app.setPluginStatus('Started');
-        const loadProviders = bluebird
-            .mapSeries(chartPaths, (chartPath) => (0, charts_1.findCharts)(chartPath))
-            .then((list) => _.reduce(list, (result, charts) => _.merge({}, result, charts), {}));
-        return loadProviders
-            .then((charts) => {
-            app.debug(`Chart plugin: Found ${_.keys(charts).length} charts from ${chartPaths.join(', ')}.`);
-            chartProviders = _.merge({}, charts, onlineProviders);
-        })
-            .catch((e) => {
+        startWatchers();
+        return loadChartProviders();
+    };
+    const loadChartProviders = async () => {
+        // Scan configured chart paths in parallel. findCharts already bounds its
+        // own per-file concurrency internally, so kicking off multiple roots at
+        // once just overlaps their directory reads.
+        let results;
+        try {
+            results = await Promise.all(activeChartPaths.map((chartPath) => (0, charts_1.findCharts)(chartPath)));
+        }
+        catch (e) {
+            // Keep the last-good chartProviders instead of wiping everything - a
+            // transient read error (file locked during copy, EBUSY, etc.) shouldn't
+            // blank the service out until the next filesystem event.
             console.error(`Error loading chart providers`, e.message);
-            chartProviders = {};
             app.setPluginError(`Error loading chart providers`);
-        });
+            return;
+        }
+        // Identifier is the source of uniqueness: a deep-merge here would cost
+        // O(N²) property copies for identical keys while adding nothing over a
+        // plain shallow assignment.
+        const newCharts = {};
+        for (const r of results) {
+            if (!r)
+                continue;
+            for (const [id, chart] of Object.entries(r)) {
+                if (newCharts[id]) {
+                    app.debug(`Duplicate chart identifier "${id}" from multiple chart paths; ` +
+                        `the later one wins.`);
+                }
+                newCharts[id] = chart;
+            }
+        }
+        app.debug(`Chart plugin: Found ${Object.keys(newCharts).length} charts from ${activeChartPaths.join(', ')}.`);
+        reconcileMbtilesHandles(chartProviders);
+        // Shallow assign is enough: newCharts and activeOnlineProviders both
+        // have unique ids per entry; the values themselves are used by reference.
+        chartProviders = { ...newCharts };
+        for (const [id, provider] of Object.entries(activeOnlineProviders)) {
+            if (chartProviders[id]) {
+                app.debug(`Online provider identifier "${id}" collides with a local chart; ` +
+                    `the online provider wins.`);
+            }
+            chartProviders[id] = provider;
+        }
+        buildSanitizedCache();
+        app.setPluginStatus(`Started - ${Object.keys(chartProviders).length} chart(s) loaded`);
+    };
+    // Rebuilds the per-version sanitized views. Called once per reload so the
+    // HTTP handlers can hand out pre-built dictionaries instead of deep-cloning
+    // every provider on every metadata request.
+    const buildSanitizedCache = () => {
+        sanitizedV1 = {};
+        sanitizedV2 = {};
+        for (const [id, provider] of Object.entries(chartProviders)) {
+            sanitizedV1[id] = sanitizeProvider(provider, 1);
+            sanitizedV2[id] = sanitizeProvider(provider, 2);
+        }
+    };
+    // Close every old MBTiles handle after a reload. findCharts opened fresh
+    // handles for every file that still exists, so the NEW set reflects current
+    // content — including files that were replaced in place (same filename,
+    // new content). Reusing the old handle in that case would serve stale tiles
+    // from SQLite's cached pages. Close is delayed so an in-flight tile request
+    // that captured a reference has time to complete before the handle goes
+    // away; 1s is well above realistic tile-serve latency.
+    const MBTILES_CLOSE_DELAY_MS = 1000;
+    const reconcileMbtilesHandles = (oldSet) => {
+        for (const old of Object.values(oldSet)) {
+            if (old?._mbtilesHandle) {
+                const handle = old._mbtilesHandle;
+                setTimeout(() => closeMbtilesHandle(handle), MBTILES_CLOSE_DELAY_MS);
+            }
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const closeMbtilesHandle = (handle) => {
+        if (typeof handle?.close !== 'function')
+            return;
+        try {
+            handle.close((err) => {
+                if (err)
+                    app.debug(`MBTiles close error: ${err.message}`);
+            });
+        }
+        catch (err) {
+            app.debug(`MBTiles close threw: ${err.message}`);
+        }
+    };
+    // Chart folders are watched so new/renamed/deleted files become visible
+    // without a plugin restart. FSWatcher bursts events during rename and
+    // atomic-save sequences; the debounce collapses a burst into one reload.
+    const scheduleReload = () => {
+        if (reloadTimer)
+            clearTimeout(reloadTimer);
+        reloadTimer = setTimeout(() => {
+            reloadTimer = undefined;
+            app.debug('Reloading charts after filesystem change');
+            loadChartProviders();
+        }, RELOAD_DEBOUNCE_MS);
+    };
+    const startWatchers = () => {
+        stopWatchers();
+        for (const p of activeChartPaths) {
+            watchers.push(...createWatchers(p));
+        }
+    };
+    // recursive:true is the common path on macOS / Windows / Linux (Node 22+).
+    // If the platform or filesystem doesn't support it (some network mounts,
+    // older Linux), fall back to a non-recursive watch so at least top-level
+    // changes are picked up.
+    const createWatchers = (p) => {
+        const handlers = [];
+        try {
+            const watcher = fs_1.default.watch(p, { encoding: 'utf8', recursive: true }, () => scheduleReload());
+            watcher.on('error', (err) => app.debug(`Watcher error on ${p}: ${err.message}`));
+            handlers.push(watcher);
+            app.debug(`Watching chart folder recursively: ${p}`);
+        }
+        catch (err) {
+            app.debug(`Recursive watch unavailable for ${p} (${err.message}); falling back to top-level watch`);
+            try {
+                const watcher = fs_1.default.watch(p, { encoding: 'utf8' }, () => scheduleReload());
+                watcher.on('error', (e) => app.debug(`Watcher error on ${p}: ${e.message}`));
+                handlers.push(watcher);
+            }
+            catch (e) {
+                app.debug(`Unable to watch ${p}: ${e.message}`);
+            }
+        }
+        return handlers;
+    };
+    const stopWatchers = () => {
+        if (reloadTimer) {
+            clearTimeout(reloadTimer);
+            reloadTimer = undefined;
+        }
+        while (watchers.length) {
+            watchers.pop()?.close();
+        }
     };
     const registerRoutes = () => {
         app.debug('** Registering API paths **');
         app.get(`${chartTilesPath}/:identifier/:z([0-9]*)/:x([0-9]*)/:y([0-9]*)`, async (req, res) => {
             const { identifier, z, x, y } = req.params;
+            if (!identifier || !z || !x || !y) {
+                return res.sendStatus(404);
+            }
             const ix = parseInt(x);
             const iy = parseInt(y);
             const iz = parseInt(z);
@@ -245,21 +448,39 @@ module.exports = (app) => {
         });
         app.post(`${chartTilesPath}/cache/:identifier`, async (req, res) => {
             const { identifier } = req.params;
+            if (!identifier) {
+                return res.sendStatus(404);
+            }
             const { regionGUID, tile, bbox, maxZoom } = req.body;
             const provider = chartProviders[identifier];
             if (!provider) {
-                return res.sendStatus(500).send('Provider not found');
+                return res.status(404).send('Provider not found');
             }
             if (!maxZoom) {
                 return res.status(400).send('maxZoom parameter is required');
             }
+            if (!regionGUID && !bbox && !tile) {
+                return res
+                    .status(400)
+                    .send('Request must include regionGUID, bbox, or tile');
+            }
             const maxZoomParsed = parseInt(maxZoom);
-            await chartDownloader_1.ChartSeedingManager.createJob(app.resourcesApi, cachePath, provider, maxZoomParsed, regionGUID, bbox
-                ? [bbox.minLon, bbox.minLat, bbox.maxLon, bbox.maxLat]
-                : undefined, tile);
-            return res.status(200);
+            try {
+                const job = await chartDownloader_1.ChartSeedingManager.createJob(app.resourcesApi, cachePath, provider, maxZoomParsed, regionGUID, bbox
+                    ? [bbox.minLon, bbox.minLat, bbox.maxLon, bbox.maxLat]
+                    : undefined, tile);
+                // Job is registered and its tile set is known, but nothing has been
+                // downloaded yet — the caller starts it with
+                // POST /cache/jobs/:id { action: 'start' }.
+                return res.status(202).json(job.info());
+            }
+            catch (err) {
+                return res
+                    .status(500)
+                    .send(`Failed to create seeding job: ${err.message}`);
+            }
         });
-        app.get(`${chartTilesPath}/cache/jobs`, (req, res) => {
+        app.get(`${chartTilesPath}/cache/jobs`, (_req, res) => {
             const jobs = Object.values(chartDownloader_1.ChartSeedingManager.ActiveJobs).map((job) => {
                 return job.info();
             });
@@ -267,42 +488,57 @@ module.exports = (app) => {
         });
         app.post(`${chartTilesPath}/cache/jobs/:id`, (req, res) => {
             const { id } = req.params;
+            if (!id) {
+                return res.sendStatus(404);
+            }
             const { action } = req.body;
+            if (!id) {
+                return res.status(400).send('Missing job id');
+            }
             const parsedId = parseInt(id);
+            if (!Number.isFinite(parsedId)) {
+                return res.status(400).send(`Invalid job id: ${id}`);
+            }
             const job = chartDownloader_1.ChartSeedingManager.ActiveJobs[parsedId];
-            if (job && action) {
-                if (action === 'start') {
-                    job.seedCache();
-                }
-                else if (action === 'stop') {
-                    job.cancelJob();
-                }
-                else if (action === 'delete') {
-                    job.deleteCache();
-                }
-                else if (action === 'remove') {
-                    delete chartDownloader_1.ChartSeedingManager.ActiveJobs[parsedId];
-                }
-                else {
-                    return res.status(404).send(`Job ${parsedId} not found`);
-                }
-                return res.status(200).send(`Job ${parsedId} ${action}ed`);
+            if (!job) {
+                return res.status(404).send(`Job ${parsedId} not found`);
+            }
+            if (!action) {
+                return res.status(400).send('action parameter is required');
+            }
+            if (action === 'start') {
+                job.seedCache();
+            }
+            else if (action === 'stop') {
+                job.cancelJob();
+            }
+            else if (action === 'delete') {
+                job.deleteCache();
             }
+            else if (action === 'remove') {
+                delete chartDownloader_1.ChartSeedingManager.ActiveJobs[parsedId];
+            }
+            else {
+                return res.status(400).send(`Unknown action: ${action}`);
+            }
+            return res.status(200).send(`Job ${parsedId} ${action}ed`);
         });
         app.debug('** Registering v1 API paths **');
         app.get(constants_1.apiRoutePrefix[1] + '/charts/:identifier', (req, res) => {
             const { identifier } = req.params;
-            const provider = chartProviders[identifier];
-            if (provider) {
-                return res.json(sanitizeProvider(provider));
+            if (!identifier) {
+                return res.sendStatus(404);
+            }
+            const view = sanitizedV1[identifier];
+            if (view) {
+                return res.json(view);
             }
             else {
                 return res.status(404).send('Not found');
             }
         });
-        app.get(constants_1.apiRoutePrefix[1] + '/charts', (req, res) => {
-            const sanitized = _.mapValues(chartProviders, (provider) => sanitizeProvider(provider));
-            res.json(sanitized);
+        app.get(constants_1.apiRoutePrefix[1] + '/charts', (_req, res) => {
+            res.json(sanitizedV1);
         });
     };
     // Resources API provider registration
@@ -314,13 +550,13 @@ module.exports = (app) => {
                 methods: {
                     listResources: (params) => {
                         app.debug(`** listResources() ${params}`);
-                        return Promise.resolve(_.mapValues(chartProviders, (provider) => sanitizeProvider(provider, 2)));
+                        return Promise.resolve(sanitizedV2);
                     },
                     getResource: (id) => {
                         app.debug(`** getResource() ${id}`);
-                        const provider = chartProviders[id];
-                        if (provider) {
-                            return Promise.resolve(sanitizeProvider(provider, 2));
+                        const view = sanitizedV2[id];
+                        if (view) {
+                            return Promise.resolve(view);
                         }
                         else {
                             throw new Error('Chart not found!');
@@ -337,7 +573,7 @@ module.exports = (app) => {
             });
         }
         catch (error) {
-            app.debug('Failed Provider Registration!');
+            app.setPluginError(`Failed to register as charts resource provider: ${error.message}`);
         }
     };
     const serveTileFromCacheOrRemote = async (res, provider, z, x, y) => {
@@ -356,9 +592,16 @@ const responseHttpOptions = {
         'Cache-Control': 'public, max-age=7776000' // 90 days
     }
 };
+// Allowed tile file formats. Add new formats here when supporting them.
+const ALLOWED_TILE_FORMATS = new Set(['png', 'jpg', 'jpeg', 'pbf']);
+const isAllowedTileFormat = (format) => {
+    if (!format)
+        return false;
+    return ALLOWED_TILE_FORMATS.has(format.toLowerCase());
+};
 const resolveUniqueChartPaths = (chartPaths, configBasePath) => {
-    const paths = _.map(chartPaths, (chartPath) => path_1.default.resolve(configBasePath, chartPath));
-    return _.uniq(paths);
+    const paths = chartPaths.map((chartPath) => path_1.default.resolve(configBasePath, chartPath));
+    return [...new Set(paths)];
 };
 const convertOnlineProviderConfig = (provider) => {
     const id = _.kebabCase(_.deburr(provider.name));
@@ -405,48 +648,76 @@ const convertOnlineProviderConfig = (provider) => {
     };
     return data;
 };
+// Builds the outward-facing view of a provider for either the v1 or v2 API.
+// Copies non-private top-level fields, then overlays the version-specific
+// block (v1 has tilemapUrl/chartLayers, v2 has url/layers), rewriting the
+// tile-path placeholder. Intentionally a single shallow walk — the previous
+// implementation did three deep clones per call and ran per metadata request.
 const sanitizeProvider = (provider, version = 1) => {
-    let v;
-    if (version === 1) {
-        v = _.merge({}, provider.v1);
-        v.tilemapUrl = v.tilemapUrl.replace('~tilePath~', chartTilesPath);
+    const out = {};
+    for (const [key, value] of Object.entries(provider)) {
+        if (key.startsWith('_') || key === 'v1' || key === 'v2')
+            continue;
+        out[key] = value;
+    }
+    const v = version === 1 ? provider.v1 : provider.v2;
+    if (v) {
+        for (const [key, value] of Object.entries(v)) {
+            out[key] = value;
+        }
+    }
+    if (version === 1 && typeof out.tilemapUrl === 'string') {
+        out.tilemapUrl = out.tilemapUrl.replace('~tilePath~', chartTilesPath);
+    }
+    else if (version === 2 && typeof out.url === 'string') {
+        out.url = out.url.replace('~tilePath~', chartTilesPath);
     }
     else if (version === 2) {
-        v = _.merge({}, provider.v2);
-        v.url = v.url ? v.url.replace('~tilePath~', chartTilesPath) : '';
+        out.url = '';
     }
-    provider = _.omit(provider, [
-        '_filePath',
-        '_fileFormat',
-        '_mbtilesHandle',
-        '_flipY',
-        'v1',
-        'v2'
-    ]);
-    return _.merge(provider, v);
+    return out;
 };
-const ensureDirectoryExists = (path) => {
-    if (!fs_1.default.existsSync(path)) {
-        fs_1.default.mkdirSync(path);
-    }
+const ensureDirectoryExists = async (p) => {
+    // mkdir with recursive:true is idempotent and skips the existsSync probe,
+    // keeping startup off the sync-fs path.
+    await fs_1.default.promises.mkdir(p, { recursive: true });
 };
-const serveTileFromFilesystem = (res, provider, z, x, y) => {
+const serveTileFromFilesystem = async (res, provider, z, x, y) => {
     const { format, _flipY, _filePath } = provider;
+    const normalizedFormat = format?.toLowerCase() ?? '';
+    if (!_filePath || !ALLOWED_TILE_FORMATS.has(normalizedFormat)) {
+        res.sendStatus(404);
+        return;
+    }
     const flippedY = Math.pow(2, z) - 1 - y;
-    const file = _filePath
-        ? path_1.default.resolve(_filePath, `${z}/${x}/${_flipY ? flippedY : y}.${format}`)
-        : '';
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    res.sendFile(file, responseHttpOptions, (err) => {
-        if (err && err.code === 'ENOENT') {
+    const file = path_1.default.resolve(_filePath, `${z}/${x}/${_flipY ? flippedY : y}.${normalizedFormat}`);
+    try {
+        const stats = await fs_1.default.promises.stat(file);
+        if (!stats.isFile()) {
             res.sendStatus(404);
+            return;
         }
-        else if (err) {
-            throw err;
-        }
-    });
+        await fs_1.default.promises.access(file, fs_1.default.constants.R_OK);
+    }
+    catch {
+        res.sendStatus(404);
+        return;
+    }
+    res.sendFile(file, responseHttpOptions);
 };
 const serveTileFromMbtiles = (res, provider, z, x, y) => {
+    if (!isAllowedTileFormat(provider.format)) {
+        res.sendStatus(404);
+        return;
+    }
+    // Guard against a provider whose MBTiles handle is missing: openMbtilesFile
+    // may have failed post-reconcile, or the handle was closed while a request
+    // was in flight. Without this check, `.getTile` throws synchronously and
+    // Express never answers the client.
+    if (!provider._mbtilesHandle) {
+        res.sendStatus(500);
+        return;
+    }
     provider._mbtilesHandle.getTile(z, x, y, (err, tile, headers) => {
         if (err && err.message && err.message === 'Tile does not exist') {
             res.sendStatus(404);
@@ -462,3 +733,5 @@ const serveTileFromMbtiles = (res, provider, z, x, y) => {
         }
     });
 };
+module.exports = createPlugin;
+//# sourceMappingURL=index.js.map