@pmate/chat-sdk 0.12.0-next.31 → 0.12.0-next.33

package/lib/runtime/chatSession.js

@@ -203,7 +203,16 @@ export class ChatSession {
     }
     synchronizeReading(cursor, profileId) { return this.readingOperation(() => this.reading.synchronize(cursor, profileId), false); }
     /** Explicit text-history acknowledgement; unheard audio stays unread. */
-    markRead(threadId, messages = []) { return this.readingOperation(() => this.reading.markRead(threadId, messages)); }
+    async markRead(threadId, messages) {
+        this.assertOpen();
+        const cached = messages ?? this.getSnapshot(threadId).timeline.flatMap(item => {
+            if (item.recalled || !item.message)
+                return [];
+            const candidate = this.options.readingCandidate?.(item.message);
+            return candidate ? [{ id: item.id, threadId, from: item.from, mine: item.mine, recalled: item.recalled, readPolicy: candidate.readPolicy }] : [];
+        });
+        return this.readingOperation(() => this.reading.markRead(threadId, cached));
+    }
     updateReading(transform) { return this.readingOperation(() => this.reading.update(transform)); }
     assertOpen() { if (this.withdrawn)
         throw new Error("CHAT_ACCESS_REVOKED"); if (this.closed)
@@ -439,19 +448,23 @@ export class ChatSession {
         return snapshot;
     }
     buildThreadSnapshot(threadId, previous) {
-        const messages = this.messages.getSnapshot(threadId);
+        const source = this.messages.getSnapshot(threadId), raw = source?.messages ?? [];
+        const messages = previous && previous.messages.length === raw.length && previous.messages.every((message, index) => message === raw[index]) ? previous.messages : raw;
+        const outgoing = this.sender.snapshot(threadId);
+        const sameSource = previous && previous.messages === messages && previous.outgoing.length === outgoing.length && previous.outgoing.every((record, index) => record === outgoing[index]);
+        const semanticReading = previous?.messageReading ?? {};
+        const semantics = sameSource ? previous.timeline : projectMessageTimeline({ appId: this.options.messages.scope.appId, profileId: this.options.messages.scope.profileId, threadId, messages, outgoing, decode: this.decodeTimeline, reading: semanticReading, previous: previous?.timeline });
+        const candidates = new Map(messages.flatMap(message => { const candidate = this.options.readingCandidate?.(message); return candidate ? [[candidate.id, candidate]] : []; }));
+        for (const item of semantics)
+            if (item.recalled)
+                candidates.set(item.id, { ...candidates.get(item.id), id: item.id, threadId, from: item.from, mine: item.mine, recalled: true });
         const state = this.getReadingSnapshot();
-        const candidates = messages?.messages.flatMap(message => { const candidate = this.options.readingCandidate?.(message); return candidate ? [candidate] : []; }) ?? [];
-        const sources = state?.threads.filter(thread => (thread.conversationId ?? thread.id) === threadId) ?? [];
-        const kind = sources[0]?.kind ?? "dm";
-        const view = projectConversationReading(state, { id: threadId, kind }, candidates);
+        const kind = state?.threads.find(thread => (thread.conversationId ?? thread.id) === threadId)?.kind ?? "dm";
+        const view = projectConversationReading(state, { id: threadId, kind }, [...candidates.values()]);
         const unread = previous && JSON.stringify(previous.unread) === JSON.stringify(view.unread) ? previous.unread : view.unread;
         const messageReading = previous && JSON.stringify(previous.messageReading) === JSON.stringify(view.messageReading) ? previous.messageReading : view.messageReading;
-        const raw = messages?.messages ?? [];
-        const stableMessages = previous && previous.messages.length === raw.length && previous.messages.every((message, index) => message === raw[index]) ? previous.messages : raw;
-        const outgoing = this.sender.snapshot(threadId);
-        const timeline = projectMessageTimeline({ appId: this.options.messages.scope.appId, profileId: this.options.messages.scope.profileId, threadId, messages: stableMessages, outgoing, decode: this.decodeTimeline, reading: messageReading, previous: previous?.timeline });
-        return { timeline, messages: stableMessages, hasEarlier: messages?.hasEarlier ?? false, resetVersion: messages?.resetVersion ?? 0, complete: messages?.complete ?? false, outgoing, readCounts: this.countSnapshots.get(threadId), unread, messageReading };
+        const timeline = messageReading === semanticReading ? semantics : projectMessageTimeline({ appId: this.options.messages.scope.appId, profileId: this.options.messages.scope.profileId, threadId, messages, outgoing, decode: this.decodeTimeline, reading: messageReading, previous: previous?.timeline });
+        return { timeline, messages, hasEarlier: source?.hasEarlier ?? false, resetVersion: source?.resetVersion ?? 0, complete: source?.complete ?? false, outgoing, readCounts: this.countSnapshots.get(threadId), unread, messageReading };
     }
     subscribe(target, listener, fields) {
         if (this.closed || this.withdrawn)

package/lib/runtime/conversationReading.js

@@ -2,13 +2,18 @@ import { sourcesInConversation, unreadInConversation } from "./readIndex.js";
 /** One projection for indexed authority and observations awaiting indexing. A
  * directory badge is optional compatibility metadata, never proof of coverage. */
 export function projectConversationReading(state, conversation, candidates = []) {
+    const unique = new Map(candidates.filter(message => message.threadId === conversation.id).map(message => [message.id, message]));
+    const hidden = new Map();
+    for (const message of unique.values())
+        if (message.recalled && message.from)
+            hidden.set(message.id, new Set([message.from]));
     const sources = state ? sourcesInConversation(state, conversation.id) : [];
     const sourceIds = new Set([conversation.id, ...sources.map(source => source.id)]);
     const indexed = new Set(), messageReading = Object.create(null);
     for (const source of sources)
         for (const message of source.messages) {
             indexed.add(message.id);
-            messageReading[message.id] = { seq: message.seq, readPolicy: message.readPolicy, read: message.recalled || message.from === state.profileId || !message.recipients.includes(state.profileId) || (message.readPolicy === "explicit" ? source.explicitReadMessageIds.includes(message.id) : message.seq <= source.readThroughSeq) };
+            messageReading[message.id] = { seq: message.seq, readPolicy: message.readPolicy, read: message.recalled || hidden.get(message.id)?.has(message.from) === true || message.from === state.profileId || !message.recipients.includes(state.profileId) || (message.readPolicy === "explicit" ? source.explicitReadMessageIds.includes(message.id) : message.seq <= source.readThroughSeq) };
         }
     const observed = new Map();
     for (const intent of state?.observedReadIntents ?? [])
@@ -17,7 +22,6 @@ export function projectConversationReading(state, conversation, candidates = [])
                 observed.set(intent.messageId, new Set());
             observed.get(intent.messageId).add(intent.readPolicy);
         }
-    const unique = new Map(candidates.filter(message => message.threadId === conversation.id).map(message => [message.id, message]));
     let pendingMessages = 0, pendingMentions = 0, observedBadges = 0;
     for (const message of unique.values()) {
         const incoming = !message.mine && message.from !== state?.profileId && !message.recalled;
@@ -36,7 +40,7 @@ export function projectConversationReading(state, conversation, candidates = [])
         if (message.attentionEligible === true)
             pendingMentions++;
     }
-    const authoritative = sources.length && state ? unreadInConversation(state, conversation.id) : undefined;
+    const authoritative = sources.length && state ? unreadInConversation(state, conversation.id, hidden) : undefined;
     const unread = authoritative ? { unreadMessageCount: authoritative.unreadMessageCount + pendingMessages, unreadMentionCount: authoritative.unreadMentionCount + pendingMentions, badgeCount: authoritative.badgeCount + (conversation.kind === "group" ? pendingMentions : pendingMessages) } : undefined;
     const pendingBadge = conversation.kind === "group" ? pendingMentions : pendingMessages;
     return { messageReading, unread, badgeCount: unread?.badgeCount ?? (conversation.badgeCount === undefined ? undefined : Math.max(Math.max(0, conversation.badgeCount - observedBadges), pendingBadge)) };

package/lib/runtime/createChat.d.ts

@@ -4,6 +4,7 @@ import type { ChatClient, ChatClientOptions } from "./chatClient.js";
 export type CachedChatMessage = ChatReaderSocialMessage & {
     id: string;
     timestamp: number;
+    readPolicy?: "visible" | "explicit";
 };
 export type CreateChatOptions = {
     appId: string;

package/lib/runtime/createChat.js

@@ -1,4 +1,4 @@
-import { isReadingControl } from "./readingContent.js";
+import { isReadingControl, messageRequiresPlayback, messageMentionsProfile } from "./readingContent.js";
 import { ChatSession } from "./chatSession.js";
 import { SocialReadClient } from "./socialReadClient.js";
 import { chatTeamId } from "./teamScope.js";
@@ -29,7 +29,7 @@ export function createChat(options) {
             if (!body || !["message", "quote"].includes(String(body.kind)) && !(body.kind === "contact" && ["friendRequest", "requestFriend"].includes(String(body.action))))
                 return undefined;
             return { id: message.id, threadId: message.threadId, from: message.from, mine: message.from === profileId, recalled: message.recalled, unread: message.from !== profileId,
-                readPolicy: body?.contentKind === "voice" ? "explicit" : "visible", attentionEligible: Array.isArray(body.content?.mentions) && body.content.mentions.some(mention => mention?.id === profileId) };
+                readPolicy: message.readPolicy === "explicit" || message.legacyDisplay?.kind === "voice" || messageRequiresPlayback(body) ? "explicit" : "visible", attentionEligible: messageMentionsProfile(body, profileId) };
         },
         decode: message => decodeIncoming(message, { appId, profileId, teamId }), onError,
     });

