@pmate/chat-sdk 0.12.0-next.46 → 0.12.0-next.48

package/lib/runtime/messageClient.d.ts

@@ -90,6 +90,7 @@ export declare class MessageClient<T extends StoredMessage> {
     private release;
     private flushWrites;
     private runWrites;
+    private assertNetworkAvailable;
     synchronize(thread: string): Promise<void>;
     /** Keep an explicitly requested history range in the shared subscribed view. */
     expandWindow(thread: string, page: MessageSnapshot<T>): Promise<void>;

package/lib/runtime/messageClient.js

@@ -168,7 +168,8 @@ export class MessageClient {
                     const fallback = await this.fallback(thread, limit);
                     if (!fallback.messages.length)
                         throw error;
-                    this.options.onError?.(error, thread);
+                    if (!isOfflineNetworkFailure(error))
+                        this.options.onError?.(error, thread);
                     return fallback;
                 }
             }
@@ -188,7 +189,8 @@ export class MessageClient {
                 const cached = await this.fallback(thread, limit);
                 if (!cached.messages.length)
                     throw error;
-                this.options.onError?.(error, thread);
+                if (!isOfflineNetworkFailure(error))
+                    this.options.onError?.(error, thread);
                 return cached;
             }
             const snapshot = await this.reload(thread);
@@ -433,6 +435,12 @@ export class MessageClient {
             this.release(queue);
         }
     }
