@pmate/chat-sdk 0.12.0-next.17 → 0.12.0-next.19

package/lib/runtime/chatSession.d.ts

@@ -1,3 +1,4 @@
+import type { ConversationReadMessage } from "./conversationRead.js";
 import { type ReadCountsResult } from "./readCounts.js";
 import type { OnlineReachEvent } from "./reach.js";
 import { type MessageReadersQuery } from "./messageReaders.js";
@@ -70,10 +71,14 @@ export declare class ChatSession<T extends StoredMessage> {
     /** Initializes local state and background reading sync without opening a
      * second transport when the host already owns calls/presence. */
     initialize(): Promise<void>;
+    /** One-time migration only: never establishes trusted history coverage. */
+    importLegacyMessages(threadId: string, messages: T[]): Promise<void>;
     getReadingSnapshot(): import("./readIndex.js").ReadIndexState | undefined;
     subscribeReading(listener: () => void): () => void;
     refreshReading(): void;
     synchronizeReading(cursor?: string, profileId?: string): Promise<import("./readIndex.js").ReadIndexState>;
+    /** Explicit text-history acknowledgement; unheard audio stays unread. */
+    markRead(threadId: string, messages?: readonly ConversationReadMessage[]): Promise<import("./readIndex.js").ReadIndexState>;
     updateReading(transform: Parameters<ReadingClient["update"]>[0]): Promise<import("./readIndex.js").ReadIndexState>;
     private assertOpen;
     getMessages(threadId: string, options?: {

package/lib/runtime/chatSession.js

@@ -117,10 +117,14 @@ export class ChatSession {
             this.assertOpen();
         })().catch(error => { this.initializing = undefined; throw error; });
     }
+    /** One-time migration only: never establishes trusted history coverage. */
+    importLegacyMessages(threadId, messages) { this.assertOpen(); return this.messages.importLegacy(threadId, messages); }
     getReadingSnapshot() { return this.reading.getSnapshot(); }
     subscribeReading(listener) { this.assertOpen(); return this.reading.subscribe(listener); }
     refreshReading() { this.assertOpen(); this.reading.refresh(); }
     synchronizeReading(cursor, profileId) { this.assertOpen(); return this.reading.synchronize(cursor, profileId); }
+    /** Explicit text-history acknowledgement; unheard audio stays unread. */
+    markRead(threadId, messages = []) { this.assertOpen(); return this.reading.markRead(threadId, messages); }
     updateReading(transform) { this.assertOpen(); return this.reading.update(transform); }
     assertOpen() { if (this.closed)
         throw new Error("CHAT_SESSION_CLOSED"); }
@@ -194,6 +198,8 @@ export class ChatSession {
                         break;
                     }
                     pages.push(page.messages);
+                    if (!page.complete)
+                        return { messages: pages.reverse().flat(), hasEarlier: true, complete: false, resetVersion: version };
                 }
                 if (restart)
                     continue;

package/lib/runtime/conversationRead.d.ts

@@ -0,0 +1,13 @@
+import { type ReadIndexState } from "./readIndex.js";
+/** Optional observations whose index metadata may still be in flight. */
+export type ConversationReadMessage = {
+    id: string;
+    threadId: string;
+    mine?: boolean;
+    from?: string;
+    recalled?: boolean;
+    readPolicy?: "visible" | "explicit";
+    kind?: string;
+};
+/** Explicitly mark ordinary text history read; unheard audio stays unread. */
+export declare function recordConversationRead(state: ReadIndexState, conversationId: string, messages?: readonly ConversationReadMessage[], operationId?: () => `${string}-${string}-${string}-${string}-${string}`): ReadIndexState;

package/lib/runtime/conversationRead.js

