@korajs/server 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/index.js

@@ -54,11 +54,17 @@ function createDefaultLogger() {
   }
 }
 
+// src/apply/rejection-taxonomy.ts
+var RETRIABLE_REJECTION_CODES = /* @__PURE__ */ new Set(["RATE_LIMIT"]);
+function isRetriableRejection(code) {
+  return RETRIABLE_REJECTION_CODES.has(code);
+}
+
 // src/store/memory-server-store.ts
 import { generateUUIDv7 } from "@korajs/core";
 
 // src/store/materialization.ts
-import { StorageError } from "@korajs/core";
+import { StorageError, quoteIdent, replayOperationsForRecord } from "@korajs/core";
 function fieldTypeToSql(descriptor, dialect) {
   switch (descriptor.kind) {
     case "string":
@@ -73,6 +79,14 @@ function fieldTypeToSql(descriptor, dialect) {
       return dialect === "postgres" ? "BIGINT" : "INTEGER";
     case "array":
       return dialect === "postgres" ? "JSONB" : "TEXT";
+    case "object":
+      return dialect === "postgres" ? "JSONB" : "TEXT";
+    case "json":
+      return dialect === "postgres" ? "JSONB" : "TEXT";
+    case "blob":
+      return "TEXT";
+    case "secret":
+      return "TEXT";
     case "richtext":
       return dialect === "postgres" ? "BYTEA" : "BLOB";
   }
@@ -89,13 +103,13 @@ function generateCollectionDDL(name, collection, dialect) {
   const columns = ["id TEXT PRIMARY KEY NOT NULL"];
   for (const [fieldName, descriptor] of Object.entries(collection.fields)) {
     const sqlType = fieldTypeToSql(descriptor, dialect);
-    let colDef = `${fieldName} ${sqlType}`;
+    let colDef = `${quoteIdent(fieldName)} ${sqlType}`;
     if (descriptor.defaultValue !== void 0) {
       colDef += ` DEFAULT ${sqlDefaultLiteral(descriptor.defaultValue)}`;
     }
     if (descriptor.kind === "enum" && descriptor.enumValues) {
       const values = descriptor.enumValues.map((v) => `'${v}'`).join(", ");
-      colDef += ` CHECK (${fieldName} IN (${values}))`;
+      colDef += ` CHECK (${quoteIdent(fieldName)} IN (${values}))`;
     }
     columns.push(colDef);
   }
@@ -103,24 +117,26 @@ function generateCollectionDDL(name, collection, dialect) {
   columns.push(`_created_at ${tsType} NOT NULL DEFAULT 0`);
   columns.push(`_updated_at ${tsType} NOT NULL DEFAULT 0`);
   columns.push("_deleted INTEGER NOT NULL DEFAULT 0");
-  statements.push(`CREATE TABLE IF NOT EXISTS ${name} (
+  statements.push(`CREATE TABLE IF NOT EXISTS ${quoteIdent(name)} (
   ${columns.join(",\n  ")}
 )`);
   for (const [fieldName, descriptor] of Object.entries(collection.fields)) {
     const sqlType = fieldTypeToSql(descriptor, dialect);
-    let colDef = `${fieldName} ${sqlType}`;
+    let colDef = `${quoteIdent(fieldName)} ${sqlType}`;
     if (descriptor.defaultValue !== void 0) {
       colDef += ` DEFAULT ${sqlDefaultLiteral(descriptor.defaultValue)}`;
     }
     statements.push(`--kora:safe-alter
-ALTER TABLE ${name} ADD COLUMN ${colDef}`);
+ALTER TABLE ${quoteIdent(name)} ADD COLUMN ${colDef}`);
   }
   for (const indexField of collection.indexes) {
     statements.push(
-      `CREATE INDEX IF NOT EXISTS idx_${name}_${indexField} ON ${name} (${indexField})`
+      `CREATE INDEX IF NOT EXISTS idx_${name}_${indexField} ON ${quoteIdent(name)} (${quoteIdent(indexField)})`
     );
   }
-  statements.push(`CREATE INDEX IF NOT EXISTS idx_${name}__deleted ON ${name} (_deleted)`);
+  statements.push(
+    `CREATE INDEX IF NOT EXISTS idx_${name}__deleted ON ${quoteIdent(name)} (_deleted)`
+  );
   return statements;
 }
 function generateAllCollectionDDL(schema, dialect) {
@@ -130,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])
@@ -204,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;
@@ -217,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;
@@ -249,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();
@@ -282,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);
@@ -301,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]) {
@@ -445,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);
       }
@@ -480,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) {
@@ -590,8 +620,8 @@ var MemoryServerStore = class {
 };
 
 // src/store/postgres-server-store.ts
-import { generateUUIDv7 as generateUUIDv72 } 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";
@@ -607,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(),
@@ -614,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", {
@@ -636,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;
   }
@@ -682,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,
@@ -706,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;
@@ -720,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;
@@ -754,7 +905,7 @@ var PostgresServerStore = class {
     this.assertCollection(collection);
     const schema = this.schema;
     const collectionDef = schema.collections[collection];
-    const query = sql`SELECT * FROM ${sql.raw(collection)} WHERE id = ${id} AND _deleted = 0`;
+    const query = sql`SELECT * FROM ${sql.raw(quoteIdent2(collection))} WHERE id = ${id} AND _deleted = 0`;
     const rows = await this.db.execute(query);
     if (rows.length === 0) return null;
     return this.deserializeRow(rows[0], collectionDef);
@@ -771,7 +922,7 @@ var PostgresServerStore = class {
       }
     }
     const whereClause = this.buildWhereClause(where ?? {}, false);
-    const query = sql`SELECT COUNT(*) as cnt FROM ${sql.raw(collection)} WHERE ${whereClause}`;
+    const query = sql`SELECT COUNT(*) as cnt FROM ${sql.raw(quoteIdent2(collection))} WHERE ${whereClause}`;
     const rows = await this.db.execute(query);
     const cnt = rows[0]?.cnt;
     return typeof cnt === "string" ? Number.parseInt(cnt, 10) : cnt ?? 0;
@@ -783,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);
   }
@@ -798,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();
@@ -807,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.
@@ -831,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);
@@ -858,7 +1041,7 @@ var PostgresServerStore = class {
       );
     } else {
       await txOrDb.execute(
-        sql`UPDATE ${sql.raw(collection)} SET _deleted = 1, _updated_at = ${Date.now()} WHERE id = ${recordId}`
+        sql`UPDATE ${sql.raw(quoteIdent2(collection))} SET _deleted = 1, _updated_at = ${Date.now()} WHERE id = ${recordId}`
       );
     }
   }
@@ -877,16 +1060,16 @@ var PostgresServerStore = class {
       updatedAt,
       0
     ];
