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

package/README.md

@@ -143,6 +143,8 @@ 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 })
+// 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 +164,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> = {
@@ -57,7 +59,9 @@ export declare class ChatSession<T extends StoredMessage> {
             timestamp: number;
             id: string;
         };
-    }): Promise<import("./messageClient.js").MessageSnapshot<T>>;
+        all?: boolean;
+    }): Promise<MessageSnapshot<T>>;
+    private readAll;
     sendMessage(threadId: string, input: {
         to: string;
         body: ChatBody;

package/lib/runtime/chatSession.js

@@ -70,11 +70,55 @@ export class ChatSession {
         throw new Error("CHAT_SESSION_CLOSED"); }
     async getMessages(threadId, options = {}) {
         this.assertOpen();
+        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) {
+        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);
@@ -98,7 +142,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;

package/lib/runtime/durableSender.js

@@ -143,10 +143,13 @@ export class DurableChatSender {
     /** Confirm only after the authoritative message has been durably merged.
      * A tombstone prevents another tab's late failure from recreating the outbox. */
     async confirm(hashes) {
+        hashes = [...new Set(hashes)];
+        if (!hashes.length)
+            return;
         await this.ready;
         await this.db.transaction("rw", this.outbox, async () => {
             const previous = await this.outbox.bulkGet(hashes.map(hash => [this.scope, hash]));
-            const confirmed = previous.filter((record) => Boolean(record)).map(record => ({ ...record, status: "sent", confirmed: true }));
+            const confirmed = previous.filter((record) => Boolean(record && !record.confirmed)).map(record => ({ ...record, status: "sent", confirmed: true }));
             if (confirmed.length)
                 await this.outbox.bulkPut(confirmed);
         });

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;
@@ -27,6 +29,7 @@ export type MessageClientOptions<T extends StoredMessage> = {
     syncWindowMs?: number;
     transactionBytes?: number;
     queueBytes?: number;
+    freshnessMs?: number;
 };
 /** Local-first message facade; hosts never select a cache or network source. */
 export declare class MessageClient<T extends StoredMessage> {
@@ -71,6 +74,8 @@ export declare class MessageClient<T extends StoredMessage> {
     }, limit?: number): Promise<{
         messages: T[];
         hasEarlier: boolean;
+        resetVersion: number;
+        complete: boolean;
     }>;
     private fillWindow;
     revoke(thread: string): Promise<void>;

package/lib/runtime/messageClient.js

@@ -44,14 +44,14 @@ export class MessageClient {
     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))
+        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"));
@@ -60,12 +60,43 @@ export class MessageClient {
             return running;
         const task = (async () => {
             const local = await this.storage.read(thread, limit);
-            if (!local.coverage?.complete)
-                await this.synchronize(thread);
+            if (!local.coverage?.complete || local.coverage.revoked || this.revoked.has(thread)) {
+                if (typeof navigator !== "undefined" && navigator.onLine === false) {
+                    if (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 (!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))
+                this.invalidate(thread);
             return limit === 100 ? snapshot : result;
         })().finally(() => { if (this.reads.get(key) === task)
             this.reads.delete(key); });
@@ -89,9 +120,10 @@ 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 = 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]))
             return old;
-        const snapshot = { messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore) };
+        const snapshot = { messages, resetVersion, complete, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore) };
         if (!watch) {
             watch = { snapshot, listeners: new Set() };
             this.watches.set(thread, watch);
@@ -105,17 +137,20 @@ export class MessageClient {
         if (this.closed || this.closing || this.revoked.has(thread))
             return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
         const queue = this.writes.get(thread) ?? [];
+        if (messages.length > 1000 || this.pendingRecords + messages.length > 4096)
+            return Promise.reject(new Error("MESSAGE_STORAGE_BACKPRESSURE"));
         let bytes = 0;
         try {
-            for (const message of messages)
+            for (const message of messages) {
                 bytes += this.messageBytes(message);
+                if (this.pendingBytes + bytes > this.queueBytes)
+                    throw new Error("MESSAGE_STORAGE_BACKPRESSURE");
+            }
             messages = structuredClone(messages);
         }
         catch (error) {
             return Promise.reject(error);
         }
-        if (messages.length > 1000 || this.pendingRecords + messages.length > 4096 || this.pendingBytes + bytes > this.queueBytes)
-            return Promise.reject(new Error("MESSAGE_STORAGE_BACKPRESSURE"));
         this.pendingBytes += bytes;
         this.pendingRecords += messages.length;
         const promise = new Promise((resolve, reject) => queue.push({ messages, bytes, resolve, reject }));
@@ -123,8 +158,12 @@ export class MessageClient {
         this.writeTasks.schedule(thread, () => this.flushWrites(thread));
         return promise;
     }
-    async persist(thread, messages, checkpoint, complete, nextBefore) {
+    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.
         let batch = [], bytes = 0;
         const commit = async () => {
@@ -132,7 +171,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;
         };
@@ -148,9 +187,10 @@ 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");
-            await this.storage.commit(thread, [], { 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) {
+        if (changed || navigationChanged) {
             await this.reload(thread);
             this.channel?.postMessage(thread);
         }
@@ -197,6 +237,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)
@@ -204,7 +245,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);
             }
@@ -213,7 +254,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);
+                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)
@@ -221,7 +262,11 @@ 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)
+                await this.revoke(thread);
+            throw error;
+        }).finally(() => { if (this.syncing.get(thread) === task)
             this.syncing.delete(thread); });
         this.syncing.set(thread, task);
         return task;
@@ -237,6 +282,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) {
@@ -244,25 +290,32 @@ 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)
+                    await this.revoke(thread);
+                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) {
         this.revoked.add(thread);
@@ -272,7 +325,7 @@ export class MessageClient {
             queue.forEach(write => write.reject(new Error("MESSAGE_ACCESS_REVOKED")));
             this.release(queue);
         }
-        await this.storage.removeThread(thread);
+        await this.storage.resetThread(thread, true);
         await this.reload(thread);
         this.channel?.postMessage(thread);
     }

package/lib/runtime/messageStore.d.ts

@@ -15,6 +15,9 @@ export type MessageCoverage = {
     checkpoint?: string;
     complete: boolean;
     nextBefore?: string | null;
+    syncedAt?: number;
+    resetVersion?: number;
+    revoked?: boolean;
 };
 type CoverageRow = MessageCoverage & {
     scope: string;
@@ -41,7 +44,12 @@ 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>;
+    /** 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

@@ -26,13 +26,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 +53,23 @@ 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;
         });
     }
+    /** 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.3",
+  "version": "0.12.0-next.5",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",