@pmate/chat-sdk 0.12.0-next.2 → 0.12.0-next.4

package/README.md

@@ -137,6 +137,40 @@ sends and reading synchronization independently. The runtime now provides local
 IndexedDB storage and fixed-window scheduling primitives so those operations can
 share bounded I/O, durable confirmation and scoped subscriptions.
 
+The browser entry point is `createChat` from `@pmate/chat-sdk/runtime`:
+
+```ts
+const chat = createChat({ appId, accountId, profileId, teamId, token, onError })
+await chat.start()
+const page = await chat.getMessages(threadId, { limit: 50 })
+const off = chat.subscribe(threadId, () => render(chat.getSnapshot(threadId)))
+const offSummary = chat.subscribe(() => renderSummary(chat.getSnapshot()))
+await chat.observeMessages(threadId, visibleIds, "visible")
+// Report only the actual audio `playing` event.
+await chat.observeMessages(threadId, [voiceId], "played")
+await chat.sendMessage(threadId, { to, body, recipients })
+const readers = await chat.getReaders(threadId, messageId)
+off(); offSummary()
+await chat.close()
+```
+
+The facade owns all clients below. Message reads transparently restore IndexedDB
+windows and fetch missing ranges through the authenticated Hub. Its normalized
+messages retain the protocol body; product rendering remains with the host.
+`sendMessage` resolves after local persistence, while `outgoing` in the thread
+snapshot reports transport progress and failure. Retry uses the original message
+hash. The subscribed recent window remains 100 records regardless of individual
+query limits; history requests return their own pages and do not replace it.
+Global snapshots contain thread summaries and totals, not complete message arrays.
+Voice visibility never acknowledges playback, including observations that arrive
+before metadata. Create a new instance and close the previous owner when the
+account or active Team changes.
+
+This facade is still under integration. Reader details currently require network
+access, global summaries do not yet replace the host's contact/thread metadata,
+and Merry's message-list/send migration and production validation are unfinished.
+The lower-level primitives remain available for custom transports:
+
 `MessageClient` reads a trusted recent window locally, coalesces concurrent misses,
 subscribes per conversation, and accepts incremental event batches. Its transport
 supplies authoritative `load`, `changes` and `older` pages. `nextBefore` tracks
@@ -165,7 +199,7 @@ when the connection returns. Call `confirm(hashes)` only after authoritative
 messages have been durably merged. Confirmation tombstones prevent another tab's
 late transport failure from recreating an outgoing message.
 
-These APIs are runtime primitives; applications must initialize them with the
-same authenticated scope, dispose them on identity changes, and wire their
-transport to an authorized server. The Merry migration and production validation
+Custom primitive integrations must initialize them with the same authenticated
+scope, dispose them on identity changes, and wire their transport to an authorized
+server. Standard browser integrations should use the facade instead. The Merry migration and production validation
 are tracked in the unified message layer proposal.

package/lib/runtime/chatClient.d.ts

