@mxtommy/kip 4.5.1 → 4.6.0-beta.2

package/plugin/index.js

@@ -34,12 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const server_api_1 = require("@signalk/server-api");
-const module_1 = require("module");
 const openapi = __importStar(require("./openApi.json"));
 const history_series_service_1 = require("./history-series.service");
-const duckdb_parquet_storage_service_1 = require("./duckdb-parquet-storage.service");
+const sqlite_history_storage_service_1 = require("./sqlite-history-storage.service");
 const start = (server) => {
-    const packageRequire = (0, module_1.createRequire)(__filename);
     const mutableOpenApi = JSON.parse(JSON.stringify(openapi.default ?? openapi));
     const API_PATHS = {
         DISPLAYS: `/displays`,
@@ -61,6 +59,12 @@ const start = (server) => {
         title: 'Remote Control and Data Series',
         description: 'NOTE: All plugin settings are also managed from within KIP\'s Display Options panel. Changes made here will be overridden when KIP applies settings from the Display Options.',
         properties: {
+            nodeSqliteAvailable: {
+                type: 'boolean',
+                title: 'node:sqlite Available',
+                description: 'Indicates if node:sqlite is available in the current runtime (requires Node.js version 22.5.0 or newer). This is set automatically and is read-only.\n\nBefore upgrading Node.js, always verify compatibility with your Signal K server version at https://demo.signalk.org/documentation.',
+                readOnly: true
+            },
             historySeriesServiceEnabled: {
                 type: 'boolean',
                 title: 'Enable Automatic Historical Time-Series Capture and Management',
@@ -70,38 +74,59 @@ const start = (server) => {
             registerAsHistoryApiProvider: {
                 type: 'boolean',
                 title: 'Enable Query Provider',
-                description: 'The built-in History-API provider is the querying engine that uses the Historical Time-Series data to seed the widget historical panel, the Data Chart and Wind Trends widgets. If you want to use another History-API provider, turn this off and configure your chosen History-API compatible provider accordingly and KIP will query that provider.',
+                description: 'The built-in History-API query provider is a feature that enables the plugin to respond to History-API requests. If you want to use another History-API provider, disable this option and configure your chosen History-API compatible provider accordingly and KIP will query that provider.',
                 default: true
             }
         }
     };
-    const historySeries = new history_series_service_1.HistorySeriesService(() => Date.now(), false);
-    const storageService = new duckdb_parquet_storage_service_1.DuckDbParquetStorageService();
+    const historySeries = new history_series_service_1.HistorySeriesService(() => Date.now());
+    const storageService = new sqlite_history_storage_service_1.SqliteHistoryStorageService();
     let retentionSweepTimer = null;
     let storageFlushTimer = null;
-    let duckDbInitializationPromise = null;
-    const DUCKDB_INIT_WAIT_TIMEOUT_MS = 5000;
+    let sqliteInitializationPromise = null;
+    const SQLITE_INIT_WAIT_TIMEOUT_MS = 5000;
+    const MIN_NODE_SQLITE_VERSION = '22.5.0';
     let streamUnsubscribes = [];
     let historyApiRegistry = null;
-    let historySeriesServiceEnabled = true;
-    let registerAsHistoryApiProvider = true;
     let historyApiProviderRegistered = false;
-    function resolveDependencyIdentity(dependencyName) {
+    let runtimeSqliteUnavailableMessage = null;
+    function logRuntimeDependencyVersions() {
+        const nodeIdentity = `node@${process.version}`;
+        const sqliteAvailability = modeConfig && modeConfig.nodeSqliteAvailable ? 'available' : 'unavailable';
+        server.debug(`[KIP][RUNTIME] ${nodeIdentity} node:sqlite=${sqliteAvailability}`);
+    }
+    async function getSqliteModule() {
         try {
-            const pkg = packageRequire(`${dependencyName}/package.json`);
-            const name = typeof pkg.name === 'string' && pkg.name.trim() ? pkg.name.trim() : dependencyName;
-            const version = typeof pkg.version === 'string' && pkg.version.trim() ? pkg.version.trim() : 'unknown';
-            return `${name}@${version}`;
+            return await Promise.resolve().then(() => __importStar(require('node:sqlite')));
         }
         catch {
-            return `${dependencyName}@unavailable`;
+            return null;
         }
     }
-    function logRuntimeDependencyVersions() {
-        const nodeIdentity = `node@${process.version}`;
-        const duckDbNodeIdentity = resolveDependencyIdentity('@duckdb/node-api');
-        const parquetIdentity = resolveDependencyIdentity('@dsnp/parquetjs');
-        server.debug(`[KIP][RUNTIME] ${nodeIdentity} duckdb=${duckDbNodeIdentity} parquet=${parquetIdentity}`);
+    async function detectSqliteRuntime() {
+        const sqliteModule = await getSqliteModule();
+        if (!sqliteModule) {
+            runtimeSqliteUnavailableMessage = `node:sqlite requires Node ${MIN_NODE_SQLITE_VERSION}+`;
+            return false;
+        }
+        if (!sqliteModule.DatabaseSync && !sqliteModule.Database) {
+            runtimeSqliteUnavailableMessage = 'node:sqlite module missing required exports';
+            return false;
+        }
+        runtimeSqliteUnavailableMessage = null;
+        return true;
+    }
+    function getSqliteUnavailableMessage() {
+        if (!(modeConfig && modeConfig.nodeSqliteAvailable)) {
+            return `node:sqlite is not supported in the installed Node.js runtime. Node ${MIN_NODE_SQLITE_VERSION}+ is required.`;
+        }
+        const details = storageService.getLastInitError();
+        return details
+            ? `node:sqlite storage unavailable: ${details}`
+            : 'node:sqlite storage unavailable';
+    }
+    function isSqliteUnavailable() {
+        return !(modeConfig && modeConfig.nodeSqliteAvailable) || Boolean(storageService.getLastInitError());
     }
     function resolveHistoryModeConfig(settings) {
         const root = (settings && typeof settings === 'object' ? settings : {});
@@ -111,12 +136,15 @@ const start = (server) => {
         const registerAsHistoryApiProviderSetting = typeof root.registerAsHistoryApiProvider === 'boolean'
             ? root.registerAsHistoryApiProvider
             : undefined;
+        const nodeSqliteAvailable = typeof root.nodeSqliteAvailable === 'boolean'
+            ? root.nodeSqliteAvailable
+            : undefined;
         return {
             historySeriesServiceEnabled: historySeriesServiceEnabledSetting !== false,
-            registerAsHistoryApiProvider: registerAsHistoryApiProviderSetting !== false
+            registerAsHistoryApiProvider: registerAsHistoryApiProviderSetting !== false,
+            nodeSqliteAvailable: nodeSqliteAvailable !== false
         };
     }
-    // Helpers
     function getDisplaySelfPath(displayId, suffix) {
         const tail = suffix ? `.${suffix}` : '';
         const want = `displays.${displayId}${tail}`;
@@ -140,28 +168,19 @@ const start = (server) => {
     function getHistorySeriesServiceDisabledMessage() {
         return 'KIP history-series service is disabled by plugin configuration';
     }
-    function getDuckDbUnavailableMessage() {
-        const details = storageService.getLastInitError();
-        return details
-            ? `DuckDB storage unavailable: ${details}`
-            : 'DuckDB storage unavailable';
-    }
-    function isDuckDbUnavailable() {
-        return Boolean(storageService.getLastInitError());
-    }
-    async function waitForDuckDbInitialization(timeoutMs = DUCKDB_INIT_WAIT_TIMEOUT_MS) {
-        if (!duckDbInitializationPromise) {
-            return storageService.isDuckDbParquetReady();
+    async function waitForSqliteInitialization(timeoutMs = SQLITE_INIT_WAIT_TIMEOUT_MS) {
+        if (!sqliteInitializationPromise) {
+            return storageService.isSqliteReady();
         }
         try {
             const ready = await Promise.race([
-                duckDbInitializationPromise,
+                sqliteInitializationPromise,
                 new Promise(resolvePromise => {
                     setTimeout(() => resolvePromise(false), timeoutMs);
                 })
             ]);
-            if (!ready && !storageService.isDuckDbParquetReady()) {
-                server.error(`[SERIES STORAGE] DuckDB initialization wait timed out after ${timeoutMs}ms`);
+            if (!ready && !storageService.isSqliteReady()) {
+                server.error(`[SERIES STORAGE] node:sqlite initialization wait timed out after ${timeoutMs}ms`);
             }
             return ready;
         }
@@ -179,10 +198,10 @@ const start = (server) => {
             || normalized.includes('expected an iso')) {
             return { statusCode: 400, message };
         }
-        if (normalized.includes('duckdb')
+        if (normalized.includes('sqlite')
             || normalized.includes('storage unavailable')
             || normalized.includes('not initialized')
-            || isDuckDbUnavailable()) {
+            || isSqliteUnavailable()) {
             return { statusCode: 503, message };
         }
         return { statusCode: 500, message };
@@ -192,23 +211,27 @@ const start = (server) => {
         return current ? JSON.parse(JSON.stringify(current)) : null;
     }
     function isHistorySeriesServiceEnabled() {
-        return historySeriesServiceEnabled;
+        return !!(modeConfig && modeConfig.historySeriesServiceEnabled && modeConfig.nodeSqliteAvailable);
     }
     function isHistoryApiProviderEnabled() {
-        return registerAsHistoryApiProvider;
+        return !!(modeConfig && modeConfig.registerAsHistoryApiProvider && modeConfig.nodeSqliteAvailable);
     }
     function logOperationalMode(stage) {
         server.debug(`[HISTORY MODE] stage=${stage} historySeriesServiceEnabled=${isHistorySeriesServiceEnabled()} historyApiProviderEnabled=${isHistoryApiProviderEnabled()} historyApiProviderRegistered=${historyApiProviderRegistered}`);
     }
-    async function ensureDuckDbReadyForRequest(res) {
-        await waitForDuckDbInitialization();
-        if (storageService.isDuckDbParquetReady()) {
+    async function ensureSqliteReadyForRequest(res) {
+        await waitForSqliteInitialization();
+        if (storageService.isSqliteReady()) {
             return true;
         }
-        sendFail(res, 503, getDuckDbUnavailableMessage());
+        sendFail(res, 503, getSqliteUnavailableMessage());
         return false;
     }
     function ensureHistorySeriesServiceEnabledForRequest(res) {
+        if (!(modeConfig && modeConfig.nodeSqliteAvailable)) {
+            sendFail(res, 503, getSqliteUnavailableMessage());
+            return false;
+        }
         if (isHistorySeriesServiceEnabled()) {
             return true;
         }
@@ -393,9 +416,9 @@ const start = (server) => {
         };
     }
     async function resolveHistoryPaths(query) {
-        await waitForDuckDbInitialization();
-        if (!storageService.isDuckDbParquetReady()) {
-            throw new Error(getDuckDbUnavailableMessage());
+        await waitForSqliteInitialization();
+        if (!storageService.isSqliteReady()) {
+            throw new Error(getSqliteUnavailableMessage());
         }
         try {
             await storageService.flush();
@@ -408,9 +431,9 @@ const start = (server) => {
         });
     }
     async function resolveHistoryContexts(query) {
-        await waitForDuckDbInitialization();
-        if (!storageService.isDuckDbParquetReady()) {
-            throw new Error(getDuckDbUnavailableMessage());
+        await waitForSqliteInitialization();
+        if (!storageService.isSqliteReady()) {
+            throw new Error(getSqliteUnavailableMessage());
         }
         try {
             await storageService.flush();
@@ -423,9 +446,9 @@ const start = (server) => {
         });
     }
     async function resolveHistoryValues(query) {
-        await waitForDuckDbInitialization();
-        if (!storageService.isDuckDbParquetReady()) {
-            throw new Error(getDuckDbUnavailableMessage());
+        await waitForSqliteInitialization();
+        if (!storageService.isSqliteReady()) {
+            throw new Error(getSqliteUnavailableMessage());
         }
         try {
             await storageService.flush();
@@ -437,7 +460,7 @@ const start = (server) => {
             ...query
         });
         if (!values) {
-            throw new Error('DuckDB storage did not return history values.');
+            throw new Error('node:sqlite storage did not return history values.');
         }
         return values;
     }
@@ -556,114 +579,128 @@ const start = (server) => {
             clearInterval(storageFlushTimer);
             storageFlushTimer = null;
         }
-        if (!storageService.isDuckDbParquetEnabled()) {
+        if (!storageService.isSqliteEnabled()) {
             return;
         }
         storageFlushTimer = setInterval(() => {
             void storageService.flush()
-                .then(result => {
-                if (result.inserted > 0 || result.exported > 0) {
-                    server.debug(`[KIP][STORAGE] flush inserted=${result.inserted} exported=${result.exported}`);
-                }
-            })
                 .catch(error => {
                 server.error(`[SERIES STORAGE] flush failed: ${String(error.message || error)}`);
             });
         }, intervalMs);
         storageFlushTimer.unref?.();
     }
+    let modeConfig = null;
     const plugin = {
         id: 'kip',
         name: 'KIP',
         description: 'KIP server plugin',
-        start: (settings) => {
+        start: async (settings) => {
             server.debug('[KIP][LIFECYCLE] start');
+            modeConfig = resolveHistoryModeConfig(settings);
+            // Overwrite runtime-detected properties in modeConfig
+            modeConfig.nodeSqliteAvailable = await detectSqliteRuntime();
+            if (!modeConfig.nodeSqliteAvailable) {
+                server.error(`[KIP][RUNTIME] node:sqlite unavailable. ${runtimeSqliteUnavailableMessage}`);
+            }
+            const serverWithApp = server;
+            const dataDirPath = serverWithApp.app?.getDataDirPath?.();
+            storageService.setDataDirPath(typeof dataDirPath === 'string' ? dataDirPath : null);
+            storageService.setRuntimeAvailability(modeConfig.nodeSqliteAvailable, runtimeSqliteUnavailableMessage ?? undefined);
             logRuntimeDependencyVersions();
-            const modeConfig = resolveHistoryModeConfig(settings);
-            historySeriesServiceEnabled = modeConfig.historySeriesServiceEnabled;
-            registerAsHistoryApiProvider = modeConfig.registerAsHistoryApiProvider;
             logOperationalMode('start-configured');
-            storageService.setLogger({
-                debug: (msg) => server.debug(msg),
-                error: (msg) => server.error(msg)
-            });
-            const storageConfig = storageService.configure();
-            server.debug(`[KIP][STORAGE] config engine=${storageConfig.engine} db=${storageConfig.databaseFile} parquetDir=${storageConfig.parquetDirectory} flushMs=${storageConfig.flushIntervalMs}`);
-            historySeries.setSampleSink(sample => {
-                storageService.enqueueSample(sample);
-            });
-            duckDbInitializationPromise = storageService.initialize();
-            void duckDbInitializationPromise.then((ready) => {
-                server.debug(`[KIP][STORAGE] duckdbReady=${ready}`);
-                if (ready && storageService.isDuckDbParquetEnabled()) {
-                    if (isHistorySeriesServiceEnabled()) {
-                        void storageService.getSeriesDefinitions()
-                            .then((storedSeries) => {
-                            if (storedSeries.length > 0) {
-                                historySeries.reconcileSeries(storedSeries);
-                                rebuildSeriesCaptureSubscriptions();
-                            }
-                            startStorageFlushTimer(storageConfig.flushIntervalMs);
-                            logOperationalMode('duckdb-ready');
-                            server.setPluginStatus(`KIP plugin started with DuckDB/Parquet history storage. Loaded ${storedSeries.length} persisted series. historySeriesServiceEnabled=${isHistorySeriesServiceEnabled()} historyApiProviderEnabled=${isHistoryApiProviderEnabled()} historyApiProviderRegistered=${historyApiProviderRegistered}`);
-                        })
-                            .catch((loadError) => {
-                            server.error(`[SERIES STORAGE] failed to load persisted series: ${String(loadError.message || loadError)}`);
+            const needsSqlite = (modeConfig.historySeriesServiceEnabled || modeConfig.registerAsHistoryApiProvider) && modeConfig.nodeSqliteAvailable;
+            if (needsSqlite) {
+                storageService.setLogger({
+                    debug: (msg) => server.debug(msg),
+                    error: (msg) => server.error(msg)
+                });
+                const storageConfig = storageService.configure();
+                server.debug(`[KIP][STORAGE] config engine=${storageConfig.engine} db=${storageConfig.databaseFile} flushMs=${storageConfig.flushIntervalMs}`);
+                historySeries.setSampleSink(sample => {
+                    storageService.enqueueSample(sample);
+                });
+                sqliteInitializationPromise = storageService.initialize();
+                void sqliteInitializationPromise.then((ready) => {
+                    server.debug(`[KIP][STORAGE] sqliteReady=${ready}`);
+                    if (ready && storageService.isSqliteEnabled()) {
+                        if (modeConfig && modeConfig.historySeriesServiceEnabled) {
+                            void storageService.getSeriesDefinitions()
+                                .then((storedSeries) => {
+                                if (storedSeries.length > 0) {
+                                    historySeries.reconcileSeries(storedSeries);
+                                    rebuildSeriesCaptureSubscriptions();
+                                }
+                                startStorageFlushTimer(storageConfig.flushIntervalMs);
+                                logOperationalMode('sqlite-ready');
+                                server.setPluginStatus(`KIP plugin started with node:sqlite history storage. Loaded ${storedSeries.length} persisted series. historySeriesServiceEnabled=${modeConfig.historySeriesServiceEnabled} historyApiProviderEnabled=${modeConfig.registerAsHistoryApiProvider} historyApiProviderRegistered=${historyApiProviderRegistered}`);
+                            })
+                                .catch((loadError) => {
+                                server.error(`[SERIES STORAGE] failed to load persisted series: ${String(loadError.message || loadError)}`);
+                                startStorageFlushTimer(storageConfig.flushIntervalMs);
+                                logOperationalMode('sqlite-ready-series-load-failed');
+                                server.setPluginStatus(`KIP plugin started with node:sqlite history storage. historySeriesServiceEnabled=${modeConfig.historySeriesServiceEnabled} historyApiProviderEnabled=${modeConfig.registerAsHistoryApiProvider} historyApiProviderRegistered=${historyApiProviderRegistered}`);
+                            });
+                        }
+                        else {
+                            historySeries.reconcileSeries([]);
+                            stopSeriesCapture();
                             startStorageFlushTimer(storageConfig.flushIntervalMs);
-                            logOperationalMode('duckdb-ready-series-load-failed');
-                            server.setPluginStatus(`KIP plugin started with DuckDB/Parquet history storage. historySeriesServiceEnabled=${isHistorySeriesServiceEnabled()} historyApiProviderEnabled=${isHistoryApiProviderEnabled()} historyApiProviderRegistered=${historyApiProviderRegistered}`);
-                        });
+                            logOperationalMode('sqlite-ready-series-disabled');
+                            server.setPluginStatus(`KIP plugin started with history-series service disabled. historyApiProviderEnabled=${modeConfig.registerAsHistoryApiProvider} historyApiProviderRegistered=${historyApiProviderRegistered}`);
+                        }
+                        return;
                     }
-                    else {
-                        historySeries.reconcileSeries([]);
-                        stopSeriesCapture();
-                        startStorageFlushTimer(storageConfig.flushIntervalMs);
-                        logOperationalMode('duckdb-ready-series-disabled');
-                        server.setPluginStatus(`KIP plugin started with history-series service disabled. historyApiProviderEnabled=${isHistoryApiProviderEnabled()} historyApiProviderRegistered=${historyApiProviderRegistered}`);
+                    if (storageFlushTimer) {
+                        clearInterval(storageFlushTimer);
+                        storageFlushTimer = null;
                     }
-                    return;
-                }
-                if (storageFlushTimer) {
-                    clearInterval(storageFlushTimer);
-                    storageFlushTimer = null;
-                }
-                const initError = storageService.getLastInitError();
-                if (initError) {
-                    server.setPluginError(`DuckDB unavailable. ${initError}`);
-                    logOperationalMode('duckdb-unavailable');
-                    server.setPluginStatus(`KIP plugin started with DuckDB unavailable. historySeriesServiceEnabled=${isHistorySeriesServiceEnabled()} historyApiProviderEnabled=${isHistoryApiProviderEnabled()} historyApiProviderRegistered=${historyApiProviderRegistered}`);
+                    const initError = storageService.getLastInitError();
+                    if (initError) {
+                        server.setPluginError(`node:sqlite unavailable. ${initError}`);
+                        logOperationalMode('sqlite-unavailable');
+                        server.setPluginStatus(`KIP plugin started with node:sqlite unavailable. historySeriesServiceEnabled=${modeConfig?.historySeriesServiceEnabled} historyApiProviderEnabled=${modeConfig?.registerAsHistoryApiProvider} historyApiProviderRegistered=${historyApiProviderRegistered}`);
+                    }
+                });
+                if (retentionSweepTimer) {
+                    clearInterval(retentionSweepTimer);
                 }
-            });
-            if (retentionSweepTimer) {
-                clearInterval(retentionSweepTimer);
-            }
-            retentionSweepTimer = setInterval(() => {
-                try {
-                    if (storageService.isDuckDbParquetReady()) {
-                        const lifecycleToken = storageService.getLifecycleToken();
-                        void storageService.pruneExpiredSamples(Date.now(), lifecycleToken)
-                            .then(removedPersistedRows => {
-                            if (removedPersistedRows > 0) {
-                                server.debug(`[KIP][RETENTION] pruneExpired removedRows=${removedPersistedRows}`);
-                            }
-                            return storageService.pruneOrphanedSamples(lifecycleToken)
-                                .then(removedOrphanRows => {
-                                if (removedOrphanRows > 0) {
-                                    server.debug(`[KIP][RETENTION] pruneOrphaned removedRows=${removedOrphanRows}`);
+                retentionSweepTimer = setInterval(() => {
+                    try {
+                        if (storageService.isSqliteReady()) {
+                            const lifecycleToken = storageService.getLifecycleToken();
+                            void storageService.pruneExpiredSamples(Date.now(), lifecycleToken)
+                                .then(removedPersistedRows => {
+                                if (removedPersistedRows > 0) {
+                                    server.debug(`[KIP][RETENTION] pruneExpired removedRows=${removedPersistedRows}`);
                                 }
+                                return storageService.pruneOrphanedSamples(lifecycleToken)
+                                    .then(removedOrphanRows => {
+                                    if (removedOrphanRows > 0) {
+                                        server.debug(`[KIP][RETENTION] pruneOrphaned removedRows=${removedOrphanRows}`);
+                                    }
+                                });
+                            })
+                                .catch(error => {
+                                server.error(`[SERIES RETENTION] node:sqlite Prune failed: ${String(error.message || error)}`);
                             });
-                        })
-                            .catch(error => {
-                            server.error(`[SERIES RETENTION] duckdbPrune failed: ${String(error.message || error)}`);
-                        });
+                        }
                     }
+                    catch (error) {
+                        server.error(`[SERIES RETENTION] node:sqlite sweep failed: ${String(error.message || error)}`);
+                    }
+                }, 60 * 60_000);
+                retentionSweepTimer.unref?.();
+                rebuildSeriesCaptureSubscriptions();
+            }
+            else {
+                if (modeConfig && !modeConfig.nodeSqliteAvailable && (modeConfig.historySeriesServiceEnabled || modeConfig.registerAsHistoryApiProvider)) {
+                    server.setPluginError(getSqliteUnavailableMessage());
                 }
-                catch (error) {
-                    server.error(`[SERIES RETENTION] sweep failed: ${String(error.message || error)}`);
-                }
-            }, 60 * 60_000);
-            retentionSweepTimer.unref?.();
-            rebuildSeriesCaptureSubscriptions();
+                server.debug('[KIP][STORAGE] sqlite init skipped reason=config-disabled-or-runtime');
+                sqliteInitializationPromise = null;
+                stopSeriesCapture();
+            }
             if (server.registerPutHandler) {
                 server.debug(`[KIP][COMMAND] registerPutHandlers context=${PUT_CONTEXT}`);
                 server.registerPutHandler(PUT_CONTEXT, COMMAND_PATHS.SET_DISPLAY, (context, path, value) => {
@@ -715,11 +752,26 @@ const start = (server) => {
                 }
                 historyApiRegistry = null;
             }
-            duckDbInitializationPromise = null;
+            sqliteInitializationPromise = null;
             const msg = 'Stopped.';
             server.setPluginStatus(msg);
         },
-        schema: () => CONFIG_SCHEMA,
+        schema: () => {
+            // Return schema with live modeConfig values
+            const schema = JSON.parse(JSON.stringify(CONFIG_SCHEMA));
+            if (schema && schema.properties && modeConfig) {
+                if (typeof modeConfig.nodeSqliteAvailable === 'boolean') {
+                    schema.properties.nodeSqliteAvailable.default = modeConfig.nodeSqliteAvailable;
+                }
+                if (typeof modeConfig.historySeriesServiceEnabled === 'boolean') {
+                    schema.properties.historySeriesServiceEnabled.default = modeConfig.historySeriesServiceEnabled;
+                }
+                if (typeof modeConfig.registerAsHistoryApiProvider === 'boolean') {
+                    schema.properties.registerAsHistoryApiProvider.default = modeConfig.registerAsHistoryApiProvider;
+                }
+            }
+            return schema;
+        },
         registerWithRouter(router) {
             server.debug(`[KIP][ROUTES] register displays=${API_PATHS.DISPLAYS} instance=${API_PATHS.INSTANCE} screenIndex=${API_PATHS.SCREEN_INDEX} activeScreen=${API_PATHS.ACTIVATE_SCREEN}`);
             // Validate/normalize :displayId where present
@@ -912,7 +964,7 @@ const start = (server) => {
                     if (!ensureHistorySeriesServiceEnabledForRequest(res)) {
                         return;
                     }
-                    if (!(await ensureDuckDbReadyForRequest(res))) {
+                    if (!(await ensureSqliteReadyForRequest(res))) {
                         return;
                     }
                     return sendOk(res, historySeries.listSeries());
@@ -929,7 +981,7 @@ const start = (server) => {
                     if (!ensureHistorySeriesServiceEnabledForRequest(res)) {
                         return;
                     }
-                    if (!(await ensureDuckDbReadyForRequest(res))) {
+                    if (!(await ensureSqliteReadyForRequest(res))) {
                         return;
                     }
                     const seriesId = String(req.params.seriesId ?? '').trim();
@@ -970,7 +1022,7 @@ const start = (server) => {
                     if (!ensureHistorySeriesServiceEnabledForRequest(res)) {
                         return;
                     }
-                    if (!(await ensureDuckDbReadyForRequest(res))) {
+                    if (!(await ensureSqliteReadyForRequest(res))) {
                         return;
                     }
                     const seriesId = String(req.params.seriesId ?? '').trim();
@@ -998,14 +1050,14 @@ const start = (server) => {
                     if (!ensureHistorySeriesServiceEnabledForRequest(res)) {
                         return;
                     }
-                    if (!(await ensureDuckDbReadyForRequest(res))) {
+                    if (!(await ensureSqliteReadyForRequest(res))) {
                         return;
                     }
                     const payload = req.body;
                     if (!Array.isArray(payload)) {
                         return sendFail(res, 400, 'Body must be an array of series definitions');
                     }
-                    const simulated = new history_series_service_1.HistorySeriesService(() => Date.now(), false);
+                    const simulated = new history_series_service_1.HistorySeriesService(() => Date.now());
                     historySeries.listSeries().forEach(series => {
                         simulated.upsertSeries(series);
                     });