@steve31415/baselib 3.33.1 → 3.33.2

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

@@ -217,6 +217,12 @@ export declare class SyncClient<B, C extends EventBody, S extends EventBody, Sum
      * the page counted as visible is counted (hidden pages are throttled by
      * design and their time is `hiddenMs`). */
     private observeStall;
+    /** The sleep half of `observeStall`, also run by every event-driven entry
+     * that starts, ends or splits the accounting (outage start and end, an
+     * `online` event, a hide): a wake can reach the page as one of those
+     * events before any timer runs, and the sleep must land on the right side
+     * of it (reader, 2026-10-11). */
+    private observeClockJump;
     private setTimer;
     private setRepeating;
     private isHidden;

package/dist/sync-browser/client.js

@@ -382,20 +382,27 @@ export class SyncClient {
      * the page counted as visible is counted (hidden pages are throttled by
      * design and their time is `hiddenMs`). */
     observeStall(dueMono) {
+        this.observeClockJump();
         const mono = this.monoNow();
-        const offset = this.now() - mono;
-        const visible = !this.isHidden();
-        if (visible && this.clockOffset !== null && offset - this.clockOffset >= STALL_MIN_MS) {
-            this.counters.stalledMs += offset - this.clockOffset;
-        }
-        this.clockOffset = offset;
-        if (visible && mono - dueMono >= STALL_MIN_MS) {
+        if (!this.isHidden() && mono - dueMono >= STALL_MIN_MS) {
             const from = Math.max(dueMono, this.stallCoveredUntil, this.visibleSinceMono);
             if (mono > from)
                 this.counters.stalledMs += mono - from;
             this.stallCoveredUntil = mono;
         }
     }
+    /** The sleep half of `observeStall`, also run by every event-driven entry
+     * that starts, ends or splits the accounting (outage start and end, an
+     * `online` event, a hide): a wake can reach the page as one of those
+     * events before any timer runs, and the sleep must land on the right side
+     * of it (reader, 2026-10-11). */
+    observeClockJump() {
+        const offset = this.now() - this.monoNow();
+        if (!this.isHidden() && this.clockOffset !== null && offset - this.clockOffset >= STALL_MIN_MS) {
+            this.counters.stalledMs += offset - this.clockOffset;
+        }
+        this.clockOffset = offset;
+    }
     setTimer(callback, delayMs) {
         const dueMono = this.monoNow() + delayMs;
         return this.options.runtime.setTimeout(() => {
@@ -439,8 +446,9 @@ export class SyncClient {
         if (this.halted || this.disposed || this.hiddenSince !== null)
             return;
         this.finishReturnWindow();
-        // A device that slept and then hid the page: the sleep counts as hidden.
-        this.rebaselineClocks();
+        // A device that slept with the page visible and hid it on waking: the
+        // sleep counts as stalled, before the hidden spell starts.
+        this.observeClockJump();
         this.hiddenSince = this.now();
         this.spellCounters = this.snapshot();
         this.hiddenSocketFailed = false;
@@ -483,6 +491,7 @@ export class SyncClient {
     onOnline() {
         if (this.halted || this.disposed)
             return;
+        this.observeClockJump();
         if (this.isHidden()) {
             if (this.socket === null) {
                 this.cancelBackgroundTick();
@@ -966,6 +975,10 @@ export class SyncClient {
     startOutage(closeCode, wasClean = false) {
         if (this.outageStartedAt !== null)
             return;
+        // A sleep or freeze that ended in this close happened before the outage
+        // began (durationMs starts now): keep it out of the outage's stalledMs.
+        this.observeClockJump();
+        this.stallCoveredUntil = Math.max(this.stallCoveredUntil, this.monoNow());
         this.outageStartedAt = this.options.runtime.now();
         this.outageEscalated = false;
         this.outageCloseCode = closeCode;
@@ -1300,6 +1313,7 @@ export class SyncClient {
     }
     onSyncEstablished() {
         if (this.outageStartedAt !== null) {
+            this.observeClockJump();
             const durationMs = Math.max(0, this.options.runtime.now() - this.outageStartedAt);
             // Failures are only counted (and the ladder only runs) while visible,
             // and the count restarts on each return, so `attempts` is what the

package/package.json

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