@camstack/core 0.1.13 → 0.1.15

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

@@ -31,213 +31,124 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var sqlite_storage_exports = {};
 __export(sqlite_storage_exports, {
   CORE_TABLE_DDL: () => CORE_TABLE_DDL,
-  FileSystemStorage: () => FileSystemStorage,
+  ConfigStore: () => ConfigStore,
+  DeviceStore: () => DeviceStore,
   FilesystemStorageAddon: () => FilesystemStorageAddon,
-  FilesystemStorageProvider: () => FilesystemStorageProvider,
+  FilesystemStorageProvider: () => import_node2.FilesystemStorageProvider,
   SettingsStore: () => SettingsStore,
   SqliteSettingsAddon: () => SqliteSettingsAddon,
   SqliteSettingsBackend: () => SqliteSettingsBackend,
-  SqliteStorageAddon: () => SqliteStorageAddon,
-  SqliteStorageProvider: () => SqliteStorageProvider,
   addonTableToDdl: () => addonTableToDdl,
   default: () => FilesystemStorageAddon
 });
 module.exports = __toCommonJS(sqlite_storage_exports);
-
-// src/builtins/sqlite-storage/filesystem-storage-provider.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var STORAGE_LOCATION_TYPES = [
-  "recordings-high",
-  "recordings-low",
-  "recordings-clips",
-  "event-images",
-  "models",
-  "addons-data",
-  "cache",
-  "logs"
-];
-var DEFAULT_LOCATION_SUBDIRS = {
-  "recordings-high": "recordings-high",
-  "recordings-low": "recordings-low",
-  "recordings-clips": "recordings-clips",
-  "event-images": "event-images",
-  "models": "models",
-  "addons-data": "addons-data",
-  "cache": "/tmp/camstack-cache",
-  "logs": "logs"
-};
-var FilesystemStorageProvider = class {
-  id = "local";
-  name = "Local Filesystem";
-  supportedLocations = [...STORAGE_LOCATION_TYPES];
-  rootPath;
-  locationPaths;
-  constructor(rootPath, overrides) {
-    this.rootPath = path.resolve(rootPath);
-    this.locationPaths = /* @__PURE__ */ new Map();
-    for (const loc of STORAGE_LOCATION_TYPES) {
-      const override = overrides?.[loc];
-      if (override) {
-        this.locationPaths.set(loc, path.resolve(override));
-      } else {
-        const subdir = DEFAULT_LOCATION_SUBDIRS[loc];
-        this.locationPaths.set(
-          loc,
-          path.isAbsolute(subdir) ? subdir : path.join(this.rootPath, subdir)
-        );
-      }
-    }
-  }
-  resolve(location, relativePath) {
-    const base = this.locationPaths.get(location);
-    if (!base) throw new Error(`Unknown storage location: ${location}`);
-    return path.join(base, relativePath);
-  }
-  async write(location, relativePath, data) {
-    const filePath = this.resolve(location, relativePath);
-    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-    if (Buffer.isBuffer(data)) {
-      await fs.promises.writeFile(filePath, data);
-    } else {
-      const writeStream = fs.createWriteStream(filePath);
-      await new Promise((resolve2, reject) => {
-        data.pipe(writeStream);
-        writeStream.on("finish", resolve2);
-        writeStream.on("error", reject);
-      });
-    }
-  }
-  async read(location, relativePath) {
-    return fs.promises.readFile(this.resolve(location, relativePath));
-  }
-  async exists(location, relativePath) {
-    try {
-      await fs.promises.access(this.resolve(location, relativePath));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async list(location, prefix) {
-    const base = this.locationPaths.get(location);
-    if (!base) return [];
-    const dir = prefix ? path.join(base, prefix) : base;
-    try {
-      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-      return entries.map((e) => prefix ? `${prefix}/${e.name}` : e.name);
-    } catch {
-      return [];
-    }
-  }
-  async delete(location, relativePath) {
-    const filePath = this.resolve(location, relativePath);
-    await fs.promises.rm(filePath, { force: true });
-  }
-  async getAvailableSpace(location) {
-    const base = this.locationPaths.get(location);
-    if (!base) return null;
-    try {
-      const stats = await fs.promises.statfs(base);
-      return stats.bavail * stats.bsize;
-    } catch {
-      return null;
-    }
-  }
-  async initialize() {
-    for (const [, dirPath] of this.locationPaths) {
-      await fs.promises.mkdir(dirPath, { recursive: true });
-    }
-  }
-  async shutdown() {
-  }
-  /** Get the resolved path for a location type */
-  getLocationPath(location) {
-    const p = this.locationPaths.get(location);
-    if (!p) throw new Error(`Unknown storage location: ${location}`);
-    return p;
-  }
-  /** Get the root path */
-  getRootPath() {
-    return this.rootPath;
-  }
-};
+var import_node2 = require("@camstack/types/node");
 
 // src/builtins/sqlite-storage/filesystem-storage.addon.ts
-var FilesystemStorageAddon = class {
-  manifest = {
-    id: "filesystem-storage",
-    name: "Local Filesystem Storage",
-    version: "1.0.0",
-    capabilities: [{ name: "storage", mode: "collection" }]
-  };
+var import_types = require("@camstack/types");
+var import_node = require("@camstack/types/node");
+var FilesystemStorageAddon = class extends import_types.BaseAddon {
   provider = null;
-  currentConfig = {
-    rootPath: "camstack-data"
-  };
-  async initialize(context) {
-    const rootPath = context.addonConfig.rootPath ?? this.currentConfig.rootPath;
-    this.currentConfig.rootPath = rootPath;
+  constructor() {
+    super({ rootPath: "camstack-data" });
+  }
+  async onInitialize() {
+    const rootPath = this.ctx.addonConfig.rootPath ?? this.config.rootPath;
     const overrides = {};
-    for (const key of Object.keys(context.addonConfig)) {
+    const addonCfg = this.ctx.addonConfig;
+    for (const key of Object.keys(addonCfg)) {
       if (key.startsWith("override.")) {
         const loc = key.slice("override.".length);
-        overrides[loc] = context.addonConfig[key];
+        overrides[loc] = addonCfg[key];
       }
     }
-    this.provider = new FilesystemStorageProvider(rootPath, overrides);
-    await this.provider.initialize();
-    context.logger.info(`Filesystem storage initialized at ${this.provider.getRootPath()}`);
-  }
-  async shutdown() {
-    await this.provider?.shutdown();
+    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 }];
   }
-  getCapabilityProvider(name) {
-    if (name === "storage" && this.provider) {
-      return this.provider;
-    }
-    return null;
+  async onShutdown() {
+    this.provider = null;
   }
   getProvider() {
     return this.provider;
   }
-  getConfigSchema() {
-    return { sections: [] };
-  }
-  getConfig() {
-    return { ...this.currentConfig };
-  }
-  async onConfigChange(config) {
-    this.currentConfig.rootPath = config.rootPath ?? this.currentConfig.rootPath;
-  }
 };
 
 // src/builtins/sqlite-storage/sqlite-settings-backend.ts
 var import_better_sqlite3 = __toESM(require("better-sqlite3"));
 var import_node_crypto = require("crypto");
-var SqliteSettingsBackend = class {
+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;
-  ensuredTables = /* @__PURE__ */ new Set();
   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 fs3 = await import("fs");
-      fs3.mkdirSync(dir, { recursive: true });
+      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");
-    const isEmpty = await this.isEmpty("system-settings");
+    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;
@@ -245,148 +156,255 @@ var SqliteSettingsBackend = class {
   // ---------------------------------------------------------------------------
   // ISettingsBackend implementation
   // ---------------------------------------------------------------------------
-  async get(collection, key) {
-    this.ensureCollectionTable(collection);
-    const row = this.getDb().prepare(`SELECT data FROM "${collection}" WHERE id = ?`).get(key);
+  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;
-    return JSON.parse(row.data);
-  }
-  async set(collection, key, value) {
-    this.ensureCollectionTable(collection);
-    this.getDb().prepare(`INSERT INTO "${collection}" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`).run(key, JSON.stringify(value));
+    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 query(collection, filter) {
-    this.ensureCollectionTable(collection);
-    let sql = `SELECT id, data FROM "${collection}"`;
+  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)) {
-        if (field === "id") {
-          whereClauses.push("id = ?");
-          params.push(value);
-        } else {
-          whereClauses.push(`json_extract(data, '$.${field}') = ?`);
-          params.push(typeof value === "object" ? JSON.stringify(value) : value);
-        }
+        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(", ");
-        if (field === "id") {
-          whereClauses.push(`id IN (${placeholders})`);
-        } else {
-          whereClauses.push(`json_extract(data, '$.${field}') IN (${placeholders})`);
-        }
-        params.push(...values);
+        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)) {
-        if (field === "id") {
-          whereClauses.push("id BETWEEN ? AND ?");
-        } else {
-          whereClauses.push(`json_extract(data, '$.${field}') BETWEEN ? AND ?`);
-        }
-        params.push(low, high);
+        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 (whereClauses.length > 0) sql += ` WHERE ${whereClauses.join(" AND ")}`;
     if (filter?.orderBy) {
-      const dir = filter.orderBy.direction === "desc" ? "DESC" : "ASC";
-      if (filter.orderBy.field === "id") {
-        sql += ` ORDER BY id ${dir}`;
-      } else {
-        sql += ` ORDER BY json_extract(data, '$.${filter.orderBy.field}') ${dir}`;
+      const expr = fieldExpr(filter.orderBy.field);
+      if (expr) {
+        const dir = filter.orderBy.direction === "desc" ? "DESC" : "ASC";
+        sql += ` ORDER BY ${expr} ${dir}`;
       }
     }
-    if (filter?.limit) {
+    if (filter?.limit !== void 0) {
       sql += ` LIMIT ?`;
       params.push(filter.limit);
     }
-    if (filter?.offset) {
+    if (filter?.offset !== void 0) {
       sql += ` OFFSET ?`;
       params.push(filter.offset);
     }
     const rows = this.getDb().prepare(sql).all(...params);
-    return rows.map((row) => ({
-      id: row.id,
-      data: JSON.parse(row.data)
-    }));
-  }
-  async insert(collection, record) {
-    this.ensureCollectionTable(collection);
-    const id = record.id || (0, import_node_crypto.randomUUID)();
-    this.getDb().prepare(`INSERT INTO "${collection}" (id, data) VALUES (?, ?)`).run(id, JSON.stringify(record.data));
-  }
-  async update(collection, id, data) {
-    this.ensureCollectionTable(collection);
-    this.getDb().prepare(`UPDATE "${collection}" SET data = ? WHERE id = ?`).run(JSON.stringify(data), id);
-  }
-  async delete(collection, key) {
-    this.ensureCollectionTable(collection);
-    this.getDb().prepare(`DELETE FROM "${collection}" WHERE id = ?`).run(key);
-  }
-  async count(collection, filter) {
-    this.ensureCollectionTable(collection);
-    if (!filter) {
-      const row = this.getDb().prepare(`SELECT COUNT(*) AS cnt FROM "${collection}"`).get();
-      return row?.cnt ?? 0;
-    }
-    const rows = await this.query(collection, { ...filter, limit: void 0, offset: void 0 });
-    return rows.length;
-  }
-  async isEmpty(collection) {
-    this.ensureCollectionTable(collection);
-    const row = this.getDb().prepare(`SELECT COUNT(*) AS cnt FROM "${collection}"`).get();
-    return (row?.cnt ?? 0) === 0;
+    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.ensureCollectionTable("system-settings");
+    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.ensureCollectionTable("system-settings");
+    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.ensureCollectionTable("system-settings");
+    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.ensureCollectionTable("addon-settings");
+    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 = JSON.parse(row.data);
+      const parsed = parseRowData(row.data);
       const key = row.id.startsWith(`${addonId}.`) ? row.id.slice(addonId.length + 1) : row.id;
-      result[key] = parsed.value ?? parsed;
+      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.ensureCollectionTable("addon-settings");
+    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 }));
       }
     })();
@@ -407,9 +425,41 @@ var SqliteSettingsBackend = class {
   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.ensureCollectionTable("system-settings");
+    this.requireDeclared("system-settings");
     const insert = this.getDb().prepare(
       'INSERT OR IGNORE INTO "system-settings" (id, data) VALUES (?, ?)'
     );
@@ -422,41 +472,73 @@ var SqliteSettingsBackend = class {
   // ---------------------------------------------------------------------------
   // 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;
   }
-  ensureCollectionTable(collection) {
-    if (this.ensuredTables.has(collection)) return;
-    this.getDb().exec(
-      `CREATE TABLE IF NOT EXISTS "${collection}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)`
-    );
-    this.ensuredTables.add(collection);
-  }
   getAllScoped(collection, scopeId) {
-    this.ensureCollectionTable(collection);
+    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 = JSON.parse(row.data);
+      const parsed = parseRowData(row.data);
       result[key] = parsed.value ?? parsed;
     }
     return result;
   }
   setScopedKey(collection, scopeId, key, value) {
-    this.ensureCollectionTable(collection);
+    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 (!schema) {
-      if (!this.ensuredTables.has(table)) {
-        this.getDb().exec(`CREATE TABLE IF NOT EXISTS "${table}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)`);
-        this.ensuredTables.add(table);
-      }
-      return;
-    }
     if (this.structuredTables.has(table)) return;
     const colDefs = schema.columns.map((col) => {
       const parts = [`"${col.name}" ${col.type}`];
@@ -468,6 +550,19 @@ var SqliteSettingsBackend = class {
       }
       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) {
@@ -523,12 +618,13 @@ var SqliteSettingsBackend = class {
       sql += ` OFFSET ?`;
       values.push(options.offset);
     }
-    return this.getDb().prepare(sql).all(...values);
+    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 row ?? null;
+    return (0, import_types2.asJsonObject)(row);
   }
   async tableCount(table, filter) {
     let sql = `SELECT COUNT(*) as count FROM "${table}"`;
@@ -538,8 +634,8 @@ var SqliteSettingsBackend = class {
       sql += whereSql;
       values.push(...whereValues);
     }
-    const row = this.getDb().prepare(sql).get(...values);
-    return row.count;
+    const row = (0, import_types2.asJsonObject)(this.getDb().prepare(sql).get(...values));
+    return typeof row?.count === "number" ? row.count : 0;
   }
   buildWhere(filter) {
     const conditions = [];
@@ -554,332 +650,49 @@ var SqliteSettingsBackend = class {
 };
 
 // src/builtins/sqlite-storage/sqlite-settings.addon.ts
-var SqliteSettingsAddon = class {
-  manifest = {
-    id: "sqlite-settings",
-    name: "SQLite Settings",
-    version: "1.0.0",
-    capabilities: [{ name: "settings-store", mode: "singleton" }]
-  };
+var import_types3 = require("@camstack/types");
+var SqliteSettingsAddon = class extends import_types3.BaseAddon {
   backend = null;
-  async initialize(context) {
-    const dbPath = context.storageProvider ? context.storageProvider.resolve("addons-data", `${context.id.replace("addon:", "")}/camstack.db`) : context.dataDir ? `${context.dataDir}/camstack.db` : "camstack-data/addons-data/sqlite-settings/camstack.db";
-    const runtimeDefaults = context.addonConfig._runtimeDefaults ?? {};
-    this.backend = new SqliteSettingsBackend(dbPath, runtimeDefaults);
+  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();
-    context.logger.info(`SQLite settings initialized at ${dbPath}`);
+    this.ctx.logger.info("Initialized successfully");
+    return [{ capability: import_types3.settingsStoreCapability, provider: this.backend }];
   }
-  async shutdown() {
+  async onShutdown() {
     await this.backend?.shutdown();
   }
   getBackend() {
     return this.backend;
   }
-  getCapabilityProvider(name) {
-    if (name === "settings-store" && this.backend) {
-      return this.backend;
-    }
-    return null;
-  }
-  getConfigSchema() {
-    return { sections: [] };
-  }
-  getConfig() {
-    return {};
-  }
-  async onConfigChange(_config) {
-  }
-};
-
-// src/builtins/sqlite-storage/sqlite-storage.provider.ts
-var import_better_sqlite32 = __toESM(require("better-sqlite3"));
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
-var import_node_crypto2 = require("crypto");
-var LOCATION_TYPES = {
-  // New location names (from StorageLocationManager)
-  data: "structured",
-  // settings, events, trails — SQL only
-  media: "files",
-  // crops, snapshots, thumbnails — files only
-  recordings: "files",
-  // video segments — files only
-  models: "files",
-  // ONNX/TFLite models — files only
-  cache: "files",
-  // temp files — files only
-  logs: "files",
-  // Winston log files — files only
-  // Legacy location names (backward compat)
-  config: "structured",
-  events: "structured",
-  addon: "both"
-};
-var SqliteStructuredStorage = class {
-  constructor(db) {
-    this.db = db;
-  }
-  ensuredTables = /* @__PURE__ */ new Set();
-  ensureTable(collection) {
-    if (this.ensuredTables.has(collection)) return;
-    this.db.exec(
-      `CREATE TABLE IF NOT EXISTS "${collection}" (id TEXT PRIMARY KEY, data TEXT)`
-    );
-    this.ensuredTables.add(collection);
-  }
-  async insert(record) {
-    this.ensureTable(record.collection);
-    const id = record.id || (0, import_node_crypto2.randomUUID)();
-    const newRecord = {
-      collection: record.collection,
-      id,
-      data: record.data
-    };
-    this.db.prepare(`INSERT INTO "${record.collection}" (id, data) VALUES (?, ?)`).run(id, JSON.stringify(newRecord.data));
-    return newRecord;
-  }
-  async query(collection, filter) {
-    this.ensureTable(collection);
-    const { sql, params } = this.buildSelect(collection, filter);
-    const rows = this.db.prepare(sql).all(...params);
-    return rows.map((row) => ({
-      collection,
-      id: row.id,
-      data: JSON.parse(row.data)
-    }));
-  }
-  async update(collection, id, data) {
-    this.ensureTable(collection);
-    this.db.prepare(`UPDATE "${collection}" SET data = ? WHERE id = ?`).run(JSON.stringify(data), id);
-    return { collection, id, data };
-  }
-  async delete(collection, id) {
-    this.ensureTable(collection);
-    this.db.prepare(`DELETE FROM "${collection}" WHERE id = ?`).run(id);
-  }
-  async count(collection, filter) {
-    this.ensureTable(collection);
-    const { sql, params } = this.buildCount(collection, filter);
-    const row = this.db.prepare(sql).get(...params);
-    return row.cnt;
-  }
-  buildWhereClause(filter) {
-    if (!filter) return { clause: "", params: [] };
-    const conditions = [];
-    const params = [];
-    if (filter.where) {
-      for (const [field, value] of Object.entries(filter.where)) {
-        if (field === "id") {
-          conditions.push("id = ?");
-          params.push(value);
-        } else {
-          conditions.push(`json_extract(data, '$.${field}') = ?`);
-          params.push(value);
-        }
-      }
-    }
-    if (filter.whereIn) {
-      for (const [field, values] of Object.entries(filter.whereIn)) {
-        const placeholders = values.map(() => "?").join(", ");
-        if (field === "id") {
-          conditions.push(`id IN (${placeholders})`);
-        } else {
-          conditions.push(`json_extract(data, '$.${field}') IN (${placeholders})`);
-        }
-        params.push(...values);
-      }
-    }
-    if (filter.whereBetween) {
-      for (const [field, [low, high]] of Object.entries(filter.whereBetween)) {
-        if (field === "id") {
-          conditions.push("id BETWEEN ? AND ?");
-        } else {
-          conditions.push(`json_extract(data, '$.${field}') BETWEEN ? AND ?`);
-        }
-        params.push(low, high);
-      }
-    }
-    const clause = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-    return { clause, params };
-  }
-  buildSelect(collection, filter) {
-    const { clause, params } = this.buildWhereClause(filter);
-    let sql = `SELECT id, data FROM "${collection}"${clause}`;
-    if (filter?.orderBy) {
-      const dir = filter.orderBy.direction === "desc" ? "DESC" : "ASC";
-      if (filter.orderBy.field === "id") {
-        sql += ` ORDER BY id ${dir}`;
-      } else {
-        sql += ` ORDER BY json_extract(data, '$.${filter.orderBy.field}') ${dir}`;
-      }
-    }
-    if (filter?.limit !== void 0) {
-      sql += ` LIMIT ?`;
-      params.push(filter.limit);
-    }
-    if (filter?.offset !== void 0) {
-      sql += ` OFFSET ?`;
-      params.push(filter.offset);
-    }
-    return { sql, params };
-  }
-  buildCount(collection, filter) {
-    const { clause, params } = this.buildWhereClause(filter);
-    return { sql: `SELECT COUNT(*) as cnt FROM "${collection}"${clause}`, params };
-  }
-};
-var FileSystemStorage = class {
-  constructor(basePath) {
-    this.basePath = basePath;
-  }
-  async readFile(filePath) {
-    const fullPath = path2.join(this.basePath, filePath);
-    return fs2.promises.readFile(fullPath);
-  }
-  async writeFile(filePath, data) {
-    const fullPath = path2.join(this.basePath, filePath);
-    fs2.mkdirSync(path2.dirname(fullPath), { recursive: true });
-    await fs2.promises.writeFile(fullPath, data);
-  }
-  async deleteFile(filePath) {
-    const fullPath = path2.join(this.basePath, filePath);
-    await fs2.promises.unlink(fullPath);
-  }
-  async listFiles(prefix) {
-    const searchDir = prefix ? path2.join(this.basePath, prefix) : this.basePath;
-    try {
-      const entries = await fs2.promises.readdir(searchDir, { recursive: true });
-      const files = [];
-      for (const entry of entries) {
-        const entryStr = String(entry);
-        const relative = prefix ? path2.join(prefix, entryStr) : entryStr;
-        const fullPath = path2.join(this.basePath, relative);
-        try {
-          const stat = await fs2.promises.stat(fullPath);
-          if (stat.isFile()) {
-            files.push(relative);
-          }
-        } catch {
-        }
-      }
-      return files;
-    } catch {
-      return [];
-    }
-  }
-  async getFileUrl(_path) {
-    return null;
-  }
-  async exists(filePath) {
-    const fullPath = path2.join(this.basePath, filePath);
-    try {
-      await fs2.promises.access(fullPath, fs2.constants.F_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-var SqliteStorageProvider = class {
-  mainDb = null;
-  sharedStructured = null;
-  locations = /* @__PURE__ */ new Map();
-  async initialize() {
-  }
-  /**
-   * Configure all storage locations.
-   * ONE single SQLite database (camstack.db) is used for ALL structured storage.
-   * File-based locations use the filesystem at their configured path.
-   */
-  async configure(config) {
-    const dataPath = config.locations["data"] ?? config.locations["config"] ?? Object.values(config.locations)[0];
-    if (!dataPath) throw new Error("No data path configured for SQLite storage");
-    fs2.mkdirSync(dataPath, { recursive: true });
-    const dbPath = path2.join(dataPath, "camstack.db");
-    this.mainDb = new import_better_sqlite32.default(dbPath);
-    this.mainDb.pragma("journal_mode = WAL");
-    this.sharedStructured = new SqliteStructuredStorage(this.mainDb);
-    for (const [name, dirPath] of Object.entries(config.locations)) {
-      const locationName = name;
-      const locationType = LOCATION_TYPES[name] ?? "files";
-      fs2.mkdirSync(dirPath, { recursive: true });
-      const location = {};
-      if (locationType === "structured" || locationType === "both") {
-        location.structured = this.sharedStructured;
-      }
-      if (locationType === "files" || locationType === "both") {
-        location.files = new FileSystemStorage(dirPath);
-      }
-      this.locations.set(locationName, location);
-    }
-  }
-  getLocation(name) {
-    const location = this.locations.get(name);
-    if (!location) {
-      throw new Error(`Storage location "${name}" not found`);
-    }
-    return location;
-  }
-  async shutdown() {
-    if (this.mainDb) {
-      this.mainDb.close();
-      this.mainDb = null;
-      this.sharedStructured = null;
-    }
-    this.locations.clear();
-  }
-  async export(_locationName) {
-    throw new Error("Export not yet implemented");
-  }
-  async import(_locationName, _data) {
-    throw new Error("Import not yet implemented");
-  }
-};
-
-// src/builtins/sqlite-storage/sqlite-storage.addon.ts
-var SqliteStorageAddon = class {
-  manifest = {
-    id: "sqlite-storage",
-    name: "SQLite Storage",
-    version: "1.0.0",
-    capabilities: ["storage"]
-  };
-  provider = null;
-  async initialize(context) {
-    const storageConfig = {
-      locations: { ...context.locationPaths }
-    };
-    this.provider = new SqliteStorageProvider();
-    await this.provider.configure(storageConfig);
-    context.logger.info("SQLite storage initialized");
-  }
-  async shutdown() {
-    await this.provider?.shutdown();
-  }
-  getProvider() {
-    if (!this.provider) throw new Error("SQLite storage not initialized");
-    return this.provider;
-  }
-  getCapabilityProvider(name) {
-    if (name === "storage" && this.provider) {
-      return this.provider;
-    }
-    return null;
-  }
-  getConfigSchema() {
-    return {
-      sections: []
-    };
-  }
-  getConfig() {
-    return {};
-  }
-  async onConfigChange(_config) {
-  }
 };
 
 // src/builtins/sqlite-storage/settings-store.ts
-var import_better_sqlite33 = __toESM(require("better-sqlite3"));
+var import_better_sqlite32 = __toESM(require("better-sqlite3"));
 
 // src/builtins/sqlite-storage/sql-schema.ts
 var CORE_TABLE_DDL = [
@@ -910,45 +723,59 @@ var CORE_TABLE_DDL = [
     updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
     PRIMARY KEY (device_id, key)
   )`,
-  // Detection events
-  `CREATE TABLE IF NOT EXISTS detection_events (
-    id TEXT PRIMARY KEY,
-    timestamp INTEGER NOT NULL,
-    device_id TEXT NOT NULL,
-    class_name TEXT NOT NULL,
-    score REAL NOT NULL,
-    severity TEXT NOT NULL,
-    track_id TEXT,
-    zones JSON,
-    recognition JSON,
-    media_files JSON,
-    data JSON
-  )`,
-  `CREATE INDEX IF NOT EXISTS idx_det_device_ts ON detection_events(device_id, timestamp)`,
-  `CREATE INDEX IF NOT EXISTS idx_det_class_ts ON detection_events(class_name, timestamp)`,
-  // Audio levels
-  `CREATE TABLE IF NOT EXISTS audio_levels (
-    id TEXT PRIMARY KEY,
-    timestamp INTEGER NOT NULL,
-    device_id TEXT NOT NULL,
-    dbfs REAL NOT NULL,
-    rms REAL NOT NULL,
-    state TEXT NOT NULL
-  )`,
-  `CREATE INDEX IF NOT EXISTS idx_audio_device_ts ON audio_levels(device_id, timestamp)`,
-  // Track trails
-  `CREATE TABLE IF NOT EXISTS track_trails (
-    track_id TEXT PRIMARY 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 (
+    addon_id TEXT NOT NULL,
     device_id TEXT NOT NULL,
-    class_name TEXT NOT NULL,
-    first_seen INTEGER NOT NULL,
-    last_seen INTEGER NOT NULL,
-    positions JSON NOT NULL,
-    snapshots JSON,
-    total_distance REAL,
-    zones_visited JSON
+    key TEXT NOT NULL,
+    value JSON NOT NULL,
+    updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+    PRIMARY KEY (addon_id, device_id, key)
   )`,
-  `CREATE INDEX IF NOT EXISTS idx_trails_device_ts ON track_trails(device_id, first_seen)`
+  // 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 (
+  id                INTEGER PRIMARY KEY AUTOINCREMENT,
+  addon_id          TEXT NOT NULL,
+  stable_id         TEXT NOT NULL,
+  type              TEXT NOT NULL,
+  name              TEXT NOT NULL,
+  parent_stable_id  TEXT,
+  role              TEXT,
+  enabled           INTEGER DEFAULT 1,
+  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 (
+  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`
 ];
 function addonTableToDdl(schema) {
   const pks = schema.columns.filter((c) => c.primaryKey).map((c) => c.name);
@@ -973,11 +800,11 @@ function addonTableToDdl(schema) {
 }
 
 // src/builtins/sqlite-storage/settings-store.ts
-var import_kernel = require("@camstack/kernel");
+var import_types4 = require("@camstack/types");
 var SettingsStore = class {
   db;
   constructor(dbPath) {
-    this.db = new import_better_sqlite33.default(dbPath);
+    this.db = new import_better_sqlite32.default(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
     this.initTables();
@@ -1080,6 +907,42 @@ var SettingsStore = class {
     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). */
@@ -1097,7 +960,7 @@ var SettingsStore = class {
       `INSERT OR IGNORE INTO system_settings (key, value, updated_at) VALUES (?, json(?), unixepoch())`
     );
     this.db.transaction(() => {
-      for (const [key, value] of Object.entries(import_kernel.RUNTIME_DEFAULTS)) {
+      for (const [key, value] of Object.entries(import_types4.RUNTIME_DEFAULTS)) {
         insert.run(key, JSON.stringify(value));
       }
     })();
@@ -1110,20 +973,90 @@ var SettingsStore = class {
       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
+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);
+  }
+};
+
+// 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)
+           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)
+           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);
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CORE_TABLE_DDL,
-  FileSystemStorage,
+  ConfigStore,
+  DeviceStore,
   FilesystemStorageAddon,
   FilesystemStorageProvider,
   SettingsStore,
   SqliteSettingsAddon,
   SqliteSettingsBackend,
-  SqliteStorageAddon,
-  SqliteStorageProvider,
   addonTableToDdl
 });
 //# sourceMappingURL=index.js.map