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

package/lib/chatContract.d.ts

@@ -145,4 +145,7 @@ export interface Chat {
         threadId: string;
     }>;
     updateGroup(threadId: string, changes: GroupChanges): Promise<ChatGroup>;
+    dissolveGroup(threadId: string, options?: {
+        expectedRevision?: string;
+    }): Promise<ChatGroup>;
 }

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/chatTypes.d.ts

@@ -52,7 +52,7 @@ export type ChatMessage = Readonly<{
     mentions?: readonly ChatMention[];
     recipientCount?: number;
     system?: Readonly<{
-        type: "group-created" | "group-updated" | "contact-updated";
+        type: "group-created" | "group-updated" | "group-dissolved" | "contact-updated";
         title?: string;
     }>;
 }>;
@@ -60,11 +60,17 @@ export type ChatGroup = Readonly<{
     groupId: string;
     teamId: string;
     ownerId: string;
+    revision: string;
+} & ({
+    status: "active";
     title: string;
     avatar?: string;
     memberIds: readonly string[];
-    revision: string;
-}>;
+} | {
+    status: "dissolved";
+    dissolvedBy?: string;
+    dissolvedAt?: number;
+})>;
 export type ConversationInfo = Readonly<{
     kind: "dm" | "group";
     targetId: string;

package/lib/internal/chatEngine.d.ts

@@ -11,8 +11,10 @@ export type OutgoingContent = Exclude<RuntimeContent, {
     groupCreate: unknown;
 } | {
     groupUpdate: unknown;
+} | {
+    groupDissolve: unknown;
 }>;
-import type { ChatThreadSnapshot, ChatSnapshot, ReadOptions } from "../chatTypes.js";
+import type { ChatGroup, ChatThreadSnapshot, ChatSnapshot, ReadOptions } from "../chatTypes.js";
 export type { ChatGroup, ConversationInfo, ChatThreadSnapshot, ChatSnapshot, ReadOptions } from "../chatTypes.js";
 export type MessageQuery = {
     earlier?: boolean;
@@ -94,15 +96,7 @@ export declare class ChatEngine {
     getVoiceAttachment(threadId: string, messageId: string): Promise<import("../runtime/durableSender.js").VoiceAttachmentLease>;
     getGroup(threadId: string, options?: {
         refresh?: boolean;
-    }): Promise<Readonly<{
-        groupId: string;
-        teamId: string;
-        ownerId: string;
-        title: string;
-        avatar?: string;
-        memberIds: readonly string[];
-        revision: string;
-    }>>;
+    }): Promise<ChatGroup>;
     createGroup(input: {
         groupId?: string;
         title: string;
@@ -112,20 +106,25 @@ export declare class ChatEngine {
         groupId: string;
         teamId: string;
         ownerId: string;
+        revision: string;
+        status: "active";
         title: string;
         avatar?: string;
         memberIds: readonly string[];
-        revision: string;
-    }>;
-    updateGroup(threadId: string, changes: GroupChanges): Promise<Readonly<{
+    } | {
+        threadId: string;
         groupId: string;
         teamId: string;
         ownerId: string;
-        title: string;
-        avatar?: string;
-        memberIds: readonly string[];
         revision: string;
-    }>>;
+        status: "dissolved";
+        dissolvedBy?: string;
+        dissolvedAt?: number;
+    }>;
+    updateGroup(threadId: string, changes: GroupChanges): Promise<ChatGroup>;
+    dissolveGroup(threadId: string, options?: {
+        expectedRevision?: string;
+    }): Promise<ChatGroup>;
     revokeAccess(): Promise<void>;
     close(): Promise<void>;
 }

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);
@@ -201,8 +201,8 @@ export class ChatEngine {
     }
     sendMessage(threadId, content, options = {}) {
         return this.threadOperation(threadId, async () => {
-            if (content && ("groupCreate" in content || "groupUpdate" in content))
-                throw new ChatError("invalid-input", "Use createGroup or updateGroup for group changes");
+            if (content && ("groupCreate" in content || "groupUpdate" in content || "groupDissolve" in content))
+                throw new ChatError("invalid-input", "Use group lifecycle methods for group changes");
             const result = await this.advanced.sendMessage(threadId, content, options);
             return { id: result.hash, timestamp: result.t };
         });
@@ -275,6 +275,7 @@ export class ChatEngine {
         });
     }
     updateGroup(threadId, changes) { return this.threadOperation(threadId, async () => this.group(await this.advanced.updateGroup(threadId, changes))); }
