@pmate/chat-sdk 0.12.0-next.13 → 0.12.0-next.15

package/lib/runtime/chatClient.d.ts

@@ -62,6 +62,7 @@ export declare class ChatClient {
         profileId: string | undefined;
         accountId: string | undefined;
         teamId: string | undefined;
+        clientInstanceId: string;
     };
     watchConnection(handler: (state: ChatConnectionState) => void): () => void;
     private setConnection;

package/lib/runtime/chatClient.js

@@ -123,7 +123,7 @@ export class ChatClient {
     /** Non-secret identity used to validate a shared browser transport. */
     identityScope() {
         const identity = this.session?.identity ?? this.session?.session?.identity;
-        return { appId: this.options.appId, profileId: this.profileIdValue ?? this.options.profileId, accountId: identity?.accountId, teamId: this.options.teamId };
+        return { appId: this.options.appId, profileId: this.profileIdValue ?? this.options.profileId, accountId: identity?.accountId, teamId: this.options.teamId, clientInstanceId: this.instanceId };
     }
     watchConnection(handler) {
         this.connectionHandlers.add(handler);

package/lib/runtime/chatSession.d.ts

@@ -1,3 +1,5 @@
+import { type ReadCountsResult } from "./readCounts.js";
+import type { OnlineReachEvent } from "./reach.js";
 import { type MessageReadersQuery } from "./messageReaders.js";
 import { type MessageClientOptions, type MessageSnapshot } from "./messageClient.js";
 import { DurableChatSender } from "./durableSender.js";
@@ -21,6 +23,7 @@ export type ChatThreadSnapshot<T> = {
     hasEarlier: boolean;
     resetVersion: number;
     complete: boolean;
+    readCounts?: ReadCountsResult;
     unread: ReturnType<typeof unreadInConversation> | undefined;
 };
 export type ChatSummarySnapshot<T> = {
@@ -41,6 +44,12 @@ export declare class ChatSession<T extends StoredMessage> {
     private connection;
     private reading;
     private readers;
+    private counts?;
+    private countsReceiver?;
+    private countsThread?;
+    private countSnapshots;
+    private countClosings;
+    private countTasks;
     private sender;
     private listeners;
     private snapshots;
@@ -87,11 +96,18 @@ export declare class ChatSession<T extends StoredMessage> {
     }): Promise<ChatRuntimeMessage>;
     getReaders(threadId: string, messageId: string, page?: Omit<MessageReadersQuery, "threadId" | "messageId">, signal?: AbortSignal): Promise<import("./messageReaders.js").MessageReadersPage>;
     retryMessage(messageId: string): Promise<ChatRuntimeMessage>;
-    observeMessages(threadId: string, ids: string[], event: "visible" | "played"): Promise<import("./readIndex.js").ReadIndexState>;
+    observeMessages(threadId: string, ids: string[], event: "visible" | "played"): ReturnType<ReadingClient["recordVisible"]>;
+    observeMessages(threadId: string | undefined, ids: string[], event: "receipts", clientInstanceId?: string): Promise<void>;
+    /** Bridge transports can delegate social events without maintaining clients. */
+    handleReach(event: OnlineReachEvent): Promise<"handled" | undefined>;
+    private wakeCounts;
+    private publishCountSnapshot;
+    private publishCounts;
+    private watchCounts;
     getSnapshot(): ChatSummarySnapshot<T>;
     getSnapshot(threadId: string): ChatThreadSnapshot<T>;
     subscribe(listener: () => void): () => void;
-    subscribe(threadId: string, listener: () => void): () => void;
+    subscribe(threadId: string, listener: () => void, fields?: readonly (keyof ChatThreadSnapshot<T>)[]): () => void;
     private publishAll;
     private buildGlobal;
     private publishGlobal;

package/lib/runtime/chatSession.js

@@ -1,3 +1,4 @@
+import { ReadCountsClient } from "./readCounts.js";
 import { WindowedTasks } from "./coalescer.js";
 import { MessageReadersClient } from "./messageReaders.js";
 import { MessageClient } from "./messageClient.js";
@@ -12,6 +13,12 @@ export class ChatSession {
     connection;
     reading;
     readers;
+    counts;
+    countsReceiver;
+    countsThread;
+    countSnapshots = new Map();
+    countClosings = new Set();
+    countTasks;
     sender;
     listeners = new Map();
     snapshots = new Map();
@@ -44,6 +51,14 @@ export class ChatSession {
         this.sender = new DurableChatSender(this.connection, scope, options.onError);
         this.catchUp = new WindowedTasks(1000, error => { if (!this.closed)
             options.onError(error); });
+        this.countTasks = new WindowedTasks(50, error => { if (!this.closed)
+            options.onError(error); });
+        if (typeof window !== "undefined") {
+            const wake = () => this.wakeCounts();
+            window.addEventListener("online", wake);
+            window.addEventListener("focus", wake);
+            this.off.push(() => { window.removeEventListener("online", wake); window.removeEventListener("focus", wake); });
+        }
         this.off.push(this.messages.subscribeAll(thread => this.publish(thread)));
         this.off.push(this.sender.subscribe(() => this.publishAll()), this.reading.subscribe(() => this.publishAll()));
         this.off.push(this.connection.watchMessages(message => {
@@ -67,6 +82,7 @@ export class ChatSession {
                 this.catchUp.schedule("scope", () => this.messages.restore(since, options.activeThreadId));
                 if (this.readingStarted)
                     this.reading.refresh();
+                this.wakeCounts();
             }
         }));
     }
@@ -188,15 +204,115 @@ export class ChatSession {
         this.assertOpen();
         return this.sender.enqueue(threadId, input);
     }
-    getReaders(threadId, messageId, page = {}, signal) {
+    async getReaders(threadId, messageId, page = {}, signal) {
         this.assertOpen();
-        return this.readers.getReaders({ ...page, threadId, messageId }, signal);
+        const result = await this.readers.getReaders({ ...page, threadId, messageId }, signal);
+        this.assertOpen();
+        if (!result.resetRequired) {
+            const previous = this.countSnapshots.get(threadId);
+            if (!previous || previous.revision <= result.revision) {
+                this.publishCounts({ appId: result.appId, threadId, revision: result.revision, counts: { ...previous?.counts, [messageId]: result.total } });
+                this.counts?.changed(threadId, result.revision);
+            }
+        }
+        return result;
     }
     retryMessage(messageId) { this.assertOpen(); return this.sender.retry(messageId); }
-    observeMessages(threadId, ids, event) {
+    observeMessages(threadId, ids, event, clientInstanceId) {
+        if (this.closed && event === "receipts" && !threadId)
+            return Promise.resolve();
         this.assertOpen();
+        if (event === "receipts") {
+            this.watchCounts(threadId, ids, clientInstanceId);
+            return Promise.resolve();
+        }
+        if (!threadId)
+            throw new Error("INVALID_READING_THREAD");
         return event === "played" ? this.reading.recordExplicit(threadId, ids) : this.reading.recordVisible(threadId, ids);
     }
+    /** Bridge transports can delegate social events without maintaining clients. */
+    async handleReach(event) {
+        this.assertOpen();
+        if (!["social.readCountsChanged", "social.readStateChanged"].includes(event.eventType))
+            return undefined;
+        if (event.appId !== this.options.messages.scope.appId)
+            throw new Error("UNEXPECTED_READING_APPLICATION");
+        if (event.eventType === "social.readCountsChanged") {
+            if (typeof event.payload.threadId !== "string" || !Number.isSafeInteger(event.payload.revision) || Number(event.payload.revision) < 0)
+                throw new Error("INVALID_READ_COUNTS_EVENT");
+            this.counts?.changed(event.payload.threadId, Number(event.payload.revision));
+        }
+        else {
+            if (typeof event.payload.syncCursor !== "string" || !/^v1:\d+$/.test(event.payload.syncCursor) || typeof event.payload.profileId !== "string")
+                throw new Error("INVALID_READING_EVENT");
+            if (event.payload.profileId !== this.options.messages.scope.profileId)
+                throw new Error("Reading reach identity mismatch");
+            await this.initialize();
+            await this.reading.synchronize(event.payload.syncCursor, event.payload.profileId);
+            this.assertOpen();
+        }
+        return "handled";
+    }
+    wakeCounts() {
+        if (this.counts && this.countsThread && !this.closed)
+            this.countTasks.schedule("counts", async () => { this.counts?.reconnect(); });
+    }
+    publishCountSnapshot(thread) {
+        const previous = this.snapshots.get(thread);
+        if (!previous) {
+            this.publish(thread, false);
+            return;
+        }
+        // Receipt-only updates never serialize or rebuild message bodies.
+        this.snapshots.set(thread, { ...previous, readCounts: this.countSnapshots.get(thread) });
+        this.listeners.get(thread)?.forEach(listener => listener());
+    }
+    publishCounts(value) {
+        const previous = this.countSnapshots.get(value.threadId);
+        if ((previous && previous.revision > value.revision) || JSON.stringify(previous) === JSON.stringify(value))
+            return;
+        this.countSnapshots.delete(value.threadId);
+        this.countSnapshots.set(value.threadId, value);
+        if (this.countSnapshots.size > 128) {
+            const oldest = this.countSnapshots.keys().next().value;
+            this.countSnapshots.delete(oldest);
+            this.publishCountSnapshot(oldest);
+        }
+        this.publishCountSnapshot(value.threadId);
+    }
+    watchCounts(threadId, ids, receiver = this.connection.identityScope().clientInstanceId) {
+        if (!threadId || !ids.length) {
+            this.countsThread = undefined;
+            this.counts?.watch(undefined, []);
+            return;
+        }
+        if (!receiver || receiver.length > 512 || /[\x00-\x1f]/.test(receiver))
+            throw new Error("INVALID_READ_COUNTS_RECEIVER");
+        if (!this.counts || this.countsReceiver !== receiver) {
+            if (this.counts) {
+                const closing = this.counts.close().finally(() => this.countClosings.delete(closing));
+                this.countClosings.add(closing);
+            }
+            const scope = this.options.messages.scope;
+            const client = new ReadCountsClient({ appId: scope.appId, profileId: scope.profileId, scope, token: this.options.reading.sessionToken, clientInstanceId: receiver, hubHttpUrl: this.options.reading.hubHttpUrl, fetch: this.options.reading.fetch,
+                onChange: value => { if (!this.closed && this.counts === client)
+                    this.publishCounts(value); },
+                onError: error => {
+                    if (this.closed || this.counts !== client)
+                        return;
+                    if (/READ_COUNTS_HTTP_(401|403)/.test(String(error))) {
+                        const threads = [...this.countSnapshots.keys()];
+                        this.countSnapshots.clear();
+                        threads.forEach(thread => this.publishCountSnapshot(thread));
+                    }
+                    this.options.onError(error);
+                } });
+            this.counts = client;
+            this.countsReceiver = receiver;
+        }
+        this.countsThread = threadId;
+        this.counts.watch(threadId, ids);
+    }
     getSnapshot(threadId) {
         if (threadId === undefined) {
             if (!this.globalSnapshot)
@@ -207,19 +323,28 @@ export class ChatSession {
         if (!snapshot) {
             const messages = this.messages.getSnapshot(threadId);
             const state = this.reading.getSnapshot();
-            snapshot = { messages: messages?.messages ?? [], hasEarlier: messages?.hasEarlier ?? false, resetVersion: messages?.resetVersion ?? 0, complete: messages?.complete ?? false, outgoing: this.sender.snapshot(threadId), unread: state?.threads.some(thread => (thread.conversationId ?? thread.id) === threadId) ? unreadInConversation(state, threadId) : undefined };
+            snapshot = { messages: messages?.messages ?? [], hasEarlier: messages?.hasEarlier ?? false, resetVersion: messages?.resetVersion ?? 0, complete: messages?.complete ?? false, outgoing: this.sender.snapshot(threadId), readCounts: this.countSnapshots.get(threadId), unread: state?.threads.some(thread => (thread.conversationId ?? thread.id) === threadId) ? unreadInConversation(state, threadId) : undefined };
             this.snapshots.set(threadId, snapshot);
         }
         return snapshot;
     }
-    subscribe(target, listener) {
+    subscribe(target, listener, fields) {
         this.assertOpen();
         if (typeof target === "function") {
             this.globalListeners.add(target);
             return () => { this.globalListeners.delete(target); };
         }
         const threadId = target;
-        const notify = listener;
+        const selected = fields ? [...fields] : undefined;
+        let values = selected?.map(field => this.getSnapshot(threadId)[field]);
+        const equal = (a, b) => a === b || (Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((value, index) => value === b[index]));
+        const notify = selected ? () => {
+            const next = selected.map(field => this.getSnapshot(threadId)[field]);
+            const changed = next.some((value, index) => !equal(value, values[index]));
+            values = next;
+            if (changed)
+                listener();
+        } : listener;
         let listeners = this.listeners.get(threadId);
         if (!listeners) {
             listeners = new Set();
@@ -277,13 +402,15 @@ export class ChatSession {
         return this.closing ??= (async () => {
             this.closed = true;
             this.catchUp.close();
+            this.countTasks.close();
             this.off.splice(0).forEach(off => off());
             if (!this.options.sharedConnection)
                 this.connection.close();
-            await Promise.all([this.readers.close(), this.sender.close(), this.reading.close(), this.messages.close()]);
+            await Promise.all([this.counts?.close(), ...this.countClosings, this.readers.close(), this.sender.close(), this.reading.close(), this.messages.close()]);
             this.listeners.clear();
             this.globalListeners.clear();
             this.snapshots.clear();
+            this.countSnapshots.clear();
             this.historyEdges.clear();
             this.earlierReads.clear();
             this.globalSnapshot = undefined;

package/lib/runtime/responseCache.d.ts

@@ -8,6 +8,7 @@ export declare class IndexedDbResponseCache<T> {
     private pending;
     private tasks;
     private running?;
+    private invalidations;
     private closed;
     private closing?;
     constructor(scope: string, options?: {

package/lib/runtime/responseCache.js

@@ -10,6 +10,7 @@ export class IndexedDbResponseCache {
     pending = [];
     tasks = new WindowedTasks(16, () => { });
     running;
+    invalidations = new Set();
     closed = false;
     closing;
     constructor(scope, options = {}) {
@@ -40,14 +41,18 @@ export class IndexedDbResponseCache {
         this.tasks.schedule("write", () => this.flush());
         return promise;
     }
-    async invalidate() {
+    invalidate() {
         if (this.closed)
-            throw new Error("RESPONSE_CACHE_CLOSED");
-        await this.db.transaction("rw", this.rows, this.epochs, async () => {
-            const epoch = ((await this.epochs.get(this.scope))?.epoch ?? 0) + 1;
-            await this.epochs.put({ scope: this.scope, epoch });
-            await this.rows.where("scope").equals(this.scope).delete();
-        });
+            return Promise.reject(new Error("RESPONSE_CACHE_CLOSED"));
+        const task = (async () => {
+            await this.db.transaction("rw", this.rows, this.epochs, async () => {
+                const epoch = ((await this.epochs.get(this.scope))?.epoch ?? 0) + 1;
+                await this.epochs.put({ scope: this.scope, epoch });
+                await this.rows.where("scope").equals(this.scope).delete();
+            });
+        })();
+        this.invalidations.add(task);
+        return task.finally(() => this.invalidations.delete(task));
     }
     async flush() {
         if (this.running) {
@@ -96,7 +101,7 @@ export class IndexedDbResponseCache {
         this.tasks.close();
         return this.closing = (async () => {
             try {
-                await this.flush();
+                await Promise.all([this.flush(), ...this.invalidations]);
             }
             finally {
                 this.db.close();

package/package.json

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