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

package/lib/runtime/chatSession.d.ts

@@ -1,3 +1,4 @@
+import { type ReadingCandidate, type MessageReadingState } from "./conversationReading.js";
 import type { ConversationReadMessage } from "./conversationRead.js";
 import { type ReadCountsResult } from "./readCounts.js";
 import type { OnlineReachEvent } from "./reach.js";
@@ -16,6 +17,7 @@ export type ChatSessionOptions<T extends StoredMessage> = {
     activeThreadId?: string;
     reading: ReadingClientOptions;
     decode: (message: ChatRuntimeMessage) => T | undefined;
+    readingCandidate?: (message: T) => ReadingCandidate | undefined;
     onError: (error: unknown) => void;
 };
 export type ChatThreadSnapshot<T> = {
@@ -26,6 +28,7 @@ export type ChatThreadSnapshot<T> = {
     complete: boolean;
     readCounts?: ReadCountsResult;
     unread: ReturnType<typeof unreadInConversation> | undefined;
+    messageReading: Readonly<Record<string, MessageReadingState>>;
 };
 export type ChatSummarySnapshot<T> = {
     threads: readonly {

package/lib/runtime/chatSession.js

@@ -1,3 +1,4 @@
+import { projectConversationReading } from "./conversationReading.js";
 import { ReadCountsClient } from "./readCounts.js";
 import { WindowedTasks } from "./coalescer.js";
 import { MessageReadersClient } from "./messageReaders.js";
@@ -27,7 +28,7 @@ export class ChatSession {
     off = [];
     globalListeners = new Set();
     globalSnapshot;
-    closedThread = { messages: [], outgoing: [], hasEarlier: false, resetVersion: 0, complete: false, unread: undefined };
+    closedThread = { messages: [], outgoing: [], hasEarlier: false, resetVersion: 0, complete: false, unread: undefined, messageReading: {} };
     closedSummary = { threads: [], unreadMessageCount: undefined, badgeCount: undefined, connection: "closed" };
     connectionState = "closed";
     catchUp;
@@ -430,7 +431,11 @@ export class ChatSession {
         if (!snapshot) {
             const messages = this.messages.getSnapshot(threadId);
             const state = this.getReadingSnapshot();
-            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: state?.threads.some(thread => (thread.conversationId ?? thread.id) === threadId) ? unreadInConversation(state, threadId) : undefined };
+            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 };
             this.snapshots.set(threadId, snapshot);
         }
         return snapshot;

package/lib/runtime/conversationReading.d.ts

@@ -0,0 +1,28 @@
+import { unreadInConversation, type ReadIndexState } from "./readIndex.js";
+export type ReadingCandidate = {
+    id: string;
+    threadId: string;
+    from?: string;
+    mine?: boolean;
+    recalled?: boolean;
+    unread?: boolean;
+    attentionEligible?: boolean;
+    readPolicy?: "visible" | "explicit";
+};
+export type MessageReadingState = {
+    seq?: number;
+    read: boolean;
+    readPolicy: "visible" | "explicit";
+};
+export type ConversationReadingView = {
+    messageReading: Readonly<Record<string, MessageReadingState>>;
+    unread: ReturnType<typeof unreadInConversation> | undefined;
+    badgeCount: number | undefined;
+};
+/** One projection for indexed authority and observations awaiting indexing. A
+ * directory badge is optional compatibility metadata, never proof of coverage. */
+export declare function projectConversationReading(state: ReadIndexState | undefined, conversation: {
+    id: string;
+    kind: "dm" | "group";
+    badgeCount?: number;
+}, candidates?: readonly ReadingCandidate[]): ConversationReadingView;

package/lib/runtime/conversationReading.js

@@ -0,0 +1,43 @@
+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 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) };
+        }
+    const observed = new Map();
+    for (const intent of state?.observedReadIntents ?? [])
+        if (sourceIds.has(intent.threadId)) {
+            if (!observed.has(intent.messageId))
+                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;
+        const attention = conversation.kind === "dm" || message.attentionEligible === true;
+        const policy = message.readPolicy ?? "visible";
+        const acknowledged = observed.get(message.id)?.has(policy) === true;
+        if (!indexed.has(message.id) && acknowledged)
+            messageReading[message.id] = { read: true, readPolicy: policy };
+        if (!incoming)
+            continue;
+        if (acknowledged && attention)
+            observedBadges++;
+        if (indexed.has(message.id) || acknowledged || message.unread !== true)
+            continue;
+        pendingMessages++;
+        if (message.attentionEligible === true)
+            pendingMentions++;
+    }
+    const authoritative = sources.length && state ? unreadInConversation(state, conversation.id) : 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.js

