@pmate/chat-sdk 0.12.0-next.30 → 0.12.0-next.32

package/lib/runtime/chatSession.js

@@ -439,19 +439,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/index.d.ts

@@ -31,4 +31,4 @@ export * from "./messageReaders.js";
 export * from "./createChat.js";
 export * from "./conversationRead.js";
 export { projectConversationReading, type ReadingCandidate, type MessageReadingState, type ConversationReadingView } from "./conversationReading.js";
-export { projectMessageTimeline, type TimelineItem, type TimelineReaction } from "./messageTimeline.js";
+export { projectMessageTimeline, type TimelineItem, type TimelineReaction, type TimelineReactionEvent } from "./messageTimeline.js";

package/lib/runtime/messageTimeline.d.ts

@@ -2,6 +2,9 @@ import type { StoredMessage } from "./messageStore.js";
 import type { OutgoingMessage } from "./durableSender.js";
 import type { ChatRuntimeMessage } from "./protocol.js";
 import type { MessageReadingState } from "./conversationReading.js";
+export type TimelineReactionEvent = Reaction & {
+    threadId: string;
+};
 export type TimelineReaction = {
     emojiId: string;
     userIds: string[];
@@ -18,6 +21,16 @@ export type TimelineItem<T> = {
     message: T | undefined;
     reading?: MessageReadingState;
     reactions: readonly TimelineReaction[];
+    reactionEvents: readonly TimelineReactionEvent[];
+};
+type Reaction = {
+    id: string;
+    messageId: string;
+    from: string;
+    emojiId: string;
+    active: boolean;
+    revision: number;
+    timestamp: number;
 };
 /** Derives one display stream without copying bodies or creating another cache.
  * Outgoing rows retain their wire identity; indexed rows take precedence. */
@@ -31,3 +44,4 @@ export declare function projectMessageTimeline<T extends StoredMessage>(input: {
     reading: Readonly<Record<string, MessageReadingState>>;
     previous?: readonly TimelineItem<T>[];
 }): readonly TimelineItem<T>[];
+export {};

package/lib/runtime/messageTimeline.js

@@ -17,6 +17,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)
@@ -74,6 +75,14 @@ export function projectMessageTimeline(input) {
                 }
             }
     }
+    const groupedEvents = new Map();
+    for (const event of reactions.values()) {
+        const values = groupedEvents.get(event.messageId) ?? [];
+        values.push({ ...event, threadId: input.threadId });
+        groupedEvents.set(event.messageId, values);
+    }
+    for (const values of groupedEvents.values())
+        values.sort((a, b) => a.from < b.from ? -1 : a.from > b.from ? 1 : a.emojiId < b.emojiId ? -1 : a.emojiId > b.emojiId ? 1 : 0);
     const grouped = new Map();
     for (const event of reactions.values())
         if (event.active) {
@@ -91,13 +100,14 @@ export function projectMessageTimeline(input) {
         if (isReadingControl(envelope.body, 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, 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) }; }) };
+            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);
         const sameReading = old?.reading === item.reading || old?.reading?.seq === item.reading?.seq && old?.reading?.read === item.reading?.read && old?.reading?.readPolicy === item.reading?.readPolicy;
         const sameReactions = old?.reactions.length === item.reactions.length && old.reactions.every((reaction, index) => { const next = item.reactions[index]; return reaction.emojiId === next.emojiId && reaction.mine === next.mine && reaction.userIds.length === next.userIds.length && reaction.userIds.every((user, i) => user === next.userIds[i]); });
-        result.push(old && old.message === item.message && old.timestamp === item.timestamp && old.from === item.from && old.mine === item.mine && old.status === item.status && old.recalled === item.recalled && sameReading && sameReactions ? old : item);
+        const sameEvents = old?.reactionEvents.length === item.reactionEvents.length && old.reactionEvents.every((event, index) => { const next = item.reactionEvents[index]; return event.id === next.id && event.from === next.from && event.emojiId === next.emojiId && event.active === next.active && event.revision === next.revision && event.timestamp === next.timestamp && event.threadId === next.threadId && event.messageId === next.messageId; });
+        result.push(old && sameEvents && old.message === item.message && old.timestamp === item.timestamp && old.from === item.from && old.mine === item.mine && old.status === item.status && old.recalled === item.recalled && sameReading && sameReactions ? old : item);
     }
     result.sort((a, b) => a.timestamp - b.timestamp || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
     return input.previous?.length === result.length && result.every((item, index) => item === input.previous[index]) ? input.previous : result;

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/package.json

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