@steve31415/baselib 3.38.1 → 3.39.0

package/dist/sync/engine.js

@@ -1,5 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { SyncError, } from './types.js';
+// Past this many events a client is told to reload (a full bootstrap)
+// rather than catch up. Deliberate (2026-10-20, task 1e2cd274): a todo page
+// 138 events behind resynced as designed; the fault was its cached, stale
+// bootstrap, fixed in the app (no-store), not this limit.
 const DEFAULT_CATCHUP_LIMIT = 100;
 const DEFAULT_RETENTION_DAYS = 7;
 const IDENTIFIER = /^[a-z_][a-z0-9_]*$/;

package/dist/sync-browser/client.d.ts

@@ -154,6 +154,9 @@ export declare class SyncClient<B, C extends EventBody, S extends EventBody, Sum
      * after the bootstrap installs. Non-null exactly while reconciling. */
     private gapBuffer;
     private resyncBackoffTimer;
+    /** The backstop retry after a failed resync. Unlike the loop backoff it
+     * absorbs nothing: a fresh reload request runs at once and cancels it. */
+    private resyncFailureTimer;
     private loopEscalated;
     private reconciliationTail;
     private initialization;
@@ -302,6 +305,8 @@ export declare class SyncClient<B, C extends EventBody, S extends EventBody, Sum
      * cycle every reconcile succeeds. */
     private endResyncEpisode;
     private scheduleResyncRetry;
+    private scheduleResyncFailureRetry;
+    private cancelResyncFailureRetry;
     private sendConnect;
     private sendRaw;
     private trySend;

package/dist/sync-browser/client.js

@@ -1,6 +1,9 @@
 import { FirstLoadRetry } from './first-load-retry.js';
 const RECONNECT_DELAYS_SECONDS = [1, 2, 4, 8, 16, 30];
 const PING_INTERVAL_MS = 30_000;
+// Deliberate (2026-10-20 review, task 1e2cd274): todo's phone hit it 27
+// times in 25 minutes on 10-19, but none of those handshakes ever reached
+// the load balancer, so a longer limit would only have delayed the retry.
 const CONNECT_WATCHDOG_MS = 10_000;
 const DEFAULT_RECONNECT_BEFORE_MS = 55 * 60 * 1000;
 const FAILURE_TIMEOUT_MS = 60_000;
