@bitcobblers/wod-wiki-storage 0.35.2116 → 0.35.2119

package/dist/sql/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var wodWikiCore = require('@bitcobblers/wod-wiki-core');
 var wodWikiWql = require('@bitcobblers/wod-wiki-wql');
 var web = require('@libsql/client/web');
 
@@ -40,7 +41,8 @@ function libsqlDatabase(client) {
             query: (sql, params = []) => tx.execute({ sql, args: params }).then(libsqlRows),
             exec: async (sql, params = []) => {
               await tx.execute({ sql, args: params });
-            }
+            },
+            batch: async (statements) => (await tx.batch(statements.map(({ sql, params = [] }) => ({ sql, args: params })))).map(libsqlRows)
           };
           const result = await fn(txConn);
           await tx.commit();
@@ -50,6 +52,10 @@ function libsqlDatabase(client) {
             await tx.rollback();
           } catch {
           }
+          const message = err instanceof Error ? err.message : String(err);
+          for (const code of ["revision_conflict", "transaction_conflict", "invalid_session_pin"]) {
+            if (message.includes(code)) throw new StorageError(409, message, code);
+          }
           throw err;
         } finally {
           tx.close();
@@ -92,29 +98,33 @@ function reviveBinary(value) {
   }
   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 } });
+      return JSON.stringify({ ...row, [binaryField]: { [TAG]: bytesToBase64(bytes), [LEN]: bytes.length } }, canonicalJson);
     }
   }
-  return JSON.stringify(value);
+  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;
+    const record2 = row;
+    const revived = reviveBinary(record2[binaryField]);
+    if (revived !== record2[binaryField]) record2[binaryField] = revived;
   }
   return row;
 }
 
 // src/schema.ts
