@pmate/chat-sdk 0.12.0-next.5 → 0.12.0-next.6

package/README.md

@@ -143,6 +143,9 @@ The browser entry point is `createChat` from `@pmate/chat-sdk/runtime`:
 const chat = createChat({ appId, accountId, profileId, teamId, token, onError })
 await chat.start()
 const page = await chat.getMessages(threadId, { limit: 50 })
+// After an authoritative mutation (e.g. history assignment), await reconciliation.
+// Concurrent refreshes share transport; errors do not masquerade as fresh cache.
+const reconciled = await chat.getMessages(threadId, { refresh: true })
 // Explicit full-history queries reuse cached pages and internally rebase expired cursors.
 const history = await chat.getMessages(threadId, { all: true })
 const off = chat.subscribe(threadId, () => render(chat.getSnapshot(threadId)))

package/lib/runtime/chatSession.d.ts

@@ -47,6 +47,8 @@ export declare class ChatSession<T extends StoredMessage> {
     private globalListeners;
     private globalSnapshot?;
     private connectionState;
+    private catchUp;
+    private readingStarted;
     private closed;
     private starting?;
     private closing?;
@@ -60,6 +62,7 @@ export declare class ChatSession<T extends StoredMessage> {
             id: string;
         };
         all?: boolean;
+        refresh?: boolean;
     }): Promise<MessageSnapshot<T>>;
     private readAll;
     sendMessage(threadId: string, input: {

package/lib/runtime/chatSession.js

@@ -1,3 +1,4 @@
+import { WindowedTasks } from "./coalescer.js";
 import { MessageReadersClient } from "./messageReaders.js";
 import { MessageClient } from "./messageClient.js";
 import { DurableChatSender } from "./durableSender.js";
@@ -18,6 +19,8 @@ export class ChatSession {
     globalListeners = new Set();
     globalSnapshot;
     connectionState = "closed";
+    catchUp;
+    readingStarted = false;
     closed = false;
     starting;
     closing;
@@ -36,12 +39,18 @@ export class ChatSession {
         this.reading = new ReadingClient({ ...options.reading, storageScope: JSON.stringify([scope.accountId, scope.teamId]) });
         this.readers = new MessageReadersClient({ appId: scope.appId, profileId: scope.profileId, token: options.reading.sessionToken, hubHttpUrl: options.reading.hubHttpUrl, fetch: options.reading.fetch });
         this.sender = new DurableChatSender(this.connection, scope, options.onError);
+        this.catchUp = new WindowedTasks(1000, error => { if (!this.closed)
+            options.onError(error); });
+        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 => {
             try {
                 const decoded = options.decode(message);
                 if (decoded)
-                    void this.messages.receive(decoded.threadId, [decoded]).then(() => { this.publish(decoded.threadId); return this.sender.confirm([message.hash]); }).catch(options.onError);
+                    void this.messages.receive(decoded.threadId, [decoded]).then(() => this.sender.confirm([message.hash])).catch(error => { if (String(error).includes("MESSAGE_PROJECTION_CHANGED"))
+                        this.messages.invalidate(decoded.threadId);
+                    else if (!this.closed)
+                        options.onError(error); });
             }
             catch (error) {
                 options.onError(error);
@@ -51,9 +60,10 @@ export class ChatSession {
             this.connectionState = state;
             this.publishGlobal();
             if (state === "connected") {
-                for (const thread of this.listeners.keys())
-                    this.messages.invalidate(thread);
-                this.reading.refresh();
+                const since = Date.now();
+                this.catchUp.schedule("scope", () => this.messages.restore(since));
+                if (this.readingStarted)
+                    this.reading.refresh();
             }
         }));
     }
@@ -61,6 +71,7 @@ export class ChatSession {
         this.assertOpen();
         return this.starting ??= (async () => {
             await this.sender.initialize();
+            this.readingStarted = true;
             await this.reading.start();
             this.assertOpen();
             await this.connection.connect();
@@ -70,15 +81,17 @@ export class ChatSession {
         throw new Error("CHAT_SESSION_CLOSED"); }
     async getMessages(threadId, options = {}) {
         this.assertOpen();
+        if (options.all && (options.before || options.limit !== undefined))
+            throw new Error("INVALID_MESSAGE_QUERY");
+        // Explicit authoritative changes (for example history assignment) can invalidate
+        // even a recently cached empty window. Keep this on the existing read surface.
+        if (options.refresh)
+            await this.messages.read(threadId, options.limit ?? 100, true);
         if (options.all) {
-            if (options.before || options.limit !== undefined)
-                throw new Error("INVALID_MESSAGE_QUERY");
             return this.readAll(threadId);
         }
         const page = await (options.before ? this.messages.earlier(threadId, options.before, options.limit) : this.messages.read(threadId, options.limit));
         await this.sender.confirm(page.messages.map(message => message.id));
-        if (!options.before)
-            this.publish(threadId);
         return page;
     }
     async readAll(threadId) {
@@ -161,7 +174,7 @@ export class ChatSession {
             this.listeners.set(threadId, listeners);
         }
         listeners.add(notify);
-        const off = this.messages.subscribe(threadId, () => this.publish(threadId));
+        const off = this.messages.subscribe(threadId, () => { });
         return () => {
             off();
             listeners.delete(notify);
@@ -209,6 +222,7 @@ export class ChatSession {
     close() {
         return this.closing ??= (async () => {
             this.closed = true;
+            this.catchUp.close();
             this.off.splice(0).forEach(off => off());
             if (!this.options.sharedConnection)
                 this.connection.close();

package/lib/runtime/messageClient.d.ts

@@ -36,6 +36,7 @@ export declare class MessageClient<T extends StoredMessage> {
     private options;
     private storage;
     private watches;
+    private allListeners;
     private reads;
     private syncing;
     private paging;
@@ -56,7 +57,10 @@ export declare class MessageClient<T extends StoredMessage> {
     constructor(options: MessageClientOptions<T>);
     getSnapshot(thread: string): MessageSnapshot<T> | undefined;
     subscribe(thread: string, listener: () => void): () => void;
-    read(thread: string, limit?: number): Promise<MessageSnapshot<T>>;
+    subscribeAll(listener: (threadId: string) => void): () => void;
+    /** Close the connection gap for saved windows with four bounded background lanes. */
+    restore(since: number): 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;
     private reload;
@@ -78,6 +82,7 @@ export declare class MessageClient<T extends StoredMessage> {
         complete: boolean;
     }>;
     private fillWindow;
+    private denyView;
     revoke(thread: string): Promise<void>;
     close(): Promise<void>;
 }

package/lib/runtime/messageClient.js

@@ -5,6 +5,7 @@ export class MessageClient {
     options;
     storage;
     watches = new Map();
+    allListeners = new Set();
     reads = new Map();
     syncing = new Map();
     paging = new Map();
@@ -32,12 +33,30 @@ export class MessageClient {
             throw new Error("INVALID_MESSAGE_BYTE_LIMIT");
         if (!Number.isSafeInteger(this.batchSize) || this.batchSize < 1 || this.batchSize > 1000)
             throw new Error("INVALID_MESSAGE_BATCH_SIZE");
-        this.writeTasks = new WindowedTasks(options.writeWindowMs ?? 16, (error, thread) => options.onError?.(error, thread));
+        this.writeTasks = new WindowedTasks(options.writeWindowMs ?? 16, (error, thread) => { if (String(error).includes("MESSAGE_PROJECTION_CHANGED"))
+            this.invalidate(thread);
+        else
+            options.onError?.(error, thread); });
         this.syncTasks = new WindowedTasks(options.syncWindowMs ?? 1000, (error, thread) => options.onError?.(error, thread));
         if (typeof BroadcastChannel !== "undefined") {
-            this.channel = new BroadcastChannel(`pmate-chat:${messageScopeKey(options.scope)}`);
-            this.channel.onmessage = event => { if (typeof event.data === "string" && this.watches.has(event.data))
-                void this.reload(event.data).catch(error => options.onError?.(error, event.data)); };
+            this.channel = new BroadcastChannel(`pmate-chat:${messageScopeKey(options.scope)}${this.storage.namespace === "pmate-chat-messages" ? "" : `:${this.storage.namespace}`}`);
+            this.channel.onmessage = event => {
+                if (this.closed)
+                    return;
+                if (event.data?.type === "revoked" && typeof event.data.thread === "string" && Number.isSafeInteger(event.data.version)) {
+                    const denied = event.data;
+                    void (async () => {
+                        const current = await this.storage.read(denied.thread, 1).then(page => page.coverage).catch(() => undefined);
+                        if (this.closed || (current && !current.revoked && (current.resetVersion ?? 0) >= denied.version))
+                            return;
+                        this.denyView(denied.thread, denied.version);
+                        options.onError?.(Object.assign(new Error("MESSAGE_ACCESS_REVOKED"), { status: 403 }), denied.thread);
+                    })();
+                }
+                else if (typeof event.data === "string" && this.watches.has(event.data))
+                    void this.reload(event.data).catch(error => { if (!this.closed)
+                        options.onError?.(error, event.data); });
+            };
         }
     }
     getSnapshot(thread) { return this.watches.get(thread)?.snapshot; }
@@ -50,19 +69,36 @@ export class MessageClient {
         watch.listeners.add(listener);
         return () => { watch.listeners.delete(listener); };
     }
-    read(thread, limit = 100) {
+    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);
+        await Promise.all(Array.from({ length: Math.min(4, queue.length) }, async () => {
+            while (queue.length && !this.closed && !this.closing) {
+                const window = queue.shift();
+                try {
+                    await this.synchronize(window.thread);
+                }
+                catch (error) {
+                    if (!this.closed && !this.closing)
+                        this.options.onError?.(error, window.thread);
+                }
+            }
+        }));
+    }
+    read(thread, limit = 100, refresh = false) {
         if (this.closed || this.closing)
             return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
             return Promise.reject(new Error("INVALID_MESSAGE_LIMIT"));
-        const key = JSON.stringify([thread, limit]), running = this.reads.get(key);
+        const key = JSON.stringify([thread, limit, refresh]), running = this.reads.get(key);
         if (running)
             return running;
         const task = (async () => {
             const local = await this.storage.read(thread, limit);
-            if (!local.coverage?.complete || local.coverage.revoked || this.revoked.has(thread)) {
+            if (refresh || !local.coverage?.complete || local.coverage.revoked || this.revoked.has(thread)) {
                 if (typeof navigator !== "undefined" && navigator.onLine === false) {
-                    if (local.messages.length && !local.coverage?.revoked)
+                    if (!refresh && local.messages.length && !local.coverage?.revoked)
                         return this.reload(thread);
                     throw new Error("MESSAGE_OFFLINE_UNAVAILABLE");
                 }
@@ -71,7 +107,7 @@ export class MessageClient {
                     await this.synchronize(thread);
                 }
                 catch (error) {
-                    if (!local.messages.length || [401, 403].includes(error?.status ?? 0))
+                    if (refresh || !local.messages.length || [401, 403].includes(error?.status ?? 0))
                         throw error;
                     this.options.onError?.(error, thread);
                     return this.reload(thread);
@@ -113,6 +149,10 @@ export class MessageClient {
         const page = await this.storage.read(thread, limit);
         if (this.closed)
             throw new Error("MESSAGE_CLIENT_CLOSED");
+        if (this.revoked.has(thread)) {
+            page.messages = [];
+            page.hasEarlier = false;
+        }
         let watch = this.watches.get(thread);
         const oldById = new Map(watch?.snapshot.messages.map(message => [message.id, message]));
         const messages = page.messages.map(message => {
@@ -120,22 +160,26 @@ export class MessageClient {
             return old && JSON.stringify(old) === JSON.stringify(message) ? old : message;
         });
         const old = watch?.snapshot;
-        const resetVersion = page.coverage?.resetVersion ?? 0, complete = page.coverage?.complete ?? false;
-        if (old && old.resetVersion === resetVersion && old.complete === complete && old.hasEarlier === (page.hasEarlier || Boolean(page.coverage?.nextBefore)) && old.messages.length === messages.length && old.messages.every((message, index) => message === messages[index]))
+        const resetVersion = Math.max(page.coverage?.resetVersion ?? 0, this.revoked.has(thread) ? watch?.snapshot.resetVersion ?? 0 : 0), complete = !this.revoked.has(thread) && (page.coverage?.complete ?? false);
+        const hasEarlier = !this.revoked.has(thread) && (page.hasEarlier || Boolean(page.coverage?.nextBefore));
+        if (old && old.resetVersion === resetVersion && old.complete === complete && old.hasEarlier === hasEarlier && old.messages.length === messages.length && old.messages.every((message, index) => message === messages[index]))
             return old;
-        const snapshot = { messages, resetVersion, complete, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore) };
+        const snapshot = { messages, resetVersion, complete, hasEarlier };
         if (!watch) {
             watch = { snapshot, listeners: new Set() };
             this.watches.set(thread, watch);
         }
         watch.snapshot = snapshot;
         watch.listeners.forEach(listener => listener());
+        this.allListeners.forEach(listener => listener(thread));
         return snapshot;
     }
     /** Events are visible only after their atomic batch commits. */
     receive(thread, messages) {
-        if (this.closed || this.closing || this.revoked.has(thread))
+        if (this.closed || this.closing)
             return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
+        if (this.revoked.has(thread))
+            return Promise.reject(new Error("MESSAGE_ACCESS_REVOKED"));
         const queue = this.writes.get(thread) ?? [];
         if (messages.length > 1000 || this.pendingRecords + messages.length > 4096)
             return Promise.reject(new Error("MESSAGE_STORAGE_BACKPRESSURE"));
@@ -153,7 +197,7 @@ export class MessageClient {
         }
         this.pendingBytes += bytes;
         this.pendingRecords += messages.length;
-        const promise = new Promise((resolve, reject) => queue.push({ messages, bytes, resolve, reject }));
+        const promise = new Promise((resolve, reject) => queue.push({ messages, bytes, version: this.watches.get(thread)?.snapshot.resetVersion ?? 0, resolve, reject }));
         this.writes.set(thread, queue);
         this.writeTasks.schedule(thread, () => this.flushWrites(thread));
         return promise;
@@ -218,12 +262,26 @@ export class MessageClient {
             return;
         this.writes.delete(thread);
         try {
-            await this.persist(thread, queue.flatMap(write => write.messages));
-            queue.forEach(write => write.resolve());
-        }
-        catch (error) {
-            queue.forEach(write => write.reject(error));
-            throw error;
+            const groups = new Map();
+            for (const write of queue) {
+                const group = groups.get(write.version) ?? [];
+                group.push(write);
+                groups.set(write.version, group);
+            }
+            let failed = false, failure;
+            for (const [version, writes] of groups) {
+                try {
+                    await this.persist(thread, writes.flatMap(write => write.messages), undefined, undefined, undefined, undefined, version);
+                    writes.forEach(write => write.resolve());
+                }
+                catch (error) {
+                    failed = true;
+                    failure = error;
+                    writes.forEach(write => write.reject(error));
+                }
+            }
+            if (failed)
+                throw failure;
         }
         finally {
             this.release(queue);
@@ -263,8 +321,14 @@ export class MessageClient {
                 page = await this.options.transport.changes(thread, after, this.abort.signal);
             }
         })().catch(async (error) => {
-            if (!this.closed && !this.closing && error?.status === 403)
-                await this.revoke(thread);
+            if (!this.closed && !this.closing && error?.status === 403) {
+                try {
+                    await this.revoke(thread);
+                }
+                catch (cacheError) {
+                    Object.assign(error, { cacheError });
+                }
+            }
             throw error;
         }).finally(() => { if (this.syncing.get(thread) === task)
             this.syncing.delete(thread); });
@@ -306,8 +370,14 @@ export class MessageClient {
                     throw new Error("MESSAGE_SYNC_NO_PROGRESS");
                 await this.persist(thread, remote.messages, undefined, true, remote.nextBefore ?? null, undefined, version);
             })().catch(async (error) => {
-                if (!this.closed && !this.closing && error?.status === 403)
-                    await this.revoke(thread);
+                if (!this.closed && !this.closing && error?.status === 403) {
+                    try {
+                        await this.revoke(thread);
+                    }
+                    catch (cacheError) {
+                        Object.assign(error, { cacheError });
+                    }
+                }
                 throw error;
             }).finally(() => { if (this.paging.get(thread) === task)
                 this.paging.delete(thread); });
@@ -317,17 +387,35 @@ export class MessageClient {
         }
         return { messages: page.messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore), resetVersion: page.coverage?.resetVersion ?? 0, complete: page.coverage?.complete ?? false };
     }
-    async revoke(thread) {
+    denyView(thread, version) {
         this.revoked.add(thread);
+        const watch = this.watches.get(thread);
+        const snapshot = { messages: [], hasEarlier: false, complete: false, resetVersion: Math.max(watch?.snapshot.resetVersion ?? 0, version ?? (watch?.snapshot.resetVersion ?? 0) + 1) };
+        if (watch && !watch.snapshot.messages.length && !watch.snapshot.complete && !watch.snapshot.hasEarlier && watch.snapshot.resetVersion === snapshot.resetVersion)
+            return;
+        if (watch) {
+            watch.snapshot = snapshot;
+            watch.listeners.forEach(listener => listener());
+        }
+        else
+            this.watches.set(thread, { snapshot, listeners: new Set() });
+        this.allListeners.forEach(listener => listener(thread));
+    }
+    async revoke(thread) {
+        this.denyView(thread);
         const queue = this.writes.get(thread);
         this.writes.delete(thread);
         if (queue) {
             queue.forEach(write => write.reject(new Error("MESSAGE_ACCESS_REVOKED")));
             this.release(queue);
         }
-        await this.storage.resetThread(thread, true);
-        await this.reload(thread);
-        this.channel?.postMessage(thread);
+        try {
+            await this.storage.resetThread(thread, true);
+            await this.reload(thread);
+        }
+        finally {
+            this.channel?.postMessage({ type: "revoked", thread, version: this.watches.get(thread)?.snapshot.resetVersion });
+        }
     }
     async close() {
         // Flush accepted event batches before closing; new requests are rejected afterwards.
@@ -340,6 +428,7 @@ export class MessageClient {
         this.abort.abort();
         this.channel?.close();
         this.watches.clear();
+        this.allListeners.clear();
         this.storage.close();
     }
 }

package/lib/runtime/messageStore.d.ts

@@ -36,6 +36,7 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
         indexedDB?: IDBFactory;
         name?: string;
     });
+    get namespace(): string;
     read(thread: string, limit?: number, before?: {
         timestamp: number;
         id: string;
@@ -48,6 +49,7 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
         version: number;
         authoritative?: boolean;
     }): Promise<number>;
+    windows(): Promise<CoverageRow[]>;
     /** A durable epoch prevents another tab's pre-reset request from restoring rows. */
     resetThread(thread: string, revoked?: boolean): Promise<number>;
     removeThread(thread: string): Promise<void>;

package/lib/runtime/messageStore.js

@@ -17,6 +17,7 @@ export class IndexedDbMessageStore {
         this.coverage = this.db.table("coverage");
         this.db.on("versionchange", () => { this.db.close({ disableAutoOpen: false }); return false; });
     }
+    get namespace() { return this.db.name; }
     async read(thread, limit = 100, before) {
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
             throw new Error("INVALID_MESSAGE_LIMIT");
@@ -60,6 +61,9 @@ export class IndexedDbMessageStore {
             return changed.size;
         });
     }
+    async windows() {
+        return this.coverage.where("scope").equals(this.key).toArray();
+    }
     /** A durable epoch prevents another tab's pre-reset request from restoring rows. */
     async resetThread(thread, revoked = false) {
         return this.db.transaction("rw", this.rows, this.coverage, async () => {

package/package.json

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