@auxilium/datalynk-client 1.5.0 → 1.5.2

package/dist/index.cjs

@@ -1553,7 +1553,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         }
       });
       if ((_a = this.api.options.offline) == null ? void 0 : _a.length)
-        this.user$.pipe(filter((u) => u !== void 0)).subscribe((u) => localStorage.setItem("datalynk-user", JSON.stringify(u)));
+        this.user$.pipe(filter((u) => u !== void 0)).subscribe((u) => {
+          if (u == null) localStorage.removeItem("datalynk-user");
+          else localStorage.setItem("datalynk-user", JSON.stringify(u));
+        });
     }
     /** Current user */
     get user() {
@@ -1589,7 +1592,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      * @return {Promise<void>} Login complete
      */
     async handleLogin(spoke, options) {
-      var _a, _b;
+      var _a, _b, _c;
       if (this.onlinePrompt) window.removeEventListener("online", this.onlinePrompt);
       if ((_a = this.api.options.offline) == null ? void 0 : _a.length) window.removeEventListener("online", this.onlinePrompt = () => this.handleLogin(spoke, options));
       const urlParams = new URLSearchParams(location.search);
@@ -1598,8 +1601,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         this.api.token = urlToken;
         urlParams.delete("datalynkToken");
         location.href = location.pathname + (urlParams.toString() ? "?" + urlParams.toString() : "") + location.hash;
+      } else if (this.api.reauthenticationPending && !this.api.online && ((_b = this.api.jwtPayload) == null ? void 0 : _b.realm) == spoke) {
+        return;
       } else if (this.api.token && !this.api.expired) {
-        if (((_b = this.api.jwtPayload) == null ? void 0 : _b.realm) != spoke) {
+        if (((_c = this.api.jwtPayload) == null ? void 0 : _c.realm) != spoke) {
           this.api.token = null;
           location.reload();
         }
@@ -3229,7 +3234,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       } });
     }
   }
-  const version = "1.5.0";
+  const version = "1.5.2";
   class WebRtc {
     constructor(api) {
       __publicField(this, "ice");
@@ -3776,7 +3781,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         timeout: 6e4
       });
       __publicField(this, "authenticationInvalid", false);
+      /** Token reached exp while the client could not reach Datalynk; keep the offline session alive until reconnect. */
+      __publicField(this, "offlineAuthenticationExpired", false);
       __publicField(this, "tokenExpiryTimeout", null);
+      __publicField(this, "unauthorizedLogout", null);
+      __publicField(this, "replayingPending", false);
+      /** If replay is requested while a replay pass is already active, run another pass when it finishes. */
+      __publicField(this, "pendingReplayRequested", false);
+      __publicField(this, "offlineSessionOwner", null);
       /** Request-specific recovery after a server response proves an API call is broken. */
       __publicField(this, "recovery", null);
       /** Retry the failed request twice immediately, then this long after each failed recovery response. */
@@ -3784,6 +3796,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       __publicField(this, "recoveryImmediateRetries", 2);
       /** LocalStorage key for persisting logins */
       __publicField(this, "localStorageKey", "datalynk-token");
+      /** Persisted owner of an offline queue so another login cannot inherit queued writes. */
+      __publicField(this, "offlineSessionOwnerKey", "datalynk-offline-owner");
+      __publicField(this, "tokenStorageListener", null);
       /** Pending requests cache */
       __publicField(this, "pending", {});
       /** Helpers */
@@ -3833,12 +3848,15 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       var _a, _b;
       this.origin = origin;
       this.url = `${new URL(origin).origin}/api/`;
+      const development = this.isDevelopmentEnvironment(origin);
       this.options = {
         manifest: {},
         name: typeof document != "undefined" ? document.title : "Datalynk",
         offline: [],
         origin: typeof location !== "undefined" ? location.host : "Unknown",
         saveSession: true,
+        replayOfflineQueue: true,
+        watchTokenExpiry: true,
         serviceWorker: "/service.worker.mjs",
         ...options,
         webrtc: {
@@ -3848,14 +3866,28 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           ...options.webrtc || {}
         }
       };
