@bitcobblers/wod-wiki-storage 0.39.2143 → 0.40.2145

package/dist/sql/index.mjs

@@ -1,4 +1,7 @@
-import { STORE_DEFS, extractKeyPart, validateStorageRow, isRange, DB_VERSION, rowsEqual, validateStoredPins, DOMAIN_PROJECTION_VERSION, bufferToOps, stampUserOwned, bufferedGet, overlayRows, rangeFromIDB, isDirty, keyFromValue, bufferSlot, COLUMN_TYPES, keyInRange, compareKeys } from '../chunk-NUJEAUAK.mjs';
+import { DOMAIN_PROJECTION_VERSION, bufferToOps, bufferedGet, overlayRows, isDirty, bufferSlot } from '../chunk-JFVXIJJI.mjs';
+import { getRows, storeDefinition, deleteRows, clearRows, SCHEMA_TABLE, decodeRowJson, initializeStore, putRow, wipeRows, getRow, listRowsFromIndexMany, listRows, countRows, putRows, deleteIn, batchInsert, SYNC_STATE_TABLE, encodeRowJson } from '../chunk-IFLOX2TK.mjs';
+export { SCHEMA_TABLE, SYNC_OPS_TABLE, SYNC_STATE_TABLE, applySyncBatch, clearRows, countRows, decodeRowJson, deleteRows, encodeRowJson, fetchSyncOps, getRow, getRows, initSyncTarget, initializeStore, listRows, listRowsFromIndexMany, probeSyncTarget, putRow, putRows, readLegacyRows, readRawSyncOps, storeDefinition, wipeRows } from '../chunk-IFLOX2TK.mjs';
+import { rowsEqual, validateStoredPins, DB_VERSION, STORE_DEFS, stampUserOwned, rangeFromIDB, keyFromValue, isRange } from '../chunk-IMNG2HY5.mjs';
 import { libsqlDatabase } from '../chunk-6ZTAWTAP.mjs';
 export { libsqlDatabase } from '../chunk-6ZTAWTAP.mjs';
 import { StorageError } from '../chunk-XRQKLSOT.mjs';
@@ -6,606 +9,6 @@ export { StorageError } from '../chunk-XRQKLSOT.mjs';
 import { catalogOfItem, sourceMatches } from '@bitcobblers/wod-wiki-wql';
 import { createClient } from '@libsql/client/web';
 
