@pmate/chat-sdk 0.12.0-next.62 → 0.12.0-next.64

package/README.md

@@ -166,7 +166,9 @@ can leave the already trusted recent window usable. Cache hits do not repeat
 history requests. Reconnection and browser wake reconcile newer changes.
 
 A thread snapshot contains `threadId`, one renderable `messages` list, `ready`,
-`hasEarlier`, `unread`, `group`, `readCounts` and optional `error`. `ready` helps
+`hasEarlier`, `unread`, `group`, `readCounts`, optional `conversation` target identity,
+and optional `error`. Target identity survives recalls without exposing redacted
+message bodies. `ready` helps
 route entry and startup before the first read; it is not a cache-source indicator.
 `getSnapshot()` and `subscribe(listener)` provide conversation summaries, aggregate
 unread counts and connection state. Unknown unread counts remain `undefined`.
@@ -213,7 +215,9 @@ selects receipt counts for the current viewport; clear with `watchReaders(undefi
 `ChatError` exposes `code`, `retryable`, optional HTTP `status`, and the original
 `cause`. Recovery categories are `unavailable`, `access-denied`,
 `storage-unavailable`, `invalid-input`, `conflict`, `closed`, and `busy`.
-Permission failures never turn into trusted offline data. Dispose and recreate
+Permission failures withdraw the current scoped session and retire its caches;
+failed cleanup remains in the error cause. They never turn into trusted offline
+data. Dispose and recreate
 the SDK when account, profile, team or token changes.
 
 ### Advanced integration and migration
@@ -268,4 +272,5 @@ SDK group metadata uses a 200ms merge window, four concurrent requests, a bounde
 The persistent group cache is capped at 64 groups / 1MiB, with 128KiB records,
 32-record write batches, conditional writes and bounded pruning. Conversation
 identities are stored separately without rosters; repeated registrations share
-one write and concurrent lookups use bulk reads. Scope withdrawal retires both.
+one write, concurrent lookups use bulk reads, and a concurrent memory-hit burst
+shares one fresh authority read without retaining authorization across bursts. Scope withdrawal retires both.

package/lib/chat.d.ts

@@ -3,24 +3,34 @@ import type { ChatSession, ChatSummarySnapshot as SessionSummary, ChatThreadSnap
 import type { CachedChatMessage } from "./runtime/cachedMessage.js";
 import type { TimelineItem } from "./runtime/messageTimeline.js";
 import type { ConversationTarget } from "./runtime/conversationDirectory.js";
-import type { OutgoingContent } from "./runtime/outgoingContent.js";
+import type { OutgoingContent as RuntimeContent } from "./runtime/outgoingContent.js";
 import { ChatError } from "./runtime/chatError.js";
 export { ChatError } from "./runtime/chatError.js";
 export type { ChatErrorCode } from "./runtime/chatError.js";
-export type { CreateChatOptions, ConversationTarget, OutgoingContent };
+export type { CreateChatOptions, ConversationTarget };
+export type OutgoingContent = Exclude<RuntimeContent, {
+    groupCreate: unknown;
+} | {
+    groupUpdate: unknown;
+}>;
 export type { ChatGroup } from "./runtime/groupClient.js";
-export type ChatMessage = TimelineItem<CachedChatMessage>;
-export type ChatThreadSnapshot = {
+export type ChatMessage = Readonly<TimelineItem<CachedChatMessage>>;
+export type ConversationInfo = Readonly<{
+    kind: "dm" | "group";
+    targetId: string;
+}>;
+export type ChatThreadSnapshot = Readonly<{
     threadId: string;
     messages: readonly ChatMessage[];
     ready: boolean;
     hasEarlier: boolean;
+    conversation?: ConversationInfo;
     unread: SessionThread<CachedChatMessage>["unread"];
     group: SessionThread<CachedChatMessage>["group"];
     readCounts: SessionThread<CachedChatMessage>["readCounts"];
     error?: ChatError;
-};
-export type ChatSnapshot = {
+}>;
+export type ChatSnapshot = Readonly<{
     threads: readonly {
         threadId: string;
         lastMessage?: ChatMessage;
@@ -31,7 +41,7 @@ export type ChatSnapshot = {
     unreadMessageCount: number | undefined;
     badgeCount: number | undefined;
     connection: SessionSummary<CachedChatMessage>["connection"];
-};
+}>;
 export type MessageQuery = {
     earlier?: boolean;
     all?: boolean;
@@ -40,10 +50,10 @@ export type MessageQuery = {
 export type SendOptions = {
     waitFor?: "accepted" | "delivered";
 };
-export type SentMessage = {
+export type SentMessage = Readonly<{
     id: string;
     timestamp: number;
-};
+}>;
 type SubscribeOptions<T> = {
     fields?: readonly (keyof T)[];
     emitCurrent?: boolean;
@@ -54,11 +64,14 @@ export declare class Chat {
     private options;
     private views;
     private summary?;
+    private targets;
     private errors;
     private listeners;
     private closed;
     constructor(advanced: ChatSession<CachedChatMessage>, options: CreateChatOptions);
     private operation;
+    private deny;
+    private threadOperation;
     start(): Promise<void>;
     getConversation(target: ConversationTarget): Promise<string>;
     getSnapshot(): ChatSnapshot;

package/lib/chat.js

@@ -8,6 +8,7 @@ export class Chat {
     options;
     views = new Map();
     summary;
+    targets = new Map();
     errors = new Map();
     listeners = new Map();
     closed = false;
@@ -21,19 +22,63 @@ export class Chat {
     catch (error) {
         throw asChatError(error);
     } }
+    async deny(threadId, failure) {
+        this.errors.set(threadId, failure);
+        this.targets.delete(threadId);
+        const retiring = this.advanced.revokeAccess();
+        this.notify(threadId);
+        try {
+            await retiring;
+        }
+        catch (error) {
+            failure.cause = new AggregateError([failure.cause, error], "Access withdrawn; cache cleanup incomplete");
+        }
+    }
+    threadOperation(threadId, run) {
+        return this.operation(async () => {
+            const denied = threadId ? this.errors.get(threadId) : undefined;
+            if (denied?.code === "access-denied")
+                throw denied;
+            try {
+                return await run();
+            }
+            catch (error) {
+                const failure = asChatError(error);
+                if (threadId && failure.code === "access-denied")
+                    await this.deny(threadId, failure);
+                throw failure;
+            }
+        });
+    }
     start() { return this.operation(() => this.options.connection ? this.advanced.initialize() : this.advanced.start()); }
-    getConversation(target) { return this.operation(() => this.advanced.getConversation(target)); }
+    getConversation(target) {
+        return this.operation(async () => {
+            const id = await this.advanced.getConversation(target);
+            const value = target.groupId !== undefined ? { kind: "group", targetId: target.groupId } : { kind: "dm", targetId: target.peerId };
+            this.targets.delete(id);
+            this.targets.set(id, value);
+            if (this.targets.size > 256)
+                this.targets.delete(this.targets.keys().next().value);
+            this.notify(id);
+            return id;
+        });
+    }
     getSnapshot(threadId) {
         if (threadId === undefined) {
             const source = this.advanced.getSnapshot(), previous = this.summary;
-            const threads = source.threads.map(thread => ({ threadId: thread.threadId, lastMessage: thread.lastItem, group: thread.group, unread: thread.unread, outgoingCount: thread.outgoingCount }));
-            if (previous && previous.connection === source.connection && previous.badgeCount === source.badgeCount && previous.unreadMessageCount === source.unreadMessageCount && previous.threads.length === threads.length && threads.every((thread, i) => { const old = previous.threads[i]; return thread.threadId === old.threadId && thread.lastMessage === old.lastMessage && thread.group === old.group && thread.unread === old.unread && thread.outgoingCount === old.outgoingCount; }))
+            const threads = source.threads.filter(thread => this.errors.get(thread.threadId)?.code !== "access-denied").map(thread => ({ threadId: thread.threadId, lastMessage: thread.lastItem, group: thread.group, unread: thread.unread, outgoingCount: thread.outgoingCount }));
+            const unreadMessageCount = source.unreadMessageCount === undefined ? undefined : threads.reduce((sum, thread) => sum + (thread.unread?.unreadMessageCount ?? 0), 0);
+            const badgeCount = source.badgeCount === undefined ? undefined : threads.reduce((sum, thread) => sum + (thread.unread?.badgeCount ?? 0), 0);
+            if (previous && previous.connection === source.connection && previous.badgeCount === badgeCount && previous.unreadMessageCount === unreadMessageCount && previous.threads.length === threads.length && threads.every((thread, i) => { const old = previous.threads[i]; return thread.threadId === old.threadId && thread.lastMessage === old.lastMessage && thread.group === old.group && thread.unread === old.unread && thread.outgoingCount === old.outgoingCount; }))
                 return previous;
-            return this.summary = { threads, connection: source.connection, badgeCount: source.badgeCount, unreadMessageCount: source.unreadMessageCount };
+            return this.summary = { threads, connection: source.connection, badgeCount, unreadMessageCount };
         }
         const source = this.advanced.getSnapshot(threadId), previous = this.views.get(threadId);
+        const error = this.closed ? undefined : this.errors.get(threadId), denied = error?.code === "access-denied";
+        const target = this.closed || !this.advanced.active || denied ? undefined : this.advanced.getConversationTarget(threadId) ?? this.targets.get(threadId);
+        const conversation = previous?.conversation?.kind === target?.kind && previous?.conversation?.targetId === target?.targetId ? previous?.conversation : target ? { kind: target.kind, targetId: target.targetId } : undefined;
         // Partial migrated rows never masquerade as a trusted recent window.
-        const next = { threadId, messages: source.complete ? source.timeline : emptyMessages, ready: source.complete, hasEarlier: source.hasEarlier, unread: source.unread, group: source.group, readCounts: source.readCounts, error: this.closed ? undefined : this.errors.get(threadId) };
+        const next = { threadId, conversation, messages: !denied && source.complete ? source.timeline : emptyMessages, ready: !denied && source.complete, hasEarlier: !denied && source.hasEarlier, unread: denied ? undefined : source.unread, group: denied ? undefined : source.group, readCounts: denied ? undefined : source.readCounts, error };
         if (previous && Object.keys(next).every(key => next[key] === previous[key]))
             return previous;
         this.views.set(threadId, next);
@@ -53,14 +98,23 @@ export class Chat {
         catch (error) {
             const failure = asChatError(error);
             if (!this.closed) {
-                this.errors.set(threadId, failure);
-                this.notify(threadId);
+                if (failure.code === "access-denied")
+                    await this.deny(threadId, failure);
+                else {
+                    this.errors.set(threadId, failure);
+                    this.notify(threadId);
+                }
             }
             throw failure;
         }
     }
     sendMessage(threadId, content, options = {}) {
-        return this.operation(async () => { const result = await this.advanced.sendMessage(threadId, content, options); return { id: result.hash, timestamp: result.t }; });
+        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");
+            const result = await this.advanced.sendMessage(threadId, content, options);
+            return { id: result.hash, timestamp: result.t };
+        });
     }
     retryMessage(messageId) { return this.operation(async () => { const result = await this.advanced.retryMessage(messageId); return { id: result.hash, timestamp: result.t }; }); }
     subscribe(target, callback, options = {}) {
@@ -97,16 +151,16 @@ export class Chat {
         return dispose;
     }
     sessionFields(fields) {
-        return fields ? [...new Set(fields.flatMap(field => field === "messages" ? ["timeline", "complete"] : field === "ready" ? ["complete"] : field === "error" || field === "threadId" ? [] : [field]))] : undefined;
+        return fields ? [...new Set(fields.flatMap(field => field === "messages" ? ["timeline", "complete"] : field === "ready" ? ["complete"] : field === "conversation" ? ["messages", "group"] : field === "error" || field === "threadId" ? [] : [field]))] : undefined;
     }
-    notify(threadId) { this.listeners.get(threadId)?.forEach(listener => listener()); }
-    observeMessages(threadId, ids, event) { return this.operation(() => this.advanced.observeMessages(threadId, ids, event)); }
-    markRead(threadId) { return this.operation(() => this.advanced.markRead(threadId)); }
-    getReaders(threadId, messageId, page = {}, signal) { return this.operation(() => this.advanced.getReaders(threadId, messageId, page, signal)); }
-    watchReaders(threadId, ids, receiver) { return this.operation(() => this.advanced.observeMessages(threadId, ids, "receipts", receiver)); }
+    notify(threadId) { this.listeners.get(threadId)?.forEach(listener => listener()); this.listeners.get("")?.forEach(listener => listener()); }
+    observeMessages(threadId, ids, event) { return this.threadOperation(threadId, () => this.advanced.observeMessages(threadId, ids, event)); }
+    markRead(threadId) { return this.threadOperation(threadId, () => this.advanced.markRead(threadId)); }
+    getReaders(threadId, messageId, page = {}, signal) { return this.threadOperation(threadId, () => this.advanced.getReaders(threadId, messageId, page, signal)); }
+    watchReaders(threadId, ids, receiver) { return this.threadOperation(threadId, () => this.advanced.observeMessages(threadId, ids, "receipts", receiver)); }
     handleReach(event) { return this.operation(() => this.advanced.handleReach(event)); }
-    getVoiceAttachment(threadId, messageId) { return this.operation(() => this.advanced.getVoiceAttachment(threadId, messageId)); }
-    getGroup(threadId, options = {}) { return this.operation(() => this.advanced.getGroup(threadId, options)); }
+    getVoiceAttachment(threadId, messageId) { return this.threadOperation(threadId, () => this.advanced.getVoiceAttachment(threadId, messageId)); }
+    getGroup(threadId, options = {}) { return this.threadOperation(threadId, () => this.advanced.getGroup(threadId, options)); }
     createGroup(input) {
         return this.operation(async () => {
             const groupId = input.groupId ?? crypto.randomUUID(), threadId = await this.getConversation({ groupId });
@@ -114,9 +168,9 @@ export class Chat {
             return { ...group, threadId };
         });
     }
-    updateGroup(threadId, changes) { return this.operation(() => this.advanced.updateGroup(threadId, changes)); }
+    updateGroup(threadId, changes) { return this.threadOperation(threadId, () => this.advanced.updateGroup(threadId, changes)); }
     revokeAccess() { return this.operation(() => this.advanced.revokeAccess()); }
-    close() { this.closed = true; return this.operation(() => this.advanced.close()).finally(() => { this.errors.clear(); this.listeners.clear(); this.views.clear(); this.summary = undefined; }); }
+    close() { this.closed = true; return this.operation(() => this.advanced.close()).finally(() => { this.errors.clear(); this.targets.clear(); this.listeners.clear(); this.views.clear(); this.summary = undefined; }); }
 }
 export function createChat(options) {
     const configured = { ...options, onError: (error) => options.onError(asChatError(error)) };

package/lib/runtime/chatSession.d.ts

@@ -161,6 +161,8 @@ export declare class ChatSession<T extends StoredMessage> {
     getConversation(target: ConversationTarget): Promise<string>;
     private sendContent;
     private resolveConversation;
+    /** Validated target identity survives content redaction; no roster is exposed. */
+    getConversationTarget(threadId: string): ChatConversation | undefined;
     private sendControl;
     getReaders(threadId: string, messageId: string, page?: Omit<MessageReadersQuery, "threadId" | "messageId">, signal?: AbortSignal): Promise<import("./messageReaders.js").MessageReadersPage>;
     /** Resolve voice media uniformly; pending local bytes are loaded only on demand. */
@@ -190,6 +192,7 @@ export declare class ChatSession<T extends StoredMessage> {
     /** Permanently retire this identity/team session. UI withdrawal is immediate;
      * completion means all durable stores have crossed the same authority epoch. */
     revokeAccess(): Promise<void>;
+    get active(): boolean;
     close(): Promise<void>;
     private dispose;
 }

package/lib/runtime/chatSession.js

@@ -436,6 +436,13 @@ export class ChatSession {
         const known = await this.conversations.get(threadId);
         if (known)
             return known;
+        const inferred = this.getConversationTarget(threadId);
+        if (!inferred)
+            throw new Error("MESSAGE_CONVERSATION_UNKNOWN");
+        return inferred;
+    }
+    /** Validated target identity survives content redaction; no roster is exposed. */
+    getConversationTarget(threadId) {
         const scope = this.options.messages.scope;
         const group = this.getSnapshot(threadId).group;
         if (group)
@@ -453,7 +460,7 @@ export class ChatSession {
             }
             catch { }
         }
-        throw new Error("MESSAGE_CONVERSATION_UNKNOWN");
+        return undefined;
     }
     sendControl(thread, wire, delivered = false) {
         const content = wire.body.content;
@@ -857,6 +864,7 @@ export class ChatSession {
                 throw new AggregateError(failures, "CHAT_ACCESS_CLEANUP_FAILED");
         });
     }
+    get active() { return !this.closed && !this.withdrawn; }
     close() { return this.revoking ?? this.dispose(); }
     dispose() {
         return this.closing ??= (async () => {

package/lib/runtime/conversationDirectory.d.ts

@@ -18,10 +18,12 @@ export declare class ConversationDirectory {
     private queue;
     private writes;
     private version;
+    private authority;
     private scheduled;
     private closed;
     private retired;
     constructor(scope: MessageScope, access: ResponseCacheAccess);
+    private authorize;
     private assertOpen;
     private remember;
     create(target: ConversationTarget): Promise<string>;

package/lib/runtime/conversationDirectory.js

@@ -12,14 +12,16 @@ export class ConversationDirectory {
     queue = [];
     writes = new Map();
     version;
+    authority;
     scheduled = false;
     closed = false;
     retired = false;
     constructor(scope, access) {
         this.scope = scope;
         this.access = access;
-        this.cache = new IndexedDbResponseCache(`conversations:${messageScopeKey(scope)}`, { access, entries: 256, recordBytes: 4096 });
+        this.cache = new IndexedDbResponseCache(`conversations:${messageScopeKey(scope)}`, { access: () => this.authorize(), entries: 256, recordBytes: 4096 });
     }
+    authorize() { return this.authority ??= this.access().finally(() => { this.authority = undefined; }); }
     assertOpen() { if (this.retired)
         throw new Error("CHAT_ACCESS_REVOKED"); if (this.closed)
         throw new Error("CHAT_SESSION_CLOSED"); }
@@ -67,7 +69,7 @@ export class ConversationDirectory {
     }
     async get(id) {
         this.assertOpen();
-        const authority = await this.access();
+        const authority = await this.authorize();
         this.assertOpen();
         if (!authority.allowed)
             throw new Error("CHAT_ACCESS_REVOKED");

package/package.json

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