@cancia/astro 0.10.0 → 0.12.0

package/dist/{chunk-2NVZWZPE.js → chunk-S5YLB6P3.js}

@@ -339,15 +339,318 @@ function createJsonFileAdapterV2(opts = {}) {
   };
 }
 
+// src/storage/sqlite-v2.ts
+import { createRequire } from "module";
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+var require2 = createRequire(import.meta.url);
+function openDB(dbPath) {
+  const Database = require2("better-sqlite3");
+  if (dbPath !== ":memory:") mkdirSync3(dirname3(dbPath), { recursive: true });
+  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 makePageStore2(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 makeListStore2(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 readOrder2(site, listName) {
+    const row = getOrderStmt.get(site, listName);
+    if (!row) return [];
+    return JSON.parse(row.ids);
+  }
+  function writeOrder2(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 = readOrder2(site, listName);
+      const next = orderAfterCreate(order, id);
+      if (next !== order) writeOrder2(site, listName, next);
+    }
+  );
+  const deleteTx = db.transaction((site, listName, id, locale) => {
+    deleteEntryStmt.run(site, listName, id, locale);
+    const stillExists = distinctIds(site, listName).has(id);
+    const order = readOrder2(site, listName);
+    const next = orderAfterDelete(order, id, stillExists);
+    if (next !== order) writeOrder2(site, listName, next);
+  });
+  const reorderTx = db.transaction(
+    (site, listName, order, dropped) => {
+      for (const id of dropped) {
+        deleteEntryAllLocalesStmt.run(site, listName, id);
+      }
+      writeOrder2(site, listName, order);
+    }
+  );
+  return {
+    async list(site, listName, locale) {
+      const order = readOrder2(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 ?? randomUUID2();
+      const existing = getEntryStmt.get(site, listName, finalId, locale);
+      if (existing) {
+        throw new Error(entryExistsMessage(finalId, 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(entryNotFoundMessage(id, 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);
+      const { order, dropped } = planReorder(ids, all, listName);
+      reorderTx(site, listName, order, dropped);
+    },
+    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 = readOrder2(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: makePageStore2(db),
+    lists: makeListStore2(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);
+  }
+}
+
 export {
   createJsonFileAdapter,
   canonicalize,
   hashRev,
-  applyOrder,
-  orderAfterCreate,
-  orderAfterDelete,
-  planReorder,
-  entryExistsMessage,
-  entryNotFoundMessage,
-  createJsonFileAdapterV2
+  createJsonFileAdapterV2,
+  createSqliteAdapterV2,
+  closeSqliteAdapterV2
 };

package/dist/{chunk-LJSSPOSW.js → chunk-VF3EXXEM.js}

@@ -1,15 +1,127 @@
 import {
-  detectImageType,
+  detectUploadType,
   isValidSite
-} from "./chunk-5IPHDIC6.js";
+} from "./chunk-RHFTQW4W.js";
 import {
-  createGitBackedAdapter,
-  createSqliteAdapterV2
-} from "./chunk-MXVOJRAM.js";
+  guardRequest
+} from "./chunk-4PYVIIOO.js";
+import {
+  createGitBackedAdapter
+} from "./chunk-XINNLVZP.js";
 import {
   createJsonFileAdapter,
-  createJsonFileAdapterV2
-} from "./chunk-2NVZWZPE.js";
+  createJsonFileAdapterV2,
+  createSqliteAdapterV2
+} from "./chunk-S5YLB6P3.js";
+
+// src/auth/sqlite-store.ts
+import { createRequire } from "module";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+var require2 = createRequire(import.meta.url);
+var connections = /* @__PURE__ */ new Map();
+function openAuthDB(dbPath) {
+  const cached = connections.get(dbPath);
+  if (cached) return cached;
+  const Database = require2("better-sqlite3");
+  if (dbPath !== ":memory:") mkdirSync(dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS editors (
+      site TEXT NOT NULL, email TEXT NOT NULL, last_seen_at TEXT,
+      PRIMARY KEY (site, email)
+    );
+    CREATE TABLE IF NOT EXISTS sessions (
+      site TEXT NOT NULL, id TEXT NOT NULL, email TEXT NOT NULL,
+      created_at TEXT NOT NULL, expires_at TEXT NOT NULL,
+      PRIMARY KEY (site, id)
+    );
+    CREATE TABLE IF NOT EXISTS login_tokens (
+      site TEXT NOT NULL, hash TEXT NOT NULL, email TEXT NOT NULL,
+      expires_at TEXT NOT NULL,
+      PRIMARY KEY (site, hash)
+    );
+  `);
+  connections.set(dbPath, db);
+  return db;
+}
+function createSqliteAuthStore(opts) {
+  const db = openAuthDB(opts.dbPath);
+  const insertEditor = db.prepare(
+    `INSERT INTO editors (site, email, last_seen_at) VALUES (?, ?, NULL)
+     ON CONFLICT(site, email) DO NOTHING`
+  );
+  const deleteOtherEditors = db.prepare("DELETE FROM editors WHERE site=?");
+  const selectEditor = db.prepare("SELECT email FROM editors WHERE site=? AND email=?");
+  const insertToken = db.prepare(
+    `INSERT INTO login_tokens (site, hash, email, expires_at) VALUES (?, ?, ?, ?)
+     ON CONFLICT(site, hash) DO NOTHING`
+  );
+  const selectToken = db.prepare(
+    "SELECT hash, email, expires_at FROM login_tokens WHERE site=? AND hash=?"
+  );
+  const deleteToken = db.prepare("DELETE FROM login_tokens WHERE site=? AND hash=?");
+  const insertSession = db.prepare(
+    "INSERT INTO sessions (site, id, email, created_at, expires_at) VALUES (?, ?, ?, ?, ?)"
+  );
+  const selectSession = db.prepare(
+    "SELECT id, email, created_at, expires_at FROM sessions WHERE site=? AND id=?"
+  );
+  const touchStmt = db.prepare("UPDATE sessions SET expires_at=? WHERE site=? AND id=?");
+  const deleteSessionStmt = db.prepare("DELETE FROM sessions WHERE site=? AND id=?");
+  const purgeTokens = db.prepare("DELETE FROM login_tokens WHERE site=? AND expires_at<=?");
+  const purgeSessions = db.prepare("DELETE FROM sessions WHERE site=? AND expires_at<=?");
+  const seedTx = db.transaction((site, emails) => {
+    deleteOtherEditors.run(site);
+    for (const email of emails) insertEditor.run(site, email);
+  });
+  const consumeTx = db.transaction((site, hash) => {
+    const row = selectToken.get(site, hash);
+    if (!row) return void 0;
+    deleteToken.run(site, hash);
+    return row;
+  });
+  return {
+    async seedEditors(site, emails) {
+      seedTx(site, emails);
+    },
+    async isEditor(site, email) {
+      return selectEditor.get(site, email) !== void 0;
+    },
+    async createLoginToken(site, rec) {
+      insertToken.run(site, rec.hash, rec.email, rec.expiresAt);
+    },
+    async consumeLoginToken(site, hash) {
+      const row = consumeTx(site, hash);
+      if (!row) return null;
+      return { hash: row.hash, email: row.email, expiresAt: row.expires_at };
+    },
+    async createSession(site, rec) {
+      insertSession.run(site, rec.id, rec.email, rec.createdAt, rec.expiresAt);
+    },
+    async getSession(site, id) {
+      const row = selectSession.get(site, id);
+      if (!row) return null;
+      return {
+        id: row.id,
+        email: row.email,
+        createdAt: row.created_at,
+        expiresAt: row.expires_at
+      };
+    },
+    async touchSession(site, id, expiresAt) {
+      touchStmt.run(expiresAt, site, id);
+    },
+    async deleteSession(site, id) {
+      deleteSessionStmt.run(site, id);
+    },
+    async purgeExpired(site, now) {
+      purgeTokens.run(site, now);
+      purgeSessions.run(site, now);
+    }
+  };
+}
 
 // src/routes/upload.ts
 import { writeFile, mkdir } from "fs/promises";
@@ -27,14 +139,10 @@ function makeLocalUploadHandler(opts) {
     return `${publicUrlBase}/${site}/${name}`;
   };
 }
-function makeUploadRoute(uploadHandler, secret, maxMB = 10) {
+function makeUploadRoute(uploadHandler, secret, maxMB = 10, auth) {
   return async ({ request }) => {
-    if (secret) {
-      const token = request.headers.get("Authorization")?.replace("Bearer ", "").trim();
-      if (token !== secret) {
-        return new Response(JSON.stringify({ error: "Unauthorized" }), { status: 401 });
-      }
-    }
+    const deny = (await guardRequest(request, { secret, auth })).deny;
+    if (deny) return deny;
     const form = await request.formData().catch(() => null);
     const file = form?.get("file");
     const site = form?.get("site");
@@ -51,9 +159,9 @@ function makeUploadRoute(uploadHandler, secret, maxMB = 10) {
       return new Response(JSON.stringify({ error: `File too large (max ${maxMB}MB)` }), { status: 413 });
     }
     const buf = new Uint8Array(await file.arrayBuffer());
-    const detected = detectImageType(buf);
+    const detected = detectUploadType(buf);
     if (!detected) {
-      return new Response(JSON.stringify({ error: "File type not allowed" }), { status: 415 });
+      return new Response(JSON.stringify({ error: "That file type is not supported. Use a JPEG, PNG, GIF, WebP, AVIF or PDF." }), { status: 415 });
     }
     const url = await uploadHandler(file, site, detected);
     return new Response(JSON.stringify({ url }), {
@@ -188,6 +296,18 @@ function buildRuntimeFromBaked(baked) {
   const storageV2 = buildStorageV2(baked, projectRoot);
   const storage = storageV2 ? storageV2.kv : lazyJsonFileAdapter(projectRoot);
   const uploadHandler = buildUploadHandler(baked, projectRoot);
+  const site = baked.site ?? "default";
+  const auth = baked.editors?.length ? {
+    store: createSqliteAuthStore({
+      dbPath: baked.authDbPath ? resolveDbPath(baked.authDbPath, projectRoot) : `${projectRoot}/cancia.db`
+    }),
+    site
+  } : void 0;
+  if (auth) {
+    auth.store.seedEditors(site, baked.editors.map((e) => e.trim().toLowerCase())).catch((err) => {
+      console.error(`[cancia] could not seed editors: ${err?.message ?? err}`);
+    });
+  }
   return {
     storage,
     storageV2,
@@ -196,6 +316,8 @@ function buildRuntimeFromBaked(baked) {
     defaultLocale: baked.defaultLocale,
     locales: baked.locales,
     secret,
+    site,
+    auth,
     uploadHandler,
     deployHook,
     deployHookToken,
@@ -269,6 +391,7 @@ export {
   makeLocalUploadHandler,
   makeUploadRoute,
   makeR2UploadHandler,
+  createSqliteAuthStore,
   setBakedConfig,
   setCanciaRuntime,
   __resetRuntimeForTests,

package/dist/chunk-XINNLVZP.js

@@ -0,0 +1,183 @@
+import {
+  createGitHubClient
+} from "./chunk-U7V53JX7.js";
+
+// 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 {
+  createGitBackedAdapter
+};