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

package/README.md

@@ -143,6 +143,11 @@ 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)))
 const offSummary = chat.subscribe(() => renderSummary(chat.getSnapshot()))
 await chat.observeMessages(threadId, visibleIds, "visible")
@@ -162,6 +167,11 @@ snapshot reports transport progress and failure. Retry uses the original message
 hash. The subscribed recent window remains 100 records regardless of individual
 query limits; history requests return their own pages and do not replace it.
 Global snapshots contain thread summaries and totals, not complete message arrays.
+Message pages report `complete`; unavailable older pages return cached records with
+`complete: false`. Authorization failures throw and never fall back to denied
+records. Thread snapshots expose `resetVersion`; hosts discard retained rows when
+it changes. Reset epochs are durable, so late cross-tab writes cannot restore a
+pre-reset payload.
 Voice visibility never acknowledges playback, including observations that arrive
 before metadata. Create a new instance and close the previous owner when the
 account or active Team changes.

package/lib/runtime/chatSession.d.ts

@@ -1,5 +1,5 @@
 import { type MessageReadersQuery } from "./messageReaders.js";
-import { type MessageClientOptions } from "./messageClient.js";
+import { type MessageClientOptions, type MessageSnapshot } from "./messageClient.js";
 import { DurableChatSender } from "./durableSender.js";
 import { type ReadingClientOptions } from "./readingClient.js";
 import { ChatClient, type ChatClientOptions, type ChatConnectionState } from "./chatClient.js";
@@ -18,6 +18,8 @@ export type ChatThreadSnapshot<T> = {
     messages: readonly T[];
     outgoing: ReturnType<DurableChatSender["snapshot"]>;
     hasEarlier: boolean;
+    resetVersion: number;
+    complete: boolean;
     unread: ReturnType<typeof unreadInConversation>;
 };
 export type ChatSummarySnapshot<T> = {
@@ -45,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?;
@@ -57,7 +61,10 @@ export declare class ChatSession<T extends StoredMessage> {
             timestamp: number;
             id: string;
         };
-    }): Promise<import("./messageClient.js").MessageSnapshot<T>>;
+        all?: boolean;
+        refresh?: boolean;
+    }): Promise<MessageSnapshot<T>>;
+    private readAll;
     sendMessage(threadId: string, input: {
         to: string;
         body: ChatBody;

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,12 +81,57 @@ 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) {
+            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) {
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const pages = [];
+            let version = 0;
+            try {
+                let page = await this.getMessages(threadId);
+                version = page.resetVersion;
+                pages.push(page.messages);
+                if (!page.complete)
+                    return { ...page, hasEarlier: true };
+                let restart = false;
+                while (page.hasEarlier) {
+                    const first = page.messages[0];
+                    if (!first)
+                        throw new Error("MESSAGE_SYNC_NO_PROGRESS");
+                    page = await this.getMessages(threadId, { before: { timestamp: first.timestamp, id: first.id } });
+                    if (page.resetVersion !== version) {
+                        restart = true;
+                        break;
+                    }
+                    pages.push(page.messages);
+                }
+                if (restart)
+                    continue;
+                return { messages: pages.reverse().flat(), hasEarlier: false, complete: true, resetVersion: version };
+            }
+            catch (error) {
+                if ([401, 403].includes(error?.status ?? 0))
+                    throw error;
+                if (String(error).includes("MESSAGE_PROJECTION_CHANGED"))
+                    continue;
+                if (pages.length)
+                    return { messages: pages.reverse().flat(), hasEarlier: true, complete: false, resetVersion: version };
+                throw error;
+            }
+        }
+        throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
+    }
     sendMessage(threadId, input) {
         this.assertOpen();
         return this.sender.enqueue(threadId, input);
@@ -99,7 +155,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, outgoing: this.sender.snapshot(threadId), unread: state?.threads.some(thread => (thread.conversationId ?? thread.id) === threadId) ? unreadInConversation(state, threadId) : { unreadMessageCount: 0, unreadMentionCount: 0, badgeCount: 0 } };
+            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) : { unreadMessageCount: 0, unreadMentionCount: 0, badgeCount: 0 } };
             this.snapshots.set(threadId, snapshot);
         }
         return snapshot;
