or3-provider-sqlite 0.0.9 → 0.0.11

package/dist/runtime/server/sync/sqlite-sync-gateway-adapter.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { canRunSyncHistoryGc } from "./history-gc-policy.js";
 import { createError } from "h3";
 import {
@@ -8,10 +9,17 @@ import {
   getSyncMaintenanceState,
   SYNC_MAINTENANCE_RETENTION_SECONDS
 } from "./maintenance-state.js";
+import {
+  backgroundHistoryDeviceId,
+  parseChatGenerationAdmissionEnvelope
+} from "~~/shared/chat/background-history";
 import { getSqliteDb, getRawDb, isD1Driver } from "../db/kysely.js";
 import { d1All, d1Batch, d1Run } from "../db/d1.js";
 import { SYNCED_TABLE_MAP, ALLOWED_SYNC_TABLES } from "../db/schema.js";
 import { emitWebhookSystemHook } from "~~/server/utils/webhooks/runtime";
+import { incomingRevisionWins } from "~~/shared/sync/revision";
+import { sanitizePayloadForSync } from "~~/shared/sync/sanitize";
+import { computePullRetention } from "./history-gc-policy.js";
 const DEFAULT_PULL_LIMIT = 100;
 const MAX_PULL_LIMIT = 1e3;
 const MAX_SNAPSHOT_PAGE_SIZE = 1e3;
@@ -37,6 +45,13 @@ function stableJson(value) {
     (key) => `${JSON.stringify(key)}:${stableJson(record[key])}`
   ).join(",")}}`;
 }
+function backgroundHistoryOpId(admission, stage) {
+  const hex = createHash("sha256").update(`${admission.workspaceId}\0${admission.generationId}\0${stage}`).digest("hex").slice(0, 32).split("");
+  hex[12] = "4";
+  hex[16] = (Number.parseInt(hex[16], 16) & 3 | 8).toString(16);
+  const value = hex.join("");
+  return `${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}`;
+}
 function operationFingerprint(op) {
   return stableJson({
     tableName: op.tableName,
@@ -48,6 +63,61 @@ function operationFingerprint(op) {
     deviceId: op.stamp.deviceId
   });
 }
+function changeLogFingerprint(row) {
+  return stableJson({
+    tableName: row.table_name,
+    operation: row.op,
+    pk: row.pk,
+    payload: row.payload_json ? JSON.parse(row.payload_json) : void 0,
+    clock: row.clock,
+    hlc: row.hlc,
+    deviceId: row.device_id
+  });
+}
+function notificationPayloadUserId(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return void 0;
+  }
+  const userId = payload.user_id;
+  return typeof userId === "string" && userId.trim().length > 0 ? userId : void 0;
+}
+function isNotificationVisibleToUser(change, userId) {
+  if (change.tableName !== "notifications") return true;
+  if (!userId) return false;
+  return notificationPayloadUserId(change.payload) === userId;
+}
+function scopeNotificationWrite(op, userId) {
+  if (op.tableName !== "notifications") return op;
+  if (!userId) {
+    return "Unauthorized: notification writes require a session user";
+  }
+  if (op.operation !== "put") return op;
+  const payload = op.payload && typeof op.payload === "object" && !Array.isArray(op.payload) ? { ...op.payload } : {};
+  if (payload.user_id !== void 0 && payload.user_id !== userId) {
+    return "Forbidden: notification owner mismatch";
+  }
+  return { ...op, payload: { ...payload, user_id: userId } };
+}
+const LWW_EXCLUDED_WINS = `(
+    excluded.clock > TARGET.clock
+    OR (excluded.clock = TARGET.clock AND excluded.hlc > TARGET.hlc)
+    OR (
+        excluded.clock = TARGET.clock
+        AND excluded.hlc = TARGET.hlc
+        AND excluded.op_id > TARGET.op_id
+    )
+)`;
+function lwwExcludedWins(existingTable) {
+  return LWW_EXCLUDED_WINS.replaceAll("TARGET", existingTable);
+}
+function snapshotNotificationOwnerClause(tableName, jsonExpr, userId) {
+  if (tableName !== "notifications") return { sql: "", params: [] };
+  if (!userId) return { sql: " AND 1 = 0", params: [] };
+  return {
+    sql: ` AND json_extract(${jsonExpr}, '$.user_id') = ?`,
+    params: [userId]
+  };
+}
 function validatePushOperation(workspaceId, op) {
   if (!ALLOWED_SYNC_TABLES.includes(op.tableName)) {
     return `Invalid table: ${op.tableName}`;
@@ -292,23 +362,355 @@ function resolveHookEmission(input) {
   }
   return null;
 }
-function incomingWinsLww(inClock, inHlc, existingClock, existingHlc) {
-  if (inClock > existingClock) return true;
-  if (inClock === existingClock && inHlc > existingHlc) return true;
-  return false;
+function incomingWinsRevision(incoming, existing) {
+  return incomingRevisionWins(incoming, {
+    clock: existing.clock,
+    hlc: existing.hlc,
+    opId: existing.opId || existing.op_id || ""
+  });
+}
+function materializedWinner(row, tombstone) {
+  if (tombstone && (!row || incomingWinsRevision(
+    { clock: tombstone.clock, hlc: tombstone.hlc, opId: tombstone.op_id },
+    row
+  ))) {
+    return {
+      kind: "delete",
+      revision: { clock: tombstone.clock, hlc: tombstone.hlc, opId: tombstone.op_id },
+      serverDeletedAt: tombstone.deleted_at
+    };
+  }
+  if (!row) return void 0;
+  const revision = { clock: row.clock, hlc: row.hlc, opId: row.op_id };
+  return row.deleted ? {
+    kind: "delete",
+    revision,
+    serverDeletedAt: tombstone?.op_id === row.op_id ? tombstone.deleted_at : row.updated_at
+  } : { kind: "put", payload: JSON.parse(row.data_json), revision };
+}
+function currentWinnerNative(raw, workspaceId, tableName, pk) {
+  const materializedTable = SYNCED_TABLE_MAP[tableName];
+  if (!materializedTable) return void 0;
+  const row = raw.prepare(
+    `SELECT data_json, deleted, clock, hlc, op_id, updated_at
+         FROM ${materializedTable} WHERE id = ? AND workspace_id = ?`
+  ).get(pk, workspaceId);
+  const tombstone = raw.prepare(
+    `SELECT clock, hlc, op_id, deleted_at FROM tombstones
+         WHERE workspace_id = ? AND table_name = ? AND pk = ?`
+  ).get(workspaceId, tableName, pk);
+  return materializedWinner(row, tombstone);
+}
+async function currentWinnerD1(workspaceId, tableName, pk) {
+  const materializedTable = SYNCED_TABLE_MAP[tableName];
+  if (!materializedTable) return void 0;
+  const [row] = await d1All(
+    `SELECT data_json, deleted, clock, hlc, op_id, updated_at
+         FROM "${materializedTable}" WHERE id = ? AND workspace_id = ?`,
+    pk,
+    workspaceId
+  );
+  const [tombstone] = await d1All(
+    `SELECT clock, hlc, op_id, deleted_at FROM tombstones
+         WHERE workspace_id = ? AND table_name = ? AND pk = ?`,
+    workspaceId,
+    tableName,
+    pk
+  );
+  return materializedWinner(row, tombstone);
 }
 export class SqliteSyncGatewayAdapter {
   id = "sqlite";
-  capabilities = {
-    snapshotBootstrap: "snapshot-v1",
-    historyRetention: "snapshot-v1"
-  };
+  get capabilities() {
+    return isD1Driver() ? {
+      snapshotBootstrap: "snapshot-v1",
+      historyRetention: "snapshot-v1"
+    } : {
+      snapshotBootstrap: "snapshot-v1",
+      historyRetention: "snapshot-v1",
+      backgroundGenerationHistory: "v1"
+    };
+  }
   get db() {
     return getSqliteDb();
   }
+  assertCanonicalActor(actor) {
+    if (isD1Driver()) {
+      throw new Error("SQLite D1 does not support background generation history v1");
+    }
+    const membership = getRawDb().prepare(
+      `SELECT role FROM workspace_members
+                 WHERE workspace_id = ? AND user_id = ?`
+    ).get(actor.workspaceId, actor.userId);
+    if (!membership || membership.role !== "owner" && membership.role !== "editor") {
+      throw new Error("Forbidden background history actor");
+    }
+  }
+  async admitChatGeneration(actor, input) {
+    const admission = parseChatGenerationAdmissionEnvelope(input);
+    if (actor.workspaceId !== admission.workspaceId) {
+      throw new Error("Invalid background history workspace");
+    }
+    const raw = getRawDb();
+    const fingerprint = createHash("sha256").update(stableJson(admission)).digest("hex");
+    return raw.transaction(() => {
+      this.assertCanonicalActor(actor);
+      const receipt = raw.prepare(
+        `SELECT fingerprint, outcome, server_version
+                     FROM background_generation_receipts
+                     WHERE workspace_id = ? AND generation_id = ? AND stage = 'admission'`
+      ).get(admission.workspaceId, admission.generationId);
+      if (receipt) {
+        if (receipt.fingerprint !== fingerprint) {
+          throw new Error("Conflicting background admission replay");
+        }
+        return {
+          status: "admitted",
+          replayed: true,
+          serverVersion: receipt.server_version ?? 0
+        };
+      }
+      if (admission.kind === "continuation") {
+        const row = raw.prepare(
+          `SELECT data_json, clock, deleted FROM s_messages
+                         WHERE workspace_id = ? AND id = ?`
+        ).get(admission.workspaceId, admission.messageId);
+        const generationId = row ? JSON.parse(row.data_json).data?.generation_id : void 0;
+        const expectedClock = admission.expectedAssistant?.clock ?? -1;
+        const admissionClock = admission.assistantMessage.clock;
+        if (row && row.deleted === 1 || row && row.clock > admissionClock || row && row.clock === admissionClock && generationId !== admission.generationId || row && row.clock > expectedClock && row.clock < admissionClock || row && row.clock === expectedClock && admission.expectedAssistant?.generationId !== void 0 && generationId !== admission.expectedAssistant.generationId) {
+          throw new Error("Conflicting continuation admission");
+        }
+      }
+      const records = [
+        admission.thread ? { table: "threads", materialized: "s_threads", record: admission.thread } : null,
+        admission.userMessage ? { table: "messages", materialized: "s_messages", record: admission.userMessage } : null,
+        { table: "messages", materialized: "s_messages", record: admission.assistantMessage }
+      ].filter(Boolean);
+      const counter = raw.prepare("SELECT value FROM server_version_counter WHERE workspace_id = ?").get(admission.workspaceId);
+      const baseVersion = counter?.value ?? 0;
+      const finalVersion = baseVersion + records.length;
+      raw.prepare(
+        `INSERT INTO server_version_counter (workspace_id, value) VALUES (?, ?)
+                 ON CONFLICT(workspace_id) DO UPDATE SET value = excluded.value`
+      ).run(admission.workspaceId, finalVersion);
+      const now = nowEpoch();
+      records.forEach((entry, index) => {
+        const opId = backgroundHistoryOpId(
+          admission,
+          entry.table === "threads" ? "thread" : entry.record.id === admission.messageId ? "assistant" : "user"
+        );
+        const hlc = entry.record.hlc ?? `${Date.now().toString(36).padStart(9, "0")}:000:background`;
+        const tombstone = raw.prepare(
+          `SELECT clock, hlc, op_id FROM tombstones
+                     WHERE workspace_id = ? AND table_name = ? AND pk = ?`
+        ).get(
+          admission.workspaceId,
+          entry.table,
+          entry.record.id
+        );
+        if (tombstone && !incomingWinsRevision(
+          { clock: entry.record.clock, hlc, opId },
+          tombstone
+        )) {
+          throw new Error("Background history record was superseded");
+        }
+        const sanitized = sanitizePayloadForSync(
+          entry.table,
+          entry.record,
+          "put"
+        );
+        if (!sanitized) {
+          throw new Error("Invalid background history payload");
+        }
+        const payload = { ...sanitized, hlc, op_id: opId };
+        const payloadJson = JSON.stringify(payload);
+        if (new TextEncoder().encode(payloadJson).byteLength > MAX_SYNC_PAYLOAD_BYTES) {
+          throw new Error("Invalid background history payload size");
+        }
+        const version = baseVersion + index + 1;
+        raw.prepare(
+          `INSERT INTO change_log
+                     (id, workspace_id, server_version, table_name, pk, op, payload_json,
+                      clock, hlc, device_id, op_id, created_at)
+                     VALUES (?, ?, ?, ?, ?, 'put', ?, ?, ?, ?, ?, ?)`
+        ).run(
+          uid(),
+          admission.workspaceId,
+          version,
+          entry.table,
+          entry.record.id,
+          payloadJson,
+          entry.record.clock,
+          hlc,
+          backgroundHistoryDeviceId(admission.generationId),
+          opId,
+          now
+        );
+        raw.prepare(
+          `INSERT INTO ${entry.materialized}
+                     (id, workspace_id, data_json, clock, hlc, device_id, op_id,
+                      deleted, created_at, updated_at)
+                     VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+                     ON CONFLICT(workspace_id, id) DO UPDATE SET
+                       data_json = excluded.data_json, clock = excluded.clock,
+                       hlc = excluded.hlc, device_id = excluded.device_id,
+                       op_id = excluded.op_id, deleted = 0, updated_at = excluded.updated_at
+                     WHERE ${lwwExcludedWins(entry.materialized)}`
+        ).run(
+          entry.record.id,
+          admission.workspaceId,
+          payloadJson,
+          entry.record.clock,
+          hlc,
+          backgroundHistoryDeviceId(admission.generationId),
+          opId,
+          now,
+          now
+        );
+      });
+      const admittedAssistant = raw.prepare(
+        `SELECT data_json, clock, deleted FROM s_messages
+                     WHERE workspace_id = ? AND id = ?`
+      ).get(admission.workspaceId, admission.messageId);
+      const admittedPayload = admittedAssistant ? JSON.parse(admittedAssistant.data_json) : null;
+      const admittedData = admittedPayload?.data && typeof admittedPayload.data === "object" ? admittedPayload.data : {};
+      if (!admittedAssistant || admittedAssistant.deleted === 1 || admittedAssistant.clock !== admission.assistantMessage.clock || admittedData.generation_id !== admission.generationId) {
+        throw new Error("Background assistant admission was superseded");
+      }
+      raw.prepare(
+        `INSERT INTO background_generation_receipts
+                 (id, workspace_id, generation_id, stage, fingerprint, outcome,
+                  server_version, created_at)
+                 VALUES (?, ?, ?, 'admission', ?, 'admitted', ?, ?)`
+      ).run(uid(), admission.workspaceId, admission.generationId, fingerprint, finalVersion, now);
+      return { status: "admitted", replayed: false, serverVersion: finalVersion };
+    }).immediate();
+  }
+  async finalizeChatGeneration(actor, input) {
+    const admission = parseChatGenerationAdmissionEnvelope(input.admission);
+    if (actor.workspaceId !== admission.workspaceId) {
+      throw new Error("Invalid background history workspace");
+    }
+    const raw = getRawDb();
+    const fingerprint = createHash("sha256").update(stableJson(input)).digest("hex");
+    return raw.transaction(() => {
+      this.assertCanonicalActor(actor);
+      const receipt = raw.prepare(
+        `SELECT fingerprint, outcome, server_version
+                     FROM background_generation_receipts
+                     WHERE workspace_id = ? AND generation_id = ? AND stage = 'finalization'`
+      ).get(admission.workspaceId, admission.generationId);
+      if (receipt) {
+        if (receipt.fingerprint !== fingerprint) {
+          throw new Error("Conflicting background finalization replay");
+        }
+        return receipt.outcome === "committed" ? {
+          status: "committed",
+          replayed: true,
+          serverVersion: receipt.server_version ?? 0
+        } : {
+          status: "superseded",
+          reason: receipt.outcome
+        };
+      }
+      const row = raw.prepare(
+        `SELECT data_json, clock, deleted FROM s_messages
+                     WHERE workspace_id = ? AND id = ?`
+      ).get(admission.workspaceId, admission.messageId);
+      const current = row ? JSON.parse(row.data_json) : null;
+      const data = current?.data && typeof current.data === "object" ? current.data : {};
+      let superseded = null;
+      if (!row || !current) superseded = "missing";
+      else if (row.deleted === 1 || current.deleted === true) superseded = "deleted";
+      else if (data.generation_id !== admission.generationId) superseded = "newer_generation";
+      else if (row.clock !== admission.assistantMessage.clock) superseded = "edited";
+      const now = nowEpoch();
+      if (superseded) {
+        raw.prepare(
+          `INSERT INTO background_generation_receipts
+                     (id, workspace_id, generation_id, stage, fingerprint, outcome,
+                      server_version, created_at)
+                     VALUES (?, ?, ?, 'finalization', ?, ?, NULL, ?)`
+        ).run(uid(), admission.workspaceId, admission.generationId, fingerprint, superseded, now);
+        return { status: "superseded", reason: superseded };
+      }
+      const nextClock = row.clock + 1;
+      const hlc = `${Date.now().toString(36).padStart(9, "0")}:000:background`;
+      const opId = backgroundHistoryOpId(admission, "finalize");
+      const terminalState = input.snapshot.status === "complete" ? "complete" : input.snapshot.status === "aborted" ? "aborted" : "failed";
+      const payload = {
+        ...current,
+        pending: false,
+        error: input.snapshot.error ?? null,
+        updated_at: Math.floor(input.snapshot.completedAt / 1e3),
+        clock: nextClock,
+        hlc,
+        op_id: opId,
+        data: {
+          ...data,
+          content: input.snapshot.content,
+          reasoning_text: input.snapshot.reasoning || null,
+          tool_calls: input.snapshot.toolCalls ?? null,
+          generation_state: terminalState,
+          background_job_status: input.snapshot.status,
+          background_job_error: input.snapshot.error ?? null,
+          error: input.snapshot.error ?? null
+        }
+      };
+      const payloadJson = JSON.stringify(payload);
+      if (new TextEncoder().encode(payloadJson).byteLength > MAX_SYNC_PAYLOAD_BYTES) {
+        throw new Error("Invalid background history payload size");
+      }
+      const counter = raw.prepare("SELECT value FROM server_version_counter WHERE workspace_id = ?").get(admission.workspaceId);
+      const serverVersion = (counter?.value ?? 0) + 1;
+      raw.prepare(
+        `INSERT INTO server_version_counter (workspace_id, value) VALUES (?, ?)
+                 ON CONFLICT(workspace_id) DO UPDATE SET value = excluded.value`
+      ).run(admission.workspaceId, serverVersion);
+      raw.prepare(
+        `UPDATE s_messages SET data_json = ?, clock = ?, hlc = ?, device_id = ?,
+                    op_id = ?, deleted = 0, updated_at = ?
+                 WHERE workspace_id = ? AND id = ?`
+      ).run(
+        payloadJson,
+        nextClock,
+        hlc,
+        backgroundHistoryDeviceId(admission.generationId),
+        opId,
+        now,
+        admission.workspaceId,
+        admission.messageId
+      );
+      raw.prepare(
+        `INSERT INTO change_log
+                 (id, workspace_id, server_version, table_name, pk, op, payload_json,
+                  clock, hlc, device_id, op_id, created_at)
+                 VALUES (?, ?, ?, 'messages', ?, 'put', ?, ?, ?, ?, ?, ?)`
+      ).run(
+        uid(),
+        admission.workspaceId,
+        serverVersion,
+        admission.messageId,
+        payloadJson,
+        nextClock,
+        hlc,
+        backgroundHistoryDeviceId(admission.generationId),
+        opId,
+        now
+      );
+      raw.prepare(
+        `INSERT INTO background_generation_receipts
+                 (id, workspace_id, generation_id, stage, fingerprint, outcome,
+                  server_version, created_at)
+                 VALUES (?, ?, ?, 'finalization', ?, 'committed', ?, ?)`
+      ).run(uid(), admission.workspaceId, admission.generationId, fingerprint, serverVersion, now);
+      return { status: "committed", replayed: false, serverVersion };
+    }).immediate();
+  }
   async reserveUploadIntent(event, input) {
     await assertWorkspaceScopeAuthorized(event, input.workspaceId);
-    if (!input.intentId || !Number.isSafeInteger(input.sizeBytes) || input.sizeBytes < 1 || !Number.isSafeInteger(input.expiresAt) || input.expiresAt <= nowEpoch()) {
+    if (!input.intentId || !Number.isSafeInteger(input.sizeBytes) || input.sizeBytes < 0 || !Number.isSafeInteger(input.expiresAt) || input.expiresAt <= nowEpoch()) {
       throw createError({ statusCode: 400, statusMessage: "Invalid upload intent" });
     }
     if (input.workspaceQuotaBytes !== void 0 && (!Number.isSafeInteger(input.workspaceQuotaBytes) || input.workspaceQuotaBytes < 1)) {
@@ -497,11 +899,15 @@ export class SqliteSyncGatewayAdapter {
           throw createError({ statusCode: 500, statusMessage: "Invalid canonical file size" });
         }
         const storageId = payload.storage_id ?? payload.storageId;
+        const fileKind = payload.kind === "image" ? "image" : payload.kind === "pdf" ? "pdf" : payload.kind === "file" ? "file" : void 0;
         return {
           kind: "metadata",
           hash: normalizeStorageHash(row.id),
           sizeBytes: size,
           ...typeof storageId === "string" && storageId ? { storageId } : {},
+          ...typeof (payload.mime_type ?? payload.mimeType) === "string" ? { mimeType: String(payload.mime_type ?? payload.mimeType) } : {},
+          ...typeof payload.name === "string" ? { name: payload.name } : {},
+          ...fileKind ? { fileKind } : {},
           updatedAt: row.updated_at
         };
       });
@@ -609,6 +1015,7 @@ export class SqliteSyncGatewayAdapter {
     if (!ops.length) {
       return { results: [], serverVersion: 0 };
     }
+    const userId = resolveSessionUserId(event);
     const resultSlots = new Array(ops.length);
     const groups = /* @__PURE__ */ new Map();
     ops.forEach((op, index) => {
@@ -629,19 +1036,20 @@ export class SqliteSyncGatewayAdapter {
     const uniqueOps = [];
     const indicesByOpId = /* @__PURE__ */ new Map();
     for (const group of groups.values()) {
-      const error = group.conflicting ? `Conflicting operations reuse op_id ${group.op.stamp.opId}` : validatePushOperation(workspaceId, group.op);
+      const scoped = group.conflicting ? group.op : scopeNotificationWrite(group.op, userId);
+      const error = group.conflicting ? `Conflicting operations reuse op_id ${group.op.stamp.opId}` : typeof scoped === "string" ? scoped : validatePushOperation(workspaceId, scoped);
       if (error) {
         for (const index of group.indices) {
           resultSlots[index] = {
             opId: group.op.stamp.opId,
             success: false,
             error,
-            errorCode: group.conflicting ? "CONFLICT" : "VALIDATION_ERROR"
+            errorCode: group.conflicting ? "CONFLICT" : error.startsWith("Unauthorized") || error.startsWith("Forbidden") ? "UNAUTHORIZED" : "VALIDATION_ERROR"
           };
         }
         continue;
       }
-      uniqueOps.push(group.op);
+      uniqueOps.push(scoped);
       indicesByOpId.set(group.op.stamp.opId, group.indices);
     }
     if (isD1Driver()) {
@@ -650,12 +1058,12 @@ export class SqliteSyncGatewayAdapter {
         workspaceId,
         uniqueOps,
         resultSlots,
-        indicesByOpId
+        indicesByOpId,
+        userId
       });
     }
     const raw = getRawDb();
     const now = nowEpoch();
-    const userId = resolveSessionUserId(event);
     const uniqueResults = [];
     let finalServerVersion = 0;
     const hookEmissions = [];
@@ -667,15 +1075,42 @@ export class SqliteSyncGatewayAdapter {
         const chunk = opIds.slice(i, i + chunkSize);
         const placeholders = chunk.map(() => "?").join(",");
         const rows = raw.prepare(
-          `SELECT op_id, server_version FROM change_log WHERE op_id IN (${placeholders})`
+          `SELECT op_id, server_version, workspace_id, table_name, pk, op,
+                                payload_json, clock, hlc, device_id
+                         FROM change_log WHERE op_id IN (${placeholders})`
         ).all(...chunk);
         for (const row of rows) {
-          existingOps.set(row.op_id, row.server_version);
+          existingOps.set(row.op_id, {
+            server_version: row.server_version,
+            workspace_id: row.workspace_id,
+            fingerprint: changeLogFingerprint(row),
+            op_id: row.op_id
+          });
+        }
+      }
+      const failedBeforeAlloc = /* @__PURE__ */ new Set();
+      for (const op of uniqueOps) {
+        if (op.tableName !== "notifications" || op.operation !== "delete") continue;
+        const materializedTable = SYNCED_TABLE_MAP[op.tableName];
+        if (!materializedTable) continue;
+        const owned = raw.prepare(
+          `SELECT data_json FROM ${materializedTable} WHERE id = ? AND workspace_id = ?`
+        ).get(op.pk, workspaceId);
+        const owner = owned ? notificationPayloadUserId(JSON.parse(owned.data_json)) : void 0;
+        if (!owned || owner !== userId) {
+          failedBeforeAlloc.add(op.stamp.opId);
+          uniqueResults.push({
+            opId: op.stamp.opId,
+            success: false,
+            error: "Forbidden: notification owner mismatch",
+            errorCode: "UNAUTHORIZED"
+          });
         }
       }
       const uniqueNewOpIds = /* @__PURE__ */ new Set();
       for (const op of uniqueOps) {
         if (existingOps.has(op.stamp.opId)) continue;
+        if (failedBeforeAlloc.has(op.stamp.opId)) continue;
         uniqueNewOpIds.add(op.stamp.opId);
       }
       let baseVersion;
@@ -700,6 +1135,7 @@ export class SqliteSyncGatewayAdapter {
       let versionOffset = 0;
       for (const op of uniqueOps) {
         if (existingOps.has(op.stamp.opId)) continue;
+        if (failedBeforeAlloc.has(op.stamp.opId)) continue;
         if (assignedVersions.has(op.stamp.opId)) continue;
         versionOffset++;
         assignedVersions.set(op.stamp.opId, baseVersion + versionOffset);
@@ -707,12 +1143,26 @@ export class SqliteSyncGatewayAdapter {
       const processedNew = /* @__PURE__ */ new Set();
       for (const op of uniqueOps) {
         const opId = op.stamp.opId;
-        const existingSv = existingOps.get(opId);
-        if (existingSv !== void 0) {
+        if (failedBeforeAlloc.has(opId)) continue;
+        const existingLog = existingOps.get(opId);
+        if (existingLog !== void 0) {
+          if (existingLog.workspace_id !== workspaceId || existingLog.fingerprint !== operationFingerprint(op)) {
+            uniqueResults.push({
+              opId,
+              success: false,
+              error: `Conflicting operation reuses processed op_id ${opId}`,
+              errorCode: "CONFLICT"
+            });
+            continue;
+          }
+          const winner = currentWinnerNative(raw, workspaceId, op.tableName, op.pk);
           uniqueResults.push({
             opId,
             success: true,
-            serverVersion: existingSv
+            serverVersion: existingLog.server_version,
+            replayed: true,
+            applied: winner?.revision.opId === opId,
+            ...winner?.revision.opId === opId ? {} : { winner }
           });
           continue;
         }
@@ -740,6 +1190,21 @@ export class SqliteSyncGatewayAdapter {
           continue;
         }
         const pkValue = op.pk;
+        if (op.tableName === "notifications" && op.operation === "delete") {
+          const owned = raw.prepare(
+            `SELECT data_json FROM ${materializedTable} WHERE id = ? AND workspace_id = ?`
+          ).get(pkValue, workspaceId);
+          const owner = owned ? notificationPayloadUserId(JSON.parse(owned.data_json)) : void 0;
+          if (!owned || owner !== userId) {
+            uniqueResults.push({
+              opId,
+              success: false,
+              error: "Forbidden: notification owner mismatch",
+              errorCode: "UNAUTHORIZED"
+            });
+            continue;
+          }
+        }
         const payloadJson = op.payload != null ? JSON.stringify(op.payload) : null;
         insertChangeLog.run(
           uid(),
@@ -755,33 +1220,42 @@ export class SqliteSyncGatewayAdapter {
           opId,
           now
         );
+        const incomingRev = {
+          clock: op.stamp.clock,
+          hlc: op.stamp.hlc,
+          opId
+        };
         if (op.operation === "put") {
           const existing = raw.prepare(
-            `SELECT clock, hlc FROM ${materializedTable} WHERE id = ? AND workspace_id = ?`
+            `SELECT clock, hlc, op_id, data_json FROM ${materializedTable} WHERE id = ? AND workspace_id = ?`
           ).get(pkValue, workspaceId);
+          const tombstone = !existing ? raw.prepare(
+            `SELECT clock, hlc, op_id FROM tombstones
+                             WHERE workspace_id = ? AND table_name = ? AND pk = ?`
+          ).get(workspaceId, op.tableName, pkValue) : void 0;
           let applied = false;
+          let winnerPayload = op.payload;
           if (!existing) {
-            raw.prepare(
-              `INSERT INTO ${materializedTable} (id, workspace_id, data_json, clock, hlc, device_id, op_id, deleted, created_at, updated_at)
-                             VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?)`
-            ).run(
-              pkValue,
-              workspaceId,
-              payloadJson ?? "{}",
-              op.stamp.clock,
-              op.stamp.hlc,
-              op.stamp.deviceId,
-              opId,
-              now,
-              now
-            );
-            applied = true;
-          } else if (incomingWinsLww(
-            op.stamp.clock,
-            op.stamp.hlc,
-            existing.clock,
-            existing.hlc
-          )) {
+            if (tombstone && !incomingWinsRevision(incomingRev, tombstone)) {
+              winnerPayload = void 0;
+            } else {
+              raw.prepare(
+                `INSERT INTO ${materializedTable} (id, workspace_id, data_json, clock, hlc, device_id, op_id, deleted, created_at, updated_at)
+                                 VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?)`
+              ).run(
+                pkValue,
+                workspaceId,
+                payloadJson ?? "{}",
+                op.stamp.clock,
+                op.stamp.hlc,
+                op.stamp.deviceId,
+                opId,
+                now,
+                now
+              );
+              applied = true;
+            }
+          } else if (incomingWinsRevision(incomingRev, existing)) {
             raw.prepare(
               `UPDATE ${materializedTable}
                              SET data_json = ?, clock = ?, hlc = ?, device_id = ?, op_id = ?, deleted = 0, updated_at = ?