-    const columnsSql = sql.raw(allColumns.join(", "));
+    const columnsSql = sql.raw(allColumns.map((c) => quoteIdent2(c)).join(", "));
     const valuesSql = sql.join(
       values.map((v) => sql`${v}`),
       sql.raw(", ")
     );
     const updateSet = sql.raw(
-      allColumns.slice(1).map((c) => `${c} = excluded.${c}`).join(", ")
+      allColumns.slice(1).map((c) => `${quoteIdent2(c)} = excluded.${quoteIdent2(c)}`).join(", ")
     );
     await txOrDb.execute(
-      sql`INSERT INTO ${sql.raw(tableName)} (${columnsSql}) VALUES (${valuesSql}) ON CONFLICT (id) DO UPDATE SET ${updateSet}`
+      sql`INSERT INTO ${sql.raw(quoteIdent2(tableName))} (${columnsSql}) VALUES (${valuesSql}) ON CONFLICT (id) DO UPDATE SET ${updateSet}`
     );
   }
   /**
@@ -908,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();
@@ -928,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) {
@@ -946,7 +1131,7 @@ var PostgresServerStore = class {
         );
       } else {
         await this.db.execute(
-          sql`INSERT INTO ${sql.raw(collectionName)} (id, _deleted, _created_at, _updated_at) VALUES (${recordId}, 1, ${Date.now()}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET _deleted = 1, _updated_at = ${Date.now()}`
+          sql`INSERT INTO ${sql.raw(quoteIdent2(collectionName))} (id, _deleted, _created_at, _updated_at) VALUES (${recordId}, 1, ${Date.now()}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET _deleted = 1, _updated_at = ${Date.now()}`
         );
       }
     }
@@ -959,10 +1144,12 @@ var PostgresServerStore = class {
       options?.where ?? {},
       options?.includeDeleted ?? false
     );
-    const parts = [sql`SELECT * FROM ${sql.raw(collection)} WHERE ${whereClause}`];
+    const parts = [
+      sql`SELECT * FROM ${sql.raw(quoteIdent2(collection))} WHERE ${whereClause}`
+    ];
     if (options?.orderBy) {
       const dir = options.orderDirection === "desc" ? "DESC" : "ASC";
-      parts.push(sql.raw(` ORDER BY ${options.orderBy} ${dir}`));
+      parts.push(sql.raw(` ORDER BY ${quoteIdent2(options.orderBy)} ${dir}`));
     }
     if (options?.limit !== void 0) {
       parts.push(sql` LIMIT ${options.limit}`);
@@ -978,7 +1165,7 @@ var PostgresServerStore = class {
       conditions.push(sql.raw("_deleted = 0"));
     }
     for (const [key, value] of Object.entries(where)) {
-      conditions.push(sql`${sql.raw(key)} = ${value}`);
+      conditions.push(sql`${sql.raw(quoteIdent2(key))} = ${value}`);
     }
     if (conditions.length === 0) {
       return sql.raw("1 = 1");
@@ -1051,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,
@@ -1097,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,
@@ -1122,7 +1360,8 @@ var PostgresServerStore = class {
       },
       sequenceNumber: row.sequenceNumber,
       causalDeps: JSON.parse(row.causalDeps),
-      schemaVersion: row.schemaVersion
+      schemaVersion: row.schemaVersion,
+      ...atomicOps ? { atomicOps } : {}
     };
   }
   // ---------------------------------------------------------------------------
@@ -1173,8 +1412,8 @@ async function loadPostgresDeps() {
 
 // src/store/sqlite-server-store.ts
 import { createRequire } from "module";
-import { generateUUIDv7 as generateUUIDv73 } 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 { 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, 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";
@@ -1190,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(),
@@ -1197,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", {
@@ -1210,6 +1456,10 @@ var syncState = sqliteTable("sync_state", {
   maxSequenceNumber: integer2("max_sequence_number").notNull(),
   lastSeenAt: integer2("last_seen_at").notNull()
 });
+var deliveryCounter = sqliteTable("delivery_counter", {
+  id: integer2("id").primaryKey(),
+  value: integer2("value").notNull()
+});
 
 // src/store/sqlite-server-store.ts
 var esmRequire = createRequire(import.meta.url);
@@ -1263,12 +1513,15 @@ 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";
       }
+      const row = this.serializeOperation(op, now, this.nextDeliverySeq(tx));
+      tx.insert(operations).values(row).run();
       tx.insert(syncState).values({
         nodeId: op.nodeId,
         maxSequenceNumber: op.sequenceNumber,
@@ -1297,6 +1550,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]) {
@@ -1328,7 +1596,7 @@ var SqliteServerStore = class {
     this.assertCollection(collection);
     const schema = this.schema;
     const collectionDef = schema.collections[collection];
-    const query = sql2`SELECT * FROM ${sql2.raw(collection)} WHERE id = ${id} AND _deleted = 0`;
+    const query = sql2`SELECT * FROM ${sql2.raw(quoteIdent3(collection))} WHERE id = ${id} AND _deleted = 0`;
     const rows = this.db.all(query);
     if (rows.length === 0) return null;
     return this.deserializeRow(rows[0], collectionDef);
@@ -1344,7 +1612,7 @@ var SqliteServerStore = class {
       }
     }
     const whereClause = this.buildWhereClause(where ?? {}, false);
-    const query = sql2`SELECT COUNT(*) as cnt FROM ${sql2.raw(collection)} WHERE ${whereClause}`;
+    const query = sql2`SELECT COUNT(*) as cnt FROM ${sql2.raw(quoteIdent3(collection))} WHERE ${whereClause}`;
     const rows = this.db.all(query);
     return rows[0]?.cnt ?? 0;
   }
@@ -1354,7 +1622,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);
@@ -1374,13 +1642,17 @@ var SqliteServerStore = class {
     this.db.transaction((tx) => {
       tx.run(sql2.raw("DELETE FROM operations"));
       tx.run(sql2.raw("DELETE FROM sync_state"));
+      tx.update(deliveryCounter).set({ value: 0 }).where(eq2(deliveryCounter.id, 1)).run();
       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();
       }
+      tx.update(deliveryCounter).set({ value: deliverySeq }).where(eq2(deliveryCounter.id, 1)).run();
     });
     return { operationsRestored: ops.length, success: true };
   }
@@ -1398,11 +1670,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);
@@ -1421,7 +1695,7 @@ var SqliteServerStore = class {
       );
     } else {
       txOrDb.run(
-        sql2`UPDATE ${sql2.raw(collection)} SET _deleted = 1, _updated_at = ${Date.now()} WHERE id = ${recordId}`
+        sql2`UPDATE ${sql2.raw(quoteIdent3(collection))} SET _deleted = 1, _updated_at = ${Date.now()} WHERE id = ${recordId}`
       );
     }
   }
@@ -1442,16 +1716,16 @@ var SqliteServerStore = class {
       0
       // _deleted = false
     ];
-    const columnsSql = sql2.raw(allColumns.join(", "));
+    const columnsSql = sql2.raw(allColumns.map((c) => quoteIdent3(c)).join(", "));
     const valuesSql = sql2.join(
       values.map((v) => sql2`${v}`),
       sql2.raw(", ")
     );
     const updateSet = sql2.raw(
-      allColumns.slice(1).map((c) => `${c} = excluded.${c}`).join(", ")
+      allColumns.slice(1).map((c) => `${quoteIdent3(c)} = excluded.${quoteIdent3(c)}`).join(", ")
     );
     txOrDb.run(
-      sql2`INSERT INTO ${sql2.raw(tableName)} (${columnsSql}) VALUES (${valuesSql}) ON CONFLICT (id) DO UPDATE SET ${updateSet}`
+      sql2`INSERT INTO ${sql2.raw(quoteIdent3(tableName))} (${columnsSql}) VALUES (${valuesSql}) ON CONFLICT (id) DO UPDATE SET ${updateSet}`
     );
   }
   /**
@@ -1474,8 +1748,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) {
@@ -1491,7 +1766,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) {
@@ -1509,7 +1785,7 @@ var SqliteServerStore = class {
           );
         } else {
           tx.run(
-            sql2`INSERT INTO ${sql2.raw(collectionName)} (id, _deleted, _created_at, _updated_at) VALUES (${recordId}, 1, ${Date.now()}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET _deleted = 1, _updated_at = ${Date.now()}`
+            sql2`INSERT INTO ${sql2.raw(quoteIdent3(collectionName))} (id, _deleted, _created_at, _updated_at) VALUES (${recordId}, 1, ${Date.now()}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET _deleted = 1, _updated_at = ${Date.now()}`
           );
         }
       }
@@ -1523,10 +1799,12 @@ var SqliteServerStore = class {
       options?.where ?? {},
       options?.includeDeleted ?? false
     );
-    const parts = [sql2`SELECT * FROM ${sql2.raw(collection)} WHERE ${whereClause}`];
+    const parts = [
+      sql2`SELECT * FROM ${sql2.raw(quoteIdent3(collection))} WHERE ${whereClause}`
+    ];
     if (options?.orderBy) {
       const dir = options.orderDirection === "desc" ? "DESC" : "ASC";
-      parts.push(sql2.raw(` ORDER BY ${options.orderBy} ${dir}`));
+      parts.push(sql2.raw(` ORDER BY ${quoteIdent3(options.orderBy)} ${dir}`));
     }
     if (options?.limit !== void 0) {
       parts.push(sql2` LIMIT ${options.limit}`);
@@ -1542,7 +1820,7 @@ var SqliteServerStore = class {
       conditions.push(sql2.raw("_deleted = 0"));
     }
     for (const [key, value] of Object.entries(where)) {
-      conditions.push(sql2`${sql2.raw(key)} = ${value}`);
+      conditions.push(sql2`${sql2.raw(quoteIdent3(key))} = ${value}`);
     }
     if (conditions.length === 0) {
       return sql2.raw("1 = 1");
@@ -1613,6 +1891,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,
@@ -1622,9 +1901,35 @@ 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 UNIQUE INDEX IF NOT EXISTS idx_delivery_seq_unique
+			ON operations (delivery_seq)
+			WHERE delivery_seq IS NOT NULL
+		`);
     this.db.run(sql2`
 			CREATE INDEX IF NOT EXISTS idx_collection ON operations (collection)
 		`);
@@ -1641,11 +1946,60 @@ var SqliteServerStore = class {
 				last_seen_at INTEGER NOT NULL
 			)
 		`);
+    this.db.run(sql2`
+			CREATE TABLE IF NOT EXISTS delivery_counter (
+				id INTEGER PRIMARY KEY,
+				value INTEGER NOT NULL
+			)
+		`);
+    this.backfillDeliverySequence();
+  }
+  /**
+   * Assign delivery sequences to any operations written before the column existed,
+   * then seed the durable 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}`);
+      }
+      tx.insert(deliveryCounter).values({ id: 1, value: next }).onConflictDoUpdate({
+        target: deliveryCounter.id,
+        set: {
+          value: sql2`MAX(${deliveryCounter.value}, ${next})`
+        }
+      }).run();
+    });
+  }
+  /**
+   * Reserve the next delivery sequence inside the append transaction. SQLite locks
+   * the database for the write transaction, and this counter row keeps sequence
+   * allocation shared by every SqliteServerStore instance using the same file.
+   */
+  nextDeliverySeq(tx) {
+    const rows = tx.update(deliveryCounter).set({ value: sql2`${deliveryCounter.value} + 1` }).where(eq2(deliveryCounter.id, 1)).returning({ value: deliveryCounter.value }).all();
+    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 value;
   }
   // ---------------------------------------------------------------------------
   // Operation serialization
   // ---------------------------------------------------------------------------
