@pmate/chat-sdk 0.12.0-next.1 → 0.12.0-next.3

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);
@@ -79,6 +89,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 +103,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 +159,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/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,8 @@ export type MessageClientOptions<T extends StoredMessage> = {
     batchSize?: number;
     writeWindowMs?: number;
     syncWindowMs?: number;
+    transactionBytes?: number;
+    queueBytes?: number;
 };
 /** Local-first message facade; hosts never select a cache or network source. */
 export declare class MessageClient<T extends StoredMessage> {
@@ -33,6 +35,7 @@ export declare class MessageClient<T extends StoredMessage> {
     private watches;
     private reads;
     private syncing;
+    private paging;
     private writes;
     private activeWrites;
     private writeTasks;
@@ -43,6 +46,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;
@@ -53,6 +60,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>;
@@ -63,6 +72,7 @@ export declare class MessageClient<T extends StoredMessage> {
         messages: T[];
         hasEarlier: boolean;
     }>;
+    private fillWindow;
     revoke(thread: string): Promise<void>;
     close(): Promise<void>;
 }

package/lib/runtime/messageClient.js

@@ -7,6 +7,7 @@ export class MessageClient {
     watches = new Map();
     reads = new Map();
     syncing = new Map();
+    paging = new Map();
     writes = new Map();
     activeWrites = new Set();
     writeTasks;
@@ -17,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));
@@ -35,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);
@@ -55,7 +64,9 @@ export class MessageClient {
                 await this.synchronize(thread);
             if (this.closed)
                 throw new Error("MESSAGE_CLIENT_CLOSED");
-            return this.reload(thread, limit);
+            const result = await this.fillWindow(thread, limit);
+            const snapshot = await this.reload(thread);
+            return limit === 100 ? snapshot : result;
         })().finally(() => { if (this.reads.get(key) === task)
             this.reads.delete(key); });
         this.reads.set(key, task);