@@ -0,0 +1,34 @@
+import { recordReadIntent, sourcesInConversation } from "./readIndex.js";
+/** Explicitly mark ordinary text history read; unheard audio stays unread. */
+export function recordConversationRead(state, conversationId, messages = [], operationId = () => crypto.randomUUID()) {
+    if (!conversationId)
+        throw new Error("INVALID_READING_THREAD");
+    const sources = sourcesInConversation(state, conversationId);
+    if (new Set(sources.map(source => source.teamId)).size > 1)
+        throw new Error("READ_CONVERSATION_TEAM_MISMATCH");
+    let next = state;
+    const indexedIds = new Set();
+    for (const source of sources) {
+        const incoming = source.messages.filter(message => {
+            indexedIds.add(message.id);
+            return !message.recalled && message.from !== state.profileId && message.recipients.includes(state.profileId);
+        });
+        const latest = incoming.filter(message => message.readPolicy === "visible" && message.seq > source.readThroughSeq)
+            .reduce((last, message) => !last || message.seq > last.seq ? message : last, undefined);
+        if (latest)
+            next = recordReadIntent(next, { operationId: operationId(), threadId: source.id, messageId: latest.id, readPolicy: "visible" });
+    }
+    // Live/history messages can precede their read-index metadata. Persist their
+    // observations so leaving the page or reloading cannot resurrect the badge.
+    const observed = new Set(next.observedReadIntents?.filter(intent => intent.threadId === conversationId).map(intent => intent.messageId));
+    for (const message of messages) {
+        if (message.threadId !== conversationId || message.mine || message.from === state.profileId || message.recalled || indexedIds.has(message.id) || observed.has(message.id))
+            continue;
+        const readPolicy = message.readPolicy ?? (message.kind === "voice" ? "explicit" : "visible");
+        if (message.kind === "voice" || readPolicy === "explicit")
+            continue;
+        next = recordReadIntent(next, { operationId: operationId(), threadId: conversationId, messageId: message.id, readPolicy });
+        observed.add(message.id);
+    }
+    return next;
+}

package/lib/runtime/index.d.ts

@@ -29,3 +29,4 @@ export * from "./durableSender.js";
 export * from "./chatSession.js";
 export * from "./messageReaders.js";
 export * from "./createChat.js";
+export * from "./conversationRead.js";

package/lib/runtime/index.js

@@ -29,3 +29,4 @@ export * from "./durableSender.js";
 export * from "./chatSession.js";
 export * from "./messageReaders.js";
 export * from "./createChat.js";
+export * from "./conversationRead.js";

package/lib/runtime/messageClient.d.ts

