@mxtommy/kip 4.5.2 → 4.6.0

package/CHANGELOG.md

@@ -1,12 +1,21 @@
-# v4.5.2
+# v4.6.0
+## Improvements
+* Built-in Time-Series storage and History-API provider now use the native node:sqlite feature, eliminating all binary and external dependencies.
+  * Requires Node.js 22.5.0 or newer. If you use an older Node.js version, you must select an alternative History-API provider.
+  * **IMPORTANT:** Before upgrading Node.js, always confirm your Signal K server version supports the required Node.js version. See the [Signal K installation documentation](https://demo.signalk.org/documentation/Installation.html).
+## Fixes
+* Extending v4.5.x features to VenusOS (32bit OS) - Error: Failed to start: Error loading duckdb native binding: unsupported arch 'arm' for platform 'linux'. Fixes #979
+* Uninstallation does not remove all files. Fixes #981
+* Reduce unwarranted installation size.
+# v4.5.2 - Deprecated version due to lack of VenusOS (32bit) DuckDB binary support  
 ## Fixes
 * DuckDB initialized when features are not enabled.
 * Parquet data compression and pruning not executing.
-# v4.5.1
+# v4.5.1 - Deprecated version due to lack of VenusOS (32bit) DuckDB binary support 
 ## Fixes
 * DuckDB dependency causing build and installation errors. Fixes #979
 * Reduced installation size. Fixes #980
-# v4.5.0
+# v4.5.0 - Deprecated version due to lack of VenusOS (32bit) DuckDB binary support 
 ## New Features
 * Effortlessly review your vessel’s history with the new Widget Historical Charts—automatically track, store, and visualize key data. Instantly access up to the last full day of performance: just two-finger tap or right-click any widget to open a seamless history dialog—no setup, no clutter, just the trends you need. (Requires Signal K v2.22.1)
 * Dashboards now start with fully populated Data Charts, powered by KIP’s managed Time-Series History-API provider or other compatible history providers. (Requires Signal K v2.22.1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxtommy/kip",
-  "version": "4.5.2",
+  "version": "4.6.0",
   "description": "An advanced and versatile marine instrumentation package to display Signal K data.",
   "license": "MIT",
   "author": {
@@ -66,22 +66,22 @@
   },
   "schematics": "tools/schematics/collection.json",
   "devDependencies": {
-    "@angular/cdk": "21.2.0",
-    "@angular/common": "21.2.0",
-    "@angular/compiler": "21.2.0",
-    "@angular/core": "21.2.0",
-    "@angular/forms": "21.2.0",
-    "@angular/material": "21.2.0",
-    "@angular/animations": "21.2.0",
-    "@angular/platform-browser": "21.2.0",
-    "@angular/platform-browser-dynamic": "21.2.0",
-    "@angular/router": "21.2.0",
+    "@angular/cdk": "21.2.1",
+    "@angular/common": "21.2.1",
+    "@angular/compiler": "21.2.1",
+    "@angular/core": "21.2.1",
+    "@angular/forms": "21.2.1",
+    "@angular/material": "21.2.1",
+    "@angular/animations": "21.2.1",
+    "@angular/platform-browser": "21.2.1",
+    "@angular/platform-browser-dynamic": "21.2.1",
+    "@angular/router": "21.2.1",
     "@angular-devkit/build-angular": "^21.1.4",
     "@angular-devkit/schematics-cli": "^20.1.6",
     "@angular/build": "^21.1.4",
     "@angular/cli": "^21.1.4",
-    "@angular/compiler-cli": "21.2.0",
-    "@angular/language-service": "21.2.0",
+    "@angular/compiler-cli": "21.2.1",
+    "@angular/language-service": "21.2.1",
     "@types/canvas-gauges": "^2.1.8",
     "@types/d3": "^7.4.3",
     "@types/jasmine": "~3.6.0",
@@ -131,8 +131,6 @@
     "zone.js": "^0.15.1"
   },
   "dependencies": {
-    "@dsnp/parquetjs": "^1.8.7",
-    "@duckdb/node-api": "^1.4.4-r.2",
     "@signalk/server-api": "^2.22.0"
   }
 }

package/plugin/history-series.service.js

@@ -6,13 +6,11 @@ exports.HistorySeriesService = void 0;
  */
 class HistorySeriesService {
     nowProvider;
-    retainSamplesInMemory;
     seriesById = new Map();
     lastAcceptedTimestampBySeriesKey = new Map();
     sampleSink = null;
-    constructor(nowProvider = () => Date.now(), retainSamplesInMemory = true) {
+    constructor(nowProvider = () => Date.now()) {
         this.nowProvider = nowProvider;
-        this.retainSamplesInMemory = retainSamplesInMemory;
     }
     /**
      * Returns all configured series sorted by `seriesId`.
@@ -171,9 +169,10 @@ class HistorySeriesService {
         if (!series || series.enabled === false || !Number.isFinite(value) || !Number.isFinite(timestamp)) {
             return false;
         }
-        const samplingIntervalMs = this.resolveSampleTimeMs(series.sampleTime);
         const previousTimestamp = this.lastAcceptedTimestampBySeriesKey.get(seriesKey);
-        if (previousTimestamp !== undefined && (timestamp - previousTimestamp) < samplingIntervalMs) {
+        // Enforces a minimum of 1 second to prevent excessive sampling on short retention durations
+        const minSampleTime = Math.max(Number(series.sampleTime) || 0, 1000);
+        if (previousTimestamp !== undefined && (timestamp - previousTimestamp) < minSampleTime) {
             return false;
         }
         const context = series.context ?? 'vessels.self';
@@ -311,17 +310,19 @@ class HistorySeriesService {
         if (!path) {
             throw new Error('path is required');
         }
-        // Determine if this is a data chart based widget
-        const dsSampleTime = ownerWidgetUuid?.startsWith('widget-windtrends-chart') ||
-            ownerWidgetUuid?.startsWith('widget-data-chart');
+        // Determine if this is a chart type widget
+        const isDataWidget = ownerWidgetUuid?.startsWith('widget-windtrends-chart') || ownerWidgetUuid?.startsWith('widget-data-chart');
+        const retentionMs = this.resolveRetentionMs(input);
         let sampleTime;
-        const retentionMs = input.retentionDurationMs ?? this.resolveRetentionMs(input);
-        if (dsSampleTime && Number.isFinite(retentionMs) && retentionMs > 0) {
-            // regular widget sampleTime: 15 sec
-            sampleTime = Math.max(1, Math.trunc(15000));
+        if (isDataWidget) {
+            // For chart type widgets we use retention duration to dynamically calculate sampleTime to
+            // aims for around 120 samples.
+            sampleTime = retentionMs ? Math.max(1000, Math.round(retentionMs / 120)) : 1000;
         }
         else {
-            sampleTime = this.resolveSampleTimeMs(input.sampleTime);
+            // Non chart type widgets, ie historical Time-Series, have a fixed sampleTime of 15 sec that is
+            // a good median amount of samples for the dynamically queryable chart display range (15 min up to 24h).
+            sampleTime = 15000; // ms
         }
         return {
             ...input,
@@ -336,17 +337,6 @@ class HistorySeriesService {
             sampleTime
         };
     }
-    resolveSampleTimeMs(sampleTime) {
-        const parsed = Number(sampleTime);
-        if (Number.isFinite(parsed) && parsed > 0) {
-            return Math.max(1, Math.trunc(parsed));
-        }
-        return 1000;
-    }
-    buildSeriesMapKey(seriesId) {
-        // userScope removed; now returns only seriesId
-        return String(seriesId).trim();
-    }
     resolveRetentionMs(series) {
         if (Number.isFinite(series.retentionDurationMs) && series.retentionDurationMs > 0) {
             return series.retentionDurationMs;

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,49 +579,52 @@ 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');
-            const needsDuckDb = historySeriesServiceEnabled || registerAsHistoryApiProvider;
-            if (needsDuckDb) {
+            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} parquetDir=${storageConfig.parquetDirectory} flushMs=${storageConfig.flushIntervalMs} parquetWindowMs=${storageConfig.parquetWindowMs} parquetCompression=${storageConfig.parquetCompression}`);
+                server.debug(`[KIP][STORAGE] config engine=${storageConfig.engine} db=${storageConfig.databaseFile} 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()) {
+                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) {
@@ -606,22 +632,22 @@ const start = (server) => {
                                     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}`);
+                                logOperationalMode('sqlite-ready');
+                                server.setPluginStatus(`Providing: Remote Control${historyApiProviderRegistered ? ', History service' : ', No History service'}${storedSeries.length > 0 ? `, ${storedSeries.length} Time-Series` : ', No Time-Series'}.`);
                             })
                                 .catch((loadError) => {
                                 server.error(`[SERIES STORAGE] failed to load persisted series: ${String(loadError.message || loadError)}`);
                                 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-load-failed');
+                                server.setPluginStatus(`Providing: Remote Control${historyApiProviderRegistered ? ', History service' : ', No History service'}, No Time-Series.`);
                             });
                         }
                         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}`);
+                            logOperationalMode('sqlite-ready-series-disabled');
+                            server.setPluginStatus(`Providing: Remote Control${historyApiProviderRegistered ? ', History service' : ', No History service'}, No Time-Series.`);
                         }
                         return;
                     }
@@ -631,9 +657,9 @@ const start = (server) => {
                     }
                     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}`);
+                        server.setPluginError(`node:sqlite unavailable. ${initError}`);
+                        logOperationalMode('sqlite-unavailable');
+                        server.setPluginStatus(`Providing: Remote Control${historyApiProviderRegistered ? ', History service' : ', No History service'}, No Time-Series.`);
                     }
                 });
                 if (retentionSweepTimer) {
@@ -641,7 +667,7 @@ const start = (server) => {
                 }
                 retentionSweepTimer = setInterval(() => {
                     try {
-                        if (storageService.isDuckDbParquetReady()) {
+                        if (storageService.isSqliteReady()) {
                             const lifecycleToken = storageService.getLifecycleToken();
                             void storageService.pruneExpiredSamples(Date.now(), lifecycleToken)
                                 .then(removedPersistedRows => {
@@ -656,20 +682,23 @@ const start = (server) => {
                                 });
                             })
                                 .catch(error => {
-                                server.error(`[SERIES RETENTION] duckdbPrune failed: ${String(error.message || error)}`);
+                                server.error(`[SERIES RETENTION] node:sqlite Prune failed: ${String(error.message || error)}`);
                             });
                         }
                     }
                     catch (error) {
-                        server.error(`[SERIES RETENTION] sweep failed: ${String(error.message || error)}`);
+                        server.error(`[SERIES RETENTION] node:sqlite sweep failed: ${String(error.message || error)}`);
                     }
                 }, 60 * 60_000);
                 retentionSweepTimer.unref?.();
                 rebuildSeriesCaptureSubscriptions();
             }
             else {
-                server.debug('[KIP][STORAGE] duckdb init skipped reason=config-disabled');
-                duckDbInitializationPromise = null;
+                if (modeConfig && !modeConfig.nodeSqliteAvailable && (modeConfig.historySeriesServiceEnabled || modeConfig.registerAsHistoryApiProvider)) {
+                    server.setPluginStatus(getSqliteUnavailableMessage());
+                }
+                server.debug('[KIP][STORAGE] sqlite init skipped reason=config-disabled-or-runtime');
+                sqliteInitializationPromise = null;
                 stopSeriesCapture();
             }
             if (server.registerPutHandler) {
@@ -723,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
@@ -920,7 +964,7 @@ const start = (server) => {
                     if (!ensureHistorySeriesServiceEnabledForRequest(res)) {
                         return;
                     }
-                    if (!(await ensureDuckDbReadyForRequest(res))) {
+                    if (!(await ensureSqliteReadyForRequest(res))) {
                         return;
                     }
                     return sendOk(res, historySeries.listSeries());
@@ -937,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();
@@ -978,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();
@@ -1006,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);
                     });