+    assertNetworkAvailable(thread) {
+        if (this.closed || this.closing || this.scopeDenied || this.revoked.has(thread))
+            throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
+        if (isOffline())
+            throw new TypeError("MESSAGE_OFFLINE_UNAVAILABLE");
+    }
     synchronize(thread) {
         if (this.closed || this.closing || this.scopeDenied || this.revoked.has(thread))
             return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
@@ -449,6 +457,7 @@ export class MessageClient {
             }
             let version = coverage?.resetVersion ?? 0;
             let after = coverage?.complete ? coverage.checkpoint : undefined;
+            this.assertNetworkAvailable(thread);
             let page = after && this.options.transport.changes
                 ? await this.options.transport.changes(thread, after, this.abort.signal)
                 : await this.options.transport.load(thread, this.abort.signal);
@@ -457,6 +466,7 @@ export class MessageClient {
                     throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
                 version = await this.storage.resetThread(thread, false, scopeVersion);
                 after = undefined;
+                this.assertNetworkAvailable(thread);
                 page = await this.options.transport.load(thread, this.abort.signal);
             }
             for (;;) {
@@ -470,6 +480,7 @@ export class MessageClient {
                 if (!page.checkpoint || page.checkpoint === after || !this.options.transport.changes)
                     throw new Error("MESSAGE_SYNC_NO_PROGRESS");
                 after = page.checkpoint;
+                this.assertNetworkAvailable(thread);
                 page = await this.options.transport.changes(thread, after, this.abort.signal);
             }
         })().catch(async (error) => {
@@ -530,7 +541,8 @@ export class MessageClient {
             const fallback = await this.fallback(thread, limit, before);
             if (!fallback.messages.length)
                 throw error;
-            this.options.onError?.(error, thread);
+            if (!isOfflineNetworkFailure(error))
+                this.options.onError?.(error, thread);
             return fallback;
         }
     }
@@ -546,6 +558,7 @@ export class MessageClient {
             }
             const token = page.coverage.nextBefore, version = page.coverage.resetVersion ?? 0, scopeVersion = page.coverage.scopeVersion ?? 0;
             const task = (async () => {
+                this.assertNetworkAvailable(thread);
                 const remote = await this.options.transport.older(thread, token, this.abort.signal);
                 if (this.closed || this.scopeDenied || this.revoked.has(thread))
                     throw new Error("MESSAGE_CLIENT_UNAVAILABLE");

package/lib/runtime/readIndex.d.ts

@@ -71,6 +71,7 @@ export declare function installReadSnapshot(current: ReadIndexState, snapshot: R
 export declare function applyReadChange(current: ReadIndexState, change: ReadChange): ReadIndexState;
 /** Persist observations even if the message arrived before its Sequence metadata. */
 export declare function recordReadIntent(current: ReadIndexState, intent: ObservedReadIntent): ReadIndexState;
+export declare function resolveObservedReads(current: ReadIndexState): ReadIndexState;
 /** Called only for a message the visible viewport actually reached. */
 export declare function recordVisibleRead(current: ReadIndexState, threadId: string, messageId: string, operationId: string): ReadIndexState;
 export declare function recordExplicitRead(current: ReadIndexState, threadId: string, messageId: string, operationId: string): ReadIndexState;

package/lib/runtime/readIndex.js

@@ -105,12 +105,12 @@ export function recordReadIntent(current, intent) {
         throw new Error("INVALID_READ_INTENT");
     const observed = current.observedReadIntents ?? [];
     if (observed.some(item => item.threadId === intent.threadId && item.messageId === intent.messageId && item.readPolicy === intent.readPolicy))
-        return current;
+        return resolveObservedReads(current);
     if (observed.some(item => item.operationId === intent.operationId) || current.pending.some(item => item.operationId === intent.operationId))
         throw new Error("INVALID_READ_OPERATION_ID");
     return resolveObservedReads({ ...current, observedReadIntents: [...observed, structuredClone(intent)] });
 }
-function resolveObservedReads(current) {
+export function resolveObservedReads(current) {
     let next = current;
     const remaining = [];
     for (const intent of current.observedReadIntents ?? []) {
@@ -127,6 +127,9 @@ function resolveObservedReads(current) {
         next = intent.readPolicy === "explicit" ? recordExplicitRead(next, intent.threadId, intent.messageId, intent.operationId)
             : recordVisibleRead(next, intent.threadId, intent.messageId, intent.operationId);
     }
+    const previous = current.observedReadIntents;
+    if (next === current && previous && previous.length === remaining.length && previous.every((intent, i) => intent === remaining[i]))
+        return current;
     return { ...next, observedReadIntents: remaining };
 }
 /** Called only for a message the visible viewport actually reached. */
@@ -231,6 +234,9 @@ export class IndexedDbReadIndex {
         // Native indexes track scalar source identity even when an older writer
         // changes rows. Reading these keys does not deserialize messageIds arrays.
         this.database.version(4).stores({ readThreads: "[owner+id],owner,[owner+id+value.kind+value.teamId],[owner+value.conversationId+value.kind+value.teamId+id],[owner+id+value.conversationId]" });
+        // Keep v4 indexes for already-open older SDKs, and make source discovery
+        // dense for legitimate legacy rows whose optional team field is absent.
+        this.database.version(5).stores({ readThreads: "[owner+id],owner,[owner+id+value.kind+value.teamId],[owner+value.conversationId+value.kind+value.teamId+id],[owner+id+value.conversationId],[owner+id+value.kind],[owner+value.conversationId+value.kind+id]" });
         this.positionRows = this.database.table("readPositions");
         this.threadRows = this.database.table("readThreads");
         this.messageRows = this.database.table("readMessages");
@@ -451,16 +457,23 @@ export class IndexedDbReadIndex {
             return undefined;
         const sources = new Map();
         for (const threadId of new Set(scope.targets.map(target => target.threadId))) {
-            const direct = await this.threadRows.where("[owner+id+value.kind+value.teamId]").between([owner, threadId, Dexie.minKey], [owner, threadId, Dexie.maxKey], true, true).limit(129).keys();
-            const assigned = await this.threadRows.where("[owner+value.conversationId+value.kind+value.teamId+id]").between([owner, threadId, Dexie.minKey], [owner, threadId, Dexie.maxKey], true, true).limit(129).keys();
+            const direct = await this.threadRows.where("[owner+id+value.kind]").between([owner, threadId, Dexie.minKey], [owner, threadId, Dexie.maxKey], true, true).limit(129).keys();
+            const assigned = await this.threadRows.where("[owner+value.conversationId+value.kind+id]").between([owner, threadId, Dexie.minKey], [owner, threadId, Dexie.maxKey], true, true).limit(129).keys();
             if (direct.length + assigned.length > 128)
                 return undefined;
-            const identities = [...direct.map(value => ({ id: value[1], kind: value[2], teamId: value[3] })), ...assigned.map(value => ({ id: value[4], kind: value[2], teamId: value[3] }))];
-            if (!identities.length && base.threads.some(thread => thread.id === threadId || thread.conversationId === threadId))
+            const identities = [...new Map([...direct.map(value => ({ id: value[1], kind: value[2] })), ...assigned.map(value => ({ id: value[3], kind: value[2] }))].map(value => [value.id, value])).values()];
+            const indexedIds = new Set(identities.map(identity => identity.id));
+            const expected = base.threads.filter(thread => thread.id === threadId || thread.conversationId === threadId);
+            // Sparse indexes omit legacy sources without team metadata. A partial
+            // family cannot safely resolve an observation for the logical thread.
+            if (indexedIds.size !== expected.length || expected.some(thread => !indexedIds.has(thread.id)))
                 return undefined;
             for (const identity of identities) {
                 const cached = base.threads.find(thread => thread.id === identity.id);
-                if (!cached || cached.kind !== identity.kind || cached.teamId !== identity.teamId)
+                if (!cached || cached.kind !== identity.kind)
+                    return undefined;
+                const team = await this.threadRows.where("[owner+id+value.kind+value.teamId]").between([owner, identity.id, Dexie.minKey], [owner, identity.id, Dexie.maxKey], true, true).limit(2).keys();
+                if (team.length > 1 || cached.teamId !== team[0]?.[3])
                     return undefined;
                 const mapping = await this.threadRows.where("[owner+id+value.conversationId]").between([owner, identity.id, Dexie.minKey], [owner, identity.id, Dexie.maxKey], true, true).limit(2).keys();
                 if (mapping.length > 1 || cached.conversationId !== mapping[0]?.[2])

package/lib/runtime/readSync.js

@@ -1,4 +1,4 @@
-import { readingMetadata, assertReadIndexVersions, applyReadChange, ReadSyncGap, createReadIndex, installReadSnapshot } from "./readIndex.js";
+import { readingMetadata, resolveObservedReads, assertReadIndexVersions, applyReadChange, ReadSyncGap, createReadIndex, installReadSnapshot } from "./readIndex.js";
 /** Keeps local operations until an authoritative projection covers them. */
 export class ReadSyncClient {
     options;
@@ -11,9 +11,13 @@ export class ReadSyncClient {
     async loadLocal() {
         const { appId, profileId, persistence, metadataOnly } = this.options;
         const state = await persistence.load(appId, profileId) ?? createReadIndex(appId, profileId);
-        if (!metadataOnly || readingMetadata(state) === state)
+        const normalize = (current) => {
+            const next = metadataOnly ? readingMetadata(current) : current;
+            return next.observedReadIntents?.length ? resolveObservedReads(next) : next;
+        };
+        if (normalize(state) === state)
             return state;
-        return persistence.update(appId, profileId, readingMetadata);
+        return persistence.update(appId, profileId, normalize);
     }
     stop() { this.controller.abort(); }
     synchronize() {

package/package.json

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