@korajs/server 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/index.js

@@ -64,7 +64,7 @@ function isRetriableRejection(code) {
 import { generateUUIDv7 } from "@korajs/core";
 
 // src/store/materialization.ts
-import { StorageError, quoteIdent } from "@korajs/core";
+import { StorageError, quoteIdent, replayOperationsForRecord } from "@korajs/core";
 function fieldTypeToSql(descriptor, dialect) {
   switch (descriptor.kind) {
     case "string":
@@ -146,30 +146,6 @@ function generateAllCollectionDDL(schema, dialect) {
   }
   return statements;
 }
-function replayOperationsForRecord(ops) {
-  let record = null;
-  let deleted = false;
-  for (const op of ops) {
-    switch (op.type) {
-      case "insert":
-        if (op.data) {
-          record = { ...op.data };
-          deleted = false;
-        }
-        break;
-      case "update":
-        if (op.data) {
-          record = { ...record ?? {}, ...op.data };
-          deleted = false;
-        }
-        break;
-      case "delete":
-        deleted = true;
-        break;
-    }
-  }
-  return deleted ? null : record;
-}
 var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var BASE64_REVERSE = new Map(
   Array.from(BASE64_ALPHABET, (char, index3) => [char, index3])
@@ -220,6 +196,9 @@ function serializeFieldValue(value, descriptor) {
   if (value === null || value === void 0) return null;
   switch (descriptor.kind) {
     case "array":
+    case "object":
+    case "json":
+    case "blob":
       return typeof value === "string" ? value : JSON.stringify(value);
     case "boolean":
       return value ? 1 : 0;
@@ -233,6 +212,9 @@ function deserializeFieldValue(value, descriptor) {
   if (value === null || value === void 0) return null;
   switch (descriptor.kind) {
     case "array":
+    case "object":
+    case "json":
+    case "blob":
       return typeof value === "string" ? JSON.parse(value) : value;
     case "boolean":
       return value === 1 || value === true;
@@ -265,6 +247,14 @@ var MemoryServerStore = class {
   operations = [];
   operationIndex = /* @__PURE__ */ new Map();
   versionVector = /* @__PURE__ */ new Map();
+  /**
+   * Server-assigned delivery sequence per operation id. Single-process, so a plain
+   * counter incremented at insert time gives commit-order delivery sequence with no
+   * gaps. `operations` is kept in insertion (== delivery) order, so a delivery scan
+   * is a forward walk.
+   */
+  deliverySeqByOpId = /* @__PURE__ */ new Map();
+  deliverySeqCounter = 0;
   schema = null;
   /** Materialized records: collection -> recordId -> record data */
   materializedRecords = /* @__PURE__ */ new Map();
@@ -298,6 +288,8 @@ var MemoryServerStore = class {
     }
     this.operations.push(op);
     this.operationIndex.set(op.id, op);
+    this.deliverySeqCounter += 1;
+    this.deliverySeqByOpId.set(op.id, this.deliverySeqCounter);
     const currentSeq = this.versionVector.get(op.nodeId) ?? 0;
     if (op.sequenceNumber > currentSeq) {
       this.versionVector.set(op.nodeId, op.sequenceNumber);
@@ -317,6 +309,23 @@ var MemoryServerStore = class {
     this.assertOpen();
     return this.operations.length;
   }
+  async getMaxDeliverySequence() {
+    this.assertOpen();
+    return this.deliverySeqCounter;
+  }
+  async getOperationsAfterDelivery(afterDeliverySequence, limit) {
+    this.assertOpen();
+    const result = [];
+    if (limit <= 0) return result;
+    for (const op of this.operations) {
+      const deliverySequence = this.deliverySeqByOpId.get(op.id) ?? 0;
+      if (deliverySequence > afterDeliverySequence) {
+        result.push({ operation: op, deliverySequence });
+        if (result.length >= limit) break;
+      }
+    }
+    return result;
+  }
   async materializeCollection(collection) {
     this.assertOpen();
     if (this.schema?.collections[collection]) {
@@ -461,12 +470,16 @@ var MemoryServerStore = class {
     this.operations.length = 0;
     this.operationIndex.clear();
     this.versionVector.clear();
+    this.deliverySeqByOpId.clear();
+    this.deliverySeqCounter = 0;
     for (const [nid, seq] of versionVector) {
       this.versionVector.set(nid, seq);
     }
     for (const op of operations2) {
       this.operations.push(op);
       this.operationIndex.set(op.id, op);
+      this.deliverySeqCounter += 1;
+      this.deliverySeqByOpId.set(op.id, this.deliverySeqCounter);
       if (this.schema?.collections[op.collection]) {
         this.rebuildMaterializedRecord(op.collection, op.recordId);
       }
@@ -496,11 +509,12 @@ var MemoryServerStore = class {
         return a.timestamp.wallTime - b.timestamp.wallTime;
       if (a.timestamp.logical !== b.timestamp.logical)
         return a.timestamp.logical - b.timestamp.logical;
-      return a.sequenceNumber - b.sequenceNumber;
+      return a.timestamp.nodeId < b.timestamp.nodeId ? -1 : a.timestamp.nodeId > b.timestamp.nodeId ? 1 : 0;
     });
     const parsedOps = recordOps.map((op) => ({
       type: op.type,
-      data: op.data
+      data: op.data,
+      atomicOps: op.atomicOps ?? null
     }));
     const recordData = replayOperationsForRecord(parsedOps);
     if (recordData) {
@@ -606,8 +620,8 @@ var MemoryServerStore = class {
 };
 
 // src/store/postgres-server-store.ts
-import { generateUUIDv7 as generateUUIDv72, quoteIdent as quoteIdent2 } from "@korajs/core";
-import { and, asc, between, count, eq, sql } from "drizzle-orm";
+import { HybridLogicalClock, generateUUIDv7 as generateUUIDv72, quoteIdent as quoteIdent2 } from "@korajs/core";
+import { and, asc, between, count, desc, eq, gt, sql } from "drizzle-orm";
 
 // src/store/drizzle-pg-schema.ts
 import { bigint, index, integer, pgTable, text } from "drizzle-orm/pg-core";
@@ -623,6 +637,8 @@ var pgOperations = pgTable(
     // JSON-serialized, null for deletes
     previousData: text("previous_data"),
     // JSON-serialized, null for insert/delete
+    atomicOps: text("atomic_ops"),
+    // JSON-serialized Record<field, AtomicOp>, null when none
     wallTime: bigint("wall_time", { mode: "number" }).notNull(),
     logical: integer("logical").notNull(),
     timestampNodeId: text("timestamp_node_id").notNull(),
@@ -630,12 +646,18 @@ var pgOperations = pgTable(
     causalDeps: text("causal_deps").notNull().default("[]"),
     // JSON array of op IDs
     schemaVersion: integer("schema_version").notNull(),
-    receivedAt: bigint("received_at", { mode: "number" }).notNull()
+    receivedAt: bigint("received_at", { mode: "number" }).notNull(),
+    // Server-assigned monotonic delivery sequence, ordered by commit (assigned from
+    // a counter row locked inside the append transaction, so delivery order equals
+    // visibility order even across instances). Drives the gap-free server->client
+    // delivery watermark. Nullable only for pre-column rows, backfilled on startup.
+    deliverySeq: bigint("delivery_seq", { mode: "number" })
   },
   (table) => ({
     nodeSeqIdx: index("idx_pg_node_seq").on(table.nodeId, table.sequenceNumber),
     collectionIdx: index("idx_pg_collection").on(table.collection),
-    receivedIdx: index("idx_pg_received").on(table.receivedAt)
+    receivedIdx: index("idx_pg_received").on(table.receivedAt),
+    deliveryIdx: index("idx_pg_delivery_seq").on(table.deliverySeq)
   })
 );
 var pgSyncState = pgTable("sync_state", {
@@ -652,15 +674,43 @@ var PostgresServerStore = class {
   ready;
   schema = null;
   closed = false;
-  constructor(db, nodeId) {
+  /**
+   * Monotonic counter for this node's server-originated sequence numbers. Lazily
+   * seeded from the persisted version vector on first use, then advanced in memory
+   * (a synchronous `++`, atomic on the single JS thread) so concurrent conditional
+   * applies never receive the same number. Null means "not yet seeded"; reset to
+   * null after a backup import so it re-seeds from the restored version vector.
+   */
+  sequenceCounter = null;
+  /**
+   * Time source for HLC timestamps on server-originated operations. Injectable so a
+   * test can freeze wall-clock time and prove the conditional-apply ordering holds
+   * under same-millisecond commits (the case the advisory lock and clock advance
+   * exist to make correct). Defaults to the system clock in production.
+   */
+  timeSource;
+  constructor(db, nodeId, timeSource) {
     this.db = db;
     this.nodeId = nodeId ?? generateUUIDv72();
+    this.timeSource = timeSource ?? { now: () => Date.now() };
     this.ready = this.initialize();
   }
   getVersionVector() {
     this.assertOpen();
     return new Map(this.versionVector);
   }
+  /**
+   * Atomically reserve this node's next server-operation sequence number. The
+   * synchronous increment cannot interleave on the single JS thread, so two
+   * concurrent conditional applies are always handed distinct numbers.
+   */
+  reserveSequenceNumber() {
+    if (this.sequenceCounter === null) {
+      this.sequenceCounter = this.versionVector.get(this.nodeId) ?? 0;
+    }
+    this.sequenceCounter += 1;
+    return this.sequenceCounter;
+  }
   getNodeId() {
     return this.nodeId;
   }
@@ -698,8 +748,9 @@ var PostgresServerStore = class {
       return "duplicate";
     }
     const now = Date.now();
-    const row = this.serializeOperation(op, now);
     await this.db.transaction(async (tx) => {
+      const deliverySeq = await this.nextDeliverySeq(tx);
+      const row = this.serializeOperation(op, now, deliverySeq);
       await tx.insert(pgOperations).values(row).onConflictDoNothing({ target: pgOperations.id });
       await tx.insert(pgSyncState).values({
         nodeId: op.nodeId,
@@ -722,6 +773,73 @@ var PostgresServerStore = class {
     }
     return "applied";
   }
+  /**
+   * Conditionally apply operations atomically, serialized across server instances
+   * on the target record via a transaction-scoped advisory lock. The lock makes
+   * the read-decide-write cycle atomic against concurrent instances, so a cap
+   * check like `responseCount < max` cannot be passed by two admissions at once.
+   */
+  async applyConditional(input) {
+    this.assertOpen();
+    await this.ready;
+    this.assertSchema();
+    this.assertCollection(input.target.collection);
+    const schema = this.schema;
+    const collectionDef = schema.collections[input.target.collection];
+    const lockKey = `kora:${input.target.collection}:${input.target.id}`;
+    const result = await this.db.transaction(async (tx) => {
+      await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtextextended(${lockKey}, 0))`);
+      if (input.idempotencyKey) {
+        const existing = await tx.execute(
+          sql`SELECT 1 FROM ${sql.raw(quoteIdent2(input.idempotencyKey.collection))} WHERE id = ${input.idempotencyKey.id} AND _deleted = 0 LIMIT 1`
+        );
+        if (existing.length > 0) {
+          return { admitted: true, idempotent: true, applied: [] };
+        }
+      }
+      const rows = await tx.execute(
+        sql`SELECT * FROM ${sql.raw(quoteIdent2(input.target.collection))} WHERE id = ${input.target.id} AND _deleted = 0`
+      );
+      const current = rows.length > 0 ? this.deserializeRow(rows[0], collectionDef) : null;
+      if (!input.admit(current)) {
+        return { admitted: false, idempotent: false, applied: [] };
+      }
+      const clock = new HybridLogicalClock(this.nodeId, this.timeSource);
+      const latest = await this.latestOperationTimestamp(
+        tx,
+        input.target.collection,
+        input.target.id
+      );
+      if (latest) {
+        clock.advanceTo(latest);
+      }
+      const ops = await input.buildOperations(current, { clock });
+      const now = Date.now();
+      for (const op of ops) {
+        const deliverySeq = await this.nextDeliverySeq(tx);
+        const row = this.serializeOperation(op, now, deliverySeq);
+        await tx.insert(pgOperations).values(row).onConflictDoNothing({ target: pgOperations.id });
+        await tx.insert(pgSyncState).values({ nodeId: op.nodeId, maxSequenceNumber: op.sequenceNumber, lastSeenAt: now }).onConflictDoUpdate({
+          target: pgSyncState.nodeId,
+          set: {
+            maxSequenceNumber: sql`GREATEST(${pgSyncState.maxSequenceNumber}, ${op.sequenceNumber})`,
+            lastSeenAt: sql`${now}`
+          }
+        });
+        if (this.schema?.collections[op.collection]) {
+          await this.rebuildMaterializedRecord(tx, op.collection, op.recordId);
+        }
+      }
+      return { admitted: true, idempotent: false, applied: ops };
+    });
+    for (const op of result.applied) {
+      const currentMax = this.versionVector.get(op.nodeId) ?? 0;
+      if (op.sequenceNumber > currentMax) {
+        this.versionVector.set(op.nodeId, op.sequenceNumber);
+      }
+    }
+    return result;
+  }
   async getOperationRange(nodeId, fromSeq, toSeq) {
     this.assertOpen();
     await this.ready;
@@ -736,6 +854,23 @@ var PostgresServerStore = class {
     const result = await this.db.select({ value: count() }).from(pgOperations);
     return result[0]?.value ?? 0;
   }
+  async getMaxDeliverySequence() {
+    this.assertOpen();
+    await this.ready;
+    const rows = await this.db.execute(
+      sql`SELECT COALESCE(MAX(delivery_seq), 0) AS m FROM operations`
+    );
+    return Number(rows[0]?.m ?? 0);
+  }
+  async getOperationsAfterDelivery(afterDeliverySequence, limit) {
+    this.assertOpen();
+    await this.ready;
+    const rows = await this.db.select().from(pgOperations).where(gt(pgOperations.deliverySeq, afterDeliverySequence)).orderBy(asc(pgOperations.deliverySeq)).limit(limit);
+    return rows.map((row) => ({
+      operation: this.deserializeOperation(row),
+      deliverySequence: row.deliverySeq ?? 0
+    }));
+  }
   async materializeCollection(collection) {
     this.assertOpen();
     await this.ready;
@@ -799,7 +934,7 @@ var PostgresServerStore = class {
     this.assertOpen();
     await this.ready;
     const { buildServerBackup } = await import("./server-backup-MOICK6MI.js");
-    const rows = await this.db.select().from(pgOperations).orderBy(asc(pgOperations.sequenceNumber));
+    const rows = await this.db.select().from(pgOperations).orderBy(asc(pgOperations.deliverySeq));
     const operations2 = rows.map((row) => this.deserializeOperation(row));
     return buildServerBackup(this.nodeId, operations2, this.versionVector);
   }
@@ -814,6 +949,7 @@ var PostgresServerStore = class {
         const result = await this.applyRemoteOperation(op);
         if (result === "applied") restored++;
       }
+      this.sequenceCounter = null;
       return { operationsRestored: restored, success: true };
     }
     const now = Date.now();
@@ -823,20 +959,49 @@ var PostgresServerStore = class {
       for (const [nid, seq] of versionVector) {
         await tx.insert(pgSyncState).values({ nodeId: nid, maxSequenceNumber: seq, lastSeenAt: now }).onConflictDoNothing({ target: pgSyncState.nodeId });
       }
+      let deliverySeq = 0;
       for (const op of operations2) {
-        const row = this.serializeOperation(op, now);
+        deliverySeq += 1;
+        const row = this.serializeOperation(op, now, deliverySeq);
         await tx.insert(pgOperations).values(row).onConflictDoNothing({ target: pgOperations.id });
       }
+      await tx.execute(
+        sql`INSERT INTO delivery_counter (id, value) VALUES (1, ${deliverySeq})
+					ON CONFLICT (id) DO UPDATE SET value = ${deliverySeq}`
+      );
     });
     this.versionVector.clear();
     for (const [nid, seq] of versionVector) {
       this.versionVector.set(nid, seq);
     }
+    this.sequenceCounter = null;
     return { operationsRestored: operations2.length, success: true };
   }
   // ---------------------------------------------------------------------------
   // Materialization internals
   // ---------------------------------------------------------------------------
+  /**
+   * The HLC timestamp of the most recent operation on a record, by total order
+   * (wallTime, logical, nodeId), or null when the record has no operations. Used
+   * by {@link applyConditional} to advance its clock past the record's latest
+   * write so newly built operations sort strictly after it.
+   */
+  async latestOperationTimestamp(txOrDb, collection, recordId) {
+    const rows = await txOrDb.select({
+      wallTime: pgOperations.wallTime,
+      logical: pgOperations.logical,
+      timestampNodeId: pgOperations.timestampNodeId
+    }).from(pgOperations).where(and(eq(pgOperations.collection, collection), eq(pgOperations.recordId, recordId))).orderBy(
+      desc(pgOperations.wallTime),
+      desc(pgOperations.logical),
+      desc(pgOperations.timestampNodeId)
+    ).limit(1);
+    const row = rows[0];
+    if (!row) {
+      return null;
+    }
+    return { wallTime: row.wallTime, logical: row.logical, nodeId: row.timestampNodeId };
+  }
   /**
    * Rebuild a single record in the materialized collection table by replaying
    * all operations for that record.
@@ -847,15 +1012,17 @@ var PostgresServerStore = class {
     const ops = await txOrDb.select({
       type: pgOperations.type,
       data: pgOperations.data,
+      atomicOps: pgOperations.atomicOps,
       wallTime: pgOperations.wallTime
     }).from(pgOperations).where(and(eq(pgOperations.collection, collection), eq(pgOperations.recordId, recordId))).orderBy(
       asc(pgOperations.wallTime),
       asc(pgOperations.logical),
-      asc(pgOperations.sequenceNumber)
+      asc(pgOperations.timestampNodeId)
     );
     const parsedOps = ops.map((op) => ({
       type: op.type,
-      data: op.data !== null ? JSON.parse(op.data) : null
+      data: op.data !== null ? JSON.parse(op.data) : null,
+      atomicOps: op.atomicOps != null ? JSON.parse(op.atomicOps) : null
     }));
     const recordData = replayOperationsForRecord(parsedOps);
     const fieldNames = Object.keys(collectionDef.fields);
@@ -924,11 +1091,12 @@ var PostgresServerStore = class {
       recordId: pgOperations.recordId,
       type: pgOperations.type,
       data: pgOperations.data,
+      atomicOps: pgOperations.atomicOps,
       wallTime: pgOperations.wallTime
     }).from(pgOperations).where(eq(pgOperations.collection, collectionName)).orderBy(
       asc(pgOperations.wallTime),
       asc(pgOperations.logical),
-      asc(pgOperations.sequenceNumber)
+      asc(pgOperations.timestampNodeId)
     );
     if (allOps.length === 0) return;
     const grouped = /* @__PURE__ */ new Map();
@@ -944,7 +1112,8 @@ var PostgresServerStore = class {
     for (const [recordId, recordOps] of grouped) {
       const parsedOps = recordOps.map((op) => ({
         type: op.type,
-        data: op.data !== null ? JSON.parse(op.data) : null
+        data: op.data !== null ? JSON.parse(op.data) : null,
+        atomicOps: op.atomicOps != null ? JSON.parse(op.atomicOps) : null
       }));
       const recordData = replayOperationsForRecord(parsedOps);
       if (recordData) {
@@ -1069,44 +1238,92 @@ var PostgresServerStore = class {
     }
   }
   async ensureTables() {
-    await this.db.execute(sql`
-			CREATE TABLE IF NOT EXISTS operations (
-				id TEXT PRIMARY KEY,
-				node_id TEXT NOT NULL,
-				type TEXT NOT NULL,
-				collection TEXT NOT NULL,
-				record_id TEXT NOT NULL,
-				data TEXT,
-				previous_data TEXT,
-				wall_time BIGINT NOT NULL,
-				logical INTEGER NOT NULL,
-				timestamp_node_id TEXT NOT NULL,
-				sequence_number INTEGER NOT NULL,
-				causal_deps TEXT NOT NULL DEFAULT '[]',
-				schema_version INTEGER NOT NULL,
-				received_at BIGINT NOT NULL
-			)
-		`);
-    await this.db.execute(
-      sql`CREATE INDEX IF NOT EXISTS idx_node_seq ON operations (node_id, sequence_number)`
-    );
-    await this.db.execute(sql`CREATE INDEX IF NOT EXISTS idx_collection ON operations (collection)`);
-    await this.db.execute(sql`CREATE INDEX IF NOT EXISTS idx_received ON operations (received_at)`);
-    await this.db.execute(
-      sql`CREATE INDEX IF NOT EXISTS idx_collection_record ON operations (collection, record_id)`
+    await this.db.transaction(async (tx) => {
+      await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtextextended('kora:ensure-tables', 0))`);
+      await tx.execute(sql`
+				CREATE TABLE IF NOT EXISTS operations (
+					id TEXT PRIMARY KEY,
+					node_id TEXT NOT NULL,
+					type TEXT NOT NULL,
+					collection TEXT NOT NULL,
+					record_id TEXT NOT NULL,
+					data TEXT,
+					previous_data TEXT,
+					atomic_ops TEXT,
+					wall_time BIGINT NOT NULL,
+					logical INTEGER NOT NULL,
+					timestamp_node_id TEXT NOT NULL,
+					sequence_number INTEGER NOT NULL,
+					causal_deps TEXT NOT NULL DEFAULT '[]',
+					schema_version INTEGER NOT NULL,
+					received_at BIGINT NOT NULL
+				)
+			`);
+      await tx.execute(sql`ALTER TABLE operations ADD COLUMN IF NOT EXISTS atomic_ops TEXT`);
+      await tx.execute(sql`ALTER TABLE operations ADD COLUMN IF NOT EXISTS delivery_seq BIGINT`);
+      await tx.execute(
+        sql`CREATE INDEX IF NOT EXISTS idx_node_seq ON operations (node_id, sequence_number)`
+      );
+      await tx.execute(sql`CREATE INDEX IF NOT EXISTS idx_collection ON operations (collection)`);
+      await tx.execute(sql`CREATE INDEX IF NOT EXISTS idx_received ON operations (received_at)`);
+      await tx.execute(
+        sql`CREATE INDEX IF NOT EXISTS idx_delivery_seq ON operations (delivery_seq)`
+      );
+      await tx.execute(
+        sql`CREATE INDEX IF NOT EXISTS idx_collection_record ON operations (collection, record_id)`
+      );
+      await tx.execute(sql`
+				CREATE TABLE IF NOT EXISTS sync_state (
+					node_id TEXT PRIMARY KEY,
+					max_sequence_number INTEGER NOT NULL,
+					last_seen_at BIGINT NOT NULL
+				)
+			`);
+      await tx.execute(sql`
+				CREATE TABLE IF NOT EXISTS delivery_counter (
+					id INTEGER PRIMARY KEY,
+					value BIGINT NOT NULL
+				)
+			`);
+      await tx.execute(sql`
+				WITH ordered AS (
+					SELECT id, ROW_NUMBER() OVER (
+						ORDER BY received_at ASC, sequence_number ASC, id ASC
+					) + COALESCE((SELECT MAX(delivery_seq) FROM operations), 0) AS rn
+					FROM operations WHERE delivery_seq IS NULL
+				)
+				UPDATE operations o SET delivery_seq = ordered.rn
+				FROM ordered WHERE o.id = ordered.id
+			`);
+      await tx.execute(sql`
+				INSERT INTO delivery_counter (id, value)
+				VALUES (1, COALESCE((SELECT MAX(delivery_seq) FROM operations), 0))
+				ON CONFLICT (id) DO UPDATE
+					SET value = GREATEST(delivery_counter.value, EXCLUDED.value)
+			`);
+    });
+  }
+  /**
+   * Reserve the next delivery sequence inside an open append transaction. The
+   * `UPDATE ... RETURNING` locks the counter row until this transaction commits,
+   * serializing assignment into commit order (see the counter table comment).
+   */
+  async nextDeliverySeq(tx) {
+    const rows = await tx.execute(
+      sql`UPDATE delivery_counter SET value = value + 1 WHERE id = 1 RETURNING value`
     );
-    await this.db.execute(sql`
-			CREATE TABLE IF NOT EXISTS sync_state (
-				node_id TEXT PRIMARY KEY,
-				max_sequence_number INTEGER NOT NULL,
-				last_seen_at BIGINT NOT NULL
-			)
-		`);
+    const value = rows[0]?.value;
+    if (value === void 0 || value === null) {
+      throw new Error(
+        "delivery_counter row (id=1) is missing; the operations log cannot assign delivery sequences"
+      );
+    }
+    return Number(value);
   }
   // ---------------------------------------------------------------------------
   // Operation serialization
   // ---------------------------------------------------------------------------
-  serializeOperation(op, receivedAt) {
+  serializeOperation(op, receivedAt, deliverySeq) {
     return {
       id: op.id,
       nodeId: op.nodeId,
@@ -1115,16 +1332,19 @@ var PostgresServerStore = class {
       recordId: op.recordId,
       data: op.data !== null ? JSON.stringify(op.data) : null,
       previousData: op.previousData !== null ? JSON.stringify(op.previousData) : null,
+      atomicOps: op.atomicOps && Object.keys(op.atomicOps).length > 0 ? JSON.stringify(op.atomicOps) : null,
       wallTime: op.timestamp.wallTime,
       logical: op.timestamp.logical,
       timestampNodeId: op.timestamp.nodeId,
       sequenceNumber: op.sequenceNumber,
       causalDeps: JSON.stringify(op.causalDeps),
       schemaVersion: op.schemaVersion,
-      receivedAt
+      receivedAt,
+      deliverySeq
     };
   }
   deserializeOperation(row) {
+    const atomicOps = row.atomicOps != null ? JSON.parse(row.atomicOps) : void 0;
     return {
       id: row.id,
       nodeId: row.nodeId,
@@ -1140,7 +1360,8 @@ var PostgresServerStore = class {
       },
       sequenceNumber: row.sequenceNumber,
       causalDeps: JSON.parse(row.causalDeps),
-      schemaVersion: row.schemaVersion
+      schemaVersion: row.schemaVersion,
+      ...atomicOps ? { atomicOps } : {}
     };
   }
   // ---------------------------------------------------------------------------
@@ -1192,7 +1413,7 @@ async function loadPostgresDeps() {
 // src/store/sqlite-server-store.ts
 import { createRequire } from "module";
 import { generateUUIDv7 as generateUUIDv73, quoteIdent as quoteIdent3 } from "@korajs/core";
-import { and as and2, asc as asc2, between as between2, count as count2, eq as eq2, sql as sql2 } from "drizzle-orm";
+import { and as and2, asc as asc2, between as between2, count as count2, eq as eq2, gt as gt2, sql as sql2 } from "drizzle-orm";
 
 // src/store/drizzle-schema.ts
 import { index as index2, integer as integer2, sqliteTable, text as text2 } from "drizzle-orm/sqlite-core";
@@ -1208,6 +1429,8 @@ var operations = sqliteTable(
     // JSON-serialized, null for deletes
     previousData: text2("previous_data"),
     // JSON-serialized, null for insert/delete
+    atomicOps: text2("atomic_ops"),
+    // JSON-serialized Record<field, AtomicOp>, null when none
     wallTime: integer2("wall_time").notNull(),
     logical: integer2("logical").notNull(),
     timestampNodeId: text2("timestamp_node_id").notNull(),
@@ -1215,12 +1438,17 @@ var operations = sqliteTable(
     causalDeps: text2("causal_deps").notNull().default("[]"),
     // JSON array of op IDs
     schemaVersion: integer2("schema_version").notNull(),
-    receivedAt: integer2("received_at").notNull()
+    receivedAt: integer2("received_at").notNull(),
+    // Server-assigned monotonic delivery sequence, ordered by commit. Drives the
+    // gap-free server->client delivery watermark. Nullable only for rows written
+    // before the column existed; those are backfilled on startup.
+    deliverySeq: integer2("delivery_seq")
   },
   (table) => ({
     nodeSeqIdx: index2("idx_node_seq").on(table.nodeId, table.sequenceNumber),
     collectionIdx: index2("idx_collection").on(table.collection),
-    receivedIdx: index2("idx_received").on(table.receivedAt)
+    receivedIdx: index2("idx_received").on(table.receivedAt),
+    deliveryIdx: index2("idx_delivery_seq").on(table.deliverySeq)
   })
 );
 var syncState = sqliteTable("sync_state", {
@@ -1236,6 +1464,12 @@ var SqliteServerStore = class {
   db;
   schema = null;
   closed = false;
+  /**
+   * Next delivery sequence to assign. Single-writer (better-sqlite3 is synchronous),
+   * so a plain in-memory counter, seeded from MAX(delivery_seq) at startup, gives
+   * commit-order delivery sequence. Assigned inside the append transaction.
+   */
+  deliverySeqCounter = 0;
   constructor(db, nodeId) {
     this.db = db;
     this.nodeId = nodeId ?? generateUUIDv73();
@@ -1281,12 +1515,16 @@ var SqliteServerStore = class {
   async applyRemoteOperation(op) {
     this.assertOpen();
     const now = Date.now();
-    const row = this.serializeOperation(op, now);
     const result = this.db.transaction((tx) => {
-      const insertResult = tx.insert(operations).values(row).onConflictDoNothing({ target: operations.id }).run();
-      if (insertResult.changes === 0) {
+      const existing = tx.all(
+        sql2`SELECT id FROM operations WHERE id = ${op.id} LIMIT 1`
+      );
+      if (existing.length > 0) {
         return "duplicate";
       }
+      this.deliverySeqCounter += 1;
+      const row = this.serializeOperation(op, now, this.deliverySeqCounter);
+      tx.insert(operations).values(row).run();
       tx.insert(syncState).values({
         nodeId: op.nodeId,
         maxSequenceNumber: op.sequenceNumber,
@@ -1315,6 +1553,21 @@ var SqliteServerStore = class {
     const result = this.db.select({ value: count2() }).from(operations).all();
     return result[0]?.value ?? 0;
   }
+  async getMaxDeliverySequence() {
+    this.assertOpen();
+    const rows = this.db.all(
+      sql2`SELECT MAX(delivery_seq) AS m FROM operations`
+    );
+    return rows[0]?.m ?? 0;
+  }
+  async getOperationsAfterDelivery(afterDeliverySequence, limit) {
+    this.assertOpen();
+    const rows = this.db.select().from(operations).where(gt2(operations.deliverySeq, afterDeliverySequence)).orderBy(asc2(operations.deliverySeq)).limit(limit).all();
+    return rows.map((row) => ({
+      operation: this.deserializeOperation(row),
+      deliverySequence: row.deliverySeq ?? 0
+    }));
+  }
   async materializeCollection(collection) {
     this.assertOpen();
     if (this.schema?.collections[collection]) {
@@ -1372,7 +1625,7 @@ var SqliteServerStore = class {
   async exportBackup() {
     this.assertOpen();
     const { buildServerBackup } = await import("./server-backup-MOICK6MI.js");
-    const rows = this.db.select().from(operations).all();
+    const rows = this.db.select().from(operations).orderBy(asc2(operations.deliverySeq)).all();
     const deserialized = rows.map((row) => this.deserializeOperation(row));
     const vv = this.getVersionVector();
     return buildServerBackup(this.nodeId, deserialized, vv);
@@ -1395,10 +1648,13 @@ var SqliteServerStore = class {
       for (const [nid, seq] of versionVector) {
         tx.insert(syncState).values({ nodeId: nid, maxSequenceNumber: seq, lastSeenAt: Date.now() }).run();
       }
+      let deliverySeq = 0;
       for (const op of ops) {
-        const row = this.serializeOperation(op, Date.now());
+        deliverySeq += 1;
+        const row = this.serializeOperation(op, Date.now(), deliverySeq);
         tx.insert(operations).values(row).run();
       }
+      this.deliverySeqCounter = deliverySeq;
     });
     return { operationsRestored: ops.length, success: true };
   }
@@ -1416,11 +1672,13 @@ var SqliteServerStore = class {
     const ops = txOrDb.select({
       type: operations.type,
       data: operations.data,
+      atomicOps: operations.atomicOps,
       wallTime: operations.wallTime
-    }).from(operations).where(and2(eq2(operations.collection, collection), eq2(operations.recordId, recordId))).orderBy(asc2(operations.wallTime), asc2(operations.logical), asc2(operations.sequenceNumber)).all();
+    }).from(operations).where(and2(eq2(operations.collection, collection), eq2(operations.recordId, recordId))).orderBy(asc2(operations.wallTime), asc2(operations.logical), asc2(operations.timestampNodeId)).all();
     const parsedOps = ops.map((op) => ({
       type: op.type,
-      data: op.data !== null ? JSON.parse(op.data) : null
+      data: op.data !== null ? JSON.parse(op.data) : null,
+      atomicOps: op.atomicOps != null ? JSON.parse(op.atomicOps) : null
     }));
     const recordData = replayOperationsForRecord(parsedOps);
     const fieldNames = Object.keys(collectionDef.fields);
@@ -1492,8 +1750,9 @@ var SqliteServerStore = class {
       recordId: operations.recordId,
       type: operations.type,
       data: operations.data,
+      atomicOps: operations.atomicOps,
       wallTime: operations.wallTime
-    }).from(operations).where(eq2(operations.collection, collectionName)).orderBy(asc2(operations.wallTime), asc2(operations.logical), asc2(operations.sequenceNumber)).all();
+    }).from(operations).where(eq2(operations.collection, collectionName)).orderBy(asc2(operations.wallTime), asc2(operations.logical), asc2(operations.timestampNodeId)).all();
     if (allOps.length === 0) return;
     const grouped = /* @__PURE__ */ new Map();
     for (const op of allOps) {
@@ -1509,7 +1768,8 @@ var SqliteServerStore = class {
       for (const [recordId, recordOps] of grouped) {
         const parsedOps = recordOps.map((op) => ({
           type: op.type,
-          data: op.data !== null ? JSON.parse(op.data) : null
+          data: op.data !== null ? JSON.parse(op.data) : null,
+          atomicOps: op.atomicOps != null ? JSON.parse(op.atomicOps) : null
         }));
         const recordData = replayOperationsForRecord(parsedOps);
         if (recordData) {
@@ -1633,6 +1893,7 @@ var SqliteServerStore = class {
 				record_id TEXT NOT NULL,
 				data TEXT,
 				previous_data TEXT,
+				atomic_ops TEXT,
 				wall_time INTEGER NOT NULL,
 				logical INTEGER NOT NULL,
 				timestamp_node_id TEXT NOT NULL,
@@ -1642,9 +1903,30 @@ var SqliteServerStore = class {
 				received_at INTEGER NOT NULL
 			)
 		`);
+    try {
+      this.db.run(sql2`ALTER TABLE operations ADD COLUMN atomic_ops TEXT`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : "";
+      const causeMsg = e instanceof Error && e.cause instanceof Error ? e.cause.message : "";
+      if (!msg.includes("duplicate column") && !causeMsg.includes("duplicate column")) {
+        throw e;
+      }
+    }
+    try {
+      this.db.run(sql2`ALTER TABLE operations ADD COLUMN delivery_seq INTEGER`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : "";
+      const causeMsg = e instanceof Error && e.cause instanceof Error ? e.cause.message : "";
+      if (!msg.includes("duplicate column") && !causeMsg.includes("duplicate column")) {
+        throw e;
+      }
+    }
     this.db.run(sql2`
 			CREATE INDEX IF NOT EXISTS idx_node_seq ON operations (node_id, sequence_number)
 		`);
+    this.db.run(sql2`
+			CREATE INDEX IF NOT EXISTS idx_delivery_seq ON operations (delivery_seq)
+		`);
     this.db.run(sql2`
 			CREATE INDEX IF NOT EXISTS idx_collection ON operations (collection)
 		`);
@@ -1661,11 +1943,34 @@ var SqliteServerStore = class {
 				last_seen_at INTEGER NOT NULL
 			)
 		`);
+    this.backfillDeliverySequence();
+  }
+  /**
+   * Assign delivery sequences to any operations written before the column existed,
+   * then seed the in-memory counter from the current max. Ordered by
+   * (received_at, sequence_number, id) so the backfill is deterministic and stable
+   * across restarts. A one-time migration: after it runs, all rows have a value.
+   */
+  backfillDeliverySequence() {
+    this.db.transaction((tx) => {
+      const maxRow = tx.all(
+        sql2`SELECT MAX(delivery_seq) AS m FROM operations`
+      );
+      let next = maxRow[0]?.m ?? 0;
+      const nullRows = tx.all(
+        sql2`SELECT id FROM operations WHERE delivery_seq IS NULL ORDER BY received_at ASC, sequence_number ASC, id ASC`
+      );
+      for (const row of nullRows) {
+        next += 1;
+        tx.run(sql2`UPDATE operations SET delivery_seq = ${next} WHERE id = ${row.id}`);
+      }
+      this.deliverySeqCounter = next;
+    });
   }
   // ---------------------------------------------------------------------------
   // Operation serialization
   // ---------------------------------------------------------------------------
-  serializeOperation(op, receivedAt) {
+  serializeOperation(op, receivedAt, deliverySeq) {
     return {
       id: op.id,
       nodeId: op.nodeId,
@@ -1674,16 +1979,19 @@ var SqliteServerStore = class {
       recordId: op.recordId,
       data: op.data !== null ? JSON.stringify(op.data) : null,
       previousData: op.previousData !== null ? JSON.stringify(op.previousData) : null,
+      atomicOps: op.atomicOps && Object.keys(op.atomicOps).length > 0 ? JSON.stringify(op.atomicOps) : null,
       wallTime: op.timestamp.wallTime,
       logical: op.timestamp.logical,
       timestampNodeId: op.timestamp.nodeId,
       sequenceNumber: op.sequenceNumber,
       causalDeps: JSON.stringify(op.causalDeps),
       schemaVersion: op.schemaVersion,
-      receivedAt
+      receivedAt,
+      deliverySeq
     };
   }
   deserializeOperation(row) {
+    const atomicOps = row.atomicOps != null ? JSON.parse(row.atomicOps) : void 0;
     return {
       id: row.id,
       nodeId: row.nodeId,
@@ -1699,7 +2007,8 @@ var SqliteServerStore = class {
       },
       sequenceNumber: row.sequenceNumber,
       causalDeps: JSON.parse(row.causalDeps),
-      schemaVersion: row.schemaVersion
+      schemaVersion: row.schemaVersion,
+      ...atomicOps ? { atomicOps } : {}
     };
   }
   // ---------------------------------------------------------------------------
@@ -1981,10 +2290,10 @@ function createServerReferentialContext(store) {
 }
 
 // src/apply/server-side-effect-operation.ts
-import { HybridLogicalClock, createOperation } from "@korajs/core";
+import { HybridLogicalClock as HybridLogicalClock2, createOperation } from "@korajs/core";
 async function createServerSideEffectOperation(store, parentOp, effect, schemaVersion, sequenceNumber) {
   const nodeId = store.getNodeId();
-  const clock = new HybridLogicalClock(nodeId);
+  const clock = new HybridLogicalClock2(nodeId);
   clock.receive(parentOp.timestamp);
   return createOperation(
     {
@@ -2002,6 +2311,9 @@ async function createServerSideEffectOperation(store, parentOp, effect, schemaVe
   );
 }
 function nextServerSequenceNumber(store) {
+  if (store.reserveSequenceNumber) {
+    return store.reserveSequenceNumber();
+  }
   const nodeId = store.getNodeId();
   const current = store.getVersionVector().get(nodeId) ?? 0;
   return current + 1;
@@ -2043,16 +2355,14 @@ async function applyServerOperation(store, op, relationLookup) {
       return { result: primaryResult, appliedOperations: [] };
     }
     const appliedOperations = [op];
-    let serverSeq = nextServerSequenceNumber(store);
     for (const effect of referential.sideEffectOps) {
       const sideOp = await createServerSideEffectOperation(
         store,
         op,
         effect,
         op.schemaVersion,
-        serverSeq
+        nextServerSequenceNumber(store)
       );
-      serverSeq += 1;
       const sideResult = await store.applyRemoteOperation(sideOp);
       if (sideResult === "applied") {
         appliedOperations.push(sideOp);
@@ -2110,11 +2420,11 @@ function mergeScopeMaps(base, overlay, source) {
 }
 
 // src/scopes/server-scope-filter.ts
-function operationMatchesScopes(op, scopes) {
+function operationMatchesScopes(op, scopes, fullRecord) {
   if (!scopes) return true;
   const collectionScope = scopes[op.collection];
   if (!collectionScope) return false;
-  const snapshot = buildSnapshot(op);
+  const snapshot = buildSnapshot(op, fullRecord);
   if (!snapshot) return false;
   for (const [field, expected] of Object.entries(collectionScope)) {
     if (snapshot[field] !== expected) {
@@ -2123,11 +2433,19 @@ function operationMatchesScopes(op, scopes) {
   }
   return true;
 }
-function buildSnapshot(op) {
+function missingScopeFields(op, scopes) {
+  if (!scopes) return [];
+  const collectionScope = scopes[op.collection];
+  if (!collectionScope) return [];
+  const snapshot = buildSnapshot(op);
+  return Object.keys(collectionScope).filter((field) => !snapshot || !(field in snapshot));
+}
+function buildSnapshot(op, fullRecord) {
   const previous = asRecord(op.previousData);
   const next = asRecord(op.data);
-  if (!previous && !next) return null;
+  if (!previous && !next && !fullRecord) return null;
   return {
+    ...fullRecord ?? {},
     ...previous ?? {},
     ...next ?? {}
   };
@@ -2218,18 +2536,48 @@ function warnIfMultiTenantWithoutScopes(auth, resolvedScopes, schema) {
     "[kora] An authenticated session resolved to no sync scopes, so every user will sync every other user's data. Return per-user sync scopes from your auth provider (for example KoraAuthProvider's resolveScopes) to isolate tenants. Note: declaring sync rules in your schema is not enough on its own \u2014 the per-user values come from the auth provider. (This warning is expected for single-tenant apps where all authenticated users are meant to share the same data.)"
   );
 }
-var ClientSession = class {
+var ClientSession = class _ClientSession {
   state = "connected";
   clientNodeId = null;
   authContext = null;
   syncQuerySubsets = [];
   resumeDeltaCursor = null;
+  /**
+   * The delivery watermark the client reported at handshake, or null when the client
+   * does not use the delivery watermark (old client, or no watermark yet). When set,
+   * the server drives the gap-free server->client stream from delivery sequences
+   * instead of the version-vector delta.
+   */
+  clientDeliveryWatermark = null;
+  /**
+   * The highest delivery sequence this client has ACKNOWLEDGED (its confirmed
+   * watermark, as reported in acks). Incremental streaming pushes resume from here, not
+   * from the highest sequence sent, so a dropped or unapplied batch is always
+   * re-included by the next push (which re-scans from the acknowledged position). This
+   * is what makes streaming recovery independent of any bounded retransmit buffer: there
+   * is no sent-but-unacked window that a buffer eviction could strand. Seeded from the
+   * client's reported watermark at handshake.
+   */
+  lastAckedDeliverySeq = 0;
+  /** Serializes incremental delivery pushes so their batches never interleave. */
+  deliveryPushChain = Promise.resolve();
+  /**
+   * Relay batches sent to this client but not yet acknowledged, keyed by messageId.
+   * The client acks every operation-batch it applies; on ack the entry is cleared.
+   * {@link retransmitPendingRelays} re-sends anything still unacked, so a relay
+   * dropped by a lossy transport is redelivered instead of leaving the client with a
+   * permanent version-vector gap (a lost operation) that delta sync cannot recover.
+   * Bounded so a silent client cannot grow it without limit.
+   */
+  pendingRelays = /* @__PURE__ */ new Map();
+  static MAX_PENDING_RELAYS = 1e3;
   sessionId;
   transport;
   store;
   auth;
   serializer;
   emitter;
+  logger;
   batchSize;
   schemaVersion;
   supportedSchemaVersions;
@@ -2240,6 +2588,8 @@ var ClientSession = class {
   onBlobChunkResponse;
   persistBlobChunk;
   onClose;
+  onOrphanedRelays;
+  takeOrphanedRelays;
   maxOperationBytes;
   maxOpsPerMinute;
   rateLimiter;
@@ -2252,6 +2602,7 @@ var ClientSession = class {
     this.auth = options.auth ?? null;
     this.serializer = options.serializer ?? new NegotiatedMessageSerializer("json");
     this.emitter = options.emitter ?? null;
+    this.logger = options.logger ?? null;
     this.batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
     this.schemaVersion = options.schemaVersion ?? DEFAULT_SCHEMA_VERSION;
     const supported = options.supportedSchemaVersions;
@@ -2266,6 +2617,8 @@ var ClientSession = class {
     this.onBlobChunkResponse = options.onBlobChunkResponse ?? null;
     this.persistBlobChunk = options.persistBlobChunk ?? null;
     this.onClose = options.onClose ?? null;
+    this.onOrphanedRelays = options.onOrphanedRelays ?? null;
+    this.takeOrphanedRelays = options.takeOrphanedRelays ?? null;
     this.maxOperationBytes = options.maxOperationBytes ?? DEFAULT_MAX_OPERATION_BYTES;
     this.maxOpsPerMinute = options.maxOpsPerMinute ?? DEFAULT_MAX_OPS_PER_MINUTE;
     this.rateLimiter = new SessionRateLimiter(this.maxOpsPerMinute);
@@ -2290,9 +2643,40 @@ var ClientSession = class {
    */
   relayOperations(operations2) {
     if (this.state !== "streaming" || !this.transport.isConnected()) return;
+    if (this.clientDeliveryWatermark !== null) {
+      this.pushDeliveryStream();
+      return;
+    }
     if (operations2.length === 0) return;
-    const visibleOperations = operations2.filter((op) => this.operationVisibleToClient(op));
+    void this.relayVisibleOperations(operations2);
+  }
+  /**
+   * Push newly-available in-scope operations to a delivery-watermark client, resuming
+   * from the highest delivery sequence already sent. Pushes are serialized so their
+   * batches never interleave (which would break the base/max chain).
+   */
+  pushDeliveryStream() {
+    this.deliveryPushChain = this.deliveryPushChain.then(async () => {
+      if (this.state !== "streaming" || !this.transport.isConnected()) return;
+      try {
+        await this.sendDeliveryStream(
+          this.lastAckedDeliverySeq,
+          false,
+          this.clientNodeId ?? void 0
+        );
+      } catch {
+      }
+    });
+  }
+  async relayVisibleOperations(operations2) {
+    const visibleOperations = [];
+    for (const op of operations2) {
+      if (await this.operationVisibleToClient(op)) {
+        visibleOperations.push(op);
+      }
+    }
     if (visibleOperations.length === 0) return;
+    if (this.state !== "streaming" || !this.transport.isConnected()) return;
     const serializedOps = visibleOperations.map((op) => this.serializer.encodeOperation(op));
     const msg = {
       type: "operation-batch",
@@ -2301,14 +2685,62 @@ var ClientSession = class {
       isFinal: true,
       batchIndex: 0
     };
+    this.trackPendingRelay(msg, visibleOperations);
     this.sendToClient(msg);
   }
+  /** Record a relay batch as awaiting acknowledgment, evicting the oldest if full. */
+  trackPendingRelay(msg, ops) {
+    if (this.pendingRelays.size >= _ClientSession.MAX_PENDING_RELAYS) {
+      const oldest = this.pendingRelays.keys().next().value;
+      if (oldest !== void 0) {
+        this.pendingRelays.delete(oldest);
+      }
+    }
+    this.pendingRelays.set(msg.messageId, { message: msg, ops, sentAtMs: Date.now() });
+  }
+  /**
+   * Retransmit relay batches this client has not acknowledged within `staleMs`.
+   * Called on a periodic tick by the server (and directly by tests). Redelivering an
+   * already-applied op is harmless: the client dedups by content-addressed id.
+   */
+  retransmitPendingRelays(staleMs = 0) {
+    if (this.state !== "streaming" || !this.transport.isConnected()) return;
+    if (this.clientDeliveryWatermark !== null) {
+      this.pushDeliveryStream();
+      return;
+    }
+    if (this.pendingRelays.size === 0) return;
+    const cutoff = Date.now() - staleMs;
+    for (const { message, sentAtMs } of this.pendingRelays.values()) {
+      if (sentAtMs <= cutoff) {
+        this.sendToClient(message);
+      }
+    }
+  }
   /**
    * Close this session.
    */
+  /**
+   * Hand any unacknowledged relays to the server so they survive this session and are
+   * redelivered when this client reconnects (per-node buffer), then clear them. Called
+   * from every session-teardown path (explicit close and transport close).
+   */
+  flushOrphanedRelays() {
+    if (this.onOrphanedRelays && this.clientNodeId && this.pendingRelays.size > 0) {
+      const ops = [];
+      for (const entry of this.pendingRelays.values()) {
+        ops.push(...entry.ops);
+      }
+      if (ops.length > 0) {
+        this.onOrphanedRelays(this.clientNodeId, ops);
+      }
+    }
+    this.pendingRelays.clear();
+  }
   close(reason) {
     if (this.state === "closed") return;
     this.state = "closed";
+    this.flushOrphanedRelays();
     if (this.transport.isConnected()) {
       this.transport.close(1e3, reason ?? "session closed");
     }
@@ -2363,6 +2795,10 @@ var ClientSession = class {
         await this.handleOperationBatch(message);
         break;
       case "acknowledgment":
+        this.pendingRelays.delete(message.acknowledgedMessageId);
+        if (message.deliverySequence !== void 0) {
+          this.lastAckedDeliverySeq = Math.max(this.lastAckedDeliverySeq, message.deliverySequence);
+        }
         break;
       case "error":
         break;
@@ -2401,6 +2837,18 @@ var ClientSession = class {
   }
   handleMessageFailure(error) {
     const reason = error instanceof Error ? error.message : "Message handling failed";
+    this.logger?.log({
+      timestamp: Date.now(),
+      level: "error",
+      event: "session.message_failed",
+      sessionId: this.sessionId,
+      nodeId: this.clientNodeId ?? void 0,
+      error: reason,
+      details: {
+        state: this.state,
+        errorName: error instanceof Error ? error.name : typeof error
+      }
+    });
     this.sendError("SYNC_ERROR", reason, true);
     this.close(reason);
   }
@@ -2439,6 +2887,15 @@ var ClientSession = class {
       this.syncQuerySubsets = [];
     }
     this.resumeDeltaCursor = msg.deltaCursor ? decodeDeltaCursor(msg.deltaCursor) : null;
+    this.clientDeliveryWatermark = msg.lastDeliverySequence ?? null;
+    const clientUsesWatermark = this.clientDeliveryWatermark !== null;
+    let serverMaxDelivery = 0;
+    if (clientUsesWatermark) {
+      serverMaxDelivery = await this.store.getMaxDeliverySequence();
+      if (this.clientDeliveryWatermark !== null && this.clientDeliveryWatermark > serverMaxDelivery) {
+        this.clientDeliveryWatermark = 0;
+      }
+    }
     const serverVector = this.store.getVersionVector();
     const selectedWireFormat = selectWireFormat(msg.supportedWireFormats);
     this.setSerializerWireFormat(selectedWireFormat);
@@ -2469,6 +2926,10 @@ var ClientSession = class {
       accepted: true,
       selectedWireFormat,
       serverTime: Date.now(),
+      // The server's highest delivery sequence, so a client whose persisted watermark
+      // is ahead of it (server rolled back) can reset to a full resync. Sent only to
+      // watermark-using clients.
+      ...clientUsesWatermark ? { serverMaxDeliverySequence: serverMaxDelivery } : {},
       // Advertise central blob storage so the client uploads the bytes behind
       // its blob fields, keeping them available after the author goes offline.
       ...this.persistBlobChunk ? { blobStorageEnabled: true } : {},
@@ -2479,16 +2940,28 @@ var ClientSession = class {
     this.sendToClient(response);
     this.emitter?.emit({ type: "sync:connected", nodeId: msg.nodeId });
     this.state = "syncing";
-    const clientVector = wireToVersionVector(msg.versionVector);
-    await this.sendDelta(clientVector);
+    if (this.clientDeliveryWatermark !== null) {
+      this.lastAckedDeliverySeq = this.clientDeliveryWatermark;
+      const excludeOwn = this.clientDeliveryWatermark > 0 ? this.clientNodeId ?? void 0 : void 0;
+      await this.sendDeliveryStream(this.clientDeliveryWatermark, true, excludeOwn);
+    } else {
+      const clientVector = wireToVersionVector(msg.versionVector);
+      await this.sendDelta(clientVector);
+    }
     this.state = "streaming";
+    if (this.takeOrphanedRelays && this.clientNodeId) {
+      const buffered = this.takeOrphanedRelays(this.clientNodeId);
+      if (buffered.length > 0) {
+        this.relayOperations(buffered);
+      }
+    }
   }
   async handleOperationBatch(msg) {
     const operations2 = msg.operations.map((s) => this.serializer.decodeOperation(s));
     const applied = [];
     const rejected = [];
     for (const op of operations2) {
-      if (!this.operationVisibleToClient(op)) {
+      if (!await this.operationVisibleToClient(op)) {
         rejected.push(op);
         continue;
       }
@@ -2542,20 +3015,17 @@ var ClientSession = class {
           continue;
         }
       }
-      try {
-        const applyResult = await applyServerOperation(this.store, op);
-        if (applyResult.rejection) {
-          this.sendError(
-            applyResult.rejection.code,
-            applyResult.rejection.message,
-            applyResult.rejection.retriable
-          );
-          continue;
-        }
-        if (applyResult.result === "applied") {
-          applied.push(...applyResult.appliedOperations);
-        }
-      } catch {
+      const applyResult = await applyServerOperation(this.store, op);
+      if (applyResult.rejection) {
+        this.sendError(
+          applyResult.rejection.code,
+          applyResult.rejection.message,
+          applyResult.rejection.retriable
+        );
+        continue;
+      }
+      if (applyResult.result === "applied") {
+        applied.push(...applyResult.appliedOperations);
       }
     }
     if (rejected.length > 0) {
@@ -2593,8 +3063,11 @@ var ClientSession = class {
       const clientSeq = clientVector.get(nodeId) ?? 0;
       if (serverSeq > clientSeq) {
         const ops = await this.store.getOperationRange(nodeId, clientSeq + 1, serverSeq);
-        const visible = ops.filter((op) => this.operationVisibleToClient(op));
-        missing.push(...visible);
+        for (const op of ops) {
+          if (await this.operationVisibleToClient(op)) {
+            missing.push(op);
+          }
+        }
       }
     }
     if (missing.length === 0) {
@@ -2646,11 +3119,111 @@ var ClientSession = class {
       });
     }
   }
-  operationVisibleToClient(op) {
-    if (!operationMatchesScopes(op, this.authContext?.scopes)) {
+  /**
+   * Send the gap-free server->client delivery stream, resuming just after
+   * `fromDeliverySeq`. Operations are scanned in server delivery-sequence order
+   * (commit order), scope-filtered for this session, and sent in batches that chain:
+   * each batch's `baseDeliverySequence` equals the previous batch's
+   * `maxDeliverySequence` (the first batch bases on `fromDeliverySeq`). The client
+   * applies a batch only when its watermark equals the base and advances the
+   * watermark to the max, so a dropped batch stalls the watermark and is recovered by
+   * the next handshake resend. Because delivery-sequence order respects causal order
+   * (a dependency is always committed, and thus sequenced, before its dependent), no
+   * topological sort is needed and the client never defers on a missing dependency
+   * that is itself in this stream.
+   *
+   * The final batch advances the watermark to the highest delivery sequence scanned,
+   * not merely the last in-scope one, so an out-of-scope tail is not re-scanned on the
+   * next reconnect. Returns the number of operations actually sent.
+   */
+  async sendDeliveryStream(fromDeliverySeq, finalizeWhenEmpty, excludeNodeId) {
+    const scanChunk = Math.max(this.batchSize, 1) * 5;
+    let scanCursor = fromDeliverySeq;
+    let maxScanned = fromDeliverySeq;
+    const visible = [];
+    while (true) {
+      const chunk = await this.store.getOperationsAfterDelivery(scanCursor, scanChunk);
+      const last = chunk[chunk.length - 1];
+      if (last === void 0) break;
+      scanCursor = last.deliverySequence;
+      maxScanned = scanCursor;
+      for (const delivered of chunk) {
+        if (excludeNodeId !== void 0 && delivered.operation.nodeId === excludeNodeId) {
+          continue;
+        }
+        if (await this.operationVisibleToClient(delivered.operation)) {
+          visible.push(delivered);
+        }
+      }
+      if (chunk.length < scanChunk) break;
+    }
+    if (visible.length === 0) {
+      if (finalizeWhenEmpty) {
+        this.sendDeliveryBatch([], fromDeliverySeq, maxScanned, 0, true);
+      }
+      return 0;
+    }
+    const totalBatches = Math.ceil(visible.length / this.batchSize);
+    let base = fromDeliverySeq;
+    for (let i = 0; i < totalBatches; i++) {
+      const slice = visible.slice(i * this.batchSize, (i + 1) * this.batchSize);
+      const lastInSlice = slice[slice.length - 1];
+      if (lastInSlice === void 0) continue;
+      const isFinal = i === totalBatches - 1;
+      const lastSeq = lastInSlice.deliverySequence;
+      const max = isFinal ? Math.max(maxScanned, lastSeq) : lastSeq;
+      this.sendDeliveryBatch(slice, base, max, i, isFinal);
+      base = max;
+    }
+    return visible.length;
+  }
+  /** Build, track, and send one chained delivery-stream batch. */
+  sendDeliveryBatch(slice, base, max, batchIndex, isFinal) {
+    const batchMsg = {
+      type: "operation-batch",
+      messageId: generateUUIDv74(),
+      operations: slice.map((delivered) => this.serializer.encodeOperation(delivered.operation)),
+      isFinal,
+      batchIndex,
+      baseDeliverySequence: base,
+      maxDeliverySequence: max
+    };
+    this.sendToClient(batchMsg);
+    if (slice.length > 0) {
+      this.emitter?.emit({
+        type: "sync:sent",
+        operations: slice.map((delivered) => delivered.operation),
+        batchSize: slice.length
+      });
+    }
+  }
+  async operationVisibleToClient(op) {
+    const scopes = this.authContext?.scopes;
+    const subsets = this.syncQuerySubsets;
+    const needsBackfill = missingScopeFields(op, scopes).length > 0 || subsets !== void 0 && subsets.length > 0;
+    const fullRecord = needsBackfill ? await this.lookupRecordFields(op.collection, op.recordId) : void 0;
+    if (!operationMatchesScopes(op, scopes, fullRecord)) {
       return false;
     }
-    return operationMatchesQuerySubsets(op, this.syncQuerySubsets);
+    return operationMatchesQuerySubsets(op, subsets, fullRecord);
+  }
+  /**
+   * Read a record's current field values from the materialized store for scope /
+   * query-subset backfill. Includes soft-deleted rows so a relayed delete (whose op
+   * carries no fields) is still judged against the record's actual scope. Returns
+   * undefined when the record cannot be read (never materialized, or no schema).
+   */
+  async lookupRecordFields(collection, recordId) {
+    try {
+      const rows = await this.store.queryCollection(collection, {
+        where: { id: recordId },
+        includeDeleted: true,
+        limit: 1
+      });
+      return rows[0];
+    } catch {
+      return void 0;
+    }
   }
   handleAwarenessUpdate(msg) {
     this.onAwarenessUpdate?.(this.sessionId, msg);
@@ -2695,6 +3268,7 @@ var ClientSession = class {
   handleTransportClose() {
     if (this.state === "closed") return;
     this.state = "closed";
+    this.flushOrphanedRelays();
     this.emitter?.emit({ type: "sync:disconnected", reason: "transport closed" });
     this.onClose?.(this.sessionId);
   }
@@ -3069,7 +3643,7 @@ var YjsDocRelay = class {
 
 // src/server/route-context.ts
 import {
-  HybridLogicalClock as HybridLogicalClock2,
+  HybridLogicalClock as HybridLogicalClock3,
   createOperation as createOperation2,
   generateUUIDv7 as generateUUIDv76,
   isAtomicOp,
@@ -3147,9 +3721,9 @@ function pickFields(record, keys) {
   }
   return picked;
 }
-async function buildRouteOperation(store, mutation) {
+async function buildRouteOperation(store, mutation, currentOverride, clockOverride) {
   const nodeId = store.getNodeId();
-  const clock = new HybridLogicalClock2(nodeId);
+  const clock = clockOverride ?? new HybridLogicalClock3(nodeId);
   const schemaVersion = store.getSchema()?.version ?? 1;
   const sequenceNumber = nextServerSequenceNumber(store);
   if (mutation.type === "insert") {
@@ -3174,7 +3748,7 @@ async function buildRouteOperation(store, mutation) {
       `A ${mutation.type} mutation on "${mutation.collection}" requires a recordId.`
     );
   }
-  const current = await store.findRecord(mutation.collection, mutation.recordId);
+  const current = currentOverride ? currentOverride.record : await store.findRecord(mutation.collection, mutation.recordId);
   if (mutation.type === "update") {
     const rawData = mutation.data ?? {};
     const data = {};
@@ -3291,11 +3865,88 @@ function createRouteContext(server, store) {
     }
     return commitOperation(prepared.op, mutation.collection);
   }
+  async function runConditionalViaStore(storeApplyConditional, spec, options) {
+    const scope = options?.scope;
+    const mutations = [];
+    const hasTargetUpdate = spec.update !== void 0 && spec.update !== null;
+    if (hasTargetUpdate) {
+      mutations.push({
+        collection: spec.collection,
+        type: "update",
+        recordId: spec.id,
+        data: spec.update
+      });
+    }
+    if (spec.also) {
+      mutations.push(...spec.also);
+    }
+    let result;
+    try {
+      result = await storeApplyConditional({
+        target: { collection: spec.collection, id: spec.id },
+        ...spec.idempotencyKey ? { idempotencyKey: spec.idempotencyKey } : {},
+        admit: (current) => spec.if && Object.keys(spec.if).length > 0 ? evaluateRoutePredicate(current, spec.if) : true,
+        buildOperations: async (current, context) => {
+          const ops = [];
+          for (let i = 0; i < mutations.length; i++) {
+            const mutation = mutations[i];
+            const useLockedCurrent = i === 0 && hasTargetUpdate;
+            const op = await buildRouteOperation(
+              store,
+              mutation,
+              useLockedCurrent ? { record: current } : void 0,
+              context.clock
+            );
+            if (scope && !operationMatchesScopes(op, scope)) {
+              throw new RouteMutationError(
+                "SCOPE_VIOLATION",
+                `Mutation on "${mutation.collection}" is outside the provided scope.`
+              );
+            }
+            ops.push(op);
+          }
+          return ops;
+        }
+      });
+    } catch (error) {
+      if (error instanceof RouteMutationError) {
+        return {
+          ok: false,
+          code: error.code,
+          message: error.message,
+          retriable: isRetriableRejection(error.code)
+        };
+      }
+      throw error;
+    }
+    if (!result.admitted) {
+      return {
+        ok: false,
+        code: spec.reject?.code ?? "CONDITION_NOT_MET",
+        message: spec.reject?.message ?? `Admission condition not met on "${spec.collection}" record "${spec.id}".`,
+        retriable: false
+      };
+    }
+    if (result.idempotent) {
+      const records2 = spec.idempotencyKey ? [await store.findRecord(spec.idempotencyKey.collection, spec.idempotencyKey.id)] : [];
+      return { ok: true, idempotent: true, operations: [], records: records2 };
+    }
+    server.relayServerOperations(result.applied);
+    const records = [];
+    for (const op of result.applied) {
+      records.push(await store.findRecord(op.collection, op.recordId));
+    }
+    return { ok: true, idempotent: false, operations: result.applied, records };
+  }
   return {
     apply(mutation, options) {
       return serialize(() => rawApply(mutation, options?.scope));
     },
     applyConditional(spec, options) {
+      const storeApplyConditional = store.applyConditional;
+      if (storeApplyConditional) {
+        return runConditionalViaStore(storeApplyConditional.bind(store), spec, options);
+      }
       return serialize(async () => {
         if (spec.idempotencyKey) {
           const existing = await store.findRecord(
@@ -3383,7 +4034,8 @@ var DEFAULT_BATCH_SIZE2 = 100;
 var DEFAULT_SCHEMA_VERSION2 = 1;
 var DEFAULT_HOST = "0.0.0.0";
 var DEFAULT_PATH = "/";
-var KoraSyncServer = class {
+var RELAY_RETRANSMIT_INTERVAL_MS = 2e3;
+var KoraSyncServer = class _KoraSyncServer {
   store;
   auth;
   serializer;
@@ -3413,6 +4065,20 @@ var KoraSyncServer = class {
   serverVersion = "1.0.0-beta.0";
   wsServer = null;
   running = false;
+  /**
+   * Periodic tick that retransmits relay batches connected clients have not
+   * acknowledged, so a relay dropped by a lossy transport is redelivered instead of
+   * leaving that client with a permanent version-vector gap (a lost operation).
+   */
+  relayRetransmitTimer = null;
+  /**
+   * Relay operations a client never acknowledged before it disconnected, buffered by
+   * client node id so they can be redelivered on its next connection. Bounded per
+   * node and expired by age so a client that never returns cannot grow this forever.
+   */
+  orphanedRelaysByNode = /* @__PURE__ */ new Map();
+  static MAX_ORPHANED_RELAY_OPS_PER_NODE = 5e3;
+  static ORPHANED_RELAY_TTL_MS = 5 * 6e4;
   constructor(config) {
     this.store = config.store;
     this.auth = config.auth ?? null;
@@ -3440,6 +4106,57 @@ var KoraSyncServer = class {
     if (!this.emitter) {
       this.emitter = new SimpleEventEmitter();
     }
+    this.relayRetransmitTimer = setInterval(() => {
+      this.retransmitPendingRelays(RELAY_RETRANSMIT_INTERVAL_MS);
+    }, RELAY_RETRANSMIT_INTERVAL_MS);
+    this.relayRetransmitTimer.unref?.();
+  }
+  /**
+   * Retransmit relay batches that connected clients have not acknowledged within
+   * `staleMs`. Called on a periodic tick and directly by tests. Redelivering an
+   * already-applied operation is harmless (clients dedup by content-addressed id).
+   */
+  retransmitPendingRelays(staleMs = 0) {
+    for (const session of this.sessions.values()) {
+      session.retransmitPendingRelays(staleMs);
+    }
+    this.expireOrphanedRelays();
+  }
+  /**
+   * Buffer relay operations a disconnected client never acknowledged, keyed by its
+   * node id, deduped by operation id and bounded by count. Redelivered when the
+   * client reconnects (see {@link takeOrphanedRelays}).
+   */
+  bufferOrphanedRelays(nodeId, ops) {
+    if (ops.length === 0) return;
+    const existing = this.orphanedRelaysByNode.get(nodeId);
+    const merged = existing ? existing.ops : [];
+    const seen = new Set(merged.map((op) => op.id));
+    for (const op of ops) {
+      if (!seen.has(op.id)) {
+        merged.push(op);
+        seen.add(op.id);
+      }
+    }
+    const bounded = merged.length > _KoraSyncServer.MAX_ORPHANED_RELAY_OPS_PER_NODE ? merged.slice(merged.length - _KoraSyncServer.MAX_ORPHANED_RELAY_OPS_PER_NODE) : merged;
+    this.orphanedRelaysByNode.set(nodeId, { ops: bounded, bufferedAtMs: Date.now() });
+  }
+  /** Remove and return a node's buffered orphaned relay operations, if any. */
+  takeOrphanedRelays(nodeId) {
+    const entry = this.orphanedRelaysByNode.get(nodeId);
+    if (!entry) return [];
+    this.orphanedRelaysByNode.delete(nodeId);
+    return entry.ops;
+  }
+  /** Drop buffered orphaned relays older than the TTL (client never returned). */
+  expireOrphanedRelays() {
+    if (this.orphanedRelaysByNode.size === 0) return;
+    const cutoff = Date.now() - _KoraSyncServer.ORPHANED_RELAY_TTL_MS;
+    for (const [nodeId, entry] of this.orphanedRelaysByNode) {
+      if (entry.bufferedAtMs <= cutoff) {
+        this.orphanedRelaysByNode.delete(nodeId);
+      }
+    }
   }
   /**
    * The trusted, scoped data-plane context (`apply` / `query` / `findById`).
@@ -3566,6 +4283,11 @@ var KoraSyncServer = class {
       event: "server.stopping",
       details: { connectedClients: this.sessions.size }
     });
+    if (this.relayRetransmitTimer) {
+      clearInterval(this.relayRetransmitTimer);
+      this.relayRetransmitTimer = null;
+    }
+    this.orphanedRelaysByNode.clear();
     this.awarenessRelay.clear();
     this.yjsDocRelay.clear();
     this.blobChunkRelay.clear();
@@ -3701,6 +4423,7 @@ var KoraSyncServer = class {
       auth: this.auth ?? void 0,
       serializer: this.serializer,
       emitter: sessionEmitter,
+      logger: this.logger,
       batchSize: this.batchSize,
       schemaVersion: this.schemaVersion,
       supportedSchemaVersions: this.supportedSchemaVersions,
@@ -3727,7 +4450,11 @@ var KoraSyncServer = class {
       ...this.validateOperation ? { validateOperation: this.validateOperation, koraContext: this.koraContext } : {},
       onClose: (sid) => {
         this.handleSessionClose(sid);
-      }
+      },
+      onOrphanedRelays: (nodeId, ops) => {
+        this.bufferOrphanedRelays(nodeId, ops);
+      },
+      takeOrphanedRelays: (nodeId) => this.takeOrphanedRelays(nodeId)
     });
     this.sessions.set(sessionId, session);
     this.yjsDocRelay.addClient(sessionId, transport);
@@ -3787,6 +4514,22 @@ var KoraSyncServer = class {
     }
     return result;
   }
+  /**
+   * Relay already-applied, server-originated operations to every connected client.
+   * Used by the conditional route apply, which commits its operations atomically
+   * through the store (bypassing {@link applyLocalOperation}) and then fans them
+   * out. Each session still enforces its own per-scope visibility filter.
+   *
+   * @param operations - Operations that have already been committed to the store
+   */
+  relayServerOperations(operations2) {
+    if (operations2.length === 0) {
+      return;
+    }
+    for (const session of this.sessions.values()) {
+      session.relayOperations(operations2);
+    }
+  }
   /**
    * Collect every blob reference still reachable from live records on the server.
    *
@@ -4004,6 +4747,7 @@ function createProductionServer(config) {
   const port = config.port ?? (Number(process.env.PORT) || 3001);
   const staticDir = config.staticDir ?? "./dist";
   const syncPath = config.syncPath ?? "/kora-sync";
+  const crossOriginEmbedderPolicy = config.crossOriginEmbedderPolicy ?? "credentialless";
   const syncServer = new KoraSyncServer({
     store: config.store,
     enableDashboard: true,
@@ -4174,7 +4918,7 @@ function createProductionServer(config) {
       });
       async function handleRequest(req, res) {
         res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
-        res.setHeader("Cross-Origin-Embedder-Policy", "require-corp");
+        res.setHeader("Cross-Origin-Embedder-Policy", crossOriginEmbedderPolicy);
         const url = new URL(req.url || "/", `http://${req.headers.host}`);
         if (url.pathname === "/health") {
           const status = await syncServer.getStatus();