@@ -1,3 +1,4 @@
+import { isReadingControl } from "./readingContent.js";
 import { ChatSession } from "./chatSession.js";
 import { SocialReadClient } from "./socialReadClient.js";
 import { chatTeamId } from "./teamScope.js";
@@ -21,6 +22,15 @@ export function createChat(options) {
         reading: { appId, profileId, sessionToken: token, hubHttpUrl: http, fetch: options.fetch, onError },
         connection: { appId, profileId, teamId, hubUrl: ws, clientInstanceId: options.clientInstanceId, fetchImpl: options.fetch,
             session: { token, identity: { accountId, app: appId, profileId } }, onNotification: options.onNotification, onReach: options.onReach },
+        readingCandidate: message => {
+            if (isReadingControl(message.body, appId))
+                return undefined;
+            const body = message.body;
+            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) };
+        },
         decode: message => decodeIncoming(message, { appId, profileId, teamId }), onError,
     });
 }

package/lib/runtime/index.d.ts

@@ -30,3 +30,4 @@ export * from "./chatSession.js";
 export * from "./messageReaders.js";
 export * from "./createChat.js";
 export * from "./conversationRead.js";
+export { projectConversationReading, type ReadingCandidate, type MessageReadingState, type ConversationReadingView } from "./conversationReading.js";

package/lib/runtime/index.js

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

package/lib/runtime/readIndex.js

@@ -1,4 +1,5 @@
 import { Dexie } from "dexie";
+import { isReadingControl } from "./readingContent.js";
 import { isValidChatTeamId } from "./thread.js";
 export class ReadSyncGap extends Error {
     cursor;
@@ -158,7 +159,7 @@ export function unreadInThread(state, threadId) {
     if (!thread)
         throw new Error("UNKNOWN_READ_THREAD");
     const explicit = new Set(thread.explicitReadMessageIds);
-    const messages = thread.messages.filter(message => !message.recalled && message.from !== state.profileId && message.recipients.includes(state.profileId)
+    const messages = thread.messages.filter(message => !message.recalled && !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;
@@ -278,7 +279,7 @@ export class IndexedDbReadIndex {
             return this.hydrate(current, this.key(appId, profileId));
         if (current) {
             if (this.migrateLegacy)
-                await this.persist(appId, profileId, undefined, current);
+                await this.persist(appId, profileId, undefined, current, true);
             return current;
         }
         if (!this.migrateLegacy || this.storageScope === undefined)
@@ -305,9 +306,11 @@ export class IndexedDbReadIndex {
     }
     /** Message bodies are immutable for local read observations: keep them out of
      * profile/cursor writes, and update only changed normalized rows on sync. */
-    async persist(appId, profileId, previous, next) {
-        if (previous && !this.normalizedStates.has(previous))
+    async persist(appId, profileId, previous, next, replaceLegacy = false) {
+        if (previous && !this.normalizedStates.has(previous)) {
             previous = undefined;
+            replaceLegacy = true;
+        }
         const owner = JSON.stringify(this.key(appId, profileId));
         const oldThreads = new Map(previous?.threads.map(thread => [thread.id, thread]) ?? []);
         const nextIds = new Set(next.threads.map(thread => thread.id));
@@ -352,6 +355,14 @@ export class IndexedDbReadIndex {
                 await this.positionRows.delete([owner, id]);
                 await this.messageRows.where("[owner+thread]").equals([owner, id]).delete();
             }
+        // A legacy document can replace the full profile after normalization. Its
+        // replacement is authoritative for the row set; discard unreachable bodies
+        // in the same transaction before installing the rebuilt normalized records.
+        if (replaceLegacy) {
+            await this.messageRows.where("owner").equals(owner).delete();
+            await this.threadRows.where("owner").equals(owner).delete();
+            await this.positionRows.where("owner").equals(owner).delete();
+        }
         // Bound each IndexedDB bulk request. A snapshot and its cursor still commit
         // atomically; bounding total snapshot transaction bytes is separate work.
         for (let offset = 0; offset < positionWrites.length; offset += 128)

package/lib/runtime/readingContent.d.ts

@@ -0,0 +1,2 @@
+/** Social control envelopes do not contribute to message unread counts. */
+export declare function isReadingControl(payload: unknown, appId: string): boolean;

package/lib/runtime/readingContent.js

@@ -0,0 +1,9 @@
+/** Social control envelopes do not contribute to message unread counts. */
+export function isReadingControl(payload, appId) {
+    if (!payload || typeof payload !== "object")
+        return false;
+    const value = payload;
+    if (value.body !== undefined)
+        return isReadingControl(value.body, appId);
+    return value.kind === "message" && value.content?.appId === appId && (value.content.reaction !== undefined || value.content.recall !== undefined);
+}

package/package.json

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