@pmate/chat-sdk 0.12.0-next.28 → 0.12.0-next.29

package/lib/runtime/chatSession.d.ts

@@ -1,3 +1,4 @@
+import { type TimelineItem } from "./messageTimeline.js";
 import { type ReadingCandidate, type MessageReadingState } from "./conversationReading.js";
 import type { ConversationReadMessage } from "./conversationRead.js";
 import { type ReadCountsResult } from "./readCounts.js";
@@ -22,6 +23,7 @@ export type ChatSessionOptions<T extends StoredMessage> = {
 };
 export type ChatThreadSnapshot<T> = {
     messages: readonly T[];
+    timeline: readonly TimelineItem<T>[];
     outgoing: ReturnType<DurableChatSender["snapshot"]>;
     hasEarlier: boolean;
     resetVersion: number;
@@ -34,6 +36,7 @@ export type ChatSummarySnapshot<T> = {
     threads: readonly {
         threadId: string;
         lastMessage?: T;
+        lastItem?: TimelineItem<T>;
         unread: ChatThreadSnapshot<T>["unread"];
         outgoingCount: number;
     }[];
@@ -57,6 +60,8 @@ export declare class ChatSession<T extends StoredMessage> {
     private sender;
     private listeners;
     private snapshots;
+    private timelineDecoded;
+    private decodeTimeline;
     private historyEdges;
     private earlierReads;
     private off;
@@ -128,6 +133,7 @@ export declare class ChatSession<T extends StoredMessage> {
     private watchCounts;
     getSnapshot(): ChatSummarySnapshot<T>;
     getSnapshot(threadId: string): ChatThreadSnapshot<T>;
+    private buildThreadSnapshot;
     subscribe(listener: () => void): () => void;
     subscribe(threadId: string, listener: () => void, fields?: readonly (keyof ChatThreadSnapshot<T>)[]): () => void;
     private publishAll;

package/lib/runtime/chatSession.js

@@ -1,3 +1,4 @@
+import { projectMessageTimeline } from "./messageTimeline.js";
 import { projectConversationReading } from "./conversationReading.js";
 import { ReadCountsClient } from "./readCounts.js";
 import { WindowedTasks } from "./coalescer.js";
@@ -23,12 +24,15 @@ export class ChatSession {
     sender;
     listeners = new Map();
     snapshots = new Map();
+    timelineDecoded = new WeakMap();
+    decodeTimeline = (message) => { if (!this.timelineDecoded.has(message))
+        this.timelineDecoded.set(message, this.options.decode(message)); return this.timelineDecoded.get(message); };
     historyEdges = new Map();
     earlierReads = new Map();
     off = [];
     globalListeners = new Set();
     globalSnapshot;
-    closedThread = { messages: [], outgoing: [], hasEarlier: false, resetVersion: 0, complete: false, unread: undefined, messageReading: {} };
+    closedThread = { messages: [], timeline: [], outgoing: [], hasEarlier: false, resetVersion: 0, complete: false, unread: undefined, messageReading: {} };
     closedSummary = { threads: [], unreadMessageCount: undefined, badgeCount: undefined, connection: "closed" };
     connectionState = "closed";
     catchUp;
@@ -429,17 +433,26 @@ export class ChatSession {
         }
         let snapshot = this.snapshots.get(threadId);
         if (!snapshot) {
-            const messages = this.messages.getSnapshot(threadId);
-            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);
-            snapshot = { messages: messages?.messages ?? [], hasEarlier: messages?.hasEarlier ?? false, resetVersion: messages?.resetVersion ?? 0, complete: messages?.complete ?? false, outgoing: this.sender.snapshot(threadId), readCounts: this.countSnapshots.get(threadId), unread: view.unread, messageReading: view.messageReading };
+            snapshot = this.buildThreadSnapshot(threadId);
             this.snapshots.set(threadId, snapshot);
         }
         return snapshot;
     }
+    buildThreadSnapshot(threadId, previous) {
+        const messages = this.messages.getSnapshot(threadId);
+        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 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 };
+    }
     subscribe(target, listener, fields) {
         if (this.closed || this.withdrawn)
             return () => { };
@@ -488,7 +501,7 @@ export class ChatSession {
             ids.add(outgoing.threadId);
         const threads = [...ids].sort().map(threadId => {
             const snapshot = this.getSnapshot(threadId);
-            return { threadId, lastMessage: snapshot.messages.at(-1), unread: snapshot.unread, outgoingCount: snapshot.outgoing.length };
+            return { threadId, lastMessage: snapshot.timeline.at(-1)?.message, lastItem: snapshot.timeline.at(-1), unread: snapshot.unread, outgoingCount: snapshot.outgoing.length };
         });
         const state = this.getReadingSnapshot();
         const known = Boolean(state && state.syncCursor !== "0" && threads.every(thread => thread.unread !== undefined));
@@ -498,7 +511,11 @@ export class ChatSession {
         if (this.closed || this.withdrawn)
             return;
         const next = this.buildGlobal();
-        if (JSON.stringify(next) === JSON.stringify(this.globalSnapshot))
+        const previous = this.globalSnapshot;
+        if (previous && previous.connection === next.connection && previous.unreadMessageCount === next.unreadMessageCount && previous.badgeCount === next.badgeCount && previous.threads.length === next.threads.length && previous.threads.every((thread, index) => {
+            const other = next.threads[index];
+            return thread.threadId === other.threadId && thread.lastMessage === other.lastMessage && thread.lastItem === other.lastItem && thread.outgoingCount === other.outgoingCount && JSON.stringify(thread.unread) === JSON.stringify(other.unread);
+        }))
             return;
         this.globalSnapshot = next;
         this.globalListeners.forEach(listener => listener());
@@ -506,8 +523,9 @@ export class ChatSession {
     publish(threadId, notifyGlobal = true) {
         const previous = this.snapshots.get(threadId);
         this.snapshots.delete(threadId);
-        const next = this.getSnapshot(threadId);
-        if (previous && JSON.stringify(previous) === JSON.stringify(next)) {
+        const next = this.buildThreadSnapshot(threadId, previous);
+        this.snapshots.set(threadId, next);
+        if (previous && previous.messages === next.messages && previous.timeline === next.timeline && previous.outgoing.length === next.outgoing.length && previous.outgoing.every((record, index) => record === next.outgoing[index]) && previous.hasEarlier === next.hasEarlier && previous.resetVersion === next.resetVersion && previous.complete === next.complete && previous.readCounts === next.readCounts && JSON.stringify(previous.unread) === JSON.stringify(next.unread) && JSON.stringify(previous.messageReading) === JSON.stringify(next.messageReading)) {
             this.snapshots.set(threadId, previous);
             return;
         }
@@ -533,6 +551,7 @@ export class ChatSession {
         this.counts?.watch(undefined, []);
         this.countSnapshots.clear();
         this.snapshots.clear();
+        this.timelineDecoded = new WeakMap();
         this.historyEdges.clear();
         this.earlierReads.clear();
         this.globalSnapshot = undefined;
@@ -598,6 +617,7 @@ export class ChatSession {
                 this.globalListeners.clear();
                 this.readingListeners.clear();
                 this.snapshots.clear();
+                this.timelineDecoded = new WeakMap();
                 this.countSnapshots.clear();
                 this.historyEdges.clear();
                 this.earlierReads.clear();

package/lib/runtime/index.d.ts

@@ -31,3 +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";

package/lib/runtime/index.js

@@ -31,3 +31,4 @@ export * from "./messageReaders.js";
 export * from "./createChat.js";
 export * from "./conversationRead.js";
 export { projectConversationReading } from "./conversationReading.js";
+export { projectMessageTimeline } from "./messageTimeline.js";

package/lib/runtime/messageTimeline.d.ts

@@ -0,0 +1,33 @@
+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 TimelineReaction = {
+    emojiId: string;
+    userIds: string[];
+    mine: boolean;
+};
+export type TimelineItem<T> = {
+    id: string;
+    threadId: string;
+    timestamp: number;
+    from?: string;
+    mine: boolean;
+    status: "sending" | "sent" | "failed" | "read";
+    recalled: boolean;
+    message: T | undefined;
+    reading?: MessageReadingState;
+    reactions: readonly TimelineReaction[];
+};
+/** Derives one display stream without copying bodies or creating another cache.
+ * Outgoing rows retain their wire identity; indexed rows take precedence. */
+export declare function projectMessageTimeline<T extends StoredMessage>(input: {
+    appId: string;
+    profileId: string;
+    threadId: string;
+    messages: readonly T[];
+    outgoing: readonly OutgoingMessage[];
+    decode: (message: ChatRuntimeMessage) => T | undefined;
+    reading: Readonly<Record<string, MessageReadingState>>;
+    previous?: readonly TimelineItem<T>[];
+}): readonly TimelineItem<T>[];

package/lib/runtime/messageTimeline.js

@@ -0,0 +1,98 @@
+import { isReadingControl } from "./readingContent.js";
+function content(message, appId) {
+    const body = message.body;
+    return body?.kind === "message" && body.content?.appId === appId ? body : undefined;
+}
+function validReaction(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const event = value;
+    return [event.id, event.messageId, event.from, event.emojiId].every(field => typeof field === "string" && field.length > 0 && field.length <= 256) && typeof event.active === "boolean" && Number.isSafeInteger(event.revision) && event.revision >= 0 && Number.isFinite(event.timestamp);
+}
+/** Derives one display stream without copying bodies or creating another cache.
+ * Outgoing rows retain their wire identity; indexed rows take precedence. */
+export function projectMessageTimeline(input) {
+    const scoped = (message) => {
+        const value = message, body = value.body;
+        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 records = new Map();
+    for (const pending of input.outgoing) {
+        if (pending.threadId !== input.threadId || pending.confirmed)
+            continue;
+        const message = input.decode(pending.message);
+        if (message && scoped(message))
+            records.set(message.id, { message, status: pending.status });
+    }
+    for (const message of input.messages)
+        if (scoped(message))
+            records.set(message.id, { message, status: "sent" });
+    const recalled = new Map(), reactions = new Map();
+    const addReaction = (event) => {
+        const key = JSON.stringify([event.messageId, event.from, event.emojiId]), old = reactions.get(key);
+        if (!old || event.revision > old.revision || event.revision === old.revision && (event.timestamp > old.timestamp || event.timestamp === old.timestamp && event.id > old.id))
+            reactions.set(key, event);
+    };
+    for (const { message, status } of records.values()) {
+        if (status === "failed" && isReadingControl(message.body, input.appId))
+            continue;
+        const envelope = message, body = content(envelope, input.appId), target = 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());
+            recalled.get(target).add(envelope.from);
+        }
+        const reaction = body?.content?.reaction;
+        if (body?.contentKind === "text" && reaction?.version === 1 && typeof reaction.messageId === "string" && typeof reaction.emojiId === "string" && typeof reaction.active === "boolean" && typeof reaction.revision === "number" && reaction.revision >= 1 && envelope.from) {
+            const event = { id: message.id, messageId: reaction.messageId, from: envelope.from, emojiId: reaction.emojiId, active: reaction.active, revision: reaction.revision, timestamp: message.timestamp };
+            if (validReaction(event))
+                addReaction(event);
+        }
+        const events = envelope.reactionEvents ?? envelope.legacyDisplay?.reactionEvents;
+        if (Array.isArray(events))
+            for (const event of events)
+                if (validReaction(event) && event.messageId === message.id && (event.threadId === undefined || event.threadId === input.threadId))
+                    addReaction(event);
+        // Old display-only imports may have aggregates but no event IDs. Treat them
+        // as revision-zero baselines; any durable control supersedes them.
+        const baseline = envelope.legacyDisplay?.reactions;
+        if (Array.isArray(baseline))
+            for (const value of baseline) {
+                if (typeof value?.emojiId !== "string" || !Array.isArray(value.userIds))
+                    continue;
+                for (const from of value.userIds) {
+                    const event = { id: `legacy:${message.id}`, messageId: message.id, from, emojiId: value.emojiId, active: true, revision: 0, timestamp: 0 };
+                    if (validReaction(event))
+                        addReaction(event);
+                }
+            }
+    }
+    const grouped = new Map();
+    for (const event of reactions.values())
+        if (event.active) {
+            if (!grouped.has(event.messageId))
+                grouped.set(event.messageId, new Map());
+            const emojis = grouped.get(event.messageId);
+            if (!emojis.has(event.emojiId))
+                emojis.set(event.emojiId, new Set());
+            emojis.get(event.emojiId).add(event.from);
+        }
+    const previous = new Map(input.previous?.map(item => [item.id, item]) ?? []);
+    const result = [];
+    for (const { message, status } of records.values()) {
+        const envelope = message;
+        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 item = { id: message.id, threadId: message.threadId, timestamp: message.timestamp, from: envelope.from, mine, status: !mine && reading?.read ? "read" : 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) }; }) };
+        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);
+    }
+    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/package.json

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