@@ -118,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);
@@ -166,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

@@ -15,6 +15,8 @@ export type MessageTransport<T> = {
 export type MessageSnapshot<T> = {
     messages: readonly T[];
     hasEarlier: boolean;
+    resetVersion: number;
+    complete: boolean;
 };
 export type MessageClientOptions<T extends StoredMessage> = {
     scope: MessageScope;
@@ -34,6 +36,7 @@ export declare class MessageClient<T extends StoredMessage> {
     private options;
     private storage;
     private watches;
+    private allListeners;
     private reads;
     private syncing;
     private paging;
@@ -54,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;
@@ -72,8 +78,11 @@ export declare class MessageClient<T extends StoredMessage> {
     }, limit?: number): Promise<{
         messages: T[];
         hasEarlier: boolean;
+        resetVersion: number;
+        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,39 +33,102 @@ 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; }
     subscribe(thread, listener) {
         let watch = this.watches.get(thread);
         if (!watch) {
-            watch = { snapshot: { messages: [], hasEarlier: false }, listeners: new Set() };
+            watch = { snapshot: { messages: [], hasEarlier: false, resetVersion: 0, complete: false }, listeners: new Set() };
             this.watches.set(thread, watch);
         }
         watch.listeners.add(listener);
         return () => { watch.listeners.delete(listener); };
     }
-    read(thread, limit = 100) {
-        if (this.closed || this.closing || this.revoked.has(thread))
+    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)
-                await this.synchronize(thread);
+            if (refresh || !local.coverage?.complete || local.coverage.revoked || this.revoked.has(thread)) {
+                if (typeof navigator !== "undefined" && navigator.onLine === false) {
+                    if (!refresh && local.messages.length && !local.coverage?.revoked)
+                        return this.reload(thread);
+                    throw new Error("MESSAGE_OFFLINE_UNAVAILABLE");
+                }
+                this.revoked.delete(thread);
+                try {
+                    await this.synchronize(thread);
+                }
+                catch (error) {
+                    if (refresh || !local.messages.length || [401, 403].includes(error?.status ?? 0))
+                        throw error;
+                    this.options.onError?.(error, thread);
+                    return this.reload(thread);
+                }
+            }
             if (this.closed)
                 throw new Error("MESSAGE_CLIENT_CLOSED");
-            const result = await this.fillWindow(thread, limit);
+            let result;
+            try {
+                result = await this.fillWindow(thread, limit);
+            }
+            catch (error) {
+                if ([401, 403].includes(error?.status ?? 0))
+                    throw error;
+                const cached = await this.storage.read(thread, limit);
+                if (!cached.messages.length)
+                    throw error;
+                this.options.onError?.(error, thread);
+                await this.reload(thread);
+                return { messages: cached.messages, hasEarlier: true, complete: false, resetVersion: cached.coverage?.resetVersion ?? 0 };
+            }
             const snapshot = await this.reload(thread);
             if (local.coverage?.complete && Date.now() - (local.coverage.syncedAt ?? 0) > (this.options.freshnessMs ?? 30_000)
                 && (typeof navigator === "undefined" || navigator.onLine !== false))
@@ -85,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 => {
@@ -92,21 +160,26 @@ export class MessageClient {
             return old && JSON.stringify(old) === JSON.stringify(message) ? old : message;
         });
         const old = watch?.snapshot;
-        if (old && 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, 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"));
@@ -124,12 +197,15 @@ 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;
     }
-    async persist(thread, messages, checkpoint, complete, nextBefore, syncedAt) {
+    async persist(thread, messages, checkpoint, complete, nextBefore, syncedAt, expectedVersion) {
+        const initial = (await this.storage.read(thread, 1)).coverage;
+        const version = expectedVersion ?? initial?.resetVersion ?? 0;
+        const guard = { version, authoritative: complete === true };
         let changed = 0;
         let navigationChanged = false;
         // Coverage advances only after all bounded batches have durably committed.
@@ -139,7 +215,7 @@ export class MessageClient {
                 return;
             if (this.closed || this.revoked.has(thread))
                 throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
-            changed += await this.storage.commit(thread, batch);
+            changed += await this.storage.commit(thread, batch, undefined, guard);
             batch = [];
             bytes = 0;
         };
@@ -155,8 +231,8 @@ export class MessageClient {
             const old = (await this.storage.read(thread, 1)).coverage;
             if (this.closed || this.revoked.has(thread))
                 throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
-            navigationChanged = nextBefore !== undefined && nextBefore !== old?.nextBefore;
-            await this.storage.commit(thread, [], { syncedAt: syncedAt ?? old?.syncedAt, complete: complete ?? old?.complete ?? false, checkpoint: checkpoint ?? old?.checkpoint, nextBefore: nextBefore === undefined ? old?.nextBefore : nextBefore });
+            navigationChanged = (nextBefore !== undefined && nextBefore !== old?.nextBefore) || (complete !== undefined && complete !== old?.complete);
+            await this.storage.commit(thread, [], { resetVersion: version, revoked: complete === true ? false : old?.revoked, syncedAt: syncedAt ?? old?.syncedAt, complete: complete ?? old?.complete ?? false, checkpoint: checkpoint ?? old?.checkpoint, nextBefore: nextBefore === undefined ? old?.nextBefore : nextBefore }, guard);
         }
         if (changed || navigationChanged) {
             await this.reload(thread);
@@ -186,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);
@@ -205,6 +295,7 @@ export class MessageClient {
             return running;
         const task = (async () => {
             const coverage = (await this.storage.read(thread, 1)).coverage;
+            let version = coverage?.resetVersion ?? 0;
             let after = coverage?.complete ? coverage.checkpoint : undefined;
             let page = after && this.options.transport.changes
                 ? await this.options.transport.changes(thread, after, this.abort.signal)
@@ -212,7 +303,7 @@ export class MessageClient {
             if (page.resetRequired) {
                 if (this.closed || this.revoked.has(thread))
                     throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
-                await this.storage.removeThread(thread);
+                version = await this.storage.resetThread(thread);
                 after = undefined;
                 page = await this.options.transport.load(thread, this.abort.signal);
             }
@@ -221,7 +312,7 @@ export class MessageClient {
                     throw new Error("MESSAGE_ACCESS_REVOKED");
                 if (page.resetRequired)
                     throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
-                await this.persist(thread, page.messages, page.checkpoint, true, after ? undefined : page.nextBefore, Date.now());
+                await this.persist(thread, page.messages, page.checkpoint, true, after ? undefined : page.nextBefore, Date.now(), version);
                 if (!page.hasMoreChanges)
                     break;
                 if (!page.checkpoint || page.checkpoint === after || !this.options.transport.changes)
@@ -229,7 +320,17 @@ export class MessageClient {
                 after = page.checkpoint;
                 page = await this.options.transport.changes(thread, after, this.abort.signal);
             }
-        })().finally(() => { if (this.syncing.get(thread) === task)
+        })().catch(async (error) => {
+            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); });
         this.syncing.set(thread, task);
         return task;
@@ -245,6 +346,7 @@ export class MessageClient {
     }
     async fillWindow(thread, limit, before) {
         let page = await this.storage.read(thread, limit, before);
+        let resets = 0;
         while (page.messages.length < limit && page.coverage?.nextBefore && this.options.transport.older) {
             const pending = this.paging.get(thread);
             if (pending) {
@@ -252,37 +354,68 @@ export class MessageClient {
                 page = await this.storage.read(thread, limit, before);
                 continue;
             }
-            const token = page.coverage.nextBefore;
+            const token = page.coverage.nextBefore, version = page.coverage.resetVersion ?? 0;
             const task = (async () => {
                 const remote = await this.options.transport.older(thread, token, this.abort.signal);
                 if (this.closed || this.revoked.has(thread))
                     throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
                 if (remote.resetRequired) {
-                    await this.storage.removeThread(thread);
-                    throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
+                    if (++resets > 2)
+                        throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
+                    await this.storage.resetThread(thread);
+                    await this.synchronize(thread);
+                    return;
                 }
                 if (remote.nextBefore === token)
                     throw new Error("MESSAGE_SYNC_NO_PROGRESS");
-                await this.persist(thread, remote.messages, undefined, true, remote.nextBefore ?? null);
-            })().finally(() => { if (this.paging.get(thread) === task)
+                await this.persist(thread, remote.messages, undefined, true, remote.nextBefore ?? null, undefined, version);
+            })().catch(async (error) => {
+                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); });
             this.paging.set(thread, task);
             await task;
             page = await this.storage.read(thread, limit, before);
         }
-        return { messages: page.messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore) };
+        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.removeThread(thread);
-        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.
@@ -295,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

@@ -16,6 +16,8 @@ export type MessageCoverage = {
     complete: boolean;
     nextBefore?: string | null;
     syncedAt?: number;
+    resetVersion?: number;
+    revoked?: boolean;
 };
 type CoverageRow = MessageCoverage & {
     scope: string;
@@ -34,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;
@@ -42,7 +45,13 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
         hasEarlier: boolean;
         coverage: CoverageRow | undefined;
     }>;
-    commit(thread: string, messages: T[], coverage?: MessageCoverage): Promise<number>;
+    commit(thread: string, messages: T[], coverage?: MessageCoverage, guard?: {
+        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>;
     clear(): Promise<void>;
     close(): 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");
@@ -26,13 +27,18 @@ export class IndexedDbMessageStore {
             return { messages: records.slice(0, limit).reverse().map(row => row.value), hasEarlier: records.length > limit, coverage: await this.coverage.get([this.key, thread]) };
         });
     }
-    async commit(thread, messages, coverage) {
+    async commit(thread, messages, coverage, guard) {
         for (const message of messages)
             if (message.threadId !== thread || !message.id || !Number.isFinite(message.timestamp))
                 throw new Error("MESSAGE_SCOPE_MISMATCH");
         if (messages.length > 1000)
             throw new Error("MESSAGE_BATCH_TOO_LARGE");
         return this.db.transaction("rw", this.rows, this.coverage, async () => {
+            const current = await this.coverage.get([this.key, thread]);
+            if (guard && (current?.resetVersion ?? 0) !== guard.version)
+                throw new Error("MESSAGE_PROJECTION_CHANGED");
+            if (guard && current?.revoked && !guard.authoritative)
+                throw new Error("MESSAGE_ACCESS_REVOKED");
             const ids = [...new Set(messages.map(message => message.id))];
             const previous = await this.rows.bulkGet(ids.map(id => [this.key, thread, id]));
             const latest = new Map(previous.flatMap(row => row ? [[row.id, row.value]] : []));
@@ -48,13 +54,26 @@ export class IndexedDbMessageStore {
             if (changed.size)
                 await this.rows.bulkPut([...changed.values()]);
             if (coverage) {
-                const old = await this.coverage.get([this.key, thread]), next = { ...coverage, scope: this.key, thread };
+                const old = await this.coverage.get([this.key, thread]), next = { ...old, ...coverage, scope: this.key, thread };
                 if (JSON.stringify(old) !== JSON.stringify(next))
                     await this.coverage.put(next);
             }
             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 () => {
+            const old = await this.coverage.get([this.key, thread]);
+            const resetVersion = (old?.resetVersion ?? 0) + 1;
+            await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();
+            await this.coverage.put({ scope: this.key, thread, complete: false, resetVersion, revoked });
+            return resetVersion;
+        });
+    }
     async removeThread(thread) {
         await this.db.transaction("rw", this.rows, this.coverage, async () => {
             await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.4",
+  "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",