-// src/sql/codec.ts
-var TAG = "$binary";
-var LEN = "$bytes";
-function bytesToBase64(bytes) {
-  let binary = "";
-  const CHUNK = 32768;
-  for (let i = 0; i < bytes.length; i += CHUNK) {
-    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
-  }
-  return btoa(binary);
-}
-function base64ToBytes(base64) {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-  return bytes;
-}
-function reviveBinary(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
-  const keys = Object.keys(value);
-  if (keys.length !== 2 || !keys.includes(TAG) || !keys.includes(LEN)) return value;
-  const tag = value;
-  if (typeof tag[TAG] !== "string" || typeof tag[LEN] !== "number") return value;
-  const bytes = base64ToBytes(tag[TAG]);
-  if (bytes.length !== tag[LEN]) {
-    throw new Error(`corrupt binary cell: declared ${tag[LEN]} bytes, decoded ${bytes.length}`);
-  }
-  return bytes.buffer;
-}
-var canonicalJson = (_key, value) => {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
-  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, Reflect.get(value, key)]));
-};
-function encodeRowJson(value, binaryField) {
-  if (binaryField && value !== null && typeof value === "object" && !Array.isArray(value)) {
-    const row = value;
-    const data = row[binaryField];
-    if (data instanceof ArrayBuffer) {
-      const bytes = new Uint8Array(data);
-      return JSON.stringify({ ...row, [binaryField]: { [TAG]: bytesToBase64(bytes), [LEN]: bytes.length } }, canonicalJson);
-    }
-  }
-  return JSON.stringify(value, canonicalJson);
-}
-function decodeRowJson(text2, binaryField) {
-  const row = JSON.parse(text2);
-  if (binaryField && row !== null && typeof row === "object" && !Array.isArray(row)) {
-    const record = row;
-    const revived = reviveBinary(record[binaryField]);
-    if (revived !== record[binaryField]) record[binaryField] = revived;
-  }
-  return row;
-}
-
-// src/sql/store.ts
-var SCHEMA_TABLE = "_wodwiki_schema";
-var SCHEMA_KEY = "schema";
-var ADDED_STORES_BY_VERSION = {
-  31: ["equipment", "block_equipment"]
-};
-function additiveStoresSince(stored) {
-  const added = /* @__PURE__ */ new Set();
-  for (const [version, names] of Object.entries(ADDED_STORES_BY_VERSION)) {
-    if (Number(version) > stored) for (const name of names) added.add(name);
-  }
-  return added;
-}
-var BINARY_FIELD = { attachments: "data" };
-var binaryFieldOf = (def) => BINARY_FIELD[def.name];
-function storeDefinition(name) {
-  const def = STORE_DEFS.find((d) => d.name === name);
-  if (!def) throw new StorageError(404, `unknown store: ${name}`);
-  return def;
-}
-function indexDefinition(def, indexName) {
-  const idx = def.indexes.find((i) => i.name === indexName);
-  if (!idx) throw new StorageError(404, `unknown index: ${def.name}.${indexName}`);
-  return idx;
-}
-function sanitize(name) {
-  return name.replace(/[^A-Za-z0-9_]/g, "_");
-}
-var indexCol = (indexName, part) => `i_${sanitize(indexName)}_${part}`;
-function keyCols(def) {
-  return def.keyPath.map((_, i) => `k${i}`);
-}
-var junctionTable = (def, idx) => `${def.name}__${sanitize(idx.name)}`;
-var multiEntryIndex = (def) => def.indexes.find((i) => i.multiEntry);
-function pathType(def, path) {
-  return COLUMN_TYPES[def.name][path] ?? "text";
-}
-function colSql(dialect, type) {
-  if (dialect === "sqlite") return "";
-  return type === "text" ? ' TEXT COLLATE "C"' : " DOUBLE PRECISION";
-}
-function toSqlScalar(v) {
-  if (v === null || v === void 0) return null;
-  if (typeof v === "boolean") return v ? 1 : 0;
-  if (typeof v === "number" || typeof v === "string") return v;
-  return JSON.stringify(v);
-}
-function validateKey(key) {
-  const scalar = (v) => typeof v === "string" || typeof v === "number" && Number.isFinite(v);
-  if (!scalar(key) && !(Array.isArray(key) && key.length > 0 && key.every(scalar))) {
-    throw new StorageError(400, "key must be a string, finite number, or non-empty scalar tuple");
-  }
-}
-function validateRange(range) {
-  if (range === void 0) return;
-  if (range === null || typeof range !== "object" || Array.isArray(range)) {
-    throw new StorageError(400, "range must be an object");
-  }
-  for (const key of [range.only, range.lower, range.upper]) {
-    if (key !== void 0) validateKey(key);
-  }
-  for (const open of [range.lowerOpen, range.upperOpen]) {
-    if (open !== void 0 && typeof open !== "boolean") {
-      throw new StorageError(400, "range open flags must be boolean");
-    }
-  }
-}
-function toParts(key) {
-  validateKey(key);
-  return Array.isArray(key) ? key : [key];
-}
-function arrayPart(value, dotted) {
-  let cur = value;
-  for (const part of dotted.split(".")) {
-    if (cur === null || typeof cur !== "object") return void 0;
-    const row = cur;
-    cur = row[part];
-  }
-  return Array.isArray(cur) ? cur : void 0;
-}
-function requireKey(def, value) {
-  const parts = def.keyPath.map((p) => extractKeyPart(value, p));
-  for (const [i, part] of parts.entries()) {
-    if (part === void 0) {
-      throw new StorageError(400, `keyPath part '${def.keyPath[i]}' missing on ${def.name} value`);
-    }
-  }
-  const key = parts;
-  return key.length === 1 ? key[0] : key;
-}
-function rangeWhere(cols, range, params) {
-  if (!range) return "";
-  if (range.only !== void 0) {
-    const parts = toParts(range.only);
-    if (parts.length > cols.length) return null;
-    const clauses2 = parts.map((p, i) => {
-      params.push(toSqlScalar(p));
-      return `"${cols[i]}" = ?`;
-    });
-    return ` WHERE ${clauses2.join(" AND ")}`;
-  }
-  const bounds = [];
-  if (range.lower !== void 0 && range.lower !== null) {
-    bounds.push([toParts(range.lower), range.lowerOpen ? ">" : ">="]);
-  }
-  if (range.upper !== void 0 && range.upper !== null) {
-    bounds.push([toParts(range.upper), range.upperOpen ? "<" : "<="]);
-  }
-  const clauses = [];
-  for (const [parts, op] of bounds) {
-    if (parts.length > cols.length) return null;
-    if (parts.length === 1) {
-      params.push(toSqlScalar(parts[0]));
-      clauses.push(`"${cols[0]}" ${op} ?`);
-    } else {
-      const ors = parts.map((p, i) => {
-        const eqs = [];
-        for (let j = 0; j < i; j++) {
-          params.push(toSqlScalar(parts[j]));
-          eqs.push(`"${cols[j]}" = ?`);
-        }
-        params.push(toSqlScalar(p));
-        const cmpOp = i === parts.length - 1 ? op : op[0];
-        eqs.push(`"${cols[i]}" ${cmpOp} ?`);
-        return `(${eqs.join(" AND ")})`;
-      });
-      clauses.push(`(${ors.join(" OR ")})`);
-    }
-  }
-  return clauses.length ? ` WHERE ${clauses.join(" AND ")}` : "";
-}
-function clampLimit(count) {
-  if (count === void 0) return void 0;
-  if (typeof count !== "number" || !Number.isFinite(count)) {
-    throw new StorageError(400, `invalid count: ${String(count)}`);
-  }
-  return Math.max(0, Math.floor(count));
-}
-var limitClause = (count) => count === void 0 ? "" : ` LIMIT ${clampLimit(count)}`;
-function parseRows(rows, binaryField) {
-  return rows.map((r) => decodeRowJson(r.data, binaryField));
-}
-async function scanRows(conn, def, idx, range, limit) {
-  const rows = await conn.query(`SELECT "data" FROM "${def.name}"`);
-  const keyed = [];
-  for (const row of rows) {
-    const value = decodeRowJson(row.data, binaryFieldOf(def));
-    if (idx) {
-      const parts = idx.keyPath.map((p) => extractKeyPart(value, p));
-      if (!parts.every((p) => p !== void 0)) continue;
-      const key = parts.length === 1 ? parts[0] : parts;
-      if (range && !keyInRange(key, range)) continue;
-      keyed.push([key, value]);
-    } else {
-      const key = requireKey(def, value);
-      if (range && !keyInRange(key, range)) continue;
-      keyed.push([key, value]);
-    }
-  }
-  keyed.sort((a, b) => compareKeys(a[0], b[0]));
-  const out = keyed.map(([, v]) => v);
-  return limit === void 0 ? out : out.slice(0, limit);
-}
-async function getRow(conn, def, key) {
-  const parts = toParts(key);
-  if (parts.length !== def.keyPath.length) {
-    throw new StorageError(400, `key arity ${parts.length} != keyPath arity ${def.keyPath.length} for ${def.name}`);
-  }
-  const cond = keyCols(def).map((c) => `"${c}" = ?`).join(" AND ");
-  const rows = await conn.query(
-    `SELECT "data" FROM "${def.name}" WHERE ${cond}`,
-    parts.map(toSqlScalar)
-  );
-  return rows[0] ? decodeRowJson(rows[0].data, binaryFieldOf(def)) : void 0;
-}
-async function getRows(conn, def, keys) {
-  const found = /* @__PURE__ */ new Map();
-  for (const part of chunks(keys, 50)) {
-    const params = [];
-    const conditions = part.map((key) => {
-      const parts = toParts(key);
-      if (parts.length !== def.keyPath.length) throw new StorageError(400, "invalid compound key arity");
-      params.push(...parts.map(toSqlScalar));
-      return `(${keyCols(def).map((col) => `"${col}" = ?`).join(" AND ")})`;
-    });
-    for (const row of await conn.query(`SELECT "data" FROM "${def.name}" WHERE ${conditions.join(" OR ")}`, params)) {
-      const value = decodeRowJson(String(row.data), binaryFieldOf(def));
-      found.set(JSON.stringify(requireKey(def, value)), value);
-    }
-  }
-  return keys.map((key) => found.get(JSON.stringify(key)));
-}
-async function listRowsFromIndexMany(conn, def, indexName, keys) {
-  const idx = indexDefinition(def, indexName);
-  if (idx.multiEntry) {
-    const out = [];
-    for (const key of keys) out.push(await listRows(conn, def, { only: key }, void 0, indexName));
-    return out;
-  }
-  const found = /* @__PURE__ */ new Map();
-  for (const part of chunks(keys, 50)) {
-    const params = [];
-    const conditions = part.map((key) => {
-      const parts = toParts(key);
-      if (parts.length !== idx.keyPath.length) throw new StorageError(400, "invalid index key arity");
-      params.push(...parts.map(toSqlScalar));
-      return `(${parts.map((_, i) => `"${indexCol(idx.name, i)}" = ?`).join(" AND ")})`;
-    });
-    for (const row of await conn.query(`SELECT "data" FROM "${def.name}" WHERE ${conditions.join(" OR ")} ORDER BY ${keyCols(def).map((col) => `"${col}"`).join(", ")}`, params)) {
-      const value = decodeRowJson(String(row.data), binaryFieldOf(def));
-      const parts = idx.keyPath.map((path) => extractKeyPart(value, path));
-      const key = JSON.stringify(parts.length === 1 ? parts[0] : parts);
-      const bucket = found.get(key);
-      if (bucket) bucket.push(value);
-      else found.set(key, [value]);
-    }
-  }
-  return keys.map((key) => found.get(JSON.stringify(key)) ?? []);
-}
-async function listRows(conn, def, range, count, indexName) {
-  validateRange(range);
-  const idx = indexName ? indexDefinition(def, indexName) : void 0;
-  const binaryField = binaryFieldOf(def);
-  if (idx?.multiEntry) {
-    const only = range?.only;
-    if (only === void 0 || typeof only === "object") {
-      throw new StorageError(400, `multi-entry index ${def.name}.${idx.name} supports exact-match queries only`);
-    }
-    const joinOn = keyCols(def).map((c) => `j."${c}" = e."${c}"`).join(" AND ");
-    const order2 = ['j."v"', ...keyCols(def).map((c) => `j."${c}"`)].join(", ");
-    const rows2 = await conn.query(
-      `SELECT e."data" AS "data" FROM "${def.name}" e JOIN "${junctionTable(def, idx)}" j ON ${joinOn} WHERE j."v" = ? ORDER BY ${order2}${limitClause(count)}`,
-      [JSON.stringify(only)]
-    );
-    return parseRows(rows2, binaryField);
-  }
-  const cols = idx ? idx.keyPath.map((_, part) => indexCol(idx.name, part)) : keyCols(def);
-  const params = [];
-  const where = rangeWhere(cols, range, params);
-  if (where === null) return scanRows(conn, def, idx, range, clampLimit(count));
-  const notNull = cols.map((c) => `"${c}" IS NOT NULL`).join(" AND ");
-  const cond = where ? `${where} AND ${notNull}` : ` WHERE ${notNull}`;
-  const keyNames = keyCols(def).filter((k) => !cols.includes(k));
-  const order = ` ORDER BY ${[...cols, ...keyNames].map((c) => `"${c}"`).join(", ")}`;
-  const rows = await conn.query(
-    `SELECT "data" FROM "${def.name}"${cond}${order}${limitClause(count)}`,
-    params
-  );
-  return parseRows(rows, binaryField);
-}
-async function countRows(conn, def, range, indexName) {
-  validateRange(range);
-  const idx = indexName ? indexDefinition(def, indexName) : void 0;
-  if (idx?.multiEntry) {
-    const only = range?.only;
-    if (only === void 0 || typeof only === "object") {
-      throw new StorageError(400, `multi-entry index ${def.name}.${idx.name} supports exact-match queries only`);
-    }
-    const joinOn = keyCols(def).map((c) => `j."${c}" = e."${c}"`).join(" AND ");
-    const rows2 = await conn.query(
-      `SELECT COUNT(*) AS "n" FROM "${def.name}" e JOIN "${junctionTable(def, idx)}" j ON ${joinOn} WHERE j."v" = ?`,
-      [JSON.stringify(only)]
-    );
-    return Number(rows2[0]?.n ?? 0);
-  }
-  const cols = idx ? idx.keyPath.map((_, part) => indexCol(idx.name, part)) : keyCols(def);
-  const params = [];
-  const where = rangeWhere(cols, range, params);
-  if (where === null) {
-    const all = await scanRows(conn, def, idx, range, void 0);
-    return all.length;
-  }
-  const cond = idx ? where ? `${where} AND ${cols.map((c) => `"${c}" IS NOT NULL`).join(" AND ")}` : ` WHERE ${cols.map((c) => `"${c}" IS NOT NULL`).join(" AND ")}` : where;
-  const rows = await conn.query(`SELECT COUNT(*) AS "n" FROM "${def.name}"${cond}`, params);
-  return Number(rows[0]?.n ?? 0);
-}
-var PARAM_BUDGET = 2e4;
-var ROW_CAP = 100;
-var chunks = (arr, size) => {
-  const out = [];
-  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
-  return out;
-};
-async function batchInsert(conn, table, cols, rows, onConflict) {
-  if (rows.length === 0) return;
-  const collist = cols.map((c) => `"${c}"`).join(", ");
-  const tuple = `(${cols.map(() => "?").join(", ")})`;
-  const per = Math.max(1, Math.min(ROW_CAP, Math.floor(PARAM_BUDGET / cols.length)));
-  const statements = chunks(rows, per).map((part) => ({
-    sql: `INSERT INTO "${table}" (${collist}) VALUES ${part.map(() => tuple).join(", ")} ${onConflict}`,
-    params: part.flat()
-  }));
-  if (conn.batch) await conn.batch(statements);
-  else for (const statement of statements) await conn.exec(statement.sql, statement.params);
-}
-async function deleteIn(conn, table, col, vals) {
-  for (const part of chunks(vals, 500)) {
-    if (part.length === 0) continue;
-    await conn.exec(`DELETE FROM "${table}" WHERE "${col}" IN (${part.map(() => "?").join(", ")})`, part);
-  }
-}
-async function putRows(conn, def, values, changedKeys) {
-  if (values.length === 0) return [];
-  for (const value of values) validateStorageRow(def.name, value);
-  const keys = keyCols(def);
-  const cols = [...keys];
-  for (const idx of def.indexes) {
-    if (idx.multiEntry) continue;
-    idx.keyPath.forEach((_, part) => cols.push(indexCol(idx.name, part)));
-  }
-  cols.push("data");
-  const keySet = new Set(keys);
-  const updates = cols.filter((c) => !keySet.has(c)).map((c) => `"${c}" = excluded."${c}"`).join(", ");
-  const pk = keys.map((k) => `"${k}"`).join(", ");
-  const rows = [];
-  const out = [];
-  const junction = [];
-  const multi = multiEntryIndex(def);
-  for (const value of values) {
-    const k = requireKey(def, value);
-    const keyParts = toParts(k).map(toSqlScalar);
-    const vals = [...keyParts];
-    for (const idx of def.indexes) {
-      if (idx.multiEntry) continue;
-      idx.keyPath.forEach((path) => vals.push(toSqlScalar(extractKeyPart(value, path) ?? null)));
-    }
-    vals.push(encodeRowJson(value, binaryFieldOf(def)));
-    rows.push(vals);
-    out.push(k);
-    if (multi) {
-      const items = arrayPart(value, multi.keyPath[0]);
-      if (Array.isArray(items)) {
-        for (const item of items) junction.push([...keyParts, JSON.stringify(item)]);
-      }
-    }
-  }
-  const tuple = `(${cols.map(() => "?").join(", ")})`;
-  const per = Math.max(1, Math.min(ROW_CAP, Math.floor(PARAM_BUDGET / cols.length)));
-  const statements = chunks(rows, per).map((part) => ({
-    sql: `INSERT INTO "${def.name}" (${cols.map((col) => `"${col}"`).join(", ")}) VALUES ${part.map(() => tuple).join(", ")} ` + (def.name === "block_revisions" ? `ON CONFLICT (${pk}) DO NOTHING` : `ON CONFLICT (${pk}) DO UPDATE SET ${updates} WHERE "${def.name}"."data" <> excluded."data"`) + ` RETURNING ${keys.map((col) => `"${col}"`).join(", ")}`,
-    params: part.flat()
-  }));
-  let returned;
-  try {
-    if (conn.batch) returned = await conn.batch(statements);
-    else {
-      returned = [];
-      for (const statement of statements) returned.push(await conn.query(statement.sql, statement.params));
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    for (const code of ["revision_conflict", "transaction_conflict", "invalid_session_pin"]) {
-      if (message.includes(code)) throw new StorageError(409, message, code);
-    }
-    throw error;
-  }
-  const changed = returned.flat().map((row) => {
-    const parts = keys.map((col) => row[col]);
-    return parts.length === 1 ? parts[0] : parts;
-  });
-  changedKeys?.push(...changed);
-  if (multi) {
-    const jt = junctionTable(def, multi);
-    const changedSet = new Set(changed.map((key) => JSON.stringify(key)));
-    const deletes = values.flatMap((value) => {
-      const key = requireKey(def, value);
-      if (!changedSet.has(JSON.stringify(key))) return [];
-      const items = arrayPart(value, multi.keyPath[0]) ?? [];
-      return [{
-        sql: `DELETE FROM "${jt}" WHERE ${keys.map((col) => `"${col}" = ?`).join(" AND ")}` + (items.length ? ` AND "v" NOT IN (${items.map(() => "?").join(", ")})` : ""),
-        params: [...toParts(key).map(toSqlScalar), ...items.map((item) => JSON.stringify(item))]
-      }];
-    });
-    if (conn.batch && deletes.length) await conn.batch(deletes);
-    else for (const statement of deletes) await conn.exec(statement.sql, statement.params);
-    await batchInsert(conn, jt, [...keys, "v"], junction.filter((row) => changedSet.has(JSON.stringify(keys.length === 1 ? row[0] : row.slice(0, keys.length)))), "ON CONFLICT DO NOTHING");
-  }
-  return out;
-}
-async function putRow(conn, def, value) {
-  return (await putRows(conn, def, [value]))[0];
-}
-async function deleteRows(conn, def, keyOrRange) {
-  if (def.name === "block_revisions") throw new StorageError(409, "block history may only be removed by explicit wipe", "revision_conflict");
-  const multi = multiEntryIndex(def);
-  if (!isRange(keyOrRange)) {
-    const parts = toParts(keyOrRange);
-    if (parts.length > def.keyPath.length) {
-      throw new StorageError(400, `key arity ${parts.length} > keyPath arity ${def.keyPath.length} for ${def.name}`);
-    }
-    const n = Math.min(parts.length, def.keyPath.length);
-    const cond = keyCols(def).slice(0, n).map((c) => `"${c}" = ?`).join(" AND ");
-    const params2 = parts.slice(0, n).map(toSqlScalar);
-    if (multi) await conn.exec(`DELETE FROM "${junctionTable(def, multi)}" WHERE ${cond}`, params2);
-    await conn.exec(`DELETE FROM "${def.name}" WHERE ${cond}`, params2);
-    return;
-  }
-  validateRange(keyOrRange);
-  const cols = keyCols(def);
-  const params = [];
-  const where = rangeWhere(cols, keyOrRange, params);
-  if (where === null) {
-    for (const row of await listRows(conn, def, keyOrRange)) {
-      await deleteRows(conn, def, requireKey(def, row));
-    }
-    return;
-  }
-  const collist = cols.map((c) => `"${c}"`).join(", ");
-  if (multi) {
-    await conn.exec(
-      `DELETE FROM "${junctionTable(def, multi)}" WHERE (${collist}) IN (SELECT ${collist} FROM "${def.name}"${where})`,
-      params
-    );
-  }
-  await conn.exec(`DELETE FROM "${def.name}"${where}`, params);
-}
-async function clearRows(conn, def, wipe = false) {
-  if (def.name === "block_revisions" && !wipe) throw new StorageError(409, "block history may only be removed by explicit wipe", "revision_conflict");
-  const multi = multiEntryIndex(def);
-  if (multi) await conn.exec(`DELETE FROM "${junctionTable(def, multi)}"`);
-  await conn.exec(`DELETE FROM "${def.name}"`);
-}
-async function wipeRows(conn) {
-  for (const def of STORE_DEFS) {
-    if (!def.system) await clearRows(conn, def, true);
-  }
-}
-function tableListSql(dialect) {
-  return dialect === "sqlite" ? `SELECT "name" FROM "sqlite_master" WHERE "type" = 'table'` : `SELECT "table_name" FROM "information_schema"."tables" WHERE "table_schema" = current_schema()`;
-}
-async function ensureStoreTables(conn, dialect, def) {
-  const keys = keyCols(def);
-  const cols = keys.map((k, i) => [k, colSql(dialect, pathType(def, def.keyPath[i]))]);
-  for (const idx of def.indexes) {
-    if (idx.multiEntry) continue;
-    idx.keyPath.forEach((path, part) => {
-      cols.push([indexCol(idx.name, part), colSql(dialect, pathType(def, path))]);
-    });
-  }
-  cols.push(["data", " TEXT NOT NULL"]);
-  const colDefs = cols.map(([c, t]) => `"${c}"${t}`);
-  await conn.exec(
-    `CREATE TABLE IF NOT EXISTS "${def.name}" (${colDefs.join(", ")}, PRIMARY KEY (${keys.map((k) => `"${k}"`).join(", ")}))`
-  );
-  for (const idx of def.indexes) {
-    if (idx.multiEntry) continue;
-    const parts = idx.keyPath.map((_, part) => `"${indexCol(idx.name, part)}"`).join(", ");
-    await conn.exec(
-      `CREATE ${idx.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS "${def.name}__${sanitize(idx.name)}" ON "${def.name}" (${parts})`
-    );
-  }
-  const multi = multiEntryIndex(def);
-  if (multi) {
-    const jt = junctionTable(def, multi);
-    const jkeys = keys.map((k, i) => `"${k}"${colSql(dialect, pathType(def, def.keyPath[i]))}`);
-    await conn.exec(
-      `CREATE TABLE IF NOT EXISTS "${jt}" (${jkeys.join(", ")}, "v"${colSql(dialect, "text")}, PRIMARY KEY (${[...keys, '"v"'].join(", ")}))`
-    );
-    await conn.exec(`CREATE INDEX IF NOT EXISTS "${jt}__v" ON "${jt}" ("v")`);
-  }
-  if (def.name === "notes" && dialect === "sqlite") {
-    await conn.exec(`CREATE TRIGGER IF NOT EXISTS "notes_revision_guard" BEFORE UPDATE ON "notes"
-      WHEN json_extract(NEW."data", '$.sourceRevision') < json_extract(OLD."data", '$.sourceRevision')
-      OR ((json_extract(NEW."data", '$.rawContent') IS NOT json_extract(OLD."data", '$.rawContent')
-        OR json_extract(NEW."data", '$.blocks') IS NOT json_extract(OLD."data", '$.blocks'))
-        AND json_extract(NEW."data", '$.sourceRevision') <= json_extract(OLD."data", '$.sourceRevision'))
-      BEGIN SELECT RAISE(ABORT, 'transaction_conflict: stale Note source revision'); END`);
-  }
-  if (def.name === "block_revisions" && dialect === "sqlite") {
-    await conn.exec(`CREATE TRIGGER IF NOT EXISTS "block_revision_guard" BEFORE INSERT ON "block_revisions"
-      WHEN EXISTS (SELECT 1 FROM "block_revisions" old WHERE old."k0" = NEW."k0" AND old."k1" = NEW."k1" AND old."k2" = NEW."k2" AND old."data" <> NEW."data")
-      BEGIN SELECT RAISE(ABORT, 'revision_conflict: immutable block revision collision'); END`);
-  }
-  if (def.name === "sessions" && dialect === "sqlite") {
-    await conn.exec(`CREATE TRIGGER IF NOT EXISTS "session_pin_guard" BEFORE UPDATE ON "sessions"
-      WHEN json_extract(NEW."data", '$.noteId') IS NOT json_extract(OLD."data", '$.noteId')
-        OR json_extract(NEW."data", '$.blockId') IS NOT json_extract(OLD."data", '$.blockId')
-        OR json_extract(NEW."data", '$.blockVersion') IS NOT json_extract(OLD."data", '$.blockVersion')
-      BEGIN SELECT RAISE(ABORT, 'invalid_session_pin: Session pin is immutable'); END`);
-  }
-  if (dialect === "postgres" && ["notes", "block_revisions", "sessions"].includes(def.name)) {
-    const condition = def.name === "block_revisions" ? `EXISTS (SELECT 1 FROM "block_revisions" saved WHERE saved."k0" = NEW."k0" AND saved."k1" = NEW."k1" AND saved."k2" = NEW."k2" AND saved."data" <> NEW."data")` : def.name === "notes" ? `(NEW."data"::jsonb->>'sourceRevision')::bigint < (OLD."data"::jsonb->>'sourceRevision')::bigint OR ((NEW."data"::jsonb->'rawContent' IS DISTINCT FROM OLD."data"::jsonb->'rawContent' OR NEW."data"::jsonb->'blocks' IS DISTINCT FROM OLD."data"::jsonb->'blocks') AND (NEW."data"::jsonb->>'sourceRevision')::bigint <= (OLD."data"::jsonb->>'sourceRevision')::bigint)` : `NEW."data"::jsonb->'noteId' IS DISTINCT FROM OLD."data"::jsonb->'noteId' OR NEW."data"::jsonb->'blockId' IS DISTINCT FROM OLD."data"::jsonb->'blockId' OR NEW."data"::jsonb->'blockVersion' IS DISTINCT FROM OLD."data"::jsonb->'blockVersion'`;
-    const code = def.name === "block_revisions" ? "revision_conflict" : def.name === "notes" ? "transaction_conflict" : "invalid_session_pin";
-    const guard = `${def.name}_guard`;
-    await conn.exec(`CREATE OR REPLACE FUNCTION "${guard}"() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF ${condition} THEN RAISE EXCEPTION '${code}'; END IF; RETURN NEW; END; $$`);
-    await conn.exec(`DROP TRIGGER IF EXISTS "${guard}" ON "${def.name}"`);
-    await conn.exec(`CREATE TRIGGER "${guard}" BEFORE ${def.name === "block_revisions" ? "INSERT" : "UPDATE"} ON "${def.name}" FOR EACH ROW EXECUTE FUNCTION "${guard}"()`);
-  }
-}
-async function initializeStore(db) {
-  await db.transaction(async (tx) => {
-    await tx.exec(
-      `CREATE TABLE IF NOT EXISTS "${SCHEMA_TABLE}" ("key" TEXT PRIMARY KEY, "value" TEXT NOT NULL)`
-    );
-    const ignored = (name) => name.startsWith("_wodwiki_") || name.startsWith("sqlite_") || name === "domain_note" || name === "query_block";
-    const storeTables = new Set(STORE_DEFS.map((d) => d.name));
-    for (const def of STORE_DEFS) {
-      const multi = def.indexes.find((i) => i.multiEntry);
-      if (multi) storeTables.add(junctionTable(def, multi));
-    }
-    const tableNames = new Set(
-      (await tx.query(tableListSql(db.dialect))).map((r) => String(Object.values(r)[0])).filter((n) => !ignored(n))
-    );
-    const guardRows = await tx.query(`SELECT "value" FROM "${SCHEMA_TABLE}" WHERE "key" = ?`, [SCHEMA_KEY]);
-    let stored;
-    if (guardRows[0]) {
-      const guard = JSON.parse(String(guardRows[0].value));
-      if (typeof guard.version !== "number" || !Number.isSafeInteger(guard.version) || guard.version < 0) {
-        throw new StorageError(500, `corrupt ${SCHEMA_TABLE} guard row`, "bad_schema_guard");
-      }
-      stored = guard.version;
-      if (stored > DB_VERSION) {
-        throw new StorageError(
-          500,
-          `database schema v${stored} is newer than this server supports (v${DB_VERSION}); refusing to downgrade`,
-          "schema_incompatible"
-        );
-      }
-      if (stored < DB_VERSION) {
-        const missing = [...storeTables].filter((name) => !tableNames.has(name));
-        const unexpected = [...tableNames].filter((name) => name !== SCHEMA_TABLE && !storeTables.has(name));
-        const additive = additiveStoresSince(stored);
-        if (stored < 30 || unexpected.length > 0 || missing.some((name) => !additive.has(name))) {
-          throw new StorageError(
-            500,
-            `database schema v${stored} is incompatible with v${DB_VERSION} (missing tables: ${missing.join(", ") || "none"}; unrecognized tables: ${unexpected.join(", ") || "none"}); recreation required using an explicitly disposable database`,
-            "schema_incompatible"
-          );
-        }
-      }
-    } else if ([...tableNames].some((name) => storeTables.has(name))) {
-      throw new StorageError(
-        500,
-        "database contains store tables but no wod-wiki schema guard; refusing to adopt a foreign database \u2014 point SQLITE_PATH/DATABASE_URL at a fresh database",
-        "foreign_database"
-      );
-    }
-    for (const def of STORE_DEFS) await ensureStoreTables(tx, db.dialect, def);
-    if (stored !== DB_VERSION) {
-      await tx.exec(
-        `INSERT INTO "${SCHEMA_TABLE}" ("key", "value") VALUES (?, ?) ON CONFLICT ("key") DO UPDATE SET "value" = excluded."value"`,
-        [SCHEMA_KEY, JSON.stringify({ version: DB_VERSION })]
-      );
-    }
-  });
-}
 var TABLES = ["domain_note", "query_block"];
 var PROJECTION_GUARD_KEY = "domain_projection";
 function sourceItem(row) {
@@ -1600,291 +1003,224 @@ var BrowserTursoStorage = class extends SqlStorage {
   }
 };
 
-// src/sql/sync.ts
-var SYNC_OPS_TABLE = "_wodwiki_sync_ops";
-var SYNC_STATE_TABLE = "_wodwiki_sync_state";
-var SYNC_ARCHIVE_TABLE = "_wodwiki_sync_ops_archive";
-var BINARY_FIELD2 = { attachments: "data" };
-var STORE_NAMES = Object.fromEntries(STORE_DEFS.map((d) => [d.name, true]));
-var STATE_KEY = "meta";
-function isSafeInt(value) {
-  return typeof value === "number" && Number.isSafeInteger(value);
-}
-function isScalar(value) {
-  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
-}
-function assertKey(key, what) {
-  if (isScalar(key)) return;
-  if (Array.isArray(key) && key.length > 0 && key.every(isScalar)) return;
-  throw new StorageError(400, `${what} must be a string, finite number, or non-empty scalar tuple`, "bad_sync_key");
-}
-function validateMutation(raw) {
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new StorageError(400, "sync mutation must be an object", "bad_sync_mutation");
-  }
-  const mutation = raw;
-  if (mutation.op === "wipe") return { op: "wipe" };
-  if (typeof mutation.store !== "string" || !STORE_NAMES[mutation.store]) {
-    throw new StorageError(400, `sync mutation has unknown store ${String(mutation.store)}`, "bad_sync_mutation");
-  }
-  const store = mutation.store;
-  if (mutation.op === "clear") return { op: "clear", store };
-  if (mutation.op === "delete") {
-    assertKey(mutation.key, "sync delete key");
-    return { op: "delete", store, key: mutation.key };
-  }
-  if (mutation.op === "put") {
-    assertKey(mutation.key, "sync put key");
-    if (mutation.value === null || typeof mutation.value !== "object" || Array.isArray(mutation.value)) {
-      throw new StorageError(400, "sync put value must be an object row", "bad_sync_mutation");
-    }
-    return { op: "put", store, key: mutation.key, value: mutation.value };
-  }
-  throw new StorageError(400, `sync mutation has unknown op ${String(mutation.op)}`, "bad_sync_mutation");
-}
-function validateEntry(entry) {
-  if (typeof entry.id !== "string" || entry.id.length === 0 || entry.id.length > 200) {
-    throw new StorageError(400, "sync entry id must be a non-empty string", "bad_sync_entry");
-  }
-  if (!isSafeInt(entry.at) || entry.at < 0) {
-    throw new StorageError(400, "sync entry at must be a non-negative safe integer", "bad_sync_entry");
-  }
-  if (!Array.isArray(entry.ops) || entry.ops.length === 0) {
-    throw new StorageError(400, "sync entry ops must be a non-empty array", "bad_sync_entry");
-  }
-  for (const op of entry.ops) validateMutation(op);
-}
-async function runStatements(tx, statements) {
-  if (statements.length === 0) return [];
-  if (tx.batch) return tx.batch(statements);
-  const results = [];
-  for (const statement of statements) {
-    results.push(await tx.query(statement.sql, statement.params ?? []));
+// src/sql/backup.ts
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function toCanonicalCell(value) {
+  if (value === null) return { z: null };
+  if (typeof value === "string") return { s: value };
+  if (typeof value === "number") return { n: value };
+  if (typeof value === "bigint") return { i: value.toString() };
+  if (value instanceof Uint8Array) return { b: bytesToHex(value) };
+  if (value instanceof ArrayBuffer) return { b: bytesToHex(new Uint8Array(value)) };
+  throw new StorageError(500, `fingerprint cannot encode cell of type ${typeof value}`, "bad_fingerprint_cell");
+}
+function quoteIdent(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+async function sha256(text2) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new StorageError(500, "Web Crypto unavailable \u2014 cannot fingerprint the database", "no_webcrypto");
+  const bytes = new Uint8Array(await subtle.digest("SHA-256", new TextEncoder().encode(text2)));
+  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function readStateMarker(conn) {
+  const tables = await conn.query(
+    `SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`,
+    [SYNC_STATE_TABLE]
+  );
+  if (tables.length === 0) return void 0;
+  const rows = await conn.query(`SELECT "value" FROM ${quoteIdent(SYNC_STATE_TABLE)} WHERE "key" = 'meta'`);
+  const raw = rows[0]?.value;
+  if (typeof raw !== "string") {
+    throw new StorageError(400, "sync target is not initialized", "sync_not_initialized");
   }
-  return results;
-}
-async function tableExists(conn, dialect, name) {
-  const sql = dialect === "postgres" ? `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_name = $1` : `SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`;
-  return (await conn.query(sql, [name])).length > 0;
-}
-async function readSyncState(tx) {
-  const rows = await tx.query(`SELECT "value" FROM "${SYNC_STATE_TABLE}" WHERE "key" = ?`, [STATE_KEY]);
-  if (!rows[0]) throw new StorageError(409, "sync target is not initialized", "sync_not_initialized");
   let parsed;
   try {
-    parsed = JSON.parse(String(rows[0].value));
+    parsed = JSON.parse(raw);
   } catch {
     throw new StorageError(400, "malformed sync state row", "bad_sync_state");
   }
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new StorageError(400, "malformed sync state row", "bad_sync_state");
   }
-  const state = parsed;
-  if (!isSafeInt(state.schema) || state.schema < 0 || !isSafeInt(state.rev) || state.rev < 0) {
-    throw new StorageError(400, "sync state schema/rev must be non-negative safe integers", "bad_sync_state");
+  if (!("schema" in parsed) || !("rev" in parsed)) {
+    throw new StorageError(400, "sync state row is missing schema/rev", "bad_sync_state");
   }
-  return { schema: state.schema, rev: state.rev };
-}
-async function probeSyncTarget(db) {
-  if (await tableExists(db, db.dialect, SYNC_STATE_TABLE)) {
-    const state = await readSyncState(db);
-    return { kind: "current", schemaVersion: state.schema, rev: state.rev };
-  }
-  if (await tableExists(db, db.dialect, SCHEMA_TABLE)) {
-    const rows = await db.query(`SELECT "value" FROM "${SCHEMA_TABLE}" WHERE "key" = 'schema'`);
-    if (rows[0]) {
-      const guard = JSON.parse(String(rows[0].value));
-      if (typeof guard.version === "number" && Number.isSafeInteger(guard.version) && guard.version >= 0) {
-        return { kind: "legacy", schemaVersion: guard.version };
-      }
-    }
-    return { kind: "legacy", schemaVersion: 0 };
+  const { schema, rev } = parsed;
+  if (typeof schema !== "number" || !Number.isSafeInteger(schema) || schema < 0 || typeof rev !== "number" || !Number.isSafeInteger(rev) || rev < 0) {
+    throw new StorageError(400, "sync state schema/rev must be non-negative safe integers", "bad_sync_state");
   }
-  const others = await db.query(
-    db.dialect === "postgres" ? `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'` : `SELECT name FROM sqlite_master WHERE type = 'table'`
-  );
-  const internal = (name) => name.startsWith("_wodwiki_") || name.startsWith("sqlite_");
-  return others.some((row) => !internal(String(Object.values(row)[0]))) ? { kind: "unknown" } : "empty";
+  return { schema, rev };
 }
-async function initSyncTarget(db, schemaVersion) {
-  await db.transaction(async (tx) => {
-    await tx.exec(`CREATE TABLE IF NOT EXISTS "${SYNC_STATE_TABLE}" ("key" TEXT PRIMARY KEY, "value" TEXT NOT NULL)`);
-    await tx.exec(
-      `CREATE TABLE IF NOT EXISTS "${SYNC_OPS_TABLE}" ("op_id" TEXT PRIMARY KEY, "rev" INTEGER NOT NULL, "idx" INTEGER NOT NULL, "at" INTEGER NOT NULL, "data" TEXT NOT NULL)`
-    );
-    await tx.exec(
-      `CREATE INDEX IF NOT EXISTS "${SYNC_OPS_TABLE}_rev" ON "${SYNC_OPS_TABLE}" ("rev", "idx")`
-    );
-    await tx.exec(
-      `INSERT INTO "${SYNC_STATE_TABLE}" ("key", "value") VALUES (?, ?) ON CONFLICT ("key") DO NOTHING`,
-      [STATE_KEY, JSON.stringify({ schema: schemaVersion, rev: 0 })]
+async function databaseFingerprint(db) {
+  return db.transaction(async (tx) => {
+    const tableRows = await tx.query(
+      `SELECT name, sql FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND name NOT LIKE 'libsql\\_%' ESCAPE '\\'`
     );
+    const tables = tableRows.map((row) => ({ name: String(row.name), createSql: typeof row.sql === "string" ? row.sql : "" })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    const sections = ["wod-wiki-db-fingerprint-v2"];
+    let totalRows = 0;
+    for (const table of tables) {
+      const rows = await tx.query(`SELECT * FROM ${quoteIdent(table.name)}`);
+      totalRows += rows.length;
+      const encoded = rows.map((row) => JSON.stringify(Object.values(row).map(toCanonicalCell)));
+      encoded.sort();
+      sections.push(`table ${table.name}`, `schema ${table.createSql}`, `rows ${rows.length}`, ...encoded);
+    }
+    const sync = await readStateMarker(tx);
+    return { tables: tables.length, rows: totalRows, digest: await sha256(sections.join("\n")), sync };
   });
 }
-function encodeMutation(mutation) {
-  if (mutation.op !== "put") return JSON.stringify(mutation);
-  const encoded = encodeRowJson(mutation.value, BINARY_FIELD2[mutation.store]);
-  return `{"key":${JSON.stringify(mutation.key)},"op":"put","store":${JSON.stringify(mutation.store)},"value":${encoded}}`;
-}
-function decodeMutation(data) {
-  if (typeof data !== "string") {
-    throw new StorageError(400, "sync op data must be a string", "bad_sync_mutation");
+async function assertDatabaseCopyMatches(source, copy, before) {
+  const after = await databaseFingerprint(source);
+  if (after.digest !== before.digest) {
+    throw new StorageError(
+      409,
+      "source database changed during the copy \u2014 a writer is still active; retire all writers and retry",
+      "source_moved"
+    );
   }
-  let parsed;
-  try {
-    parsed = JSON.parse(data);
-  } catch {
-    throw new StorageError(400, "sync op data is not valid JSON", "bad_sync_mutation");
+  const copied = await databaseFingerprint(copy);
+  if (copied.digest !== before.digest) {
+    throw new StorageError(
+      409,
+      `copy is incomplete or divergent (copy: ${copied.tables} tables / ${copied.rows} rows, source: ${before.tables} tables / ${before.rows} rows)`,
+      "copy_mismatch"
+    );
   }
-  const mutation = validateMutation(parsed);
-  if (mutation.op !== "put") return mutation;
-  return {
-    op: "put",
-    store: mutation.store,
-    key: mutation.key,
-    value: decodeRowJson(JSON.stringify(mutation.value), BINARY_FIELD2[mutation.store])
-  };
+  return after;
 }
-async function applySyncBatch(db, entries, opts = {}) {
-  if (entries.length === 0) return 0;
-  for (const entry of entries) validateEntry(entry);
-  return db.transaction(async (tx) => {
-    const state = await readSyncState(tx);
-    if (opts.expectSchema !== void 0 && state.schema !== opts.expectSchema) {
+async function finalizeMigrationTarget(db, toSchema, expectRev) {
+  if (!Number.isSafeInteger(toSchema) || toSchema < 1) {
+    throw new StorageError(400, "finalize requires a positive schema version", "bad_sync_state");
+  }
+  await db.transaction(async (tx) => {
+    const marker = await readStateMarker(tx);
+    if (!marker || marker.schema !== 0 || marker.rev !== expectRev) {
       throw new StorageError(
         409,
-        `sync target schema changed from v${opts.expectSchema} to v${state.schema} between probe and write \u2014 retry the cycle`,
-        "sync_schema_conflict"
+        `migration target is not in constructing state (expected schema 0 at rev ${expectRev}, found ${marker ? `schema ${marker.schema} at rev ${marker.rev}` : "no state row"})`,
+        "migration_not_constructing"
       );
     }
-    const firstIds = entries.map((entry) => `${entry.id}:0`);
-    const present = /* @__PURE__ */ new Set();
-    for (let i = 0; i < firstIds.length; i += 100) {
-      const chunk = firstIds.slice(i, i + 100);
-      const rows = await tx.query(
-        `SELECT "op_id" FROM "${SYNC_OPS_TABLE}" WHERE "op_id" IN (${chunk.map(() => "?").join(", ")})`,
-        chunk
+    await tx.exec(
+      `UPDATE ${quoteIdent(SYNC_STATE_TABLE)} SET "value" = ? WHERE "key" = 'meta'`,
+      [JSON.stringify({ schema: toSchema, rev: expectRev })]
+    );
+  });
+}
+function pinKey(noteId, blockId, version) {
+  return `${String(noteId)}\0${String(blockId)}\0${String(version)}`;
+}
+function assertPolicySnapshot(ops) {
+  const revisions = /* @__PURE__ */ new Set();
+  for (const mutation of ops) {
+    if (mutation.op !== "put") {
+      throw new StorageError(
+        400,
+        `policy snapshot contains a non-put operation (${mutation.op}) \u2014 refusing`,
+        "policy_violation"
       );
-      for (const row of rows) present.add(String(row.op_id));
     }
-    const statements = [];
-    let rev = state.rev;
-    let committed = 0;
-    for (const entry of entries) {
-      if (present.has(`${entry.id}:0`)) continue;
-      rev += 1;
-      committed += 1;
-      entry.ops.forEach((mutation, idx) => {
-        statements.push({
-          sql: `INSERT INTO "${SYNC_OPS_TABLE}" ("op_id", "rev", "idx", "at", "data") VALUES (?, ?, ?, ?, ?) ON CONFLICT ("op_id") DO NOTHING`,
-          params: [`${entry.id}:${idx}`, rev, idx, entry.at, encodeMutation(mutation)]
-        });
-      });
+    if (mutation.store !== "block_revisions") continue;
+    const row = mutation.value;
+    if (typeof row !== "object" || row === null || !("noteId" in row) || !("blockId" in row) || !("version" in row)) {
+      throw new StorageError(400, "block_revisions row is missing noteId/blockId/version", "policy_violation");
     }
-    const nextSchema = opts.toSchemaVersion ?? state.schema;
-    statements.push({
-      sql: `UPDATE "${SYNC_STATE_TABLE}" SET "value" = ? WHERE "key" = ?`,
-      params: [JSON.stringify({ schema: nextSchema, rev }), STATE_KEY]
-    });
-    await runStatements(tx, statements);
-    return committed;
-  });
-}
-async function fetchSyncOps(db, afterRev, limit) {
-  if (!isSafeInt(afterRev) || afterRev < 0) {
-    throw new StorageError(400, "fetchSyncOps cursor must be a non-negative safe integer", "bad_sync_cursor");
-  }
-  const bounded = Math.min(Math.max(1, Math.floor(limit)), 4294967295);
-  const revRows = await db.query(
-    `SELECT DISTINCT "rev" FROM (SELECT "rev" FROM "${SYNC_OPS_TABLE}" WHERE "rev" > ? ORDER BY "rev" ASC LIMIT ?)`,
-    [afterRev, bounded]
-  );
-  const revs = revRows.map((row) => {
-    const rev = Number(row.rev);
-    if (!Number.isSafeInteger(rev) || rev < 0) {
-      throw new StorageError(400, "sync op rev must be a non-negative safe integer", "bad_sync_row");
+    revisions.add(pinKey(row.noteId, row.blockId, row.version));
+  }
+  const check = (noteId, blockId, version, what) => {
+    if (!revisions.has(pinKey(noteId, blockId, version))) {
+      throw new StorageError(
+        400,
+        `${what} pins [${String(noteId)}, ${String(blockId)}, ${String(version)}] but the snapshot has no such immutable revision`,
+        "policy_violation"
+      );
     }
-    return rev;
-  });
-  if (revs.length === 0) return [];
-  const rows = await db.query(
-    `SELECT "op_id", "rev", "idx", "at", "data" FROM "${SYNC_OPS_TABLE}" WHERE "rev" IN (${revs.map(() => "?").join(", ")}) ORDER BY "rev", "idx"`,
-    revs
-  );
-  return rows.map((row, at) => {
-    const opId = row.op_id;
-    const rev = Number(row.rev);
-    const idx = Number(row.idx);
-    const atMs = Number(row.at);
-    if (typeof opId !== "string" || opId.length === 0 || !Number.isSafeInteger(rev) || rev < 0 || !Number.isSafeInteger(idx) || idx < 0 || !Number.isSafeInteger(atMs) || atMs < 0) {
-      throw new StorageError(400, `sync op row ${at} has malformed shape`, "bad_sync_row");
+  };
+  for (const mutation of ops) {
+    if (mutation.op !== "put") continue;
+    if (mutation.store === "sessions") {
+      const row = mutation.value;
+      if (typeof row !== "object" || row === null || !("noteId" in row) || !("blockId" in row) || !("blockVersion" in row)) {
+        throw new StorageError(400, "session row is missing noteId/blockId/blockVersion", "policy_violation");
+      }
+      check(row.noteId, row.blockId, row.blockVersion, "a session");
+    } else if (mutation.store === "notes") {
+      const row = mutation.value;
+      if (typeof row !== "object" || row === null || !("id" in row) || !("blocks" in row)) {
+        throw new StorageError(400, "note row is missing id/blocks", "policy_violation");
+      }
+      if (typeof row.blocks !== "object" || row.blocks === null) continue;
+      for (const block of Object.values(row.blocks)) {
+        if (typeof block !== "object" || block === null || !("id" in block) || !("version" in block)) {
+          throw new StorageError(400, "note block entry is missing id/version", "policy_violation");
+        }
+        check(row.id, block.id, block.version, "a note block");
+      }
     }
-    return { opId, rev, idx, at: atMs, mutation: decodeMutation(row.data) };
-  });
+  }
 }
-async function replaceSyncLog(db, entries, toSchemaVersion) {
-  if (entries.length === 0) throw new StorageError(400, "replacement log must contain the converted snapshot", "bad_sync_entry");
-  for (const entry of entries) validateEntry(entry);
-  await db.transaction(async (tx) => {
-    await readSyncState(tx);
-    await tx.exec(
-      `CREATE TABLE IF NOT EXISTS "${SYNC_ARCHIVE_TABLE}" ("op_id" TEXT PRIMARY KEY, "rev" INTEGER NOT NULL, "idx" INTEGER NOT NULL, "at" INTEGER NOT NULL, "data" TEXT NOT NULL)`
-    );
-    await tx.exec(`INSERT INTO "${SYNC_ARCHIVE_TABLE}" ("op_id", "rev", "idx", "at", "data") SELECT "op_id", "rev", "idx", "at", "data" FROM "${SYNC_OPS_TABLE}"`);
-    await tx.exec(`DELETE FROM "${SYNC_OPS_TABLE}"`);
-    const statements = [];
-    let rev = 0;
-    for (const entry of entries) {
-      rev += 1;
-      entry.ops.forEach((mutation, idx) => {
-        statements.push({
-          sql: `INSERT INTO "${SYNC_OPS_TABLE}" ("op_id", "rev", "idx", "at", "data") VALUES (?, ?, ?, ?, ?) ON CONFLICT ("op_id") DO NOTHING`,
-          params: [`${entry.id}:${idx}`, rev, idx, entry.at, encodeMutation(mutation)]
-        });
-      });
-    }
-    statements.push({
-      sql: `UPDATE "${SYNC_STATE_TABLE}" SET "value" = ? WHERE "key" = ?`,
-      params: [JSON.stringify({ schema: toSchemaVersion, rev }), STATE_KEY]
-    });
-    await runStatements(tx, statements);
-  });
+function logKey(store, key) {
+  return `${store}\0${JSON.stringify(key) ?? String(key)}`;
 }
-async function readRawSyncOps(db) {
-  const rows = await db.query(`SELECT "rev", "idx", "data" FROM "${SYNC_OPS_TABLE}" ORDER BY "rev", "idx"`);
-  return rows.map((row) => {
-    const rev = Number(row.rev);
-    const idx = Number(row.idx);
-    if (!Number.isSafeInteger(rev) || rev < 0 || !Number.isSafeInteger(idx) || idx < 0 || typeof row.data !== "string") {
-      throw new StorageError(400, "sync op row has malformed shape", "bad_sync_row");
+function assertLogPinClosure(ops) {
+  const live = /* @__PURE__ */ new Map();
+  for (const { mutation } of ops) {
+    if (mutation.op === "put") {
+      live.set(logKey(mutation.store, mutation.key), { store: mutation.store, value: mutation.value });
+    } else if (mutation.op === "delete") {
+      live.delete(logKey(mutation.store, mutation.key));
+    } else if (mutation.op === "clear") {
+      for (const key of live.keys()) {
+        if (key.startsWith(`${mutation.store}\0`)) live.delete(key);
+      }
+    } else {
+      live.clear();
     }
-    let parsed;
-    try {
-      parsed = JSON.parse(row.data);
-    } catch {
-      throw new StorageError(400, "sync op data is not valid JSON", "bad_sync_row");
+  }
+  const revisions = /* @__PURE__ */ new Set();
+  for (const row of live.values()) {
+    if (row.store !== "block_revisions") continue;
+    if (!("noteId" in row.value) || !("blockId" in row.value) || !("version" in row.value)) {
+      throw new StorageError(400, "block_revisions row is missing noteId/blockId/version", "policy_violation");
     }
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new StorageError(400, "sync op data must be an object", "bad_sync_row");
+    revisions.add(pinKey(row.value.noteId, row.value.blockId, row.value.version));
+  }
+  const check = (noteId, blockId, version, what) => {
+    if (!revisions.has(pinKey(noteId, blockId, version))) {
+      throw new StorageError(
+        400,
+        `${what} pins [${String(noteId)}, ${String(blockId)}, ${String(version)}] but the target has no live immutable revision for it`,
+        "policy_violation"
+      );
     }
-    const mutation = parsed;
-    if (typeof mutation.op !== "string" || typeof mutation.store !== "string") {
-      throw new StorageError(400, "sync op must carry string op/store", "bad_sync_row");
+  };
+  for (const row of live.values()) {
+    if (row.store === "sessions") {
+      if (!("noteId" in row.value) || !("blockId" in row.value) || !("blockVersion" in row.value)) {
+        throw new StorageError(400, "session row is missing noteId/blockId/blockVersion", "policy_violation");
+      }
+      check(row.value.noteId, row.value.blockId, row.value.blockVersion, "a live session");
+    } else if (row.store === "notes") {
+      if (!("id" in row.value) || !("blocks" in row.value)) {
+        throw new StorageError(400, "note row is missing id/blocks", "policy_violation");
+      }
+      if (typeof row.value.blocks !== "object" || row.value.blocks === null) continue;
+      for (const block of Object.values(row.value.blocks)) {
+        if (typeof block !== "object" || block === null || !("id" in block) || !("version" in block)) {
+          throw new StorageError(400, "note block entry is missing id/version", "policy_violation");
+        }
+        check(row.value.id, block.id, block.version, "a live note block");
+      }
     }
-    return {
-      op: mutation.op,
-      store: mutation.store,
-      key: mutation.key,
-      value: mutation.value === void 0 || mutation.value === null ? void 0 : decodeRowJson(JSON.stringify(mutation.value), BINARY_FIELD2[mutation.store])
-    };
-  });
-}
-async function readLegacyRows(db, table) {
-  if (!await tableExists(db, db.dialect, table)) return [];
-  const rows = await db.query(`SELECT "data" FROM "${table}"`);
-  return rows.map((row) => decodeRowJson(String(row.data), BINARY_FIELD2[table]));
+  }
 }
 
-export { BrowserTursoStorage, MAX_BODY, SCHEMA_TABLE, SYNC_ARCHIVE_TABLE, SYNC_OPS_TABLE, SYNC_STATE_TABLE, SqlStorage, applySyncBatch, clearRows, countRows, decodeRowJson, deleteRows, encodeRowJson, fetchSyncOps, getRow, getRows, handleDomainQuery, initSyncTarget, initializeDomain, initializeStore, listRows, listRowsFromIndexMany, probeSyncTarget, putRow, putRows, readLegacyRows, readRawSyncOps, rebuildProjections, refreshDomain, replaceSyncLog, storeDefinition, validateTursoUrl, verifyReadiness, wipeDomain, wipeRows };
+export { BrowserTursoStorage, MAX_BODY, SqlStorage, assertDatabaseCopyMatches, assertLogPinClosure, assertPolicySnapshot, databaseFingerprint, finalizeMigrationTarget, handleDomainQuery, initializeDomain, rebuildProjections, refreshDomain, validateTursoUrl, verifyReadiness, wipeDomain };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map