package/lib/runtime/messageTimeline.js

@@ -3,6 +3,11 @@ function content(message, appId) {
     const body = message.body;
     return body?.kind === "message" && body.content?.appId === appId ? body : undefined;
 }
+function nativeRecall(message, appId) {
+    const body = message.body;
+    return message.appId === appId && body?.kind === "recall" && typeof body.targetMessageId === "string" && body.targetMessageId.length > 0 && body.targetMessageId.length <= 256 ? body.targetMessageId : undefined;
+}
+function isControl(message, appId) { return isReadingControl(message.body, appId) || nativeRecall(message, appId) !== undefined; }
 function validReaction(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -17,6 +22,7 @@ export function projectMessageTimeline(input) {
         const app = body?.content?.appId ?? body?.payload?.appId;
         return message.threadId === input.threadId && (value.appId === undefined || value.appId === input.appId) && (app === undefined || app === input.appId);
     };
+    const tombstones = new Set(input.messages.filter(message => scoped(message) && (message.recalled || message.legacyDisplay?.recalled)).map(message => message.id));
     const records = new Map();
     for (const pending of input.outgoing) {
         if (pending.threadId !== input.threadId || pending.confirmed)
@@ -41,9 +47,9 @@ export function projectMessageTimeline(input) {
             reactions.set(key, event);
     };
     for (const { message, status } of records.values()) {
-        if (status === "failed" && isReadingControl(message.body, input.appId))
+        if (status === "failed" && isControl(message, input.appId))
             continue;
-        const envelope = message, body = content(envelope, input.appId), target = body?.content?.recall?.messageId;
+        const envelope = message, body = content(envelope, input.appId), target = nativeRecall(envelope, input.appId) ?? body?.content?.recall?.messageId;
         if (typeof target === "string" && target.length > 0 && target.length <= 256 && envelope.from) {
             if (!recalled.has(target))
                 recalled.set(target, new Set());
@@ -96,10 +102,10 @@ export function projectMessageTimeline(input) {
     const result = [];
     for (const { message, status } of records.values()) {
         const envelope = message;
-        if (isReadingControl(envelope.body, input.appId))
+        if (isControl(envelope, input.appId))
             continue;
         const mine = envelope.from === input.profileId, reading = input.reading[message.id];
-        const withdrawn = Boolean(message.recalled || envelope.legacyDisplay?.recalled || envelope.from && recalled.get(message.id)?.has(envelope.from));
+        const withdrawn = Boolean(tombstones.has(message.id) || message.recalled || envelope.legacyDisplay?.recalled || envelope.from && recalled.get(message.id)?.has(envelope.from));
         const item = { id: message.id, threadId: message.threadId, timestamp: message.timestamp, from: envelope.from, mine, status: !mine && reading ? (reading.read ? "read" : status === "read" ? "sent" : status) : status, recalled: withdrawn,
             message: withdrawn ? undefined : message, reading, reactionEvents: withdrawn ? [] : groupedEvents.get(message.id) ?? [], reactions: withdrawn ? [] : [...(grouped.get(message.id) ?? [])].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([emojiId, users]) => { const userIds = [...users].sort(); return { emojiId, userIds, mine: userIds.includes(input.profileId) }; }) };
         const old = previous.get(item.id);

package/lib/runtime/readIndex.d.ts

@@ -72,7 +72,7 @@ export declare function coalesceReadOperations(current: ReadIndexState): (Readin
     operationIds: string[];
 })[];
 /** Counts are over the indexed message coverage, not an estimate of missing history. */
-export declare function unreadInThread(state: ReadIndexState, threadId: string): {
+export declare function unreadInThread(state: ReadIndexState, threadId: string, hidden?: ReadonlyMap<string, ReadonlySet<string>>): {
     unreadMessageCount: number;
     unreadMentionCount: number;
     badgeCount: number;
@@ -126,7 +126,7 @@ export declare class IndexedDbReadIndex implements ReadIndexPersistence {
 }
 export declare function sourcesInConversation(state: ReadIndexState, conversationId: string): IndexedReadThread[];
 /** Aggregate logical history while each original source retains its own read cursor. */
-export declare function unreadInConversation(state: ReadIndexState, conversationId: string): {
+export declare function unreadInConversation(state: ReadIndexState, conversationId: string, hidden?: ReadonlyMap<string, ReadonlySet<string>>): {
     unreadMessageCount: number;
     unreadMentionCount: number;
     badgeCount: number;

package/lib/runtime/readIndex.js

@@ -154,12 +154,12 @@ export function coalesceReadOperations(current) {
     return [...batches.values()];
 }
 /** Counts are over the indexed message coverage, not an estimate of missing history. */
-export function unreadInThread(state, threadId) {
+export function unreadInThread(state, threadId, hidden) {
     const thread = state.threads.find(t => t.id === threadId);
     if (!thread)
         throw new Error("UNKNOWN_READ_THREAD");
     const explicit = new Set(thread.explicitReadMessageIds);
-    const messages = thread.messages.filter(message => !message.recalled && !isReadingControl(message.payload, state.appId) && message.from !== state.profileId && message.recipients.includes(state.profileId)
+    const messages = thread.messages.filter(message => !message.recalled && !hidden?.get(message.id)?.has(message.from) && !isReadingControl(message.payload, state.appId) && message.from !== state.profileId && message.recipients.includes(state.profileId)
         && (message.readPolicy === "explicit" ? !explicit.has(message.id) : message.seq > thread.readThroughSeq));
     const unreadMessageCount = messages.length;
     const unreadMentionCount = messages.filter(message => message.mentions.includes(state.profileId)).length;
@@ -426,14 +426,14 @@ function readSource(state, conversationId, messageId) {
     return sources[0];
 }
 /** Aggregate logical history while each original source retains its own read cursor. */
-export function unreadInConversation(state, conversationId) {
+export function unreadInConversation(state, conversationId, hidden) {
     const sources = sourcesInConversation(state, conversationId);
     if (!sources.length)
         throw new Error("UNKNOWN_READ_CONVERSATION");
     if (new Set(sources.map(source => source.teamId)).size > 1)
         throw new Error("READ_CONVERSATION_TEAM_MISMATCH");
     return sources.reduce((total, source) => {
-        const unread = unreadInThread(state, source.id);
+        const unread = unreadInThread(state, source.id, hidden);
         return { unreadMessageCount: total.unreadMessageCount + unread.unreadMessageCount, unreadMentionCount: total.unreadMentionCount + unread.unreadMentionCount, badgeCount: total.badgeCount + unread.badgeCount };
     }, { unreadMessageCount: 0, unreadMentionCount: 0, badgeCount: 0 });
 }

package/lib/runtime/readingContent.d.ts

@@ -1,2 +1,5 @@
 /** Social control envelopes do not contribute to message unread counts. */
 export declare function isReadingControl(payload: unknown, appId: string): boolean;
+/** Mirrors the server's voice policy for ordinary and quoted wire envelopes. */
+export declare function messageRequiresPlayback(body: unknown): boolean;
+export declare function messageMentionsProfile(body: unknown, profileId: string): boolean;

package/lib/runtime/readingContent.js

@@ -7,3 +7,17 @@ export function isReadingControl(payload, appId) {
         return isReadingControl(value.body, appId);
     return value.kind === "message" && value.content?.appId === appId && (value.content.reaction !== undefined || value.content.recall !== undefined);
 }
+/** Mirrors the server's voice policy for ordinary and quoted wire envelopes. */
+export function messageRequiresPlayback(body) {
+    if (!body || typeof body !== "object")
+        return false;
+    const value = body;
+    return value.contentKind === "voice" || value.content?.contentKind === "voice" || [value.content?.voice?.url, value.content?.content?.voice?.url].some(url => typeof url === "string" && url.length > 0);
+}
+export function messageMentionsProfile(body, profileId) {
+    if (!body || typeof body !== "object")
+        return false;
+    const content = body.content;
+    const mentions = content?.mentions !== undefined ? content.mentions : content?.content?.mentions;
+    return Array.isArray(mentions) && mentions.some(mention => mention?.id === profileId);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.31",
+  "version": "0.12.0-next.33",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",