@camstack/core 0.1.15 → 0.1.16

package/dist/builtins/sqlite-storage/index.js

@@ -1,733 +1,43 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/builtins/sqlite-storage/index.ts
-var sqlite_storage_exports = {};
-__export(sqlite_storage_exports, {
-  CORE_TABLE_DDL: () => CORE_TABLE_DDL,
-  ConfigStore: () => ConfigStore,
-  DeviceStore: () => DeviceStore,
-  FilesystemStorageAddon: () => FilesystemStorageAddon,
-  FilesystemStorageProvider: () => import_node2.FilesystemStorageProvider,
-  SettingsStore: () => SettingsStore,
-  SqliteSettingsAddon: () => SqliteSettingsAddon,
-  SqliteSettingsBackend: () => SqliteSettingsBackend,
-  addonTableToDdl: () => addonTableToDdl,
-  default: () => FilesystemStorageAddon
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
 });
-module.exports = __toCommonJS(sqlite_storage_exports);
-var import_node2 = require("@camstack/types/node");
-
-// src/builtins/sqlite-storage/filesystem-storage.addon.ts
-var import_types = require("@camstack/types");
-var import_node = require("@camstack/types/node");
-var FilesystemStorageAddon = class extends import_types.BaseAddon {
-  provider = null;
-  constructor() {
-    super({ rootPath: "camstack-data" });
-  }
-  async onInitialize() {
-    const rootPath = this.ctx.addonConfig.rootPath ?? this.config.rootPath;
-    const overrides = {};
-    const addonCfg = this.ctx.addonConfig;
-    for (const key of Object.keys(addonCfg)) {
-      if (key.startsWith("override.")) {
-        const loc = key.slice("override.".length);
-        overrides[loc] = addonCfg[key];
-      }
-    }
-    this.provider = new import_node.FilesystemStorageProvider(rootPath, overrides);
-    this.ctx.logger.info("Filesystem storage initialized", { meta: { rootPath: this.provider.getRootPath() } });
-    return [{ capability: import_types.storageCapability, provider: this.provider }];
-  }
-  async onShutdown() {
-    this.provider = null;
-  }
-  getProvider() {
-    return this.provider;
-  }
-};
-
-// src/builtins/sqlite-storage/sqlite-settings-backend.ts
-var import_better_sqlite3 = __toESM(require("better-sqlite3"));
-var import_node_crypto = require("crypto");
-var import_types2 = require("@camstack/types");
-function parseRowData(raw) {
-  return (0, import_types2.asJsonObject)((0, import_types2.parseJsonUnknown)(raw)) ?? {};
-}
-var SqliteSettingsBackend = class _SqliteSettingsBackend {
-  // Domain schemas (auth, analytics events, …) live in the addons that
-  // own them — same pattern as `pipeline-analytics` (`event-store.ts`,
-  // `track-store.ts`, `media-store.ts`) and `local-auth` (`auth-schema.ts`).
-  // The backend exposes `declareCollection` and stays out of domain
-  // knowledge.
-  constructor(dbPath, runtimeDefaults) {
-    this.dbPath = dbPath;
-    this.runtimeDefaults = runtimeDefaults ?? {};
-  }
-  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"
-  ];
-  async initialize() {
-    const dir = this.dbPath.substring(0, this.dbPath.lastIndexOf("/"));
-    if (dir) {
-      const fs = await import("fs");
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    this.db = new import_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: /* @__PURE__ */ new Set(["data"])
-      });
-    }
-    const isEmpty = await this.isEmpty({ collection: "system-settings" });
-    if (isEmpty) {
-      await this.seedDefaults();
-    }
-  }
-  requireDeclared(scoped) {
-    const decl = this.declaredCollections.get(scoped);
-    if (!decl) {
-      throw new Error(`SqliteSettingsBackend: collection "${scoped}" is not declared. Call declareCollection() first or add it to CANONICAL_KV_COLLECTIONS.`);
-    }
-    return decl;
-  }
-  async shutdown() {
-    this.db?.close();
-    this.db = null;
-  }
-  // ---------------------------------------------------------------------------
-  // ISettingsBackend implementation
-  // ---------------------------------------------------------------------------
-  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) {
-      const v = row[c];
-      if (typeof v === "string" && (v.startsWith("{") || v.startsWith("["))) {
-        try {
-          data[c] = JSON.parse(v);
-        } catch {
-          data[c] = v;
-        }
-      } else {
-        data[c] = v ?? null;
-      }
-    }
-    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, import_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 ")}`;
-    }
-    const row = this.getDb().prepare(sql).get(...params);
-    return row?.cnt ?? 0;
-  }
-  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");
-    const cols = [`"${decl.primaryKey}"`, ...[...decl.columns].map((c) => `"${c}"`)].join(", ");
-    let sql = `SELECT ${cols} FROM "${table}"`;
-    const params = [];
-    const whereClauses = [];
-    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 "";
-    };
-    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);
-    }
-    const rows = this.getDb().prepare(sql).all(...params);
-    return rows.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) {
-        const v = r[c];
-        if (typeof v === "string" && (v.startsWith("{") || v.startsWith("["))) {
-          try {
-            data[c] = JSON.parse(v);
-          } catch {
-            data[c] = v;
-          }
-        } else {
-          data[c] = v ?? null;
-        }
-      }
-      return { id, data };
-    });
-  }
-  // ---------------------------------------------------------------------------
-  // Legacy SettingsStore compatibility (used by ConfigManager.setSettingsStore)
-  // ---------------------------------------------------------------------------
-  /** 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;
-      const isWrapper = parsed !== null && typeof parsed === "object" && "addonId" in parsed && "key" in parsed;
-      if (isWrapper) {
-        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);
-  }
-  // ── Addon-device settings (per-device overrides of an addon's config) ──
-  //
-  // Storage key format: "<addonId>:<deviceId>.<field>" inside the
-  // "addon-device-settings" collection. Uses the same JSON-blob layout
-  // as the other scoped collections so no schema change is required.
-  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));
-      }
-    })();
-  }
-  // ---------------------------------------------------------------------------
-  // Private helpers
-  // ---------------------------------------------------------------------------
-  /**
-   * 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 \u2014 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 }));
-  }
-  // ── Declared collections (typed SQL tables behind the generic cap) ──
-  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 hasId = input.columns.some((c) => c.primaryKey === true);
-    const columns = hasId ? input.columns : [{ name: "id", type: "TEXT", primaryKey: true, notNull: true }, ...input.columns];
-    const schema = {
-      columns: columns.map((c) => ({
-        name: c.name,
-        // SQLite treats JSON as TEXT; we serialize object values on write
-        // and parse on read.
-        type: c.type === "JSON" ? "TEXT" : 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));
-    this.declaredCollections.set(table, { primaryKey, columns: columnNames });
-  }
-  /** 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;
-  }
-  // ── Structured table operations ────────────────────────────────────
-  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));
-      const isLegacyKv = existingCols.length <= 2 && existingNames.has("data") && !declaredNames.has("data");
-      if (isLegacyKv || 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);
-    const result = this.getDb().prepare(`UPDATE "${table}" SET ${setClauses.join(", ")}${whereSql}`).run(...setValues, ...whereValues);
-    return result.changes;
-  }
-  async tableDelete(table, filter) {
-    const { whereSql, whereValues } = this.buildWhere(filter);
-    const result = this.getDb().prepare(`DELETE FROM "${table}"${whereSql}`).run(...whereValues);
-    return result.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);
-    }
-    const rows = this.getDb().prepare(sql).all(...values);
-    return rows.flatMap((r) => (0, import_types2.asJsonObject)(r) ? [(0, import_types2.asJsonObject)(r)] : []);
-  }
-  async tableGet(table, filter) {
-    const { whereSql, whereValues } = this.buildWhere(filter);
-    const row = this.getDb().prepare(`SELECT * FROM "${table}"${whereSql} LIMIT 1`).get(...whereValues);
-    return (0, import_types2.asJsonObject)(row);
-  }
-  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, import_types2.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);
-    }
-    const whereSql = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-    return { whereSql, whereValues: values };
-  }
-};
-
-// src/builtins/sqlite-storage/sqlite-settings.addon.ts
-var import_types3 = require("@camstack/types");
-var SqliteSettingsAddon = class extends import_types3.BaseAddon {
-  backend = null;
-  constructor() {
-    super({});
-  }
-  async onInitialize() {
-    const addonId = this.ctx.id.replace("addon:", "");
-    let pathSource = "fallback (hardcoded)";
-    const dbPath = await this.ctx.api.storage.resolve.query({ location: "addons-data", relativePath: `${addonId}/camstack.db` }).then((p) => {
-      pathSource = "storage capability (addons-data)";
-      return p;
-    }).catch(() => {
-      if (this.ctx.dataDir) {
-        pathSource = "dataDir";
-        return `${this.ctx.dataDir}/camstack.db`;
-      }
-      return "camstack-data/addons-data/sqlite-settings/camstack.db";
-    });
-    let dbExists = false;
-    try {
-      const fs = await import("fs");
-      dbExists = fs.existsSync(dbPath);
-    } catch (err) {
-      this.ctx.logger.warn("Failed to check DB file existence", { meta: { error: (0, import_types3.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, { ...import_types3.RUNTIME_DEFAULTS });
-    await this.backend.initialize();
-    this.ctx.logger.info("Initialized successfully");
-    return [{ capability: import_types3.settingsStoreCapability, provider: this.backend }];
-  }
-  async onShutdown() {
-    await this.backend?.shutdown();
-  }
-  getBackend() {
-    return this.backend;
-  }
-};
-
-// src/builtins/sqlite-storage/settings-store.ts
-var import_better_sqlite32 = __toESM(require("better-sqlite3"));
-
-// src/builtins/sqlite-storage/sql-schema.ts
+const require_chunk = require("../../chunk-C13QxCFV.js");
+const require_builtins_sqlite_storage_filesystem_storage_addon = require("./filesystem-storage.addon.js");
+const require_builtins_sqlite_storage_sqlite_settings_addon = require("./sqlite-settings.addon.js");
+let _camstack_types = require("@camstack/types");
+let better_sqlite3 = require("better-sqlite3");
+better_sqlite3 = require_chunk.__toESM(better_sqlite3);
+//#region src/builtins/sqlite-storage/sql-schema.ts
+/** Core table DDL statements -- executed on first boot */
 var CORE_TABLE_DDL = [
-  // Settings tables
-  `CREATE TABLE IF NOT EXISTS system_settings (
+	`CREATE TABLE IF NOT EXISTS system_settings (
     key TEXT PRIMARY KEY,
     value JSON NOT NULL,
     updated_at INTEGER NOT NULL DEFAULT (unixepoch())
   )`,
-  `CREATE TABLE IF NOT EXISTS addon_settings (
+	`CREATE TABLE IF NOT EXISTS addon_settings (
     addon_id TEXT NOT NULL,
     key TEXT NOT NULL,
     value JSON NOT NULL,
     updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
     PRIMARY KEY (addon_id, key)
   )`,
-  `CREATE TABLE IF NOT EXISTS provider_settings (
+	`CREATE TABLE IF NOT EXISTS provider_settings (
     provider_id TEXT NOT NULL,
     key TEXT NOT NULL,
     value JSON NOT NULL,
     updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
     PRIMARY KEY (provider_id, key)
   )`,
-  `CREATE TABLE IF NOT EXISTS device_settings (
+	`CREATE TABLE IF NOT EXISTS device_settings (
     device_id TEXT NOT NULL,
     key TEXT NOT NULL,
     value JSON NOT NULL,
     updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
     PRIMARY KEY (device_id, key)
   )`,
-  /**
-   * Per-device overrides of an addon's settings (scope: 'device' fields).
-   * Resolution chain: schema default -> addon_settings (global) -> this.
-   */
-  `CREATE TABLE IF NOT EXISTS addon_device_settings (
+	`CREATE TABLE IF NOT EXISTS addon_device_settings (
     addon_id TEXT NOT NULL,
     device_id TEXT NOT NULL,
     key TEXT NOT NULL,
@@ -735,14 +45,7 @@ var CORE_TABLE_DDL = [
     updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
     PRIMARY KEY (addon_id, device_id, key)
   )`,
-  // P12b sweep: removed static DDL for `detection_events`, `audio_levels`,
-  // `track_trails` — these were consumed exclusively by the old
-  // analytics sub-addon (deleted) and its analysis-data-persistence cap.
-  // addon-pipeline-analytics now owns all detection/audio/track tables
-  // via `declareCollection` (pipeline-analytics:motion-events,
-  // :object-events, :audio-events, :tracks, :media).
-  // Device registry
-  `CREATE TABLE IF NOT EXISTS devices (
+	`CREATE TABLE IF NOT EXISTS devices (
   id                INTEGER PRIMARY KEY AUTOINCREMENT,
   addon_id          TEXT NOT NULL,
   stable_id         TEXT NOT NULL,
@@ -754,309 +57,234 @@ var CORE_TABLE_DDL = [
   created_at        TEXT DEFAULT (datetime('now')),
   UNIQUE(addon_id, stable_id)
 )`,
-  `CREATE INDEX IF NOT EXISTS idx_devices_addon ON devices(addon_id)`,
-  `CREATE INDEX IF NOT EXISTS idx_devices_parent ON devices(addon_id, parent_stable_id)`,
-  // Addon / device config store
-  // stable_id IS NULL  -> addon-global row   (one per addon_id)
-  // stable_id IS NOT NULL -> per-device row  (one per addon_id + stable_id pair)
-  // Two partial unique indexes enforce the constraint because SQLite does not
-  // support expressions inside UNIQUE(...) declarations.
-  `CREATE TABLE IF NOT EXISTS addon_config (
+	`CREATE INDEX IF NOT EXISTS idx_devices_addon ON devices(addon_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_devices_parent ON devices(addon_id, parent_stable_id)`,
+	`CREATE TABLE IF NOT EXISTS addon_config (
   addon_id    TEXT NOT NULL,
   stable_id   TEXT,
   data        TEXT NOT NULL DEFAULT '{}',
   updated_at  TEXT DEFAULT (datetime('now'))
 )`,
-  `CREATE UNIQUE INDEX IF NOT EXISTS idx_addon_config_global ON addon_config(addon_id) WHERE stable_id IS NULL`,
-  `CREATE UNIQUE INDEX IF NOT EXISTS idx_addon_config_device ON addon_config(addon_id, stable_id) WHERE stable_id IS NOT NULL`,
-  `CREATE INDEX IF NOT EXISTS idx_addon_config_addon ON addon_config(addon_id)`
-];
-var CORE_TABLE_MIGRATIONS = [
-  // 2026-04 — DeviceRole support: optional role hint per device, used by
-  // admin UI to pick icons/widgets for accessory children (siren,
-  // floodlight, PIR, chime, doorbell, …). Nullable; existing rows stay.
-  `ALTER TABLE devices ADD COLUMN role TEXT`
+	`CREATE UNIQUE INDEX IF NOT EXISTS idx_addon_config_global ON addon_config(addon_id) WHERE stable_id IS NULL`,
+	`CREATE UNIQUE INDEX IF NOT EXISTS idx_addon_config_device ON addon_config(addon_id, stable_id) WHERE stable_id IS NOT NULL`,
+	`CREATE INDEX IF NOT EXISTS idx_addon_config_addon ON addon_config(addon_id)`
 ];
+/**
+* Idempotent ALTER statements run after `CORE_TABLE_DDL`. Each entry
+* may fail on installs where the column already exists — the runner
+* catches "duplicate column name" / "no such table" errors and moves
+* on. Order matters: migrations stack in chronological order.
+*
+* Pattern when adding a new column:
+*   1. Add the column to the matching `CREATE TABLE` above so fresh
+*      installs get it by default.
+*   2. Append an `ALTER TABLE ... ADD COLUMN ...` here so existing
+*      installs get it on next boot.
+*/
+var CORE_TABLE_MIGRATIONS = [`ALTER TABLE devices ADD COLUMN role TEXT`];
+/** Generate CREATE TABLE DDL from addon schema */
 function addonTableToDdl(schema) {
-  const pks = schema.columns.filter((c) => c.primaryKey).map((c) => c.name);
-  const colDefs = schema.columns.map((c) => {
-    const parts = [c.name, c.type];
-    if (c.notNull) parts.push("NOT NULL");
-    return parts.join(" ");
-  });
-  let ddl = `CREATE TABLE IF NOT EXISTS ${schema.name} (
-  ${colDefs.join(",\n  ")}`;
-  if (pks.length > 0) {
-    ddl += `,
-  PRIMARY KEY (${pks.join(", ")})`;
-  }
-  ddl += "\n)";
-  const stmts = [ddl];
-  for (const idx of schema.indexes ?? []) {
-    const unique = idx.unique ? "UNIQUE " : "";
-    stmts.push(`CREATE ${unique}INDEX IF NOT EXISTS ${idx.name} ON ${schema.name}(${idx.columns.join(", ")})`);
-  }
-  return stmts;
+	const pks = schema.columns.filter((c) => c.primaryKey).map((c) => c.name);
+	const colDefs = schema.columns.map((c) => {
+		const parts = [c.name, c.type];
+		if (c.notNull) parts.push("NOT NULL");
+		return parts.join(" ");
+	});
+	let ddl = `CREATE TABLE IF NOT EXISTS ${schema.name} (\n  ${colDefs.join(",\n  ")}`;
+	if (pks.length > 0) ddl += `,\n  PRIMARY KEY (${pks.join(", ")})`;
+	ddl += "\n)";
+	const stmts = [ddl];
+	for (const idx of schema.indexes ?? []) {
+		const unique = idx.unique ? "UNIQUE " : "";
+		stmts.push(`CREATE ${unique}INDEX IF NOT EXISTS ${idx.name} ON ${schema.name}(${idx.columns.join(", ")})`);
+	}
+	return stmts;
 }
-
-// src/builtins/sqlite-storage/settings-store.ts
-var import_types4 = require("@camstack/types");
+//#endregion
+//#region src/builtins/sqlite-storage/settings-store.ts
+/**
+* Thin wrapper over better-sqlite3 that manages the four settings tables:
+* system_settings, addon_settings, provider_settings, device_settings.
+*
+* All values are stored as JSON text and deserialized on read.
+*/
 var SettingsStore = class {
-  db;
-  constructor(dbPath) {
-    this.db = new import_better_sqlite32.default(dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = ON");
-    this.initTables();
-  }
-  // ---------------------------------------------------------------------------
-  // System settings
-  // ---------------------------------------------------------------------------
-  getSystem(key) {
-    const row = this.db.prepare("SELECT value FROM system_settings WHERE key = ?").get(key);
-    if (row === void 0) return void 0;
-    return JSON.parse(row.value);
-  }
-  setSystem(key, value) {
-    this.db.prepare(
-      `INSERT INTO system_settings (key, value, updated_at) VALUES (?, json(?), unixepoch())
-         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
-    ).run(key, JSON.stringify(value));
-  }
-  getAllSystem() {
-    const rows = this.db.prepare("SELECT key, value FROM system_settings").all();
-    return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
-  }
-  // ---------------------------------------------------------------------------
-  // Addon settings
-  // ---------------------------------------------------------------------------
-  getAddon(addonId, key) {
-    const row = this.db.prepare(
-      "SELECT value FROM addon_settings WHERE addon_id = ? AND key = ?"
-    ).get(addonId, key);
-    if (row === void 0) return void 0;
-    return JSON.parse(row.value);
-  }
-  setAddon(addonId, key, value) {
-    this.db.prepare(
-      `INSERT INTO addon_settings (addon_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())
-         ON CONFLICT(addon_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
-    ).run(addonId, key, JSON.stringify(value));
-  }
-  getAllAddon(addonId) {
-    const rows = this.db.prepare(
-      "SELECT key, value FROM addon_settings WHERE addon_id = ?"
-    ).all(addonId);
-    return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
-  }
-  /** Bulk-replace all keys for an addon (within a transaction). */
-  setAllAddon(addonId, config) {
-    const deleteStmt = this.db.prepare("DELETE FROM addon_settings WHERE addon_id = ?");
-    const insertStmt = this.db.prepare(
-      `INSERT INTO addon_settings (addon_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())`
-    );
-    this.db.transaction(() => {
-      deleteStmt.run(addonId);
-      for (const [key, value] of Object.entries(config)) {
-        insertStmt.run(addonId, key, JSON.stringify(value));
-      }
-    })();
-  }
-  // ---------------------------------------------------------------------------
-  // Provider settings
-  // ---------------------------------------------------------------------------
-  getProvider(providerId, key) {
-    const row = this.db.prepare(
-      "SELECT value FROM provider_settings WHERE provider_id = ? AND key = ?"
-    ).get(providerId, key);
-    if (row === void 0) return void 0;
-    return JSON.parse(row.value);
-  }
-  setProvider(providerId, key, value) {
-    this.db.prepare(
-      `INSERT INTO provider_settings (provider_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())
-         ON CONFLICT(provider_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
-    ).run(providerId, key, JSON.stringify(value));
-  }
-  getAllProvider(providerId) {
-    const rows = this.db.prepare(
-      "SELECT key, value FROM provider_settings WHERE provider_id = ?"
-    ).all(providerId);
-    return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
-  }
-  // ---------------------------------------------------------------------------
-  // Device settings
-  // ---------------------------------------------------------------------------
-  getDevice(deviceId, key) {
-    const row = this.db.prepare(
-      "SELECT value FROM device_settings WHERE device_id = ? AND key = ?"
-    ).get(deviceId, key);
-    if (row === void 0) return void 0;
-    return JSON.parse(row.value);
-  }
-  setDevice(deviceId, key, value) {
-    this.db.prepare(
-      `INSERT INTO device_settings (device_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())
-         ON CONFLICT(device_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
-    ).run(deviceId, key, JSON.stringify(value));
-  }
-  getAllDevice(deviceId) {
-    const rows = this.db.prepare(
-      "SELECT key, value FROM device_settings WHERE device_id = ?"
-    ).all(deviceId);
-    return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
-  }
-  // ---------------------------------------------------------------------------
-  // Addon-device settings (per-device overrides of an addon's config)
-  //
-  // Implements the third level of the resolution chain used by the
-  // multi-level settings system:
-  //   schema default -> addon_settings (global) -> addon_device_settings
-  // ---------------------------------------------------------------------------
-  getAddonDevice(addonId, deviceId) {
-    const rows = this.db.prepare(
-      "SELECT key, value FROM addon_device_settings WHERE addon_id = ? AND device_id = ?"
-    ).all(addonId, deviceId);
-    return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
-  }
-  /**
-   * Bulk-replace all per-device overrides for (addonId, deviceId) in a
-   * single transaction. Empty input clears the override set — caller
-   * should use `clearAddonDevice` for explicit resets.
-   */
-  setAddonDevice(addonId, deviceId, values) {
-    const deleteStmt = this.db.prepare(
-      "DELETE FROM addon_device_settings WHERE addon_id = ? AND device_id = ?"
-    );
-    const insertStmt = this.db.prepare(
-      `INSERT INTO addon_device_settings (addon_id, device_id, key, value, updated_at)
-       VALUES (?, ?, ?, json(?), unixepoch())`
-    );
-    this.db.transaction(() => {
-      deleteStmt.run(addonId, deviceId);
-      for (const [key, value] of Object.entries(values)) {
-        insertStmt.run(addonId, deviceId, key, JSON.stringify(value));
-      }
-    })();
-  }
-  clearAddonDevice(addonId, deviceId) {
-    this.db.prepare("DELETE FROM addon_device_settings WHERE addon_id = ? AND device_id = ?").run(addonId, deviceId);
-  }
-  // ---------------------------------------------------------------------------
-  // Lifecycle
-  // ---------------------------------------------------------------------------
-  /** Close the SQLite connection (call on shutdown). */
-  close() {
-    this.db.close();
-  }
-  /** Check if system_settings is empty (used for first-boot seeding). */
-  isSystemSettingsEmpty() {
-    const row = this.db.prepare("SELECT COUNT(*) AS cnt FROM system_settings").get();
-    return (row?.cnt ?? 0) === 0;
-  }
-  /** Seed system_settings with RUNTIME_DEFAULTS (only on first boot). */
-  seedDefaults() {
-    const insert = this.db.prepare(
-      `INSERT OR IGNORE INTO system_settings (key, value, updated_at) VALUES (?, json(?), unixepoch())`
-    );
-    this.db.transaction(() => {
-      for (const [key, value] of Object.entries(import_types4.RUNTIME_DEFAULTS)) {
-        insert.run(key, JSON.stringify(value));
-      }
-    })();
-  }
-  // ---------------------------------------------------------------------------
-  // Private helpers
-  // ---------------------------------------------------------------------------
-  initTables() {
-    this.db.transaction(() => {
-      for (const stmt of CORE_TABLE_DDL) {
-        this.db.prepare(stmt).run();
-      }
-      for (const stmt of CORE_TABLE_MIGRATIONS) {
-        try {
-          this.db.prepare(stmt).run();
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          if (msg.includes("duplicate column name") || msg.includes("no such table")) continue;
-          throw err;
-        }
-      }
-    })();
-  }
+	db;
+	constructor(dbPath) {
+		this.db = new better_sqlite3.default(dbPath);
+		this.db.pragma("journal_mode = WAL");
+		this.db.pragma("foreign_keys = ON");
+		this.initTables();
+	}
+	getSystem(key) {
+		const row = this.db.prepare("SELECT value FROM system_settings WHERE key = ?").get(key);
+		if (row === void 0) return void 0;
+		return JSON.parse(row.value);
+	}
+	setSystem(key, value) {
+		this.db.prepare(`INSERT INTO system_settings (key, value, updated_at) VALUES (?, json(?), unixepoch())
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`).run(key, JSON.stringify(value));
+	}
+	getAllSystem() {
+		const rows = this.db.prepare("SELECT key, value FROM system_settings").all();
+		return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+	}
+	getAddon(addonId, key) {
+		const row = this.db.prepare("SELECT value FROM addon_settings WHERE addon_id = ? AND key = ?").get(addonId, key);
+		if (row === void 0) return void 0;
+		return JSON.parse(row.value);
+	}
+	setAddon(addonId, key, value) {
+		this.db.prepare(`INSERT INTO addon_settings (addon_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())
+         ON CONFLICT(addon_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`).run(addonId, key, JSON.stringify(value));
+	}
+	getAllAddon(addonId) {
+		const rows = this.db.prepare("SELECT key, value FROM addon_settings WHERE addon_id = ?").all(addonId);
+		return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+	}
+	/** Bulk-replace all keys for an addon (within a transaction). */
+	setAllAddon(addonId, config) {
+		const deleteStmt = this.db.prepare("DELETE FROM addon_settings WHERE addon_id = ?");
+		const insertStmt = this.db.prepare(`INSERT INTO addon_settings (addon_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())`);
+		this.db.transaction(() => {
+			deleteStmt.run(addonId);
+			for (const [key, value] of Object.entries(config)) insertStmt.run(addonId, key, JSON.stringify(value));
+		})();
+	}
+	getProvider(providerId, key) {
+		const row = this.db.prepare("SELECT value FROM provider_settings WHERE provider_id = ? AND key = ?").get(providerId, key);
+		if (row === void 0) return void 0;
+		return JSON.parse(row.value);
+	}
+	setProvider(providerId, key, value) {
+		this.db.prepare(`INSERT INTO provider_settings (provider_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())
+         ON CONFLICT(provider_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`).run(providerId, key, JSON.stringify(value));
+	}
+	getAllProvider(providerId) {
+		const rows = this.db.prepare("SELECT key, value FROM provider_settings WHERE provider_id = ?").all(providerId);
+		return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+	}
+	getDevice(deviceId, key) {
+		const row = this.db.prepare("SELECT value FROM device_settings WHERE device_id = ? AND key = ?").get(deviceId, key);
+		if (row === void 0) return void 0;
+		return JSON.parse(row.value);
+	}
+	setDevice(deviceId, key, value) {
+		this.db.prepare(`INSERT INTO device_settings (device_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())
+         ON CONFLICT(device_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`).run(deviceId, key, JSON.stringify(value));
+	}
+	getAllDevice(deviceId) {
+		const rows = this.db.prepare("SELECT key, value FROM device_settings WHERE device_id = ?").all(deviceId);
+		return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+	}
+	getAddonDevice(addonId, deviceId) {
+		const rows = this.db.prepare("SELECT key, value FROM addon_device_settings WHERE addon_id = ? AND device_id = ?").all(addonId, deviceId);
+		return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+	}
+	/**
+	* Bulk-replace all per-device overrides for (addonId, deviceId) in a
+	* single transaction. Empty input clears the override set — caller
+	* should use `clearAddonDevice` for explicit resets.
+	*/
+	setAddonDevice(addonId, deviceId, values) {
+		const deleteStmt = this.db.prepare("DELETE FROM addon_device_settings WHERE addon_id = ? AND device_id = ?");
+		const insertStmt = this.db.prepare(`INSERT INTO addon_device_settings (addon_id, device_id, key, value, updated_at)
+       VALUES (?, ?, ?, json(?), unixepoch())`);
+		this.db.transaction(() => {
+			deleteStmt.run(addonId, deviceId);
+			for (const [key, value] of Object.entries(values)) insertStmt.run(addonId, deviceId, key, JSON.stringify(value));
+		})();
+	}
+	clearAddonDevice(addonId, deviceId) {
+		this.db.prepare("DELETE FROM addon_device_settings WHERE addon_id = ? AND device_id = ?").run(addonId, deviceId);
+	}
+	/** Close the SQLite connection (call on shutdown). */
+	close() {
+		this.db.close();
+	}
+	/** Check if system_settings is empty (used for first-boot seeding). */
+	isSystemSettingsEmpty() {
+		return (this.db.prepare("SELECT COUNT(*) AS cnt FROM system_settings").get()?.cnt ?? 0) === 0;
+	}
+	/** Seed system_settings with RUNTIME_DEFAULTS (only on first boot). */
+	seedDefaults() {
+		const insert = this.db.prepare(`INSERT OR IGNORE INTO system_settings (key, value, updated_at) VALUES (?, json(?), unixepoch())`);
+		this.db.transaction(() => {
+			for (const [key, value] of Object.entries(_camstack_types.RUNTIME_DEFAULTS)) insert.run(key, JSON.stringify(value));
+		})();
+	}
+	initTables() {
+		this.db.transaction(() => {
+			for (const stmt of CORE_TABLE_DDL) this.db.prepare(stmt).run();
+			for (const stmt of CORE_TABLE_MIGRATIONS) try {
+				this.db.prepare(stmt).run();
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				if (msg.includes("duplicate column name") || msg.includes("no such table")) continue;
+				throw err;
+			}
+		})();
+	}
 };
-
-// src/builtins/sqlite-storage/device-store.ts
+//#endregion
+//#region src/builtins/sqlite-storage/device-store.ts
 var DeviceStore = class {
-  constructor(db) {
-    this.db = db;
-  }
-  db;
-  insert(addonId, device) {
-    this.db.prepare(
-      `INSERT INTO devices (addon_id, stable_id, type, name, parent_stable_id) VALUES (?, ?, ?, ?, ?)`
-    ).run(addonId, device.stableId, device.type, device.name, device.parentStableId);
-  }
-  listByAddon(addonId) {
-    return this.db.prepare(
-      `SELECT stable_id as stableId, type, name, parent_stable_id as parentStableId, enabled FROM devices WHERE addon_id = ?`
-    ).all(addonId);
-  }
-  listChildren(addonId, parentStableId) {
-    return this.db.prepare(
-      `SELECT stable_id as stableId, type, name, parent_stable_id as parentStableId, enabled FROM devices WHERE addon_id = ? AND parent_stable_id = ?`
-    ).all(addonId, parentStableId);
-  }
-  remove(addonId, stableId) {
-    this.db.prepare(`DELETE FROM devices WHERE addon_id = ? AND stable_id = ?`).run(addonId, stableId);
-  }
+	constructor(db) {
+		this.db = db;
+	}
+	insert(addonId, device) {
+		this.db.prepare(`INSERT INTO devices (addon_id, stable_id, type, name, parent_stable_id) VALUES (?, ?, ?, ?, ?)`).run(addonId, device.stableId, device.type, device.name, device.parentStableId);
+	}
+	listByAddon(addonId) {
+		return this.db.prepare(`SELECT stable_id as stableId, type, name, parent_stable_id as parentStableId, enabled FROM devices WHERE addon_id = ?`).all(addonId);
+	}
+	listChildren(addonId, parentStableId) {
+		return this.db.prepare(`SELECT stable_id as stableId, type, name, parent_stable_id as parentStableId, enabled FROM devices WHERE addon_id = ? AND parent_stable_id = ?`).all(addonId, parentStableId);
+	}
+	remove(addonId, stableId) {
+		this.db.prepare(`DELETE FROM devices WHERE addon_id = ? AND stable_id = ?`).run(addonId, stableId);
+	}
 };
-
-// src/builtins/sqlite-storage/config-store.ts
+//#endregion
+//#region src/builtins/sqlite-storage/config-store.ts
 var ConfigStore = class {
-  constructor(db) {
-    this.db = db;
-  }
-  db;
-  save(addonId, stableId, data) {
-    if (stableId === null) {
-      this.db.prepare(
-        `INSERT INTO addon_config (addon_id, stable_id, data, updated_at)
+	constructor(db) {
+		this.db = db;
+	}
+	save(addonId, stableId, data) {
+		if (stableId === null) this.db.prepare(`INSERT INTO addon_config (addon_id, stable_id, data, updated_at)
            VALUES (?, NULL, ?, datetime('now'))
            ON CONFLICT(addon_id) WHERE stable_id IS NULL
-           DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`
-      ).run(addonId, JSON.stringify(data));
-    } else {
-      this.db.prepare(
-        `INSERT INTO addon_config (addon_id, stable_id, data, updated_at)
+           DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`).run(addonId, JSON.stringify(data));
+		else this.db.prepare(`INSERT INTO addon_config (addon_id, stable_id, data, updated_at)
            VALUES (?, ?, ?, datetime('now'))
            ON CONFLICT(addon_id, stable_id) WHERE stable_id IS NOT NULL
-           DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`
-      ).run(addonId, stableId, JSON.stringify(data));
-    }
-  }
-  load(addonId, stableId) {
-    const row = stableId === null ? this.db.prepare(`SELECT data FROM addon_config WHERE addon_id = ? AND stable_id IS NULL`).get(addonId) : this.db.prepare(`SELECT data FROM addon_config WHERE addon_id = ? AND stable_id = ?`).get(addonId, stableId);
-    return row ? JSON.parse(row.data) : {};
-  }
-  remove(addonId, stableId) {
-    if (stableId === null) {
-      this.db.prepare(`DELETE FROM addon_config WHERE addon_id = ? AND stable_id IS NULL`).run(addonId);
-    } else {
-      this.db.prepare(`DELETE FROM addon_config WHERE addon_id = ? AND stable_id = ?`).run(addonId, stableId);
-    }
-  }
+           DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`).run(addonId, stableId, JSON.stringify(data));
+	}
+	load(addonId, stableId) {
+		const row = stableId === null ? this.db.prepare(`SELECT data FROM addon_config WHERE addon_id = ? AND stable_id IS NULL`).get(addonId) : this.db.prepare(`SELECT data FROM addon_config WHERE addon_id = ? AND stable_id = ?`).get(addonId, stableId);
+		return row ? JSON.parse(row.data) : {};
+	}
+	remove(addonId, stableId) {
+		if (stableId === null) this.db.prepare(`DELETE FROM addon_config WHERE addon_id = ? AND stable_id IS NULL`).run(addonId);
+		else this.db.prepare(`DELETE FROM addon_config WHERE addon_id = ? AND stable_id = ?`).run(addonId, stableId);
+	}
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CORE_TABLE_DDL,
-  ConfigStore,
-  DeviceStore,
-  FilesystemStorageAddon,
-  FilesystemStorageProvider,
-  SettingsStore,
-  SqliteSettingsAddon,
-  SqliteSettingsBackend,
-  addonTableToDdl
-});
+//#endregion
+exports.CORE_TABLE_DDL = CORE_TABLE_DDL;
+exports.CORE_TABLE_DDL$1 = CORE_TABLE_DDL;
+exports.ConfigStore = ConfigStore;
+exports.ConfigStore$1 = ConfigStore;
+exports.DeviceStore = DeviceStore;
+exports.DeviceStore$1 = DeviceStore;
+exports.FilesystemStorageAddon = require_builtins_sqlite_storage_filesystem_storage_addon.FilesystemStorageAddon;
+exports.FilesystemStorageProvider = require_builtins_sqlite_storage_filesystem_storage_addon.FilesystemStorageProvider;
+exports.SettingsStore = SettingsStore;
+exports.SettingsStore$1 = SettingsStore;
+exports.SqliteSettingsAddon = require_builtins_sqlite_storage_sqlite_settings_addon.SqliteSettingsAddon;
+exports.SqliteSettingsBackend = require_builtins_sqlite_storage_sqlite_settings_addon.SqliteSettingsBackend;
+exports.addonTableToDdl = addonTableToDdl;
+exports.addonTableToDdl$1 = addonTableToDdl;
+exports.default = require_builtins_sqlite_storage_filesystem_storage_addon.FilesystemStorageAddon;
+
 //# sourceMappingURL=index.js.map