@syncular/client 0.30.0 → 0.30.2

package/README.md

@@ -221,7 +221,8 @@ with `client.follower_timeout` when the link goes `blocked`, with
 `client.leader_handover` when another leader announces or this tab promotes
 before the answer arrives, and with `client.worker_failed` when the handle
 closes. Only calls queued while no leader is bound keep the
-`followerCallTimeoutMs` deadline.
+`followerCallTimeoutMs` deadline; when this tab wins the lock itself, its own
+core runs them.
 
 **Tabs of different builds never serve each other.** Every `hello`, `req`,
 and `announce` carries `MULTI_TAB_PROTOCOL_VERSION` and the schema version.

package/dist/multi-tab.d.ts

@@ -192,6 +192,11 @@ export declare class FollowerLink {
      * flushes the queued ones.
      */
     unbind(): void;
+    /**
+     * This tab won the lock and runs its own core: calls queued for the next
+     * leader run on `invoke` instead of failing, then the link closes.
+     */
+    handOver(invoke: (method: string, args: readonly unknown[]) => Promise<unknown>): void;
     close(): void;
 }
 export {};

package/dist/multi-tab.js

@@ -502,6 +502,19 @@ export class FollowerLink {
         this.#armUnboundDeadline();
         this.#probe();
     }
+    /**
+     * This tab won the lock and runs its own core: calls queued for the next
+     * leader run on `invoke` instead of failing, then the link closes.
+     */
+    handOver(invoke) {
+        const queued = this.#queue;
+        this.#queue = [];
+        for (const call of queued) {
+            call.cancelTimer?.();
+            invoke(call.method, call.args).then(call.resolve, call.reject);
+        }
+        this.close();
+    }
     close() {
         if (this.#closed)
             return;

package/dist/reactive-store.js

@@ -233,6 +233,10 @@ class ObservationCache {
         for (const entry of this.#active)
             entry.onChange(batch);
     }
+    reclaim() {
+        for (const entry of this.#active)
+            entry.reclaim?.();
+    }
     clear() {
         for (const entry of this.#entries.values())
             entry.dispose();
@@ -364,6 +368,8 @@ class QueryEntry {
     refresh = () => {
         if (this.#delegate !== undefined)
             this.#delegate.refresh();
+        else if (this.#claimError !== undefined)
+            this.reclaim();
         else
             this.#requestRead(true);
     };
@@ -386,13 +392,29 @@ class QueryEntry {
         this.store.releaseWindowClaims(this.#owner);
         this.reset();
     }
+    /** SPEC §7.7: a rejected claim is claimed again; its stored error would
+     * fail every read until the last subscriber leaves. */
+    reclaim() {
+        if (this.#delegate !== undefined || this.#claimError === undefined)
+            return;
+        this.#claimError = undefined;
+        this.#claimCoverage();
+        this.#requestRead();
+    }
     onChange(batch) {
         if (!batchMatches(batch, this.spec))
             return;
         if (batch.revision > this.#desiredRevision) {
             this.#desiredRevision = batch.revision;
         }
-        if (this.#listeners.size > 0)
+        if (this.#listeners.size === 0)
+            return;
+        // A committed row change of a dependency claims again; a window-only
+        // batch, which a failed window edit can itself produce, does not.
+        const rowChange = batch.tables.some((change) => this.spec.dependencies.some((dependency) => dependency.table === change.table));
+        if (rowChange && this.#claimError !== undefined)
+            this.reclaim();
+        else
             this.#requestRead();
     }
     #publish(next) {
@@ -446,12 +468,6 @@ class QueryEntry {
             return;
         }
         const wasBlocked = this.#state.phase === 'blocked';
-        // A claim that failed while the leader link was blocked is retried with
-        // the link: its stored error would otherwise fail every later read.
-        if (wasBlocked && this.#claimError !== undefined) {
-            this.#claimError = undefined;
-            this.#claimCoverage();
-        }
         this.#publish({
             ...this.#state,
             phase: wasBlocked
@@ -887,6 +903,16 @@ export class ReactiveClientStore {
                 this.#scheduleWindow(group);
         }
     }
+    /** Apply every claimed window group again and claim again for query entries
+     * whose claim was rejected. An applied group compares equal and makes no
+     * call; a group whose edit is in flight applies once more after it. */
+    #reclaimWindows() {
+        for (const group of this.#windowClaims.values()) {
+            if (group.claims.size > 0)
+                this.#scheduleWindow(group);
+        }
+        this.#queries.reclaim();
+    }
     #scheduleWindow(group) {
         group.requested = true;
         if (group.scheduled || group.running)
@@ -978,7 +1004,14 @@ export class ReactiveClientStore {
                 this.outcomes.refresh();
         });
         const roundFailure = this.roundFailure;
+        let claimedAttempt;
         this.#offProgress = this.client.onProgress((progress) => {
+            // A new sync attempt is the client's retry schedule (§7.6): window
+            // claims that failed are claimed again once per attempt.
+            if (progress.state === 'running' && progress.attempt !== claimedAttempt) {
+                claimedAttempt = progress.attempt;
+                this.#reclaimWindows();
+            }
             const current = roundFailure.getSnapshot();
             if (progress.state === 'failed' && current?.attempt !== progress.attempt)
                 roundFailure.set(new SyncRoundFailedError(progress.errorCode ?? 'client.unknown_failure', progress.attempt, progress.retryDelayMs));
@@ -997,12 +1030,8 @@ export class ReactiveClientStore {
                 this.status.refresh();
             // Window edits that failed while no leader served this tab apply now;
             // an applied group compares equal and makes no call.
-            if (leadership.state === 'leader' || leadership.state === 'follower') {
-                for (const group of this.#windowClaims.values()) {
-                    if (group.claims.size > 0)
-                        this.#scheduleWindow(group);
-                }
-            }
+            if (leadership.state === 'leader' || leadership.state === 'follower')
+                this.#reclaimWindows();
         });
         this.status.refresh();
         this.conflicts.refresh();

package/dist/worker-host.js

@@ -128,7 +128,8 @@ export class SyncClientHandle {
     }
     /** @internal — swap this handle from follower to leader (promotion). */
     __becomeLeader(core) {
-        this.#follower?.close();
+        // Calls queued for the next leader run on this tab's own core.
+        this.#follower?.handOver(core.invoke);
         this.#follower = undefined;
         this.#core = core;
         this.#clientId = core.clientId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/client",
-  "version": "0.30.0",
+  "version": "0.30.2",
   "description": "Syncular TypeScript client core — offline-first sync over SQLite (WASM/OPFS, Bun, Node)",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -89,10 +89,10 @@
   },
   "dependencies": {
     "@sqlite.org/sqlite-wasm": "^3.53.0-build1",
-    "@syncular/core": "0.30.0"
+    "@syncular/core": "0.30.2"
   },
   "devDependencies": {
-    "@syncular/server": "0.30.0",
+    "@syncular/server": "0.30.2",
     "playwright": "1.63.0"
   }
 }

package/src/multi-tab.ts

@@ -724,6 +724,22 @@ export class FollowerLink {
     this.#probe();
   }
 
+  /**
+   * This tab won the lock and runs its own core: calls queued for the next
+   * leader run on `invoke` instead of failing, then the link closes.
+   */
+  handOver(
+    invoke: (method: string, args: readonly unknown[]) => Promise<unknown>,
+  ): void {
+    const queued = this.#queue;
+    this.#queue = [];
+    for (const call of queued) {
+      call.cancelTimer?.();
+      invoke(call.method, call.args).then(call.resolve, call.reject);
+    }
+    this.close();
+  }
+
   close(): void {
     if (this.#closed) return;
     this.#closed = true;

package/src/reactive-store.ts

@@ -315,6 +315,8 @@ function reconcileRows<Row>(
 
 interface CachedObservation {
   onChange(batch: ClientChangeBatch): void;
+  /** A leader serves this tab again (it leads or follows a bound leader). */
+  reclaim?(): void;
   reset(): void;
   dispose(): void;
 }
@@ -356,6 +358,9 @@ class ObservationCache {
   onChange(batch: ClientChangeBatch): void {
     for (const entry of this.#active) entry.onChange(batch);
   }
+  reclaim(): void {
+    for (const entry of this.#active) entry.reclaim?.();
+  }
   clear(): void {
     for (const entry of this.#entries.values()) entry.dispose();
     this.#entries.clear();
@@ -499,6 +504,7 @@ class QueryEntry<Row> implements ExternalStoreEntry<LiveQueryResult<Row>> {
 
   refresh = (): void => {
     if (this.#delegate !== undefined) this.#delegate.refresh();
+    else if (this.#claimError !== undefined) this.reclaim();
     else this.#requestRead(true);
   };
 
@@ -523,12 +529,30 @@ class QueryEntry<Row> implements ExternalStoreEntry<LiveQueryResult<Row>> {
     this.reset();
   }
 
+  /** SPEC §7.7: a rejected claim is claimed again; its stored error would
+   * fail every read until the last subscriber leaves. */
+  reclaim(): void {
+    if (this.#delegate !== undefined || this.#claimError === undefined) return;
+    this.#claimError = undefined;
+    this.#claimCoverage();
+    this.#requestRead();
+  }
+
   onChange(batch: ClientChangeBatch): void {
     if (!batchMatches(batch, this.spec)) return;
     if (batch.revision > this.#desiredRevision) {
       this.#desiredRevision = batch.revision;
     }
-    if (this.#listeners.size > 0) this.#requestRead();
+    if (this.#listeners.size === 0) return;
+    // A committed row change of a dependency claims again; a window-only
+    // batch, which a failed window edit can itself produce, does not.
+    const rowChange = batch.tables.some((change) =>
+      this.spec.dependencies.some(
+        (dependency) => dependency.table === change.table,
+      ),
+    );
+    if (rowChange && this.#claimError !== undefined) this.reclaim();
+    else this.#requestRead();
   }
 
   #publish(next: LiveQueryResult<Row>): void {
@@ -584,12 +608,6 @@ class QueryEntry<Row> implements ExternalStoreEntry<LiveQueryResult<Row>> {
       return;
     }
     const wasBlocked = this.#state.phase === 'blocked';
-    // A claim that failed while the leader link was blocked is retried with
-    // the link: its stored error would otherwise fail every later read.
-    if (wasBlocked && this.#claimError !== undefined) {
-      this.#claimError = undefined;
-      this.#claimCoverage();
-    }
     this.#publish({
       ...this.#state,
       phase: wasBlocked
@@ -1070,6 +1088,16 @@ export class ReactiveClientStore {
     }
   }
 
+  /** Apply every claimed window group again and claim again for query entries
+   * whose claim was rejected. An applied group compares equal and makes no
+   * call; a group whose edit is in flight applies once more after it. */
+  #reclaimWindows(): void {
+    for (const group of this.#windowClaims.values()) {
+      if (group.claims.size > 0) this.#scheduleWindow(group);
+    }
+    this.#queries.reclaim();
+  }
+
   #scheduleWindow(group: WindowClaimGroup): void {
     group.requested = true;
     if (group.scheduled || group.running) return;
@@ -1158,7 +1186,14 @@ export class ReactiveClientStore {
     const roundFailure = this.roundFailure as ValueEntry<
       SyncRoundFailedError | undefined
     >;
+    let claimedAttempt: number | undefined;
     this.#offProgress = this.client.onProgress((progress) => {
+      // A new sync attempt is the client's retry schedule (§7.6): window
+      // claims that failed are claimed again once per attempt.
+      if (progress.state === 'running' && progress.attempt !== claimedAttempt) {
+        claimedAttempt = progress.attempt;
+        this.#reclaimWindows();
+      }
       const current = roundFailure.getSnapshot();
       if (progress.state === 'failed' && current?.attempt !== progress.attempt)
         roundFailure.set(
@@ -1184,11 +1219,8 @@ export class ReactiveClientStore {
       if (previous.isLoading) this.status.refresh();
       // Window edits that failed while no leader served this tab apply now;
       // an applied group compares equal and makes no call.
-      if (leadership.state === 'leader' || leadership.state === 'follower') {
-        for (const group of this.#windowClaims.values()) {
-          if (group.claims.size > 0) this.#scheduleWindow(group);
-        }
-      }
+      if (leadership.state === 'leader' || leadership.state === 'follower')
+        this.#reclaimWindows();
     });
     this.status.refresh();
     this.conflicts.refresh();

package/src/worker-host.ts

@@ -385,7 +385,8 @@ export class SyncClientHandle implements PromiseMethods<WorkerApi> {
 
   /** @internal — swap this handle from follower to leader (promotion). */
   __becomeLeader(core: LeaderCore): void {
-    this.#follower?.close();
+    // Calls queued for the next leader run on this tab's own core.
+    this.#follower?.handOver(core.invoke);
     this.#follower = undefined;
     this.#core = core;
     this.#clientId = core.clientId;