@@ -797,6 +1271,8 @@ export class SqliteSyncGatewayAdapter {
               workspaceId
             );
             applied = true;
+          } else {
+            winnerPayload = JSON.parse(existing.data_json);
           }
           const emission = resolveHookEmission({
             op,
@@ -809,9 +1285,19 @@ export class SqliteSyncGatewayAdapter {
           if (emission) {
             hookEmissions.push(emission);
           }
+          uniqueResults.push({
+            opId,
+            success: true,
+            serverVersion,
+            applied,
+            ...applied ? {} : {
+              payload: winnerPayload,
+              winner: currentWinnerNative(raw, workspaceId, op.tableName, pkValue)
+            }
+          });
         } else if (op.operation === "delete") {
           const existing = raw.prepare(
-            `SELECT clock, hlc FROM ${materializedTable} WHERE id = ? AND workspace_id = ?`
+            `SELECT clock, hlc, op_id, data_json FROM ${materializedTable} WHERE id = ? AND workspace_id = ?`
           ).get(pkValue, workspaceId);
           let applied = false;
           if (!existing) {
@@ -829,12 +1315,7 @@ export class SqliteSyncGatewayAdapter {
               now
             );
             applied = true;
-          } else if (incomingWinsLww(
-            op.stamp.clock,
-            op.stamp.hlc,
-            existing.clock,
-            existing.hlc
-          )) {
+          } else if (incomingWinsRevision(incomingRev, existing)) {
             raw.prepare(
               `UPDATE ${materializedTable}
                              SET deleted = 1, clock = ?, hlc = ?, device_id = ?, op_id = ?, updated_at = ?
@@ -859,11 +1340,7 @@ export class SqliteSyncGatewayAdapter {
                            hlc = excluded.hlc,
                            op_id = excluded.op_id,
                            server_version = excluded.server_version
-                         WHERE excluded.clock > tombstones.clock
-                            OR (
-                                excluded.clock = tombstones.clock
-                                AND excluded.server_version > tombstones.server_version
-                            )`
+                         WHERE ${lwwExcludedWins("tombstones")}`
           ).run(
             uid(),
             workspaceId,
@@ -887,12 +1364,17 @@ export class SqliteSyncGatewayAdapter {
           if (emission) {
             hookEmissions.push(emission);
           }
+          uniqueResults.push({
+            opId,
+            success: true,
+            serverVersion,
+            applied,
+            ...applied || !existing ? {} : { payload: JSON.parse(existing.data_json) },
+            ...applied ? {} : {
+              winner: currentWinnerNative(raw, workspaceId, op.tableName, pkValue)
+            }
+          });
         }
-        uniqueResults.push({
-          opId,
-          success: true,
-          serverVersion
-        });
       }
     });
     runTx.immediate();
@@ -935,17 +1417,32 @@ export class SqliteSyncGatewayAdapter {
         deviceId: row.device_id,
         opId: row.op_id
       }
-    }));
+    })).filter(
+      (change) => isNotificationVisibleToUser(change, resolveSessionUserId(event))
+    );
     const lastRow = resultRows[resultRows.length - 1];
     const nextCursor = lastRow ? lastRow.server_version : cursor;
-    return { changes, nextCursor, hasMore };
+    const minLog = await db.selectFrom("change_log").select("server_version").where("workspace_id", "=", scope.workspaceId).orderBy("server_version", "asc").limit(1).executeTakeFirst();
+    const counter = await db.selectFrom("server_version_counter").select("value").where("workspace_id", "=", scope.workspaceId).executeTakeFirst();
+    const retention = computePullRetention({
+      cursor,
+      oldestLogVersion: minLog?.server_version ?? null,
+      highWatermark: counter?.value ?? 0
+    });
+    return {
+      changes,
+      nextCursor,
+      hasMore,
+      ...retention
+    };
   }
   async snapshot(event, input) {
     const workspaceId = input.scope.workspaceId;
     await assertWorkspaceScopeAuthorized(event, workspaceId);
     const pageSize = resolveSnapshotPageSize(input.pageSize);
+    const snapshotUserId = resolveSessionUserId(event);
     if (isD1Driver()) {
-      return this.snapshotInD1(workspaceId, input, pageSize);
+      return this.snapshotInD1(workspaceId, input, pageSize, snapshotUserId);
     }
     const raw = getRawDb();
     const now = nowEpoch();
@@ -1015,6 +1512,11 @@ export class SqliteSyncGatewayAdapter {
           if (!materializedTable) {
             throw new Error(`Missing materialized table for ${tableName}`);
           }
+          const liveOwner = snapshotNotificationOwnerClause(
+            tableName,
+            "data_json",
+            snapshotUserId
+          );
           raw.prepare(`
                         INSERT INTO sync_snapshot_items (
                             snapshot_id, table_name, pk, kind, payload_json,
@@ -1030,8 +1532,13 @@ export class SqliteSyncGatewayAdapter {
                             END,
                             NULL
                         FROM "${materializedTable}"
-                        WHERE workspace_id = ? AND deleted = 0
-                    `).run(snapshotId, tableName, workspaceId);
+                        WHERE workspace_id = ? AND deleted = 0${liveOwner.sql}
+                    `).run(snapshotId, tableName, workspaceId, ...liveOwner.params);
+          const deletedOwner = snapshotNotificationOwnerClause(
+            tableName,
+            "materialized.data_json",
+            snapshotUserId
+          );
           raw.prepare(`
                         INSERT INTO sync_snapshot_items (
                             snapshot_id, table_name, pk, kind, payload_json,
@@ -1062,8 +1569,9 @@ export class SqliteSyncGatewayAdapter {
                                 0
                             ))
                         FROM "${materializedTable}" AS materialized
-                        WHERE materialized.workspace_id = ? AND materialized.deleted <> 0
-                    `).run(snapshotId, tableName, tableName, workspaceId);
+                        WHERE materialized.workspace_id = ? AND materialized.deleted <> 0${deletedOwner.sql}
+                    `).run(snapshotId, tableName, tableName, workspaceId, ...deletedOwner.params);
+          const orphanFilter = tableName === "notifications" ? " AND 1 = 0" : "";
           raw.prepare(`
                         INSERT INTO sync_snapshot_items (
                             snapshot_id, table_name, pk, kind, payload_json,
@@ -1086,7 +1594,7 @@ export class SqliteSyncGatewayAdapter {
                               FROM "${materializedTable}" AS materialized
                               WHERE materialized.workspace_id = tombstone.workspace_id
                                 AND materialized.id = tombstone.pk
-                          )
+                          )${orphanFilter}
                     `).run(snapshotId, tableName, workspaceId, tableName);
         }
         return {
@@ -1400,7 +1908,7 @@ export class SqliteSyncGatewayAdapter {
       }
     ]);
   }
-  async snapshotInD1(workspaceId, input, pageSize) {
+  async snapshotInD1(workspaceId, input, pageSize, snapshotUserId) {
     const now = nowEpoch();
     let header;
     let after;
@@ -1466,6 +1974,17 @@ export class SqliteSyncGatewayAdapter {
         if (!materializedTable) {
           throw new Error(`Missing materialized table for ${tableName}`);
         }
+        const liveOwner = snapshotNotificationOwnerClause(
+          tableName,
+          "data_json",
+          snapshotUserId
+        );
+        const deletedOwner = snapshotNotificationOwnerClause(
+          tableName,
+          "materialized.data_json",
+          snapshotUserId
+        );
+        const orphanFilter = tableName === "notifications" ? " AND 1 = 0" : "";
         statements.push(
           {
             sql: `INSERT INTO sync_snapshot_items (
@@ -1482,8 +2001,8 @@ export class SqliteSyncGatewayAdapter {
                             END,
                             NULL
                         FROM "${materializedTable}"
-                        WHERE workspace_id = ? AND deleted = 0`,
-            parameters: [snapshotId, tableName, workspaceId]
+                        WHERE workspace_id = ? AND deleted = 0${liveOwner.sql}`,
+            parameters: [snapshotId, tableName, workspaceId, ...liveOwner.params]
           },
           {
             sql: `INSERT INTO sync_snapshot_items (
@@ -1515,8 +2034,14 @@ export class SqliteSyncGatewayAdapter {
                                 0
                             ))
                         FROM "${materializedTable}" AS materialized
-                        WHERE materialized.workspace_id = ? AND materialized.deleted <> 0`,
-            parameters: [snapshotId, tableName, tableName, workspaceId]
+                        WHERE materialized.workspace_id = ? AND materialized.deleted <> 0${deletedOwner.sql}`,
+            parameters: [
+              snapshotId,
+              tableName,
+              tableName,
+              workspaceId,
+              ...deletedOwner.params
+            ]
           },
           {
             sql: `INSERT INTO sync_snapshot_items (
@@ -1540,7 +2065,7 @@ export class SqliteSyncGatewayAdapter {
                               FROM "${materializedTable}" AS materialized
                               WHERE materialized.workspace_id = tombstone.workspace_id
                                 AND materialized.id = tombstone.pk
-                          )`,
+                          )${orphanFilter}`,
             parameters: [snapshotId, tableName, workspaceId, tableName]
           }
         );
@@ -1663,7 +2188,7 @@ export class SqliteSyncGatewayAdapter {
     }
   }
   async pushInD1(input) {
-    const { event, workspaceId, uniqueOps, resultSlots, indicesByOpId } = input;
+    const { workspaceId, uniqueOps, resultSlots, indicesByOpId, userId } = input;
     const existingOps = /* @__PURE__ */ new Map();
     const opIds = uniqueOps.map((op) => op.stamp.opId);
     for (let offset = 0; offset < opIds.length; offset += 500) {
@@ -1671,12 +2196,61 @@ export class SqliteSyncGatewayAdapter {
       if (chunk.length === 0) continue;
       const placeholders = chunk.map(() => "?").join(",");
       const rows = await d1All(
-        `SELECT op_id, server_version FROM change_log WHERE op_id IN (${placeholders})`,
+        `SELECT op_id, server_version, workspace_id, table_name, pk, op,
+                        payload_json, clock, hlc, device_id
+                 FROM change_log WHERE op_id IN (${placeholders})`,
         ...chunk
       );
-      for (const row of rows) existingOps.set(row.op_id, row.server_version);
+      for (const row of rows) {
+        existingOps.set(row.op_id, {
+          server_version: row.server_version,
+          workspace_id: row.workspace_id,
+          fingerprint: changeLogFingerprint(row)
+        });
+      }
+    }
+    const rejected = /* @__PURE__ */ new Set();
+    for (const op of uniqueOps) {
+      const existing = existingOps.get(op.stamp.opId);
+      if (!existing) continue;
+      if (existing.workspace_id !== workspaceId || existing.fingerprint !== operationFingerprint(op)) {
+        rejected.add(op.stamp.opId);
+        for (const index of indicesByOpId.get(op.stamp.opId) ?? []) {
+          resultSlots[index] = {
+            opId: op.stamp.opId,
+            success: false,
+            error: `Conflicting operation reuses processed op_id ${op.stamp.opId}`,
+            errorCode: "CONFLICT"
+          };
+        }
+      }
+    }
+    for (const op of uniqueOps) {
+      if (op.tableName !== "notifications" || op.operation !== "delete") continue;
+      if (existingOps.has(op.stamp.opId) || rejected.has(op.stamp.opId)) continue;
+      const materializedTable = SYNCED_TABLE_MAP[op.tableName];
+      if (!materializedTable) continue;
+      const [owned] = await d1All(
+        `SELECT data_json FROM "${materializedTable}" WHERE id = ? AND workspace_id = ?`,
+        op.pk,
+        workspaceId
+      );
+      const owner = owned ? notificationPayloadUserId(JSON.parse(owned.data_json)) : void 0;
+      if (!owned || owner !== userId) {
+        rejected.add(op.stamp.opId);
+        for (const index of indicesByOpId.get(op.stamp.opId) ?? []) {
+          resultSlots[index] = {
+            opId: op.stamp.opId,
+            success: false,
+            error: "Forbidden: notification owner mismatch",
+            errorCode: "UNAUTHORIZED"
+          };
+        }
+      }
     }
-    const newOps = uniqueOps.filter((op) => !existingOps.has(op.stamp.opId));
+    const newOps = uniqueOps.filter(
+      (op) => !existingOps.has(op.stamp.opId) && !rejected.has(op.stamp.opId)
+    );
     const versionOffsets = /* @__PURE__ */ new Map();
     newOps.forEach((op, index) => {
       versionOffsets.set(op.stamp.opId, index + 1);
@@ -1707,8 +2281,32 @@ export class SqliteSyncGatewayAdapter {
         }
       }
     }
+    const skipMaterialize = /* @__PURE__ */ new Set();
+    for (const op of newOps) {
+      if (op.operation !== "put") continue;
+      const materializedTable = SYNCED_TABLE_MAP[op.tableName];
+      if (!materializedTable) continue;
+      const materializedKey = `${materializedTable}\0${op.pk}`;
+      if (existingMaterializedKeys.has(materializedKey)) continue;
+      const [tombstone] = await d1All(
+        `SELECT clock, hlc, op_id FROM tombstones
+                 WHERE workspace_id = ? AND table_name = ? AND pk = ?`,
+        workspaceId,
+        op.tableName,
+        op.pk
+      );
+      if (tombstone && !incomingWinsRevision(
+        {
+          clock: op.stamp.clock,
+          hlc: op.stamp.hlc,
+          opId: op.stamp.opId
+        },
+        tombstone
+      )) {
+        skipMaterialize.add(op.stamp.opId);
+      }
+    }
     const now = nowEpoch();
-    const userId = resolveSessionUserId(event);
     const statements = [];
     if (newOps.length > 0) {
       statements.push(
@@ -1739,7 +2337,7 @@ export class SqliteSyncGatewayAdapter {
       );
       seenMaterializedKeys.add(materializedKey);
       statements.push({
-        sql: `INSERT OR IGNORE INTO change_log (
+        sql: `INSERT INTO change_log (
                     id, workspace_id, server_version, table_name, pk, op,
                     payload_json, clock, hlc, device_id, op_id, created_at
                 ) VALUES (
@@ -1764,6 +2362,7 @@ export class SqliteSyncGatewayAdapter {
           now
         ]
       });
+      if (skipMaterialize.has(op.stamp.opId)) continue;
       materializedStatementIndex.set(op.stamp.opId, statements.length);
       if (op.operation === "put") {
         statements.push({
@@ -1779,11 +2378,7 @@ export class SqliteSyncGatewayAdapter {
                         op_id = excluded.op_id,
                         deleted = 0,
                         updated_at = excluded.updated_at
-                    WHERE excluded.clock > "${materializedTable}".clock
-                       OR (
-                           excluded.clock = "${materializedTable}".clock
-                           AND excluded.hlc > "${materializedTable}".hlc
-                       )`,
+                    WHERE ${lwwExcludedWins(`"${materializedTable}"`)}`,
           parameters: [
             op.pk,
             workspaceId,
@@ -1809,11 +2404,7 @@ export class SqliteSyncGatewayAdapter {
                         op_id = excluded.op_id,
                         deleted = 1,
                         updated_at = excluded.updated_at
-                    WHERE excluded.clock > "${materializedTable}".clock
-                       OR (
-                           excluded.clock = "${materializedTable}".clock
-                           AND excluded.hlc > "${materializedTable}".hlc
-                       )`,
+                    WHERE ${lwwExcludedWins(`"${materializedTable}"`)}`,
           parameters: [
             op.pk,
             workspaceId,
@@ -1840,11 +2431,7 @@ export class SqliteSyncGatewayAdapter {
                         hlc = excluded.hlc,
                         op_id = excluded.op_id,
                         server_version = excluded.server_version
-                    WHERE excluded.clock > tombstones.clock
-                       OR (
-                           excluded.clock = tombstones.clock
-                           AND excluded.server_version > tombstones.server_version
-                       )`,
+                    WHERE ${lwwExcludedWins("tombstones")}`,
           parameters: [
             uid(),
             workspaceId,
@@ -1897,20 +2484,59 @@ export class SqliteSyncGatewayAdapter {
     }
     const emissions = [];
     for (const op of uniqueOps) {
+      if (rejected.has(op.stamp.opId)) continue;
+      const existing = existingOps.get(op.stamp.opId);
+      if (existing) {
+        const winner = await currentWinnerD1(workspaceId, op.tableName, op.pk);
+        const applied2 = winner?.revision.opId === op.stamp.opId;
+        const result2 = {
+          opId: op.stamp.opId,
+          success: true,
+          serverVersion: existing.server_version,
+          replayed: true,
+          applied: applied2,
+          ...applied2 ? {} : { winner }
+        };
+        for (const index of indicesByOpId.get(op.stamp.opId) ?? []) {
+          resultSlots[index] = result2;
+        }
+        continue;
+      }
       const serverVersion = resolvedOps.get(op.stamp.opId);
       if (serverVersion === void 0) {
         throw new Error(`D1 failed to resolve sync operation ${op.stamp.opId}.`);
       }
+      const skipApply = skipMaterialize.has(op.stamp.opId);
+      const materializedResult = batchResults[materializedStatementIndex.get(op.stamp.opId) ?? -1];
+      const applied = !skipApply && (materializedResult?.meta?.changes ?? 0) > 0;
+      let winnerPayload;
+      if (!applied && !skipApply) {
+        const materializedTable = SYNCED_TABLE_MAP[op.tableName];
+        if (materializedTable) {
+          const [winner] = await d1All(
+            `SELECT data_json FROM "${materializedTable}" WHERE id = ? AND workspace_id = ?`,
+            op.pk,
+            workspaceId
+          );
+          if (winner?.data_json) {
+            winnerPayload = JSON.parse(winner.data_json);
+          }
+        }
+      }
       const result = {
         opId: op.stamp.opId,
         success: true,
-        serverVersion
+        serverVersion,
+        applied,
+        ...applied ? {} : { payload: winnerPayload },
+        ...applied ? {} : {
+          winner: await currentWinnerD1(workspaceId, op.tableName, op.pk)
+        }
       };
       for (const index of indicesByOpId.get(op.stamp.opId) ?? []) {
         resultSlots[index] = result;
       }
-      const materializedResult = batchResults[materializedStatementIndex.get(op.stamp.opId) ?? -1];
-      if ((materializedResult?.meta?.changes ?? 0) > 0) {
+      if (applied) {
         const emission = resolveHookEmission({
           op,
           workspaceId,