+      if (development) this.options.watchTokenExpiry = false;
       if (this.options.saveSession && typeof localStorage != "undefined") {
         this.token = localStorage.getItem(this.localStorageKey) || null;
         this.token$.pipe(distinctUntilChanged()).subscribe((token) => {
           if (token) localStorage.setItem(this.localStorageKey, token);
           else localStorage.removeItem(this.localStorageKey);
         });
+        if (typeof window != "undefined") {
+          this.tokenStorageListener = (event) => {
+            if (event.storageArea === localStorage && event.key == null) {
+              this.token = null;
+              return;
+            }
+            if (event.key !== this.localStorageKey || event.newValue === this.token) return;
+            if (event.newValue && this.canAdoptToken(event.newValue, this.token)) this.token = event.newValue;
+            else if (event.newValue == null) this.token = null;
+          };
+          window.addEventListener("storage", this.tokenStorageListener);
+        }
       }
-      this.token$.pipe(distinctUntilChanged()).subscribe((token) => this.scheduleTokenExpiry(token));
+      if (this.options.watchTokenExpiry)
+        this.token$.pipe(distinctUntilChanged()).subscribe((token) => this.scheduleTokenExpiry(token));
       this.socket = new Socket(this, { url: options.socket });
       this.gps = new Gps(this, options.gps);
       this.auth = new Auth(this);
