@korajs/sync 0.6.0 → 1.0.0-beta.0

package/dist/index.js

@@ -17,6 +17,7 @@ var SYNC_STATUSES = [
   "syncing",
   "synced",
   "offline",
+  "clock-error",
   "error",
   "schema-mismatch"
 ];
@@ -263,7 +264,7 @@ function isYjsDocUpdateMessage(value) {
 
 // src/protocol/serializer.ts
 import { SyncError } from "@korajs/core";
-import protobuf from "protobufjs/minimal";
+import protobuf from "protobufjs/minimal.js";
 var { Reader, Writer } = protobuf;
 function versionVectorToWire(vector) {
   const wire = {};
@@ -499,7 +500,8 @@ function toProtoEnvelope(message) {
         schemaVersion: message.schemaVersion,
         accepted: message.accepted,
         rejectReason: message.rejectReason,
-        selectedWireFormat: message.selectedWireFormat
+        selectedWireFormat: message.selectedWireFormat,
+        serverTime: message.serverTime
       };
     case "operation-batch":
       return {
@@ -559,7 +561,10 @@ function fromProtoEnvelope(envelope) {
         schemaVersion: envelope.schemaVersion ?? 0,
         accepted: envelope.accepted ?? false,
         rejectReason: envelope.rejectReason,
-        selectedWireFormat: envelope.selectedWireFormat === "json" || envelope.selectedWireFormat === "protobuf" ? envelope.selectedWireFormat : void 0
+        selectedWireFormat: envelope.selectedWireFormat === "json" || envelope.selectedWireFormat === "protobuf" ? envelope.selectedWireFormat : void 0,
+        // Preserve the server's wall-clock time so clock-skew detection and
+        // automatic timestamp rebase work over the protobuf wire, not just JSON.
+        ...envelope.serverTime !== void 0 ? { serverTime: envelope.serverTime } : {}
       };
     case "operation-batch":
       return {
@@ -728,6 +733,7 @@ function encodeEnvelope(envelope) {
     writer.uint32(138).string(envelope.errorMessage);
   }
   if (envelope.retriable !== void 0) writer.uint32(144).bool(envelope.retriable);
+  if (envelope.serverTime !== void 0) writer.uint32(152).int64(envelope.serverTime);
   return writer.finish();
 }
 function decodeEnvelope(bytes) {
@@ -796,6 +802,9 @@ function decodeEnvelope(bytes) {
       case 18:
         envelope.retriable = reader.bool();
         break;
+      case 19:
+        envelope.serverTime = longToNumber(reader.int64());
+        break;
       default:
         reader.skipType(tag & 7);
     }
@@ -1297,7 +1306,7 @@ var ChaosTransport = class {
   random;
   messageHandler = null;
   reorderBuffer = [];
-  timers = [];
+  pending = [];
   constructor(inner, config) {
     this.inner = inner;
     this.dropRate = config?.dropRate ?? 0;
@@ -1312,10 +1321,14 @@ var ChaosTransport = class {
   }
   async disconnect() {
     this.flushReorderBuffer();
-    for (const timer of this.timers) {
+    const flushed = this.pending;
+    this.pending = [];
+    for (const { timer } of flushed) {
       clearTimeout(timer);
     }
-    this.timers = [];
+    for (const { message } of flushed) {
+      this.deliverIncoming(message);
+    }
     return this.inner.disconnect();
   }
   send(message) {
@@ -1352,9 +1365,10 @@ var ChaosTransport = class {
     if (this.maxLatency > 0) {
       const delay = Math.floor(this.random() * this.maxLatency);
       const timer = setTimeout(() => {
+        this.pending = this.pending.filter((p) => p.timer !== timer);
         this.deliverIncoming(message);
       }, delay);
-      this.timers.push(timer);
+      this.pending.push({ timer, message });
       return;
     }
     this.deliverIncoming(message);
@@ -2249,6 +2263,41 @@ var OutboundQueue = class {
   peek(count) {
     return this.queue.slice(0, count);
   }
+  /**
+   * All queued operations (not counting in-flight), in causal order.
+   */
+  getAll() {
+    return [...this.queue];
+  }
+  /**
+   * Atomically replace the entire queue with a new set of operations.
+   *
+   * Used after a timestamp rebase rewrote the queued operations under new
+   * content-addressed ids: the old entries must vanish from memory AND from
+   * persistent storage in one step, or a page refresh could resurrect
+   * stale-stamped ops the server would reject. Resets the seen set to exactly
+   * the new ids so the rewritten ops are not treated as duplicates.
+   */
+  async replaceAll(ops) {
+    const removeIds = this.queue.map((op) => op.id);
+    for (const batch of this.inFlight.values()) {
+      for (const op of batch) {
+        removeIds.push(op.id);
+      }
+    }
+    this.inFlight.clear();
+    this.queue = ops.length > 1 ? topologicalSort([...ops]) : [...ops];
+    this.seen.clear();
+    for (const op of this.queue) {
+      this.seen.add(op.id);
+    }
+    if (removeIds.length > 0) {
+      await this.storage.dequeue(removeIds);
+    }
+    for (const op of this.queue) {
+      await this.storage.enqueue(op);
+    }
+  }
   /**
    * Whether initialize() has been called.
    */
@@ -2310,6 +2359,8 @@ var SyncEngine = class {
   currentBatch = null;
   reconnecting = false;
   schemaBlocked = false;
+  clockBlocked = false;
+  clockSkewMs = null;
   // Track delta exchange state
   deltaBatchesReceived = 0;
   deltaReceiveComplete = false;
@@ -2483,10 +2534,17 @@ var SyncEngine = class {
       lastSyncedAt: this.lastSyncedAt,
       lastSuccessfulPush: this.lastSuccessfulPush,
       lastSuccessfulPull: this.lastSuccessfulPull,
-      conflicts: this.conflictCount
+      conflicts: this.conflictCount,
+      clockSkewMs: this.clockSkewMs
     };
     switch (this.state) {
       case "disconnected":
+        if (this.clockBlocked) {
+          return { ...base, status: "clock-error" };
+        }
+        if (this.schemaBlocked) {
+          return { ...base, status: "schema-mismatch" };
+        }
         return { ...base, status: "offline" };
       case "connecting":
       case "handshaking":
@@ -2495,6 +2553,9 @@ var SyncEngine = class {
       case "streaming":
         return { ...base, status: pendingOperations > 0 ? "syncing" : "synced" };
       case "error":
+        if (this.clockBlocked) {
+          return { ...base, status: "clock-error" };
+        }
         return { ...base, status: this.schemaBlocked ? "schema-mismatch" : "error" };
     }
   }
@@ -2505,6 +2566,27 @@ var SyncEngine = class {
   isSchemaBlocked() {
     return this.schemaBlocked;
   }
+  /**
+   * True when sync is blocked because this device's clock is too far ahead.
+   * Local writes continue to work and queue; only sync is paused.
+   */
+  isClockBlocked() {
+    return this.clockBlocked;
+  }
+  /** serverTime - localTime measured at the last handshake, or null before first connect. */
+  getClockSkewMs() {
+    return this.clockSkewMs;
+  }
+  /**
+   * Clears the clock block after the user corrects the device clock.
+   * Moves the engine back to `disconnected` so `start()` can run again.
+   */
+  clearClockBlock() {
+    this.clockBlocked = false;
+    if (this.state === "error") {
+      this.transitionTo("disconnected");
+    }
+  }
   /**
    * Clears schema-mismatch block after upgrading the local schema / sync config.
    * Moves the engine back to `disconnected` so `start()` can run again.
@@ -2648,7 +2730,7 @@ var SyncEngine = class {
   async handleMessageAsync(message) {
     switch (message.type) {
       case "handshake-response":
-        this.handleHandshakeResponse(message);
+        await this.handleHandshakeResponse(message);
         break;
       case "operation-batch":
         await this.handleOperationBatch(message);
@@ -2671,8 +2753,41 @@ var SyncEngine = class {
     const reason = error instanceof Error ? error.message : "Message handling failed";
     this.handleTransportClose(reason);
   }
-  handleHandshakeResponse(msg) {
+  /**
+   * Compares server wall-clock time from the handshake with local time.
+   * Negative skew = this device's clock is fast (dangerous for LWW and rejected
+   * by server ingest beyond 60s). Positive skew = slow (accepted but surfaced).
+   * Zero developer work required: the result flows into sync status and events.
+   */
+  evaluateClockSkew(serverTime) {
+    const skewMs = serverTime - Date.now();
+    this.clockSkewMs = skewMs;
+    const FAST_BLOCK_MS = 6e4;
+    const SLOW_WARN_MS = 10 * 6e4;
+    let severity = "info";
+    if (skewMs < -FAST_BLOCK_MS) {
+      severity = "fast-blocked";
+    } else if (skewMs > SLOW_WARN_MS) {
+      severity = "slow-warning";
+    }
+    this.emitter?.emit({ type: "sync:clock-skew", skewMs, severity, source: "handshake" });
+    if (severity === "fast-blocked") {
+      this.clockBlocked = true;
+    } else {
+      this.clockBlocked = false;
+    }
+  }
+  async handleHandshakeResponse(msg) {
     if (this.state !== "handshaking") return;
+    if (typeof msg.serverTime === "number") {
+      this.evaluateClockSkew(msg.serverTime);
+      if (this.clockBlocked) {
+        this.metricsCollector.updateStatus("error");
+        this.transitionTo("error");
+        void this.transport.disconnect();
+        return;
+      }
+    }
     if (!msg.accepted) {
       const reason = msg.rejectReason ?? "Handshake rejected";
       if (isSchemaMismatchReject(msg.rejectReason)) {
@@ -2719,8 +2834,51 @@ var SyncEngine = class {
     this.deltaSentOpIds = [];
     this.pendingDeltaBatchAcks.clear();
     this.initialSyncTotalBatches = 0;
+    if (typeof msg.serverTime === "number") {
+      await this.maybeRebaseQueuedOperations(msg.serverTime);
+    }
     this.sendDelta();
   }
+  /**
+   * Re-stamps queued (never-acknowledged) operations whose timestamps are far
+   * enough in the future that the server would reject them, using the server's
+   * own handshake time as the trusted "now". This is the automatic recovery
+   * path after a user corrects a fast device clock: the queue drains
+   * immediately instead of waiting for real time to catch up.
+   */
+  async maybeRebaseQueuedOperations(serverTime) {
+    const rebase = this.store.rebaseUnsyncedOperations?.bind(this.store);
+    if (!rebase) return;
+    const queued = this.outboundQueue.getAll();
+    if (queued.length === 0) return;
+    let maxQueuedWallTime = Number.NEGATIVE_INFINITY;
+    for (const op of queued) {
+      if (op.timestamp.wallTime > maxQueuedWallTime) {
+        maxQueuedWallTime = op.timestamp.wallTime;
+      }
+    }
+    const SERVER_FUTURE_TOLERANCE_MS = 6e4;
+    if (maxQueuedWallTime <= serverTime + SERVER_FUTURE_TOLERANCE_MS) return;
+    try {
+      const result = await rebase(
+        queued.map((op) => op.id),
+        serverTime
+      );
+      await this.outboundQueue.replaceAll(result.operations);
+      this.emitter?.emit({
+        type: "sync:clock-rebase",
+        rebasedCount: result.rebasedCount,
+        maxSkewMs: maxQueuedWallTime - serverTime
+      });
+    } catch (error) {
+      this.emitter?.emit({
+        type: "store:persistence-error",
+        dbName: "kora-oplog",
+        message: error instanceof Error ? error.message : "Timestamp rebase failed",
+        code: "CLOCK_REBASE_FAILED"
+      });
+    }
+  }
   async sendDelta() {
     const localVector = this.store.getVersionVector();
     const allMissingOps = await this.collectDelta(localVector, this.remoteVector);
@@ -2900,6 +3058,17 @@ var SyncEngine = class {
     if (msg.code === "AUTH_FAILED") {
       this.emitter?.emit({ type: "sync:auth-failed", reason: msg.message });
     }
+    if (msg.code === "INVALID_TIMESTAMP") {
+      this.clockBlocked = true;
+      this.emitter?.emit({
+        type: "sync:clock-skew",
+        skewMs: this.clockSkewMs ?? Number.NaN,
+        severity: "fast-blocked",
+        source: "server-reject"
+      });
+      this.emitter?.emit({ type: "sync:disconnected", reason: msg.message });
+      return;
+    }
     this.emitter?.emit({ type: "sync:disconnected", reason: msg.message });
     this.transitionTo("disconnected");
   }
@@ -3380,7 +3549,7 @@ var KeyDerivationError = class extends SyncError5 {
   }
 };
 var SALT_LENGTH = 32;
-var PBKDF2_ITERATIONS = 6e5;
+var DEFAULT_PBKDF2_ITERATIONS = 6e5;
 var DERIVED_KEY_LENGTH = 256;
 function assertCryptoAvailable() {
   if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle === "undefined") {
@@ -3397,13 +3566,19 @@ function generateSalt() {
   }
   return globalThis.crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
 }
-async function deriveKey(passphrase, salt) {
+async function deriveKey(passphrase, salt, iterations = DEFAULT_PBKDF2_ITERATIONS) {
   assertCryptoAvailable();
   if (passphrase.length === 0) {
     throw new KeyDerivationError(
       "Passphrase must not be empty. Provide a non-empty string for encryption key derivation."
     );
   }
+  if (!Number.isInteger(iterations) || iterations < 1) {
+    throw new KeyDerivationError(
+      `PBKDF2 iteration count must be a positive integer, received: ${iterations}`,
+      { iterations }
+    );
+  }
   const usedSalt = salt ?? generateSalt();
   try {
     const passphraseBytes = new TextEncoder().encode(passphrase);
@@ -3418,7 +3593,7 @@ async function deriveKey(passphrase, salt) {
       {
         name: "PBKDF2",
         salt: usedSalt,
-        iterations: PBKDF2_ITERATIONS,
+        iterations,
         hash: "SHA-256"
       },
       baseKey,
@@ -3438,13 +3613,13 @@ async function deriveKey(passphrase, salt) {
     );
   }
 }
-async function deriveVersionedKey(passphrase, version, salt) {
+async function deriveVersionedKey(passphrase, version, salt, iterations = DEFAULT_PBKDF2_ITERATIONS) {
   if (!Number.isInteger(version) || version < 1) {
     throw new KeyDerivationError(`Key version must be a positive integer, received: ${version}`, {
       version
     });
   }
-  const { key, salt: usedSalt } = await deriveKey(passphrase, salt);
+  const { key, salt: usedSalt } = await deriveKey(passphrase, salt, iterations);
   return { version, key, salt: usedSalt };
 }
 
@@ -3484,11 +3659,13 @@ var SyncEncryptor = class _SyncEncryptor {
    * @param config - Encryption configuration with passphrase
    * @param salt - Optional salt for deterministic key derivation (mainly for testing).
    *              If omitted, a random salt is generated.
+   * @param iterations - Optional PBKDF2 iteration count. Defaults to the
+   *              production-strength value. Lower it only in tests.
    * @returns A configured SyncEncryptor instance
    * @throws {EncryptionError} If configuration is invalid
    * @throws {KeyDerivationError} If key derivation fails
    */
-  static async create(config, salt) {
+  static async create(config, salt, iterations) {
     if (!config.enabled) {
       throw new EncryptionError(
         "Cannot create SyncEncryptor with encryption disabled. Set enabled: true in the encryption config."
@@ -3500,7 +3677,7 @@ var SyncEncryptor = class _SyncEncryptor {
         "Encryption key/passphrase must not be empty. Provide a non-empty string or key provider function."
       );
     }
-    const versionedKey = await deriveVersionedKey(passphrase, 1, salt);
+    const versionedKey = await deriveVersionedKey(passphrase, 1, salt, iterations);
     const keys = /* @__PURE__ */ new Map();
     keys.set(1, versionedKey);
     return new _SyncEncryptor(keys, 1);
@@ -3801,10 +3978,12 @@ var OFFLINE_SYNC_STATUS = Object.freeze({
   lastSyncedAt: null,
   lastSuccessfulPush: null,
   lastSuccessfulPull: null,
-  conflicts: 0
+  conflicts: 0,
+  clockSkewMs: null
 });
 var SYNC_STATUS_EVENT_TYPES = [
   "sync:connected",
+  "sync:clock-skew",
   "sync:disconnected",
   "sync:schema-mismatch",
   "sync:auth-failed",