@@ -54,6 +54,7 @@ export declare class MessageClient<T extends StoredMessage> {
     private queueBytes;
     private pendingBytes;
     private pendingRecords;
+    private legacyImports;
     constructor(options: MessageClientOptions<T>);
     getSnapshot(thread: string): MessageSnapshot<T> | undefined;
     subscribe(thread: string, listener: () => void): () => void;
@@ -63,6 +64,9 @@ export declare class MessageClient<T extends StoredMessage> {
     read(thread: string, limit?: number, refresh?: boolean): Promise<MessageSnapshot<T>>;
     /** Application connection/wake events invalidate, rather than fetching directly. */
     invalidate(thread: string): void;
+    private fallback;
+    /** Migration batches remain separate from authoritative message coverage. */
+    importLegacy(thread: string, messages: T[]): Promise<void>;
     private reload;
     /** Events are visible only after their atomic batch commits. */
     receive(thread: string, messages: T[]): Promise<void>;
@@ -75,12 +79,7 @@ export declare class MessageClient<T extends StoredMessage> {
     earlier(thread: string, before: {
         timestamp: number;
         id: string;
-    }, limit?: number): Promise<{
-        messages: T[];
-        hasEarlier: boolean;
-        resetVersion: number;
-        complete: boolean;
-    }>;
+    }, limit?: number): Promise<MessageSnapshot<T>>;
     private fillWindow;
     private denyView;
     revoke(thread: string): Promise<void>;

package/lib/runtime/messageClient.js

@@ -23,6 +23,7 @@ export class MessageClient {
     queueBytes;
     pendingBytes = 0;
     pendingRecords = 0;
+    legacyImports = 0;
     constructor(options) {
         this.options = options;
         this.storage = options.storage ?? new IndexedDbMessageStore(options.scope, options.merge ?? mergeStoredMessage);
@@ -53,6 +54,11 @@ export class MessageClient {
                         options.onError?.(Object.assign(new Error("MESSAGE_ACCESS_REVOKED"), { status: 403 }), denied.thread);
                     })();
                 }
+                else if (event.data?.type === "legacy" && typeof event.data.thread === "string" && this.watches.has(event.data.thread)) {
+                    const thread = event.data.thread;
+                    void this.storage.read(thread, 1).then(page => this.reload(thread, !page.coverage?.complete)).catch(error => { if (!this.closed)
+                        options.onError?.(error, thread); });
+                }
                 else if (typeof event.data === "string" && this.watches.has(event.data))
                     void this.reload(event.data).catch(error => { if (!this.closed)
                         options.onError?.(error, event.data); });
@@ -98,8 +104,11 @@ export class MessageClient {
             const local = await this.storage.read(thread, limit);
             if (refresh || !local.coverage?.complete || local.coverage.revoked || this.revoked.has(thread)) {
                 if (typeof navigator !== "undefined" && navigator.onLine === false) {
-                    if (!refresh && local.messages.length && !local.coverage?.revoked)
-                        return this.reload(thread);
+                    if (!refresh && !local.coverage?.revoked) {
+                        const fallback = await this.fallback(thread, limit);
+                        if (fallback.messages.length)
+                            return fallback;
+                    }
                     throw new Error("MESSAGE_OFFLINE_UNAVAILABLE");
                 }
                 this.revoked.delete(thread);
@@ -107,10 +116,13 @@ export class MessageClient {
                     await this.synchronize(thread);
                 }
                 catch (error) {
-                    if (refresh || !local.messages.length || [401, 403].includes(error?.status ?? 0))
+                    if (refresh || [401, 403].includes(error?.status ?? 0))
+                        throw error;
+                    const fallback = await this.fallback(thread, limit);
+                    if (!fallback.messages.length)
                         throw error;
                     this.options.onError?.(error, thread);
-                    return this.reload(thread);
+                    return fallback;
                 }
             }
             if (this.closed)
@@ -122,12 +134,11 @@ export class MessageClient {
             catch (error) {
                 if ([401, 403].includes(error?.status ?? 0))
                     throw error;
-                const cached = await this.storage.read(thread, limit);
+                const cached = await this.fallback(thread, limit);
                 if (!cached.messages.length)
                     throw error;
                 this.options.onError?.(error, thread);
-                await this.reload(thread);
-                return { messages: cached.messages, hasEarlier: true, complete: false, resetVersion: cached.coverage?.resetVersion ?? 0 };
+                return cached;
             }
             const snapshot = await this.reload(thread);
             if (local.coverage?.complete && Date.now() - (local.coverage.syncedAt ?? 0) > (this.options.freshnessMs ?? 30_000)
@@ -144,9 +155,45 @@ export class MessageClient {
         if (!this.closed && !this.closing && !this.revoked.has(thread))
             this.syncTasks.schedule(thread, () => this.synchronize(thread));
     }
-    async reload(thread) {
+    async fallback(thread, limit, before) {
+        const page = await this.storage.readFallback(thread, limit, before);
+        if (!before && page.messages.length)
+            await this.reload(thread, true);
+        return { messages: page.messages, hasEarlier: true, complete: false, resetVersion: page.coverage?.resetVersion ?? 0 };
+    }
+    /** Migration batches remain separate from authoritative message coverage. */
+    importLegacy(thread, messages) {
+        if (this.closed || this.closing)
+            return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
+        if (messages.length > 128)
+            return Promise.reject(new Error("MESSAGE_BATCH_TOO_LARGE"));
+        if (this.legacyImports >= 4)
+            return Promise.reject(new Error("MESSAGE_STORAGE_BACKPRESSURE"));
+        let records;
+        try {
+            let bytes = 0;
+            for (const message of messages) {
+                bytes += this.messageBytes(message);
+                if (bytes > Math.min(this.transactionBytes, 1_048_576))
+                    throw new Error("MESSAGE_BATCH_TOO_LARGE");
+            }
+            records = structuredClone(messages);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        this.legacyImports++;
+        const task = this.storage.importLegacy(thread, records).then(async () => {
+            const page = await this.storage.read(thread, 1);
+            await this.reload(thread, !page.coverage?.complete);
+            this.channel?.postMessage({ type: "legacy", thread });
+        }).finally(() => { this.legacyImports--; this.activeWrites.delete(task); });
+        this.activeWrites.add(task);
+        return task;
+    }
+    async reload(thread, fallback = false) {
         const limit = 100;
-        const page = await this.storage.read(thread, limit);
+        const page = await (fallback ? this.storage.readFallback(thread, limit) : this.storage.read(thread, limit));
         if (this.closed)
             throw new Error("MESSAGE_CLIENT_CLOSED");
         if (this.revoked.has(thread)) {
@@ -160,7 +207,7 @@ export class MessageClient {
             return old && JSON.stringify(old) === JSON.stringify(message) ? old : message;
         });
         const old = watch?.snapshot;
-        const resetVersion = Math.max(page.coverage?.resetVersion ?? 0, this.revoked.has(thread) ? watch?.snapshot.resetVersion ?? 0 : 0), complete = !this.revoked.has(thread) && (page.coverage?.complete ?? false);
+        const resetVersion = Math.max(page.coverage?.resetVersion ?? 0, this.revoked.has(thread) ? watch?.snapshot.resetVersion ?? 0 : 0), complete = !fallback && !this.revoked.has(thread) && (page.coverage?.complete ?? false);
         const hasEarlier = !this.revoked.has(thread) && (page.hasEarlier || Boolean(page.coverage?.nextBefore));
         if (old && old.resetVersion === resetVersion && old.complete === complete && old.hasEarlier === hasEarlier && old.messages.length === messages.length && old.messages.every((message, index) => message === messages[index]))
             return old;
@@ -340,9 +387,23 @@ export class MessageClient {
             throw new Error("MESSAGE_CLIENT_CLOSED");
         if (this.revoked.has(thread))
             throw new Error("MESSAGE_ACCESS_REVOKED");
-        if (!(await this.storage.read(thread, 1)).coverage?.complete)
-            await this.synchronize(thread);
-        return this.fillWindow(thread, limit, before);
+        try {
+            if (!(await this.storage.read(thread, 1)).coverage?.complete) {
+                if (typeof navigator !== "undefined" && navigator.onLine === false)
+                    throw new Error("MESSAGE_OFFLINE_UNAVAILABLE");
+                await this.synchronize(thread);
+            }
+            return await this.fillWindow(thread, limit, before);
+        }
+        catch (error) {
+            if ([401, 403].includes(error?.status ?? 0))
+                throw error;
+            const fallback = await this.fallback(thread, limit, before);
+            if (!fallback.messages.length)
+                throw error;
+            this.options.onError?.(error, thread);
+            return fallback;
+        }
     }
     async fillWindow(thread, limit, before) {
         let page = await this.storage.read(thread, limit, before);

package/lib/runtime/messageStore.d.ts

@@ -30,6 +30,7 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
     private merge;
     private db;
     private rows;
+    private legacy;
     private coverage;
     private key;
     constructor(scope: MessageScope, merge: (previous: T | undefined, incoming: T) => T, options?: {
@@ -45,6 +46,17 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
         hasEarlier: boolean;
         coverage: CoverageRow | undefined;
     }>;
+    /** Migration records never claim coverage or overwrite authoritative rows. */
+    importLegacy(thread: string, messages: T[]): Promise<number>;
+    /** Bounded fallback only; callers must report an incomplete window. */
+    readFallback(thread: string, limit?: number, before?: {
+        timestamp: number;
+        id: string;
+    }): Promise<{
+        messages: T[];
+        hasEarlier: boolean;
+        coverage: CoverageRow | undefined;
+    }>;
     commit(thread: string, messages: T[], coverage?: MessageCoverage, guard?: {
         version: number;
         authoritative?: boolean;

package/lib/runtime/messageStore.js

@@ -6,6 +6,7 @@ export class IndexedDbMessageStore {
     merge;
     db;
     rows;
+    legacy;
     coverage;
     key;
     constructor(scope, merge, options = {}) {
@@ -13,6 +14,8 @@ export class IndexedDbMessageStore {
         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.legacy = this.db.table("legacyMessages");
         this.rows = this.db.table("messages");
         this.coverage = this.db.table("coverage");
         this.db.on("versionchange", () => { this.db.close({ disableAutoOpen: false }); return false; });
@@ -27,32 +30,87 @@ export class IndexedDbMessageStore {
             return { messages: records.slice(0, limit).reverse().map(row => row.value), hasEarlier: records.length > limit, coverage: await this.coverage.get([this.key, thread]) };
         });
     }
+    /** Migration records never claim coverage or overwrite authoritative rows. */
+    async importLegacy(thread, messages) {
+        if (messages.length > 128)
+            throw new Error("MESSAGE_BATCH_TOO_LARGE");
+        let bytes = 0;
+        for (const message of messages) {
+            if (message.threadId !== thread || !message.id || !Number.isFinite(message.timestamp))
+                throw new Error("MESSAGE_SCOPE_MISMATCH");
+            bytes += new TextEncoder().encode(JSON.stringify(message)).byteLength;
+            if (bytes > 1_048_576)
+                throw new Error("MESSAGE_BATCH_TOO_LARGE");
+        }
+        return this.db.transaction("rw", this.rows, this.legacy, this.coverage, async () => {
+            const coverage = await this.coverage.get([this.key, thread]);
+            if (coverage?.revoked)
+                throw new Error("MESSAGE_ACCESS_REVOKED");
+            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]);
+            const authoritative = await this.rows.bulkGet(keys), previous = await this.legacy.bulkGet(keys);
+            const known = new Set(authoritative.flatMap(row => row ? [row.id] : []));
+            const latest = new Map(previous.flatMap(row => row ? [[row.id, row.value]] : [])), changed = new Map();
+            for (const message of messages) {
+                if (known.has(message.id))
+                    continue;
+                const old = latest.get(message.id), value = this.merge(old, message);
+                if (value.id !== message.id || value.threadId !== thread || !Number.isFinite(value.timestamp))
+                    throw new Error("MESSAGE_SCOPE_MISMATCH");
+                latest.set(message.id, value);
+                if (JSON.stringify(old) !== JSON.stringify(value))
+                    changed.set(message.id, { scope: this.key, thread, id: value.id, time: value.timestamp, value });
+            }
+            if (changed.size)
+                await this.legacy.bulkPut([...changed.values()]);
+            return changed.size;
+        });
+    }
+    /** Bounded fallback only; callers must report an incomplete window. */
+    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, async () => {
+            const coverage = await this.coverage.get([this.key, thread]);
+            if (coverage?.revoked)
+                return { messages: [], hasEarlier: false, coverage };
+            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 };
+        });
+    }
     async commit(thread, messages, coverage, guard) {
         for (const message of messages)
             if (message.threadId !== thread || !message.id || !Number.isFinite(message.timestamp))
                 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.coverage, async () => {
+        return this.db.transaction("rw", this.rows, this.legacy, this.coverage, async () => {
             const current = await this.coverage.get([this.key, thread]);
             if (guard && (current?.resetVersion ?? 0) !== guard.version)
                 throw new Error("MESSAGE_PROJECTION_CHANGED");
             if (guard && current?.revoked && !guard.authoritative)
                 throw new Error("MESSAGE_ACCESS_REVOKED");
             const ids = [...new Set(messages.map(message => message.id))];
-            const previous = await this.rows.bulkGet(ids.map(id => [this.key, thread, id]));
-            const latest = new Map(previous.flatMap(row => row ? [[row.id, row.value]] : []));
+            const keys = ids.map(id => [this.key, thread, id]);
+            const previous = await this.rows.bulkGet(keys), legacy = await this.legacy.bulkGet(keys);
+            const canonicalIds = new Set(previous.flatMap(row => row ? [row.id] : []));
+            const latest = new Map([...legacy, ...previous].flatMap(row => row ? [[row.id, row.value]] : []));
             const changed = new Map();
             for (const message of messages) {
                 const old = latest.get(message.id), value = this.merge(old, message);
                 if (value.id !== message.id || value.threadId !== thread || !Number.isFinite(value.timestamp))
                     throw new Error("MESSAGE_SCOPE_MISMATCH");
                 latest.set(message.id, value);
-                if (JSON.stringify(old) !== JSON.stringify(value))
+                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 });
             }
             if (changed.size)
                 await this.rows.bulkPut([...changed.values()]);
+            if (ids.length)
+                await this.legacy.bulkDelete(ids.map(id => [this.key, thread, id]));
             if (coverage) {
                 const old = await this.coverage.get([this.key, thread]), next = { ...old, ...coverage, scope: this.key, thread };
                 if (JSON.stringify(old) !== JSON.stringify(next))
@@ -66,22 +124,25 @@ export class IndexedDbMessageStore {
     }
     /** A durable epoch prevents another tab's pre-reset request from restoring rows. */
     async resetThread(thread, revoked = false) {
-        return this.db.transaction("rw", this.rows, this.coverage, async () => {
+        return this.db.transaction("rw", this.rows, this.legacy, this.coverage, async () => {
             const old = await this.coverage.get([this.key, thread]);
             const resetVersion = (old?.resetVersion ?? 0) + 1;
             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 });
             return resetVersion;
         });
     }
     async removeThread(thread) {
-        await this.db.transaction("rw", this.rows, this.coverage, async () => {
+        await this.db.transaction("rw", this.rows, this.legacy, this.coverage, async () => {
             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.coverage, async () => {
+        await this.db.transaction("rw", this.rows, this.legacy, this.coverage, async () => {
+            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/readingClient.d.ts

@@ -1,3 +1,4 @@
+import { type ConversationReadMessage } from "./conversationRead.js";
 import { type ReadIndexPersistence, type ReadIndexState } from "./readIndex.js";
 export type ReadingClientOptions = {
     appId: string;
@@ -35,6 +36,7 @@ export declare class ReadingClient {
     refresh: () => void;
     synchronize(targetCursor?: string, profileId?: string): Promise<ReadIndexState>;
     update(transform: (state: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
+    markRead(threadId: string, messages?: readonly ConversationReadMessage[]): Promise<ReadIndexState>;
     recordVisible(threadId: string, messageIds: string[]): Promise<ReadIndexState>;
     recordExplicit(threadId: string, messageIds: string[]): Promise<ReadIndexState>;
     private record;

package/lib/runtime/readingClient.js

@@ -1,3 +1,4 @@
+import { recordConversationRead } from "./conversationRead.js";
 import { BatchedReadIndex } from "./batchedReadIndex.js";
 import { WindowedTasks } from "./coalescer.js";
 import { IndexedDbReadIndex, recordReadIntent } from "./readIndex.js";
@@ -95,6 +96,9 @@ export class ReadingClient {
         }
         return next;
     }
+    markRead(threadId, messages = []) {
+        return this.update(state => recordConversationRead(state, threadId, messages));
+    }
     recordVisible(threadId, messageIds) { return this.record(threadId, messageIds, "visible"); }
     recordExplicit(threadId, messageIds) { return this.record(threadId, messageIds, "explicit"); }
     record(threadId, ids, readPolicy) {

package/package.json

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