-var DB_VERSION = 28;
+var DB_VERSION = 30;
 var COLUMN_TYPES = {
   notes: { date: "number", createdAt: "number" },
   page: { createdAt: "number" },
@@ -123,16 +133,9 @@ var COLUMN_TYPES = {
   tags: { createdAt: "number" },
   tag_types: { createdAt: "number" },
   note_tags: {},
-  segments: {
-    version: "number",
-    position: "number",
-    createdAt: "number",
-    updatedAt: "number",
-    isHistory: "boolean"
-  },
+  block_revisions: { version: "number", savedAt: "number" },
   sessions: {
-    segmentVersion: "number",
-    version: "number",
+    blockVersion: "number",
     startTime: "number",
     endTime: "number",
     duration: "number",
@@ -145,7 +148,7 @@ var COLUMN_TYPES = {
   attachments: { createdAt: "number" },
   events: {
     timestamp: "number",
-    segmentVersion: "number",
+    blockVersion: "number",
     line: "number",
     sourceStatementId: "number",
     stackLevel: "number",
@@ -158,7 +161,10 @@ var COLUMN_TYPES = {
   field_catalog_meta: {},
   efforts: { "baseAttributes.met": "number" },
   block_index: {
-    segmentVersion: "number",
+    blockVersion: "number",
+    sourceRevision: "number",
+    from: "number",
+    to: "number",
     position: "number",
     createdAt: "number",
     isStatic: "boolean"
@@ -205,17 +211,12 @@ var STORE_DEFS = [
     { name: "by-note-tag", keyPath: ["noteId", "tagId"], unique: true },
     { name: "by-user", keyPath: ["userId"] }
   ] },
-  // 5. segments
-  { name: "segments", keyPath: ["id", "version"], indexes: [
+  { name: "block_revisions", keyPath: ["noteId", "blockId", "version"], indexes: [
     { name: "by-note", keyPath: ["noteId"] },
-    { name: "by-type", keyPath: ["dataType"] },
-    { name: "by-page", keyPath: ["pageId"] },
-    { name: "by-history", keyPath: ["isHistory"] },
-    { name: "by-user", keyPath: ["userId"] }
+    { name: "by-block", keyPath: ["noteId", "blockId"] }
   ] },
   // 6. sessions
   { name: "sessions", keyPath: ["id"], indexes: [
-    { name: "by-segment", keyPath: ["segmentId"] },
     { name: "by-note", keyPath: ["noteId"] },
     { name: "by-completed", keyPath: ["createdAt"] },
     { name: "by-content", keyPath: ["blockContentId"] },
@@ -224,9 +225,6 @@ var STORE_DEFS = [
     { name: "by-origin", keyPath: ["origin"] },
     { name: "by-user", keyPath: ["userId"] }
   ] },
-  // 7. results — removed in V26: legacy alias of sessions. The V26 upgrade
-  // migrates any residual rows into `sessions` (projecting pre-V21 data.logs
-  // into event rows) before dropping the store; no compatibility alias.
   // 8. attachments
   { name: "attachments", keyPath: ["id"], indexes: [
     { name: "by-note", keyPath: ["noteId"] },
@@ -321,7 +319,7 @@ function rangeFromIDB(query) {
     wire.lowerOpen = query.lowerOpen === true;
   }
   if (query.upper !== void 0 && query.upper !== null) {
-    wire.upper = query.upper;
+    wire.upper = Array.isArray(query.upper) ? query.upper.map((p) => Array.isArray(p) && p.length === 0 ? "\uFFFF" : p) : query.upper;
     wire.upperOpen = query.upperOpen === true;
   }
   return wire.lower !== void 0 || wire.upper !== void 0 ? wire : void 0;
@@ -353,6 +351,75 @@ function keyInRange(key, range) {
   }
   return true;
 }
+function rowsEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (left instanceof ArrayBuffer && right instanceof ArrayBuffer) {
+    const a2 = new Uint8Array(left), b2 = new Uint8Array(right);
+    return a2.length === b2.length && a2.every((value, i) => value === b2[i]);
+  }
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+  if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, i) => rowsEqual(value, right[i]));
+  const a = Object.keys(left).filter((key) => Reflect.get(left, key) !== void 0);
+  const b = Object.keys(right).filter((key) => Reflect.get(right, key) !== void 0);
+  return a.length === b.length && a.every((key) => Object.hasOwn(right, key) && rowsEqual(Reflect.get(left, key), Reflect.get(right, key)));
+}
+function record(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new StorageError(400, "storage row must be an object");
+  return value;
+}
+function validateStorageRow(store, value) {
+  if (store !== "notes" && store !== "block_revisions" && store !== "sessions" && store !== "block_index") return;
+  const row = record(value);
+  const positive = (field) => typeof row[field] === "number" && Number.isSafeInteger(row[field]) && row[field] > 0;
+  const required = (field) => typeof row[field] === "string" && row[field].length > 0;
+  if (store === "notes") {
+    if (!required("id") || typeof row.title !== "string" || typeof row.rawContent !== "string" || !positive("sourceRevision") || typeof row.createdAt !== "number" || !Number.isFinite(row.createdAt) || "segments" in row || "segmentIds" in row || row.date !== void 0 && (typeof row.date !== "number" || !Number.isFinite(row.date)) || row.seedOrigin !== void 0 && row.seedOrigin !== "seed" && row.seedOrigin !== "user" || row.seedVersion !== void 0 && !positive("seedVersion") || row.tags !== void 0 && (!Array.isArray(row.tags) || !row.tags.every((tag) => typeof tag === "string")) || ["type", "sourceId", "sourcePath", "catalog", "seedChunkId"].some((field) => row[field] !== void 0 && typeof row[field] !== "string")) {
+      throw new StorageError(400, "invalid whole Note", "invalid_note_blocks");
+    }
+    try {
+      wodWikiCore.validateNoteBlocks(row.rawContent, record(row.blocks), row.sourceRevision);
+    } catch (error) {
+      throw new StorageError(400, error instanceof Error ? error.message : "invalid block map", "invalid_note_blocks");
+    }
+  } else if (store === "block_revisions") {
+    if (!required("noteId") || !required("blockId") || !positive("version") || typeof row.rawContent !== "string" || typeof row.savedAt !== "number" || !Number.isFinite(row.savedAt) || !["wod", "query", "widget", "embed"].includes(String(row.kind)) || (row.kind === "wod" ? row.dialect !== "time" && row.dialect !== "log" : row.dialect !== void 0 || row.sport !== void 0) || row.sport !== void 0 && typeof row.sport !== "string") throw new StorageError(400, "invalid block revision", "invalid_note_blocks");
+    try {
+      wodWikiCore.validateNoteBlocks(row.rawContent, { [String(row.blockId)]: {
+        id: String(row.blockId),
+        kind: row.kind,
+        version: row.version,
+        sourceRevision: 1,
+        from: 0,
+        to: row.rawContent.length,
+        ...row.dialect === void 0 ? {} : { dialect: row.dialect },
+        ...row.sport === void 0 ? {} : { sport: row.sport }
+      } }, 1);
+    } catch (error) {
+      throw new StorageError(400, error instanceof Error ? error.message : "invalid revision source", "invalid_note_blocks");
+    }
+  } else if (store === "sessions") {
+    if (!required("noteId") || !required("blockId") || !positive("blockVersion") || ["segmentId", "segmentVersion", "version", "rawContent", "script", "serializedScript", "source", "data", "logs"].some((field) => field in row)) {
+      throw new StorageError(400, "Session requires immutable block pin", "invalid_session_pin");
+    }
+  } else if (!required("noteId") || !required("blockId") || !positive("blockVersion") || !positive("sourceRevision") || row.id !== `${row.noteId}:${row.blockId}` || !Number.isSafeInteger(row.from) || !Number.isSafeInteger(row.to) || "segmentId" in row || "segmentVersion" in row || !["wod", "query", "widget", "embed"].includes(String(row.dataType)) || typeof row.rawContent !== "string" || typeof row.noteTitle !== "string" || typeof row.from !== "number" || typeof row.to !== "number" || row.from < 0 || row.to <= row.from) {
+    throw new StorageError(400, "invalid actionable block projection", "invalid_note_blocks");
+  }
+}
+async function validateStoredPins(notes, sessions, getRevisions) {
+  const keys = [];
+  for (const note of notes) for (const block of Object.values(note.blocks)) keys.push([note.id, block.id, block.version]);
+  for (const session of sessions) keys.push([session.noteId, session.blockId, session.blockVersion]);
+  const revisions = await getRevisions(keys);
+  let i = 0;
+  for (const note of notes) for (const block of Object.values(note.blocks)) {
+    const revision = revisions[i++];
+    if (!revision || revision.kind !== block.kind || revision.rawContent !== note.rawContent.slice(block.from, block.to) || revision.dialect !== block.dialect || revision.sport !== block.sport) throw new StorageError(409, "Note block has no matching immutable revision", "invalid_note_blocks");
+  }
+  for (let sessionIndex = 0; sessionIndex < sessions.length; sessionIndex++) {
+    const revision = revisions[i++];
+    if (!revision || revision.kind !== "wod") throw new StorageError(409, "Session pin must reference a saved workout revision", "invalid_session_pin");
+  }
+}
 
 // src/sql/store.ts
 var SCHEMA_TABLE = "_wodwiki_schema";
@@ -519,6 +586,50 @@ async function getRow(conn, def, key) {
   );
   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;
@@ -576,51 +687,114 @@ async function countRows(conn, def, range, indexName) {
   const rows = await conn.query(`SELECT COUNT(*) AS "n" FROM "${def.name}"${cond}`, params);
   return Number(rows[0]?.n ?? 0);
 }
-async function putRow(conn, def, value) {
-  const key = requireKey(def, value);
-  const keyParts = toParts(key).map(toSqlScalar);
+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];
-  const vals = [...keyParts];
   for (const idx of def.indexes) {
     if (idx.multiEntry) continue;
-    idx.keyPath.forEach((path, part) => {
-      cols.push(indexCol(idx.name, part));
-      vals.push(toSqlScalar(extractKeyPart(value, path) ?? null));
-    });
+    idx.keyPath.forEach((_, part) => cols.push(indexCol(idx.name, part)));
   }
   cols.push("data");
-  vals.push(encodeRowJson(value, binaryFieldOf(def)));
   const keySet = new Set(keys);
   const updates = cols.filter((c) => !keySet.has(c)).map((c) => `"${c}" = excluded."${c}"`).join(", ");
-  const collist = cols.map((c) => `"${c}"`).join(", ");
-  const placeholders = cols.map(() => "?").join(", ");
   const pk = keys.map((k) => `"${k}"`).join(", ");
-  await conn.exec(
-    `INSERT INTO "${def.name}" (${collist}) VALUES (${placeholders}) ON CONFLICT (${pk}) DO UPDATE SET ${updates}`,
-    vals
-  );
+  const rows = [];
+  const out = [];
+  const junction = [];
   const multi = multiEntryIndex(def);
-  if (multi) {
-    const jt = junctionTable(def, multi);
-    const cond = keys.map((c) => `"${c}" = ?`).join(" AND ");
-    await conn.exec(`DELETE FROM "${jt}" WHERE ${cond}`, keyParts);
-    const items = arrayPart(value, multi.keyPath[0]);
-    if (Array.isArray(items)) {
-      const jcols = [...keys, "v"];
-      const jcollist = jcols.map((c) => `"${c}"`).join(", ");
-      const jph = jcols.map(() => "?").join(", ");
-      for (const item of items) {
-        await conn.exec(
-          `INSERT INTO "${jt}" (${jcollist}) VALUES (${jph}) ON CONFLICT DO NOTHING`,
-          [...keyParts, JSON.stringify(item)]
-        );
+  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)]);
       }
     }
   }
-  return key;
+  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);
@@ -653,14 +827,15 @@ async function deleteRows(conn, def, keyOrRange) {
   }
   await conn.exec(`DELETE FROM "${def.name}"${where}`, params);
 }
-async function clearRows(conn, def) {
+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);
+    if (!def.system) await clearRows(conn, def, true);
   }
 }
 function tableListSql(dialect) {
@@ -696,31 +871,75 @@ async function ensureStoreTables(conn, dialect, def) {
     );
     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" old WHERE old."k0" = NEW."k0" AND old."k1" = NEW."k1" AND old."k2" = NEW."k2" AND old."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_");
     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]))