@@ -3866,21 +3898,13 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       this.webrtc = new WebRtc(this);
       if (typeof indexedDB != "undefined") {
         this.database = new Database("datalynk", ["pending", ...this.options.offline || []]);
-        this.online$.subscribe(async (online) => {
-          var _a2;
-          if (!online) return;
-          const table = (_a2 = this.database) == null ? void 0 : _a2.table("pending");
-          const keys = await (table == null ? void 0 : table.getAllKeys());
-          await Promise.allSettled(keys.map(async (k) => {
-            const r = await (table == null ? void 0 : table.get(k));
-            await this.request(r).then(() => table == null ? void 0 : table.delete(k));
-          }));
+        if (this.options.replayOfflineQueue !== false) this.online$.subscribe((online) => {
+          if (online) void this.replayPendingQueue();
         });
       }
       if (typeof window !== "undefined") {
         window.addEventListener("online", () => this.checkConnection());
         window.addEventListener("offline", () => this.setConnectionStatus("offline"));
-        this.online$.subscribe(() => this.offlineBanner());
         this.startHeartbeat();
       }
       if ((_a = this.options.offline) == null ? void 0 : _a.length) {
@@ -3911,6 +3935,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       var _a;
       return (((_a = this.jwtPayload) == null ? void 0 : _a.exp) ?? Infinity) * 1e3 <= Date.now();
     }
+    /** Whether authentication expired while offline and must be renewed before replaying queued work. */
+    get reauthenticationPending() {
+      return this.offlineAuthenticationExpired;
+    }
     /** Get session info from JWT payload */
     get jwtPayload() {
       if (!this.token) return null;
@@ -3969,19 +3997,26 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       return this.token$.getValue();
     }
     set token(token) {
+      var _a;
       if (this.recovery && token !== this.recovery.token)
         this.cancelRecovery(errorFromCode(401, "Session changed during API recovery"));
       if (token && this.isTokenExpired(token)) {
-        this.authenticationInvalid = true;
-        this.token$.next(null);
-        this.setConnectionStatus("unauthorized");
+        if (this.adoptStoredToken(token)) return;
+        if (this.shouldDeferLocalExpiry()) {
+          this.deferOfflineExpiry(token);
+          return;
+        }
+        this.markUnauthorized(void 0, this.hasOwnedOfflineSession(token));
         return;
       }
       this.authenticationInvalid = false;
+      this.offlineAuthenticationExpired = false;
       this.token$.next(token);
       if (token && !this.online && !this.recovery) {
-        this.setConnectionStatus(typeof navigator == "undefined" || navigator.onLine ? "online" : "offline");
+        const browserOnline = typeof navigator == "undefined" || typeof navigator.onLine == "undefined" || navigator.onLine;
+        this.setConnectionStatus(browserOnline ? "online" : "offline");
       }
+      if (token && ((_a = this.options) == null ? void 0 : _a.replayOfflineQueue) !== false) void this.replayPendingQueue();
     }
     async _request(req, options = {}) {
       if (this.recovery) throw errorFromCode(503, "Datalynk is unavailable");
@@ -4000,7 +4035,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     async _requestOnce(req, options = {}, recoveryAttempt = false) {
       const token = options.token || this.token;
       if (token && this.isTokenExpired(token)) {
-        this.markUnauthorized(token);
+        if (token === this.token) this.expireToken(token);
         throw errorFromCode(401, "Session token expired");
       }
       let resp;
@@ -4036,7 +4071,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       if (!resp.ok || (data == null ? void 0 : data.error)) {
         const error = Object.assign(errorFromCode(resp.status, data == null ? void 0 : data.error), data);
         Object.defineProperty(error, "response", { value: resp, configurable: true });
-        if (!recoveryAttempt && resp.status < 500 && resp.status !== 401 && !this.isMysqlError(error))
+        if (!recoveryAttempt && resp.status !== 401 && !this.isSqlStateError(error))
           this.setConnectionStatus("online");
         throw error;
       }
@@ -4044,17 +4079,22 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       if (!recoveryAttempt) this.setConnectionStatus("online");
       return data;
     }
-    /** Only server-response failures own global recovery; auth and ordinary 4xx errors do not. */
+    /**
+     * Only failures which indicate Datalynk as a service is unavailable own global
+     * recovery. A request-specific application failure must not take the whole
+     * client offline: another unrelated API request may still be perfectly healthy.
+     */
     isRecoverableResponseError(error) {
       var _a;
-      if (error instanceof UnexpectedApiResponseError) return true;
       if ((error == null ? void 0 : error.code) === 401) return false;
       const status = ((_a = error == null ? void 0 : error.response) == null ? void 0 : _a.status) ?? (error == null ? void 0 : error.code);
-      return status >= 500 || this.isMysqlError(error);
+      if (this.isGatewayUnavailableStatus(status)) return true;
+      return this.isSqlStateError(error);
     }
-    isMysqlError(error) {
-      const message = String((error == null ? void 0 : error.error) ?? (error == null ? void 0 : error.message) ?? "");
-      return /\bSQLSTATE\[[A-Z0-9]+\]/i.test(message);
+    /** Any API error returned in PDO SQLSTATE form uses the offline/recovery path. */
+    isSqlStateError(error) {
+      const message = String((error == null ? void 0 : error.error) ?? (error == null ? void 0 : error.message) ?? "").trim();
+      return /^SQLSTATE\[/i.test(message);
     }
     /**
      * A returned server failure immediately makes the client unavailable. The exact
@@ -4147,8 +4187,22 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         this.setConnectionStatus("unauthorized");
         return;
       }
+      if (this.offlineAuthenticationExpired) {
+        const controller2 = new AbortController();
+        const timeout2 = setTimeout(() => controller2.abort(), this.heartbeat.timeout);
+        try {
+          const response = await fetch(this.url + this.heartbeat.target, { signal: controller2.signal });
+          if (this.isGatewayUnavailableStatus(response.status)) this.setConnectionStatus("unavailable");
+          else this.markUnauthorized(this.token, true);
+        } catch {
+          this.setConnectionStatus("offline");
+        } finally {
+          clearTimeout(timeout2);
+        }
+        return;
+      }
       if (this.token && this.isTokenExpired(this.token)) {
-        this.markUnauthorized(this.token);
+        this.expireToken(this.token);
         return;
       }
       const controller = new AbortController();
@@ -4156,13 +4210,16 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       try {
         const response = await fetch(this.url + this.heartbeat.target, { signal: controller.signal });
         if (this.recovery) return;
-        this.setConnectionStatus(response.ok ? "online" : "unavailable");
+        this.setConnectionStatus(this.isGatewayUnavailableStatus(response.status) ? "unavailable" : "online");
       } catch (error) {
         if (!this.recovery) this.setConnectionStatus("offline");
       } finally {
         clearTimeout(timeout);
       }
     }
+    isGatewayUnavailableStatus(status) {
+      return status === 502 || status === 503 || status === 504;
+    }
     isTokenExpired(token) {
       var _a;
       try {
@@ -4171,6 +4228,38 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         return true;
       }
     }
+    isDevelopmentEnvironment(origin) {
+      var _a;
+      const isDevHost = (hostname) => {
+        hostname = hostname.toLowerCase();
+        return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname.endsWith(".datalynk") || hostname.endsWith(".test");
+      };
+      const configuredDev = typeof window != "undefined" && ((_a = window.dojoConfig) == null ? void 0 : _a.isDev) === true;
+      const pageHost = typeof location == "undefined" ? "" : location.hostname;
+      return configuredDev || isDevHost(new URL(origin).hostname) || !!pageHost && isDevHost(pageHost);
+    }
+    canAdoptToken(candidate, rejected) {
+      if (!candidate || candidate === rejected || this.isTokenExpired(candidate)) return false;
+      try {
+        const next = decodeJwt(candidate);
+        const previous = rejected ? decodeJwt(rejected) : null;
+        if ((previous == null ? void 0 : previous.realm) && (next == null ? void 0 : next.realm) && previous.realm !== next.realm) return false;
+        const previousUser = (previous == null ? void 0 : previous.uid) ?? (previous == null ? void 0 : previous.sub);
+        const nextUser = (next == null ? void 0 : next.uid) ?? (next == null ? void 0 : next.sub);
+        return previousUser == null || String(previousUser) === String(nextUser);
+      } catch {
+        return false;
+      }
+    }
+    /** Adopt a newer canonical token written by another auth path before expiring this session. */
+    adoptStoredToken(rejected) {
+      var _a;
+      if (!((_a = this.options) == null ? void 0 : _a.saveSession) || typeof localStorage == "undefined") return false;
+      const stored = localStorage.getItem(this.localStorageKey);
+      if (!stored || !this.canAdoptToken(stored, rejected)) return false;
+      this.token = stored;
+      return true;
+    }
     scheduleTokenExpiry(token) {
       var _a, _b, _c;
       if (this.tokenExpiryTimeout) clearTimeout(this.tokenExpiryTimeout);
@@ -4180,40 +4269,241 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       try {
         expiresAt = (((_a = decodeJwt(token)) == null ? void 0 : _a.exp) ?? 0) * 1e3;
       } catch {
-        return this.markUnauthorized(token);
+        if (!this.adoptStoredToken(token)) this.expireToken(token);
+        return;
       }
       const delay = expiresAt - Date.now();
-      if (delay <= 0) return this.markUnauthorized(token);
+      if (delay <= 0) {
+        if (!this.adoptStoredToken(token)) this.expireToken(token);
+        return;
+      }
       this.tokenExpiryTimeout = setTimeout(() => {
         if (delay > 2147e6) this.scheduleTokenExpiry(token);
-        else this.markUnauthorized(token);
+        else if (!this.adoptStoredToken(token)) this.expireToken(token);
       }, Math.min(delay, 2147e6));
       (_c = (_b = this.tokenExpiryTimeout) == null ? void 0 : _b.unref) == null ? void 0 : _c.call(_b);
     }
-    markUnauthorized(token) {
+    /** Handle local JWT expiry without treating an offline device like a rejected online session. */
+    expireToken(token) {
+      if (token !== this.token) return;
+      if (this.shouldDeferLocalExpiry()) {
+        this.deferOfflineExpiry(token);
+        return;
+      }
+      this.markUnauthorized(token, this.hasOwnedOfflineSession(token));
+    }
+    shouldDeferLocalExpiry() {
+      if (this.authenticationInvalid) return false;
+      if (typeof navigator != "undefined" && typeof navigator.onLine != "undefined" && !navigator.onLine) return true;
+      return this.status === "offline" || this.status === "unavailable";
+    }
+    deferOfflineExpiry(token) {
+      this.authenticationInvalid = false;
+      this.offlineAuthenticationExpired = true;
+      this.cancelRecovery(errorFromCode(401, "Session expired while offline"));
+      this.rememberOfflineSessionOwner(token);
+      if (this.token !== token) this.token$.next(token);
+      if (this.status === "online") this.setConnectionStatus("offline");
+    }
+    markUnauthorized(token, preservePending = this.hasOwnedOfflineSession(token || this.token)) {
       if (token && token !== this.token) return;
+      if (this.adoptStoredToken(token)) return;
+      if (this.authenticationInvalid && this.unauthorizedLogout) return;
       this.authenticationInvalid = true;
+      this.offlineAuthenticationExpired = false;
       this.cancelRecovery(errorFromCode(401, "Session expired"));
-      if (this.token != null) this.token$.next(null);
+      if (this.token !== null) this.token$.next(null);
       this.setConnectionStatus("unauthorized");
+      this.unauthorizedLogout ?? (this.unauthorizedLogout = Promise.resolve().then(() => this.finishUnauthorizedLogout(preservePending)).finally(() => {
+        this.unauthorizedLogout = null;
+      }));
+    }
+    async finishUnauthorizedLogout(preservePending = false) {
+      var _a;
+      if (typeof localStorage != "undefined") {
+        localStorage.removeItem(this.localStorageKey);
+        localStorage.removeItem("datalynk-user");
+        if (!preservePending) localStorage.removeItem(this.offlineSessionOwnerKey);
+      }
+      if (!preservePending) this.offlineSessionOwner = null;
+      for (const slice of this.sliceCache.values()) {
+        try {
+          slice.sync(false);
+        } catch {
+        }
+      }
+      await this.clearOfflineSessionCache(preservePending);
+      if (typeof caches != "undefined") {
+        try {
+          await Promise.all([caches.delete("datalynk"), caches.delete("api-settings")]);
+        } catch (error) {
+          console.error("Unable to clear Datalynk service worker cache", error);
+        }
+      }
+      if (typeof navigator != "undefined" && ((_a = navigator.serviceWorker) == null ? void 0 : _a.controller)) {
+        navigator.serviceWorker.controller.postMessage({ token: null, clearCache: true });
+      }
+      if (typeof location != "undefined" && typeof location.reload == "function")
+        location.reload();
+    }
+    async clearOfflineSessionCache(preservePending = false) {
+      if (typeof indexedDB == "undefined") return;
+      try {
+        if (this.database) {
+          const db = await this.database.connection;
+          const stores = Array.from(db.objectStoreNames).filter((name) => !(preservePending && name === "pending"));
+          if (!stores.length) return;
+          await new Promise((resolve, reject) => {
+            const tx = db.transaction(stores, "readwrite");
+            stores.forEach((name) => tx.objectStore(name).clear());
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+            tx.onabort = () => reject(tx.error);
+          });
+          return;
+        }
+        await new Promise((resolve, reject) => {
+          const request = indexedDB.open("datalynk");
+          request.onerror = () => reject(request.error);
+          request.onsuccess = () => {
+            const db = request.result;
+            const stores = Array.from(db.objectStoreNames).filter((name) => !(preservePending && name === "pending"));
+            if (!stores.length) {
+              db.close();
+              resolve();
+              return;
+            }
+            const tx = db.transaction(stores, "readwrite");
+            stores.forEach((name) => tx.objectStore(name).clear());
+            tx.oncomplete = () => {
+              db.close();
+              resolve();
+            };
+            tx.onerror = () => {
+              const error = tx.error;
+              db.close();
+              reject(error);
+            };
+            tx.onabort = () => {
+              const error = tx.error;
+              db.close();
+              reject(error);
+            };
+          };
+        });
+      } catch (error) {
+        console.error("Unable to clear Datalynk offline session cache", error);
+      }
+    }
+    tokenIdentity(token) {
+      if (!token) return null;
+      try {
+        const payload = decodeJwt(token);
+        const user = (payload == null ? void 0 : payload.uid) ?? (payload == null ? void 0 : payload.sub);
+        return {
+          realm: (payload == null ? void 0 : payload.realm) == null ? void 0 : String(payload.realm),
+          user: user == null ? void 0 : String(user)
+        };
+      } catch {
+        return null;
+      }
+    }
+    readOfflineSessionOwner() {
+      if (this.offlineSessionOwner) return this.offlineSessionOwner;
+      if (typeof localStorage == "undefined") return null;
+      try {
+        const value = localStorage.getItem(this.offlineSessionOwnerKey);
+        if (!value) return null;
+        const owner = JSON.parse(value);
+        if (!owner || typeof owner !== "object") return null;
+        return this.offlineSessionOwner = owner;
+      } catch {
+        return null;
+      }
+    }
+    ownersMatch(owner, identity2) {
+      if (!identity2) return false;
+      if (owner.realm != null && owner.realm !== identity2.realm) return false;
+      if (owner.user != null && owner.user !== identity2.user) return false;
+      return true;
+    }
+    rememberOfflineSessionOwner(token) {
+      const identity2 = this.tokenIdentity(token);
+      if (!identity2) return;
+      const existing = this.readOfflineSessionOwner();
+      if (existing && !this.ownersMatch(existing, identity2)) return;
+      this.offlineSessionOwner = identity2;
+      if (typeof localStorage != "undefined") {
+        try {
+          localStorage.setItem(this.offlineSessionOwnerKey, JSON.stringify(identity2));
+        } catch {
+        }
+      }
+    }
+    ensureOfflineSessionOwner(token) {
+      const existing = this.readOfflineSessionOwner();
+      const identity2 = this.tokenIdentity(token);
+      if (existing) return this.ownersMatch(existing, identity2);
+      if (!identity2) return true;
+      this.rememberOfflineSessionOwner(token);
+      return true;
+    }
+    hasOwnedOfflineSession(token) {
+      const owner = this.readOfflineSessionOwner();
+      return !!owner && this.ownersMatch(owner, this.tokenIdentity(token));
+    }
+    clearOfflineSessionOwner() {
+      this.offlineSessionOwner = null;
+      if (typeof localStorage != "undefined") {
+        try {
+          localStorage.removeItem(this.offlineSessionOwnerKey);
+        } catch {
+        }
+      }
+    }
+    /** Replay queued writes only after a matching authenticated session is online. */
+    async replayPendingQueue() {
+      if (!this.database || !this.online || this.authenticationInvalid || this.offlineAuthenticationExpired) return;
+      if (this.replayingPending) {
+        this.pendingReplayRequested = true;
+        return;
+      }
+      const table = this.database.table("pending");
+      const owner = this.readOfflineSessionOwner();
+      if (owner && !this.ownersMatch(owner, this.tokenIdentity(this.token))) {
+        if (this.token) console.warn("Datalynk offline queue is quarantined because it belongs to another authenticated user");
+        return;
+      }
+      this.replayingPending = true;
+      try {
+        const keys = await table.getAllKeys();
+        for (const key of keys) {
+          if (!this.online || this.authenticationInvalid || this.offlineAuthenticationExpired) break;
+          if (owner && !this.ownersMatch(owner, this.tokenIdentity(this.token))) break;
+          const request = await table.get(key);
+          if (request == null) continue;
+          try {
+            await this.request(request);
+            await table.delete(key);
+          } catch (error) {
+            break;
+          }
+        }
+        if (await table.count() === 0) this.clearOfflineSessionOwner();
+      } finally {
+        this.replayingPending = false;
+        if (this.pendingReplayRequested) {
+          this.pendingReplayRequested = false;
+          if (this.online && !this.authenticationInvalid && !this.offlineAuthenticationExpired)
+            void this.replayPendingQueue();
+        }
+      }
     }
     setConnectionStatus(status) {
       if (this.status !== status) this.status$.next(status);
       const online = status === "online";
       if (this.online !== online) this.online$.next(online);
     }
-    offlineBanner() {
-      if (this.options.offlineBanner === false || typeof document == "undefined") return;
-      if (this.status === "online") {
-        removeBanner("datalynk-offline-banner");
-      } else {
-        const message = this.status === "unauthorized" ? "⚠️ Your session expired, please sign in again" : this.status === "unavailable" ? "⚠️ Datalynk is currently unavailable" : "⚠️ You are offline, please reconnect to sync changes";
-        createBanner(message, {
-          id: "datalynk-offline-banner",
-          position: this.options.offlineBanner === "top" ? "top" : "bottom"
-        });
-      }
-    }
     startHeartbeat() {
       this.stopHeartbeat();
       this.heartbeat.interval = setInterval(() => this.checkConnection(), this.heartbeat.timeout / 2);
@@ -4323,6 +4613,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       if (this.offline && typeof navigator != "undefined") {
         if (this.status === "unauthorized") return Promise.reject(errorFromCode(401, "Session expired"));
         if (options.offline) {
+          if (!this.ensureOfflineSessionOwner(this.token))
+            return Promise.reject(errorFromCode(409, "Offline queue belongs to another authenticated user"));
           (_b = (_a = this.database) == null ? void 0 : _a.table("pending")) == null ? void 0 : _b.add(data, key);
           return Promise.resolve();
         }