@camstack/core 0.1.13 → 0.1.15

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

@@ -34,19 +34,50 @@ __export(sqlite_settings_addon_exports, {
   default: () => sqlite_settings_addon_default
 });
 module.exports = __toCommonJS(sqlite_settings_addon_exports);
+var import_types2 = require("@camstack/types");
 
 // 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_types = require("@camstack/types");
+function parseRowData(raw) {
+  return (0, import_types.asJsonObject)((0, import_types.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) {
@@ -56,11 +87,30 @@ var SqliteSettingsBackend = class {
     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;
@@ -68,148 +118,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 }));
       }
     })();
@@ -230,9 +387,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 (?, ?)'
     );
@@ -245,41 +434,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}`];
@@ -291,6 +512,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) {
@@ -346,12 +580,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_types.asJsonObject)(r) ? [(0, import_types.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_types.asJsonObject)(row);
   }
   async tableCount(table, filter) {
     let sql = `SELECT COUNT(*) as count FROM "${table}"`;
@@ -361,8 +596,8 @@ var SqliteSettingsBackend = class {
       sql += whereSql;
       values.push(...whereValues);
     }
-    const row = this.getDb().prepare(sql).get(...values);
-    return row.count;
+    const row = (0, import_types.asJsonObject)(this.getDb().prepare(sql).get(...values));
+    return typeof row?.count === "number" ? row.count : 0;
   }
   buildWhere(filter) {
     const conditions = [];
@@ -377,41 +612,44 @@ 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 SqliteSettingsAddon = class extends import_types2.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_types2.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_types2.RUNTIME_DEFAULTS });
     await this.backend.initialize();
-    context.logger.info(`SQLite settings initialized at ${dbPath}`);
+    this.ctx.logger.info("Initialized successfully");
+    return [{ capability: import_types2.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) {
-  }
 };
 var sqlite_settings_addon_default = SqliteSettingsAddon;
 // Annotate the CommonJS export names for ESM import in node: