@cancia/astro 0.2.1 → 0.4.0

package/dist/chunk-5AUIPW2I.js

@@ -0,0 +1,518 @@
+import {
+  createGitHubClient
+} from "./chunk-U7V53JX7.js";
+import {
+  hashRev
+} from "./chunk-L2VKQJPY.js";
+import {
+  RevConflictError
+} from "./chunk-7IA5B5CF.js";
+
+// src/storage/sqlite-v2.ts
+import { createRequire } from "module";
+import { randomUUID } from "crypto";
+var require2 = createRequire(import.meta.url);
+function openDB(dbPath) {
+  const Database = require2("better-sqlite3");
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS kv (
+      site TEXT NOT NULL, key TEXT NOT NULL, lang TEXT NOT NULL, value TEXT NOT NULL,
+      PRIMARY KEY (site, key, lang)
+    );
+    CREATE TABLE IF NOT EXISTS pages (
+      site TEXT NOT NULL, route TEXT NOT NULL, meta TEXT NOT NULL,
+      PRIMARY KEY (site, route)
+    );
+    CREATE TABLE IF NOT EXISTS list_entries (
+      site TEXT NOT NULL, list TEXT NOT NULL, id TEXT NOT NULL, locale TEXT NOT NULL,
+      data TEXT NOT NULL,
+      created_at TEXT NOT NULL, updated_at TEXT NOT NULL,
+      PRIMARY KEY (site, list, id, locale)
+    );
+    CREATE TABLE IF NOT EXISTS list_order (
+      site TEXT NOT NULL, list TEXT NOT NULL, ids TEXT NOT NULL,
+      PRIMARY KEY (site, list)
+    );
+  `);
+  return db;
+}
+function makeKVStore(db) {
+  const getStmt = db.prepare("SELECT value FROM kv WHERE site=? AND key=? AND lang=?");
+  const setStmt = db.prepare(
+    `INSERT INTO kv (site, key, lang, value) VALUES (?, ?, ?, ?)
+     ON CONFLICT(site, key, lang) DO UPDATE SET value=excluded.value`
+  );
+  const getAllStmt = db.prepare("SELECT key, lang, value FROM kv WHERE site=?");
+  const delStmt = db.prepare("DELETE FROM kv WHERE site=? AND key=? AND lang=?");
+  return {
+    async get(site, key, lang) {
+      const row = getStmt.get(site, key, lang);
+      return row?.value ?? null;
+    },
+    async set(site, key, lang, value) {
+      setStmt.run(site, key, lang, value);
+    },
+    async getAll(site) {
+      const rows = getAllStmt.all(site);
+      const out = {};
+      for (const r of rows) out[`${r.key}.${r.lang}`] = r.value;
+      return out;
+    },
+    async delete(site, key, lang) {
+      delStmt.run(site, key, lang);
+    }
+  };
+}
+function makePageStore(db) {
+  const getStmt = db.prepare("SELECT meta FROM pages WHERE site=? AND route=?");
+  const listStmt = db.prepare("SELECT route, meta FROM pages WHERE site=?");
+  const upsertStmt = db.prepare(
+    `INSERT INTO pages (site, route, meta) VALUES (?, ?, ?)
+     ON CONFLICT(site, route) DO UPDATE SET meta=excluded.meta`
+  );
+  const delStmt = db.prepare("DELETE FROM pages WHERE site=? AND route=?");
+  function parseMeta(raw) {
+    return JSON.parse(raw);
+  }
+  return {
+    async get(site, route) {
+      const row = getStmt.get(site, route);
+      if (!row) return null;
+      const meta = parseMeta(row.meta);
+      return { route, meta, _rev: hashRev(meta) };
+    },
+    async list(site) {
+      const rows = listStmt.all(site);
+      return rows.map((r) => {
+        const meta = parseMeta(r.meta);
+        return { route: r.route, meta, _rev: hashRev(meta) };
+      });
+    },
+    async set(site, route, meta, rev) {
+      const existing = getStmt.get(site, route);
+      if (existing) {
+        const currentRev = hashRev(parseMeta(existing.meta));
+        if (rev !== currentRev) throw new RevConflictError();
+      }
+      upsertStmt.run(site, route, JSON.stringify(meta));
+      return { route, meta, _rev: hashRev(meta) };
+    },
+    async delete(site, route) {
+      delStmt.run(site, route);
+    }
+  };
+}
+function rowToEntry(row) {
+  const data = JSON.parse(row.data);
+  return {
+    id: row.id,
+    locale: row.locale,
+    data,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    _rev: hashRev(data)
+  };
+}
+function applyOrder(order, ids) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of order) {
+    if (ids.has(id)) {
+      result.push(id);
+      seen.add(id);
+    }
+  }
+  const extras = [...ids].filter((id) => !seen.has(id)).sort();
+  return [...result, ...extras];
+}
+function makeListStore(db) {
+  const getOrderStmt = db.prepare("SELECT ids FROM list_order WHERE site=? AND list=?");
+  const upsertOrderStmt = db.prepare(
+    `INSERT INTO list_order (site, list, ids) VALUES (?, ?, ?)
+     ON CONFLICT(site, list) DO UPDATE SET ids=excluded.ids`
+  );
+  const getEntryStmt = db.prepare(
+    "SELECT id, locale, data, created_at, updated_at FROM list_entries WHERE site=? AND list=? AND id=? AND locale=?"
+  );
+  const allEntriesStmt = db.prepare(
+    "SELECT id, locale, data, created_at, updated_at FROM list_entries WHERE site=? AND list=? ORDER BY locale"
+  );
+  const localeEntriesStmt = db.prepare(
+    "SELECT id, locale, data, created_at, updated_at FROM list_entries WHERE site=? AND list=? AND locale=?"
+  );
+  const insertEntryStmt = db.prepare(
+    `INSERT INTO list_entries (site, list, id, locale, data, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+  const updateEntryStmt = db.prepare(
+    "UPDATE list_entries SET data=?, updated_at=? WHERE site=? AND list=? AND id=? AND locale=?"
+  );
+  const deleteEntryStmt = db.prepare(
+    "DELETE FROM list_entries WHERE site=? AND list=? AND id=? AND locale=?"
+  );
+  const deleteEntryAllLocalesStmt = db.prepare(
+    "DELETE FROM list_entries WHERE site=? AND list=? AND id=?"
+  );
+  const distinctIdsStmt = db.prepare(
+    "SELECT DISTINCT id FROM list_entries WHERE site=? AND list=?"
+  );
+  function readOrder(site, listName) {
+    const row = getOrderStmt.get(site, listName);
+    if (!row) return [];
+    return JSON.parse(row.ids);
+  }
+  function writeOrder(site, listName, ids) {
+    upsertOrderStmt.run(site, listName, JSON.stringify(ids));
+  }
+  function distinctIds(site, listName) {
+    const rows = distinctIdsStmt.all(site, listName);
+    return new Set(rows.map((r) => r.id));
+  }
+  const createTx = db.transaction(
+    (site, listName, id, locale, dataJson, now) => {
+      insertEntryStmt.run(site, listName, id, locale, dataJson, now, now);
+      const order = readOrder(site, listName);
+      if (!order.includes(id)) {
+        writeOrder(site, listName, [...order, id]);
+      }
+    }
+  );
+  const deleteTx = db.transaction((site, listName, id, locale) => {
+    deleteEntryStmt.run(site, listName, id, locale);
+    const stillExists = distinctIds(site, listName).has(id);
+    if (!stillExists) {
+      const order = readOrder(site, listName);
+      const next = order.filter((existingId) => existingId !== id);
+      if (next.length !== order.length) {
+        writeOrder(site, listName, next);
+      }
+    }
+  });
+  const reorderTx = db.transaction((site, listName, ids) => {
+    const all = distinctIds(site, listName);
+    const supplied = new Set(ids);
+    for (const id of all) {
+      if (!supplied.has(id)) {
+        deleteEntryAllLocalesStmt.run(site, listName, id);
+      }
+    }
+    writeOrder(site, listName, ids);
+  });
+  return {
+    async list(site, listName, locale) {
+      const order = readOrder(site, listName);
+      if (locale !== void 0) {
+        const rows2 = localeEntriesStmt.all(site, listName, locale);
+        const byId2 = /* @__PURE__ */ new Map();
+        for (const r of rows2) byId2.set(r.id, r);
+        const sorted = applyOrder(order, new Set(byId2.keys()));
+        const entries2 = [];
+        for (const id of sorted) {
+          const r = byId2.get(id);
+          if (r) entries2.push(rowToEntry(r));
+        }
+        return entries2;
+      }
+      const rows = allEntriesStmt.all(site, listName);
+      const byId = /* @__PURE__ */ new Map();
+      const allIds = /* @__PURE__ */ new Set();
+      for (const r of rows) {
+        allIds.add(r.id);
+        const list = byId.get(r.id) ?? [];
+        list.push(r);
+        byId.set(r.id, list);
+      }
+      const sortedIds = applyOrder(order, allIds);
+      const entries = [];
+      for (const id of sortedIds) {
+        const group = byId.get(id) ?? [];
+        for (const r of group) entries.push(rowToEntry(r));
+      }
+      return entries;
+    },
+    async get(site, listName, id, locale) {
+      const row = getEntryStmt.get(site, listName, id, locale);
+      return row ? rowToEntry(row) : null;
+    },
+    async create(site, listName, data, locale, id) {
+      const finalId = id ?? randomUUID();
+      const existing = getEntryStmt.get(site, listName, finalId, locale);
+      if (existing) {
+        throw new Error(`List entry "${finalId}" already exists in "${listName}" (${locale})`);
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      createTx(site, listName, finalId, locale, JSON.stringify(data), now);
+      return {
+        id: finalId,
+        locale,
+        data,
+        createdAt: now,
+        updatedAt: now,
+        _rev: hashRev(data)
+      };
+    },
+    async update(site, listName, id, locale, data, rev) {
+      const existing = getEntryStmt.get(site, listName, id, locale);
+      if (!existing) {
+        throw new Error(`List entry "${id}" not found in "${listName}" (${locale})`);
+      }
+      const existingData = JSON.parse(existing.data);
+      if (hashRev(existingData) !== rev) throw new RevConflictError();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      updateEntryStmt.run(JSON.stringify(data), now, site, listName, id, locale);
+      return {
+        id,
+        locale,
+        data,
+        createdAt: existing.created_at,
+        updatedAt: now,
+        _rev: hashRev(data)
+      };
+    },
+    async delete(site, listName, id, locale) {
+      const existing = getEntryStmt.get(site, listName, id, locale);
+      if (!existing) return;
+      deleteTx(site, listName, id, locale);
+    },
+    async reorder(site, listName, ids) {
+      const all = distinctIds(site, listName);
+      for (const id of ids) {
+        if (!all.has(id)) {
+          throw new Error(`Cannot reorder: entry "${id}" not found in "${listName}"`);
+        }
+      }
+      reorderTx(site, listName, ids);
+    },
+    async translations(site, listName) {
+      const rows = allEntriesStmt.all(site, listName);
+      const idToLocales = /* @__PURE__ */ new Map();
+      for (const r of rows) {
+        const list = idToLocales.get(r.id) ?? [];
+        list.push(r.locale);
+        idToLocales.set(r.id, list);
+      }
+      const order = readOrder(site, listName);
+      const orderedIds = applyOrder(order, new Set(idToLocales.keys()));
+      return orderedIds.map((id) => ({
+        id,
+        locales: idToLocales.get(id) ?? []
+      }));
+    }
+  };
+}
+var _connections = /* @__PURE__ */ new Map();
+function getConnection(dbPath) {
+  let db = _connections.get(dbPath);
+  if (!db) {
+    db = openDB(dbPath);
+    _connections.set(dbPath, db);
+  }
+  return db;
+}
+function createSqliteAdapterV2(opts = {}) {
+  const root = opts.projectRoot ?? process.cwd();
+  const dbPath = opts.dbPath ?? `${root}/cancia.db`;
+  const db = getConnection(dbPath);
+  return {
+    kv: makeKVStore(db),
+    pages: makePageStore(db),
+    lists: makeListStore(db)
+  };
+}
+function closeSqliteAdapterV2(dbPath) {
+  if (dbPath === void 0) {
+    for (const db2 of _connections.values()) db2.close();
+    _connections.clear();
+    return;
+  }
+  const db = _connections.get(dbPath);
+  if (db) {
+    db.close();
+    _connections.delete(dbPath);
+  }
+}
+
+// src/storage/git-backed.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, relative } from "path";
+function createGitBackedAdapter(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const branch = opts.branch ?? "main";
+  const debounceMs = opts.debounceMs ?? 3e3;
+  const commitMessage = opts.commitMessage ?? "Cancia: content update";
+  const warn = opts.warn ?? ((m) => console.warn(m));
+  const onError = opts.onError ?? ((m, e) => console.error(m, e));
+  const kvPath = opts.contentPaths?.kvPath ?? join(projectRoot, "cancia-content.json");
+  const pagesPath = opts.contentPaths?.pagesPath ?? join(projectRoot, ".cancia", "pages.json");
+  const listsDir = opts.contentPaths?.listsDir ?? join(projectRoot, ".cancia", "lists");
+  const token = opts.token ?? process.env.CANCIA_GITHUB_TOKEN ?? "";
+  let client = null;
+  if (opts.client) {
+    client = opts.client;
+  } else if (token) {
+    client = createGitHubClient({
+      repo: opts.repo,
+      branch,
+      token,
+      committer: opts.committer,
+      fetch: opts.fetch,
+      apiBase: opts.apiBase
+    });
+  }
+  const gitEnabled = client !== null;
+  if (!gitEnabled) {
+    warn(
+      "[cancia] Git-backed storage: no GitHub token (CANCIA_GITHUB_TOKEN) \u2014 running local-only. Edits save to disk but are NOT committed/pushed."
+    );
+  }
+  const dirty = /* @__PURE__ */ new Set();
+  let timer = null;
+  let flushing = null;
+  let rerunRequested = false;
+  function toRepoPath(absPath) {
+    return relative(projectRoot, absPath).split("\\").join("/");
+  }
+  function markDirty(absPath) {
+    dirty.add(absPath);
+  }
+  function markListDirty(listName, site) {
+    const siteDir = join(listsDir, listName, site);
+    if (!existsSync(siteDir)) return;
+    const walk = (dir) => {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) walk(full);
+        else if (entry.isFile()) markDirty(full);
+      }
+    };
+    walk(siteDir);
+  }
+  function scheduleFlush() {
+    if (!gitEnabled) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      void runFlush();
+    }, debounceMs);
+  }
+  async function runFlush() {
+    if (flushing) {
+      rerunRequested = true;
+      return flushing;
+    }
+    flushing = doFlush().finally(() => {
+      flushing = null;
+      if (rerunRequested) {
+        rerunRequested = false;
+        void runFlush();
+      }
+    });
+    return flushing;
+  }
+  async function doFlush() {
+    if (!client || dirty.size === 0) return;
+    const batch = [...dirty];
+    const files = [];
+    for (const abs of batch) {
+      if (!existsSync(abs) || !statSync(abs).isFile()) continue;
+      files.push({ path: toRepoPath(abs), content: readFileSync(abs, "utf-8") });
+    }
+    if (files.length === 0) {
+      for (const abs of batch) dirty.delete(abs);
+      return;
+    }
+    try {
+      await client.commitFiles(files, commitMessage);
+      for (const abs of batch) dirty.delete(abs);
+    } catch (err) {
+      onError(
+        "[cancia] Git-backed storage: commit failed \u2014 data saved locally, will retry on next flush.",
+        err
+      );
+      throw err;
+    }
+  }
+  async function flush() {
+    if (!gitEnabled) return;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    await runFlush();
+  }
+  const kv = {
+    get: (site, key, lang) => opts.local.kv.get(site, key, lang),
+    getAll: (site) => opts.local.kv.getAll(site),
+    async set(site, key, lang, value) {
+      await opts.local.kv.set(site, key, lang, value);
+      markDirty(kvPath);
+      scheduleFlush();
+    },
+    async delete(site, key, lang) {
+      await opts.local.kv.delete(site, key, lang);
+      markDirty(kvPath);
+      scheduleFlush();
+    }
+  };
+  const pages = {
+    get: (site, route) => opts.local.pages.get(site, route),
+    list: (site) => opts.local.pages.list(site),
+    async set(site, route, meta, rev) {
+      const result = await opts.local.pages.set(site, route, meta, rev);
+      markDirty(pagesPath);
+      scheduleFlush();
+      return result;
+    },
+    async delete(site, route) {
+      await opts.local.pages.delete(site, route);
+      markDirty(pagesPath);
+      scheduleFlush();
+    }
+  };
+  const lists = {
+    list: (site, listName, locale) => opts.local.lists.list(site, listName, locale),
+    get: (site, listName, id, locale) => opts.local.lists.get(site, listName, id, locale),
+    translations: (site, listName) => opts.local.lists.translations(site, listName),
+    async create(site, listName, data, locale, id) {
+      const entry = await opts.local.lists.create(site, listName, data, locale, id);
+      markListDirty(listName, site);
+      scheduleFlush();
+      return entry;
+    },
+    async update(site, listName, id, locale, data, rev) {
+      const entry = await opts.local.lists.update(site, listName, id, locale, data, rev);
+      markListDirty(listName, site);
+      scheduleFlush();
+      return entry;
+    },
+    async delete(site, listName, id, locale) {
+      await opts.local.lists.delete(site, listName, id, locale);
+      markListDirty(listName, site);
+      scheduleFlush();
+    },
+    async reorder(site, listName, ids) {
+      await opts.local.lists.reorder(site, listName, ids);
+      markListDirty(listName, site);
+      scheduleFlush();
+    }
+  };
+  const git = {
+    flush,
+    get gitEnabled() {
+      return gitEnabled;
+    },
+    pendingPaths() {
+      return [...dirty].map(toRepoPath);
+    }
+  };
+  return { kv, pages, lists, git };
+}
+
+export {
+  createSqliteAdapterV2,
+  closeSqliteAdapterV2,
+  createGitBackedAdapter
+};

package/dist/chunk-BMCI2F2Y.js

@@ -0,0 +1,45 @@
+import {
+  createGitHubClient
+} from "./chunk-U7V53JX7.js";
+
+// src/publish-hook.ts
+async function firePublish(hook, opts = {}) {
+  if (!hook) return { ok: false, kind: "no-hook" };
+  const headers = { ...opts.headers ?? {} };
+  if (opts.token) headers.Authorization = `Bearer ${opts.token}`;
+  const init = { method: opts.method ?? "POST" };
+  if (Object.keys(headers).length > 0) init.headers = headers;
+  try {
+    const res = await fetch(hook, init);
+    if (!res.ok) return { ok: false, kind: "bad-response", status: res.status };
+    return { ok: true };
+  } catch {
+    return { ok: false, kind: "unreachable" };
+  }
+}
+
+// src/publish-dispatch.ts
+var CANCIA_PUBLISH_EVENT = "cancia-publish";
+async function fireDispatch(opts) {
+  if (!opts.repo || !opts.token) return { ok: false, kind: "not-configured" };
+  const client = createGitHubClient({
+    repo: opts.repo,
+    // branch is irrelevant for dispatch (repo-level event) but required by the
+    // client's options — a harmless placeholder.
+    branch: "main",
+    token: opts.token,
+    fetch: opts.fetch,
+    apiBase: opts.apiBase
+  });
+  try {
+    await client.dispatch(opts.eventType ?? CANCIA_PUBLISH_EVENT, opts.clientPayload);
+    return { ok: true };
+  } catch {
+    return { ok: false, kind: "failed" };
+  }
+}
+
+export {
+  firePublish,
+  fireDispatch
+};

package/dist/{chunk-ST44VULL.js → chunk-L2VKQJPY.js}

@@ -48,10 +48,8 @@ function createJsonFileAdapter(filePath) {
   };
 }
 
-// src/storage/json-file-v2.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, rmSync } from "fs";
-import { dirname as dirname2, join } from "path";
-import { createHash, randomUUID } from "crypto";
+// src/storage/rev.ts
+import { createHash } from "crypto";
 function canonicalize(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
   if (Array.isArray(value)) {
@@ -64,6 +62,11 @@ function canonicalize(value) {
 function hashRev(value) {
   return createHash("sha256").update(canonicalize(value)).digest("hex").slice(0, 16);
 }
+
+// src/storage/json-file-v2.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, rmSync } from "fs";
+import { dirname as dirname2, join } from "path";
+import { randomUUID } from "crypto";
 function readJsonFile(filePath, fallback) {
   if (!existsSync2(filePath)) return fallback;
   try {
@@ -315,5 +318,7 @@ function createJsonFileAdapterV2(opts = {}) {
 
 export {
   createJsonFileAdapter,
+  canonicalize,
+  hashRev,
   createJsonFileAdapterV2
 };

package/dist/{chunk-7MPOERVU.js → chunk-U46HCJN3.js}

@@ -1,10 +1,11 @@
 import {
-  createGitBackedAdapter
-} from "./chunk-5ELSN6LI.js";
+  createGitBackedAdapter,
+  createSqliteAdapterV2
+} from "./chunk-5AUIPW2I.js";
 import {
   createJsonFileAdapter,
   createJsonFileAdapterV2
-} from "./chunk-ST44VULL.js";
+} from "./chunk-L2VKQJPY.js";
 import {
   detectImageType,
   isValidSite
@@ -156,6 +157,7 @@ function makeR2UploadHandler(opts) {
 }
 
 // src/runtime.ts
+import { isAbsolute, join as join2 } from "path";
 var _runtime = null;
 var _bakedConfig = null;
 function setBakedConfig(config) {
@@ -169,6 +171,9 @@ function buildRuntimeFromBaked(baked) {
   const token = process.env.CANCIA_TOKEN?.trim() || "";
   const secret = baked.public ? void 0 : token || void 0;
   const deployHook = process.env.CANCIA_DEPLOY_HOOK || void 0;
+  const deployHookToken = process.env.CANCIA_DEPLOY_HOOK_TOKEN || void 0;
+  const publishRepo = baked.publishRepo || void 0;
+  const publishGithubToken = process.env.CANCIA_GITHUB_TOKEN?.trim() || void 0;
   const storageV2 = buildStorageV2(baked, projectRoot);
   const storage = storageV2 ? storageV2.kv : lazyJsonFileAdapter(projectRoot);
   const uploadHandler = buildUploadHandler(baked, projectRoot);
@@ -182,12 +187,20 @@ function buildRuntimeFromBaked(baked) {
     secret,
     uploadHandler,
     deployHook,
+    deployHookToken,
+    deployHookMethod: baked.deployHookMethod,
+    deployHookHeaders: baked.deployHookHeaders,
+    publishRepo,
+    publishGithubToken,
     maxUploadMB: baked.maxUploadMB
   };
 }
 function lazyJsonFileAdapter(projectRoot) {
   return createJsonFileAdapter(projectRoot + "/cancia-content.json");
 }
+function resolveDbPath(dbPath, projectRoot) {
+  return isAbsolute(dbPath) ? dbPath : join2(projectRoot, dbPath);
+}
 function buildStorageV2(baked, projectRoot) {
   const desc = baked.storage;
   if (!desc) return void 0;
@@ -204,6 +217,10 @@ function buildStorageV2(baked, projectRoot) {
       commitMessage: desc.commitMessage
     });
   }
+  if (desc.kind === "sqlite-v2") {
+    const dbPath = desc.dbPath ? resolveDbPath(desc.dbPath, projectRoot) : `${projectRoot}/cancia.db`;
+    return createSqliteAdapterV2({ dbPath });
+  }
   return createJsonFileAdapterV2({ projectRoot });
 }
 function buildUploadHandler(baked, projectRoot) {