@@ -66,7 +77,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");
@@ -81,10 +93,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;
@@ -94,9 +105,20 @@ 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)
+        let bytes = 0;
+        try {
+            for (const message of messages)
+                bytes += this.messageBytes(message);
+            messages = structuredClone(messages);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        if (messages.length > 1000 || this.pendingRecords + messages.length > 4096 || this.pendingBytes + bytes > this.queueBytes)
             return Promise.reject(new Error("MESSAGE_STORAGE_BACKPRESSURE"));
-        const promise = new Promise((resolve, reject) => queue.push({ messages, resolve, reject }));
+        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;
@@ -104,11 +126,24 @@ export class MessageClient {
     async persist(thread, messages, checkpoint, complete, nextBefore) {
         let changed = 0;
         // 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))
@@ -120,6 +155,18 @@ export class MessageClient {
             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);
@@ -138,6 +185,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))
@@ -183,19 +233,33 @@ export class MessageClient {
             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);
+    }
+    async fillWindow(thread, limit, before) {
         let page = await this.storage.read(thread, limit, before);
         while (page.messages.length < limit && page.coverage?.nextBefore && this.options.transport.older) {
-            const token = page.coverage.nextBefore;
-            const remote = await this.options.transport.older(thread, token, this.abort.signal);
-            if (this.closed || this.revoked.has(thread))
-                throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
-            if (remote.resetRequired) {
-                await this.storage.removeThread(thread);
-                throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
+            const pending = this.paging.get(thread);
+            if (pending) {
+                await pending;
+                page = await this.storage.read(thread, limit, before);
+                continue;
             }
-            if (remote.nextBefore === token)
-                throw new Error("MESSAGE_SYNC_NO_PROGRESS");
-            await this.persist(thread, remote.messages, undefined, true, remote.nextBefore ?? null);
+            const token = page.coverage.nextBefore;
+            const task = (async () => {
+                const remote = await this.options.transport.older(thread, token, this.abort.signal);
+                if (this.closed || this.revoked.has(thread))
+                    throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
+                if (remote.resetRequired) {
+                    await this.storage.removeThread(thread);
+                    throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
+                }
+                if (remote.nextBefore === token)
+                    throw new Error("MESSAGE_SYNC_NO_PROGRESS");
+                await this.persist(thread, remote.messages, undefined, true, remote.nextBefore ?? null);
+            })().finally(() => { if (this.paging.get(thread) === task)
+                this.paging.delete(thread); });
+            this.paging.set(thread, task);
+            await task;
             page = await this.storage.read(thread, limit, before);
         }
         return { messages: page.messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore) };
@@ -204,7 +268,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/messageReaders.js

@@ -39,21 +39,33 @@ export class MessageReadersClient {
     }
     async request(input) {
         const { token, fetch: fetcher, hubHttpUrl, appId, profileId } = this.options;
-        const response = await (fetcher ?? fetch)(`${hubHttpUrl.replace(/^ws/, "http").replace(/\/+$/, "")}/api/social/reading/readers`, {
-            method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, body: JSON.stringify({ ...input, appId, profileId }),
-            signal: AbortSignal.any([this.lifetime.signal, AbortSignal.timeout(8000)]), redirect: "error", cache: "no-store",
-        });
-        if (!response.ok)
-            throw new MessageReadersError(response.status, `MESSAGE_READERS_HTTP_${response.status}`);
-        const envelope = await response.json(), data = envelope.data;
-        if (envelope.success !== true || data?.appId !== appId || data.threadId !== input.threadId || data.messageId !== input.messageId
-            || !Number.isSafeInteger(data.revision) || data.revision < 0 || !Number.isSafeInteger(data.total) || data.total < 0
-            || !Array.isArray(data.profileIds) || data.profileIds.length > input.limit || data.profileIds.length > data.total
-            || data.profileIds.some((id, i, ids) => typeof id !== "string" || !id || id.length > 512 || id === profileId || (i > 0 && id <= ids[i - 1]) || (input.afterProfileId && !data.resetRequired && id <= input.afterProfileId))
-            || typeof data.resetRequired !== "boolean" || (data.nextAfter !== null && (typeof data.nextAfter !== "string" || data.nextAfter !== data.profileIds.at(-1)))
-            || (!data.resetRequired && input.revision !== undefined && data.revision !== input.revision))
-            throw new Error("INVALID_MESSAGE_READERS_RESPONSE");
-        return data;
+        const controller = new AbortController();
+        const cancel = () => controller.abort(this.lifetime.signal.reason);
+        this.lifetime.signal.addEventListener("abort", cancel, { once: true });
+        const timeout = setTimeout(() => controller.abort(), 8000);
+        try {
+            const response = await (fetcher ?? fetch)(`${hubHttpUrl.replace(/^ws/, "http").replace(/\/+$/, "")}/api/social/reading/readers`, {
+                method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, body: JSON.stringify({ ...input, appId, profileId }),
+                signal: controller.signal, redirect: "error", cache: "no-store",
+            });
+            if (!response.ok)
+                throw new MessageReadersError(response.status, `MESSAGE_READERS_HTTP_${response.status}`);
+            const envelope = await response.json(), data = envelope.data;
+            if (envelope.success !== true || data?.appId !== appId || data.threadId !== input.threadId || data.messageId !== input.messageId
+                || !Number.isSafeInteger(data.revision) || data.revision < 0 || !Number.isSafeInteger(data.total) || data.total < 0
+                || !Array.isArray(data.profileIds) || data.profileIds.length > input.limit || data.profileIds.length > data.total
+                || data.profileIds.some((id, i, ids) => typeof id !== "string" || !id || id.length > 512 || id === profileId || (i > 0 && id <= ids[i - 1]) || (input.afterProfileId && !data.resetRequired && id <= input.afterProfileId))
+                || typeof data.resetRequired !== "boolean" || (data.nextAfter !== null && (typeof data.nextAfter !== "string" || data.nextAfter !== data.profileIds.at(-1)))
+                || (!data.resetRequired && input.revision !== undefined && data.revision !== input.revision))
+                throw new Error("INVALID_MESSAGE_READERS_RESPONSE");
+            if (this.lifetime.signal.aborted)
+                throw new Error("MESSAGE_READERS_CLOSED");
+            return data;
+        }
+        finally {
+            clearTimeout(timeout);
+            this.lifetime.signal.removeEventListener("abort", cancel);
+        }
     }
     close() { this.lifetime.abort(); this.pending.clear(); }
 }

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.1",
+  "version": "0.12.0-next.3",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",