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

package/lib/chatError.d.ts

@@ -4,8 +4,11 @@ export declare class ChatError extends Error {
     readonly code: ChatErrorCode;
     readonly retryable: boolean;
     readonly status?: number;
+    /** Present only when access was denied for one conversation, not the Team. */
+    readonly threadId?: string;
     constructor(code: ChatErrorCode, message: string, options?: {
         cause?: unknown;
         status?: number;
+        threadId?: string;
     });
 }

package/lib/chatError.js

@@ -3,11 +3,14 @@ export class ChatError extends Error {
     code;
     retryable;
     status;
+    /** Present only when access was denied for one conversation, not the Team. */
+    threadId;
     constructor(code, message, options = {}) {
         super(message, { cause: options.cause });
         this.code = code;
         this.name = "ChatError";
         this.status = options.status;
+        this.threadId = options.threadId;
         this.retryable = ["unavailable", "storage-unavailable", "busy"].includes(code);
     }
 }

package/lib/internal/chatEngine.js

@@ -1,6 +1,6 @@
 import { createMessagePresenter } from "../messageView.js";
 import { createChat as createSession } from "../runtime/createChat.js";
-import { asChatError } from "../runtime/chatError.js";
+import { asChatError, threadChatError } from "../runtime/chatError.js";
 import { ChatError } from "../chatError.js";
 export { ChatError } from "../chatError.js";
 const emptyMessages = Object.freeze([]);
