@pmate/chat-sdk 0.12.0-next.12 → 0.12.0-next.14

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";
@@ -10,6 +12,7 @@ export type ChatSessionOptions<T extends StoredMessage> = {
     messages: MessageClientOptions<T>;
     connection: ChatClientOptions;
     sharedConnection?: ChatClient;
+    activeThreadId?: string;
     reading: ReadingClientOptions;
     decode: (message: ChatRuntimeMessage) => T | undefined;
     onError: (error: unknown) => void;
@@ -20,6 +23,7 @@ export type ChatThreadSnapshot<T> = {
     hasEarlier: boolean;
     resetVersion: number;
     complete: boolean;
+    readCounts?: ReadCountsResult;
     unread: ReturnType<typeof unreadInConversation> | undefined;
 };
 export type ChatSummarySnapshot<T> = {
@@ -40,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;
@@ -86,7 +96,13 @@ 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 publishCounts;
+    private watchCounts;
     getSnapshot(): ChatSummarySnapshot<T>;
     getSnapshot(threadId: string): ChatThreadSnapshot<T>;
     subscribe(listener: () => void): () => void;

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 => {
@@ -64,9 +79,10 @@ export class ChatSession {
             this.publishGlobal();
             if (state === "connected") {
                 const since = Date.now();
-                this.catchUp.schedule("scope", () => this.messages.restore(since));
+                this.catchUp.schedule("scope", () => this.messages.restore(since, options.activeThreadId));
                 if (this.readingStarted)
                     this.reading.refresh();
+                this.wakeCounts();
             }
         }));
     }
@@ -188,15 +204,105 @@ export class ChatSession {
         this.assertOpen();
         return this.sender.enqueue(threadId, input);
     }
-    getReaders(threadId, messageId, page = {}, signal) {
+    async getReaders(threadId, messageId, page = {}, signal) {
+        this.assertOpen();
+        const result = await this.readers.getReaders({ ...page, threadId, messageId }, signal);
         this.assertOpen();
-        return this.readers.getReaders({ ...page, threadId, messageId }, signal);
+        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(); });
+    }
+    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.publish(oldest, false);
+        }
+        this.publish(value.threadId, false);
+    }
+    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.publish(thread, false));
+                    }
+                    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,7 +313,7 @@ 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;
@@ -277,13 +383,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/createChat.d.ts

@@ -11,6 +11,8 @@ export type CreateChatOptions = {
     profileId: string;
     teamId: string;
     token: string;
+    /** Limit reconnect reconciliation for a dedicated conversation document. */
+    threadId?: string;
     endpoint?: string;
     clientInstanceId?: string;
     fetch?: typeof fetch;

package/lib/runtime/createChat.js

@@ -16,6 +16,7 @@ export function createChat(options) {
     };
     return new ChatSession({
         sharedConnection: options.connection,
+        activeThreadId: options.threadId,
         messages: { scope: { appId, accountId, profileId, teamId }, transport: { load: (thread, signal) => page(thread, signal), changes: (thread, after, signal) => page(thread, signal, { after }), older: (thread, before, signal) => page(thread, signal, { before }) }, onError },
         reading: { appId, profileId, sessionToken: token, hubHttpUrl: http, fetch: options.fetch, onError },
         connection: { appId, profileId, teamId, hubUrl: ws, clientInstanceId: options.clientInstanceId, fetchImpl: options.fetch,

package/lib/runtime/messageClient.d.ts

@@ -59,7 +59,7 @@ export declare class MessageClient<T extends StoredMessage> {
     subscribe(thread: string, listener: () => void): () => void;
     subscribeAll(listener: (threadId: string) => void): () => void;
     /** Close the connection gap for saved windows with four bounded background lanes. */
-    restore(since: number): Promise<void>;
+    restore(since: number, threadId?: string): Promise<void>;
     read(thread: string, limit?: number, refresh?: boolean): Promise<MessageSnapshot<T>>;
     /** Application connection/wake events invalidate, rather than fetching directly. */
     invalidate(thread: string): void;

package/lib/runtime/messageClient.js

@@ -71,8 +71,8 @@ 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) {
-        const queue = (await this.storage.windows()).filter(window => (window.syncedAt ?? 0) < since && !window.revoked);
+    async restore(since, threadId) {
+        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) {
                 const window = queue.shift();

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.12",
+  "version": "0.12.0-next.14",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",