+    dissolveGroup(threadId, options = {}) { return this.threadOperation(threadId, async () => this.group(await this.advanced.dissolveGroup(threadId, options))); }
     revokeAccess() { return this.operation(() => this.advanced.revokeAccess()); }
     close() { this.closed = true; return this.operation(() => this.advanced.close()).finally(() => { this.errors.clear(); this.targets.clear(); this.listeners.clear(); this.threadSubscribers.clear(); this.openQueue.clear(); this.views.clear(); this.summary = undefined; this.present = createMessagePresenter(); this.messageLists = new WeakMap(); this.groups = new WeakMap(); this.redactedQuotes = new WeakMap(); }); }
 }

package/lib/internal/createPublicChat.js

@@ -45,7 +45,7 @@ export function createPublicChat(options) {
         },
         getVoiceAttachment: (id, messageId, options = {}) => read(() => engine.getVoiceAttachment(id, messageId), options, lease => lease.release()),
         getGroup: (id, options = {}) => read(() => engine.getGroup(id), options), refreshGroup: (id, options = {}) => read(() => engine.getGroup(id, { refresh: true }), options),
-        createGroup: input => engine.createGroup(input), updateGroup: (id, changes) => engine.updateGroup(id, changes),
+        createGroup: input => engine.createGroup(input), updateGroup: (id, changes) => engine.updateGroup(id, changes), dissolveGroup: (id, options) => engine.dissolveGroup(id, options),
     });
     registerChat(chat, engine);
     return chat;

package/lib/messageView.js

@@ -51,7 +51,7 @@ function content(message) {
     }
     else if (body.kind === "group") {
         result.kind = "system";
-        result.system = { type: body.action === "groupCreate" ? "group-created" : "group-updated", title: text(object(body.payload).title) || undefined };
+        result.system = { type: body.action === "groupCreate" ? "group-created" : body.action === "groupDissolve" ? "group-dissolved" : "group-updated", title: text(object(body.payload).title) || undefined };
     }
     else if (file) {
         result.kind = "attachment";

package/lib/runtime/chatClient.d.ts

@@ -123,6 +123,11 @@ export declare class ChatClient {
         title?: string;
         avatar?: string;
     }): Promise<ChatRuntimeMessage>;
+    dissolveGroup(input: {
+        groupId: string;
+        teamId?: string;
+        expectedRevision: string;
+    }): Promise<ChatRuntimeMessage>;
     sendGroup(input: {
         groupId: string;
         teamId?: string;

package/lib/runtime/chatClient.js

@@ -252,6 +252,12 @@ export class ChatClient {
                 addMembers: input.addMembers ?? [], removeMembers: input.removeMembers ?? [], ...(input.title !== undefined ? { title: input.title } : {}), ...(input.avatar !== undefined ? { avatar: input.avatar } : {}) },
         });
     }
