@pylonsync/sync 0.3.184 → 0.3.186

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.184",
+  "version": "0.3.186",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -1598,23 +1598,38 @@ export class SyncEngine {
     this.lastSeenToken = tokenNow;
 
     try {
-      const resp = await this.request<PullResponse>(
-        "GET",
-        `/api/sync/pull?since=${this.cursor.last_seq}`
-      );
-      // Successful response — clear the 410 circuit breaker.
-      this.consecutive_410s = 0;
-      // Route through the apply queue so concurrent WS messages and
-      // pull responses don't race. The queue's monotonic guard skips
-      // any seq we've already applied (e.g. WS already landed the
-      // events that pull is now redelivering) and only advances the
-      // cursor forward. We still advance even when no changes land,
-      // because the server's last_seq may have moved past us due to
-      // policy-filtered events.
-      await this.enqueueApply(resp.changes, resp.cursor);
-      // If there are more, pull again immediately.
-      if (resp.has_more) {
-        await this.pull();
+      // Snapshot pagination: when the cursor is 0 and the server's
+      // table is larger than a single batch, the response carries
+      // `snapshot_after` for the next page. Loop until exhausted
+      // BEFORE returning so a fresh client always observes a
+      // consistent full snapshot, not a 1k-row prefix it mistakes
+      // for the whole replica.
+      let snapshotAfter: string | undefined;
+      let firstPass = true;
+      while (firstPass || snapshotAfter) {
+        firstPass = false;
+        const params = new URLSearchParams();
+        params.set("since", String(this.cursor.last_seq));
+        if (snapshotAfter) {
+          params.set("snapshot_after", snapshotAfter);
+        }
+        const resp = await this.request<
+          PullResponse & { snapshot_after?: string | null }
+        >("GET", `/api/sync/pull?${params.toString()}`);
+        this.consecutive_410s = 0;
+        await this.enqueueApply(resp.changes, resp.cursor);
+        // `snapshot_after` is only set when the server is mid-snapshot.
+        // Continue paginating in the same loop iteration so we don't
+        // leave a fresh client with a partial replica.
+        snapshotAfter = resp.snapshot_after ?? undefined;
+        // The change-log tail also paginates via `has_more` — handle
+        // that one recursively after the snapshot loop completes so
+        // backpressure on the change-log path uses the existing
+        // tail-pull semantics.
+        if (!snapshotAfter && resp.has_more) {
+          await this.pull();
+          break;
+        }
       }
     } catch (err) {
       // Swallow network + transient errors so the poll/reconnect loop
@@ -1735,6 +1750,13 @@ export class SyncEngine {
     // bypass the tombstone — re-creation server-side still propagates.
     const tombstoneSeq = this.cursor.last_seq;
     for (const entity of names) {
+      // Capture cursor BEFORE the fetch so we can detect drift mid-
+      // reconcile. If a WS event lands while this entity is being
+      // pulled, our snapshot is already stale — applying it would
+      // overwrite a newer authoritative row. Skip apply in that case
+      // and rely on the WS event (which has the correct seq) plus the
+      // next reconcile trigger to converge. Codex P1.
+      const cursorBeforeFetch = this.cursor.last_seq;
       let serverRows: Row[];
       try {
         serverRows = await this.fetchEntityRows(entity);
@@ -1750,6 +1772,15 @@ export class SyncEngine {
         }
         continue;
       }
+      if (this.cursor.last_seq !== cursorBeforeFetch) {
+        // Cursor moved during fetch — at least one WS event for this
+        // (or another) entity landed and might have a fresher value
+        // for a row our snapshot just captured. Bail out for this
+        // entity; reconcile() is triggered again on visibility-change
+        // and reconnect, and the WS event already carried the latest
+        // state for the affected row.
+        continue;
+      }
       await this.applyEntityReconcile(entity, serverRows, tombstoneSeq);
     }
   }