@cancia/astro 0.9.0 → 0.11.0

package/dist/{chunk-DIV2FFYX.js → chunk-GD37XVES.js}

@@ -103,6 +103,15 @@ function makeListsRoutes(ctx) {
       if (!body || !Array.isArray(body.ids) || !body.ids.every((id2) => typeof id2 === "string")) {
         return json({ error: "`ids` must be a string array" }, 400);
       }
+      if (typeof body.knownCount === "number") {
+        const existing = await lists.translations(site, parsed.listName);
+        if (existing.length !== body.knownCount) {
+          return json({
+            error: "This list changed while you were reordering it. Close and reopen the panel to see the latest entries.",
+            code: "REV_CONFLICT"
+          }, 409);
+        }
+      }
       try {
         await lists.reorder(site, parsed.listName, body.ids);
         return json({ ok: true });

package/dist/{chunk-WVHTCFE6.js → chunk-QQEUCOXQ.js}

@@ -45,6 +45,17 @@ var defineField = {
   },
   slug: (o) => z.string().regex(/^[a-z0-9-]+$/).meta({ widget: "slug", ...o }),
   image: (o) => z.string().url().meta({ widget: "image", ...o }),
+  /**
+   * An uploaded document — a PDF today.
+   *
+   * Stores a URL exactly as `image` does, because the upload path is the same:
+   * the file goes to the configured store (R2, or public/uploads) and what
+   * comes back is a plain URL. A separate widget rather than reusing `image`
+   * so the editor renders a filename and a download affordance instead of a
+   * thumbnail, and so an `image` field cannot silently accept a PDF and
+   * render a broken <img>.
+   */
+  file: (o) => z.string().url().meta({ widget: "file", ...o }),
   select: (o) => z.enum(o.options).meta({ widget: "select", ...o }),
   /**
    * A repeatable list of a single member type. `member` is any Zod type,
@@ -93,7 +104,14 @@ var defineField = {
    */
   link: (o) => z.object({
     label: z.string(),
-    href: z.string().refine(isSafeHref, "unsafe or unsupported URL scheme")
+    // An EMPTY href is allowed: it means "this link has no destination
+    // yet", which is a state the editor must be able to save — otherwise a
+    // client cannot clear a URL at all, and the form rejects a field they
+    // deliberately emptied. `isSafeHref("")` is false (correct for
+    // rendering, where an empty href must not become an anchor), so the
+    // empty case is permitted here explicitly rather than by loosening the
+    // guard. Anything non-empty still has to pass it.
+    href: z.string().refine((h) => h === "" || isSafeHref(h), "unsafe or unsupported URL scheme")
   }).meta({ widget: "link", ...o }),
   /**
    * A constrained rich-text body. Stored as a Portable-Text SUBSET array (D4):

package/dist/{chunk-5IPHDIC6.js → chunk-RHFTQW4W.js}

@@ -3,6 +3,15 @@ var SITE_RE = /^[a-z0-9][a-z0-9._-]*$/i;
 function isValidSite(site) {
   return SITE_RE.test(site);
 }
+function detectFileType(buf) {
+  if ([37, 80, 68, 70, 45].every((b, i) => buf[i] === b)) {
+    return { mime: "application/pdf", ext: "pdf" };
+  }
+  return null;
+}
+function detectUploadType(buf) {
+  return detectImageType(buf) ?? detectFileType(buf);
+}
 function detectImageType(buf) {
   const startsWith = (sig, offset = 0) => sig.every((b, i) => buf[offset + i] === b);
   if (startsWith([255, 216, 255])) return { mime: "image/jpeg", ext: "jpg" };
@@ -15,5 +24,5 @@ function detectImageType(buf) {
 
 export {
   isValidSite,
-  detectImageType
+  detectUploadType
 };

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-HQIGNRIU.js → chunk-T2GDBQJ7.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-VL6FO446.js";
 import {
   describeList
-} from "./chunk-WVHTCFE6.js";
+} from "./chunk-QQEUCOXQ.js";
 
 // src/routes/schemas.ts
 function json(body, status = 200) {

package/dist/{chunk-GBTFXQEA.js → chunk-TUZNTXZR.js}

@@ -1,16 +1,33 @@
 import {
-  createJsonFileAdapterV2
-} from "./chunk-2NVZWZPE.js";
+  createJsonFileAdapterV2,
+  createSqliteAdapterV2
+} from "./chunk-S5YLB6P3.js";
 import {
   isDraft
-} from "./chunk-WVHTCFE6.js";
+} from "./chunk-QQEUCOXQ.js";
+
+// src/loader/index.ts
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+
+// src/storage/resolve.ts
+import { isAbsolute, join } from "path";
+function resolveDbPath(dbPath, projectRoot) {
+  return isAbsolute(dbPath) ? dbPath : join(projectRoot, dbPath);
+}
+function resolveReadStorage(desc, projectRoot) {
+  if (desc?.kind === "sqlite-v2") {
+    const dbPath = desc.dbPath ? resolveDbPath(desc.dbPath, projectRoot) : join(projectRoot, "cancia.db");
+    return createSqliteAdapterV2({ dbPath });
+  }
+  return createJsonFileAdapterV2({ projectRoot });
+}
 
 // src/loader/index.ts
-import { join } from "path";
 function makeId(locale, entryId) {
   return `${locale}/${entryId}`;
 }
-async function syncOnce(ctx, lists, list, site, schema, includeDrafts) {
+async function syncOnce(ctx, lists, list, site, schema, includeDrafts, usingJsonFile = false, projectRoot = "") {
   ctx.store.clear();
   const all = await lists.list(site, list);
   const drafts = schema?.draftField && !includeDrafts ? all.filter((e) => isDraft(schema, e.data)) : [];
@@ -30,6 +47,11 @@ async function syncOnce(ctx, lists, list, site, schema, includeDrafts) {
       digest: entry._rev
     });
   }
+  if (entries.length === 0 && usingJsonFile && existsSync(join2(projectRoot, "cancia.db"))) {
+    ctx.logger.warn(
+      `cancia: list "${list}" is empty, but a cancia.db exists at the project root and this loader is reading JSON files. Pass db: { kind: "sqlite" } to canciaLoader() to match your integration's db option \u2014 otherwise every entry the client saves is invisible to the build.`
+    );
+  }
   const skipped = drafts.length ? ` (${drafts.length} draft${drafts.length === 1 ? "" : "s"} skipped)` : "";
   ctx.logger.info(
     `cancia: loaded ${entries.length} entr${entries.length === 1 ? "y" : "ies"} from list "${list}"${skipped}`
@@ -44,15 +66,27 @@ function canciaLoader(opts) {
     name: `@cancia/astro/loader[${opts.list}]`,
     async load(ctx) {
       latestCtx = ctx;
-      const storage = opts.storage ?? createJsonFileAdapterV2({
-        projectRoot: opts.projectRoot ?? process.cwd()
-      });
+      const projectRoot = opts.projectRoot ?? process.cwd();
+      const storage = opts.storage ?? resolveReadStorage(
+        opts.db ? { kind: opts.db.kind === "sqlite" ? "sqlite-v2" : "json-file", dbPath: opts.db.path } : void 0,
+        projectRoot
+      );
       const { lists } = storage;
-      await syncOnce(ctx, lists, opts.list, opts.site, opts.schema, opts.includeDrafts);
+      const usingJsonFile = !opts.storage && opts.db?.kind !== "sqlite";
+      await syncOnce(
+        ctx,
+        lists,
+        opts.list,
+        opts.site,
+        opts.schema,
+        opts.includeDrafts,
+        usingJsonFile,
+        projectRoot
+      );
       if (ctx.watcher && !watcherAttached) {
         watcherAttached = true;
         const root = opts.projectRoot ?? process.cwd();
-        const watchDir = join(root, ".cancia", "lists", opts.list, opts.site);
+        const watchDir = join2(root, ".cancia", "lists", opts.list, opts.site);
         ctx.watcher.add(watchDir);
         const scheduleSync = () => {
           if (pendingTimer) clearTimeout(pendingTimer);
@@ -66,7 +100,9 @@ function canciaLoader(opts) {
                 opts.list,
                 opts.site,
                 opts.schema,
-                opts.includeDrafts
+                opts.includeDrafts,
+                usingJsonFile,
+                projectRoot
               ).catch((err) => {
                 latestCtx.logger.error(`cancia: resync failed \u2014 ${err.message}`);
               })

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
+};