@pmate/chat-sdk 0.12.0-next.34 → 0.12.0-next.36

package/lib/runtime/chatSession.js

@@ -297,7 +297,9 @@ export class ChatSession {
                 }
                 if (restart)
                     continue;
-                return { messages: pages.reverse().flat(), hasEarlier: false, complete: true, resetVersion: version };
+                const result = { messages: pages.reverse().flat(), hasEarlier: false, complete: true, resetVersion: version };
+                await this.messages.expandWindow(threadId, result);
+                return result;
             }
             catch (error) {
                 this.assertOpen();
@@ -453,9 +455,9 @@ export class ChatSession {
         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]] : []; }));
+        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, candidates, decode: this.decodeTimeline, reading: semanticReading, previous: previous?.timeline });
         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 });
@@ -464,7 +466,7 @@ export class ChatSession {
         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 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 });
+        const timeline = messageReading === semanticReading ? semantics : projectMessageTimeline({ appId: this.options.messages.scope.appId, profileId: this.options.messages.scope.profileId, threadId, messages, outgoing, candidates, 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) {

package/lib/runtime/messageClient.d.ts

@@ -91,6 +91,8 @@ export declare class MessageClient<T extends StoredMessage> {
     private flushWrites;
     private runWrites;
     synchronize(thread: string): Promise<void>;
+    /** Keep an explicitly requested history range in the shared subscribed view. */
+    expandWindow(thread: string, page: MessageSnapshot<T>): Promise<void>;
     earlier(thread: string, before: {
         timestamp: number;
         id: string;

package/lib/runtime/messageClient.js

@@ -485,6 +485,18 @@ export class MessageClient {
         this.syncing.set(thread, task);
         return task;
     }
+    /** Keep an explicitly requested history range in the shared subscribed view. */
+    async expandWindow(thread, page) {
+        const first = page.messages[0];
+        if (!first || !page.complete)
+            return;
+        const old = this.windowEdges.get(thread);
+        if (!old || old.version !== page.resetVersion || first.timestamp < old.timestamp || first.timestamp === old.timestamp && first.id < old.id)
+            this.windowEdges.set(thread, { timestamp: first.timestamp, id: first.id, version: page.resetVersion });
+        const snapshot = await this.reload(thread);
+        if (snapshot.resetVersion !== page.resetVersion)
+            throw new Error("MESSAGE_PROJECTION_CHANGED");
+    }
     async earlier(thread, before, limit = 100, expand = false) {
         await this.ensureScope();
         if (this.scopeDenied)
@@ -500,12 +512,8 @@ export class MessageClient {
                 await this.synchronize(thread);
             }
             const page = await this.fillWindow(thread, limit, before);
-            if (expand && page.complete && page.messages.length) {
-                const first = page.messages[0], old = this.windowEdges.get(thread);
-                if (!old || old.version !== page.resetVersion || first.timestamp < old.timestamp || first.timestamp === old.timestamp && first.id < old.id)
-                    this.windowEdges.set(thread, { timestamp: first.timestamp, id: first.id, version: page.resetVersion });
-                await this.reload(thread);
-            }
+            if (expand)
+                await this.expandWindow(thread, page);
             return page;
         }
         catch (error) {

package/lib/runtime/messageControls.d.ts

@@ -0,0 +1,19 @@
+import type { StoredMessage, MessageScope } from "./messageStore.js";
+export type MessageControl = {
+    scope: string;
+    thread: string;
+    target: string;
+    kind: "recall" | "reaction";
+    actor: string;
+    emoji: string;
+    id: string;
+    timestamp: number;
+    revision: number;
+    active: boolean;
+};
+export type ControlKey = [string, string, string, string, string, string];
+export declare const controlKey: (event: MessageControl) => ControlKey;
+export declare function newerControl(old: MessageControl | undefined, next: MessageControl): MessageControl;
+/** Body-free proofs retained independently of the visible history window. */
+export declare function messageControls(message: StoredMessage, scope: MessageScope, key: string): MessageControl[];
+export declare function applyMessageControls<T extends StoredMessage>(messages: T[], controls: readonly MessageControl[]): T[];

package/lib/runtime/messageControls.js

@@ -0,0 +1,44 @@
+export const controlKey = (event) => [event.scope, event.thread, event.target, event.kind, event.actor, event.emoji];
+export function newerControl(old, next) {
+    return !old || next.revision > old.revision || next.revision === old.revision && (next.timestamp > old.timestamp || next.timestamp === old.timestamp && next.id > old.id) ? next : old;
+}
+const identifier = (value) => typeof value === "string" && value.length > 0 && value.length <= 256;
+/** Body-free proofs retained independently of the visible history window. */
+export function messageControls(message, scope, key) {
+    const row = message;
+    if (row.appId !== undefined && row.appId !== scope.appId || row.teamId !== undefined && row.teamId !== scope.teamId || !identifier(row.from))
+        return [];
+    const apps = row.body;
+    const app = apps?.content?.appId ?? apps?.payload?.appId;
+    if (app !== undefined && app !== scope.appId)
+        return [];
+    if (row.recalled || row.legacyDisplay?.recalled)
+        return [{ scope: key, thread: message.threadId, target: message.id, kind: "recall", actor: row.from, emoji: "", id: message.id, timestamp: message.timestamp, revision: 0, active: true }];
+    const body = row.body;
+    const content = body?.kind === "message" && body.content?.appId === scope.appId ? body.content : undefined;
+    const target = body?.kind === "recall" && row.appId === scope.appId ? body.targetMessageId : content?.recall?.messageId;
+    const base = { scope: key, thread: message.threadId, actor: row.from, id: message.id, timestamp: message.timestamp };
+    if (identifier(target))
+        return [{ ...base, target, kind: "recall", emoji: "", revision: 0, active: true }];
+    const reaction = content?.reaction;
+    if (body?.contentKind === "text" && reaction?.version === 1 && identifier(reaction.messageId) && identifier(reaction.emojiId) && Number.isSafeInteger(reaction.revision) && (reaction.revision ?? 0) >= 1 && typeof reaction.active === "boolean")
+        return [{ ...base, target: reaction.messageId, kind: "reaction", emoji: reaction.emojiId, revision: reaction.revision, active: reaction.active }];
+    return [];
+}
+export function applyMessageControls(messages, controls) {
+    const grouped = new Map();
+    for (const event of controls) {
+        const list = grouped.get(event.target) ?? [];
+        list.push(event);
+        grouped.set(event.target, list);
+    }
+    return messages.map(message => {
+        const facts = grouped.get(message.id);
+        if (!facts?.length)
+            return message;
+        const row = message;
+        const recalled = message.recalled || facts.some(event => event.kind === "recall" && event.actor === row.from);
+        const reactionEvents = facts.filter(event => event.kind === "reaction").map(event => ({ id: event.id, messageId: event.target, threadId: event.thread, from: event.actor, emojiId: event.emoji, active: event.active, revision: event.revision, timestamp: event.timestamp }));
+        return { ...message, ...(recalled ? { recalled: true } : {}), ...(reactionEvents.length ? { reactionEvents: [...(row.reactionEvents ?? []), ...reactionEvents] } : {}) };
+    });
+}

package/lib/runtime/messageStore.d.ts

@@ -33,12 +33,14 @@ export declare const messageScopeKey: (scope: MessageScope) => string;
 /** Normalized browser cache. Data and coverage advance together in each commit.
  * Merge runs inside the write transaction against the latest cross-tab state. */
 export declare class IndexedDbMessageStore<T extends StoredMessage> {
+    private scope;
     private merge;
     private db;
     private rows;
     private legacy;
     private coverage;
     private accessRows;
+    private controls;
     private key;
     constructor(scope: MessageScope, merge: (previous: T | undefined, incoming: T) => T, options?: {
         indexedDB?: IDBFactory;
@@ -69,6 +71,9 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
         authoritative?: boolean;
         scopeVersion?: number;
     }): Promise<number>;
+    private rememberControls;
+    private controlPage;
+    private finishPage;
     windows(): Promise<CoverageRow[]>;
     scopeAccess(): Promise<MessageScopeAccess>;
     private scopedCoverage;

package/lib/runtime/messageStore.js

@@ -1,22 +1,28 @@
 import { Dexie } from "dexie";
+import { messageControls, controlKey, newerControl, applyMessageControls } from "./messageControls.js";
 export const messageScopeKey = (scope) => JSON.stringify([scope.appId, scope.accountId, scope.profileId, scope.teamId]);
 /** Normalized browser cache. Data and coverage advance together in each commit.
  * Merge runs inside the write transaction against the latest cross-tab state. */
 export class IndexedDbMessageStore {
+    scope;
     merge;
     db;
     rows;
     legacy;
     coverage;
     accessRows;
+    controls;
     key;
     constructor(scope, merge, options = {}) {
+        this.scope = scope;
         this.merge = merge;
         this.key = messageScopeKey(scope);
         this.db = new Dexie(options.name ?? "pmate-chat-messages", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
         this.db.version(1).stores({ messages: "[scope+thread+id],[scope+thread+time+id],[scope+thread],scope", coverage: "[scope+thread],scope" });
         this.db.version(2).stores({ legacyMessages: "[scope+thread+id],[scope+thread+time+id],[scope+thread],scope" });
         this.db.version(3).stores({ scopeAccess: "scope" });
+        this.db.version(4).stores({ messageControls: "[scope+thread+target+kind+actor+emoji],[scope+thread+target],[scope+thread],scope" });
+        this.controls = this.db.table("messageControls");
         this.accessRows = this.db.table("scopeAccess");
         this.legacy = this.db.table("legacyMessages");
         this.rows = this.db.table("messages");
@@ -27,14 +33,15 @@ export class IndexedDbMessageStore {
     async read(thread, limit = 100, before) {
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
             throw new Error("INVALID_MESSAGE_LIMIT");
-        return this.db.transaction("r", this.rows, this.coverage, this.accessRows, async () => {
+        const page = await this.db.transaction("r", this.rows, this.coverage, this.accessRows, this.controls, async () => {
             const access = await this.scopeAccess();
             if (access.revoked)
                 return { messages: [], hasEarlier: false, coverage: { complete: false, revoked: true, resetVersion: 0, scopeVersion: access.version } };
             const range = this.rows.where("[scope+thread+time+id]").between([this.key, thread, Dexie.minKey, Dexie.minKey], [this.key, thread, before?.timestamp ?? Dexie.maxKey, before?.id ?? Dexie.maxKey], true, !before);
             const records = await range.reverse().limit(limit + 1).toArray();
-            return { messages: records.slice(0, limit).reverse().map(row => row.value), hasEarlier: records.length > limit, coverage: this.scopedCoverage(await this.coverage.get([this.key, thread]), access) };
+            return this.controlPage({ messages: records.slice(0, limit).reverse().map(row => row.value), hasEarlier: records.length > limit, coverage: this.scopedCoverage(await this.coverage.get([this.key, thread]), access) });
         });
+        return this.finishPage(thread, page);
     }
     /** Migration records never claim coverage or overwrite authoritative rows. */
     async importLegacy(thread, messages) {
@@ -48,13 +55,19 @@ export class IndexedDbMessageStore {
             if (bytes > 1_048_576)
                 throw new Error("MESSAGE_BATCH_TOO_LARGE");
         }
-        return this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        return this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             const coverage = await this.coverage.get([this.key, thread]);
             if (access.revoked || coverage?.revoked)
                 throw new Error("MESSAGE_ACCESS_REVOKED");
             if (access.version > 0)
                 throw new Error("MESSAGE_PROJECTION_CHANGED");
+            const proofs = messages.map(message => messageControls(message, this.scope, this.key));
+            const controlsOnly = messages.length > 0 && proofs.every((events, index) => events.length > 0 && !messages[index].recalled && !messages[index].legacyDisplay?.recalled);
+            if (controlsOnly) {
+                await this.rememberControls(proofs.flat());
+                return 0;
+            }
             if ((coverage?.resetVersion ?? 0) > 0)
                 throw new Error("MESSAGE_PROJECTION_CHANGED");
             const ids = [...new Set(messages.map(message => message.id))], keys = ids.map(id => [this.key, thread, id]);
@@ -71,6 +84,7 @@ export class IndexedDbMessageStore {
                 if (JSON.stringify(old) !== JSON.stringify(value))
                     changed.set(message.id, { scope: this.key, thread, id: value.id, time: value.timestamp, value });
             }
+            await this.rememberControls([...changed.values()].flatMap(row => messageControls(row.value, this.scope, this.key)));
             if (changed.size)
                 await this.legacy.bulkPut([...changed.values()]);
             return changed.size;
@@ -80,7 +94,7 @@ export class IndexedDbMessageStore {
     async readFallback(thread, limit = 100, before) {
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
             throw new Error("INVALID_MESSAGE_LIMIT");
-        return this.db.transaction("r", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        const page = await this.db.transaction("r", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             const coverage = access.revoked ? { complete: false, revoked: true, resetVersion: 0, scopeVersion: access.version } : this.scopedCoverage(await this.coverage.get([this.key, thread]), access);
             if (coverage?.revoked)
@@ -88,8 +102,9 @@ export class IndexedDbMessageStore {
             const read = (table) => table.where("[scope+thread+time+id]").between([this.key, thread, Dexie.minKey, Dexie.minKey], [this.key, thread, before?.timestamp ?? Dexie.maxKey, before?.id ?? Dexie.maxKey], true, !before).reverse().limit(limit + 1).toArray();
             const [canonical, legacy] = await Promise.all([read(this.rows), read(this.legacy)]);
             const rows = [...new Map([...legacy, ...canonical].map(row => [row.id, row])).values()].sort((a, b) => a.time - b.time || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-            return { messages: rows.slice(-limit).map(row => row.value), hasEarlier: rows.length > limit, coverage };
+            return this.controlPage({ messages: rows.slice(-limit).map(row => row.value), hasEarlier: rows.length > limit, coverage });
         });
+        return this.finishPage(thread, page);
     }
     async commit(thread, messages, coverage, guard) {
         for (const message of messages)
@@ -97,7 +112,7 @@ export class IndexedDbMessageStore {
                 throw new Error("MESSAGE_SCOPE_MISMATCH");
         if (messages.length > 1000)
             throw new Error("MESSAGE_BATCH_TOO_LARGE");
-        return this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        return this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             if ((guard?.scopeVersion ?? 0) !== access.version)
                 throw new Error("MESSAGE_SCOPE_CHANGED");
@@ -126,6 +141,7 @@ export class IndexedDbMessageStore {
                 if (!canonicalIds.has(message.id) || JSON.stringify(old) !== JSON.stringify(value))
                     changed.set(message.id, { scope: this.key, thread, id: value.id, time: value.timestamp, value });
             }
+            await this.rememberControls(messages.flatMap(message => messageControls(message, this.scope, this.key)));
             if (changed.size)
                 await this.rows.bulkPut([...changed.values()]);
             const replaced = legacy.flatMap(row => row ? [[this.key, thread, row.id]] : []);
@@ -139,6 +155,47 @@ export class IndexedDbMessageStore {
             return changed.size;
         });
     }
+    async rememberControls(events) {
+        const latest = new Map();
+        for (const event of events) {
+            const key = JSON.stringify(controlKey(event));
+            latest.set(key, newerControl(latest.get(key), event));
+        }
+        const values = [...latest.values()];
+        for (let offset = 0; offset < values.length; offset += 128) {
+            const batch = values.slice(offset, offset + 128), previous = await this.controls.bulkGet(batch.map(controlKey));
+            const changed = batch.filter((event, index) => newerControl(previous[index], event) !== previous[index]);
+            if (changed.length)
+                await this.controls.bulkPut(changed);
+        }
+    }
+    async controlPage(page) {
+        const events = page.messages.flatMap(message => messageControls(message, this.scope, this.key));
+        const old = events.length ? await this.controls.bulkGet(events.map(controlKey)) : [];
+        const pendingControls = events.filter((event, index) => newerControl(old[index], event) !== old[index]);
+        const facts = await this.controls.where("[scope+thread+target]").anyOf(page.messages.map(message => [this.key, message.threadId, message.id])).toArray();
+        const latest = new Map();
+        for (const event of [...facts, ...events]) {
+            const key = JSON.stringify(controlKey(event));
+            latest.set(key, newerControl(latest.get(key), event));
+        }
+        return { ...page, messages: applyMessageControls(page.messages, [...latest.values()]), pendingControls };
+    }
+    async finishPage(thread, page) {
+        const { pendingControls, ...result } = page;
+        // v3 caches migrate only source proofs from already-read pages, with no body
+        // rewrite. Steady reads remain a single read-only IndexedDB transaction.
+        if (pendingControls?.length)
+            await this.db.transaction("rw", this.controls, this.coverage, this.accessRows, async () => {
+                const access = await this.scopeAccess(), current = await this.coverage.get([this.key, thread]);
+                if (access.revoked || access.version !== (page.coverage?.scopeVersion ?? 0))
+                    throw new Error("MESSAGE_SCOPE_CHANGED");
+                if ((current?.resetVersion ?? 0) !== (page.coverage?.resetVersion ?? 0))
+                    throw new Error("MESSAGE_PROJECTION_CHANGED");
+                await this.rememberControls(pendingControls);
+            });
+        return result;
+    }
     async windows() {
         return this.db.transaction("r", this.coverage, this.accessRows, async () => {
             if ((await this.scopeAccess()).revoked)
@@ -156,6 +213,7 @@ export class IndexedDbMessageStore {
         return access.version ? { ...coverage, complete: coverage?.complete ?? false, scopeVersion: access.version } : coverage;
     }
     async clearScopeRows() {
+        await this.controls.where("scope").equals(this.key).delete();
         await this.rows.where("[scope+thread+id]").between([this.key, Dexie.minKey, Dexie.minKey], [this.key, Dexie.maxKey, Dexie.maxKey], true, true).delete();
         await this.legacy.where("[scope+thread+id]").between([this.key, Dexie.minKey, Dexie.minKey], [this.key, Dexie.maxKey, Dexie.maxKey], true, true).delete();
         await this.coverage.where("[scope+thread]").between([this.key, Dexie.minKey], [this.key, Dexie.maxKey], true, true).delete();
@@ -170,7 +228,7 @@ export class IndexedDbMessageStore {
             await this.accessRows.put(next);
             return next;
         });
-        await this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const current = await this.scopeAccess();
             if (current.version === access.version && current.revoked)
                 await this.clearScopeRows();
@@ -179,7 +237,7 @@ export class IndexedDbMessageStore {
     }
     /** A durable epoch prevents another tab's pre-reset request from restoring rows. */
     async resetThread(thread, revoked = false, scopeVersion = 0) {
-        return this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        return this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             if (access.version !== scopeVersion)
                 throw new Error("MESSAGE_SCOPE_CHANGED");
@@ -187,6 +245,8 @@ export class IndexedDbMessageStore {
                 throw new Error("MESSAGE_ACCESS_REVOKED");
             const old = await this.coverage.get([this.key, thread]);
             const resetVersion = (old?.resetVersion ?? 0) + 1;
+            if (revoked)
+                await this.controls.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.legacy.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.coverage.put({ scope: this.key, thread, complete: false, resetVersion, revoked });
@@ -194,14 +254,16 @@ export class IndexedDbMessageStore {
         });
     }
     async removeThread(thread) {
-        await this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+            await this.controls.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.legacy.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.coverage.delete([this.key, thread]);
         });
     }
     async clear() {
-        await this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+            await this.controls.where("scope").equals(this.key).delete();
             await this.legacy.where("scope").equals(this.key).delete();
             await this.rows.where("scope").equals(this.key).delete();
             await this.coverage.where("scope").equals(this.key).delete();

package/lib/runtime/messageTimeline.d.ts

@@ -1,7 +1,7 @@
 import type { StoredMessage } from "./messageStore.js";
 import type { OutgoingMessage } from "./durableSender.js";
 import type { ChatRuntimeMessage } from "./protocol.js";
-import type { MessageReadingState } from "./conversationReading.js";
+import type { MessageReadingState, ReadingCandidate } from "./conversationReading.js";
 export type TimelineReactionEvent = Reaction & {
     threadId: string;
 };
@@ -18,6 +18,8 @@ export type TimelineItem<T> = {
     mine: boolean;
     status: "sending" | "sent" | "failed" | "read";
     recalled: boolean;
+    unread?: boolean;
+    attentionEligible?: boolean;
     message: T | undefined;
     reading?: MessageReadingState;
     reactions: readonly TimelineReaction[];
@@ -42,6 +44,7 @@ export declare function projectMessageTimeline<T extends StoredMessage>(input: {
     outgoing: readonly OutgoingMessage[];
     decode: (message: ChatRuntimeMessage) => T | undefined;
     reading: Readonly<Record<string, MessageReadingState>>;
+    candidates?: ReadonlyMap<string, ReadingCandidate>;
     previous?: readonly TimelineItem<T>[];
 }): readonly TimelineItem<T>[];
 export {};

package/lib/runtime/messageTimeline.js

@@ -106,13 +106,14 @@ export function projectMessageTimeline(input) {
             continue;
         const mine = envelope.from === input.profileId, reading = input.reading[message.id];
         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,
+        const candidate = input.candidates?.get(message.id);
+        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, ...(candidate ? { unread: !mine && !withdrawn && (reading ? !reading.read : candidate.unread), attentionEligible: candidate.attentionEligible } : {}),
             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]); });
         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.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 && old.unread === item.unread && old.attentionEligible === item.attentionEligible && 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.34",
+  "version": "0.12.0-next.36",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",