@gonvex/client 0.5.2-staging.20 → 0.5.2-staging.21

package/dist/index.d.ts

@@ -421,8 +421,9 @@ export declare class GonvexClient {
     private hasAuthoritativeReplicaScope;
     private replicaReady;
     private replicaFrames;
+    private queuedReplicaWatermark?;
     private processedReplicaWatermarkRevision;
-    private readonly pendingReplicaTransactions;
+    private readonly pendingReplicaFrames;
     private readonly unsubscribeOutbox;
     private readonly sharedOutboxStore?;
     private readonly unsubscribePeerOutbox?;
@@ -639,8 +640,9 @@ export declare class GonvexClient {
     };
     private handleReplicaMessage;
     private enqueueReplicaFrame;
+    private enqueueReplicaWatermark;
     private enqueueReplicaTransaction;
-    private drainPendingReplicaTransactions;
+    private drainPendingReplicaFrames;
     private acceptReplicaReady;
     private handleReplicaWatermark;
     private emitReplicaMessage;

package/dist/index.js

@@ -213,8 +213,9 @@ export class GonvexClient {
     hasAuthoritativeReplicaScope = false;
     replicaReady = Promise.resolve();
     replicaFrames = Promise.resolve();
+    queuedReplicaWatermark;
     processedReplicaWatermarkRevision = 0;
-    pendingReplicaTransactions = [];
+    pendingReplicaFrames = [];
     unsubscribeOutbox;
     sharedOutboxStore;
     unsubscribePeerOutbox;
@@ -507,7 +508,7 @@ export class GonvexClient {
                 if (subscription.socketGeneration !== undefined)
                     this.send({ type: "query.unsubscribe", id: subscription.id });
             }
-            this.pendingReplicaTransactions.length = 0;
+            this.pendingReplicaFrames.length = 0;
             await this.replica.clear(replicaScope);
             this.resetReplicaScopeState();
             this.rotateSubscriptionScopes();
@@ -951,17 +952,18 @@ export class GonvexClient {
             // A fully resident prediction reads the already published atomic replica.
             // Unrelated snapshots may still be persisting; waiting for those here
             // makes a small edit inherit their disk latency. The shared intent lock
-            // and journal still order every edit, and known peer changes must be
-            // reconciled before a resident prediction can be reused.
-            const reuseResident = preparedResult
-                && preparedResult.base === this.replica.executionVersion()
-                && preparedResult.pending === JSON.stringify(sharedPatches)
+            // and journal still order every edit. Preparation proves resident
+            // coverage, even when a published commit invalidates its result while
+            // acquiring the lock. Re-execute against the latest atomic resident
+            // snapshot below; only known peer changes or committed shared intents
+            // require synchronizing storage first.
+            const canExecuteResident = preparedResult
                 && !this.peerRefreshDirty && !this.peerRefreshScheduled
                 && !sharedEntries.some(entry => entry.state === "committed");
             const uncoveredRead = this.isUncoveredLocalRead(preparedFailure)
                 && !this.peerRefreshDirty && !this.peerRefreshScheduled
                 && !sharedEntries.some(entry => entry.state === "committed");
-            if (!reuseResident && !uncoveredRead)
+            if (!canExecuteResident && !uncoveredRead)
                 await this.replica.synchronizeStorage();
             if (sharedEntries)
                 this.replaceLocalPredictions(sharedEntries.filter(entry => entry.state !== "committed").map(entry => ({ commandId: entry.idempotencyKey, patches: entry.patches ?? [] })));
@@ -1246,7 +1248,7 @@ export class GonvexClient {
             || (hasOwn(auth, "identity") && !sameAuthTokenIdentity(this.auth, nextAuth));
         if (scopeMayChange) {
             this.pendingMessages.length = 0;
-            this.pendingReplicaTransactions.length = 0;
+            this.pendingReplicaFrames.length = 0;
             this.rejectPendingCalls((call) => new GonvexClientError(`Authentication scope changed while waiting for ${call.kind} ${call.path}`, { code: "superseded", path: call.path, operation: call.kind }));
             for (const query of this.oneShotQueries.values()) {
                 if (query.timeoutTimer)
@@ -1327,7 +1329,7 @@ export class GonvexClient {
             // drop them too — flushing them after reconnect would fire writes whose
             // callers already saw a rejection.
             this.pendingMessages.length = 0;
-            this.pendingReplicaTransactions.length = 0;
+            this.pendingReplicaFrames.length = 0;
             // Reducers/actions must fail closed on transport loss: silently
             // replaying a non-idempotent write after reconnect is unsafe, and
             // leaving the promise pending hangs the caller forever.
@@ -1390,7 +1392,7 @@ export class GonvexClient {
                     // subscription. Rotate their routing IDs immediately so delayed
                     // Replica errors from that discarded scope cannot reach current
                     // React listeners.
-                    this.pendingReplicaTransactions.length = 0;
+                    this.pendingReplicaFrames.length = 0;
                     this.quarantineReplicaScope();
                     this.activeAuthFrameId = undefined;
                     // If credentials are already being revalidated, that queued auth
@@ -1504,7 +1506,7 @@ export class GonvexClient {
                         // Replica partition has been activated locally. Only now may
                         // tenant calls and subscriptions leave the client.
                         this.authInFlight = false;
-                        this.drainPendingReplicaTransactions();
+                        this.drainPendingReplicaFrames();
                         // Authentication is replaced in-place on the same socket during
                         // normal token rotation. The runtime clears its subscription
                         // maps for every accepted auth frame, so same-generation Live
@@ -1519,7 +1521,7 @@ export class GonvexClient {
                     })
                         .catch((error) => {
                         this.authInFlight = false;
-                        this.pendingReplicaTransactions.length = 0;
+                        this.pendingReplicaFrames.length = 0;
                         this.settleManagedAuthAttempt(message.id, error instanceof Error ? error.message : "Runtime returned an invalid Local Replica scope");
                         this.rejectReplicaDirective(error);
                         this.flushPendingMessages();
@@ -1528,7 +1530,7 @@ export class GonvexClient {
                 }
                 else {
                     this.authInFlight = false;
-                    this.pendingReplicaTransactions.length = 0;
+                    this.pendingReplicaFrames.length = 0;
                     const fetcher = this.auth.fetchToken;
                     if (fetcher && !this.authRetriedAfterError) {
                         // The installed token was rejected — typically expired while the
@@ -1558,7 +1560,7 @@ export class GonvexClient {
                 // Replica frames carry no tenant/scope field. During auth renewal we
                 // cannot safely attribute a late frame to either side of the switch.
                 if (this.authInFlight) {
-                    this.pendingReplicaTransactions.push(message);
+                    this.pendingReplicaFrames.push(message);
                     return;
                 }
                 this.enqueueReplicaTransaction(message);
@@ -1570,7 +1572,11 @@ export class GonvexClient {
                     // stream. Keep both on the same client queue so a watermark cannot
                     // advance the cursor past a transaction that was received first but
                     // has not finished applying to durable Local Replica storage yet.
-                    this.enqueueReplicaFrame(() => this.handleReplicaWatermark(message.revision));
+                    if (this.authInFlight) {
+                        this.pendingReplicaFrames.push(message);
+                        return;
+                    }
+                    this.enqueueReplicaWatermark(message.revision);
                 }
                 return;
             }
@@ -2460,12 +2466,34 @@ export class GonvexClient {
         }
         this.emitReplicaMessage(subscription, message, scope);
     }
-    enqueueReplicaFrame(operation) {
+    enqueueReplicaFrame(operation, watermark = false) {
+        // Any entity/window frame seals the adjacent watermark batch. Advancing
+        // across that barrier could make an unapplied transaction look stale.
+        if (!watermark)
+            this.queuedReplicaWatermark = undefined;
         const processing = this.replicaFrames.then(operation);
         this.replicaFrames = processing.catch(() => {
             this.replica.setFreshness("verifying");
         });
     }
+    enqueueReplicaWatermark(revision) {
+        if (!Number.isSafeInteger(revision) || revision < 0)
+            return;
+        const pending = this.queuedReplicaWatermark;
+        if (pending && pending.scope === this.replicaScope) {
+            pending.revision = Math.max(pending.revision, revision);
+            return;
+        }
+        const batch = { revision, scope: this.replicaScope };
+        this.queuedReplicaWatermark = batch;
+        this.enqueueReplicaFrame(async () => {
+            if (this.queuedReplicaWatermark === batch)
+                this.queuedReplicaWatermark = undefined;
+            if (batch.scope !== this.replicaScope)
+                return;
+            await this.handleReplicaWatermark(batch.revision);
+        }, true);
+    }
     enqueueReplicaTransaction(message) {
         const scope = this.replicaScope;
         this.enqueueReplicaFrame(async () => {
@@ -2484,10 +2512,14 @@ export class GonvexClient {
             }
         });
     }
-    drainPendingReplicaTransactions() {
-        const pending = this.pendingReplicaTransactions.splice(0);
-        for (const message of pending)
-            this.enqueueReplicaTransaction(message);
+    drainPendingReplicaFrames() {
+        const pending = this.pendingReplicaFrames.splice(0);
+        for (const message of pending) {
+            if (message.type === "replica.transaction")
+                this.enqueueReplicaTransaction(message);
+            else
+                this.enqueueReplicaWatermark(message.revision);
+        }
     }
     async acceptReplicaReady(subscription, message, hashes, hashesWereStored, scope = this.replicaScope) {
         this.clearReplicaRetry(subscription, true);
@@ -2532,12 +2564,9 @@ export class GonvexClient {
             return;
         const eligibleSignatures = [];
         for (const subscription of this.replicaSubscriptions.values()) {
-            const cursor = this.replica.getWindow(subscription.key)?.cursor;
-            if (!cursor
-                || cursor.revision >= revision
-                || !subscription.isUpToDate
+            if (!subscription.isUpToDate
                 || subscription.opening
-                || !this.replica.getWindow(subscription.key)?.hashes)
+                || !this.replica.windowCanAdvance(subscription.key, revision))
                 continue;
             eligibleSignatures.push(subscription.key);
         }