-  serializeOperation(op, receivedAt) {
+  serializeOperation(op, receivedAt, deliverySeq) {
     return {
       id: op.id,
       nodeId: op.nodeId,
@@ -1654,16 +2008,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,
@@ -1679,7 +2036,8 @@ var SqliteServerStore = class {
       },
       sequenceNumber: row.sequenceNumber,
       causalDeps: JSON.parse(row.causalDeps),
-      schemaVersion: row.schemaVersion
+      schemaVersion: row.schemaVersion,
+      ...atomicOps ? { atomicOps } : {}
     };
   }
   // ---------------------------------------------------------------------------
@@ -1861,6 +2219,7 @@ var WsServerTransport = class {
 };
 
 // src/session/client-session.ts
+import { applyOperationTransforms } from "@korajs/core";
 import { generateUUIDv7 as generateUUIDv74, hashBlob } from "@korajs/core";
 import { topologicalSort } from "@korajs/core/internal";
 import { decodeBlobChunkBytes } from "@korajs/sync";
@@ -1961,10 +2320,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(
     {
@@ -1982,6 +2341,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;
@@ -1991,14 +2353,28 @@ function nextServerSequenceNumber(store) {
 async function applyServerOperation(store, op, relationLookup) {
   const schema = store.getSchema();
   const lookup = relationLookup ?? (schema ? buildMergeRelationLookup(schema) : /* @__PURE__ */ new Map());
+  const shapeCheck = validateOperationShape(op, schema);
+  if (!shapeCheck.valid) {
+    return {
+      result: "skipped",
+      appliedOperations: [],
+      rejection: {
+        code: shapeCheck.code ?? "SCHEMA_VALIDATION_ERROR",
+        message: shapeCheck.message ?? `Operation "${op.id}" does not match the server schema`,
+        retriable: false
+      }
+    };
+  }
   const constraintCheck = await validateIncomingOperationConstraints(store, op, schema);
   if (!constraintCheck.valid) {
+    const code = constraintCheck.code ?? "CONSTRAINT_VIOLATION";
     return {
       result: "skipped",
       appliedOperations: [],
       rejection: {
-        code: constraintCheck.code ?? "CONSTRAINT_VIOLATION",
-        message: constraintCheck.message ?? `Operation "${op.id}" violates a schema constraint`
+        code,
+        message: constraintCheck.message ?? `Operation "${op.id}" violates a schema constraint`,
+        retriable: isRetriableRejection(code)
       }
     };
   }
@@ -2011,7 +2387,8 @@ async function applyServerOperation(store, op, relationLookup) {
         appliedOperations: [],
         rejection: {
           code: "REFERENTIAL_INTEGRITY",
-          message: `Operation "${op.id}" violates referential integrity on "${op.collection}"`
+          message: `Operation "${op.id}" violates referential integrity on "${op.collection}"`,
+          retriable: isRetriableRejection("REFERENTIAL_INTEGRITY")
         }
       };
     }
@@ -2020,16 +2397,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);
@@ -2043,6 +2418,67 @@ async function applyServerOperation(store, op, relationLookup) {
     appliedOperations: result === "applied" ? [op] : []
   };
 }
+function validateOperationShape(op, schema) {
+  if (!schema) {
+    return { valid: true };
+  }
+  const collection = schema.collections[op.collection];
+  if (!collection) {
+    return {
+      valid: false,
+      code: "UNKNOWN_COLLECTION",
+      message: `Operation "${op.id}" targets unknown collection "${op.collection}".`
+    };
+  }
+  const declaredFields = new Set(Object.keys(collection.fields));
+  const systemPreviousFields = /* @__PURE__ */ new Set(["id", "_created_at", "_updated_at", "_deleted"]);
+  const invalidDataField = firstInvalidField(op.data, declaredFields);
+  if (invalidDataField) {
+    return {
+      valid: false,
+      code: "SCHEMA_VALIDATION_ERROR",
+      message: `Operation "${op.id}" contains undeclared field "${invalidDataField}" in data for collection "${op.collection}".`
+    };
+  }
+  const invalidPreviousField = firstInvalidField(
+    op.previousData,
+    declaredFields,
+    systemPreviousFields
+  );
+  if (invalidPreviousField) {
+    return {
+      valid: false,
+      code: "SCHEMA_VALIDATION_ERROR",
+      message: `Operation "${op.id}" contains undeclared field "${invalidPreviousField}" in previousData for collection "${op.collection}".`
+    };
+  }
+  if (op.atomicOps) {
+    for (const field of Object.keys(op.atomicOps)) {
+      if (!declaredFields.has(field)) {
+        return {
+          valid: false,
+          code: "SCHEMA_VALIDATION_ERROR",
+          message: `Operation "${op.id}" contains undeclared atomic field "${field}" for collection "${op.collection}".`
+        };
+      }
+    }
+  }
+  return { valid: true };
+}
+function firstInvalidField(value, declaredFields, extraAllowedFields) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  for (const field of Object.keys(value)) {
+    if (!declaredFields.has(field) && !extraAllowedFields?.has(field)) {
+      return field;
+    }
+  }
+  return null;
+}
 
 // src/auth/no-auth.ts
 var NoAuthProvider = class {
@@ -2087,24 +2523,74 @@ function mergeScopeMaps(base, overlay, source) {
 }
 
 // src/scopes/server-scope-filter.ts
-function operationMatchesScopes(op, scopes) {
+var DEFAULT_MAX_SCOPE_PREDICATE_VALUES = 100;
+function normalizeScopeMap(scopes, maxValues = DEFAULT_MAX_SCOPE_PREDICATE_VALUES) {
+  const normalized = {};
+  for (const collection of Object.keys(scopes).sort()) {
+    const predicate = {};
+    for (const field of Object.keys(scopes[collection] ?? {}).sort()) {
+      const expected = scopes[collection]?.[field];
+      if (expected && typeof expected === "object" && !Array.isArray(expected) && "$in" in expected) {
+        const values = expected.$in;
+        if (!Array.isArray(values))
+          throw new Error(`Invalid $in predicate for ${collection}.${field}`);
+        const unique = [...new Map(values.map((value) => [stableValueKey(value), value])).values()];
+        if (unique.length > maxValues)
+          throw new Error(
+            `Scope predicate for ${collection}.${field} exceeds the ${maxValues}-value limit`
+          );
+        predicate[field] = {
+          $in: unique.sort((a, b) => stableValueKey(a).localeCompare(stableValueKey(b)))
+        };
+      } else predicate[field] = expected;
+    }
+    normalized[collection] = predicate;
+  }
+  return normalized;
+}
+function stableValueKey(value) {
+  if (Array.isArray(value)) return `[${value.map(stableValueKey).join(",")}]`;
+  if (value && typeof value === "object")
+    return `{${Object.keys(value).sort().map(
+      (key) => `${JSON.stringify(key)}:${stableValueKey(value[key])}`
+    ).join(",")}}`;
+  return JSON.stringify(value);
+}
+function operationMatchesScopes(op, scopes, fullRecord) {
   if (!scopes) return true;
   const collectionScope = scopes[op.collection];
   if (!collectionScope) return false;
-  const snapshot = buildSnapshot(op);
+  if (Object.keys(collectionScope).length === 0) return true;
+  const snapshot = buildSnapshot(op, fullRecord);
   if (!snapshot) return false;
   for (const [field, expected] of Object.entries(collectionScope)) {
-    if (snapshot[field] !== expected) {
+    if (!matchesPredicate(snapshot[field], expected)) {
       return false;
     }
   }
   return true;
 }
-function buildSnapshot(op) {
+function matchesPredicate(actual, expected) {
+  if (expected && typeof expected === "object" && !Array.isArray(expected) && "$in" in expected) {
+    const values = expected.$in;
+    return Array.isArray(values) && values.some((value) => Object.is(actual, value));
+  }
+  return Object.is(actual, expected);
+}
+function missingScopeFields(op, scopes) {
+  if (!scopes) return [];
+  const collectionScope = scopes[op.collection];
+  if (!collectionScope) return [];
+  if (Object.keys(collectionScope).length === 0) 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 ?? {}
   };
@@ -2195,21 +2681,74 @@ 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 {
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    const entries = Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function sameScopeMap(a, b) {
+  const normalize = (value) => value && typeof value === "object" ? normalizeScopeMap(value) : value;
+  return stableStringify(normalize(a) ?? null) === stableStringify(normalize(b) ?? null);
+}
+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;
+  /**
+   * Timestamp of the last delivery-stream send attempt. Periodic retransmission uses
+   * this as its stale window so a slow client does not receive duplicate full-stream
+   * batches every server tick while the first batch is still being applied.
+   */
+  lastDeliveryPushAttemptAtMs = 0;
+  deliveryStallRepeatCount = 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;
+  operationTransforms;
   onRelay;
   onAwarenessUpdate;
   onYjsDocUpdate;
@@ -2217,9 +2756,13 @@ var ClientSession = class {
   onBlobChunkResponse;
   persistBlobChunk;
   onClose;
+  onOrphanedRelays;
+  takeOrphanedRelays;
   maxOperationBytes;
   maxOpsPerMinute;
   rateLimiter;
+  validateOperation;
+  koraContext;
   constructor(options) {
     this.sessionId = options.sessionId;
     this.transport = options.transport;
@@ -2227,6 +2770,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;
@@ -2234,6 +2778,7 @@ var ClientSession = class {
       min: this.schemaVersion,
       max: this.schemaVersion
     };
+    this.operationTransforms = options.operationTransforms ?? [];
     this.onRelay = options.onRelay ?? null;
     this.onAwarenessUpdate = options.onAwarenessUpdate ?? null;
     this.onYjsDocUpdate = options.onYjsDocUpdate ?? null;
@@ -2241,9 +2786,13 @@ 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);
+    this.validateOperation = options.validateOperation ?? null;
+    this.koraContext = options.koraContext ?? null;
   }
   /**
    * Start handling messages from the client transport.
@@ -2263,9 +2812,41 @@ 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 {
+        this.lastDeliveryPushAttemptAtMs = Date.now();
+        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",
@@ -2274,14 +2855,86 @@ 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) {
+      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);
+      }
+    }
+  }
+  /**
+   * Wake the durable delivery stream for clients that negotiated delivery
+   * watermarks. This is used both for dropped watermark batches and for operations
+   * appended by another server/store instance: the session always scans from its
+   * own acknowledged cursor and applies its visibility filter before sending.
+   */
+  pushDeliveryStreamIfSupported(staleMs = 0, options = {}) {
+    if (this.state !== "streaming" || !this.transport.isConnected()) return;
+    if (this.clientDeliveryWatermark === null) return;
+    if (staleMs > 0 && Date.now() - this.lastDeliveryPushAttemptAtMs < staleMs) {
+      return;
+    }
+    if (options.trackStall) {
+      this.deliveryStallRepeatCount += 1;
+      if (this.deliveryStallRepeatCount >= 3) {
+        this.emitter?.emit({
+          type: "sync:delivery-stalled",
+          sessionId: this.sessionId,
+          watermark: this.lastAckedDeliverySeq,
+          repeatCount: this.deliveryStallRepeatCount
+        });
+      }
+    }
+    this.pushDeliveryStream();
+  }
   /**
    * 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");
     }
@@ -2336,6 +2989,11 @@ 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);
+          this.deliveryStallRepeatCount = 0;
+        }
         break;
       case "error":
         break;
@@ -2374,6 +3032,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);
   }
@@ -2394,14 +3064,28 @@ var ClientSession = class {
       this.authContext = context;
       this.state = "authenticated";
     }
-    const resolvedScopes = resolveSessionScopes(this.store.getSchema(), {
+    const rawResolvedScopes = resolveSessionScopes(this.store.getSchema(), {
       handshakeScope: msg.syncScope,
       authScopes: this.authContext?.scopes
     });
-    if (resolvedScopes) {
-      if (this.authContext) {
-        this.authContext = { ...this.authContext, scopes: resolvedScopes };
-      } else {
+    let resolvedScopes;
+    try {
+      resolvedScopes = rawResolvedScopes ? normalizeScopeMap(rawResolvedScopes) : void 0;
+    } catch (error) {
+      this.sendToClient({
+        type: "error",
+        messageId: generateUUIDv74(),
+        code: "SCOPE_PREDICATE_LIMIT",
+        message: error instanceof Error ? error.message : "Invalid scope predicate",
+        retriable: false
+      });
+      this.close("invalid scope predicate");
+      return;
+    }
+    if (resolvedScopes) {
+      if (this.authContext) {
+        this.authContext = { ...this.authContext, scopes: resolvedScopes };
+      } else {
         this.authContext = { userId: msg.nodeId, scopes: resolvedScopes };
       }
     }
@@ -2412,11 +3096,31 @@ var ClientSession = class {
       this.syncQuerySubsets = [];
     }
     this.resumeDeltaCursor = msg.deltaCursor ? decodeDeltaCursor(msg.deltaCursor) : null;
+    this.clientDeliveryWatermark = msg.lastDeliverySequence ?? null;
+    if (this.clientDeliveryWatermark !== null && !sameScopeMap(msg.syncScope, this.authContext?.scopes)) {
+      this.clientDeliveryWatermark = 0;
+    }
+    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);
     if (!isClientSchemaVersionSupported(msg.schemaVersion, this.supportedSchemaVersions)) {
       const { min, max } = this.supportedSchemaVersions;
+      this.emitter?.emit({
+        type: "sync:schema-mismatch",
+        clientSchemaVersion: msg.schemaVersion,
+        serverSchemaVersion: this.schemaVersion,
+        supportedMin: min,
+        supportedMax: max,
+        reason: `${SCHEMA_MISMATCH_PREFIX}: client schema version ${msg.schemaVersion} not in supported range [${min}, ${max}]`
+      });
       const response2 = {
         type: "handshake-response",
         messageId: generateUUIDv74(),
@@ -2442,6 +3146,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 } : {},
@@ -2452,17 +3160,40 @@ 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;
+      this.lastDeliveryPushAttemptAtMs = Date.now();
+      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 = [];
+    let acknowledgedThrough = 0;
+    let canAdvanceAck = true;
     for (const op of operations2) {
-      if (!this.operationVisibleToClient(op)) {
-        rejected.push(op);
+      if (!canAdvanceAck) {
+        continue;
+      }
+      if (!await this.operationVisibleToClient(op)) {
+        this.sendOperationRejected(
+          op,
+          "SCOPE_VIOLATION",
+          `Operation "${op.id}" in collection "${op.collection}" is outside the client's sync scope. Refresh sync scopes and retry.`,
+          true
+        );
+        canAdvanceAck = false;
         continue;
       }
       if (!isOperationTimestampValid(op)) {
@@ -2471,6 +3202,7 @@ var ClientSession = class {
           `Operation "${op.id}" timestamp is too far in the future`,
           false
         );
+        canAdvanceAck = false;
         continue;
       }
       if (!this.rateLimiter.allow(1)) {
@@ -2479,6 +3211,7 @@ var ClientSession = class {
           `Session exceeded operation rate limit (${String(this.maxOpsPerMinute)} ops/min)`,
           true
         );
+        canAdvanceAck = false;
         continue;
       }
       const sizeCheck = validateOperationSize(op, this.maxOperationBytes);
@@ -2488,27 +3221,73 @@ var ClientSession = class {
           sizeCheck.message ?? `Operation "${op.id}" is too large`,
           false
         );
+        canAdvanceAck = false;
         continue;
       }
-      try {
-        const applyResult = await applyServerOperation(this.store, op);
-        if (applyResult.rejection) {
-          this.sendError(applyResult.rejection.code, applyResult.rejection.message, false);
+      const serverOp = this.transformForServerSchema(op);
+      if (serverOp === null) {
+        this.sendOperationRejected(
+          op,
+          "SCHEMA_TRANSFORM_UNAVAILABLE",
+          `Operation "${op.id}" cannot be transformed from schema v${op.schemaVersion} to server schema v${this.schemaVersion}.`,
+          false
+        );
+        acknowledgedThrough = op.sequenceNumber;
+        continue;
+      }
+      if (this.validateOperation && this.koraContext) {
+        let decision;
+        try {
+          decision = await this.validateOperation(serverOp, {
+            auth: this.authContext,
+            kora: this.koraContext
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "validator error";
+          this.sendOperationRejected(
+            serverOp,
+            "VALIDATION_ERROR",
+            `Validator threw: ${message}`,
+            true
+          );
+          canAdvanceAck = false;
+          continue;
+        }
+        if (decision.action === "reject") {
+          const retriable = decision.retriable ?? isRetriableRejection(decision.code);
+          this.sendOperationRejected(serverOp, decision.code, decision.message, retriable);
+          if (retriable) {
+            canAdvanceAck = false;
+          } else {
+            acknowledgedThrough = op.sequenceNumber;
+          }
           continue;
         }
-        if (applyResult.result === "applied") {
-          applied.push(...applyResult.appliedOperations);
+        if (decision.action === "ignore") {
+          acknowledgedThrough = op.sequenceNumber;
+          continue;
         }
-      } catch {
       }
-    }
-    if (rejected.length > 0) {
-      for (const op of rejected) {
-        this.sendError(
-          "SCOPE_VIOLATION",
-          `Operation "${op.id}" in collection "${op.collection}" is outside the client's sync scope`,
-          false
+      const applyResult = await applyServerOperation(this.store, serverOp);
+      if (applyResult.rejection) {
+        this.sendOperationRejected(
+          serverOp,
+          applyResult.rejection.code,
+          applyResult.rejection.message,
+          applyResult.rejection.retriable
         );
+        if (applyResult.rejection.retriable) {
+          canAdvanceAck = false;
+        } else {
+          acknowledgedThrough = op.sequenceNumber;
+        }
+        continue;
+      }
+      if (applyResult.result === "applied") {
+        applied.push(...applyResult.appliedOperations);
+        acknowledgedThrough = op.sequenceNumber;
+      } else {
+        acknowledgedThrough = op.sequenceNumber;
       }
     }
     if (operations2.length > 0) {
@@ -2523,13 +3302,19 @@ var ClientSession = class {
       type: "acknowledgment",
       messageId: generateUUIDv74(),
       acknowledgedMessageId: msg.messageId,
-      lastSequenceNumber: lastOp ? lastOp.sequenceNumber : 0
+      lastSequenceNumber: lastOp ? Math.min(acknowledgedThrough, lastOp.sequenceNumber) : 0
     };
     this.sendToClient(ack);
     if (applied.length > 0) {
       this.onRelay?.(this.sessionId, applied);
     }
   }
+  transformForServerSchema(op) {
+    if (op.schemaVersion === this.schemaVersion) {
+      return op;
+    }
+    return applyOperationTransforms(op, this.schemaVersion, this.operationTransforms);
+  }
   async sendDelta(clientVector) {
     const serverVector = this.store.getVersionVector();
     const missing = [];
@@ -2537,8 +3322,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) {
@@ -2590,11 +3378,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);
@@ -2612,6 +3500,25 @@ var ClientSession = class {
     };
     this.sendToClient(errorMsg);
   }
+  /**
+   * Reject one specific client operation, tied to its id, so the submitter can
+   * divert it out of its pending queue into a durable rejected store rather than
+   * losing it or retrying forever. The op is NOT materialized, so no other
+   * replica ever sees it.
+   */
+  sendOperationRejected(op, code, message, retriable) {
+    const rejectedMsg = {
+      type: "operation-rejected",
+      messageId: generateUUIDv74(),
+      operationId: op.id,
+      collection: op.collection,
+      recordId: op.recordId,
+      code,
+      message,
+      retriable
+    };
+    this.sendToClient(rejectedMsg);
+  }
   setSerializerWireFormat(format) {
     if (typeof this.serializer.setWireFormat === "function") {
       this.serializer.setWireFormat(format);
@@ -2620,6 +3527,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);
   }
@@ -2632,7 +3540,7 @@ function selectWireFormat(supportedWireFormats) {
 }
 
 // src/server/kora-sync-server.ts
-import { SyncError as SyncError4, generateUUIDv7 as generateUUIDv76, isBlobRef } from "@korajs/core";
+import { SyncError as SyncError4, generateUUIDv7 as generateUUIDv77, isBlobRef } from "@korajs/core";
 import { SimpleEventEmitter } from "@korajs/core/internal";
 import { JsonMessageSerializer as JsonMessageSerializer2 } from "@korajs/sync";
 
@@ -2992,21 +3900,421 @@ var YjsDocRelay = class {
   }
 };
 
+// src/server/route-context.ts
+import {
+  HybridLogicalClock as HybridLogicalClock3,
+  createOperation as createOperation2,
+  generateUUIDv7 as generateUUIDv76,
+  isAtomicOp,
+  resolveAtomicOp,
+  toAtomicOp
+} from "@korajs/core";
+
+// src/apply/route-predicate.ts
+function evaluateField(actual, operators) {
+  if ("$eq" in operators && !Object.is(actual, operators.$eq)) {
+    return false;
+  }
+  if ("$ne" in operators && Object.is(actual, operators.$ne)) {
+    return false;
+  }
+  if (operators.$in !== void 0 && !operators.$in.some((candidate) => Object.is(actual, candidate))) {
+    return false;
+  }
+  const numericChecks = [
+    ["$lt", (a, b) => a < b],
+    ["$lte", (a, b) => a <= b],
+    ["$gt", (a, b) => a > b],
+    ["$gte", (a, b) => a >= b]
+  ];
+  for (const [operator, compare] of numericChecks) {
+    const bound = operators[operator];
+    if (bound === void 0) {
+      continue;
+    }
+    if (typeof actual !== "number" || typeof bound !== "number") {
+      return false;
+    }
+    if (!compare(actual, bound)) {
+      return false;
+    }
+  }
+  return true;
+}
+function evaluateRoutePredicate(record, predicate) {
+  const fields = Object.keys(predicate);
+  if (fields.length === 0) {
+    return true;
+  }
+  if (record === null) {
+    return false;
+  }
+  for (const field of fields) {
+    const operators = predicate[field];
+    if (operators && !evaluateField(record[field], operators)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/server/route-context.ts
+function recordMatchesScope(collection, record, scope) {
+  const collectionScope = scope[collection];
+  if (!collectionScope) {
+    return false;
+  }
+  for (const [field, expected] of Object.entries(collectionScope)) {
+    if (record[field] !== expected) {
+      return false;
+    }
+  }
+  return true;
+}
+function pickFields(record, keys) {
+  const picked = {};
+  for (const key of keys) {
+    if (key in record) {
+      picked[key] = record[key];
+    }
+  }
+  return picked;
+}
+async function buildRouteOperation(store, mutation, currentOverride, clockOverride) {
+  const nodeId = store.getNodeId();
+  const clock = clockOverride ?? new HybridLogicalClock3(nodeId);
+  const schemaVersion = store.getSchema()?.version ?? 1;
+  const sequenceNumber = nextServerSequenceNumber(store);
+  if (mutation.type === "insert") {
+    return createOperation2(
+      {
+        nodeId,
+        type: "insert",
+        collection: mutation.collection,
+        recordId: mutation.recordId ?? generateUUIDv76(),
+        data: mutation.data ?? {},
+        previousData: null,
+        sequenceNumber,
+        causalDeps: [],
+        schemaVersion
+      },
+      clock
+    );
+  }
+  if (!mutation.recordId) {
+    throw new RouteMutationError(
+      "MISSING_RECORD_ID",
+      `A ${mutation.type} mutation on "${mutation.collection}" requires a recordId.`
+    );
+  }
+  const current = currentOverride ? currentOverride.record : await store.findRecord(mutation.collection, mutation.recordId);
+  if (mutation.type === "update") {
+    const rawData = mutation.data ?? {};
+    const data = {};
+    const atomicOps = {};
+    for (const key of Object.keys(rawData)) {
+      const value = rawData[key];
+      if (isAtomicOp(value)) {
+        data[key] = resolveAtomicOp(current ? current[key] : void 0, value);
+        atomicOps[key] = toAtomicOp(value);
+      } else {
+        data[key] = value;
+      }
+    }
+    return createOperation2(
+      {
+        nodeId,
+        type: "update",
+        collection: mutation.collection,
+        recordId: mutation.recordId,
+        data,
+        previousData: current ? pickFields(current, Object.keys(rawData)) : {},
+        sequenceNumber,
+        causalDeps: [],
+        schemaVersion,
+        ...Object.keys(atomicOps).length > 0 ? { atomicOps } : {}
+      },
+      clock
+    );
+  }
+  return createOperation2(
+    {
+      nodeId,
+      type: "delete",
+      collection: mutation.collection,
+      recordId: mutation.recordId,
+      data: null,
+      previousData: current ? { ...current } : null,
+      sequenceNumber,
+      causalDeps: [],
+      schemaVersion
+    },
+    clock
+  );
+}
+var RouteMutationError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "RouteMutationError";
+  }
+  code;
+};
+function createRouteContext(server, store) {
+  let mutationTail = Promise.resolve();
+  function serialize(work) {
+    const run = mutationTail.then(work, work);
+    mutationTail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  async function prepareMutation(mutation, scope) {
+    let op;
+    try {
+      op = await buildRouteOperation(store, mutation);
+    } catch (error) {
+      if (error instanceof RouteMutationError) {
+        return {
+          ok: false,
+          rejection: {
+            ok: false,
+            code: error.code,
+            message: error.message,
+            retriable: isRetriableRejection(error.code)
+          }
+        };
+      }
+      throw error;
+    }
+    if (scope && !operationMatchesScopes(op, scope)) {
+      return {
+        ok: false,
+        rejection: {
+          ok: false,
+          code: "SCOPE_VIOLATION",
+          message: `Mutation on "${mutation.collection}" is outside the provided scope.`,
+          retriable: isRetriableRejection("SCOPE_VIOLATION")
+        }
+      };
+    }
+    return { ok: true, op };
+  }
+  async function commitOperation(op, collection) {
+    const result = await server.applyLocalOperation(op);
+    if (result.result !== "applied") {
+      const code = result.rejection?.code ?? "NOT_APPLIED";
+      return {
+        ok: false,
+        code,
+        message: result.rejection?.message ?? `Operation on "${collection}" was not applied (${result.result}).`,
+        // Prefer the pipeline's own classification when present; fall back
+        // to classifying the code so this stays correct if new codes appear.
+        retriable: result.rejection?.retriable ?? isRetriableRejection(code)
+      };
+    }
+    const record = await store.findRecord(collection, op.recordId);
+    return { ok: true, operation: op, record };
+  }
+  async function rawApply(mutation, scope) {
+    const prepared = await prepareMutation(mutation, scope);
+    if (!prepared.ok) {
+      return prepared.rejection;
+    }
+    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(
+            spec.idempotencyKey.collection,
+            spec.idempotencyKey.id
+          );
+          if (existing) {
+            return { ok: true, idempotent: true, operations: [], records: [existing] };
+          }
+        }
+        if (spec.if && Object.keys(spec.if).length > 0) {
+          const target = await store.findRecord(spec.collection, spec.id);
+          if (!evaluateRoutePredicate(target, spec.if)) {
+            const code = spec.reject?.code ?? "CONDITION_NOT_MET";
+            return {
+              ok: false,
+              code,
+              message: spec.reject?.message ?? `Admission condition not met on "${spec.collection}" record "${spec.id}".`,
+              retriable: false
+            };
+          }
+        }
+        const mutations = [];
+        if (spec.update !== void 0 && spec.update !== null) {
+          mutations.push({
+            collection: spec.collection,
+            type: "update",
+            recordId: spec.id,
+            data: spec.update
+          });
+        }
+        if (spec.also) {
+          mutations.push(...spec.also);
+        }
+        const prepared = [];
+        for (const mutation of mutations) {
+          const p = await prepareMutation(mutation, options?.scope);
+          if (!p.ok) {
+            return p.rejection;
+          }
+          prepared.push({ op: p.op, collection: mutation.collection });
+        }
+        const operations2 = [];
+        const records = [];
+        for (const { op, collection } of prepared) {
+          const result = await commitOperation(op, collection);
+          if (!result.ok) {
+            return {
+              ok: false,
+              code: result.code,
+              message: result.message,
+              retriable: result.retriable
+            };
+          }
+          operations2.push(result.operation);
+          records.push(result.record);
+        }
+        return { ok: true, idempotent: false, operations: operations2, records };
+      });
+    },
+    async query(collection, options) {
+      const { scope, ...queryOptions } = options ?? {};
+      const records = await store.queryCollection(collection, queryOptions);
+      if (!scope) {
+        return records;
+      }
+      return records.filter((record) => recordMatchesScope(collection, record, scope));
+    },
+    async findById(collection, id, options) {
+      const record = await store.findRecord(collection, id);
+      if (!record) {
+        return null;
+      }
+      if (options?.scope && !recordMatchesScope(collection, record, options.scope)) {
+        return null;
+      }
+      return record;
+    }
+  };
+}
+
 // src/server/kora-sync-server.ts
 var DEFAULT_MAX_CONNECTIONS = 0;
 var DEFAULT_BATCH_SIZE2 = 100;
 var DEFAULT_SCHEMA_VERSION2 = 1;
 var DEFAULT_HOST = "0.0.0.0";
 var DEFAULT_PATH = "/";
-var KoraSyncServer = class {
+var DEFAULT_RELAY_RETRANSMIT_INTERVAL_MS = 2e3;
+var DEFAULT_DELIVERY_POLL_INTERVAL_MS = 2e3;
+function validateIntervalOption(name, value) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+    throw new SyncError4(`${name} must be a non-negative integer number of milliseconds`, {
+      [name]: value
+    });
+  }
+  return value;
+}
+var KoraSyncServer = class _KoraSyncServer {
   store;
   auth;
   serializer;
   emitter;
   maxConnections;
   batchSize;
+  relayRetransmitIntervalMs;
+  deliveryPollIntervalMs;
   schemaVersion;
   supportedSchemaVersions;
+  operationTransforms;
   port;
   host;
   path;
@@ -3016,24 +4324,63 @@ var KoraSyncServer = class {
   yjsDocRelay = new YjsDocRelay();
   blobChunkRelay;
   persistBlobChunk;
+  maxOperationBytes;
+  maxOpsPerMinute;
+  validateOperation;
+  koraContext;
   sessions = /* @__PURE__ */ new Map();
   httpClients = /* @__PURE__ */ new Map();
   httpSessionToClient = /* @__PURE__ */ new Map();
-  serverVersion = "0.4.0";
+  // Informational value reported by getStatus(). Keep in sync with the
+  // @korajs/server package version on release; it is not used for protocol negotiation.
+  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;
+  deliveryPollTimer = null;
+  lastObservedDeliverySequence = 0;
+  deliveryPollInFlight = false;
+  /**
+   * 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;
+    const storeSchemaVersion = this.store.getSchema()?.version;
+    if (config.schemaVersion !== void 0 && storeSchemaVersion !== void 0 && config.schemaVersion !== storeSchemaVersion) {
+      throw new SyncError4("Sync schema version does not match the configured store schema.", {
+        syncSchemaVersion: config.schemaVersion,
+        storeSchemaVersion
+      });
+    }
     this.auth = config.auth ?? null;
     this.serializer = config.serializer ?? new JsonMessageSerializer2();
     this.emitter = config.emitter ?? null;
     this.maxConnections = config.maxConnections ?? DEFAULT_MAX_CONNECTIONS;
     this.batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE2;
-    this.schemaVersion = config.schemaVersion ?? DEFAULT_SCHEMA_VERSION2;
+    this.relayRetransmitIntervalMs = validateIntervalOption(
+      "relayRetransmitIntervalMs",
+      config.relayRetransmitIntervalMs ?? DEFAULT_RELAY_RETRANSMIT_INTERVAL_MS
+    );
+    this.deliveryPollIntervalMs = validateIntervalOption(
+      "deliveryPollIntervalMs",
+      config.deliveryPollIntervalMs ?? DEFAULT_DELIVERY_POLL_INTERVAL_MS
+    );
+    this.schemaVersion = config.schemaVersion ?? storeSchemaVersion ?? DEFAULT_SCHEMA_VERSION2;
     this.supportedSchemaVersions = config.supportedSchemaVersions ?? {
       min: this.schemaVersion,
       max: this.schemaVersion
     };
+    this.operationTransforms = config.operationTransforms ?? [];
     this.port = config.port;
     this.host = config.host ?? DEFAULT_HOST;
     this.path = config.path ?? DEFAULT_PATH;
@@ -3042,10 +4389,116 @@ var KoraSyncServer = class {
     this.metrics.setSchemaVersion(this.schemaVersion);
     this.blobChunkRelay = new BlobChunkRelay(config.resolveBlobChunk);
     this.persistBlobChunk = config.persistBlobChunk ?? null;
+    this.maxOperationBytes = config.maxOperationBytes;
+    this.maxOpsPerMinute = config.maxOpsPerMinute;
+    this.validateOperation = config.validateOperation;
+    this.koraContext = createRouteContext(this, this.store);
     if (!this.emitter) {
       this.emitter = new SimpleEventEmitter();
     }
   }
+  ensureBackgroundTimersStarted() {
+    if (this.relayRetransmitIntervalMs > 0 && !this.relayRetransmitTimer) {
+      this.relayRetransmitTimer = setInterval(() => {
+        this.retransmitPendingRelays(this.relayRetransmitIntervalMs);
+      }, this.relayRetransmitIntervalMs);
+      this.relayRetransmitTimer.unref?.();
+    }
+    if (this.deliveryPollIntervalMs > 0 && !this.deliveryPollTimer) {
+      this.deliveryPollTimer = setInterval(() => {
+        void this.pollDeliveryLog();
+      }, this.deliveryPollIntervalMs);
+      this.deliveryPollTimer.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();
+  }
+  /**
+   * Check whether the authoritative delivery log advanced without passing through
+   * this server instance, then wake delivery-watermark sessions to scan from their
+   * own acknowledged cursors. Session-level filtering remains the only fan-out path.
+   */
+  async pollDeliveryLog() {
+    if (this.deliveryPollInFlight) return;
+    this.deliveryPollInFlight = true;
+    try {
+      const maxDeliverySequence = await this.store.getMaxDeliverySequence();
+      if (maxDeliverySequence <= this.lastObservedDeliverySequence) {
+        for (const session of this.sessions.values()) {
+          session.pushDeliveryStreamIfSupported(this.deliveryPollIntervalMs, {
+            trackStall: true
+          });
+        }
+        return;
+      }
+      this.lastObservedDeliverySequence = maxDeliverySequence;
+      for (const session of this.sessions.values()) {
+        session.pushDeliveryStreamIfSupported(0);
+      }
+    } catch (error) {
+      this.logger.log({
+        timestamp: Date.now(),
+        level: "warn",
+        event: "delivery_poll.failed",
+        details: { error: error instanceof Error ? error.message : String(error) }
+      });
+    } finally {
+      this.deliveryPollInFlight = false;
+    }
+  }
+  /**
+   * 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`).
+   * Shared with the production server so HTTP routes, the operation validator,
+   * and `server.kora` are all the same object over the same pipeline.
+   */
+  getKoraContext() {
+    return this.koraContext;
+  }
   /**
    * Subscribe to session-level events for metrics collection and logging.
    * Called when a new session is created.
@@ -3094,6 +4547,21 @@ var KoraSyncServer = class {
         details: { reason: event.reason }
       });
     });
+    sessionEmitter.on("sync:schema-mismatch", (event) => {
+      this.logger.log({
+        timestamp: Date.now(),
+        level: "warn",
+        event: "session.schema_mismatch",
+        sessionId,
+        details: {
+          clientSchemaVersion: event.clientSchemaVersion,
+          serverSchemaVersion: event.serverSchemaVersion,
+          supportedMin: event.supportedMin,
+          supportedMax: event.supportedMax,
+          reason: event.reason
+        }
+      });
+    });
   }
   /**
    * Get the metrics collector for external access (e.g., HTTP endpoints).
@@ -3163,6 +4631,15 @@ var KoraSyncServer = class {
       event: "server.stopping",
       details: { connectedClients: this.sessions.size }
     });
+    if (this.relayRetransmitTimer) {
+      clearInterval(this.relayRetransmitTimer);
+      this.relayRetransmitTimer = null;
+    }
+    if (this.deliveryPollTimer) {
+      clearInterval(this.deliveryPollTimer);
+      this.deliveryPollTimer = null;
+    }
+    this.orphanedRelaysByNode.clear();
     this.awarenessRelay.clear();
     this.yjsDocRelay.clear();
     this.blobChunkRelay.clear();
@@ -3227,7 +4704,7 @@ var KoraSyncServer = class {
     if (this.maxConnections > 0 && this.sessions.size >= this.maxConnections) {
       transport.send({
         type: "error",
-        messageId: generateUUIDv76(),
+        messageId: generateUUIDv77(),
         code: "MAX_CONNECTIONS",
         message: `Server has reached maximum connections (${this.maxConnections})`,
         retriable: true
@@ -3245,7 +4722,8 @@ var KoraSyncServer = class {
         max: this.maxConnections
       });
     }
-    const sessionId = generateUUIDv76();
+    this.ensureBackgroundTimersStarted();
+    const sessionId = generateUUIDv77();
     this.metrics.recordConnection(sessionId);
     const sessionEmitter = new SimpleEventEmitter();
     sessionEmitter.on("sync:connected", (event) => {
@@ -3291,6 +4769,33 @@ var KoraSyncServer = class {
         sessionId
       });
     });
+    sessionEmitter.on("sync:schema-mismatch", (event) => {
+      this.logger.log({
+        timestamp: Date.now(),
+        level: "warn",
+        event: "session.schema_mismatch",
+        sessionId,
+        details: {
+          clientSchemaVersion: event.clientSchemaVersion,
+          serverSchemaVersion: event.serverSchemaVersion,
+          supportedMin: event.supportedMin,
+          supportedMax: event.supportedMax,
+          reason: event.reason
+        }
+      });
+    });
+    sessionEmitter.on("sync:delivery-stalled", (event) => {
+      this.logger.log({
+        timestamp: Date.now(),
+        level: "warn",
+        event: "session.delivery_stalled",
+        sessionId,
+        details: {
+          watermark: event.watermark,
+          repeatCount: event.repeatCount
+        }
+      });
+    });
     const session = new ClientSession({
       sessionId,
       transport,
@@ -3298,9 +4803,11 @@ 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,
+      operationTransforms: this.operationTransforms,
       onRelay: (sourceSessionId, operations2) => {
         this.handleRelay(sourceSessionId, operations2);
       },
@@ -3317,9 +4824,18 @@ var KoraSyncServer = class {
         this.blobChunkRelay.handleResponse(sourceSessionId, message);
       },
       ...this.persistBlobChunk ? { persistBlobChunk: this.persistBlobChunk } : {},
+      // Only forward when configured, so an unset server value leaves the
+      // session on its own documented default rather than `undefined`.
+      ...this.maxOperationBytes !== void 0 ? { maxOperationBytes: this.maxOperationBytes } : {},
+      ...this.maxOpsPerMinute !== void 0 ? { maxOpsPerMinute: this.maxOpsPerMinute } : {},
+      ...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);
@@ -3379,6 +4895,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.
    *
@@ -3577,159 +5109,6 @@ function createKoraServer(config) {
   return new KoraSyncServer(config);
 }
 
-// src/server/route-context.ts
-import { HybridLogicalClock as HybridLogicalClock2, createOperation as createOperation2, generateUUIDv7 as generateUUIDv77 } from "@korajs/core";
-function recordMatchesScope(collection, record, scope) {
-  const collectionScope = scope[collection];
-  if (!collectionScope) {
-    return false;
-  }
-  for (const [field, expected] of Object.entries(collectionScope)) {
-    if (record[field] !== expected) {
-      return false;
-    }
-  }
-  return true;
-}
-function pickFields(record, keys) {
-  const picked = {};
-  for (const key of keys) {
-    if (key in record) {
-      picked[key] = record[key];
-    }
-  }
-  return picked;
-}
-async function buildRouteOperation(store, mutation) {
-  const nodeId = store.getNodeId();
-  const clock = new HybridLogicalClock2(nodeId);
-  const schemaVersion = store.getSchema()?.version ?? 1;
-  const sequenceNumber = nextServerSequenceNumber(store);
-  if (mutation.type === "insert") {
-    return createOperation2(
-      {
-        nodeId,
-        type: "insert",
-        collection: mutation.collection,
-        recordId: mutation.recordId ?? generateUUIDv77(),
-        data: mutation.data ?? {},
-        previousData: null,
-        sequenceNumber,
-        causalDeps: [],
-        schemaVersion
-      },
-      clock
-    );
-  }
-  if (!mutation.recordId) {
-    throw new RouteMutationError(
-      "MISSING_RECORD_ID",
-      `A ${mutation.type} mutation on "${mutation.collection}" requires a recordId.`
-    );
-  }
-  const current = await store.findRecord(mutation.collection, mutation.recordId);
-  if (mutation.type === "update") {
-    const data = mutation.data ?? {};
-    return createOperation2(
-      {
-        nodeId,
-        type: "update",
-        collection: mutation.collection,
-        recordId: mutation.recordId,
-        data,
-        previousData: current ? pickFields(current, Object.keys(data)) : {},
-        sequenceNumber,
-        causalDeps: [],
-        schemaVersion
-      },
-      clock
-    );
-  }
-  return createOperation2(
-    {
-      nodeId,
-      type: "delete",
-      collection: mutation.collection,
-      recordId: mutation.recordId,
-      data: null,
-      previousData: current ? { ...current } : null,
-      sequenceNumber,
-      causalDeps: [],
-      schemaVersion
-    },
-    clock
-  );
-}
-var RouteMutationError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "RouteMutationError";
-  }
-  code;
-};
-function createRouteContext(server, store) {
-  let mutationTail = Promise.resolve();
-  function serialize(work) {
-    const run = mutationTail.then(work, work);
-    mutationTail = run.then(
-      () => void 0,
-      () => void 0
-    );
-    return run;
-  }
-  return {
-    apply(mutation, options) {
-      return serialize(async () => {
-        let op;
-        try {
-          op = await buildRouteOperation(store, mutation);
-        } catch (error) {
-          if (error instanceof RouteMutationError) {
-            return { ok: false, code: error.code, message: error.message };
-          }
-          throw error;
-        }
-        if (options?.scope && !operationMatchesScopes(op, options.scope)) {
-          return {
-            ok: false,
-            code: "SCOPE_VIOLATION",
-            message: `Mutation on "${mutation.collection}" is outside the provided scope.`
-          };
-        }
-        const result = await server.applyLocalOperation(op);
-        if (result.result !== "applied") {
-          return {
-            ok: false,
-            code: result.rejection?.code ?? "NOT_APPLIED",
-            message: result.rejection?.message ?? `Operation on "${mutation.collection}" was not applied (${result.result}).`
-          };
-        }
-        const record = await store.findRecord(mutation.collection, op.recordId);
-        return { ok: true, operation: op, record };
-      });
-    },
-    async query(collection, options) {
-      const { scope, ...queryOptions } = options ?? {};
-      const records = await store.queryCollection(collection, queryOptions);
-      if (!scope) {
-        return records;
-      }
-      return records.filter((record) => recordMatchesScope(collection, record, scope));
-    },
-    async findById(collection, id, options) {
-      const record = await store.findRecord(collection, id);
-      if (!record) {
-        return null;
-      }
-      if (options?.scope && !recordMatchesScope(collection, record, options.scope)) {
-        return null;
-      }
-      return record;
-    }
-  };
-}
-
 // src/server/production-server.ts
 var MIME_TYPES = {
   ".html": "text/html",
@@ -3749,12 +5128,13 @@ 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,
     ...config.syncOptions
   });
-  const routeContext = createRouteContext(syncServer, config.store);
+  const routeContext = syncServer.getKoraContext();
   let httpServer = null;
   function getOperationalToken(kind) {
     const auth = config.operationalAuth;
@@ -3894,6 +5274,10 @@ function createProductionServer(config) {
     res.end(JSON.stringify(result.body ?? null));
   }
   return {
+    kora: routeContext,
+    getLiveBlobRefs() {
+      return syncServer.getLiveBlobRefs();
+    },
     async start() {
       const { createServer } = await import("http");
       const { createReadStream, existsSync, statSync } = await import("fs");
@@ -3915,7 +5299,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();
@@ -4089,8 +5473,13 @@ data: ${JSON.stringify(s)}
           socket.destroy();
         }
       });
-      return new Promise((resolve2) => {
+      return new Promise((resolve2, reject) => {
+        const onError = (error) => {
+          reject(error);
+        };
+        httpServer?.once("error", onError);
         httpServer?.listen(port, "0.0.0.0", () => {
+          httpServer?.off("error", onError);
           resolve2(`http://localhost:${port}`);
         });
       });
@@ -4185,6 +5574,7 @@ function formatUptime(ms) {
 export {
   AwarenessRelay,
   ClientSession,
+  DEFAULT_MAX_SCOPE_PREDICATE_VALUES,
   HttpServerTransport,
   KoraAuthProvider,
   KoraSyncServer,
@@ -4192,6 +5582,7 @@ export {
   MixedAuthProvider,
   NoAuthProvider,
   PostgresServerStore,
+  RETRIABLE_REJECTION_CODES,
   SqliteServerStore,
   TokenAuthProvider,
   WsServerTransport,
@@ -4202,6 +5593,9 @@ export {
   createPrettyLogger,
   createProductionServer,
   createSilentLogger,
-  createSqliteServerStore
+  createSqliteServerStore,
+  isRetriableRejection,
+  normalizeScopeMap,
+  operationMatchesScopes
 };
 //# sourceMappingURL=index.js.map