@pmate/chat-sdk 0.12.0-next.23 → 0.12.0-next.24

package/README.md

@@ -228,3 +228,10 @@ Custom primitive integrations must initialize them with the same authenticated
 scope, dispose them on identity changes, and wire their transport to an authorized
 server. Standard browser integrations should use the facade instead. The Merry migration and production validation
 are tracked in the unified message layer proposal.
+
+When the browser reports offline, scheduled message restoration and reading
+refreshes wait for the normal reconnect/wake path. Cached reads remain available;
+unknown receipt counts stay unknown and an uncached reader detail page rejects
+without attempting transport. A network failure arriving after the browser went
+offline does not turn background synchronization into an operation error.
+Authorization failures still revoke the corresponding cached data.

package/lib/runtime/chatSession.js

@@ -97,7 +97,8 @@ export class ChatSession {
             this.publishGlobal();
             if (state === "connected") {
                 const since = Date.now();
-                this.catchUp.schedule("scope", () => this.messages.restore(since, options.activeThreadId));
+                this.catchUp.schedule("scope", async () => { if (this.connectionState === "connected" && !this.closed && !this.withdrawn)
+                    await this.messages.restore(since, options.activeThreadId); });
                 if (this.readingStarted)
                     this.reading.refresh();
                 this.wakeCounts();

package/lib/runtime/connectivity.d.ts

@@ -0,0 +1,4 @@
+/** Browser connectivity is advisory: only suppress network errors while the
+ * browser explicitly reports offline. Permission and data errors stay visible. */
+export declare function isOffline(): boolean;
+export declare function isOfflineNetworkFailure(error: unknown): boolean;

package/lib/runtime/connectivity.js

@@ -0,0 +1,8 @@
+/** Browser connectivity is advisory: only suppress network errors while the
+ * browser explicitly reports offline. Permission and data errors stay visible. */
+export function isOffline() {
+    return typeof navigator !== "undefined" && navigator.onLine === false;
+}
+export function isOfflineNetworkFailure(error) {
+    return isOffline() && (error instanceof TypeError || error?.name === "AbortError");
+}

package/lib/runtime/messageClient.js

@@ -1,3 +1,4 @@
+import { isOffline, isOfflineNetworkFailure } from "./connectivity.js";
 import { WindowedTasks } from "./coalescer.js";
 import { IndexedDbMessageStore, messageScopeKey, mergeStoredMessage } from "./messageStore.js";
 /** Local-first message facade; hosts never select a cache or network source. */
@@ -48,7 +49,8 @@ export class MessageClient {
             this.invalidate(thread);
         else
             options.onError?.(error, thread); });
-        this.syncTasks = new WindowedTasks(options.syncWindowMs ?? 1000, (error, thread) => options.onError?.(error, thread));
+        this.syncTasks = new WindowedTasks(options.syncWindowMs ?? 1000, (error, thread) => { if (!isOfflineNetworkFailure(error))
+            options.onError?.(error, thread); });
         if (typeof BroadcastChannel !== "undefined") {
             this.channel = new BroadcastChannel(`pmate-chat:${messageScopeKey(options.scope)}${this.storage.namespace === "pmate-chat-messages" ? "" : `:${this.storage.namespace}`}`);
             this.channel.onmessage = event => {
@@ -109,15 +111,17 @@ export class MessageClient {
     subscribeAll(listener) { this.allListeners.add(listener); return () => { this.allListeners.delete(listener); }; }
     /** Close the connection gap for saved windows with four bounded background lanes. */
     async restore(since, threadId) {
+        if (this.closed || this.closing || this.scopeDenied || isOffline())
+            return;
         const queue = (await this.storage.windows()).filter(window => (window.syncedAt ?? 0) < since && !window.revoked && (threadId === undefined || window.thread === threadId));
         await Promise.all(Array.from({ length: Math.min(4, queue.length) }, async () => {
-            while (queue.length && !this.closed && !this.closing) {
+            while (queue.length && !this.closed && !this.closing && !this.scopeDenied && !isOffline()) {
                 const window = queue.shift();
                 try {
                     await this.synchronize(window.thread);
                 }
                 catch (error) {
-                    if (!this.closed && !this.closing)
+                    if (!this.closed && !this.closing && !isOfflineNetworkFailure(error))
                         this.options.onError?.(error, window.thread);
                 }
             }
@@ -198,8 +202,11 @@ export class MessageClient {
     }
     /** Application connection/wake events invalidate, rather than fetching directly. */
     invalidate(thread) {
-        if (!this.closed && !this.closing && !this.revoked.has(thread))
-            this.syncTasks.schedule(thread, () => this.synchronize(thread));
+        if (!this.closed && !this.closing && !this.scopeDenied && !isOffline() && !this.revoked.has(thread))
+            this.syncTasks.schedule(thread, async () => {
+                if (!isOffline())
+                    await this.synchronize(thread);
+            });
     }
     async fallback(thread, limit, before) {
         await this.ensureScope();

package/lib/runtime/messageReaders.js

@@ -1,3 +1,4 @@
+import { isOffline } from "./connectivity.js";
 import { IndexedDbResponseCache, isResponseCacheAuthorityError, assertResponseCacheAccess } from "./responseCache.js";
 import { messageScopeKey } from "./messageStore.js";
 export class MessageReadersError extends Error {
@@ -95,6 +96,8 @@ export class MessageReadersClient {
         const scopeVersion = this.options.access ? await assertResponseCacheAccess(this.options.access) : undefined;
         if (this.lifetime.signal.aborted)
             throw new Error("MESSAGE_READERS_CLOSED");
+        if (isOffline())
+            throw new MessageReadersError(0, "MESSAGE_READERS_OFFLINE_UNAVAILABLE");
         const { token, fetch: fetcher, hubHttpUrl, appId, profileId } = this.options;
         const controller = new AbortController();
         const cancel = () => controller.abort(this.lifetime.signal.reason);

package/lib/runtime/readCounts.js

@@ -1,3 +1,4 @@
+import { isOffline, isOfflineNetworkFailure } from "./connectivity.js";
 import { IndexedDbResponseCache, isResponseCacheAuthorityError, assertResponseCacheAccess } from "./responseCache.js";
 import { messageScopeKey } from "./messageStore.js";
 let subscriptionSequence = 0;
@@ -59,6 +60,8 @@ export class ReadCountsClient {
         return envelope.data;
     }
     subscription(threadId, release) {
+        if (release && isOffline())
+            return Promise.resolve();
         return this.post("/api/social/reading/subscription", { appId: this.options.appId, profileId: this.options.profileId, threadId, clientInstanceId: this.options.clientInstanceId, sequence: nextSubscriptionSequence(), release });
     }
     renew() {
@@ -98,7 +101,8 @@ export class ReadCountsClient {
                 clearInterval(this.heartbeat);
                 this.heartbeat = undefined;
             }
-            this.options.onError?.(error);
+            if (!isOfflineNetworkFailure(error))
+                this.options.onError?.(error);
         }).finally(() => { if (this.subscriptionPending === pending)
             this.subscriptionPending = undefined; });
         this.subscriptionPending = pending;
@@ -197,6 +201,8 @@ export class ReadCountsClient {
                 if (offline || (!force && this.requestedRevision <= this.revision && Date.now() - cached.time < 5000))
                     return;
             }
+            if (isOffline())
+                return;
             const value = await this.post("/api/social/reading/counts", { appId: this.options.appId, profileId: this.options.profileId, threadId, messageIds: ids }, controller.signal);
             if (generation !== this.generation || this.closed || accessVersion !== this.accessVersion)
                 return;
@@ -217,6 +223,10 @@ export class ReadCountsClient {
                 this.renew();
         }
         catch (error) {
+            if (isOfflineNetworkFailure(error)) {
+                this.dirty = false;
+                return;
+            }
             if (!controller.signal.aborted && generation === this.generation && !this.closed) {
                 if (/READ_COUNTS_HTTP_(401|403)/.test(String(error)))
                     this.denyCache();

package/lib/runtime/readingClient.js

@@ -1,3 +1,4 @@
+import { isOffline, isOfflineNetworkFailure } from "./connectivity.js";
 import { recordConversationRead } from "./conversationRead.js";
 import { BatchedReadIndex } from "./batchedReadIndex.js";
 import { WindowedTasks } from "./coalescer.js";
@@ -40,7 +41,7 @@ export class ReadingClient {
         this.listeners.forEach(listener => listener());
     }
     failed(error) {
-        if (this.closed)
+        if (this.closed || isOfflineNetworkFailure(error))
             return;
         this.options.onError?.(error);
         if (/HTTP_(400|401|403)/.test(String(error)) || (typeof navigator !== "undefined" && !navigator.onLine) || this.retry)
@@ -63,8 +64,9 @@ export class ReadingClient {
         this.refresh();
     }
     refresh = () => {
-        if (!this.closed)
-            this.tasks.schedule("reading", async () => { await this.synchronize(); });
+        if (!this.closed && !isOffline())
+            this.tasks.schedule("reading", async () => { if (!isOffline())
+                await this.synchronize(); });
     };
     async synchronize(targetCursor, profileId) {
         if (this.closed)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.23",
+  "version": "0.12.0-next.24",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",