@mxtommy/kip 4.5.2 → 4.6.0

package/plugin/{duckdb-parquet-storage.service.js → sqlite-history-storage.service.js}

@@ -1,46 +1,71 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DuckDbParquetStorageService = void 0;
+exports.SqliteHistoryStorageService = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const node_api_1 = require("@duckdb/node-api");
-const parquetjs_1 = require("@dsnp/parquetjs");
-/**
- * Provides DuckDB storage and Parquet flush support for captured history samples.
- */
 const DEFAULT_STORAGE_CONFIG = {
-    engine: 'duckdb-parquet',
-    databaseFile: 'plugin-config-data/kip/historicalData/kip-history.duckdb',
-    parquetDirectory: 'plugin-config-data/kip/historicalData/parquet',
-    flushIntervalMs: 30_000,
-    parquetWindowMs: 60 * 60_000,
-    parquetCompression: 'snappy'
+    engine: 'node:sqlite',
+    databaseFile: 'plugin-config-data/kip/historicalData/kip-history.sqlite',
+    flushIntervalMs: 30_000
 };
-class DuckDbParquetStorageService {
-    config = { ...DEFAULT_STORAGE_CONFIG };
-    // 8 hour job interval (8 hours)
+/**
+ * Provides node:sqlite storage for captured history samples.
+ */
+class SqliteHistoryStorageService {
     static EIGHT_HOURS_INTERVAL = 8 * 60 * 60 * 1000;
-    vacuumJob = null;
-    // 4 hour job interval (4 hours)
     static FOUR_HOURS_INTERVAL = 4 * 60 * 60 * 1000;
-    pruneJob = null;
-    // Stale series cleanup interval (6 months)
-    static STALE_SERIES_AGE_MS = 180 * 24 * 60 * 60 * 1000; // 6 months
-    staleSeriesCleanupJob = null;
+    static STALE_SERIES_AGE_MS = 180 * 24 * 60 * 60 * 1000;
     static PRUNE_BATCH_SIZE = 10_000;
+    config = { ...DEFAULT_STORAGE_CONFIG };
+    dataDirPath = null;
     logger = {
         debug: () => undefined,
         error: () => undefined
     };
     db = null;
-    connection = null;
     pendingRows = [];
-    pendingRangesBySeriesId = new Map();
     lastInitError = null;
     lifecycleToken = 0;
     initialized = false;
+    runtimeAvailable = true;
     maintenanceInProgress = false;
     flushInProgress = false;
+    vacuumJob = null;
+    pruneJob = null;
+    staleSeriesCleanupJob = null;
     /**
      * Sets logger callbacks used by the storage service.
      *
@@ -56,7 +81,7 @@ class DuckDbParquetStorageService {
     /**
      * Applies the fixed storage backend configuration.
      *
-     * @returns {IDuckDbParquetStorageConfig} Fixed storage configuration.
+     * @returns {ISqliteHistoryStorageConfig} Fixed storage configuration.
      *
      * @example
      * const cfg = storage.configure();
@@ -64,229 +89,100 @@ class DuckDbParquetStorageService {
      */
     configure() {
         this.initialized = false;
-        this.config = { ...DEFAULT_STORAGE_CONFIG };
+        const databaseFile = this.dataDirPath
+            ? (0, path_1.join)(this.dataDirPath, 'historicalData', 'kip-history.sqlite')
+            : DEFAULT_STORAGE_CONFIG.databaseFile;
+        this.config = {
+            ...DEFAULT_STORAGE_CONFIG,
+            databaseFile
+        };
         return this.config;
     }
     /**
-     * Initializes DuckDB storage if DuckDB engine is selected.
+     * Sets the base directory for persisted history data.
+     *
+     * @param {string | null} baseDir Absolute directory path for plugin data.
+     * @returns {void}
+     *
+     * @example
+     * storage.setDataDirPath('/var/lib/signalk');
+     */
+    setDataDirPath(baseDir) {
+        this.dataDirPath = typeof baseDir === 'string' && baseDir.trim() ? baseDir.trim() : null;
+    }
+    /**
+     * Updates runtime availability of node:sqlite, clearing stored errors when enabled.
+     *
+     * @param {boolean} available Whether node:sqlite is available at runtime.
+     * @param {string | undefined} errorMessage Optional runtime error message.
+     * @returns {void}
+     *
+     * @example
+     * storage.setRuntimeAvailability(false, 'node:sqlite unavailable');
+     */
+    setRuntimeAvailability(available, errorMessage) {
+        this.runtimeAvailable = available;
+        this.lastInitError = available ? null : (errorMessage ?? 'node:sqlite unavailable');
+        if (!available) {
+            this.initialized = false;
+            this.db = null;
+        }
+    }
+    /**
+     * Initializes node:sqlite storage.
      *
-     * @returns {Promise<boolean>} True when DuckDB is initialized and ready.
+     * @returns {Promise<boolean>} True when node:sqlite is initialized and ready.
      *
      * @example
      * const ready = await storage.initialize();
      */
     async initialize() {
-        if (!this.isDuckDbParquetEnabled()) {
+        if (!this.isSqliteEnabled() || !this.runtimeAvailable) {
             return false;
         }
         this.initialized = false;
         this.lifecycleToken += 1;
         try {
+            const sqlite = await this.loadSqliteModule();
+            if (!sqlite?.DatabaseSync) {
+                throw new Error('node:sqlite DatabaseSync is unavailable');
+            }
             const dbPath = (0, path_1.resolve)(this.config.databaseFile);
             (0, fs_1.mkdirSync)((0, path_1.dirname)(dbPath), { recursive: true });
-            (0, fs_1.mkdirSync)((0, path_1.resolve)(this.config.parquetDirectory), { recursive: true });
-            this.db = await node_api_1.DuckDBInstance.create(dbPath);
-            this.connection = await this.db.connect();
+            this.db = new sqlite.DatabaseSync(dbPath, { timeout: 5000 });
+            this.db.exec('PRAGMA journal_mode=WAL;');
+            this.db.exec('PRAGMA synchronous=NORMAL;');
+            this.db.exec('PRAGMA temp_store=MEMORY;');
+            this.db.exec('PRAGMA foreign_keys=ON;');
             await this.createCoreTables();
             await this.runSql('CREATE INDEX IF NOT EXISTS idx_history_series_scope_ts ON history_samples(series_id, ts_ms)');
             await this.runSql('CREATE INDEX IF NOT EXISTS idx_history_series_scope_id ON history_series(series_id)');
             await this.runSql('CREATE INDEX IF NOT EXISTS idx_history_samples_scope_context_path_ts ON history_samples(context, path, ts_ms)');
             await this.runSql('CREATE INDEX IF NOT EXISTS idx_history_samples_scope_ts_path ON history_samples(ts_ms, path)');
             await this.runSql('CREATE INDEX IF NOT EXISTS idx_history_samples_scope_ts_context ON history_samples(ts_ms, context)');
-            this.logger.debug(`[SERIES STORAGE] DuckDB initialized at ${dbPath}`);
+            this.logger.debug(`[SERIES STORAGE] node:sqlite initialized at ${dbPath}`);
             this.lastInitError = null;
             this.initialized = true;
-            // Start VACUUM job
             this.startVacuumJob();
-            // Start prune job
             this.startPruneJob();
-            // Start stale series cleanup job
             this.startStaleSeriesCleanupJob();
             return true;
         }
         catch (error) {
             const message = error?.message ?? String(error);
             this.lastInitError = message;
-            this.logger.error(`[SERIES STORAGE] DuckDB initialization failed: ${message}`);
-            this.logger.error('[SERIES STORAGE] DuckDB Node API is required. Install runtime dependency with: npm i @duckdb/node-api in the installed plugin directory, then restart Signal K.');
-            this.connection = null;
+            this.logger.error(`[SERIES STORAGE] node:sqlite initialization failed: ${message}`);
             this.db = null;
             this.pendingRows = [];
-            this.pendingRangesBySeriesId.clear();
             this.initialized = false;
             this.stopVacuumJob();
+            this.stopPruneJob();
+            this.stopStaleSeriesCleanupJob();
             return false;
         }
     }
     /**
-     * Starts VACUUM job for DuckDB.
-     */
-    startVacuumJob() {
-        this.stopVacuumJob();
-        if (!this.isDuckDbParquetReady() || !this.connection)
-            return;
-        this.vacuumJob = setInterval(() => {
-            if (this.shouldSkipMaintenance()) {
-                return;
-            }
-            void this.runWithMaintenanceLock('vacuum', async () => {
-                this.logger.debug('[SERIES STORAGE] Running scheduled DuckDB VACUUM');
-                await this.runSql('VACUUM;');
-            }).catch(err => {
-                this.logger.error(`[SERIES STORAGE] VACUUM failed: ${err?.message ?? err}`);
-            });
-        }, DuckDbParquetStorageService.EIGHT_HOURS_INTERVAL);
-        this.vacuumJob.unref?.();
-    }
-    /**
-     * Stops the scheduled VACUUM job if running.
-     */
-    stopVacuumJob() {
-        if (this.vacuumJob) {
-            clearInterval(this.vacuumJob);
-            this.vacuumJob = null;
-        }
-    }
-    /**
-     * Starts the prune job for expired and orphaned samples.
-     */
-    startPruneJob() {
-        this.stopPruneJob();
-        if (!this.isDuckDbParquetReady() || !this.connection)
-            return;
-        this.pruneJob = setInterval(async () => {
-            if (this.shouldSkipMaintenance()) {
-                return;
-            }
-            try {
-                await this.runWithMaintenanceLock('prune', async () => {
-                    this.logger.debug('[SERIES STORAGE] Running scheduled prune of expired and orphaned samples');
-                    const expired = await this.pruneExpiredSamples(Date.now(), this.lifecycleToken);
-                    const orphaned = await this.pruneOrphanedSamples(this.lifecycleToken);
-                    const parquetRemoved = await this.pruneParquetFilesByRetention(Date.now());
-                    this.logger.debug(`[SERIES STORAGE] Pruned ${expired} expired and ${orphaned} orphaned samples`);
-                    if (parquetRemoved > 0) {
-                        this.logger.debug(`[SERIES STORAGE] Pruned ${parquetRemoved} parquet files/directories`);
-                    }
-                });
-            }
-            catch (err) {
-                this.logger.error(`[SERIES STORAGE] Prune failed: ${err?.message ?? err}`);
-            }
-        }, DuckDbParquetStorageService.FOUR_HOURS_INTERVAL);
-        this.pruneJob.unref?.();
-    }
-    /**
-     * Stops the scheduled prune job if running.
-     */
-    stopPruneJob() {
-        if (this.pruneJob) {
-            clearInterval(this.pruneJob);
-            this.pruneJob = null;
-        }
-    }
-    /**
-     * Starts the scheduled job to delete series not reconciled in the last 6 months.
-     */
-    startStaleSeriesCleanupJob() {
-        this.stopStaleSeriesCleanupJob();
-        if (!this.isDuckDbParquetReady() || !this.connection)
-            return;
-        this.staleSeriesCleanupJob = setInterval(async () => {
-            if (this.shouldSkipMaintenance()) {
-                return;
-            }
-            try {
-                await this.runWithMaintenanceLock('stale-cleanup', async () => {
-                    const cutoff = Date.now() - DuckDbParquetStorageService.STALE_SERIES_AGE_MS;
-                    this.logger.debug(`[SERIES STORAGE] Running scheduled stale series cleanup (cutoff: ${new Date(cutoff).toISOString()})`);
-                    const deleted = await this.deleteStaleSeries(cutoff);
-                    if (deleted > 0) {
-                        this.logger.debug(`[SERIES STORAGE] Deleted ${deleted} series not reconciled in the last 6 months`);
-                    }
-                });
-            }
-            catch (err) {
-                this.logger.error(`[SERIES STORAGE] Stale series cleanup failed: ${err?.message ?? err}`);
-            }
-        }, DuckDbParquetStorageService.EIGHT_HOURS_INTERVAL);
-        this.staleSeriesCleanupJob.unref?.();
-    }
-    /**
-     * Deletes series not reconciled since the given cutoff timestamp.
-     * @param {number} cutoffMs - Milliseconds since epoch; series with reconcile_ts < cutoffMs will be deleted.
-     * @returns {Promise<number>} Number of deleted series.
-     *
-     * @example
-     * const deleted = await storage.deleteStaleSeries(Date.now() - 180 * 24 * 60 * 60 * 1000);
-     */
-    async deleteStaleSeries(cutoffMs) {
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
-            return 0;
-        }
-        // Find series to delete
-        const rows = await this.querySql(`
-      SELECT series_id FROM history_series
-      WHERE reconcile_ts IS NULL OR reconcile_ts < ${Math.trunc(cutoffMs)}
-    `);
-        const ids = rows.map(r => r.series_id);
-        if (ids.length === 0)
-            return 0;
-        for (const id of ids) {
-            await this.deleteSeriesDefinition(id);
-        }
-        return ids.length;
-    }
-    /**
-     * Stops the scheduled stale series cleanup job if running.
-     */
-    stopStaleSeriesCleanupJob() {
-        if (this.staleSeriesCleanupJob) {
-            clearInterval(this.staleSeriesCleanupJob);
-            this.staleSeriesCleanupJob = null;
-        }
-    }
-    shouldSkipMaintenance() {
-        if (!this.isDuckDbParquetReady() || !this.connection) {
-            return true;
-        }
-        if (this.maintenanceInProgress || this.flushInProgress) {
-            return true;
-        }
-        if (this.pendingRows.length > 0) {
-            return true;
-        }
-        return false;
-    }
-    async runWithMaintenanceLock(label, task) {
-        if (this.maintenanceInProgress) {
-            this.logger.debug(`[SERIES STORAGE] Skipping ${label} (maintenance already running)`);
-            return;
-        }
-        this.maintenanceInProgress = true;
-        const startedAt = Date.now();
-        try {
-            await task();
-            const elapsedMs = Date.now() - startedAt;
-            this.logger.debug(`[SERIES STORAGE] ${label} completed in ${elapsedMs}ms`);
-        }
-        finally {
-            this.maintenanceInProgress = false;
-        }
-    }
-    /**
-     * Returns the active storage configuration.
-     *
-     * @returns {IDuckDbParquetStorageConfig} Current storage configuration.
-     *
-     * @example
-     * const cfg = storage.getConfig();
-     */
-    getConfig() {
-        return this.config;
-    }
-    /**
-     * Returns last DuckDB initialization error when initialization failed.
+     * Returns last node:sqlite initialization error when initialization failed.
      *
      * @returns {string | null} Initialization error text or null.
      *
@@ -297,38 +193,34 @@ class DuckDbParquetStorageService {
         return this.lastInitError;
     }
     /**
-     * Indicates whether DuckDB/Parquet mode is selected.
+     * Indicates whether node:sqlite mode is selected.
      *
-     * @returns {boolean} True when the selected engine is `duckdb-parquet`.
+     * @returns {boolean} True when the selected engine is `node:sqlite`.
      *
      * @example
-     * if (storage.isDuckDbParquetEnabled()) {
-     *   console.log('DuckDB mode enabled');
+     * if (storage.isSqliteEnabled()) {
+     *   console.log('node:sqlite mode enabled');
      * }
      */
-    isDuckDbParquetEnabled() {
-        return this.config.engine === 'duckdb-parquet';
+    isSqliteEnabled() {
+        return this.config.engine === 'node:sqlite';
     }
     /**
-     * Indicates whether DuckDB/Parquet mode is initialized and ready.
+     * Indicates whether node:sqlite mode is initialized and ready.
      *
-     * @returns {boolean} True when DuckDB mode is selected and an active connection exists.
+     * @returns {boolean} True when node:sqlite mode is selected and an active connection exists.
      *
      * @example
-     * if (storage.isDuckDbParquetReady()) {
-     *   console.log('DuckDB ready');
+     * if (storage.isSqliteReady()) {
+     *   console.log('node:sqlite ready');
      * }
      */
-    isDuckDbParquetReady() {
-        return this.isDuckDbParquetEnabled() && this.initialized && this.connection !== null;
+    isSqliteReady() {
+        return this.isSqliteEnabled() && this.initialized && this.db !== null && this.runtimeAvailable;
     }
     /**
      * Returns the current storage lifecycle token.
      *
-     * The token changes whenever a new initialization attempt starts and can be
-     * used by callers to scope async stop operations (flush/close) so stale work
-     * does not affect a newer startup session.
-     *
      * @returns {number} Current lifecycle token.
      *
      * @example
@@ -347,30 +239,16 @@ class DuckDbParquetStorageService {
      * storage.enqueueSample(sample);
      */
     enqueueSample(sample) {
-        if (!this.isDuckDbParquetReady()) {
+        if (!this.isSqliteReady()) {
             return;
         }
         this.pendingRows.push(sample);
-        const rangeKey = sample.seriesId;
-        const existing = this.pendingRangesBySeriesId.get(rangeKey);
-        if (!existing) {
-            this.pendingRangesBySeriesId.set(rangeKey, {
-                seriesId: sample.seriesId,
-                minTs: sample.timestamp,
-                maxTs: sample.timestamp
-            });
-            return;
-        }
-        this.pendingRangesBySeriesId.set(rangeKey, {
-            seriesId: existing.seriesId,
-            minTs: Math.min(existing.minTs, sample.timestamp),
-            maxTs: Math.max(existing.maxTs, sample.timestamp)
-        });
     }
     /**
-     * Flushes queued samples into DuckDB and exports changed ranges to Parquet chunks.
+     * Flushes queued samples into node:sqlite.
      *
-     * @returns {Promise<{inserted: number; exported: number}>} Number of inserted rows and exported parquet files.
+     * @param {number} [expectedLifecycleToken] Optional lifecycle token guard to skip stale flushes.
+     * @returns {Promise<{ inserted: number; exported: number }>} Number of inserted rows (exported is always 0).
      *
      * @example
      * const result = await storage.flush();
@@ -379,7 +257,7 @@ class DuckDbParquetStorageService {
         if (expectedLifecycleToken !== undefined && expectedLifecycleToken !== this.lifecycleToken) {
             return { inserted: 0, exported: 0 };
         }
-        if (!this.isDuckDbParquetEnabled() || !this.connection || this.pendingRows.length === 0) {
+        if (!this.isSqliteEnabled() || !this.db || this.pendingRows.length === 0) {
             return { inserted: 0, exported: 0 };
         }
         if (this.flushInProgress) {
@@ -387,35 +265,16 @@ class DuckDbParquetStorageService {
         }
         this.flushInProgress = true;
         const rows = this.pendingRows;
-        const ranges = new Map(this.pendingRangesBySeriesId);
         this.pendingRows = [];
-        this.pendingRangesBySeriesId.clear();
         const startedAt = Date.now();
         try {
             await this.insertRows(rows);
-            let exported = 0;
-            for (const range of ranges.values()) {
-                await this.exportSeriesRange(range.seriesId, range.minTs, range.maxTs);
-                exported += 1;
-            }
             const elapsedMs = Date.now() - startedAt;
-            this.logger.debug(`[SERIES STORAGE] flush inserted=${rows.length} exported=${exported} durationMs=${elapsedMs}`);
-            return { inserted: rows.length, exported };
+            this.logger.debug(`[SERIES STORAGE] flush inserted=${rows.length} durationMs=${elapsedMs}`);
+            return { inserted: rows.length, exported: 0 };
         }
         catch (error) {
             this.pendingRows = [...rows, ...this.pendingRows];
-            ranges.forEach((range, rangeKey) => {
-                const current = this.pendingRangesBySeriesId.get(rangeKey);
-                if (!current) {
-                    this.pendingRangesBySeriesId.set(rangeKey, range);
-                    return;
-                }
-                this.pendingRangesBySeriesId.set(rangeKey, {
-                    seriesId: current.seriesId,
-                    minTs: Math.min(current.minTs, range.minTs),
-                    maxTs: Math.max(current.maxTs, range.maxTs)
-                });
-            });
             throw error;
         }
         finally {
@@ -423,7 +282,7 @@ class DuckDbParquetStorageService {
         }
     }
     /**
-     * Returns persisted series definitions from DuckDB.
+     * Returns persisted series definitions from node:sqlite.
      *
      * @returns {Promise<ISeriesDefinition[]>} Stored series definitions.
      *
@@ -431,7 +290,7 @@ class DuckDbParquetStorageService {
      * const series = await storage.getSeriesDefinitions();
      */
     async getSeriesDefinitions() {
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
+        if (!this.isSqliteEnabled() || !this.db) {
             return [];
         }
         const rows = await this.querySql(`
@@ -448,7 +307,8 @@ class DuckDbParquetStorageService {
         retention_duration_ms,
         sample_time,
         enabled,
-        methods_json
+        methods_json,
+        reconcile_ts
       FROM history_series
       ORDER BY series_id ASC
     `);
@@ -465,11 +325,12 @@ class DuckDbParquetStorageService {
             retentionDurationMs: this.toNumberOrUndefined(row.retention_duration_ms),
             sampleTime: this.toNumberOrUndefined(row.sample_time),
             enabled: this.toBoolean(row.enabled),
-            methods: this.parseMethods(row.methods_json)
+            methods: this.parseMethods(row.methods_json),
+            reconcileTs: this.toNumberOrUndefined(row.reconcile_ts)
         }));
     }
     /**
-     * Persists one series definition in DuckDB.
+     * Persists one series definition in node:sqlite.
      *
      * @param {ISeriesDefinition} series Series definition to persist.
      * @returns {Promise<void>}
@@ -478,7 +339,7 @@ class DuckDbParquetStorageService {
      * await storage.upsertSeriesDefinition(series);
      */
     async upsertSeriesDefinition(series) {
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
+        if (!this.isSqliteEnabled() || !this.db) {
             return;
         }
         await this.runSql(`DELETE FROM history_series WHERE series_id = ${this.escape(series.seriesId)}`);
@@ -496,7 +357,8 @@ class DuckDbParquetStorageService {
         retention_duration_ms,
         sample_time,
         enabled,
-        methods_json
+        methods_json,
+        reconcile_ts
       ) VALUES (
         ${this.escape(series.seriesId)},
         ${this.escape(series.datasetUuid)},
@@ -509,13 +371,14 @@ class DuckDbParquetStorageService {
         ${this.nullableNumber(series.period)},
         ${this.nullableNumber(series.retentionDurationMs)},
         ${this.nullableNumber(series.sampleTime)},
-        ${series.enabled === false ? 'FALSE' : 'TRUE'},
-        ${this.nullableString(series.methods ? JSON.stringify(series.methods) : null)}
+        ${series.enabled === false ? '0' : '1'},
+        ${this.nullableString(series.methods ? JSON.stringify(series.methods) : null)},
+        ${this.nullableNumber(series.reconcileTs)}
       )
     `);
     }
     /**
-     * Deletes one persisted series definition in DuckDB.
+     * Deletes one persisted series definition in node:sqlite.
      *
      * @param {string} seriesId Series identifier.
      * @returns {Promise<void>}
@@ -524,11 +387,10 @@ class DuckDbParquetStorageService {
      * await storage.deleteSeriesDefinition('series-1');
      */
     async deleteSeriesDefinition(seriesId) {
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
+        if (!this.isSqliteEnabled() || !this.db) {
             return;
         }
         await this.runSql(`DELETE FROM history_series WHERE series_id = ${this.escape(seriesId)}`);
-        this.deleteParquetSeriesDir(seriesId);
     }
     /**
      * Replaces persisted series definitions with desired set.
@@ -540,7 +402,7 @@ class DuckDbParquetStorageService {
      * await storage.replaceSeriesDefinitions(series);
      */
     async replaceSeriesDefinitions(series) {
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
+        if (!this.isSqliteEnabled() || !this.db) {
             return;
         }
         await this.runSql('DELETE FROM history_series');
@@ -548,6 +410,29 @@ class DuckDbParquetStorageService {
             await this.upsertSeriesDefinition(item);
         }
     }
+    /**
+     * Deletes series not reconciled since the given cutoff timestamp.
+     *
+     * @param {number} cutoffMs Milliseconds since epoch; series with reconcile_ts < cutoffMs will be deleted.
+     * @returns {Promise<number>} Number of deleted series.
+     *
+     * @example
+     * const deleted = await storage.deleteStaleSeries(Date.now() - 180 * 24 * 60 * 60 * 1000);
+     */
+    async deleteStaleSeries(cutoffMs) {
+        if (!this.isSqliteEnabled() || !this.db) {
+            return 0;
+        }
+        const rows = await this.querySql(`
+      SELECT series_id FROM history_series
+      WHERE reconcile_ts IS NULL OR reconcile_ts < ${Math.trunc(cutoffMs)}
+    `);
+        const ids = rows.map(row => row.series_id).filter(Boolean);
+        for (const id of ids) {
+            await this.deleteSeriesDefinition(id);
+        }
+        return ids.length;
+    }
     /**
      * Removes persisted samples that are older than each series retention window.
      *
@@ -562,7 +447,7 @@ class DuckDbParquetStorageService {
         if (expectedLifecycleToken !== undefined && expectedLifecycleToken !== this.lifecycleToken) {
             return 0;
         }
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
+        if (!this.isSqliteEnabled() || !this.db) {
             return 0;
         }
         const anchorMs = Math.trunc(Number.isFinite(nowMs) ? nowMs : Date.now());
@@ -582,7 +467,7 @@ class DuckDbParquetStorageService {
         SELECT rowid
         FROM history_samples
         WHERE ${whereClause}
-        LIMIT ${DuckDbParquetStorageService.PRUNE_BATCH_SIZE}
+        LIMIT ${SqliteHistoryStorageService.PRUNE_BATCH_SIZE}
       `);
             if (batch.length === 0) {
                 break;
@@ -596,7 +481,7 @@ class DuckDbParquetStorageService {
         WHERE rowid IN (${rowIds.join(', ')})
       `);
             removedRows += rowIds.length;
-            if (rowIds.length < DuckDbParquetStorageService.PRUNE_BATCH_SIZE) {
+            if (rowIds.length < SqliteHistoryStorageService.PRUNE_BATCH_SIZE) {
                 break;
             }
         }
@@ -615,7 +500,7 @@ class DuckDbParquetStorageService {
         if (expectedLifecycleToken !== undefined && expectedLifecycleToken !== this.lifecycleToken) {
             return 0;
         }
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
+        if (!this.isSqliteEnabled() || !this.db) {
             return 0;
         }
         const whereClause = `
@@ -631,7 +516,7 @@ class DuckDbParquetStorageService {
         SELECT rowid
         FROM history_samples
         WHERE ${whereClause}
-        LIMIT ${DuckDbParquetStorageService.PRUNE_BATCH_SIZE}
+        LIMIT ${SqliteHistoryStorageService.PRUNE_BATCH_SIZE}
       `);
             if (batch.length === 0) {
                 break;
@@ -645,7 +530,7 @@ class DuckDbParquetStorageService {
         WHERE rowid IN (${rowIds.join(', ')})
       `);
             removedRows += rowIds.length;
-            if (rowIds.length < DuckDbParquetStorageService.PRUNE_BATCH_SIZE) {
+            if (rowIds.length < SqliteHistoryStorageService.PRUNE_BATCH_SIZE) {
                 break;
             }
         }
@@ -654,13 +539,14 @@ class DuckDbParquetStorageService {
     /**
      * Lists known history paths from persisted samples.
      *
+     * @param {IHistoryRangeQuery} [query] Optional range filter.
      * @returns {Promise<string[]>} Ordered path names.
      *
      * @example
      * const paths = await storage.getStoredPaths();
      */
     async getStoredPaths(query) {
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
+        if (!this.isSqliteEnabled() || !this.db) {
             return [];
         }
         const nowMs = Date.now();
@@ -678,13 +564,14 @@ class DuckDbParquetStorageService {
     /**
      * Lists known history contexts from persisted samples.
      *
+     * @param {IHistoryRangeQuery} [query] Optional range filter.
      * @returns {Promise<string[]>} Ordered context names.
      *
      * @example
      * const contexts = await storage.getStoredContexts();
      */
     async getStoredContexts(query) {
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
+        if (!this.isSqliteEnabled() || !this.db) {
             return [];
         }
         const nowMs = Date.now();
@@ -700,16 +587,16 @@ class DuckDbParquetStorageService {
         return rows.map(row => row.value).filter(Boolean);
     }
     /**
-     * Queries history values directly from DuckDB in History API-compatible shape.
+     * Queries history values directly from node:sqlite in History API-compatible shape.
      *
      * @param {IHistoryQueryParams} query Incoming history values query parameters.
-     * @returns {Promise<IHistoryValuesResponse | null>} History payload when DuckDB is ready, otherwise null.
+     * @returns {Promise<IHistoryValuesResponse | null>} History payload when node:sqlite is ready, otherwise null.
      *
      * @example
      * const result = await storage.getValues({ paths: 'navigation.speedOverGround:avg', duration: 'PT1H' });
      */
     async getValues(query) {
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
+        if (!this.isSqliteEnabled() || !this.db) {
             return null;
         }
         const nowMs = Date.now();
@@ -753,6 +640,7 @@ class DuckDbParquetStorageService {
     /**
      * Closes open storage resources.
      *
+     * @param {number} [expectedLifecycleToken] Optional lifecycle token guard to skip stale closes.
      * @returns {Promise<void>}
      *
      * @example
@@ -763,64 +651,174 @@ class DuckDbParquetStorageService {
             return;
         }
         this.initialized = false;
+        this.stopVacuumJob();
         this.stopPruneJob();
         this.stopStaleSeriesCleanupJob();
-        if (!this.connection) {
-            this.db = null;
+        if (!this.db) {
             return;
         }
-        const connection = this.connection;
         const db = this.db;
-        this.connection = null;
+        this.db = null;
         try {
-            connection.disconnectSync();
+            db.close();
         }
         catch {
-            // ignore disconnect failures during shutdown
+            // ignore close failures during shutdown
         }
+    }
+    async loadSqliteModule() {
         try {
-            db?.closeSync();
+            return await Promise.resolve().then(() => __importStar(require('node:sqlite')));
         }
         catch {
-            // ignore close failures during shutdown
+            return null;
+        }
+    }
+    startVacuumJob() {
+        this.stopVacuumJob();
+        if (!this.isSqliteReady())
+            return;
+        this.vacuumJob = setInterval(() => {
+            if (this.shouldSkipMaintenance()) {
+                return;
+            }
+            void this.runWithMaintenanceLock('vacuum', async () => {
+                this.logger.debug('[SERIES STORAGE] Running scheduled node:sqlite VACUUM');
+                await this.runSql('VACUUM;');
+                await this.runSql('PRAGMA optimize;');
+            }).catch(err => {
+                this.logger.error(`[SERIES STORAGE] VACUUM failed: ${err?.message ?? err}`);
+            });
+        }, SqliteHistoryStorageService.EIGHT_HOURS_INTERVAL);
+        this.vacuumJob.unref?.();
+    }
+    stopVacuumJob() {
+        if (this.vacuumJob) {
+            clearInterval(this.vacuumJob);
+            this.vacuumJob = null;
+        }
+    }
+    startPruneJob() {
+        this.stopPruneJob();
+        if (!this.isSqliteReady())
+            return;
+        this.pruneJob = setInterval(async () => {
+            if (this.shouldSkipMaintenance()) {
+                return;
+            }
+            try {
+                await this.runWithMaintenanceLock('prune', async () => {
+                    this.logger.debug('[SERIES STORAGE] Running scheduled prune of expired and orphaned samples');
+                    const expired = await this.pruneExpiredSamples(Date.now(), this.lifecycleToken);
+                    const orphaned = await this.pruneOrphanedSamples(this.lifecycleToken);
+                    this.logger.debug(`[SERIES STORAGE] Pruned ${expired} expired and ${orphaned} orphaned samples`);
+                });
+            }
+            catch (err) {
+                this.logger.error(`[SERIES STORAGE] Prune failed: ${err?.message ?? err}`);
+            }
+        }, SqliteHistoryStorageService.FOUR_HOURS_INTERVAL);
+        this.pruneJob.unref?.();
+    }
+    stopPruneJob() {
+        if (this.pruneJob) {
+            clearInterval(this.pruneJob);
+            this.pruneJob = null;
+        }
+    }
+    startStaleSeriesCleanupJob() {
+        this.stopStaleSeriesCleanupJob();
+        if (!this.isSqliteReady())
+            return;
+        this.staleSeriesCleanupJob = setInterval(async () => {
+            if (this.shouldSkipMaintenance()) {
+                return;
+            }
+            try {
+                await this.runWithMaintenanceLock('stale-cleanup', async () => {
+                    const cutoff = Date.now() - SqliteHistoryStorageService.STALE_SERIES_AGE_MS;
+                    this.logger.debug(`[SERIES STORAGE] Running scheduled stale series cleanup (cutoff: ${new Date(cutoff).toISOString()})`);
+                    const deleted = await this.deleteStaleSeries(cutoff);
+                    if (deleted > 0) {
+                        this.logger.debug(`[SERIES STORAGE] Deleted ${deleted} series not reconciled in the last 6 months`);
+                    }
+                });
+            }
+            catch (err) {
+                this.logger.error(`[SERIES STORAGE] Stale series cleanup failed: ${err?.message ?? err}`);
+            }
+        }, SqliteHistoryStorageService.EIGHT_HOURS_INTERVAL);
+        this.staleSeriesCleanupJob.unref?.();
+    }
+    stopStaleSeriesCleanupJob() {
+        if (this.staleSeriesCleanupJob) {
+            clearInterval(this.staleSeriesCleanupJob);
+            this.staleSeriesCleanupJob = null;
+        }
+    }
+    shouldSkipMaintenance() {
+        if (!this.isSqliteReady() || !this.db) {
+            return true;
+        }
+        if (this.maintenanceInProgress || this.flushInProgress) {
+            return true;
+        }
+        if (this.pendingRows.length > 0) {
+            return true;
+        }
+        return false;
+    }
+    async runWithMaintenanceLock(label, task) {
+        if (this.maintenanceInProgress) {
+            this.logger.debug(`[SERIES STORAGE] Skipping ${label} (maintenance already running)`);
+            return;
+        }
+        this.maintenanceInProgress = true;
+        const startedAt = Date.now();
+        try {
+            await task();
+            const elapsedMs = Date.now() - startedAt;
+            this.logger.debug(`[SERIES STORAGE] ${label} completed in ${elapsedMs}ms`);
+        }
+        finally {
+            this.maintenanceInProgress = false;
         }
-        this.db = null;
     }
     async createCoreTables() {
         await this.runSql(`
       CREATE TABLE IF NOT EXISTS history_samples (
-        series_id VARCHAR,
-        dataset_uuid VARCHAR,
-        owner_widget_uuid VARCHAR,
-        path VARCHAR,
-        context VARCHAR,
-        source VARCHAR,
-        ts_ms BIGINT,
-        value DOUBLE
+        series_id TEXT,
+        dataset_uuid TEXT,
+        owner_widget_uuid TEXT,
+        path TEXT,
+        context TEXT,
+        source TEXT,
+        ts_ms INTEGER,
+        value REAL
       )
     `);
         await this.runSql(`
       CREATE TABLE IF NOT EXISTS history_series (
-        series_id VARCHAR NOT NULL,
-        dataset_uuid VARCHAR NOT NULL,
-        owner_widget_uuid VARCHAR NOT NULL,
-        owner_widget_selector VARCHAR,
-        path VARCHAR NOT NULL,
-        source VARCHAR,
-        context VARCHAR,
-        time_scale VARCHAR,
+        series_id TEXT NOT NULL,
+        dataset_uuid TEXT NOT NULL,
+        owner_widget_uuid TEXT NOT NULL,
+        owner_widget_selector TEXT,
+        path TEXT NOT NULL,
+        source TEXT,
+        context TEXT,
+        time_scale TEXT,
         period INTEGER,
-        retention_duration_ms BIGINT,
+        retention_duration_ms INTEGER,
         sample_time INTEGER,
-        enabled BOOLEAN,
-        methods_json VARCHAR,
-        reconcile_ts BIGINT,
+        enabled INTEGER,
+        methods_json TEXT,
+        reconcile_ts INTEGER,
         PRIMARY KEY (series_id)
       )
     `);
     }
     async insertRows(rows) {
-        if (rows.length === 0) {
+        if (!this.db || rows.length === 0) {
             return;
         }
         const valuesSql = rows
@@ -838,196 +836,28 @@ class DuckDbParquetStorageService {
         value
       ) VALUES ${valuesSql}
     `;
-        await this.runSql(sql);
-    }
-    async exportSeriesRange(seriesId, fromMs, toMs) {
-        const windowMs = this.resolveParquetWindowMs();
-        const baseDir = (0, path_1.resolve)(this.config.parquetDirectory);
-        const seriesDir = (0, path_1.join)(baseDir, this.safePath(seriesId));
-        (0, fs_1.mkdirSync)(seriesDir, { recursive: true });
-        const startWindow = Math.floor(fromMs / windowMs) * windowMs;
-        const endWindow = Math.floor(toMs / windowMs) * windowMs;
-        for (let windowStart = startWindow; windowStart <= endWindow; windowStart += windowMs) {
-            const windowEnd = windowStart + windowMs - 1;
-            const filePath = (0, path_1.join)(seriesDir, `${windowStart}-${windowEnd}.parquet`);
-            const rows = await this.querySql(`
-        SELECT
-          series_id,
-          dataset_uuid,
-          owner_widget_uuid,
-          path,
-          context,
-          source,
-          ts_ms,
-          value
-        FROM history_samples
-        WHERE series_id = ${this.escape(seriesId)}
-          AND ts_ms >= ${Math.trunc(windowStart)}
-          AND ts_ms <= ${Math.trunc(windowEnd)}
-        ORDER BY ts_ms
-      `);
-            if (rows.length === 0) {
-                (0, fs_1.rmSync)(filePath, { force: true });
-                continue;
-            }
-            const compression = this.resolveParquetCompression();
-            const schema = new parquetjs_1.ParquetSchema({
-                series_id: { type: 'UTF8', compression },
-                dataset_uuid: { type: 'UTF8', compression },
-                owner_widget_uuid: { type: 'UTF8', compression },
-                path: { type: 'UTF8', compression },
-                context: { type: 'UTF8', compression },
-                source: { type: 'UTF8', optional: true, compression },
-                ts_ms: { type: 'INT64', compression },
-                ts: { type: 'TIMESTAMP_MILLIS', compression },
-                value: { type: 'DOUBLE', compression }
-            });
-            const tempPath = `${filePath}.tmp-${Date.now()}`;
-            const writer = await parquetjs_1.ParquetWriter.openFile(schema, tempPath);
-            try {
-                for (const row of rows) {
-                    const timestampMs = this.toNumberOrUndefined(row.ts_ms);
-                    const numericValue = this.toNumberOrUndefined(row.value);
-                    if (timestampMs === undefined || numericValue === undefined) {
-                        continue;
-                    }
-                    await writer.appendRow({
-                        series_id: row.series_id,
-                        dataset_uuid: row.dataset_uuid,
-                        owner_widget_uuid: row.owner_widget_uuid,
-                        path: row.path,
-                        context: row.context,
-                        source: row.source ?? undefined,
-                        ts_ms: Math.trunc(timestampMs),
-                        ts: new Date(timestampMs),
-                        value: numericValue
-                    });
-                }
-            }
-            finally {
-                await writer.close();
-            }
-            (0, fs_1.rmSync)(filePath, { force: true });
-            (0, fs_1.renameSync)(tempPath, filePath);
-        }
-    }
-    resolveParquetWindowMs() {
-        const parsed = Number(this.config.parquetWindowMs);
-        if (Number.isFinite(parsed) && parsed > 0) {
-            return Math.max(1, Math.trunc(parsed));
-        }
-        return 60 * 60_000;
-    }
-    resolveParquetCompression() {
-        const raw = String(this.config.parquetCompression ?? 'none').trim().toLowerCase();
-        if (raw === 'snappy') {
-            return 'SNAPPY';
-        }
-        if (raw === 'gzip') {
-            return 'GZIP';
-        }
-        if (raw === 'brotli') {
-            return 'BROTLI';
-        }
-        if (raw === 'lz4') {
-            return 'LZ4';
-        }
-        if (raw === 'lzo') {
-            return 'LZO';
-        }
-        return undefined;
-    }
-    pruneParquetFilesByRetention(nowMs) {
-        if (!this.isDuckDbParquetEnabled() || !this.connection) {
-            return Promise.resolve(0);
-        }
-        return this.querySql(`
-      SELECT series_id, retention_duration_ms
-      FROM history_series
-    `).then(rows => {
-            const baseDir = (0, path_1.resolve)(this.config.parquetDirectory);
-            const seriesConfig = new Map(rows.map(row => [this.safePath(row.series_id), row.retention_duration_ms]));
-            let removed = 0;
-            let seriesDirs = [];
-            try {
-                seriesDirs = (0, fs_1.readdirSync)(baseDir);
-            }
-            catch {
-                return 0;
-            }
-            for (const dirName of seriesDirs) {
-                const fullDir = (0, path_1.join)(baseDir, dirName);
-                let dirStat;
-                try {
-                    dirStat = (0, fs_1.statSync)(fullDir);
-                }
-                catch {
-                    continue;
-                }
-                if (!dirStat.isDirectory()) {
-                    continue;
-                }
-                const seriesKey = dirName;
-                if (!seriesConfig.has(seriesKey)) {
-                    (0, fs_1.rmSync)(fullDir, { recursive: true, force: true });
-                    removed += 1;
-                    continue;
-                }
-                const retentionMs = seriesConfig.get(seriesKey);
-                if (!Number.isFinite(retentionMs) || (retentionMs ?? 0) <= 0) {
-                    continue;
-                }
-                const cutoff = nowMs - Number(retentionMs);
-                let files = [];
-                try {
-                    files = (0, fs_1.readdirSync)(fullDir);
-                }
-                catch {
-                    continue;
-                }
-                files.forEach(fileName => {
-                    const range = this.parseParquetRangeFromFileName(fileName);
-                    if (!range) {
-                        return;
-                    }
-                    if (range.toMs < cutoff) {
-                        (0, fs_1.rmSync)((0, path_1.join)(fullDir, fileName), { force: true });
-                        removed += 1;
-                    }
-                });
-            }
-            return removed;
-        });
-    }
-    parseParquetRangeFromFileName(fileName) {
-        const match = /^([0-9]+)-([0-9]+)\.parquet$/.exec(fileName);
-        if (!match) {
-            return null;
+        this.db.exec('BEGIN');
+        try {
+            await this.runSql(sql);
+            this.db.exec('COMMIT');
         }
-        const fromMs = Number(match[1]);
-        const toMs = Number(match[2]);
-        if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) {
-            return null;
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
         }
-        return { fromMs, toMs };
-    }
-    deleteParquetSeriesDir(seriesId) {
-        const baseDir = (0, path_1.resolve)(this.config.parquetDirectory);
-        const seriesDir = (0, path_1.join)(baseDir, this.safePath(seriesId));
-        (0, fs_1.rmSync)(seriesDir, { recursive: true, force: true });
     }
     async runSql(sql) {
-        if (!this.connection) {
-            throw new Error('DuckDB connection is not initialized');
+        if (!this.db) {
+            throw new Error('node:sqlite database is not initialized');
         }
-        await this.connection.run(sql);
+        this.db.exec(sql);
     }
     async querySql(sql) {
-        if (!this.connection) {
-            throw new Error('DuckDB connection is not initialized');
+        if (!this.db) {
+            throw new Error('node:sqlite database is not initialized');
         }
-        const result = await this.connection.runAndReadAll(sql);
-        return result.getRowObjectsJson();
+        const statement = this.db.prepare(sql);
+        return statement.all();
     }
     async selectRowsForPaths(paths, context, fromMs, toMs) {
         const rowsByPath = new Map();
@@ -1234,9 +1064,6 @@ class DuckDbParquetStorageService {
         const sum = values.reduce((acc, value) => acc + value, 0);
         return sum / values.length;
     }
-    safePath(value) {
-        return value.replace(/[^a-zA-Z0-9._-]/g, '_');
-    }
     escape(value) {
         return `'${String(value).replace(/'/g, "''")}'`;
     }
@@ -1298,4 +1125,4 @@ class DuckDbParquetStorageService {
         return Boolean(value);
     }
 }
-exports.DuckDbParquetStorageService = DuckDbParquetStorageService;
+exports.SqliteHistoryStorageService = SqliteHistoryStorageService;