@@ -61,7 +61,7 @@ export class ChatEngine {
     async deny(threadId, failure) {
         this.errors.set(threadId, failure);
         this.targets.delete(threadId);
-        const retiring = this.advanced.revokeAccess();
+        const retiring = this.advanced.revokeThread(threadId);
         this.notify(threadId);
         try {
             await retiring;
@@ -79,7 +79,7 @@ export class ChatEngine {
                 return await run();
             }
             catch (error) {
-                const failure = asChatError(error);
+                const failure = threadId ? threadChatError(error, threadId) : asChatError(error);
                 if (threadId && failure.code === "access-denied")
                     await this.deny(threadId, failure);
                 throw failure;
@@ -187,7 +187,7 @@ export class ChatEngine {
             return this.getSnapshot(threadId);
         }
         catch (error) {
-            const failure = asChatError(error);
+            const failure = this.advanced.active ? threadChatError(error, threadId) : asChatError(error);
             if (!this.closed) {
                 if (failure.code === "access-denied")
                     await this.deny(threadId, failure);

package/lib/runtime/chatError.d.ts

@@ -1,3 +1,5 @@
 import { ChatError } from "../chatError.js";
 export { ChatError, type ChatErrorCode } from "../chatError.js";
 export declare function asChatError(error: unknown): ChatError;
+/** Keep a conversation denial distinct from loss of Team authority. */
+export declare function threadChatError(error: unknown, threadId: string): ChatError;

package/lib/runtime/chatError.js

@@ -11,5 +11,10 @@ export function asChatError(error) {
                 : /BACKPRESSURE|TOO_LARGE/.test(message) ? "busy"
                     : status === 400 || /INVALID_|CONVERSATION_MISMATCH|CONVERSATION_UNKNOWN|NOT_OWNED/.test(message) ? "invalid-input"
                         : /QuotaExceeded|DatabaseClosed|UnknownError|AbortError/.test(value?.name ?? "") || /STORAGE_|DATABASE_|CACHE_WRITE/.test(message) ? "storage-unavailable" : "unavailable";
-    return new ChatError(code, message, { cause: error, status });
+    return new ChatError(code, message, { cause: error, status, threadId: value?.threadId });
+}
+/** Keep a conversation denial distinct from loss of Team authority. */
+export function threadChatError(error, threadId) {
+    const failure = asChatError(error);
+    return failure.code === "access-denied" ? new ChatError(failure.code, failure.message, { cause: failure, status: failure.status, threadId }) : failure;
 }

package/lib/runtime/chatSession.d.ts

@@ -193,6 +193,8 @@ export declare class ChatSession<T extends StoredMessage> {
     private buildGlobal;
     private publishGlobal;
     private publish;
+    /** Withdraw one conversation without retiring sibling conversations. */
+    revokeThread(threadId: string): Promise<void>;
     /** Permanently retire this identity/team session. UI withdrawal is immediate;
      * completion means all durable stores have crossed the same authority epoch. */
     revokeAccess(): Promise<void>;

package/lib/runtime/chatSession.js

@@ -1,3 +1,4 @@
+import { threadChatError } from "./chatError.js";
 import { ConversationDirectory } from "./conversationDirectory.js";
 import { groupThreadId } from "./thread.js";
 import { GroupClient } from "./groupClient.js";
@@ -82,7 +83,7 @@ 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: () => { void this.revokeAccess().catch(error => options.onError(error)); } });
+            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.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) => {
@@ -836,6 +837,8 @@ export class ChatSession {
         if (notifyGlobal)
             this.publishGlobal();
     }
+    /** Withdraw one conversation without retiring sibling conversations. */
+    revokeThread(threadId) { return this.messages.revoke(threadId); }
     /** 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,3 +1,4 @@
+import { threadChatError } from "./chatError.js";
 import { ChatCredentials } from "../credentials.js";
 import { voiceUploader } from "./voiceUpload.js";
 import { isOffline } from "./connectivity.js";
@@ -41,7 +42,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 },
+        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) },
         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) => Promise<void> | void;
+    onDenied?: (error: unknown, threadId: string) => Promise<void> | void;
     indexedDB?: IDBFactory;
     name?: string;
 };
@@ -56,6 +56,7 @@ export declare class GroupClient {
     private queue;
     private controllers;
     private channel?;
+    private denied;
     private withdrawn;
     private closed;
     private closing?;

package/lib/runtime/groupClient.js

@@ -23,6 +23,7 @@ export class GroupClient {
     queue = [];
     controllers = new Set();
     channel;
+    denied = new Set();
     withdrawn = false;
     closed = false;
     closing;
@@ -177,6 +178,8 @@ 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();
@@ -190,7 +193,7 @@ export class GroupClient {
             throw entry.snapshot.error ?? new Error("GROUP_METADATA_OFFLINE");
         return this.request(entry);
     }
-    schedule(entry) { if (!this.closed && !this.withdrawn && !isOffline())
+    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 }); }); }
     wake() { for (const entry of this.entries.values())
         this.schedule(entry); }
@@ -264,11 +267,16 @@ 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)
-                        await this.options.onDenied?.(error);
+                    if (denied) {
+                        this.denied.add(entry.thread.id);
+                        await this.cache.remove(entry.thread.id);
+                        await this.options.onDenied?.(error, entry.thread.id);
+                    }
                 }
                 throw error;
             }

package/lib/runtime/responseCache.d.ts

@@ -51,6 +51,8 @@ export declare class IndexedDbResponseCache<T> {
         } | undefined;
     }>>;
     write(key: string, value: T, epoch: number, expectedRevision?: string | null): Promise<void>;
+    /** Forget one response without invalidating unrelated cached conversations. */
+    remove(key: string): Promise<void>;
     /** Idempotent shared-scope retirement: an old cleanup cannot erase windows
      * created after the same authority version was already recovered. */
     retire(version: number): Promise<void>;

package/lib/runtime/responseCache.js

@@ -105,6 +105,12 @@ export class IndexedDbResponseCache {
         this.tasks.schedule("write", () => this.flush());
         return promise;
     }
+    /** Forget one response without invalidating unrelated cached conversations. */
+    async remove(key) {
+        await this.flush();
+        await this.synchronizeAccess();
+        await this.transact("rw", this.rows, () => this.rows.delete([this.scope, key]));
+    }
     /** Idempotent shared-scope retirement: an old cleanup cannot erase windows
      * created after the same authority version was already recovered. */
     retire(version) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.74",
+  "version": "0.12.0-next.75",
   "description": "Local-first chat SDK, message subscriptions, reading state, and shared chat UI primitives",
   "type": "module",
   "main": "./lib/index.js",
@@ -53,15 +53,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "clean": "rimraf lib",
-    "build": "pnpm run clean && tsc -p tsconfig.build.json && cp src/voice/recorder-processor.js lib/voice/recorder-processor.js",
-    "prepack": "pnpm run build",
-    "npm:publish": "pnpm run build && npm publish --access public --registry https://registry.npmjs.org/",
-    "test": "vitest run",
-    "storybook": "storybook dev -p 6009",
-    "build-storybook": "storybook build --output-dir dist"
-  },
   "dependencies": {
     "@emoji-mart/data": "^1.2.1",
     "@emoji-mart/react": "^1.1.1",
@@ -77,16 +68,24 @@
   "devDependencies": {
     "@storybook/addon-docs": "^9.0.17",
     "@storybook/react-vite": "9.0.17",
-    "@tailwindcss/vite": "catalog:",
-    "@types/react": "catalog:",
-    "@types/react-dom": "catalog:",
+    "@tailwindcss/vite": "^4.1.3",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
     "fake-indexeddb": "^6.2.5",
-    "react": "catalog:",
-    "react-dom": "catalog:",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
     "rimraf": "^6.1.2",
     "storybook": "^9.0.17",
-    "tailwindcss": "catalog:",
+    "tailwindcss": "^4.0.14",
     "typescript": "5.9.2",
     "vitest": "^4.0.17"
+  },
+  "scripts": {
+    "clean": "rimraf lib",
+    "build": "pnpm run clean && tsc -p tsconfig.build.json && cp src/voice/recorder-processor.js lib/voice/recorder-processor.js",
+    "npm:publish": "pnpm run build && npm publish --access public --registry https://registry.npmjs.org/",
+    "test": "vitest run",
+    "storybook": "storybook dev -p 6009",
+    "build-storybook": "storybook build --output-dir dist"
   }
-}
+}