+    async dissolveGroup(input) {
+        return this.sendChat(input.groupId, {
+            kind: "group", threadKind: "group", action: "groupDissolve",
+            payload: { appId: this.options.appId, groupId: input.groupId, ...(input.teamId !== undefined ? { teamId: input.teamId } : {}), expectedRevision: input.expectedRevision },
+        });
+    }
     async sendGroup(input) {
         return this.sendChat(input.groupId, {
             kind: "message",

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

@@ -149,6 +149,9 @@ export declare class ChatSession<T extends StoredMessage> {
         title?: string;
         avatar?: string;
     }): Promise<ChatGroup>;
+    dissolveGroup(target: ChatConversation | string, options?: {
+        expectedRevision?: string;
+    }): Promise<ChatGroup>;
     sendMessage(threadId: string, input: OutgoingContent, options?: {
         waitFor?: "accepted" | "delivered";
     }): Promise<ChatRuntimeMessage>;
@@ -190,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) => {
@@ -403,6 +404,16 @@ export class ChatSession {
         await this.sendMessage(thread, { groupUpdate: { ...changes, expectedRevision: changes.expectedRevision ?? previous.revision } }, { waitFor: "delivered" });
         return this.groups.after(thread, previous.versionNumber + 1);
     }
+    async dissolveGroup(target, options = {}) {
+        const thread = typeof target === "string" ? await this.resolveConversation(target) : target;
+        const previous = await this.getGroup(thread);
+        if (previous.status === "dissolved")
+            return previous;
+        if (previous.versionNumber >= Number.MAX_SAFE_INTEGER)
+            throw new Error("INVALID_GROUP_VERSION");
+        await this.sendMessage(thread, { groupDissolve: { expectedRevision: options.expectedRevision ?? previous.revision } }, { waitFor: "delivered" });
+        return this.groups.after(thread, previous.versionNumber + 1);
+    }
     sendMessage(thread, input, options = {}) {
         this.assertOpen();
         if (options.waitFor !== undefined && !["accepted", "delivered"].includes(options.waitFor))
@@ -434,8 +445,10 @@ export class ChatSession {
         await this.conversations.put(thread);
         this.assertOpen();
         // Recipients are SDK-owned metadata, never an App-supplied roster.
-        if (thread.kind === "group" && !input.groupCreate && !input.groupUpdate) {
+        if (thread.kind === "group" && !input.groupCreate && !input.groupUpdate && !input.groupDissolve) {
             const group = await this.getGroup(thread);
+            if (group.status === "dissolved")
+                throw new Error("GROUP_DISSOLVED");
             this.assertOpen();
             thread = { ...thread, memberIds: group.memberIds };
         }
@@ -824,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/durableSender.js

@@ -876,7 +876,7 @@ export class DurableChatSender {
         }
     }
 }
-function statefulGroup(message) { const body = message.body; return body?.kind === "group" && (body.action === "groupCreate" || body.action === "groupUpdate"); }
+function statefulGroup(message) { const body = message.body; return body?.kind === "group" && (body.action === "groupCreate" || body.action === "groupUpdate" || body.action === "groupDissolve"); }
 function commandId(scope, version, threadId, message) {
     return bytesToHex(blake3(new TextEncoder().encode(JSON.stringify(["chat-command:v1", scope, version, threadId, message.to, ordered(message.body)]))));
 }

package/lib/runtime/groupClient.d.ts

@@ -2,7 +2,7 @@ import { type ResponseCacheAccess } from "./responseCache.js";
 import { type MessageScope } from "./messageStore.js";
 import { type ChatConversation } from "./outgoingContent.js";
 import type { SocialGroup } from "./socialReadClient.js";
-export type ChatGroup = {
+export type ActiveChatGroup = {
     groupId: string;
     teamId: string;
     ownerId: string;
@@ -11,7 +11,19 @@ export type ChatGroup = {
     memberIds: readonly string[];
     revision: string;
     versionNumber: number;
+    status: "active";
 };
+export type DissolvedChatGroup = {
+    groupId: string;
+    teamId: string;
+    ownerId: string;
+    revision: string;
+    versionNumber: number;
+    status: "dissolved";
+    dissolvedBy?: string;
+    dissolvedAt?: number;
+};
+export type ChatGroup = ActiveChatGroup | DissolvedChatGroup;
 export type GroupSnapshot = {
     data?: ChatGroup;
     loading: boolean;
@@ -22,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;
 };
@@ -44,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;
@@ -106,12 +107,19 @@ export class GroupClient {
     }
     normalize(value, entry) {
         const scope = this.options.scope;
-        if (!value || value.appId !== scope.appId || value.groupId !== entry.thread.targetId || value.teamId !== scope.teamId || !validMessageIdentifier(value.ownerId) || !validMessageIdentifier(value.revision) || !Number.isSafeInteger(value.versionNumber) || value.versionNumber < 1 || !Array.isArray(value.members) || !value.members.length || value.members.length > 256 || !value.members.every(validMessageIdentifier) || !value.members.includes(value.ownerId) || !value.members.includes(scope.profileId) || typeof value.title !== "string" || value.avatar !== undefined && value.avatar !== null && typeof value.avatar !== "string")
+        if (!value || value.appId !== scope.appId || value.groupId !== entry.thread.targetId || value.teamId !== scope.teamId || !validMessageIdentifier(value.ownerId) || !validMessageIdentifier(value.revision) || !Number.isSafeInteger(value.versionNumber) || value.versionNumber < 1)
             throw new Error("INVALID_GROUP_METADATA");
-        return Object.freeze({ groupId: value.groupId, teamId: scope.teamId, ownerId: value.ownerId, title: value.title, ...(value.avatar ? { avatar: value.avatar } : {}), memberIds: Object.freeze([...new Set(value.members)].sort()), revision: value.revision, versionNumber: value.versionNumber });
+        if (value.status === "dissolved") {
+            if (value.dissolvedBy !== undefined && !validMessageIdentifier(value.dissolvedBy) || value.dissolvedAt !== undefined && (!Number.isSafeInteger(value.dissolvedAt) || value.dissolvedAt < 0))
+                throw new Error("INVALID_GROUP_METADATA");
+            return Object.freeze({ groupId: value.groupId, teamId: scope.teamId, ownerId: value.ownerId, revision: value.revision, versionNumber: value.versionNumber, status: "dissolved", ...(value.dissolvedBy ? { dissolvedBy: value.dissolvedBy } : {}), ...(value.dissolvedAt === undefined ? {} : { dissolvedAt: value.dissolvedAt }) });
+        }
+        if (value.status !== undefined && value.status !== "active" || !Array.isArray(value.members) || !value.members.length || value.members.length > 256 || !value.members.every(validMessageIdentifier) || !value.members.includes(value.ownerId) || !value.members.includes(scope.profileId) || typeof value.title !== "string" || value.avatar !== undefined && value.avatar !== null && typeof value.avatar !== "string")
+            throw new Error("INVALID_GROUP_METADATA");
+        return Object.freeze({ groupId: value.groupId, teamId: scope.teamId, ownerId: value.ownerId, title: value.title, ...(value.avatar ? { avatar: value.avatar } : {}), memberIds: Object.freeze([...new Set(value.members)].sort()), revision: value.revision, versionNumber: value.versionNumber, status: "active" });
     }
     cached(value, entry) {
-        return this.normalize({ appId: this.options.scope.appId, groupId: value?.groupId, teamId: value?.teamId, ownerId: value?.ownerId, title: value?.title, avatar: value?.avatar, members: value?.memberIds, revision: value?.revision, versionNumber: value?.versionNumber }, entry);
+        return this.normalize(value.status === "dissolved" ? { appId: this.options.scope.appId, ...value } : { appId: this.options.scope.appId, ...value, members: value.memberIds }, entry);
     }
     local(entry) {
         if (entry.loaded)
@@ -170,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();
@@ -183,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); }
@@ -257,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/outgoingContent.d.ts

@@ -73,6 +73,11 @@ type ContentChoices = {
             avatar?: string;
         };
     };
+    groupDissolve: {
+        groupDissolve: {
+            expectedRevision: string;
+        };
+    };
 };
 export type OutgoingContent = {
     [K in keyof ContentChoices]: ContentChoices[K] & {

package/lib/runtime/outgoingContent.js

@@ -1,6 +1,6 @@
 import { parseChatFile } from "../fileMetadata.js";
 import { dmThreadId, groupThreadId } from "./thread.js";
-const contentKeys = ["text", "file", "image", "voice", "recall", "reaction", "invitation", "groupCreate", "groupUpdate"];
+const contentKeys = ["text", "file", "image", "voice", "recall", "reaction", "invitation", "groupCreate", "groupUpdate", "groupDissolve"];
 export function validMessageIdentifier(value) { return typeof value === "string" && value.length > 0 && new TextEncoder().encode(value).byteLength <= 256 && !/[\u0000-\u001f]/u.test(value); }
 function members(value) {
     if (!Array.isArray(value) || value.length > 256 || !value.every(validMessageIdentifier))
@@ -63,6 +63,11 @@ export function outgoingContent(scope, thread, input) {
             throw new Error("INVALID_GROUP_AVATAR");
         return { to: thread.targetId, body: { kind: "group", threadKind: "group", action: "groupUpdate", payload: { ...identity, groupId: thread.targetId, expectedRevision: update.expectedRevision, addMembers: add, removeMembers: remove, ...(update.title === undefined ? {} : { title: update.title.trim() }), ...(update.avatar === undefined ? {} : { avatar: update.avatar }) } } };
     }
+    if (input.groupDissolve) {
+        if (thread.kind !== "group" || !validMessageIdentifier(input.groupDissolve.expectedRevision))
+            throw new Error("INVALID_GROUP_DISSOLVE");
+        return { to: thread.targetId, body: { kind: "group", threadKind: "group", action: "groupDissolve", payload: { ...identity, groupId: thread.targetId, expectedRevision: input.groupDissolve.expectedRevision } } };
+    }
     if (thread.kind === "group" && !Array.isArray(thread.memberIds))
         throw new Error("MESSAGE_GROUP_MEMBERS_UNAVAILABLE");
     const recipients = thread.kind === "group" ? [...new Set(thread.memberIds)] : undefined;

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/lib/runtime/socialReadClient.d.ts

@@ -18,11 +18,14 @@ export type SocialGroup = {
     groupId: string;
     teamId?: string | null;
     ownerId: string;
-    members: string[];
-    title: string;
+    members?: readonly string[];
+    title?: string;
     avatar?: string | null;
     revision: string;
     versionNumber?: number;
+    status?: "active" | "dissolved";
+    dissolvedBy?: string;
+    dissolvedAt?: number;
 };
 export type SocialRelationship = {
     appId: string;

package/package.json

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