@pmate/chat-sdk 0.12.0-next.75 → 0.12.0-next.77

package/lib/internal/chatEngine.js

@@ -1,6 +1,6 @@
 import { createMessagePresenter } from "../messageView.js";
 import { createChat as createSession } from "../runtime/createChat.js";
-import { asChatError, threadChatError } from "../runtime/chatError.js";
+import { asChatError } from "../runtime/chatError.js";
 import { ChatError } from "../chatError.js";
 export { ChatError } from "../chatError.js";
 const emptyMessages = Object.freeze([]);
@@ -79,8 +79,8 @@ export class ChatEngine {
                 return await run();
             }
             catch (error) {
-                const failure = threadId ? threadChatError(error, threadId) : asChatError(error);
-                if (threadId && failure.code === "access-denied")
+                const failure = threadId ? await this.advanced.conversationFailure(error, threadId) : asChatError(error);
+                if (threadId && failure.code === "access-denied" && failure.threadId)
                     await this.deny(threadId, failure);
                 throw failure;
             }
@@ -177,6 +177,9 @@ export class ChatEngine {
     }
     async getMessages(threadId, query = {}) {
         try {
+            const denied = this.errors.get(threadId);
+            if (denied?.code === "access-denied")
+                throw denied;
             if (Object.keys(query).some(key => !["earlier", "all", "refresh"].includes(key)))
                 throw new ChatError("invalid-input", "Unsupported message query");
             const page = await this.advanced.getMessages(threadId, query);
@@ -187,9 +190,9 @@ export class ChatEngine {
             return this.getSnapshot(threadId);
         }
         catch (error) {
-            const failure = this.advanced.active ? threadChatError(error, threadId) : asChatError(error);
+            const failure = await this.advanced.conversationFailure(error, threadId);
             if (!this.closed) {
-                if (failure.code === "access-denied")
+                if (failure.code === "access-denied" && failure.threadId)
                     await this.deny(threadId, failure);
                 else {
                     this.errors.set(threadId, failure);

package/lib/runtime/chatSession.d.ts

@@ -193,6 +193,7 @@ export declare class ChatSession<T extends StoredMessage> {
     private buildGlobal;
     private publishGlobal;
     private publish;
+    conversationFailure(error: unknown, threadId: string): Promise<import("./chatError.js").ChatError>;
     /** Withdraw one conversation without retiring sibling conversations. */
     revokeThread(threadId: string): Promise<void>;
     /** Permanently retire this identity/team session. UI withdrawal is immediate;

package/lib/runtime/chatSession.js

@@ -1,3 +1,5 @@
+import { asChatError } from "./chatError.js";
+import { scopedGroupDenial, isScopedGroupDenial } from "./groupDenial.js";
 import { threadChatError } from "./chatError.js";
 import { ConversationDirectory } from "./conversationDirectory.js";
 import { groupThreadId } from "./thread.js";
@@ -70,7 +72,12 @@ export class ChatSession {
             if (shared.appId !== scope.appId || shared.profileId !== scope.profileId || (shared.accountId !== undefined && shared.accountId !== scope.accountId) || (shared.teamId !== undefined && shared.teamId !== scope.teamId))
                 throw new Error("CHAT_SESSION_SCOPE_MISMATCH");
         }
-        this.messages = new MessageClient(options.messages);
+        this.messages = new MessageClient({ ...options.messages, onError: (error, thread) => {
+                if (thread && error?.status === 403)
+                    void this.conversationFailure(error, thread).then(failure => options.onError(failure));
+                else
+                    options.messages.onError?.(error, thread);
+            } });
         this.conversations = new ConversationDirectory(scope, () => this.messages.scopeAccess());
         this.connection = options.sharedConnection ?? new ChatClient({ ...options.connection, onReach: async (event) => {
                 const handled = await this.handleReach(event);
@@ -83,7 +90,19 @@ export class ChatSession {
         this.reading = new ReadingClient({ ...options.reading, teamId: scope.teamId, storageScope: JSON.stringify([scope.accountId]), migrateLegacy: true, metadataOnly: true });
         this.readers = new MessageReadersClient({ appId: scope.appId, profileId: scope.profileId, token: options.reading.sessionToken, scope, access: () => this.messages.scopeAccess(), onError: options.onError, hubHttpUrl: options.reading.hubHttpUrl, fetch: options.reading.fetch });
         if (options.loadGroup) {
-            this.groups = new GroupClient({ scope, access: () => this.messages.scopeAccess(), load: options.loadGroup, onError: options.onError, onDenied: async (error, threadId) => { await this.messages.revoke(threadId); options.onError(threadChatError(error, threadId)); } });
+            this.groups = new GroupClient({ scope, access: () => this.messages.scopeAccess(), load: options.loadGroup, onError: options.onError, onDenied: async (error, _threadId, signal) => {
+                    if (error?.status === 403 && options.messages.transport.authorizeScope) {
+                        try {
+                            await options.messages.transport.authorizeScope(signal ?? new AbortController().signal);
+                            this.assertOpen();
+                            if ((await this.messages.scopeAccess()).allowed)
+                                return true;
+                        }
+                        catch { }
+                    }
+                    void this.revokeAccess().catch(error => options.onError(error));
+                    return false;
+                } });
             this.off.push(this.groups.subscribe(thread => this.publish(thread)));
         }
         this.sender = new DurableChatSender(this.connection, scope, options.onError, { access: () => this.messages.scopeAccess(), uploadVoice: options.uploadVoice, reconcile: async (record, signal) => {
@@ -837,8 +856,32 @@ export class ChatSession {
         if (notifyGlobal)
             this.publishGlobal();
     }
+    async conversationFailure(error, threadId) {
+        const failure = asChatError(error);
+        if (failure.code !== "access-denied" && failure.status !== 401)
+            return failure;
+        if (isScopedGroupDenial(error))
+            return scopedGroupDenial(threadChatError(error, threadId));
+        if (failure.status === 403 && this.active && this.options.messages.transport.authorizeScope) {
+            try {
+                await this.options.messages.transport.authorizeScope(new AbortController().signal);
+                this.assertOpen();
+                if ((await this.messages.scopeAccess()).allowed)
+                    return scopedGroupDenial(threadChatError(error, threadId));
+            }
+            catch { }
+        }
+        void this.revokeAccess().catch(error => this.options.onError(error));
+        return failure;
+    }
     /** Withdraw one conversation without retiring sibling conversations. */
-    revokeThread(threadId) { return this.messages.revoke(threadId); }
+    async revokeThread(threadId) { try {
+        await Promise.all([this.messages.revoke(threadId), this.groups?.revoke(threadId)]);
+    }
+    catch (error) {
+        void this.revokeAccess().catch(failure => this.options.onError(failure));
+        throw error;
+    } }
     /** Permanently retire this identity/team session. UI withdrawal is immediate;
      * completion means all durable stores have crossed the same authority epoch. */
     revokeAccess() {

package/lib/runtime/createChat.js

@@ -1,4 +1,3 @@
-import { threadChatError } from "./chatError.js";
 import { ChatCredentials } from "../credentials.js";
 import { voiceUploader } from "./voiceUpload.js";
 import { isOffline } from "./connectivity.js";
@@ -42,7 +41,7 @@ export function createChatSession(options) {
         },
         loadGroup: (groupId, signal) => reader.group({ groupId, teamId }, signal),
         activeThreadId: options.threadId,
-        messages: { scope: { appId, accountId, profileId, teamId }, transport: { authorizeScope: async (signal) => { await reader.contacts(teamId, signal); }, load: (thread, signal) => page(thread, signal), changes: (thread, after, signal) => page(thread, signal, { after }), older: (thread, before, signal) => page(thread, signal, { before }) }, onError: (error, thread) => onError(thread ? threadChatError(error, thread) : error) },
+        messages: { scope: { appId, accountId, profileId, teamId }, transport: { authorizeScope: async (signal) => { await reader.contacts(teamId, signal); }, 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: fetcher, onError },
         connection: { appId, profileId, teamId, hubUrl: ws, clientInstanceId: options.clientInstanceId, fetchImpl: fetcher,
             getToken: credentials?.getToken,

package/lib/runtime/groupClient.d.ts

@@ -34,7 +34,7 @@ export type GroupClientOptions = {
     access: ResponseCacheAccess;
     load: (groupId: string, signal: AbortSignal) => Promise<SocialGroup>;
     onError: (error: unknown) => void;
-    onDenied?: (error: unknown, threadId: string) => Promise<void> | void;
+    onDenied?: (error: unknown, threadId: string, signal?: AbortSignal) => Promise<boolean | void> | boolean | void;
     indexedDB?: IDBFactory;
     name?: string;
 };
@@ -77,6 +77,8 @@ export declare class GroupClient {
         refresh?: boolean;
     }): Promise<ChatGroup>;
     private schedule;
+    private denyGroup;
+    revoke(threadId: string): Promise<void>;
     wake(): void;
     hint(thread: ChatConversation, versionNumber?: number): void;
     private slot;

package/lib/runtime/groupClient.js

@@ -1,10 +1,11 @@
+import { scopedGroupDenial } from "./groupDenial.js";
 import { IndexedDbResponseCache } from "./responseCache.js";
 import { WindowedTasks } from "./coalescer.js";
 import { isOffline } from "./connectivity.js";
 import { messageScopeKey } from "./messageStore.js";
 import { validateConversation, validMessageIdentifier } from "./outgoingContent.js";
 const empty = Object.freeze({ loading: false });
-const token = (value) => `${value?.versionNumber}:${value?.revision}`;
+const token = (value) => value.status === "access-denied" ? `denied:${value.revision}` : `${value.versionNumber}:${value.revision}`;
 /** SDK-owned roster cache. Read sources, concurrency and reconciliation stay private. */
 export class GroupClient {
     options;
@@ -147,7 +148,10 @@ export class GroupClient {
                     for (const item of batch) {
                         try {
                             const row = rows.get(item.entry.thread.id), entry = item.entry;
-                            let data = row.cached ? this.cached(row.cached.value, entry) : undefined;
+                            const denied = row.cached?.value.status === "access-denied";
+                            let data = row.cached && !denied ? this.cached(row.cached.value, entry) : undefined;
+                            if (denied)
+                                this.denied.add(entry.thread.id);
                             const old = entry.snapshot.data;
                             if (old && data && old.versionNumber > data.versionNumber)
                                 data = old;
@@ -156,7 +160,7 @@ export class GroupClient {
                             entry.epoch = row.epoch;
                             entry.token = row.cached ? token(row.cached.value) : null;
                             entry.loaded = true;
-                            this.publish(entry, { data: data ?? old, loading: false });
+                            this.publish(entry, { data: denied ? undefined : data ?? old, loading: false, ...(denied ? { error: scopedGroupDenial(Object.assign(new Error("GROUP_ACCESS_DENIED"), { status: 403, threadId: entry.thread.id })) } : {}) });
                             item.resolve();
                         }
                         catch (error) {
@@ -178,12 +182,14 @@ export class GroupClient {
     }
     async reload(entry) { entry.loaded = false; await this.local(entry); }
     async get(thread, options = {}) {
-        if (this.denied.has(thread.id))
-            throw Object.assign(new Error("GROUP_ACCESS_REVOKED"), { status: 403, threadId: thread.id });
         const entry = this.entry(thread);
         await this.local(entry);
         await this.checkAuthority();
         this.assertOpen();
+        if (options.refresh)
+            this.denied.delete(thread.id);
+        else if (this.denied.has(thread.id))
+            throw entry.snapshot.error ?? scopedGroupDenial(Object.assign(new Error("GROUP_ACCESS_DENIED"), { status: 403, threadId: thread.id }));
         if (entry.snapshot.data && !options.refresh) {
             if (!entry.checked && !isOffline())
                 this.schedule(entry);
@@ -195,6 +201,34 @@ export class GroupClient {
     }
     schedule(entry) { if (!this.closed && !this.withdrawn && !this.denied.has(entry.thread.id) && !isOffline())
         this.tasks.schedule(entry.thread.id, async () => { await this.get(entry.thread, { refresh: true }); }); }
+    async denyGroup(entry, error) {
+        const value = { status: "access-denied", revision: crypto.randomUUID() };
+        this.denied.add(entry.thread.id);
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const row = await this.cache.read(entry.thread.id);
+            try {
+                await this.cache.write(entry.thread.id, value, row.epoch, row.cached ? token(row.cached.value) : null);
+                entry.epoch = row.epoch;
+                entry.token = token(value);
+                entry.checked = true;
+                this.publish(entry, { loading: false, error });
+                this.channel?.postMessage({ threadId: entry.thread.id, authority: this.version });
+                return;
+            }
+            catch (failure) {
+                if (attempt === 2 || !String(failure).includes("RESPONSE_CACHE_CHANGED"))
+                    throw failure;
+            }
+        }
+    }
+    async revoke(threadId) {
+        this.denied.add(threadId);
+        const entry = this.entries.get(threadId);
+        if (entry)
+            await this.denyGroup(entry, scopedGroupDenial(Object.assign(new Error("GROUP_ACCESS_DENIED"), { status: 403, threadId })));
+        else
+            await this.cache.remove(threadId);
+    }
     wake() { for (const entry of this.entries.values())
         this.schedule(entry); }
     hint(thread, versionNumber) {
@@ -232,6 +266,8 @@ export class GroupClient {
                 const value = this.normalize(await this.options.load(entry.thread.targetId, controller.signal), entry);
                 await this.checkAuthority();
                 this.assertOpen();
+                if (this.denied.has(entry.thread.id))
+                    throw Object.assign(new Error("GROUP_ACCESS_REVOKED"), { status: 403, threadId: entry.thread.id });
                 if (entry.snapshot.data && value.versionNumber <= entry.snapshot.data.versionNumber)
                     await this.reload(entry);
                 const old = entry.snapshot.data;
@@ -267,15 +303,19 @@ export class GroupClient {
                 return value;
             }
             catch (error) {
-                if (error?.status === 403)
-                    Object.assign(error, { threadId: entry.thread.id });
                 if (!this.closed) {
                     const denied = [401, 403].includes(error?.status ?? 0);
                     this.publish(entry, { data: denied ? undefined : entry.snapshot.data, loading: false, error });
-                    if (denied) {
-                        this.denied.add(entry.thread.id);
-                        await this.cache.remove(entry.thread.id);
-                        await this.options.onDenied?.(error, entry.thread.id);
+                    if (denied && await this.options.onDenied?.(error, entry.thread.id, controller.signal) === true) {
+                        Object.assign(error, { threadId: entry.thread.id });
+                        scopedGroupDenial(error);
+                        try {
+                            await this.denyGroup(entry, error);
+                        }
+                        catch (failure) {
+                            await this.options.onDenied?.(failure, entry.thread.id, controller.signal);
+                            throw failure;
+                        }
                     }
                 }
                 throw error;

package/lib/runtime/groupDenial.d.ts

@@ -0,0 +1,2 @@
+export declare function scopedGroupDenial<T extends object>(error: T): T;
+export declare function isScopedGroupDenial(error: unknown): boolean;

package/lib/runtime/groupDenial.js

@@ -0,0 +1,4 @@
+// Only SDK-verified failures may opt out of whole-session retirement.
+const scoped = new WeakSet();
+export function scopedGroupDenial(error) { scoped.add(error); return error; }
+export function isScopedGroupDenial(error) { return error !== null && typeof error === "object" && scoped.has(error); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.75",
+  "version": "0.12.0-next.77",
   "description": "Local-first chat SDK, message subscriptions, reading state, and shared chat UI primitives",
   "type": "module",
   "main": "./lib/index.js",