@@ -89,6 +92,9 @@ export class SyncClient {
      * after the bootstrap installs. Non-null exactly while reconciling. */
     gapBuffer = null;
     resyncBackoffTimer = null;
+    /** The backstop retry after a failed resync. Unlike the loop backoff it
+     * absorbs nothing: a fresh reload request runs at once and cancels it. */
+    resyncFailureTimer = null;
     loopEscalated = false;
     reconciliationTail = Promise.resolve();
     initialization = null;
@@ -647,7 +653,8 @@ export class SyncClient {
             }
             const planned = this.plannedClose === socket;
             this.plannedClose = null;
-            this.startOutage(event.code, event.wasClean === true);
+            const openForMs = this.socketOpenedAt === null ? null : Math.max(0, this.now() - this.socketOpenedAt);
+            this.startOutage(event.code, event.wasClean === true, openForMs);
             if (!this.isHidden()) {
                 this.noteReturnFailure(event.code);
                 this.scheduleReconnect();
@@ -972,7 +979,7 @@ export class SyncClient {
             void this.probeSession();
         }
     }
-    startOutage(closeCode, wasClean = false) {
+    startOutage(closeCode, wasClean = false, openForMs = null) {
         if (this.outageStartedAt !== null)
             return;
         // A sleep or freeze that ended in this close happened before the outage
@@ -982,7 +989,7 @@ export class SyncClient {
         this.outageStartedAt = this.options.runtime.now();
         this.outageEscalated = false;
         this.outageCloseCode = closeCode;
-        this.outageInfo = { closeCode, wasClean, visibleAtDrop: !this.isHidden(), counters: this.snapshot() };
+        this.outageInfo = { closeCode, wasClean, openForMs, visibleAtDrop: !this.isHidden(), counters: this.snapshot() };
         this.armEscalation();
     }
     /** ERROR only after OUTAGE_ESCALATE_MS of visible, on-time outage; re-armed
@@ -1002,6 +1009,7 @@ export class SyncClient {
                     durationMs: this.options.runtime.now() - this.outageStartedAt,
                     closeCode: this.outageCloseCode,
                     attempts: this.reconnectAttempts,
+                    openForMs: this.outageInfo?.openForMs ?? null,
                 });
             }
         }, OUTAGE_ESCALATE_MS);
@@ -1327,6 +1335,7 @@ export class SyncClient {
                 totalAttempts: this.totalAttempts,
                 closeCode: info?.closeCode,
                 wasClean: info?.wasClean,
+                openForMs: info ? info.openForMs : undefined,
                 visibleAtDrop: info?.visibleAtDrop,
                 hiddenMs: delta?.hiddenMs,
                 stalledMs: delta?.stalledMs,
@@ -1387,6 +1396,7 @@ export class SyncClient {
     async resyncFromServer(reason) {
         if (this.refetchInFlight || this.halted || this.disposed)
             return;
+        this.cancelResyncFailureRetry();
         const now = this.options.runtime.now();
         // `time <= now` drops entries stranded in the future by a backward
         // clock jump, which would otherwise pin the detector tripped.
@@ -1420,7 +1430,17 @@ export class SyncClient {
         }
         catch (error) {
             if (!isLifecycleAbort(error) && !this.disposed && !this.halted) {
-                this.options.logger.error('resync failed', { reason, error });
+                // As for the first bootstrap: fetch's TypeError means no HTTP answer
+                // reached the page (the device's network), a WARN; an answer that was
+                // an error is the server's, an ERROR. Either way the store may be
+                // stale, so a retry is scheduled rather than left to the next reload
+                // message or sequence gap, which a quiet page may never get.
+                const reachedServer = !(error instanceof TypeError);
+                if (reachedServer)
+                    this.options.logger.error('resync failed', { reason, reachedServer, error });
+                else
+                    this.options.logger.warn('resync failed', { reason, reachedServer, error });
+                this.scheduleResyncFailureRetry();
             }
         }
         finally {
@@ -1472,6 +1492,23 @@ export class SyncClient {
             void this.resyncFromServer('retry after resync backoff');
         }, RESYNC_RETRY_MS);
     }
+    scheduleResyncFailureRetry() {
+        if (this.resyncFailureTimer !== null || this.halted || this.disposed)
+            return;
+        this.resyncFailureTimer = this.setTimer(() => {
+            this.resyncFailureTimer = null;
+            // Hidden: no minutely retry (a phone without network would log one a
+            // minute); the return's HTTP catch-up re-triggers the resync.
+            if (this.isHidden())
+                return;
+            void this.resyncFromServer('retry after failed resync');
+        }, RESYNC_RETRY_MS);
+    }
+    cancelResyncFailureRetry() {
+        if (this.resyncFailureTimer !== null)
+            this.options.runtime.clearTimeout(this.resyncFailureTimer);
+        this.resyncFailureTimer = null;
+    }
     sendConnect() {
         this.sendRaw({
             type: 'connect',
@@ -1600,6 +1637,7 @@ export class SyncClient {
             this.options.runtime.clearTimeout(this.escalateTimer);
         if (this.resyncBackoffTimer !== null)
             this.options.runtime.clearTimeout(this.resyncBackoffTimer);
+        this.cancelResyncFailureRetry();
         for (const timer of this.failureTimers.values())
             this.options.runtime.clearTimeout(timer);
         this.cancelBackgroundTick();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.38.1",
+  "version": "3.39.0",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",