@camstack/system 1.0.2

package/dist/builtins/sqlite-storage/sqlite-settings.addon.js

@@ -0,0 +1,644 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_chunk = require("../../chunk-Cek0wNdY.js");
+let _camstack_types = require("@camstack/types");
+let node_crypto = require("node:crypto");
+let better_sqlite3 = require("better-sqlite3");
+better_sqlite3 = require_chunk.__toESM(better_sqlite3);
+//#region src/builtins/sqlite-storage/sqlite-settings-backend.ts
+function parseRowData(raw) {
+	return (0, _camstack_types.asJsonObject)((0, _camstack_types.parseJsonUnknown)(raw)) ?? {};
+}
+/**
+* SQLite implementation of ISettingsBackend.
+*
+* Every collection is structured: declared at boot (canonical KV
+* collections) or via `declareCollection` (typed schemas like
+* `pipeline-analytics:tracks`). The legacy auto-create-on-first-access
+* path was removed — see commit history for the migration. Operations
+* on undeclared collections throw at runtime so callers fail fast.
+*
+* WAL mode for concurrent reads.
+*/
+var SqliteSettingsBackend = class SqliteSettingsBackend {
+	dbPath;
+	db = null;
+	structuredTables = /* @__PURE__ */ new Set();
+	/** Map from scoped collection name → set of column names (non-id) that
+	*  the structured schema owns. Routes set/get/insert/update/query to
+	*  typed columns. Every collection MUST be declared here before use. */
+	declaredCollections = /* @__PURE__ */ new Map();
+	runtimeDefaults;
+	/**
+	* Canonical key/value collections — declared with a `(id TEXT PK,
+	* data TEXT NOT NULL)` schema at boot so existing JSON-blob rows
+	* keep working through the structured path. Generates SQL identical
+	* to the previous legacy path; only the routing is unified.
+	*/
+	static CANONICAL_KV_COLLECTIONS = [
+		"system-settings",
+		"addon-settings",
+		"addon-device-settings",
+		"addon-devices",
+		"device-runtime-state",
+		"sections",
+		"provider-settings",
+		"device-settings",
+		"alerts"
+	];
+	constructor(dbPath, runtimeDefaults) {
+		this.dbPath = dbPath;
+		this.runtimeDefaults = runtimeDefaults ?? {};
+	}
+	async initialize() {
+		const dir = this.dbPath.substring(0, this.dbPath.lastIndexOf("/"));
+		if (dir) (await import("node:fs")).mkdirSync(dir, { recursive: true });
+		this.db = new better_sqlite3.default(this.dbPath);
+		this.db.pragma("journal_mode = WAL");
+		this.db.pragma("foreign_keys = ON");
+		for (const collection of SqliteSettingsBackend.CANONICAL_KV_COLLECTIONS) {
+			await this.ensureTable(collection, { columns: [{
+				name: "id",
+				type: "TEXT",
+				primaryKey: true,
+				notNull: true
+			}, {
+				name: "data",
+				type: "TEXT",
+				notNull: true
+			}] });
+			this.declaredCollections.set(collection, {
+				primaryKey: "id",
+				columns: new Set(["data"]),
+				booleanColumns: /* @__PURE__ */ new Set()
+			});
+		}
+		if (await this.isEmpty({ collection: "system-settings" })) await this.seedDefaults();
+	}
+	requireDeclared(scoped) {
+		const cached = this.declaredCollections.get(scoped);
+		if (cached) return cached;
+		const colonIdx = scoped.indexOf(":");
+		if (colonIdx > 0) {
+			const baseCollection = scoped.slice(colonIdx + 1);
+			if (SqliteSettingsBackend.CANONICAL_KV_COLLECTIONS.includes(baseCollection)) {
+				this.getDb().exec(`CREATE TABLE IF NOT EXISTS "${scoped}" (id TEXT PRIMARY KEY NOT NULL, data TEXT NOT NULL)`);
+				const decl = {
+					primaryKey: "id",
+					columns: new Set(["data"]),
+					booleanColumns: /* @__PURE__ */ new Set()
+				};
+				this.declaredCollections.set(scoped, decl);
+				return decl;
+			}
+		}
+		throw new Error(`SqliteSettingsBackend: collection "${scoped}" is not declared. Call declareCollection() first or add it to CANONICAL_KV_COLLECTIONS.`);
+	}
+	/**
+	* Decode a single column value off a SQLite row into the JS shape the
+	* caller's schema expects. Handles:
+	*   - BOOLEAN columns: `0|1` → `false|true`
+	*   - JSON columns (TEXT starting with `{` / `[`): parse
+	*   - everything else: pass-through with null coalescing
+	*/
+	decodeColumnValue(value, columnName, booleanColumns) {
+		if (booleanColumns.has(columnName)) {
+			if (value === null || value === void 0) return value ?? null;
+			return value !== 0 && value !== "0" && value !== false;
+		}
+		if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+		return value ?? null;
+	}
+	async shutdown() {
+		this.db?.close();
+		this.db = null;
+	}
+	async get({ namespace, collection, key }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const cols = [`"${decl.primaryKey}"`, ...[...decl.columns].map((c) => `"${c}"`)].join(", ");
+		const row = this.getDb().prepare(`SELECT ${cols} FROM "${scoped}" WHERE "${decl.primaryKey}" = ?`).get(key);
+		if (!row) return void 0;
+		if (decl.columns.size === 1 && decl.columns.has("data")) {
+			const raw = row["data"];
+			return typeof raw === "string" ? JSON.parse(raw) : raw;
+		}
+		const data = {};
+		for (const c of decl.columns) data[c] = this.decodeColumnValue(row[c], c, decl.booleanColumns);
+		return data;
+	}
+	async set({ namespace, collection, key, value }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const row = { [decl.primaryKey]: key };
+		if (decl.columns.size === 1 && decl.columns.has("data")) row["data"] = JSON.stringify(value);
+		else {
+			const valueObj = value !== null && typeof value === "object" ? value : {};
+			for (const [k, v] of Object.entries(valueObj)) if (decl.columns.has(k)) row[k] = this.serializeColumnValue(v);
+		}
+		const keys = Object.keys(row);
+		const cols = keys.map((k) => `"${k}"`).join(", ");
+		const placeholders = keys.map(() => "?").join(", ");
+		const updates = keys.filter((k) => k !== decl.primaryKey).map((k) => `"${k}" = excluded."${k}"`).join(", ");
+		const values = keys.map((k) => row[k]);
+		const sql = updates.length > 0 ? `INSERT INTO "${scoped}" (${cols}) VALUES (${placeholders}) ON CONFLICT("${decl.primaryKey}") DO UPDATE SET ${updates}` : `INSERT INTO "${scoped}" (${cols}) VALUES (${placeholders}) ON CONFLICT("${decl.primaryKey}") DO NOTHING`;
+		this.getDb().prepare(sql).run(...values);
+	}
+	async query({ namespace, collection, filter }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		return this.queryDeclared(scoped, decl, filter);
+	}
+	async insert({ namespace, collection, record }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const id = record.id || (0, node_crypto.randomUUID)();
+		const row = { [decl.primaryKey]: id };
+		if (decl.columns.size === 1 && decl.columns.has("data")) row["data"] = JSON.stringify(record.data);
+		else for (const [k, v] of Object.entries(record.data)) if (decl.columns.has(k)) row[k] = this.serializeColumnValue(v);
+		await this.tableInsert(scoped, row);
+	}
+	async update({ namespace, collection, id, data }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const updates = {};
+		if (decl.columns.size === 1 && decl.columns.has("data")) updates["data"] = JSON.stringify(data);
+		else for (const [k, v] of Object.entries(data)) if (decl.columns.has(k)) updates[k] = this.serializeColumnValue(v);
+		if (Object.keys(updates).length > 0) await this.tableUpdate(scoped, { [decl.primaryKey]: id }, updates);
+	}
+	async delete({ namespace, collection, key }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		await this.tableDelete(scoped, { [decl.primaryKey]: key });
+	}
+	async count({ namespace, collection, filter }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const isKvShape = decl.columns.size === 1 && decl.columns.has("data");
+		const isColumn = (f) => f === decl.primaryKey || decl.columns.has(f);
+		const fieldExpr = (f) => {
+			if (isColumn(f)) return `"${f}"`;
+			if (isKvShape) return `json_extract("data", '$.${f}')`;
+			return "";
+		};
+		let sql = `SELECT COUNT(*) AS cnt FROM "${scoped}"`;
+		const params = [];
+		if (filter?.where) {
+			const clauses = [];
+			for (const [field, value] of Object.entries(filter.where)) {
+				const expr = fieldExpr(field);
+				if (!expr) continue;
+				clauses.push(`${expr} = ?`);
+				params.push(this.serializeColumnValue(value));
+			}
+			if (clauses.length > 0) sql += ` WHERE ${clauses.join(" AND ")}`;
+		}
+		return this.getDb().prepare(sql).get(...params)?.cnt ?? 0;
+	}
+	async histogram({ namespace, collection, field, bucketSize, origin, filter }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const isKvShape = decl.columns.size === 1 && decl.columns.has("data");
+		const isColumn = (f) => f === decl.primaryKey || decl.columns.has(f);
+		const fieldExpr = (f) => {
+			if (isColumn(f)) return `"${f}"`;
+			if (isKvShape) return `json_extract("data", '$.${f}')`;
+			return "";
+		};
+		const col = fieldExpr(field);
+		if (!col) return [];
+		const params = [];
+		const clauses = [];
+		if (filter?.where) for (const [f, value] of Object.entries(filter.where)) {
+			const expr = fieldExpr(f);
+			if (!expr) continue;
+			clauses.push(`${expr} = ?`);
+			params.push(this.serializeColumnValue(value));
+		}
+		if (filter?.whereBetween) for (const [f, [lo, hi]] of Object.entries(filter.whereBetween)) {
+			const expr = fieldExpr(f);
+			if (!expr) continue;
+			clauses.push(`${expr} BETWEEN ? AND ?`);
+			params.push(this.serializeColumnValue(lo), this.serializeColumnValue(hi));
+		}
+		const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+		const sql = `SELECT ${`CAST((${col} - ?) / ? AS INTEGER)`} AS bucket, COUNT(*) AS count FROM "${scoped}"${where} GROUP BY bucket ORDER BY bucket`;
+		return this.getDb().prepare(sql).all(origin, bucketSize, ...params).map((r) => ({
+			bucket: r.bucket,
+			count: r.count
+		}));
+	}
+	async isEmpty({ namespace, collection }) {
+		const scoped = this.scopedName(namespace, collection);
+		this.requireDeclared(scoped);
+		return await this.tableCount(scoped) === 0;
+	}
+	async queryDeclared(table, decl, filter) {
+		const isKvShape = decl.columns.size === 1 && decl.columns.has("data");
+		let sql = `SELECT ${[`"${decl.primaryKey}"`, ...[...decl.columns].map((c) => `"${c}"`)].join(", ")} FROM "${table}"`;
+		const params = [];
+		const whereClauses = [];
+		const isColumn = (f) => f === decl.primaryKey || decl.columns.has(f);
+		/**
+		* SQL expression for `field` on this table.
+		*  - real column → `"field"`
+		*  - KV blob field (e.g. `username` inside `data`) → `json_extract`
+		*  - structured table + non-column → empty string (filter dropped,
+		*    matches legacy structured-table behaviour)
+		*/
+		const fieldExpr = (f) => {
+			if (isColumn(f)) return `"${f}"`;
+			if (isKvShape) return `json_extract("data", '$.${f}')`;
+			return "";
+		};
+		if (filter?.where) for (const [field, value] of Object.entries(filter.where)) {
+			const expr = fieldExpr(field);
+			if (!expr) continue;
+			whereClauses.push(`${expr} = ?`);
+			params.push(this.serializeColumnValue(value));
+		}
+		if (filter?.whereIn) for (const [field, values] of Object.entries(filter.whereIn)) {
+			const expr = fieldExpr(field);
+			if (!expr) continue;
+			const placeholders = values.map(() => "?").join(", ");
+			whereClauses.push(`${expr} IN (${placeholders})`);
+			for (const v of values) params.push(this.serializeColumnValue(v));
+		}
+		if (filter?.whereBetween) for (const [field, [low, high]] of Object.entries(filter.whereBetween)) {
+			const expr = fieldExpr(field);
+			if (!expr) continue;
+			whereClauses.push(`${expr} BETWEEN ? AND ?`);
+			params.push(this.serializeColumnValue(low), this.serializeColumnValue(high));
+		}
+		if (whereClauses.length > 0) sql += ` WHERE ${whereClauses.join(" AND ")}`;
+		if (filter?.orderBy) {
+			const expr = fieldExpr(filter.orderBy.field);
+			if (expr) {
+				const dir = filter.orderBy.direction === "desc" ? "DESC" : "ASC";
+				sql += ` ORDER BY ${expr} ${dir}`;
+			}
+		}
+		if (filter?.limit !== void 0) {
+			sql += ` LIMIT ?`;
+			params.push(filter.limit);
+		}
+		if (filter?.offset !== void 0) {
+			sql += ` OFFSET ?`;
+			params.push(filter.offset);
+		}
+		return this.getDb().prepare(sql).all(...params).map((r) => {
+			const id = String(r[decl.primaryKey] ?? "");
+			if (isKvShape) {
+				const v = r["data"];
+				if (typeof v === "string" && (v.startsWith("{") || v.startsWith("["))) try {
+					return {
+						id,
+						data: JSON.parse(v)
+					};
+				} catch {
+					return {
+						id,
+						data: { value: v }
+					};
+				}
+				return {
+					id,
+					data: v == null ? {} : { value: v }
+				};
+			}
+			const data = { [decl.primaryKey]: r[decl.primaryKey] ?? null };
+			for (const c of decl.columns) data[c] = this.decodeColumnValue(r[c], c, decl.booleanColumns);
+			return {
+				id,
+				data
+			};
+		});
+	}
+	/** Get a system setting by dot-notation key */
+	getSystem(key) {
+		this.requireDeclared("system-settings");
+		const row = this.getDb().prepare("SELECT data FROM \"system-settings\" WHERE id = ?").get(key);
+		if (!row) return void 0;
+		return JSON.parse(row.data);
+	}
+	/** Set a system setting */
+	setSystem(key, value) {
+		this.requireDeclared("system-settings");
+		this.getDb().prepare("INSERT INTO \"system-settings\" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data").run(key, JSON.stringify(value));
+	}
+	/** Get all system settings as flat key-value */
+	getAllSystem() {
+		this.requireDeclared("system-settings");
+		const rows = this.getDb().prepare("SELECT id, data FROM \"system-settings\"").all();
+		return Object.fromEntries(rows.map((r) => [r.id, JSON.parse(r.data)]));
+	}
+	/** Get all settings for an addon */
+	getAllAddon(addonId) {
+		this.requireDeclared("addon-settings");
+		const rows = this.getDb().prepare("SELECT id, data FROM \"addon-settings\" WHERE json_extract(data, '$.addonId') = ?").all(addonId);
+		if (rows.length === 0) return {};
+		const result = {};
+		for (const row of rows) {
+			const parsed = parseRowData(row.data);
+			const key = row.id.startsWith(`${addonId}.`) ? row.id.slice(addonId.length + 1) : row.id;
+			if (parsed !== null && typeof parsed === "object" && "addonId" in parsed && "key" in parsed) {
+				const wrapper = parsed;
+				if ("value" in wrapper) result[key] = wrapper.value;
+			} else result[key] = parsed;
+		}
+		return result;
+	}
+	/** Bulk-set all settings for an addon */
+	setAllAddon(addonId, config) {
+		this.requireDeclared("addon-settings");
+		const db = this.getDb();
+		const deleteStmt = db.prepare("DELETE FROM \"addon-settings\" WHERE id LIKE ? || '%'");
+		const insertStmt = db.prepare("INSERT INTO \"addon-settings\" (id, data) VALUES (?, ?)");
+		db.transaction(() => {
+			deleteStmt.run(`${addonId}.`);
+			for (const [key, value] of Object.entries(config)) {
+				if (value === void 0) continue;
+				insertStmt.run(`${addonId}.${key}`, JSON.stringify({
+					addonId,
+					key,
+					value
+				}));
+			}
+		})();
+	}
+	/** Get all settings for a provider */
+	getAllProvider(providerId) {
+		return this.getAllScoped("provider-settings", providerId);
+	}
+	/** Set a provider setting */
+	setProvider(providerId, key, value) {
+		this.setScopedKey("provider-settings", providerId, key, value);
+	}
+	/** Get all settings for a device */
+	getAllDevice(deviceId) {
+		return this.getAllScoped("device-settings", deviceId);
+	}
+	/** Set a device setting */
+	setDevice(deviceId, key, value) {
+		this.setScopedKey("device-settings", deviceId, key, value);
+	}
+	getAddonDevice(addonId, deviceId) {
+		return this.getAllScoped("addon-device-settings", `${addonId}:${deviceId}`);
+	}
+	setAddonDevice(addonId, deviceId, values) {
+		this.requireDeclared("addon-device-settings");
+		const db = this.getDb();
+		const prefix = `${addonId}:${deviceId}.`;
+		const deleteStmt = db.prepare(`DELETE FROM "addon-device-settings" WHERE id LIKE ? || '%'`);
+		const insertStmt = db.prepare(`INSERT INTO "addon-device-settings" (id, data) VALUES (?, ?)
+       ON CONFLICT(id) DO UPDATE SET data = excluded.data`);
+		db.transaction(() => {
+			deleteStmt.run(prefix);
+			for (const [key, value] of Object.entries(values)) insertStmt.run(`${prefix}${key}`, JSON.stringify({
+				addonId,
+				deviceId,
+				key,
+				value
+			}));
+		})();
+	}
+	clearAddonDevice(addonId, deviceId) {
+		this.requireDeclared("addon-device-settings");
+		const prefix = `${addonId}:${deviceId}.`;
+		this.getDb().prepare(`DELETE FROM "addon-device-settings" WHERE id LIKE ? || '%'`).run(prefix);
+	}
+	/** Seed system-settings with runtime defaults (first boot) */
+	async seedDefaults() {
+		this.requireDeclared("system-settings");
+		const insert = this.getDb().prepare("INSERT OR IGNORE INTO \"system-settings\" (id, data) VALUES (?, ?)");
+		this.getDb().transaction(() => {
+			for (const [key, value] of Object.entries(this.runtimeDefaults)) insert.run(key, JSON.stringify(value));
+		})();
+	}
+	/**
+	* Expose the raw better-sqlite3 Database instance for components that
+	* need direct SQL access (e.g. DeviceStore, ConfigStore).
+	* Returns null if the backend has not been initialized yet.
+	*/
+	getDatabase() {
+		return this.db;
+	}
+	getDb() {
+		if (!this.db) throw new Error("SqliteSettingsBackend not initialized — call initialize() first");
+		return this.db;
+	}
+	getAllScoped(collection, scopeId) {
+		this.requireDeclared(collection);
+		const rows = this.getDb().prepare(`SELECT id, data FROM "${collection}" WHERE id LIKE ? || '.%'`).all(scopeId);
+		const result = {};
+		for (const row of rows) {
+			const key = row.id.slice(scopeId.length + 1);
+			const parsed = parseRowData(row.data);
+			result[key] = parsed.value ?? parsed;
+		}
+		return result;
+	}
+	setScopedKey(collection, scopeId, key, value) {
+		this.requireDeclared(collection);
+		this.getDb().prepare(`INSERT INTO "${collection}" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`).run(`${scopeId}.${key}`, JSON.stringify({
+			scopeId,
+			key,
+			value
+		}));
+	}
+	scopedName(namespace, collection) {
+		return namespace ? `${namespace}:${collection}` : collection;
+	}
+	async declareCollection(input) {
+		const table = this.scopedName(input.namespace, input.collection);
+		if (this.declaredCollections.has(table)) return;
+		const columns = input.columns.some((c) => c.primaryKey === true) ? input.columns : [{
+			name: "id",
+			type: "TEXT",
+			primaryKey: true,
+			notNull: true
+		}, ...input.columns];
+		const schema = {
+			columns: columns.map((c) => ({
+				name: c.name,
+				type: c.type === "JSON" ? "TEXT" : c.type === "BOOLEAN" ? "INTEGER" : c.type,
+				...c.primaryKey !== void 0 ? { primaryKey: c.primaryKey } : {},
+				...c.notNull !== void 0 ? { notNull: c.notNull } : {},
+				...c.unique !== void 0 ? { unique: c.unique } : {}
+			})),
+			...input.indexes ? { indexes: input.indexes.map((i) => ({
+				name: i.name,
+				columns: i.columns,
+				...i.unique !== void 0 ? { unique: i.unique } : {}
+			})) } : {}
+		};
+		await this.ensureTable(table, schema);
+		const pkCol = columns.find((c) => c.primaryKey === true);
+		const primaryKey = pkCol ? pkCol.name : "id";
+		const columnNames = new Set(columns.filter((c) => c.name !== primaryKey).map((c) => c.name));
+		const booleanColumns = new Set(columns.filter((c) => c.type === "BOOLEAN").map((c) => c.name));
+		this.declaredCollections.set(table, {
+			primaryKey,
+			columns: columnNames,
+			booleanColumns
+		});
+	}
+	/** Serialise per-column values for SQL binding: objects → JSON, booleans → 0/1. */
+	serializeColumnValue(v) {
+		if (v === null || v === void 0) return v ?? null;
+		if (typeof v === "boolean") return v ? 1 : 0;
+		if (typeof v === "object") return JSON.stringify(v);
+		return v;
+	}
+	async ensureTable(table, schema) {
+		if (this.structuredTables.has(table)) return;
+		const colDefs = schema.columns.map((col) => {
+			const parts = [`"${col.name}" ${col.type}`];
+			if (col.primaryKey) parts.push("PRIMARY KEY");
+			if (col.notNull) parts.push("NOT NULL");
+			if (col.unique) parts.push("UNIQUE");
+			if (col.defaultValue !== void 0) parts.push(`DEFAULT ${typeof col.defaultValue === "string" ? `'${col.defaultValue}'` : col.defaultValue === null ? "NULL" : String(col.defaultValue)}`);
+			return parts.join(" ");
+		});
+		const existingCols = this.getDb().prepare(`PRAGMA table_info("${table}")`).all();
+		if (existingCols.length > 0) {
+			const existingNames = new Set(existingCols.map((c) => c.name));
+			const declaredNames = new Set(schema.columns.map((c) => c.name));
+			const missingDeclared = schema.columns.some((c) => !existingNames.has(c.name));
+			if (existingCols.length <= 2 && existingNames.has("data") && !declaredNames.has("data") || missingDeclared) try {
+				this.getDb().exec(`DROP TABLE "${table}"`);
+			} catch {}
+		}
+		this.getDb().exec(`CREATE TABLE IF NOT EXISTS "${table}" (${colDefs.join(", ")})`);
+		if (schema.indexes) for (const idx of schema.indexes) {
+			const unique = idx.unique ? "UNIQUE " : "";
+			const cols = idx.columns.map((c) => `"${c}"`).join(", ");
+			this.getDb().exec(`CREATE ${unique}INDEX IF NOT EXISTS "${idx.name}" ON "${table}" (${cols})`);
+		}
+		this.structuredTables.add(table);
+	}
+	async tableInsert(table, row) {
+		const keys = Object.keys(row);
+		const cols = keys.map((k) => `"${k}"`).join(", ");
+		const placeholders = keys.map(() => "?").join(", ");
+		const values = keys.map((k) => {
+			const v = row[k];
+			return typeof v === "object" && v !== null ? JSON.stringify(v) : v;
+		});
+		this.getDb().prepare(`INSERT INTO "${table}" (${cols}) VALUES (${placeholders})`).run(...values);
+	}
+	async tableUpdate(table, filter, updates) {
+		const setClauses = [];
+		const setValues = [];
+		for (const [k, v] of Object.entries(updates)) {
+			setClauses.push(`"${k}" = ?`);
+			setValues.push(typeof v === "object" && v !== null ? JSON.stringify(v) : v);
+		}
+		const { whereSql, whereValues } = this.buildWhere(filter);
+		return this.getDb().prepare(`UPDATE "${table}" SET ${setClauses.join(", ")}${whereSql}`).run(...setValues, ...whereValues).changes;
+	}
+	async tableDelete(table, filter) {
+		const { whereSql, whereValues } = this.buildWhere(filter);
+		return this.getDb().prepare(`DELETE FROM "${table}"${whereSql}`).run(...whereValues).changes;
+	}
+	async tableQuery(table, options) {
+		let sql = `SELECT * FROM "${table}"`;
+		const values = [];
+		if (options?.where) {
+			const { whereSql, whereValues } = this.buildWhere(options.where);
+			sql += whereSql;
+			values.push(...whereValues);
+		}
+		if (options?.orderBy) sql += ` ORDER BY "${options.orderBy.field}" ${options.orderBy.direction === "desc" ? "DESC" : "ASC"}`;
+		if (options?.limit !== void 0) {
+			sql += ` LIMIT ?`;
+			values.push(options.limit);
+		}
+		if (options?.offset !== void 0) {
+			sql += ` OFFSET ?`;
+			values.push(options.offset);
+		}
+		return this.getDb().prepare(sql).all(...values).flatMap((r) => (0, _camstack_types.asJsonObject)(r) ? [(0, _camstack_types.asJsonObject)(r)] : []);
+	}
+	async tableGet(table, filter) {
+		const { whereSql, whereValues } = this.buildWhere(filter);
+		return (0, _camstack_types.asJsonObject)(this.getDb().prepare(`SELECT * FROM "${table}"${whereSql} LIMIT 1`).get(...whereValues));
+	}
+	async tableCount(table, filter) {
+		let sql = `SELECT COUNT(*) as count FROM "${table}"`;
+		const values = [];
+		if (filter) {
+			const { whereSql, whereValues } = this.buildWhere(filter);
+			sql += whereSql;
+			values.push(...whereValues);
+		}
+		const row = (0, _camstack_types.asJsonObject)(this.getDb().prepare(sql).get(...values));
+		return typeof row?.count === "number" ? row.count : 0;
+	}
+	buildWhere(filter) {
+		const conditions = [];
+		const values = [];
+		for (const [k, v] of Object.entries(filter)) {
+			conditions.push(`"${k}" = ?`);
+			values.push(typeof v === "object" && v !== null ? JSON.stringify(v) : v);
+		}
+		return {
+			whereSql: conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "",
+			whereValues: values
+		};
+	}
+};
+//#endregion
+//#region src/builtins/sqlite-storage/sqlite-settings.addon.ts
+/**
+* SQLite Settings addon — provides persistent settings storage.
+* Capability: 'settings-store' (singleton)
+*/
+var SqliteSettingsAddon = class extends _camstack_types.BaseAddon {
+	backend = null;
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		const addonId = this.ctx.id.replace("addon:", "");
+		const path = await import("node:path");
+		const dbPath = this.ctx.dataDir ? path.join(this.ctx.dataDir, "camstack.db") : path.join("camstack-data", "addons-data", addonId, "camstack.db");
+		const pathSource = this.ctx.dataDir ? "dataDir" : "fallback (hardcoded)";
+		let dbExists = false;
+		try {
+			const fs = await import("node:fs");
+			dbExists = fs.existsSync(dbPath);
+			if (!dbExists) await fs.promises.mkdir(path.dirname(dbPath), { recursive: true });
+		} catch (err) {
+			this.ctx.logger.warn("Failed to check/create DB directory", { meta: { error: (0, _camstack_types.errMsg)(err) } });
+		}
+		this.ctx.logger.info("DB path resolved", { meta: {
+			pathSource,
+			dbPath
+		} });
+		this.ctx.logger.info("DB file status", { meta: { dbExists } });
+		this.backend = new SqliteSettingsBackend(dbPath, { ..._camstack_types.RUNTIME_DEFAULTS });
+		await this.backend.initialize();
+		this.ctx.logger.info("Initialized successfully");
+		return [{
+			capability: _camstack_types.settingsStoreCapability,
+			provider: this.backend
+		}];
+	}
+	async onShutdown() {
+		await this.backend?.shutdown();
+	}
+	getBackend() {
+		return this.backend;
+	}
+};
+//#endregion
+exports.SqliteSettingsAddon = SqliteSettingsAddon;
+exports.default = SqliteSettingsAddon;
+exports.SqliteSettingsBackend = SqliteSettingsBackend;