+      (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") {
+      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) {
+      if (stored > DB_VERSION) {
         throw new StorageError(
           500,
-          `database schema v${stored} does not match this server (v${DB_VERSION}); use a compatible server or migrate a backed-up database`,
+          `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));
+        if (missing.length > 0 || unexpected.length > 0) {
+          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,
@@ -737,10 +956,8 @@ async function initializeStore(db) {
     }
   });
 }
-
-// src/domain.ts
-var DOMAIN_PROJECTION_VERSION = 1;
-var TABLES = ["domain_note", "query_block", "segment_head"];
+var DOMAIN_PROJECTION_VERSION = 2;
+var TABLES = ["domain_note", "query_block"];
 var PROJECTION_GUARD_KEY = "domain_projection";
 function sourceItem(row) {
   const item = {};
@@ -759,7 +976,7 @@ function ensureDdl(db) {
   const n = db.dialect === "postgres" ? " DOUBLE PRECISION" : "";
   const t = db.dialect === "postgres" ? ' TEXT COLLATE "C"' : " TEXT";
   const ddl = [
-    `CREATE TABLE IF NOT EXISTS "domain_note" ("note_id"${t} PRIMARY KEY NOT NULL, "note_type"${t}, "catalog"${t}, "source_id"${t}, "source_path"${t}, "title"${t} NOT NULL, "created_at"${n} NOT NULL, "date"${n}, "text_search"${t} NOT NULL, "journal"${n} NOT NULL, "payload"${t} NOT NULL)`,
+    `CREATE TABLE IF NOT EXISTS "domain_note" ("note_id"${t} PRIMARY KEY NOT NULL, "note_type"${t}, "catalog"${t}, "source_id"${t}, "source_path"${t}, "title"${t} NOT NULL, "title_search"${t} NOT NULL, "created_at"${n} NOT NULL, "date"${n}, "text_search"${t} NOT NULL, "journal"${n} NOT NULL, "payload"${t} NOT NULL)`,
     `CREATE INDEX IF NOT EXISTS "idx_domain_note_date" ON "domain_note" ("date", "note_id")`,
     `CREATE INDEX IF NOT EXISTS "idx_domain_note_created" ON "domain_note" ("created_at", "note_id")`,
     `CREATE INDEX IF NOT EXISTS "idx_domain_note_source_path" ON "domain_note" ("source_path")`,
@@ -768,169 +985,140 @@ function ensureDdl(db) {
     `CREATE INDEX IF NOT EXISTS "idx_query_block_parent" ON "query_block" ("parent_note_id", "ordinal")`,
     `CREATE INDEX IF NOT EXISTS "idx_query_block_content" ON "query_block" ("content_id")`,
     `CREATE INDEX IF NOT EXISTS "idx_query_block_source_path" ON "query_block" ("source_path")`,
-    `CREATE INDEX IF NOT EXISTS "idx_query_block_source_note" ON "query_block" ("source_note_id")`,
-    `CREATE TABLE IF NOT EXISTS "segment_head" ("id"${t} PRIMARY KEY NOT NULL, "note_id"${t} NOT NULL, "current_version"${n} NOT NULL, "position"${n}, "search_text"${t} NOT NULL)`,
-    `CREATE INDEX IF NOT EXISTS "idx_segment_head_note" ON "segment_head" ("note_id", "id")`
+    `CREATE INDEX IF NOT EXISTS "idx_query_block_source_note" ON "query_block" ("source_note_id")`
   ];
   return db.transaction(async (tx) => {
     for (const sql of ddl) await tx.exec(sql);
   });
 }
-async function upsertDomainNote(conn, note) {
+var DOMAIN_NOTE_COLS = ["note_id", "note_type", "catalog", "source_id", "source_path", "title", "title_search", "created_at", "date", "text_search", "journal", "payload"];
+var QUERY_BLOCK_COLS = ["occurrence_id", "source_note_id", "parent_note_id", "content_id", "section_key", "ordinal", "data_type", "source_id", "source_path", "catalog", "effective_date", "created_at", "note_title", "normalized_text", "journal", "payload"];
+var conflictUpdate = (cols, keys) => `ON CONFLICT (${keys.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ` + cols.filter((c) => !keys.includes(c)).map((c) => `"${c}" = excluded."${c}"`).join(",") + ` WHERE ` + cols.filter((col) => !keys.includes(col)).map((col) => `"${col}" IS DISTINCT FROM excluded."${col}"`).join(" OR ");
+function domainNoteRow(note) {
   const id = text(note.id);
-  if (!id) return;
+  if (!id) return void 0;
   const source = sourceItem(note);
-  await conn.exec(
-    `INSERT INTO "domain_note" ("note_id","note_type","catalog","source_id","source_path","title","created_at","date","text_search","journal","payload")
-     VALUES (?,?,?,?,?,?,?,?,?,?,?)
-     ON CONFLICT ("note_id") DO UPDATE SET "note_type"=excluded."note_type","catalog"=excluded."catalog","source_id"=excluded."source_id",
-       "source_path"=excluded."source_path","title"=excluded."title","created_at"=excluded."created_at","date"=excluded."date",
-       "text_search"=excluded."text_search","journal"=excluded."journal","payload"=excluded."payload"`,
-    [
-      id,
-      T(note.type),
-      T(wodWikiWql.catalogOfItem(source)),
-      T(note.sourceId),
-      T(note.sourcePath),
-      T(note.title) ?? "",
-      N(note.createdAt),
-      num(note.date),
-      (text(note.title) ?? "").toLowerCase(),
-      wodWikiWql.sourceMatches(source, "journal") ? 1 : 0,
-      encodeRowJson(note)
-    ]
-  );
-}
-async function healQueryBlocksForNote(conn, note) {
-  const id = text(note.id);
-  if (!id) return;
-  const rows = await conn.query(
-    `SELECT "occurrence_id" FROM "query_block"
-     WHERE "source_note_id" = ? OR ("source_path" IS NOT NULL AND "source_path" = ?)`,
-    [id, T(note.sourcePath)]
-  );
-  for (const row of rows) await refreshBlock(conn, String(row.occurrence_id));
-}
-async function upsertSegmentHead(conn, id, head) {
-  await conn.exec(
-    `INSERT INTO "segment_head" ("id","note_id","current_version","position","search_text")
-     VALUES (?,?,?,?,?)
-     ON CONFLICT ("id") DO UPDATE SET "note_id"=excluded."note_id","current_version"=excluded."current_version",
-       "position"=excluded."position","search_text"=excluded."search_text"`,
-    [
-      id,
-      T(head.noteId) ?? "",
-      N(head.version),
-      // Local latest-segments order is position ?? createdAt — same fallback here.
-      num(head.position) ?? num(head.createdAt),
-      (text(head.rawContent) ?? "").toLowerCase()
-    ]
-  );
-}
-async function identityBy(conn, col, val) {
-  const rows = await conn.query(
-    `SELECT "note_id", "date", "created_at" FROM "domain_note" WHERE "${col}" = ?`,
-    [val]
-  );
-  return rows.map((r) => ({
-    note_id: String(r.note_id),
-    date: num(r.date),
-    created_at: num(r.created_at) ?? 0
-  }));
+  return [
+    id,
+    T(note.type),
+    T(wodWikiWql.catalogOfItem(source)),
+    T(note.sourceId),
+    T(note.sourcePath),
+    T(note.title) ?? "",
+    (text(note.title) ?? "").toLowerCase(),
+    N(note.createdAt),
+    num(note.date),
+    (text(note.rawContent) ?? "").toLowerCase(),
+    wodWikiWql.sourceMatches(source, "journal") ? 1 : 0,
+    encodeRowJson(note)
+  ];
 }
-async function resolveParent(conn, block) {
-  const byPath = async (sp2) => {
-    const rows = await identityBy(conn, "source_path", sp2);
-    return rows.length === 1 ? rows[0] : void 0;
-  };
-  const nid = text(block.noteId);
-  if (nid) {
-    const rows = await identityBy(conn, "note_id", nid);
-    if (rows.length === 1) return rows[0];
-    if (rows.length > 1) return void 0;
-  }
-  const sp = text(block.sourcePath);
-  return sp ? byPath(sp) : void 0;
+async function upsertDomainNotes(conn, notes) {
+  const rows = notes.map(domainNoteRow).filter((r) => r !== void 0);
+  await batchInsert(conn, "domain_note", [...DOMAIN_NOTE_COLS], rows, conflictUpdate(DOMAIN_NOTE_COLS, ["note_id"]));
 }
-async function upsertQueryBlock(conn, block) {
+function queryBlockRow(block, parent) {
   const id = text(block.id);
-  if (!id) return;
+  if (!id) return void 0;
   const source = sourceItem(block);
   const createdAt = N(block.createdAt);
-  const parent = await resolveParent(conn, block);
   const effective = parent ? parent.date ?? parent.created_at : createdAt;
-  await conn.exec(
-    `INSERT INTO "query_block" ("occurrence_id","source_note_id","parent_note_id","content_id","section_key","ordinal",
-       "data_type","source_id","source_path","catalog","effective_date","created_at","note_title","normalized_text","journal","payload")
-     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
-     ON CONFLICT ("occurrence_id") DO UPDATE SET "source_note_id"=excluded."source_note_id","parent_note_id"=excluded."parent_note_id",
-       "content_id"=excluded."content_id","section_key"=excluded."section_key","ordinal"=excluded."ordinal",
-       "data_type"=excluded."data_type","source_id"=excluded."source_id","source_path"=excluded."source_path",
-       "catalog"=excluded."catalog","effective_date"=excluded."effective_date","created_at"=excluded."created_at",
-       "note_title"=excluded."note_title","normalized_text"=excluded."normalized_text","journal"=excluded."journal",
-       "payload"=excluded."payload"`,
-    [
-      id,
-      T(block.noteId),
-      parent?.note_id ?? null,
-      T(block.blockContentId),
-      T(block.segmentId),
-      num(block.position),
-      T(block.dataType),
-      T(block.sourceId),
-      T(block.sourcePath),
-      T(wodWikiWql.catalogOfItem(source)),
-      effective,
-      createdAt,
-      T(block.noteTitle),
-      (text(block.rawContent) ?? "").toLowerCase(),
-      wodWikiWql.sourceMatches(source, "journal") ? 1 : 0,
-      encodeRowJson(block)
-    ]
-  );
+  return [
+    id,
+    T(block.noteId),
+    parent?.note_id ?? null,
+    T(block.blockContentId),
+    T(block.blockId),
+    num(block.position),
+    T(block.dataType),
+    T(block.sourceId),
+    T(block.sourcePath),
+    T(wodWikiWql.catalogOfItem(source)),
+    effective,
+    createdAt,
+    parent?.note.title ?? T(block.noteTitle),
+    (text(block.rawContent) ?? "").toLowerCase(),
+    wodWikiWql.sourceMatches(source, "journal") ? 1 : 0,
+    encodeRowJson(parent ? { ...block, noteTitle: parent.note.title } : block)
+  ];
 }
-var keyHead = (key) => Array.isArray(key) ? key[0] : key;
-async function refreshNote(conn, id) {
-  const k = keyHead(id);
-  const rows = await conn.query(`SELECT "data" FROM "notes" WHERE "k0" = ?`, [k]);
-  const note = rows[0] ? decodeRowJson(String(rows[0].data)) : void 0;
-  if (note) {
-    await upsertDomainNote(conn, note);
-    await healQueryBlocksForNote(conn, note);
-  } else {
-    const orphans = await conn.query(
-      `SELECT "occurrence_id" FROM "query_block" WHERE "parent_note_id" = ? OR "source_note_id" = ?`,
-      [k, k]
-    );
-    await conn.exec(`DELETE FROM "domain_note" WHERE "note_id" = ?`, [k]);
-    for (const row of orphans) await refreshBlock(conn, String(row.occurrence_id));
-  }
+async function upsertQueryBlocks(conn, blocks) {
+  const rows = blocks.map(([b, p]) => queryBlockRow(b, p)).filter((r) => r !== void 0);
+  await batchInsert(conn, "query_block", [...QUERY_BLOCK_COLS], rows, conflictUpdate(QUERY_BLOCK_COLS, ["occurrence_id"]));
 }
-async function refreshSegment(conn, id) {
-  const k = keyHead(id);
-  const rows = await conn.query(`SELECT "data" FROM "segments" WHERE "k0" = ?`, [k]);
-  let head;
-  let headVersion = -Infinity;
-  for (const row of rows) {
-    const seg = decodeRowJson(String(row.data));
-    const v = num(seg.version) ?? 0;
-    if (!head || v > headVersion) {
-      head = seg;
-      headVersion = v;
-    }
+function indexNoteIdentities(notes) {
+  const byNoteId = /* @__PURE__ */ new Map();
+  for (const note of notes) {
+    const id = text(note.id);
+    if (id) byNoteId.set(id, { note_id: id, date: num(note.date), created_at: num(note.createdAt) ?? 0, note });
   }
-  if (head) await upsertSegmentHead(conn, k, head);
-  else await conn.exec(`DELETE FROM "segment_head" WHERE "id" = ?`, [k]);
+  return { byNoteId };
+}
+function resolveParentFrom(index, block) {
+  const parent = typeof block.noteId === "string" ? index.byNoteId.get(block.noteId) : void 0;
+  const mapped = typeof block.blockId === "string" ? parent?.note.blocks[block.blockId] : void 0;
+  return parent && mapped && block.id === `${parent.note_id}:${mapped.id}` && block.blockVersion === mapped.version && block.dataType === mapped.kind && block.sourceRevision === parent.note.sourceRevision && block.from === mapped.from && block.to === mapped.to && block.rawContent === parent.note.rawContent.slice(mapped.from, mapped.to) ? parent : void 0;
+}
+async function fetchParentIndex(conn, noteIds) {
+  const notes = await getRows(conn, storeDefinition("notes"), noteIds);
+  return indexNoteIdentities(notes.filter((row) => row !== void 0));
 }
-async function refreshBlock(conn, id) {
-  const k = keyHead(id);
-  const rows = await conn.query(`SELECT "data" FROM "block_index" WHERE "k0" = ?`, [k]);
-  if (rows[0]) await upsertQueryBlock(conn, decodeRowJson(String(rows[0].data)));
-  else await conn.exec(`DELETE FROM "query_block" WHERE "occurrence_id" = ?`, [k]);
+var keyHead = (key) => Array.isArray(key) ? key[0] : key;
+async function selectIn(conn, selectCol, table, col, vals) {
+  const IN_CHUNK = 500;
+  const out = [];
+  for (let i = 0; i < vals.length; i += IN_CHUNK) {
+    const part = vals.slice(i, i + IN_CHUNK);
+    const rows = await conn.query(`SELECT "${selectCol}" FROM "${table}" WHERE "${col}" IN (${part.map(() => "?").join(", ")})`, part);
+    for (const r of rows) out.push(String(r[selectCol]));
+  }
+  return out;
+}
+async function healQueryBlocksForNotes(conn, noteIds) {
+  const ids = await selectIn(conn, "occurrence_id", "query_block", "source_note_id", noteIds);
+  await refreshBlocks(conn, [...new Set(ids)]);
+}
+async function refreshNotes(conn, ids) {
+  const ks = [...new Set(ids.map((id) => String(keyHead(id))))];
+  if (ks.length === 0) return;
+  const found = /* @__PURE__ */ new Map();
+  for (let i = 0; i < ks.length; i += 500) {
+    const part = ks.slice(i, i + 500);
+    const rows = await conn.query(`SELECT "k0", "data" FROM "notes" WHERE "k0" IN (${part.map(() => "?").join(", ")})`, part);
+    for (const row of rows) found.set(String(row.k0), decodeRowJson(String(row.data)));
+  }
+  const present = [];
+  const missing = [];
+  for (const k of ks) {
+    const note = found.get(k);
+    if (note) present.push(note);
+    else missing.push(k);
+  }
+  await upsertDomainNotes(conn, present);
+  const presentIds = present.map((n) => text(n.id)).filter((x) => !!x);
+  await healQueryBlocksForNotes(conn, presentIds);
+  await deleteIn(conn, "domain_note", "note_id", missing);
+  await deleteIn(conn, "query_block", "source_note_id", missing);
+  await deleteIn(conn, "block_index", "i_by_note_0", missing);
+  await deleteIn(conn, "block_efforts", "i_by_note_0", missing);
+}
+async function refreshBlocks(conn, ids) {
+  const ks = [...new Set(ids.map((id) => String(keyHead(id))))];
+  if (ks.length === 0) return;
+  const found = /* @__PURE__ */ new Map();
+  for (let i = 0; i < ks.length; i += 500) {
+    const part = ks.slice(i, i + 500);
+    const rows = await conn.query(`SELECT "k0", "data" FROM "block_index" WHERE "k0" IN (${part.map(() => "?").join(", ")})`, part);
+    for (const row of rows) found.set(String(row.k0), decodeRowJson(String(row.data)));
+  }
+  const blocks = [...found.values()];
+  const noteIds = [...new Set(blocks.map((b) => text(b.noteId)).filter((x) => !!x))];
+  const index = await fetchParentIndex(conn, noteIds);
+  await upsertQueryBlocks(conn, blocks.map((b) => [b, resolveParentFrom(index, b)]));
+  await deleteIn(conn, "query_block", "occurrence_id", ks.filter((k) => !found.has(k)));
 }
 var TRACKED = {
   notes: "notes",
-  segments: "segments",
   block_index: "blocks"
 };
 async function deleteTargetKeys(conn, def, target) {
@@ -938,29 +1126,54 @@ async function deleteTargetKeys(conn, def, target) {
   const rows = await listRows(conn, def, target);
   return rows.map((row) => keyFromValue(def, row));
 }
-async function refreshDomain(conn, ops, opts = {}) {
+async function refreshDomain(conn, ops) {
   const impact = {
     notes: [],
-    segments: [],
     blocks: [],
+    pinnedNotes: [],
+    pinnedSessions: [],
     notesClear: false,
-    segmentsClear: false,
     blocksClear: false
   };
   const results = [];
+  for (const op of ops) if (op === null || typeof op !== "object" || Array.isArray(op)) throw new StorageError(400, "tx op must be an object");
+  const checks = ops.filter((op) => op.op === "check");
+  const checkStores = [...new Set(checks.map((op) => op.store))];
+  for (const store of checkStores) {
+    const scoped = checks.filter((op) => op.store === store);
+    const actual = await getRows(conn, storeDefinition(store), scoped.map((op) => op.key));
+    scoped.forEach((op, i) => {
+      if (!rowsEqual(actual[i] ?? null, op.value)) throw new StorageError(409, "transaction read changed before commit", "transaction_conflict");
+    });
+  }
+  let pending;
+  const flushPuts = async () => {
+    if (!pending) return;
+    const batch = pending;
+    pending = void 0;
+    if (batch.values.length === 0) return;
+    const changed = [];
+    const keys = await putRows(conn, batch.def, batch.values, changed);
+    const slot = TRACKED[batch.def.name];
+    if (slot) impact[slot].push(...changed);
+    const changedSet = new Set(changed.map((key) => JSON.stringify(key)));
+    if (batch.def.name === "notes") impact.pinnedNotes.push(...batch.values.filter((value) => changedSet.has(JSON.stringify(keyFromValue(batch.def, value)))));
+    if (batch.def.name === "sessions") impact.pinnedSessions.push(...batch.values.filter((value) => changedSet.has(JSON.stringify(keyFromValue(batch.def, value)))));
+    results.push(...keys);
+  };
   for (const op of ops) {
-    if (op === null || typeof op !== "object" || Array.isArray(op)) {
-      throw new StorageError(400, "tx op must be an object");
+    if (op.op === "check") {
+      results.push(null);
+      continue;
     }
     const store = "store" in op ? op.store : void 0;
     const def = storeDefinition(typeof store === "string" ? store : String(store));
     const kind = typeof op.op === "string" ? op.op : void 0;
     if (op.op === "put") {
-      const key = await putRow(conn, def, op.value);
-      const slot = TRACKED[def.name];
-      if (slot) impact[slot].push(key);
-      results.push(key);
+      if (pending && pending.def.name !== def.name) await flushPuts();
+      (pending ??= { def, values: [] }).values.push(op.value);
     } else if (op.op === "delete") {
+      await flushPuts();
       const slot = TRACKED[def.name];
       if (slot) {
         for (const key of await deleteTargetKeys(conn, def, op.key)) impact[slot].push(key);
@@ -968,28 +1181,32 @@ async function refreshDomain(conn, ops, opts = {}) {
       await deleteRows(conn, def, op.key);
       results.push(null);
     } else if (op.op === "clear") {
+      await flushPuts();
       await clearRows(conn, def);
       if (def.name === "notes") impact.notesClear = true;
-      else if (def.name === "segments") impact.segmentsClear = true;
       else if (def.name === "block_index") impact.blocksClear = true;
       results.push(null);
     } else {
-      throw new StorageError(400, `tx op must be put | delete | clear, got: ${String(kind)}`);
+      throw new StorageError(400, `tx op must be check | put | delete | clear, got: ${String(kind)}`);
     }
   }
-  if (!opts.deferProjection) await refresh(conn, impact);
+  await flushPuts();
+  const finalNotes = (await getRows(conn, storeDefinition("notes"), [...new Set(impact.pinnedNotes.map((note) => note.id))])).filter(Boolean);
+  const finalSessions = (await getRows(conn, storeDefinition("sessions"), [...new Set(impact.pinnedSessions.map((session) => session.id))])).filter(Boolean);
+  await validateStoredPins(finalNotes, finalSessions, (keys) => getRows(conn, storeDefinition("block_revisions"), keys));
+  await refresh(conn, impact);
   return results;
 }
 async function refresh(conn, impact) {
   if (impact.notesClear) {
     await conn.exec(`DELETE FROM "domain_note"`);
-    await conn.exec(`UPDATE "query_block" SET "parent_note_id" = NULL`);
+    await conn.exec(`DELETE FROM "query_block" WHERE "source_note_id" NOT IN (SELECT "k0" FROM "notes")`);
+    await conn.exec(`DELETE FROM "block_index" WHERE "i_by_note_0" NOT IN (SELECT "k0" FROM "notes")`);
+    await conn.exec(`DELETE FROM "block_efforts" WHERE "i_by_note_0" NOT IN (SELECT "k0" FROM "notes")`);
   }
-  if (impact.segmentsClear) await conn.exec(`DELETE FROM "segment_head"`);
   if (impact.blocksClear) await conn.exec(`DELETE FROM "query_block"`);
-  for (const id of impact.notes) await refreshNote(conn, id);
-  for (const key of impact.segments) await refreshSegment(conn, key);
-  for (const id of impact.blocks) await refreshBlock(conn, id);
+  await refreshNotes(conn, impact.notes);
+  await refreshBlocks(conn, impact.blocks);
 }
 async function rebuildProjections(conn) {
   await conn.exec(
@@ -997,18 +1214,12 @@ async function rebuildProjections(conn) {
   );
   for (const t of TABLES) await conn.exec(`DELETE FROM "${t}"`);
   const notes = await conn.query(`SELECT "data" FROM "notes"`);
-  for (const row of notes) await upsertDomainNote(conn, decodeRowJson(String(row.data)));
-  const segments = await conn.query(`SELECT "k0", "data" FROM "segments"`);
-  const heads = /* @__PURE__ */ new Map();
-  for (const row of segments) {
-    const seg = decodeRowJson(String(row.data));
-    const v = num(seg.version) ?? 0;
-    const prev = heads.get(String(row.k0));
-    if (!prev || v > prev.version) heads.set(String(row.k0), { id: row.k0, row: seg, version: v });
-  }
-  for (const head of heads.values()) await upsertSegmentHead(conn, head.id, head.row);
+  const noteObjs = notes.map((row) => decodeRowJson(String(row.data)));
+  await upsertDomainNotes(conn, noteObjs);
   const blocks = await conn.query(`SELECT "data" FROM "block_index"`);
-  for (const row of blocks) await upsertQueryBlock(conn, decodeRowJson(String(row.data)));
+  const blockObjs = blocks.map((row) => decodeRowJson(String(row.data)));
+  const index = indexNoteIdentities(noteObjs);
+  await upsertQueryBlocks(conn, blockObjs.map((b) => [b, resolveParentFrom(index, b)]));
   await conn.exec(
     `INSERT INTO "${SCHEMA_TABLE}" ("key", "value") VALUES (?, ?) ON CONFLICT ("key") DO UPDATE SET "value" = excluded."value"`,
     [PROJECTION_GUARD_KEY, JSON.stringify({ version: DOMAIN_PROJECTION_VERSION })]
@@ -1245,13 +1456,8 @@ function predicateSql(ctx, p, plan) {
         p.negate === true,
         blocks ? `(q."content_id" IS NOT NULL AND EXISTS (SELECT 1 FROM "block_efforts" be WHERE be."i_by_block_0" = q."content_id" AND be."i_by_effort_0" IN (${p.values.map((v) => ctx.bind(v)).join(", ")})))` : `EXISTS (SELECT 1 FROM "block_efforts" be WHERE be."i_by_note_0" = ${noteId} AND be."i_by_effort_0" IN (${p.values.map((v) => ctx.bind(v)).join(", ")}))`
       );
-    case "text": {
-      const textCol = blocks ? 'q."normalized_text"' : 'n."text_search"';
-      const title = ctx.contains(textCol, p.value);
-      if (plan !== "entries") return title;
-      const body = ctx.contains('h."search_text"', p.value);
-      return `(${title} OR EXISTS (SELECT 1 FROM "segment_head" h JOIN "segments" s ON s."k0" = h."id" AND s."k1" = h."current_version" WHERE h."note_id" = ${noteId} AND COALESCE(s."i_by_history_0", 0) = 0 AND ${body}))`;
-    }
+    case "text":
+      return blocks ? ctx.contains('q."normalized_text"', p.value) : `(${ctx.contains('n."title_search"', p.value)} OR ${ctx.contains('n."text_search"', p.value)})`;
     case "date": {
       const expr = blocks ? 'q."effective_date"' : 'COALESCE(n."date", n."created_at")';
       const lo = ctx.bind(p.start);
@@ -1295,7 +1501,7 @@ async function gate(conn) {
   if (stale > 0) {
     throw new StorageError(
       409,
-      `domain projections stale: ${stale} block rows have unresolved static parents`,
+      `domain projections stale: ${stale} block rows have invalid or unresolved current parents`,
       "domain_projection_unavailable"
     );
   }
@@ -1314,47 +1520,43 @@ async function execute(conn, q, pg) {
   const fullWhere = selWhere && filterWhere ? `${selWhere} AND ${filterWhere.replace(/^ WHERE /, "")}` : selWhere || filterWhere;
   const count = async (where, params) => Number((await conn.query(`SELECT COUNT(*) AS "n" FROM ${table}${where}`, params))[0]?.n ?? 0);
   const selectedCount = await count(selWhere, selCtx.params);
-  const matchedCount = await count(fullWhere, allParams);
+  const matchedCount = q.filters.length === 0 ? selectedCount : await count(fullWhere, allParams);
   const ordering = orderSql(q.order, plan);
   const paging = pagingSql(q, pg);
   if (plan !== "entries") {
     const pageSql2 = `SELECT "payload" FROM ${table}${fullWhere} ORDER BY ${ordering}${paging}`;
     const rows2 = (await conn.query(pageSql2, allParams)).map((r) => decodeRowJson(String(r.payload)));
-    const result2 = { projectionVersion: DOMAIN_PROJECTION_VERSION, selectedCount, matchedCount, plan, rows: rows2 };
-    return result2;
+    const result = { projectionVersion: DOMAIN_PROJECTION_VERSION, selectedCount, matchedCount, plan, rows: rows2 };
+    return result;
   }
   const pageSql = `SELECT "note_id", "payload" FROM ${table}${fullWhere} ORDER BY ${ordering}${paging}`;
   const noteRows = await conn.query(pageSql, allParams);
-  const relations = [
-    `SELECT h."note_id" AS "note_id", s."data" AS "payload" FROM selected n
-     JOIN "segment_head" h ON h."note_id" = n."note_id"
-     JOIN "segments" s ON s."k0" = h."id" AND s."k1" = h."current_version"
-     WHERE COALESCE(s."i_by_history_0", 0) = 0
-     ORDER BY h."position" ASC NULLS LAST, s."k0"`,
-    `SELECT nt."i_by_note_0" AS "note_id", t."data" AS "payload" FROM selected n
-     JOIN "note_tags" nt ON nt."i_by_note_0" = n."note_id"
-     JOIN "tags" t ON t."k0" = nt."i_by_tag_0" ORDER BY t."k0"`,
-    `SELECT p."i_by_note_0" AS "note_id", p."data" AS "payload" FROM selected n
-     JOIN "page_notes" p ON p."i_by_note_0" = n."note_id" ORDER BY p."k0"`,
-    `SELECT DISTINCT p."i_by_note_0" AS "note_id", pg."data" AS "payload" FROM selected n
-     JOIN "page_notes" p ON p."i_by_note_0" = n."note_id"
-     JOIN "page" pg ON pg."k0" = p."i_by_page_0" ORDER BY pg."data"`
-  ];
-  const buckets = noteRows.map(() => [[], [], [], []]);
+  const buckets = noteRows.map(() => [[], [], []]);
   const index = /* @__PURE__ */ new Map();
-  noteRows.forEach((r, i) => index.set(String(r.note_id), i));
-  for (const [rel, relation] of relations.entries()) {
-    for (const row of await conn.query(`WITH selected AS (${pageSql}) ${relation}`, allParams)) {
+  noteRows.forEach((row, i) => index.set(String(row.note_id), i));
+  for (let start = 0; start < noteRows.length; start += 500) {
+    const ids = noteRows.slice(start, start + 500).map((row) => String(row.note_id));
+    const placeholders = ids.map(() => "?").join(", ");
+    const statements = [
+      { sql: `SELECT nt."i_by_note_0" AS "note_id", t."data" AS "payload" FROM "note_tags" nt JOIN "tags" t ON t."k0" = nt."i_by_tag_0" WHERE nt."i_by_note_0" IN (${placeholders}) ORDER BY t."k0"`, params: ids },
+      { sql: `SELECT p."i_by_note_0" AS "note_id", p."data" AS "payload" FROM "page_notes" p WHERE p."i_by_note_0" IN (${placeholders}) ORDER BY p."k0"`, params: ids },
+      { sql: `SELECT DISTINCT p."i_by_note_0" AS "note_id", pg."data" AS "payload" FROM "page_notes" p JOIN "page" pg ON pg."k0" = p."i_by_page_0" WHERE p."i_by_note_0" IN (${placeholders}) ORDER BY pg."data"`, params: ids }
+    ];
+    const relations = conn.batch ? await conn.batch(statements) : await (async () => {
+      const rows2 = [];
+      for (const statement of statements) rows2.push(await conn.query(statement.sql, statement.params));
+      return rows2;
+    })();
+    relations.forEach((rows2, relation) => rows2.forEach((row) => {
       const i = index.get(String(row.note_id));
-      if (i !== void 0) buckets[i][rel].push(decodeRowJson(String(row.payload)));
-    }
+      if (i !== void 0) buckets[i][relation].push(decodeRowJson(String(row.payload)));
+    }));
   }
-  const rows = noteRows.map((r, i) => {
-    const [segments, tags, links, pages] = buckets[i];
-    return { note: decodeRowJson(String(r.payload)), segments, tags, links, pages };
+  const rows = noteRows.map((row, i) => {
+    const [tags, links, pages] = buckets[i];
+    return { note: decodeRowJson(String(row.payload)), tags, links, pages };
   });
-  const result = { projectionVersion: DOMAIN_PROJECTION_VERSION, selectedCount, matchedCount, plan, rows };
-  return result;
+  return { projectionVersion: DOMAIN_PROJECTION_VERSION, selectedCount, matchedCount, plan, rows };
 }
 async function handleDomainQuery(db, body) {
   const query = parseQuery(body);
@@ -1373,7 +1575,6 @@ var USER_OWNED_STORES = [
   "tags",
   "tag_types",
   "note_tags",
-  "segments",
   "sessions",
   "attachments",
   "events",
@@ -1524,18 +1725,14 @@ var SqlStorage = class {
   }
   async transaction(stores, mode, fn) {
     await this.ensureReady();
-    return this.runTx(stores, mode === "readwrite", fn, false);
+    return this.runTx(stores, mode === "readwrite", fn);
   }
-  /**
-   * Bulk load for migration destinations: like transaction(), but the
-   * buffered writes skip per-key projection refresh and derived state is
-   * rebuilt once — everything inside one SQL transaction (throw → rollback).
-   */
+  /** Bulk writes use the same affected-key refresh as ordinary transactions. */
   async bulkTransaction(stores, fn) {
     await this.ensureReady();
-    return this.runTx(stores, true, fn, true);
+    return this.runTx(stores, true, fn);
   }
-  runTx(stores, mutableMode, fn, deferProjection) {
+  runTx(stores, mutableMode, fn) {
     const scoped = new Set(stores);
     const buffer = /* @__PURE__ */ new Map();
     const cleared = /* @__PURE__ */ new Set();
@@ -1561,8 +1758,7 @@ var SqlStorage = class {
       const result = await fn(tx);
       const ops = bufferToOps(STORE_DEFS.map((d) => d.name), buffer, cleared);
       if (ops.length > 0) {
-        await refreshDomain(conn, ops, deferProjection ? { deferProjection: true } : {});
-        if (deferProjection) await rebuildProjections(conn);
+        await refreshDomain(conn, ops);
       }
       return result;
     });
@@ -1637,6 +1833,20 @@ var SqlStore = class {
     if (this.cleared?.has(this.store)) return void 0;
     return getRow(this.conn, this.def, k);
   }
+  async getMany(keys) {
+    await this.owner.ensureReady();
+    const normalized = keys.map((key) => this.pointKey(key));
+    const committed = this.cleared?.has(this.store) ? keys.map(() => void 0) : await getRows(this.conn, this.def, normalized);
+    return normalized.map((key, i) => {
+      const state = bufferedGet(this.store, key, this.buffer);
+      return state ? state.hit ? state.value : void 0 : committed[i];
+    });
+  }
+  async getAllFromIndexMany(indexName, keys) {
+    await this.owner.ensureReady();
+    const rows = await listRowsFromIndexMany(this.conn, this.def, indexName, keys.map((key) => this.pointKey(key)));
+    return rows.map((values, i) => overlayRows(this.def, this.store, this.buffer, this.cleared, values, void 0, { only: this.pointKey(keys[i]) }, indexName));
+  }
   async getAll(query, count) {
     await this.owner.ensureReady();
     const range = rangeFromIDB(query);
@@ -1668,6 +1878,10 @@ var SqlStore = class {
     this.assertMutable();
     const stored = this.owner.stamp(this.store, value);
     const key = keyFromValue(this.def, stored);
+    if (this.store === "block_revisions") {
+      const previous = this.buffer?.get(bufferSlot(this.store, key));
+      if (previous?.kind === "put" && !rowsEqual(previous.value, stored)) throw new StorageError(409, "immutable block revision collision", "revision_conflict");
+    }
     if (this.buffer) {
       this.buffer.set(bufferSlot(this.store, key), { kind: "put", value: stored });
       return key;
@@ -1675,9 +1889,28 @@ var SqlStore = class {
     await this.owner.applyOps([{ op: "put", store: this.store, value: stored }]);
     return key;
   }
+  async putMany(values, _keys) {
+    await this.owner.ensureReady();
+    this.assertMutable();
+    const stored = values.map((value) => this.owner.stamp(this.store, value));
+    const keys = stored.map((value) => keyFromValue(this.def, value));
+    if (this.store === "block_revisions") {
+      const seen = /* @__PURE__ */ new Map();
+      keys.forEach((key, i) => {
+        const slot = bufferSlot(this.store, key), previous = this.buffer?.get(slot);
+        const value = seen.has(slot) ? seen.get(slot) : previous?.kind === "put" ? previous.value : void 0;
+        if (value !== void 0 && !rowsEqual(value, stored[i])) throw new StorageError(409, "immutable block revision collision", "revision_conflict");
+        seen.set(slot, stored[i]);
+      });
+    }
+    if (this.buffer) keys.forEach((key, i) => this.buffer.set(bufferSlot(this.store, key), { kind: "put", value: stored[i] }));
+    else await this.owner.applyOps(stored.map((value) => ({ op: "put", store: this.store, value })));
+    return keys;
+  }
   async delete(key) {
     await this.owner.ensureReady();
     this.assertMutable();
+    if (this.store === "block_revisions") throw new StorageError(409, "block history requires explicit wipe", "revision_conflict");
     const range = isRange(key) ? key : void 0;
     const target = range ?? key;
     if (this.buffer) {
@@ -1697,6 +1930,7 @@ var SqlStore = class {
   async clear() {
     await this.owner.ensureReady();
     this.assertMutable();
+    if (this.store === "block_revisions") throw new StorageError(409, "block history requires explicit wipe", "revision_conflict");
     if (this.buffer) {
       this.cleared?.add(this.store);
       const prefix = `${this.store}\0`;
@@ -1752,25 +1986,323 @@ 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 ?? []));
+  }
+  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));
+  } 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");
+  }
+  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 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";
+}
+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 })]
+    );
+  });
+}
+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");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    throw new StorageError(400, "sync op data is not valid JSON", "bad_sync_mutation");
+  }
+  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])
+  };
+}
+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) {
+      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"
+      );
+    }
+    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
+      );
+      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)]
+        });
+      });
+    }
+    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");
+    }
+    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");
+    }
+    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);
+  });
+}
+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");
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(row.data);
+    } catch {
+      throw new StorageError(400, "sync op data is not valid JSON", "bad_sync_row");
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new StorageError(400, "sync op data must be an object", "bad_sync_row");
+    }
+    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");
+    }
+    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]));
+}
+
 exports.BrowserTursoStorage = BrowserTursoStorage;
 exports.MAX_BODY = MAX_BODY;
 exports.SCHEMA_TABLE = SCHEMA_TABLE;
+exports.SYNC_ARCHIVE_TABLE = SYNC_ARCHIVE_TABLE;
+exports.SYNC_OPS_TABLE = SYNC_OPS_TABLE;
+exports.SYNC_STATE_TABLE = SYNC_STATE_TABLE;
 exports.SqlStorage = SqlStorage;
 exports.StorageError = StorageError;
+exports.applySyncBatch = applySyncBatch;
 exports.clearRows = clearRows;
 exports.countRows = countRows;
 exports.decodeRowJson = decodeRowJson;
 exports.deleteRows = deleteRows;
 exports.encodeRowJson = encodeRowJson;
+exports.fetchSyncOps = fetchSyncOps;
 exports.getRow = getRow;
+exports.getRows = getRows;
 exports.handleDomainQuery = handleDomainQuery;
+exports.initSyncTarget = initSyncTarget;
 exports.initializeDomain = initializeDomain;
 exports.initializeStore = initializeStore;
 exports.libsqlDatabase = libsqlDatabase;
 exports.listRows = listRows;
+exports.listRowsFromIndexMany = listRowsFromIndexMany;
+exports.probeSyncTarget = probeSyncTarget;
 exports.putRow = putRow;
+exports.putRows = putRows;
+exports.readLegacyRows = readLegacyRows;
+exports.readRawSyncOps = readRawSyncOps;
 exports.rebuildProjections = rebuildProjections;
 exports.refreshDomain = refreshDomain;
+exports.replaceSyncLog = replaceSyncLog;
 exports.storeDefinition = storeDefinition;
 exports.validateTursoUrl = validateTursoUrl;
 exports.wipeDomain = wipeDomain;