@@ -56,6 +56,13 @@ export declare class ChatClient {
     private initialize;
     close(): void;
     connectionState(): ChatConnectionState;
+    /** Non-secret identity used to validate a shared browser transport. */
+    identityScope(): {
+        appId: string;
+        profileId: string | undefined;
+        accountId: string | undefined;
+        teamId: string | undefined;
+    };
     watchConnection(handler: (state: ChatConnectionState) => void): () => void;
     private setConnection;
     private rejectPending;

package/lib/runtime/chatClient.js

@@ -120,6 +120,11 @@ export class ChatClient {
         this.rejectPending(new Error("ChatClient closed"));
     }
     connectionState() { return this.connection; }
+    /** Non-secret identity used to validate a shared browser transport. */
+    identityScope() {
+        const identity = this.session?.identity ?? this.session?.session?.identity;
+        return { appId: this.options.appId, profileId: this.profileIdValue ?? this.options.profileId, accountId: identity?.accountId, teamId: this.options.teamId };
+    }
     watchConnection(handler) {
         this.connectionHandlers.add(handler);
         handler(this.connection);
@@ -423,10 +428,11 @@ export class ChatClient {
         return profileId;
     }
     profileId() {
-        if (!this.profileIdValue) {
+        const profileId = this.profileIdValue ?? this.options.profileId;
+        if (!profileId) {
             throw new Error("ChatClient is missing profile id; call connect() first");
         }
-        return this.profileIdValue;
+        return profileId;
     }
     async fetchProfiles(appId, accountId, token) {
         const fetcher = this.options.fetchImpl ?? fetch;

package/lib/runtime/chatSession.d.ts

@@ -2,13 +2,14 @@ import { type MessageReadersQuery } from "./messageReaders.js";
 import { type MessageClientOptions } from "./messageClient.js";
 import { DurableChatSender } from "./durableSender.js";
 import { type ReadingClientOptions } from "./readingClient.js";
-import { type ChatClientOptions } from "./chatClient.js";
+import { ChatClient, type ChatClientOptions, type ChatConnectionState } from "./chatClient.js";
 import { unreadInConversation } from "./readIndex.js";
 import type { StoredMessage } from "./messageStore.js";
 import type { ChatBody, ChatRuntimeMessage } from "./protocol.js";
 export type ChatSessionOptions<T extends StoredMessage> = {
     messages: MessageClientOptions<T>;
     connection: ChatClientOptions;
+    sharedConnection?: ChatClient;
     reading: ReadingClientOptions;
     decode: (message: ChatRuntimeMessage) => T | undefined;
     onError: (error: unknown) => void;
@@ -19,6 +20,17 @@ export type ChatThreadSnapshot<T> = {
     hasEarlier: boolean;
     unread: ReturnType<typeof unreadInConversation>;
 };
+export type ChatSummarySnapshot<T> = {
+    threads: readonly {
+        threadId: string;
+        lastMessage?: T;
+        unread: ChatThreadSnapshot<T>["unread"];
+        outgoingCount: number;
+    }[];
+    unreadMessageCount: number;
+    badgeCount: number;
+    connection: ChatConnectionState;
+};
 /** Owns all browser message clients. Hosts subscribe to stable thread snapshots. */
 export declare class ChatSession<T extends StoredMessage> {
     private options;
@@ -30,6 +42,9 @@ export declare class ChatSession<T extends StoredMessage> {
     private listeners;
     private snapshots;
     private off;
+    private globalListeners;
+    private globalSnapshot?;
+    private connectionState;
     private closed;
     private starting?;
     private closing?;
@@ -51,9 +66,13 @@ export declare class ChatSession<T extends StoredMessage> {
     getReaders(threadId: string, messageId: string, page?: Omit<MessageReadersQuery, "threadId" | "messageId">, signal?: AbortSignal): Promise<import("./messageReaders.js").MessageReadersPage>;
     retryMessage(messageId: string): Promise<ChatRuntimeMessage>;
     observeMessages(threadId: string, ids: string[], event: "visible" | "played"): Promise<import("./readIndex.js").ReadIndexState>;
+    getSnapshot(): ChatSummarySnapshot<T>;
     getSnapshot(threadId: string): ChatThreadSnapshot<T>;
+    subscribe(listener: () => void): () => void;
     subscribe(threadId: string, listener: () => void): () => void;
     private publishAll;
+    private buildGlobal;
+    private publishGlobal;
     private publish;
     close(): Promise<void>;
 }

package/lib/runtime/chatSession.js

@@ -15,6 +15,9 @@ export class ChatSession {
     listeners = new Map();
     snapshots = new Map();
     off = [];
+    globalListeners = new Set();
+    globalSnapshot;
+    connectionState = "closed";
     closed = false;
     starting;
     closing;
@@ -23,9 +26,14 @@ export class ChatSession {
         const scope = options.messages.scope;
         if (options.connection.appId !== scope.appId || options.reading.appId !== scope.appId || options.reading.profileId !== scope.profileId || options.connection.profileId !== scope.profileId || options.connection.teamId !== scope.teamId)
             throw new Error("CHAT_SESSION_SCOPE_MISMATCH");
+        if (options.sharedConnection) {
+            const shared = options.sharedConnection.identityScope();
+            if (shared.appId !== scope.appId || shared.profileId !== scope.profileId || (shared.accountId !== undefined && shared.accountId !== scope.accountId) || (shared.teamId !== undefined && shared.teamId !== scope.teamId))
+                throw new Error("CHAT_SESSION_SCOPE_MISMATCH");
+        }
         this.messages = new MessageClient(options.messages);
-        this.connection = new ChatClient(options.connection);
-        this.reading = new ReadingClient(options.reading);
+        this.connection = options.sharedConnection ?? new ChatClient(options.connection);
+        this.reading = new ReadingClient({ ...options.reading, storageScope: JSON.stringify([scope.accountId, scope.teamId]) });
         this.readers = new MessageReadersClient({ appId: scope.appId, profileId: scope.profileId, token: options.reading.sessionToken, hubHttpUrl: options.reading.hubHttpUrl, fetch: options.reading.fetch });
         this.sender = new DurableChatSender(this.connection, scope, options.onError);
         this.off.push(this.sender.subscribe(() => this.publishAll()), this.reading.subscribe(() => this.publishAll()));
@@ -40,6 +48,8 @@ export class ChatSession {
             }
         }));
         this.off.push(this.connection.watchConnection(state => {
+            this.connectionState = state;
+            this.publishGlobal();
             if (state === "connected") {
                 for (const thread of this.listeners.keys())
                     this.messages.invalidate(thread);
@@ -61,6 +71,7 @@ export class ChatSession {
     async getMessages(threadId, options = {}) {
         this.assertOpen();
         const page = await (options.before ? this.messages.earlier(threadId, options.before, options.limit) : this.messages.read(threadId, options.limit));
+        await this.sender.confirm(page.messages.map(message => message.id));
         if (!options.before)
             this.publish(threadId);
         return page;
@@ -79,6 +90,11 @@ export class ChatSession {
         return event === "played" ? this.reading.recordExplicit(threadId, ids) : this.reading.recordVisible(threadId, ids);
     }
     getSnapshot(threadId) {
+        if (threadId === undefined) {
+            if (!this.globalSnapshot)
+                this.globalSnapshot = this.buildGlobal();
+            return this.globalSnapshot;
+        }
         let snapshot = this.snapshots.get(threadId);
         if (!snapshot) {
             const messages = this.messages.getSnapshot(threadId);
@@ -88,25 +104,54 @@ export class ChatSession {
         }
         return snapshot;
     }
-    subscribe(threadId, listener) {
+    subscribe(target, listener) {
         this.assertOpen();
+        if (typeof target === "function") {
+            this.globalListeners.add(target);
+            return () => { this.globalListeners.delete(target); };
+        }
+        const threadId = target;
+        const notify = listener;
         let listeners = this.listeners.get(threadId);
         if (!listeners) {
             listeners = new Set();
             this.listeners.set(threadId, listeners);
         }
-        listeners.add(listener);
+        listeners.add(notify);
         const off = this.messages.subscribe(threadId, () => this.publish(threadId));
         return () => {
             off();
-            listeners.delete(listener);
+            listeners.delete(notify);
             if (!listeners.size)
                 this.listeners.delete(threadId);
         };
     }
-    publishAll() { for (const threadId of [...this.snapshots.keys()])
-        this.publish(threadId); }
-    publish(threadId) {
+    publishAll() {
+        for (const threadId of [...this.snapshots.keys()])
+            this.publish(threadId, false);
+        this.publishGlobal();
+    }
+    buildGlobal() {
+        const ids = new Set(this.snapshots.keys());
+        for (const thread of this.reading.getSnapshot()?.threads ?? [])
+            if (thread.teamId === this.options.messages.scope.teamId)
+                ids.add(thread.conversationId ?? thread.id);
+        for (const outgoing of this.sender.snapshot())
+            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 { threads, unreadMessageCount: threads.reduce((sum, t) => sum + t.unread.unreadMessageCount, 0), badgeCount: threads.reduce((sum, t) => sum + t.unread.badgeCount, 0), connection: this.connectionState };
+    }
+    publishGlobal() {
+        const next = this.buildGlobal();
+        if (JSON.stringify(next) === JSON.stringify(this.globalSnapshot))
+            return;
+        this.globalSnapshot = next;
+        this.globalListeners.forEach(listener => listener());
+    }
+    publish(threadId, notifyGlobal = true) {
         const previous = this.snapshots.get(threadId);
         this.snapshots.delete(threadId);
         const next = this.getSnapshot(threadId);
@@ -115,16 +160,21 @@ export class ChatSession {
             return;
         }
         this.listeners.get(threadId)?.forEach(listener => listener());
+        if (notifyGlobal)
+            this.publishGlobal();
     }
     close() {
         return this.closing ??= (async () => {
             this.closed = true;
             this.off.splice(0).forEach(off => off());
-            this.connection.close();
+            if (!this.options.sharedConnection)
+                this.connection.close();
             this.readers.close();
             await Promise.all([this.sender.close(), this.reading.close(), this.messages.close()]);
             this.listeners.clear();
+            this.globalListeners.clear();
             this.snapshots.clear();
+            this.globalSnapshot = undefined;
         })();
     }
 }

package/lib/runtime/createChat.d.ts

@@ -0,0 +1,24 @@
+import { ChatSession } from "./chatSession.js";
+import type { ChatReaderSocialMessage } from "./readerClient.js";
+import type { ChatClient, ChatClientOptions } from "./chatClient.js";
+export type CachedChatMessage = ChatReaderSocialMessage & {
+    id: string;
+    timestamp: number;
+};
+export type CreateChatOptions = {
+    appId: string;
+    accountId: string;
+    profileId: string;
+    teamId: string;
+    token: string;
+    endpoint?: string;
+    clientInstanceId?: string;
+    fetch?: typeof fetch;
+    /** Reuse an existing transport for call/presence integrations; its owner closes it. */
+    connection?: ChatClient;
+    onError: (error: unknown) => void;
+    onNotification?: ChatClientOptions["onNotification"];
+    onReach?: ChatClientOptions["onReach"];
+};
+/** Standard browser entry: storage, paging, realtime and reading share one identity. */
+export declare function createChat(options: CreateChatOptions): ChatSession<CachedChatMessage>;

package/lib/runtime/createChat.js

@@ -0,0 +1,39 @@
+import { ChatSession } from "./chatSession.js";
+import { SocialReadClient } from "./socialReadClient.js";
+import { chatTeamId } from "./teamScope.js";
+import { dmThreadId, groupThreadId, isValidChatTeamId } from "./thread.js";
+/** Standard browser entry: storage, paging, realtime and reading share one identity. */
+export function createChat(options) {
+    const { appId, accountId, profileId, teamId, token, onError } = options;
+    if (!isValidChatTeamId(teamId))
+        throw new Error("INVALID_CHAT_TEAM");
+    const endpoint = (options.endpoint ?? "https://hub.pmate.chat").replace(/\/+$/, "");
+    const http = endpoint.replace(/^ws/, "http"), ws = endpoint.replace(/^http/, "ws");
+    const reader = new SocialReadClient({ appId, profileId, token, hubHttpUrl: http, fetch: options.fetch });
+    const page = async (threadId, signal, cursor = {}) => {
+        const result = await reader.messagePage({ threadId, teamId, limit: 100, ...cursor }, signal);
+        return { ...result, messages: result.messages.map(message => ({ ...message, id: message.messageId, timestamp: message.serverCreatedAt })) };
+    };
+    return new ChatSession({
+        sharedConnection: options.connection,
+        messages: { scope: { appId, accountId, profileId, teamId }, transport: { load: (thread, signal) => page(thread, signal), changes: (thread, after, signal) => page(thread, signal, { after }), older: (thread, before, signal) => page(thread, signal, { before }) }, onError },
+        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 },
+        decode: message => decodeIncoming(message, { appId, profileId, teamId }), onError,
+    });
+}
+function decodeIncoming(message, scope) {
+    if (message.opcode !== 1 || !message.body || typeof message.body !== "object")
+        return;
+    const body = message.body;
+    if (body.kind !== "message" || body.content?.appId !== scope.appId || chatTeamId(body) !== scope.teamId)
+        return;
+    if (body.threadKind !== "dm" && body.threadKind !== "group")
+        return;
+    if (body.threadKind === "dm" && message.from !== scope.profileId && message.to !== scope.profileId)
+        return;
+    const threadId = body.threadKind === "dm" ? dmThreadId(scope.appId, message.from, message.to, scope.teamId) : groupThreadId(scope.appId, message.to, scope.teamId);
+    return { appId: scope.appId, teamId: scope.teamId, threadId, threadKind: body.threadKind, messageId: message.hash, id: message.hash,
+        timestamp: message.t, serverCreatedAt: message.t, clientCreatedAt: message.t, from: message.from, to: message.to, body: message.body, recipients: message.recipients };
+}

package/lib/runtime/durableSender.js

@@ -143,10 +143,13 @@ export class DurableChatSender {
     /** Confirm only after the authoritative message has been durably merged.
      * A tombstone prevents another tab's late failure from recreating the outbox. */
     async confirm(hashes) {
+        hashes = [...new Set(hashes)];
+        if (!hashes.length)
+            return;
         await this.ready;
         await this.db.transaction("rw", this.outbox, async () => {
             const previous = await this.outbox.bulkGet(hashes.map(hash => [this.scope, hash]));
-            const confirmed = previous.filter((record) => Boolean(record)).map(record => ({ ...record, status: "sent", confirmed: true }));
+            const confirmed = previous.filter((record) => Boolean(record && !record.confirmed)).map(record => ({ ...record, status: "sent", confirmed: true }));
             if (confirmed.length)
                 await this.outbox.bulkPut(confirmed);
         });

package/lib/runtime/index.d.ts

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

package/lib/runtime/index.js

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

package/lib/runtime/messageClient.d.ts

@@ -25,6 +25,9 @@ export type MessageClientOptions<T extends StoredMessage> = {
     batchSize?: number;
     writeWindowMs?: number;
     syncWindowMs?: number;
+    transactionBytes?: number;
+    queueBytes?: number;
+    freshnessMs?: number;
 };
 /** Local-first message facade; hosts never select a cache or network source. */
 export declare class MessageClient<T extends StoredMessage> {
@@ -44,6 +47,10 @@ export declare class MessageClient<T extends StoredMessage> {
     private closing;
     private revoked;
     private batchSize;
+    private transactionBytes;
+    private queueBytes;
+    private pendingBytes;
+    private pendingRecords;
     constructor(options: MessageClientOptions<T>);
     getSnapshot(thread: string): MessageSnapshot<T> | undefined;
     subscribe(thread: string, listener: () => void): () => void;
@@ -54,6 +61,8 @@ export declare class MessageClient<T extends StoredMessage> {
     /** Events are visible only after their atomic batch commits. */
     receive(thread: string, messages: T[]): Promise<void>;
     private persist;
+    private messageBytes;
+    private release;
     private flushWrites;
     private runWrites;
     synchronize(thread: string): Promise<void>;

package/lib/runtime/messageClient.js

@@ -18,10 +18,18 @@ export class MessageClient {
     closing = false;
     revoked = new Set();
     batchSize;
+    transactionBytes;
+    queueBytes;
+    pendingBytes = 0;
+    pendingRecords = 0;
     constructor(options) {
         this.options = options;
         this.storage = options.storage ?? new IndexedDbMessageStore(options.scope, options.merge ?? mergeStoredMessage);
         this.batchSize = options.batchSize ?? 128;
+        this.transactionBytes = options.transactionBytes ?? 1_048_576;
+        this.queueBytes = options.queueBytes ?? 8_388_608;
+        if (!Number.isSafeInteger(this.transactionBytes) || this.transactionBytes < 1 || !Number.isSafeInteger(this.queueBytes) || this.queueBytes < this.transactionBytes)
+            throw new Error("INVALID_MESSAGE_BYTE_LIMIT");
         if (!Number.isSafeInteger(this.batchSize) || this.batchSize < 1 || this.batchSize > 1000)
             throw new Error("INVALID_MESSAGE_BATCH_SIZE");
         this.writeTasks = new WindowedTasks(options.writeWindowMs ?? 16, (error, thread) => options.onError?.(error, thread));
@@ -36,7 +44,7 @@ export class MessageClient {
     subscribe(thread, listener) {
         let watch = this.watches.get(thread);
         if (!watch) {
-            watch = { limit: 100, snapshot: { messages: [], hasEarlier: false }, listeners: new Set() };
+            watch = { snapshot: { messages: [], hasEarlier: false }, listeners: new Set() };
             this.watches.set(thread, watch);
         }
         watch.listeners.add(listener);
@@ -56,8 +64,12 @@ export class MessageClient {
                 await this.synchronize(thread);
             if (this.closed)
                 throw new Error("MESSAGE_CLIENT_CLOSED");
-            await this.fillWindow(thread, limit);
-            return this.reload(thread, limit);
+            const result = await this.fillWindow(thread, limit);
+            const snapshot = await this.reload(thread);
+            if (local.coverage?.complete && Date.now() - (local.coverage.syncedAt ?? 0) > (this.options.freshnessMs ?? 30_000)
+                && (typeof navigator === "undefined" || navigator.onLine !== false))
+                this.invalidate(thread);
+            return limit === 100 ? snapshot : result;
         })().finally(() => { if (this.reads.get(key) === task)
             this.reads.delete(key); });
         this.reads.set(key, task);
@@ -68,7 +80,8 @@ export class MessageClient {
         if (!this.closed && !this.closing && !this.revoked.has(thread))
             this.syncTasks.schedule(thread, () => this.synchronize(thread));
     }
-    async reload(thread, limit = this.watches.get(thread)?.limit ?? 100) {
+    async reload(thread) {
+        const limit = 100;
         const page = await this.storage.read(thread, limit);
         if (this.closed)
             throw new Error("MESSAGE_CLIENT_CLOSED");
@@ -83,10 +96,9 @@ export class MessageClient {
             return old;
         const snapshot = { messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore) };
         if (!watch) {
-            watch = { limit, snapshot, listeners: new Set() };
+            watch = { snapshot, listeners: new Set() };
             this.watches.set(thread, watch);
         }
-        watch.limit = limit;
         watch.snapshot = snapshot;
         watch.listeners.forEach(listener => listener());
         return snapshot;
@@ -96,32 +108,73 @@ export class MessageClient {
         if (this.closed || this.closing || this.revoked.has(thread))
             return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
         const queue = this.writes.get(thread) ?? [];
-        if (messages.length > 1000 || queue.reduce((count, write) => count + write.messages.length, messages.length) > 4096)
+        if (messages.length > 1000 || this.pendingRecords + messages.length > 4096)
             return Promise.reject(new Error("MESSAGE_STORAGE_BACKPRESSURE"));
-        const promise = new Promise((resolve, reject) => queue.push({ messages, resolve, reject }));
+        let bytes = 0;
+        try {
+            for (const message of messages) {
+                bytes += this.messageBytes(message);
+                if (this.pendingBytes + bytes > this.queueBytes)
+                    throw new Error("MESSAGE_STORAGE_BACKPRESSURE");
+            }
+            messages = structuredClone(messages);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        this.pendingBytes += bytes;
+        this.pendingRecords += messages.length;
+        const promise = new Promise((resolve, reject) => queue.push({ messages, bytes, resolve, reject }));
         this.writes.set(thread, queue);
         this.writeTasks.schedule(thread, () => this.flushWrites(thread));
         return promise;
     }
-    async persist(thread, messages, checkpoint, complete, nextBefore) {
+    async persist(thread, messages, checkpoint, complete, nextBefore, syncedAt) {
         let changed = 0;
+        let navigationChanged = false;
         // Coverage advances only after all bounded batches have durably committed.
-        for (let offset = 0; offset < messages.length; offset += this.batchSize) {
+        let batch = [], bytes = 0;
+        const commit = async () => {
+            if (!batch.length)
+                return;
             if (this.closed || this.revoked.has(thread))
                 throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
-            changed += await this.storage.commit(thread, messages.slice(offset, offset + this.batchSize));
+            changed += await this.storage.commit(thread, batch);
+            batch = [];
+            bytes = 0;
+        };
+        for (const message of messages) {
+            const size = this.messageBytes(message);
+            if (batch.length >= this.batchSize || bytes + size > this.transactionBytes)
+                await commit();
+            batch.push(message);
+            bytes += size;
         }
+        await commit();
         if (complete !== undefined || checkpoint !== undefined) {
             const old = (await this.storage.read(thread, 1)).coverage;
             if (this.closed || this.revoked.has(thread))
                 throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
-            await this.storage.commit(thread, [], { complete: complete ?? old?.complete ?? false, checkpoint: checkpoint ?? old?.checkpoint, nextBefore: nextBefore === undefined ? old?.nextBefore : nextBefore });
+            navigationChanged = nextBefore !== undefined && nextBefore !== old?.nextBefore;
+            await this.storage.commit(thread, [], { syncedAt: syncedAt ?? old?.syncedAt, complete: complete ?? old?.complete ?? false, checkpoint: checkpoint ?? old?.checkpoint, nextBefore: nextBefore === undefined ? old?.nextBefore : nextBefore });
         }
-        if (changed) {
+        if (changed || navigationChanged) {
             await this.reload(thread);
             this.channel?.postMessage(thread);
         }
     }
+    messageBytes(message) {
+        const bytes = new TextEncoder().encode(JSON.stringify(message)).byteLength;
+        if (bytes > this.transactionBytes)
+            throw new Error("MESSAGE_RECORD_TOO_LARGE");
+        return bytes;
+    }
+    release(queue) {
+        for (const write of queue) {
+            this.pendingBytes -= write.bytes;
+            this.pendingRecords -= write.messages.length;
+        }
+    }
     flushWrites(thread) {
         const task = this.runWrites(thread).finally(() => this.activeWrites.delete(task));
         this.activeWrites.add(task);
@@ -140,6 +193,9 @@ export class MessageClient {
             queue.forEach(write => write.reject(error));
             throw error;
         }
+        finally {
+            this.release(queue);
+        }
     }
     synchronize(thread) {
         if (this.closed || this.closing || this.revoked.has(thread))
@@ -165,7 +221,7 @@ export class MessageClient {
                     throw new Error("MESSAGE_ACCESS_REVOKED");
                 if (page.resetRequired)
                     throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
-                await this.persist(thread, page.messages, page.checkpoint, true, after ? undefined : page.nextBefore);
+                await this.persist(thread, page.messages, page.checkpoint, true, after ? undefined : page.nextBefore, Date.now());
                 if (!page.hasMoreChanges)
                     break;
                 if (!page.checkpoint || page.checkpoint === after || !this.options.transport.changes)
@@ -220,7 +276,10 @@ export class MessageClient {
         this.revoked.add(thread);
         const queue = this.writes.get(thread);
         this.writes.delete(thread);
-        queue?.forEach(write => write.reject(new Error("MESSAGE_ACCESS_REVOKED")));
+        if (queue) {
+            queue.forEach(write => write.reject(new Error("MESSAGE_ACCESS_REVOKED")));
+            this.release(queue);
+        }
         await this.storage.removeThread(thread);
         await this.reload(thread);
         this.channel?.postMessage(thread);

package/lib/runtime/messageStore.d.ts

@@ -15,6 +15,7 @@ export type MessageCoverage = {
     checkpoint?: string;
     complete: boolean;
     nextBefore?: string | null;
+    syncedAt?: number;
 };
 type CoverageRow = MessageCoverage & {
     scope: string;

package/lib/runtime/readIndex.d.ts

@@ -84,11 +84,13 @@ export interface ReadIndexPersistence {
 }
 /** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export declare class IndexedDbReadIndex implements ReadIndexPersistence {
+    private storageScope?;
     private database;
     private profiles;
     private closed;
-    constructor(factory?: IDBFactory, name?: string);
+    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined);
     private transaction;
+    private key;
     load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
     update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
     close(): Promise<void>;

package/lib/runtime/readIndex.js

@@ -166,10 +166,12 @@ export function unreadInThread(state, threadId) {
 }
 /** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export class IndexedDbReadIndex {
+    storageScope;
     database;
     profiles;
     closed = false;
-    constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index") {
+    constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index", storageScope) {
+        this.storageScope = storageScope;
         if (!factory)
             throw new Error("READ_STORAGE_UNAVAILABLE");
         this.database = new Dexie(name, { indexedDB: factory, IDBKeyRange: globalThis.IDBKeyRange });
@@ -202,17 +204,18 @@ export class IndexedDbReadIndex {
         }
         throw new Error("READ_STORAGE_UNAVAILABLE");
     }
+    key(appId, profileId) { return this.storageScope === undefined ? [appId, profileId] : [appId, profileId, this.storageScope]; }
     async load(appId, profileId) {
-        return this.transaction("r", () => this.profiles.get([appId, profileId]));
+        return this.transaction("r", () => this.profiles.get(this.key(appId, profileId)));
     }
     async update(appId, profileId, transform) {
         return this.transaction("rw", async () => {
-            const previous = await this.profiles.get([appId, profileId]);
+            const previous = await this.profiles.get(this.key(appId, profileId));
             const next = transform(previous ?? createReadIndex(appId, profileId));
             if (next.appId !== appId || next.profileId !== profileId || next.schemaVersion !== 1)
                 throw new Error("READ_IDENTITY_MISMATCH");
             if (JSON.stringify(next) !== JSON.stringify(previous))
-                await this.profiles.put(next, [appId, profileId]);
+                await this.profiles.put(next, this.key(appId, profileId));
             return next;
         });
     }

package/lib/runtime/readingClient.d.ts

@@ -5,6 +5,7 @@ export type ReadingClientOptions = {
     sessionToken: string;
     hubHttpUrl: string;
     persistence?: ReadIndexPersistence;
+    storageScope?: string;
     fetch?: typeof fetch;
     onError?: (error: unknown) => void;
     onRecovered?: () => void;

package/lib/runtime/readingClient.js

@@ -19,7 +19,7 @@ export class ReadingClient {
     generation = 0;
     constructor(options) {
         this.options = options;
-        const storage = options.persistence ?? (this.storage = new IndexedDbReadIndex());
+        const storage = options.persistence ?? (this.storage = new IndexedDbReadIndex(globalThis.indexedDB, "pmate-social-read-index", options.storageScope));
         this.persistence = new BatchedReadIndex(storage);
         this.tasks = new WindowedTasks(1000, error => this.failed(error));
         this.sync = new ReadSyncClient({ ...options, persistence: this.persistence, onChange: state => this.publish(state) });

package/package.json

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